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