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 } 302