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>
21 * ci_device_show: prints information about device capabilities and status
23 static int ci_device_show(struct seq_file
*s
, void *data
)
25 struct ci_hdrc
*ci
= s
->private;
26 struct usb_gadget
*gadget
= &ci
->gadget
;
28 seq_printf(s
, "speed = %d\n", gadget
->speed
);
29 seq_printf(s
, "max_speed = %d\n", gadget
->max_speed
);
30 seq_printf(s
, "is_otg = %d\n", gadget
->is_otg
);
31 seq_printf(s
, "is_a_peripheral = %d\n", gadget
->is_a_peripheral
);
32 seq_printf(s
, "b_hnp_enable = %d\n", gadget
->b_hnp_enable
);
33 seq_printf(s
, "a_hnp_support = %d\n", gadget
->a_hnp_support
);
34 seq_printf(s
, "a_alt_hnp_support = %d\n", gadget
->a_alt_hnp_support
);
35 seq_printf(s
, "name = %s\n",
36 (gadget
->name
? gadget
->name
: ""));
41 seq_printf(s
, "gadget function = %s\n",
42 (ci
->driver
->function
? ci
->driver
->function
: ""));
43 seq_printf(s
, "gadget max speed = %d\n", ci
->driver
->max_speed
);
48 static int ci_device_open(struct inode
*inode
, struct file
*file
)
50 return single_open(file
, ci_device_show
, inode
->i_private
);
53 static const struct file_operations ci_device_fops
= {
54 .open
= ci_device_open
,
57 .release
= single_release
,
61 * ci_port_test_show: reads port test mode
63 static int ci_port_test_show(struct seq_file
*s
, void *data
)
65 struct ci_hdrc
*ci
= s
->private;
69 pm_runtime_get_sync(ci
->dev
);
70 spin_lock_irqsave(&ci
->lock
, flags
);
71 mode
= hw_port_test_get(ci
);
72 spin_unlock_irqrestore(&ci
->lock
, flags
);
73 pm_runtime_put_sync(ci
->dev
);
75 seq_printf(s
, "mode = %u\n", mode
);
81 * ci_port_test_write: writes port test mode
83 static ssize_t
ci_port_test_write(struct file
*file
, const char __user
*ubuf
,
84 size_t count
, loff_t
*ppos
)
86 struct seq_file
*s
= file
->private_data
;
87 struct ci_hdrc
*ci
= s
->private;
93 count
= min_t(size_t, sizeof(buf
) - 1, count
);
94 if (copy_from_user(buf
, ubuf
, count
))
97 /* sscanf requires a zero terminated string */
100 if (sscanf(buf
, "%u", &mode
) != 1)
106 pm_runtime_get_sync(ci
->dev
);
107 spin_lock_irqsave(&ci
->lock
, flags
);
108 ret
= hw_port_test_set(ci
, mode
);
109 spin_unlock_irqrestore(&ci
->lock
, flags
);
110 pm_runtime_put_sync(ci
->dev
);
112 return ret
? ret
: count
;
115 static int ci_port_test_open(struct inode
*inode
, struct file
*file
)
117 return single_open(file
, ci_port_test_show
, inode
->i_private
);
120 static const struct file_operations ci_port_test_fops
= {
121 .open
= ci_port_test_open
,
122 .write
= ci_port_test_write
,
125 .release
= single_release
,
129 * ci_qheads_show: DMA contents of all queue heads
131 static int ci_qheads_show(struct seq_file
*s
, void *data
)
133 struct ci_hdrc
*ci
= s
->private;
137 if (ci
->role
!= CI_ROLE_GADGET
) {
138 seq_printf(s
, "not in gadget mode\n");
142 spin_lock_irqsave(&ci
->lock
, flags
);
143 for (i
= 0; i
< ci
->hw_ep_max
/2; i
++) {
144 struct ci_hw_ep
*hweprx
= &ci
->ci_hw_ep
[i
];
145 struct ci_hw_ep
*hweptx
=
146 &ci
->ci_hw_ep
[i
+ ci
->hw_ep_max
/2];
147 seq_printf(s
, "EP=%02i: RX=%08X TX=%08X\n",
148 i
, (u32
)hweprx
->qh
.dma
, (u32
)hweptx
->qh
.dma
);
149 for (j
= 0; j
< (sizeof(struct ci_hw_qh
)/sizeof(u32
)); j
++)
150 seq_printf(s
, " %04X: %08X %08X\n", j
,
151 *((u32
*)hweprx
->qh
.ptr
+ j
),
152 *((u32
*)hweptx
->qh
.ptr
+ j
));
154 spin_unlock_irqrestore(&ci
->lock
, flags
);
159 static int ci_qheads_open(struct inode
*inode
, struct file
*file
)
161 return single_open(file
, ci_qheads_show
, inode
->i_private
);
164 static const struct file_operations ci_qheads_fops
= {
165 .open
= ci_qheads_open
,
168 .release
= single_release
,
172 * ci_requests_show: DMA contents of all requests currently queued (all endpts)
174 static int ci_requests_show(struct seq_file
*s
, void *data
)
176 struct ci_hdrc
*ci
= s
->private;
178 struct list_head
*ptr
= NULL
;
179 struct ci_hw_req
*req
= NULL
;
180 struct td_node
*node
, *tmpnode
;
181 unsigned i
, j
, qsize
= sizeof(struct ci_hw_td
)/sizeof(u32
);
183 if (ci
->role
!= CI_ROLE_GADGET
) {
184 seq_printf(s
, "not in gadget mode\n");
188 spin_lock_irqsave(&ci
->lock
, flags
);
189 for (i
= 0; i
< ci
->hw_ep_max
; i
++)
190 list_for_each(ptr
, &ci
->ci_hw_ep
[i
].qh
.queue
) {
191 req
= list_entry(ptr
, struct ci_hw_req
, queue
);
193 list_for_each_entry_safe(node
, tmpnode
, &req
->tds
, td
) {
194 seq_printf(s
, "EP=%02i: TD=%08X %s\n",
195 i
% (ci
->hw_ep_max
/ 2),
197 ((i
< ci
->hw_ep_max
/2) ?
200 for (j
= 0; j
< qsize
; j
++)
201 seq_printf(s
, " %04X: %08X\n", j
,
202 *((u32
*)node
->ptr
+ j
));
205 spin_unlock_irqrestore(&ci
->lock
, flags
);
210 static int ci_requests_open(struct inode
*inode
, struct file
*file
)
212 return single_open(file
, ci_requests_show
, inode
->i_private
);
215 static const struct file_operations ci_requests_fops
= {
216 .open
= ci_requests_open
,
219 .release
= single_release
,
222 static int ci_otg_show(struct seq_file
*s
, void *unused
)
224 struct ci_hdrc
*ci
= s
->private;
227 if (!ci
|| !ci_otg_is_fsm_mode(ci
))
232 /* ------ State ----- */
233 seq_printf(s
, "OTG state: %s\n\n",
234 usb_otg_state_string(ci
->otg
.state
));
236 /* ------ State Machine Variables ----- */
237 seq_printf(s
, "a_bus_drop: %d\n", fsm
->a_bus_drop
);
239 seq_printf(s
, "a_bus_req: %d\n", fsm
->a_bus_req
);
241 seq_printf(s
, "a_srp_det: %d\n", fsm
->a_srp_det
);
243 seq_printf(s
, "a_vbus_vld: %d\n", fsm
->a_vbus_vld
);
245 seq_printf(s
, "b_conn: %d\n", fsm
->b_conn
);
247 seq_printf(s
, "adp_change: %d\n", fsm
->adp_change
);
249 seq_printf(s
, "power_up: %d\n", fsm
->power_up
);
251 seq_printf(s
, "a_bus_resume: %d\n", fsm
->a_bus_resume
);
253 seq_printf(s
, "a_bus_suspend: %d\n", fsm
->a_bus_suspend
);
255 seq_printf(s
, "a_conn: %d\n", fsm
->a_conn
);
257 seq_printf(s
, "b_bus_req: %d\n", fsm
->b_bus_req
);
259 seq_printf(s
, "b_bus_suspend: %d\n", fsm
->b_bus_suspend
);
261 seq_printf(s
, "b_se0_srp: %d\n", fsm
->b_se0_srp
);
263 seq_printf(s
, "b_ssend_srp: %d\n", fsm
->b_ssend_srp
);
265 seq_printf(s
, "b_sess_vld: %d\n", fsm
->b_sess_vld
);
267 seq_printf(s
, "b_srp_done: %d\n", fsm
->b_srp_done
);
269 seq_printf(s
, "drv_vbus: %d\n", fsm
->drv_vbus
);
271 seq_printf(s
, "loc_conn: %d\n", fsm
->loc_conn
);
273 seq_printf(s
, "loc_sof: %d\n", fsm
->loc_sof
);
275 seq_printf(s
, "adp_prb: %d\n", fsm
->adp_prb
);
277 seq_printf(s
, "id: %d\n", fsm
->id
);
279 seq_printf(s
, "protocol: %d\n", fsm
->protocol
);
284 static int ci_otg_open(struct inode
*inode
, struct file
*file
)
286 return single_open(file
, ci_otg_show
, inode
->i_private
);
289 static const struct file_operations ci_otg_fops
= {
293 .release
= single_release
,
296 static int ci_role_show(struct seq_file
*s
, void *data
)
298 struct ci_hdrc
*ci
= s
->private;
300 seq_printf(s
, "%s\n", ci_role(ci
)->name
);
305 static ssize_t
ci_role_write(struct file
*file
, const char __user
*ubuf
,
306 size_t count
, loff_t
*ppos
)
308 struct seq_file
*s
= file
->private_data
;
309 struct ci_hdrc
*ci
= s
->private;
314 if (copy_from_user(buf
, ubuf
, min_t(size_t, sizeof(buf
) - 1, count
)))
317 for (role
= CI_ROLE_HOST
; role
< CI_ROLE_END
; role
++)
318 if (ci
->roles
[role
] &&
319 !strncmp(buf
, ci
->roles
[role
]->name
,
320 strlen(ci
->roles
[role
]->name
)))
323 if (role
== CI_ROLE_END
|| role
== ci
->role
)
326 pm_runtime_get_sync(ci
->dev
);
327 disable_irq(ci
->irq
);
329 ret
= ci_role_start(ci
, role
);
331 pm_runtime_put_sync(ci
->dev
);
333 return ret
? ret
: count
;
336 static int ci_role_open(struct inode
*inode
, struct file
*file
)
338 return single_open(file
, ci_role_show
, inode
->i_private
);
341 static const struct file_operations ci_role_fops
= {
342 .open
= ci_role_open
,
343 .write
= ci_role_write
,
346 .release
= single_release
,
349 static int ci_registers_show(struct seq_file
*s
, void *unused
)
351 struct ci_hdrc
*ci
= s
->private;
354 if (!ci
|| ci
->in_lpm
)
357 /* ------ Registers ----- */
358 tmp_reg
= hw_read_intr_enable(ci
);
359 seq_printf(s
, "USBINTR reg: %08x\n", tmp_reg
);
361 tmp_reg
= hw_read_intr_status(ci
);
362 seq_printf(s
, "USBSTS reg: %08x\n", tmp_reg
);
364 tmp_reg
= hw_read(ci
, OP_USBMODE
, ~0);
365 seq_printf(s
, "USBMODE reg: %08x\n", tmp_reg
);
367 tmp_reg
= hw_read(ci
, OP_USBCMD
, ~0);
368 seq_printf(s
, "USBCMD reg: %08x\n", tmp_reg
);
370 tmp_reg
= hw_read(ci
, OP_PORTSC
, ~0);
371 seq_printf(s
, "PORTSC reg: %08x\n", tmp_reg
);
374 tmp_reg
= hw_read_otgsc(ci
, ~0);
375 seq_printf(s
, "OTGSC reg: %08x\n", tmp_reg
);
381 static int ci_registers_open(struct inode
*inode
, struct file
*file
)
383 return single_open(file
, ci_registers_show
, inode
->i_private
);
386 static const struct file_operations ci_registers_fops
= {
387 .open
= ci_registers_open
,
390 .release
= single_release
,
394 * dbg_create_files: initializes the attribute interface
397 * This function returns an error code
399 int dbg_create_files(struct ci_hdrc
*ci
)
403 ci
->debugfs
= debugfs_create_dir(dev_name(ci
->dev
), NULL
);
407 dent
= debugfs_create_file("device", S_IRUGO
, ci
->debugfs
, ci
,
412 dent
= debugfs_create_file("port_test", S_IRUGO
| S_IWUSR
, ci
->debugfs
,
413 ci
, &ci_port_test_fops
);
417 dent
= debugfs_create_file("qheads", S_IRUGO
, ci
->debugfs
, ci
,
422 dent
= debugfs_create_file("requests", S_IRUGO
, ci
->debugfs
, ci
,
427 if (ci_otg_is_fsm_mode(ci
)) {
428 dent
= debugfs_create_file("otg", S_IRUGO
, ci
->debugfs
, ci
,
434 dent
= debugfs_create_file("role", S_IRUGO
| S_IWUSR
, ci
->debugfs
, ci
,
439 dent
= debugfs_create_file("registers", S_IRUGO
, ci
->debugfs
, ci
,
445 debugfs_remove_recursive(ci
->debugfs
);
450 * dbg_remove_files: destroys the attribute interface
453 void dbg_remove_files(struct ci_hdrc
*ci
)
455 debugfs_remove_recursive(ci
->debugfs
);