[go: nahoru, domu]
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
14#include "ci.h"
15#include "udc.h"
16#include "bits.h"
17#include "debug.h"
18#include "otg.h"
19
20/**
21 * ci_device_show: prints information about device capabilities and status
22 */
23static int ci_device_show(struct seq_file *s, void *data)
24{
25	struct ci_hdrc *ci = s->private;
26	struct usb_gadget *gadget = &ci->gadget;
27
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 : ""));
37
38	if (!ci->driver)
39		return 0;
40
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);
44
45	return 0;
46}
47
48static int ci_device_open(struct inode *inode, struct file *file)
49{
50	return single_open(file, ci_device_show, inode->i_private);
51}
52
53static const struct file_operations ci_device_fops = {
54	.open		= ci_device_open,
55	.read		= seq_read,
56	.llseek		= seq_lseek,
57	.release	= single_release,
58};
59
60/**
61 * ci_port_test_show: reads port test mode
62 */
63static int ci_port_test_show(struct seq_file *s, void *data)
64{
65	struct ci_hdrc *ci = s->private;
66	unsigned long flags;
67	unsigned mode;
68
69	spin_lock_irqsave(&ci->lock, flags);
70	mode = hw_port_test_get(ci);
71	spin_unlock_irqrestore(&ci->lock, flags);
72
73	seq_printf(s, "mode = %u\n", mode);
74
75	return 0;
76}
77
78/**
79 * ci_port_test_write: writes port test mode
80 */
81static ssize_t ci_port_test_write(struct file *file, const char __user *ubuf,
82				  size_t count, loff_t *ppos)
83{
84	struct seq_file *s = file->private_data;
85	struct ci_hdrc *ci = s->private;
86	unsigned long flags;
87	unsigned mode;
88	char buf[32];
89	int ret;
90
91	if (copy_from_user(buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
92		return -EFAULT;
93
94	if (sscanf(buf, "%u", &mode) != 1)
95		return -EINVAL;
96
97	spin_lock_irqsave(&ci->lock, flags);
98	ret = hw_port_test_set(ci, mode);
99	spin_unlock_irqrestore(&ci->lock, flags);
100
101	return ret ? ret : count;
102}
103
104static int ci_port_test_open(struct inode *inode, struct file *file)
105{
106	return single_open(file, ci_port_test_show, inode->i_private);
107}
108
109static const struct file_operations ci_port_test_fops = {
110	.open		= ci_port_test_open,
111	.write		= ci_port_test_write,
112	.read		= seq_read,
113	.llseek		= seq_lseek,
114	.release	= single_release,
115};
116
117/**
118 * ci_qheads_show: DMA contents of all queue heads
119 */
120static int ci_qheads_show(struct seq_file *s, void *data)
121{
122	struct ci_hdrc *ci = s->private;
123	unsigned long flags;
124	unsigned i, j;
125
126	if (ci->role != CI_ROLE_GADGET) {
127		seq_printf(s, "not in gadget mode\n");
128		return 0;
129	}
130
131	spin_lock_irqsave(&ci->lock, flags);
132	for (i = 0; i < ci->hw_ep_max/2; i++) {
133		struct ci_hw_ep *hweprx = &ci->ci_hw_ep[i];
134		struct ci_hw_ep *hweptx =
135			&ci->ci_hw_ep[i + ci->hw_ep_max/2];
136		seq_printf(s, "EP=%02i: RX=%08X TX=%08X\n",
137			   i, (u32)hweprx->qh.dma, (u32)hweptx->qh.dma);
138		for (j = 0; j < (sizeof(struct ci_hw_qh)/sizeof(u32)); j++)
139			seq_printf(s, " %04X:    %08X    %08X\n", j,
140				   *((u32 *)hweprx->qh.ptr + j),
141				   *((u32 *)hweptx->qh.ptr + j));
142	}
143	spin_unlock_irqrestore(&ci->lock, flags);
144
145	return 0;
146}
147
148static int ci_qheads_open(struct inode *inode, struct file *file)
149{
150	return single_open(file, ci_qheads_show, inode->i_private);
151}
152
153static const struct file_operations ci_qheads_fops = {
154	.open		= ci_qheads_open,
155	.read		= seq_read,
156	.llseek		= seq_lseek,
157	.release	= single_release,
158};
159
160/**
161 * ci_requests_show: DMA contents of all requests currently queued (all endpts)
162 */
163static int ci_requests_show(struct seq_file *s, void *data)
164{
165	struct ci_hdrc *ci = s->private;
166	unsigned long flags;
167	struct list_head   *ptr = NULL;
168	struct ci_hw_req *req = NULL;
169	struct td_node *node, *tmpnode;
170	unsigned i, j, qsize = sizeof(struct ci_hw_td)/sizeof(u32);
171
172	if (ci->role != CI_ROLE_GADGET) {
173		seq_printf(s, "not in gadget mode\n");
174		return 0;
175	}
176
177	spin_lock_irqsave(&ci->lock, flags);
178	for (i = 0; i < ci->hw_ep_max; i++)
179		list_for_each(ptr, &ci->ci_hw_ep[i].qh.queue) {
180			req = list_entry(ptr, struct ci_hw_req, queue);
181
182			list_for_each_entry_safe(node, tmpnode, &req->tds, td) {
183				seq_printf(s, "EP=%02i: TD=%08X %s\n",
184					   i % (ci->hw_ep_max / 2),
185					   (u32)node->dma,
186					   ((i < ci->hw_ep_max/2) ?
187					   "RX" : "TX"));
188
189				for (j = 0; j < qsize; j++)
190					seq_printf(s, " %04X:    %08X\n", j,
191						   *((u32 *)node->ptr + j));
192			}
193		}
194	spin_unlock_irqrestore(&ci->lock, flags);
195
196	return 0;
197}
198
199static int ci_requests_open(struct inode *inode, struct file *file)
200{
201	return single_open(file, ci_requests_show, inode->i_private);
202}
203
204static const struct file_operations ci_requests_fops = {
205	.open		= ci_requests_open,
206	.read		= seq_read,
207	.llseek		= seq_lseek,
208	.release	= single_release,
209};
210
211static int ci_otg_show(struct seq_file *s, void *unused)
212{
213	struct ci_hdrc *ci = s->private;
214	struct otg_fsm *fsm;
215
216	if (!ci || !ci_otg_is_fsm_mode(ci))
217		return 0;
218
219	fsm = &ci->fsm;
220
221	/* ------ State ----- */
222	seq_printf(s, "OTG state: %s\n\n",
223		usb_otg_state_string(ci->transceiver->state));
224
225	/* ------ State Machine Variables ----- */
226	seq_printf(s, "a_bus_drop: %d\n", fsm->a_bus_drop);
227
228	seq_printf(s, "a_bus_req: %d\n", fsm->a_bus_req);
229
230	seq_printf(s, "a_srp_det: %d\n", fsm->a_srp_det);
231
232	seq_printf(s, "a_vbus_vld: %d\n", fsm->a_vbus_vld);
233
234	seq_printf(s, "b_conn: %d\n", fsm->b_conn);
235
236	seq_printf(s, "adp_change: %d\n", fsm->adp_change);
237
238	seq_printf(s, "power_up: %d\n", fsm->power_up);
239
240	seq_printf(s, "a_bus_resume: %d\n", fsm->a_bus_resume);
241
242	seq_printf(s, "a_bus_suspend: %d\n", fsm->a_bus_suspend);
243
244	seq_printf(s, "a_conn: %d\n", fsm->a_conn);
245
246	seq_printf(s, "b_bus_req: %d\n", fsm->b_bus_req);
247
248	seq_printf(s, "b_bus_suspend: %d\n", fsm->b_bus_suspend);
249
250	seq_printf(s, "b_se0_srp: %d\n", fsm->b_se0_srp);
251
252	seq_printf(s, "b_ssend_srp: %d\n", fsm->b_ssend_srp);
253
254	seq_printf(s, "b_sess_vld: %d\n", fsm->b_sess_vld);
255
256	seq_printf(s, "b_srp_done: %d\n", fsm->b_srp_done);
257
258	seq_printf(s, "drv_vbus: %d\n", fsm->drv_vbus);
259
260	seq_printf(s, "loc_conn: %d\n", fsm->loc_conn);
261
262	seq_printf(s, "loc_sof: %d\n", fsm->loc_sof);
263
264	seq_printf(s, "adp_prb: %d\n", fsm->adp_prb);
265
266	seq_printf(s, "id: %d\n", fsm->id);
267
268	seq_printf(s, "protocol: %d\n", fsm->protocol);
269
270	return 0;
271}
272
273static int ci_otg_open(struct inode *inode, struct file *file)
274{
275	return single_open(file, ci_otg_show, inode->i_private);
276}
277
278static const struct file_operations ci_otg_fops = {
279	.open			= ci_otg_open,
280	.read			= seq_read,
281	.llseek			= seq_lseek,
282	.release		= single_release,
283};
284
285static int ci_role_show(struct seq_file *s, void *data)
286{
287	struct ci_hdrc *ci = s->private;
288
289	seq_printf(s, "%s\n", ci_role(ci)->name);
290
291	return 0;
292}
293
294static ssize_t ci_role_write(struct file *file, const char __user *ubuf,
295			     size_t count, loff_t *ppos)
296{
297	struct seq_file *s = file->private_data;
298	struct ci_hdrc *ci = s->private;
299	enum ci_role role;
300	char buf[8];
301	int ret;
302
303	if (copy_from_user(buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
304		return -EFAULT;
305
306	for (role = CI_ROLE_HOST; role < CI_ROLE_END; role++)
307		if (ci->roles[role] &&
308		    !strncmp(buf, ci->roles[role]->name,
309			     strlen(ci->roles[role]->name)))
310			break;
311
312	if (role == CI_ROLE_END || role == ci->role)
313		return -EINVAL;
314
315	ci_role_stop(ci);
316	ret = ci_role_start(ci, role);
317
318	return ret ? ret : count;
319}
320
321static int ci_role_open(struct inode *inode, struct file *file)
322{
323	return single_open(file, ci_role_show, inode->i_private);
324}
325
326static const struct file_operations ci_role_fops = {
327	.open		= ci_role_open,
328	.write		= ci_role_write,
329	.read		= seq_read,
330	.llseek		= seq_lseek,
331	.release	= single_release,
332};
333
334static int ci_registers_show(struct seq_file *s, void *unused)
335{
336	struct ci_hdrc *ci = s->private;
337	u32 tmp_reg;
338
339	if (!ci)
340		return 0;
341
342	/* ------ Registers ----- */
343	tmp_reg = hw_read_intr_enable(ci);
344	seq_printf(s, "USBINTR reg: %08x\n", tmp_reg);
345
346	tmp_reg = hw_read_intr_status(ci);
347	seq_printf(s, "USBSTS reg: %08x\n", tmp_reg);
348
349	tmp_reg = hw_read(ci, OP_USBMODE, ~0);
350	seq_printf(s, "USBMODE reg: %08x\n", tmp_reg);
351
352	tmp_reg = hw_read(ci, OP_USBCMD, ~0);
353	seq_printf(s, "USBCMD reg: %08x\n", tmp_reg);
354
355	tmp_reg = hw_read(ci, OP_PORTSC, ~0);
356	seq_printf(s, "PORTSC reg: %08x\n", tmp_reg);
357
358	if (ci->is_otg) {
359		tmp_reg = hw_read_otgsc(ci, ~0);
360		seq_printf(s, "OTGSC reg: %08x\n", tmp_reg);
361	}
362
363	return 0;
364}
365
366static int ci_registers_open(struct inode *inode, struct file *file)
367{
368	return single_open(file, ci_registers_show, inode->i_private);
369}
370
371static const struct file_operations ci_registers_fops = {
372	.open			= ci_registers_open,
373	.read			= seq_read,
374	.llseek			= seq_lseek,
375	.release		= single_release,
376};
377
378/**
379 * dbg_create_files: initializes the attribute interface
380 * @ci: device
381 *
382 * This function returns an error code
383 */
384int dbg_create_files(struct ci_hdrc *ci)
385{
386	struct dentry *dent;
387
388	ci->debugfs = debugfs_create_dir(dev_name(ci->dev), NULL);
389	if (!ci->debugfs)
390		return -ENOMEM;
391
392	dent = debugfs_create_file("device", S_IRUGO, ci->debugfs, ci,
393				   &ci_device_fops);
394	if (!dent)
395		goto err;
396
397	dent = debugfs_create_file("port_test", S_IRUGO | S_IWUSR, ci->debugfs,
398				   ci, &ci_port_test_fops);
399	if (!dent)
400		goto err;
401
402	dent = debugfs_create_file("qheads", S_IRUGO, ci->debugfs, ci,
403				   &ci_qheads_fops);
404	if (!dent)
405		goto err;
406
407	dent = debugfs_create_file("requests", S_IRUGO, ci->debugfs, ci,
408				   &ci_requests_fops);
409	if (!dent)
410		goto err;
411
412	if (ci_otg_is_fsm_mode(ci)) {
413		dent = debugfs_create_file("otg", S_IRUGO, ci->debugfs, ci,
414					&ci_otg_fops);
415		if (!dent)
416			goto err;
417	}
418
419	dent = debugfs_create_file("role", S_IRUGO | S_IWUSR, ci->debugfs, ci,
420				   &ci_role_fops);
421	if (!dent)
422		goto err;
423
424	dent = debugfs_create_file("registers", S_IRUGO, ci->debugfs, ci,
425				&ci_registers_fops);
426
427	if (dent)
428		return 0;
429err:
430	debugfs_remove_recursive(ci->debugfs);
431	return -ENOMEM;
432}
433
434/**
435 * dbg_remove_files: destroys the attribute interface
436 * @ci: device
437 */
438void dbg_remove_files(struct ci_hdrc *ci)
439{
440	debugfs_remove_recursive(ci->debugfs);
441}
442