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