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
  11 #include "ci.h"
  12 #include "udc.h"
  13 #include "bits.h"
  14 #include "debug.h"
  15
  16 /**
  17  * ci_device_show: prints information about device capabilities and status
  18  */
  19 static int ci_device_show(struct seq_file *s, void *data)
  20 {
  21         struct ci_hdrc *ci = s->private;
  22         struct usb_gadget *gadget = &ci->gadget;
  23
  24         seq_printf(s, "speed             = %d\n", gadget->speed);
  25         seq_printf(s, "max_speed         = %d\n", gadget->max_speed);
  26         seq_printf(s, "is_otg            = %d\n", gadget->is_otg);
  27         seq_printf(s, "is_a_peripheral   = %d\n", gadget->is_a_peripheral);
  28         seq_printf(s, "b_hnp_enable      = %d\n", gadget->b_hnp_enable);
  29         seq_printf(s, "a_hnp_support     = %d\n", gadget->a_hnp_support);
  30         seq_printf(s, "a_alt_hnp_support = %d\n", gadget->a_alt_hnp_support);
  31         seq_printf(s, "name              = %s\n",
  32                    (gadget->name ? gadget->name : ""));
  33
  34         if (!ci->driver)
  35                 return 0;
  36
  37         seq_printf(s, "gadget function   = %s\n",
  38                        (ci->driver->function ? ci->driver->function : ""));
  39         seq_printf(s, "gadget max speed  = %d\n", ci->driver->max_speed);
  40
  41         return 0;
  42 }
  43
  44 static int ci_device_open(struct inode *inode, struct file *file)
  45 {
  46         return single_open(file, ci_device_show, inode->i_private);
  47 }
  48
  49 static const struct file_operations ci_device_fops = {
  50         .open           = ci_device_open,
  51         .read           = seq_read,
  52         .llseek         = seq_lseek,
  53         .release        = single_release,
  54 };
  55
  56 /**
  57  * ci_port_test_show: reads port test mode
  58  */
  59 static int ci_port_test_show(struct seq_file *s, void *data)
  60 {
  61         struct ci_hdrc *ci = s->private;
  62         unsigned long flags;
  63         unsigned mode;
  64
  65         spin_lock_irqsave(&ci->lock, flags);
  66         mode = hw_port_test_get(ci);
  67         spin_unlock_irqrestore(&ci->lock, flags);
  68
  69         seq_printf(s, "mode = %u\n", mode);
  70
  71         return 0;
  72 }
  73
  74 /**
  75  * ci_port_test_write: writes port test mode
  76  */
  77 static ssize_t ci_port_test_write(struct file *file, const char __user *ubuf,
  78                                   size_t count, loff_t *ppos)
  79 {
  80         struct seq_file *s = file->private_data;
  81         struct ci_hdrc *ci = s->private;
  82         unsigned long flags;
  83         unsigned mode;
  84         char buf[32];
  85         int ret;
  86
  87         if (copy_from_user(buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
  88                 return -EFAULT;
  89
  90         if (sscanf(buf, "%u", &mode) != 1)
  91                 return -EINVAL;
  92
  93         spin_lock_irqsave(&ci->lock, flags);
  94         ret = hw_port_test_set(ci, mode);
  95         spin_unlock_irqrestore(&ci->lock, flags);
  96
  97         return ret ? ret : count;
  98 }
  99
 100 static int ci_port_test_open(struct inode *inode, struct file *file)
 101 {
 102         return single_open(file, ci_port_test_show, inode->i_private);
 103 }
 104
 105 static const struct file_operations ci_port_test_fops = {
 106         .open           = ci_port_test_open,
 107         .write          = ci_port_test_write,
 108         .read           = seq_read,
 109         .llseek         = seq_lseek,
 110         .release        = single_release,
 111 };
 112
 113 /**
 114  * ci_qheads_show: DMA contents of all queue heads
 115  */
 116 static int ci_qheads_show(struct seq_file *s, void *data)
 117 {
 118         struct ci_hdrc *ci = s->private;
 119         unsigned long flags;
 120         unsigned i, j;
 121
 122         if (ci->role != CI_ROLE_GADGET) {
 123                 seq_printf(s, "not in gadget mode\n");
 124                 return 0;
 125         }
 126
 127         spin_lock_irqsave(&ci->lock, flags);
 128         for (i = 0; i < ci->hw_ep_max/2; i++) {
 129                 struct ci_hw_ep *hweprx = &ci->ci_hw_ep[i];
 130                 struct ci_hw_ep *hweptx =
 131                         &ci->ci_hw_ep[i + ci->hw_ep_max/2];
 132                 seq_printf(s, "EP=%02i: RX=%08X TX=%08X\n",
 133                            i, (u32)hweprx->qh.dma, (u32)hweptx->qh.dma);
 134                 for (j = 0; j < (sizeof(struct ci_hw_qh)/sizeof(u32)); j++)
 135                         seq_printf(s, " %04X:    %08X    %08X\n", j,
 136                                    *((u32 *)hweprx->qh.ptr + j),
 137                                    *((u32 *)hweptx->qh.ptr + j));
 138         }
 139         spin_unlock_irqrestore(&ci->lock, flags);
 140
 141         return 0;
 142 }
 143
 144 static int ci_qheads_open(struct inode *inode, struct file *file)
 145 {
 146         return single_open(file, ci_qheads_show, inode->i_private);
 147 }
 148
 149 static const struct file_operations ci_qheads_fops = {
 150         .open           = ci_qheads_open,
 151         .read           = seq_read,
 152         .llseek         = seq_lseek,
 153         .release        = single_release,
 154 };
 155
 156 /**
 157  * ci_requests_show: DMA contents of all requests currently queued (all endpts)
 158  */
 159 static int ci_requests_show(struct seq_file *s, void *data)
 160 {
 161         struct ci_hdrc *ci = s->private;
 162         unsigned long flags;
 163         struct list_head   *ptr = NULL;
 164         struct ci_hw_req *req = NULL;
 165         struct td_node *node, *tmpnode;
 166         unsigned i, j, qsize = sizeof(struct ci_hw_td)/sizeof(u32);
 167
 168         if (ci->role != CI_ROLE_GADGET) {
 169                 seq_printf(s, "not in gadget mode\n");
 170                 return 0;
 171         }
 172
 173         spin_lock_irqsave(&ci->lock, flags);
 174         for (i = 0; i < ci->hw_ep_max; i++)
 175                 list_for_each(ptr, &ci->ci_hw_ep[i].qh.queue) {
 176                         req = list_entry(ptr, struct ci_hw_req, queue);
 177
 178                         list_for_each_entry_safe(node, tmpnode, &req->tds, td) {
 179                                 seq_printf(s, "EP=%02i: TD=%08X %s\n",
 180                                            i % (ci->hw_ep_max / 2),
 181                                            (u32)node->dma,
 182                                            ((i < ci->hw_ep_max/2) ?
 183                                            "RX" : "TX"));
 184
 185                                 for (j = 0; j < qsize; j++)
 186                                         seq_printf(s, " %04X:    %08X\n", j,
 187                                                    *((u32 *)node->ptr + j));
 188                         }
 189                 }
 190         spin_unlock_irqrestore(&ci->lock, flags);
 191
 192         return 0;
 193 }
 194
 195 static int ci_requests_open(struct inode *inode, struct file *file)
 196 {
 197         return single_open(file, ci_requests_show, inode->i_private);
 198 }
 199
 200 static const struct file_operations ci_requests_fops = {
 201         .open           = ci_requests_open,
 202         .read           = seq_read,
 203         .llseek         = seq_lseek,
 204         .release        = single_release,
 205 };
 206
 207 static int ci_role_show(struct seq_file *s, void *data)
 208 {
 209         struct ci_hdrc *ci = s->private;
 210
 211         seq_printf(s, "%s\n", ci_role(ci)->name);
 212
 213         return 0;
 214 }
 215
 216 static ssize_t ci_role_write(struct file *file, const char __user *ubuf,
 217                              size_t count, loff_t *ppos)
 218 {
 219         struct seq_file *s = file->private_data;
 220         struct ci_hdrc *ci = s->private;
 221         enum ci_role role;
 222         char buf[8];
 223         int ret;
 224
 225         if (copy_from_user(buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
 226                 return -EFAULT;
 227
 228         for (role = CI_ROLE_HOST; role < CI_ROLE_END; role++)
 229                 if (ci->roles[role] &&
 230                     !strncmp(buf, ci->roles[role]->name,
 231                              strlen(ci->roles[role]->name)))
 232                         break;
 233
 234         if (role == CI_ROLE_END || role == ci->role)
 235                 return -EINVAL;
 236
 237         ci_role_stop(ci);
 238         ret = ci_role_start(ci, role);
 239
 240         return ret ? ret : count;
 241 }
 242
 243 static int ci_role_open(struct inode *inode, struct file *file)
 244 {
 245         return single_open(file, ci_role_show, inode->i_private);
 246 }
 247
 248 static const struct file_operations ci_role_fops = {
 249         .open           = ci_role_open,
 250         .write          = ci_role_write,
 251         .read           = seq_read,
 252         .llseek         = seq_lseek,
 253         .release        = single_release,
 254 };
 255
 256 /**
 257  * dbg_create_files: initializes the attribute interface
 258  * @ci: device
 259  *
 260  * This function returns an error code
 261  */
 262 int dbg_create_files(struct ci_hdrc *ci)
 263 {
 264         struct dentry *dent;
 265
 266         ci->debugfs = debugfs_create_dir(dev_name(ci->dev), NULL);
 267         if (!ci->debugfs)
 268                 return -ENOMEM;
 269
 270         dent = debugfs_create_file("device", S_IRUGO, ci->debugfs, ci,
 271                                    &ci_device_fops);
 272         if (!dent)
 273                 goto err;
 274
 275         dent = debugfs_create_file("port_test", S_IRUGO | S_IWUSR, ci->debugfs,
 276                                    ci, &ci_port_test_fops);
 277         if (!dent)
 278                 goto err;
 279
 280         dent = debugfs_create_file("qheads", S_IRUGO, ci->debugfs, ci,
 281                                    &ci_qheads_fops);
 282         if (!dent)
 283                 goto err;
 284
 285         dent = debugfs_create_file("requests", S_IRUGO, ci->debugfs, ci,
 286                                    &ci_requests_fops);
 287         if (!dent)
 288                 goto err;
 289
 290         dent = debugfs_create_file("role", S_IRUGO | S_IWUSR, ci->debugfs, ci,
 291                                    &ci_role_fops);
 292         if (dent)
 293                 return 0;
 294 err:
 295         debugfs_remove_recursive(ci->debugfs);
 296         return -ENOMEM;
 297 }
 298
 299 /**
 300  * dbg_remove_files: destroys the attribute interface
 301  * @ci: device
 302  */
 303 void dbg_remove_files(struct ci_hdrc *ci)
 304 {
 305         debugfs_remove_recursive(ci->debugfs);
 306 }