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 ci13xxx *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 ci13xxx *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 ci13xxx *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 ci13xxx *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 ci13xxx_ep *mEpRx = &ci->ci13xxx_ep[i];
 130                 struct ci13xxx_ep *mEpTx =
 131                         &ci->ci13xxx_ep[i + ci->hw_ep_max/2];
 132                 seq_printf(s, "EP=%02i: RX=%08X TX=%08X\n",
 133                            i, (u32)mEpRx->qh.dma, (u32)mEpTx->qh.dma);
 134                 for (j = 0; j < (sizeof(struct ci13xxx_qh)/sizeof(u32)); j++)
 135                         seq_printf(s, " %04X:    %08X    %08X\n", j,
 136                                    *((u32 *)mEpRx->qh.ptr + j),
 137                                    *((u32 *)mEpTx->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 ci13xxx *ci = s->private;
 162         unsigned long flags;
 163         struct list_head   *ptr = NULL;
 164         struct ci13xxx_req *req = NULL;
 165         unsigned i, j, qsize = sizeof(struct ci13xxx_td)/sizeof(u32);
 166
 167         if (ci->role != CI_ROLE_GADGET) {
 168                 seq_printf(s, "not in gadget mode\n");
 169                 return 0;
 170         }
 171
 172         spin_lock_irqsave(&ci->lock, flags);
 173         for (i = 0; i < ci->hw_ep_max; i++)
 174                 list_for_each(ptr, &ci->ci13xxx_ep[i].qh.queue) {
 175                         req = list_entry(ptr, struct ci13xxx_req, queue);
 176
 177                         seq_printf(s, "EP=%02i: TD=%08X %s\n",
 178                                    i % (ci->hw_ep_max / 2), (u32)req->dma,
 179                                    ((i < ci->hw_ep_max/2) ? "RX" : "TX"));
 180
 181                         for (j = 0; j < qsize; j++)
 182                                 seq_printf(s, " %04X:    %08X\n", j,
 183                                            *((u32 *)req->ptr + j));
 184                 }
 185         spin_unlock_irqrestore(&ci->lock, flags);
 186
 187         return 0;
 188 }
 189
 190 static int ci_requests_open(struct inode *inode, struct file *file)
 191 {
 192         return single_open(file, ci_requests_show, inode->i_private);
 193 }
 194
 195 static const struct file_operations ci_requests_fops = {
 196         .open           = ci_requests_open,
 197         .read           = seq_read,
 198         .llseek         = seq_lseek,
 199         .release        = single_release,
 200 };
 201
 202 static int ci_role_show(struct seq_file *s, void *data)
 203 {
 204         struct ci13xxx *ci = s->private;
 205
 206         seq_printf(s, "%s\n", ci_role(ci)->name);
 207
 208         return 0;
 209 }
 210
 211 static ssize_t ci_role_write(struct file *file, const char __user *ubuf,
 212                              size_t count, loff_t *ppos)
 213 {
 214         struct seq_file *s = file->private_data;
 215         struct ci13xxx *ci = s->private;
 216         enum ci_role role;
 217         char buf[8];
 218         int ret;
 219
 220         if (copy_from_user(buf, ubuf, min_t(size_t, sizeof(buf) - 1, count)))
 221                 return -EFAULT;
 222
 223         for (role = CI_ROLE_HOST; role < CI_ROLE_END; role++)
 224                 if (ci->roles[role] &&
 225                     !strncmp(buf, ci->roles[role]->name,
 226                              strlen(ci->roles[role]->name)))
 227                         break;
 228
 229         if (role == CI_ROLE_END || role == ci->role)
 230                 return -EINVAL;
 231
 232         ci_role_stop(ci);
 233         ret = ci_role_start(ci, role);
 234
 235         return ret ? ret : count;
 236 }
 237
 238 static int ci_role_open(struct inode *inode, struct file *file)
 239 {
 240         return single_open(file, ci_role_show, inode->i_private);
 241 }
 242
 243 static const struct file_operations ci_role_fops = {
 244         .open           = ci_role_open,
 245         .write          = ci_role_write,
 246         .read           = seq_read,
 247         .llseek         = seq_lseek,
 248         .release        = single_release,
 249 };
 250
 251 /**
 252  * dbg_create_files: initializes the attribute interface
 253  * @ci: device
 254  *
 255  * This function returns an error code
 256  */
 257 int dbg_create_files(struct ci13xxx *ci)
 258 {
 259         struct dentry *dent;
 260
 261         ci->debugfs = debugfs_create_dir(dev_name(ci->dev), NULL);
 262         if (!ci->debugfs)
 263                 return -ENOMEM;
 264
 265         dent = debugfs_create_file("device", S_IRUGO, ci->debugfs, ci,
 266                                    &ci_device_fops);
 267         if (!dent)
 268                 goto err;
 269
 270         dent = debugfs_create_file("port_test", S_IRUGO | S_IWUSR, ci->debugfs,
 271                                    ci, &ci_port_test_fops);
 272         if (!dent)
 273                 goto err;
 274
 275         dent = debugfs_create_file("qheads", S_IRUGO, ci->debugfs, ci,
 276                                    &ci_qheads_fops);
 277         if (!dent)
 278                 goto err;
 279
 280         dent = debugfs_create_file("requests", S_IRUGO, ci->debugfs, ci,
 281                                    &ci_requests_fops);
 282         if (!dent)
 283                 goto err;
 284
 285         dent = debugfs_create_file("role", S_IRUGO | S_IWUSR, ci->debugfs, ci,
 286                                    &ci_role_fops);
 287         if (dent)
 288                 return 0;
 289 err:
 290         debugfs_remove_recursive(ci->debugfs);
 291         return -ENOMEM;
 292 }
 293
 294 /**
 295  * dbg_remove_files: destroys the attribute interface
 296  * @ci: device
 297  */
 298 void dbg_remove_files(struct ci13xxx *ci)
 299 {
 300         debugfs_remove_recursive(ci->debugfs);
 301 }