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