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