uhci-debug.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487
  1. /*
  2. * UHCI-specific debugging code. Invaluable when something
  3. * goes wrong, but don't get in my face.
  4. *
  5. * Kernel visible pointers are surrounded in []s and bus
  6. * visible pointers are surrounded in ()s
  7. *
  8. * (C) Copyright 1999 Linus Torvalds
  9. * (C) Copyright 1999-2001 Johannes Erdfelt
  10. */
  11. #include <linux/config.h>
  12. #include <linux/kernel.h>
  13. #include <linux/debugfs.h>
  14. #include <linux/smp_lock.h>
  15. #include <asm/io.h>
  16. #include "uhci-hcd.h"
  17. static struct dentry *uhci_debugfs_root = NULL;
  18. /* Handle REALLY large printks so we don't overflow buffers */
  19. static inline void lprintk(char *buf)
  20. {
  21. char *p;
  22. /* Just write one line at a time */
  23. while (buf) {
  24. p = strchr(buf, '\n');
  25. if (p)
  26. *p = 0;
  27. printk(KERN_DEBUG "%s\n", buf);
  28. buf = p;
  29. if (buf)
  30. buf++;
  31. }
  32. }
  33. static int uhci_show_td(struct uhci_td *td, char *buf, int len, int space)
  34. {
  35. char *out = buf;
  36. char *spid;
  37. u32 status, token;
  38. /* Try to make sure there's enough memory */
  39. if (len < 160)
  40. return 0;
  41. status = td_status(td);
  42. out += sprintf(out, "%*s[%p] link (%08x) ", space, "", td, le32_to_cpu(td->link));
  43. out += sprintf(out, "e%d %s%s%s%s%s%s%s%s%s%sLength=%x ",
  44. ((status >> 27) & 3),
  45. (status & TD_CTRL_SPD) ? "SPD " : "",
  46. (status & TD_CTRL_LS) ? "LS " : "",
  47. (status & TD_CTRL_IOC) ? "IOC " : "",
  48. (status & TD_CTRL_ACTIVE) ? "Active " : "",
  49. (status & TD_CTRL_STALLED) ? "Stalled " : "",
  50. (status & TD_CTRL_DBUFERR) ? "DataBufErr " : "",
  51. (status & TD_CTRL_BABBLE) ? "Babble " : "",
  52. (status & TD_CTRL_NAK) ? "NAK " : "",
  53. (status & TD_CTRL_CRCTIMEO) ? "CRC/Timeo " : "",
  54. (status & TD_CTRL_BITSTUFF) ? "BitStuff " : "",
  55. status & 0x7ff);
  56. token = td_token(td);
  57. switch (uhci_packetid(token)) {
  58. case USB_PID_SETUP:
  59. spid = "SETUP";
  60. break;
  61. case USB_PID_OUT:
  62. spid = "OUT";
  63. break;
  64. case USB_PID_IN:
  65. spid = "IN";
  66. break;
  67. default:
  68. spid = "?";
  69. break;
  70. }
  71. out += sprintf(out, "MaxLen=%x DT%d EndPt=%x Dev=%x, PID=%x(%s) ",
  72. token >> 21,
  73. ((token >> 19) & 1),
  74. (token >> 15) & 15,
  75. (token >> 8) & 127,
  76. (token & 0xff),
  77. spid);
  78. out += sprintf(out, "(buf=%08x)\n", le32_to_cpu(td->buffer));
  79. return out - buf;
  80. }
  81. static int uhci_show_urbp(struct urb_priv *urbp, char *buf, int len, int space)
  82. {
  83. char *out = buf;
  84. struct uhci_td *td;
  85. int i, nactive, ninactive;
  86. if (len < 200)
  87. return 0;
  88. out += sprintf(out, "urb_priv [%p] ", urbp);
  89. out += sprintf(out, "urb [%p] ", urbp->urb);
  90. out += sprintf(out, "qh [%p] ", urbp->qh);
  91. out += sprintf(out, "Dev=%d ", usb_pipedevice(urbp->urb->pipe));
  92. out += sprintf(out, "EP=%x(%s) ", usb_pipeendpoint(urbp->urb->pipe),
  93. (usb_pipein(urbp->urb->pipe) ? "IN" : "OUT"));
  94. switch (usb_pipetype(urbp->urb->pipe)) {
  95. case PIPE_ISOCHRONOUS: out += sprintf(out, "ISO"); break;
  96. case PIPE_INTERRUPT: out += sprintf(out, "INT"); break;
  97. case PIPE_BULK: out += sprintf(out, "BLK"); break;
  98. case PIPE_CONTROL: out += sprintf(out, "CTL"); break;
  99. }
  100. out += sprintf(out, "%s", (urbp->fsbr ? " FSBR" : ""));
  101. out += sprintf(out, "%s", (urbp->fsbr_timeout ? " FSBR_TO" : ""));
  102. if (urbp->urb->status != -EINPROGRESS)
  103. out += sprintf(out, " Status=%d", urbp->urb->status);
  104. out += sprintf(out, "\n");
  105. i = nactive = ninactive = 0;
  106. list_for_each_entry(td, &urbp->td_list, list) {
  107. if (++i <= 10 || debug > 2) {
  108. out += sprintf(out, "%*s%d: ", space + 2, "", i);
  109. out += uhci_show_td(td, out, len - (out - buf), 0);
  110. } else {
  111. if (td_status(td) & TD_CTRL_ACTIVE)
  112. ++nactive;
  113. else
  114. ++ninactive;
  115. }
  116. }
  117. if (nactive + ninactive > 0)
  118. out += sprintf(out, "%*s[skipped %d inactive and %d active "
  119. "TDs]\n",
  120. space, "", ninactive, nactive);
  121. return out - buf;
  122. }
  123. static int uhci_show_qh(struct uhci_qh *qh, char *buf, int len, int space)
  124. {
  125. char *out = buf;
  126. int i, nurbs;
  127. __le32 element = qh_element(qh);
  128. /* Try to make sure there's enough memory */
  129. if (len < 80 * 6)
  130. return 0;
  131. out += sprintf(out, "%*s[%p] link (%08x) element (%08x)\n", space, "",
  132. qh, le32_to_cpu(qh->link), le32_to_cpu(element));
  133. if (element & UHCI_PTR_QH)
  134. out += sprintf(out, "%*s Element points to QH (bug?)\n", space, "");
  135. if (element & UHCI_PTR_DEPTH)
  136. out += sprintf(out, "%*s Depth traverse\n", space, "");
  137. if (element & cpu_to_le32(8))
  138. out += sprintf(out, "%*s Bit 3 set (bug?)\n", space, "");
  139. if (!(element & ~(UHCI_PTR_QH | UHCI_PTR_DEPTH)))
  140. out += sprintf(out, "%*s Element is NULL (bug?)\n", space, "");
  141. if (list_empty(&qh->queue)) {
  142. out += sprintf(out, "%*s queue is empty\n", space, "");
  143. } else {
  144. struct urb_priv *urbp = list_entry(qh->queue.next,
  145. struct urb_priv, node);
  146. struct uhci_td *td = list_entry(urbp->td_list.next,
  147. struct uhci_td, list);
  148. if (cpu_to_le32(td->dma_handle) != (element & ~UHCI_PTR_BITS))
  149. out += sprintf(out, "%*s Element != First TD\n",
  150. space, "");
  151. i = nurbs = 0;
  152. list_for_each_entry(urbp, &qh->queue, node) {
  153. if (++i <= 10)
  154. out += uhci_show_urbp(urbp, out,
  155. len - (out - buf), space + 2);
  156. else
  157. ++nurbs;
  158. }
  159. if (nurbs > 0)
  160. out += sprintf(out, "%*s Skipped %d URBs\n",
  161. space, "", nurbs);
  162. }
  163. if (qh->udev) {
  164. out += sprintf(out, "%*s Dummy TD\n", space, "");
  165. out += uhci_show_td(qh->dummy_td, out, len - (out - buf), 0);
  166. }
  167. return out - buf;
  168. }
  169. #ifdef CONFIG_PROC_FS
  170. static const char * const qh_names[] = {
  171. "skel_unlink_qh", "skel_iso_qh",
  172. "skel_int128_qh", "skel_int64_qh",
  173. "skel_int32_qh", "skel_int16_qh",
  174. "skel_int8_qh", "skel_int4_qh",
  175. "skel_int2_qh", "skel_int1_qh",
  176. "skel_ls_control_qh", "skel_fs_control_qh",
  177. "skel_bulk_qh", "skel_term_qh"
  178. };
  179. static int uhci_show_sc(int port, unsigned short status, char *buf, int len)
  180. {
  181. char *out = buf;
  182. /* Try to make sure there's enough memory */
  183. if (len < 160)
  184. return 0;
  185. out += sprintf(out, " stat%d = %04x %s%s%s%s%s%s%s%s%s%s\n",
  186. port,
  187. status,
  188. (status & USBPORTSC_SUSP) ? " Suspend" : "",
  189. (status & USBPORTSC_OCC) ? " OverCurrentChange" : "",
  190. (status & USBPORTSC_OC) ? " OverCurrent" : "",
  191. (status & USBPORTSC_PR) ? " Reset" : "",
  192. (status & USBPORTSC_LSDA) ? " LowSpeed" : "",
  193. (status & USBPORTSC_RD) ? " ResumeDetect" : "",
  194. (status & USBPORTSC_PEC) ? " EnableChange" : "",
  195. (status & USBPORTSC_PE) ? " Enabled" : "",
  196. (status & USBPORTSC_CSC) ? " ConnectChange" : "",
  197. (status & USBPORTSC_CCS) ? " Connected" : "");
  198. return out - buf;
  199. }
  200. static int uhci_show_root_hub_state(struct uhci_hcd *uhci, char *buf, int len)
  201. {
  202. char *out = buf;
  203. char *rh_state;
  204. /* Try to make sure there's enough memory */
  205. if (len < 60)
  206. return 0;
  207. switch (uhci->rh_state) {
  208. case UHCI_RH_RESET:
  209. rh_state = "reset"; break;
  210. case UHCI_RH_SUSPENDED:
  211. rh_state = "suspended"; break;
  212. case UHCI_RH_AUTO_STOPPED:
  213. rh_state = "auto-stopped"; break;
  214. case UHCI_RH_RESUMING:
  215. rh_state = "resuming"; break;
  216. case UHCI_RH_SUSPENDING:
  217. rh_state = "suspending"; break;
  218. case UHCI_RH_RUNNING:
  219. rh_state = "running"; break;
  220. case UHCI_RH_RUNNING_NODEVS:
  221. rh_state = "running, no devs"; break;
  222. default:
  223. rh_state = "?"; break;
  224. }
  225. out += sprintf(out, "Root-hub state: %s\n", rh_state);
  226. return out - buf;
  227. }
  228. static int uhci_show_status(struct uhci_hcd *uhci, char *buf, int len)
  229. {
  230. char *out = buf;
  231. unsigned long io_addr = uhci->io_addr;
  232. unsigned short usbcmd, usbstat, usbint, usbfrnum;
  233. unsigned int flbaseadd;
  234. unsigned char sof;
  235. unsigned short portsc1, portsc2;
  236. /* Try to make sure there's enough memory */
  237. if (len < 80 * 6)
  238. return 0;
  239. usbcmd = inw(io_addr + 0);
  240. usbstat = inw(io_addr + 2);
  241. usbint = inw(io_addr + 4);
  242. usbfrnum = inw(io_addr + 6);
  243. flbaseadd = inl(io_addr + 8);
  244. sof = inb(io_addr + 12);
  245. portsc1 = inw(io_addr + 16);
  246. portsc2 = inw(io_addr + 18);
  247. out += sprintf(out, " usbcmd = %04x %s%s%s%s%s%s%s%s\n",
  248. usbcmd,
  249. (usbcmd & USBCMD_MAXP) ? "Maxp64 " : "Maxp32 ",
  250. (usbcmd & USBCMD_CF) ? "CF " : "",
  251. (usbcmd & USBCMD_SWDBG) ? "SWDBG " : "",
  252. (usbcmd & USBCMD_FGR) ? "FGR " : "",
  253. (usbcmd & USBCMD_EGSM) ? "EGSM " : "",
  254. (usbcmd & USBCMD_GRESET) ? "GRESET " : "",
  255. (usbcmd & USBCMD_HCRESET) ? "HCRESET " : "",
  256. (usbcmd & USBCMD_RS) ? "RS " : "");
  257. out += sprintf(out, " usbstat = %04x %s%s%s%s%s%s\n",
  258. usbstat,
  259. (usbstat & USBSTS_HCH) ? "HCHalted " : "",
  260. (usbstat & USBSTS_HCPE) ? "HostControllerProcessError " : "",
  261. (usbstat & USBSTS_HSE) ? "HostSystemError " : "",
  262. (usbstat & USBSTS_RD) ? "ResumeDetect " : "",
  263. (usbstat & USBSTS_ERROR) ? "USBError " : "",
  264. (usbstat & USBSTS_USBINT) ? "USBINT " : "");
  265. out += sprintf(out, " usbint = %04x\n", usbint);
  266. out += sprintf(out, " usbfrnum = (%d)%03x\n", (usbfrnum >> 10) & 1,
  267. 0xfff & (4*(unsigned int)usbfrnum));
  268. out += sprintf(out, " flbaseadd = %08x\n", flbaseadd);
  269. out += sprintf(out, " sof = %02x\n", sof);
  270. out += uhci_show_sc(1, portsc1, out, len - (out - buf));
  271. out += uhci_show_sc(2, portsc2, out, len - (out - buf));
  272. return out - buf;
  273. }
  274. static int uhci_sprint_schedule(struct uhci_hcd *uhci, char *buf, int len)
  275. {
  276. char *out = buf;
  277. int i, j;
  278. struct uhci_qh *qh;
  279. struct uhci_td *td;
  280. struct list_head *tmp, *head;
  281. out += uhci_show_root_hub_state(uhci, out, len - (out - buf));
  282. out += sprintf(out, "HC status\n");
  283. out += uhci_show_status(uhci, out, len - (out - buf));
  284. if (debug <= 1)
  285. return out - buf;
  286. out += sprintf(out, "Frame List\n");
  287. for (i = 0; i < UHCI_NUMFRAMES; ++i) {
  288. td = uhci->frame_cpu[i];
  289. if (!td)
  290. continue;
  291. out += sprintf(out, "- Frame %d\n", i); \
  292. if (td->dma_handle != (dma_addr_t)uhci->frame[i])
  293. out += sprintf(out, " frame list does not match td->dma_handle!\n");
  294. head = &td->fl_list;
  295. tmp = head;
  296. do {
  297. td = list_entry(tmp, struct uhci_td, fl_list);
  298. tmp = tmp->next;
  299. out += uhci_show_td(td, out, len - (out - buf), 4);
  300. } while (tmp != head);
  301. }
  302. out += sprintf(out, "Skeleton QHs\n");
  303. for (i = 0; i < UHCI_NUM_SKELQH; ++i) {
  304. int cnt = 0;
  305. qh = uhci->skelqh[i];
  306. out += sprintf(out, "- %s\n", qh_names[i]); \
  307. out += uhci_show_qh(qh, out, len - (out - buf), 4);
  308. /* Last QH is the Terminating QH, it's different */
  309. if (i == UHCI_NUM_SKELQH - 1) {
  310. if (qh->link != UHCI_PTR_TERM)
  311. out += sprintf(out, " bandwidth reclamation on!\n");
  312. if (qh_element(qh) != cpu_to_le32(uhci->term_td->dma_handle))
  313. out += sprintf(out, " skel_term_qh element is not set to term_td!\n");
  314. continue;
  315. }
  316. j = (i < 9) ? 9 : i+1; /* Next skeleton */
  317. head = &qh->node;
  318. tmp = head->next;
  319. while (tmp != head) {
  320. qh = list_entry(tmp, struct uhci_qh, node);
  321. tmp = tmp->next;
  322. if (++cnt <= 10)
  323. out += uhci_show_qh(qh, out,
  324. len - (out - buf), 4);
  325. }
  326. if ((cnt -= 10) > 0)
  327. out += sprintf(out, " Skipped %d QHs\n", cnt);
  328. if (i > 1 && i < UHCI_NUM_SKELQH - 1) {
  329. if (qh->link !=
  330. (cpu_to_le32(uhci->skelqh[j]->dma_handle) | UHCI_PTR_QH))
  331. out += sprintf(out, " last QH not linked to next skeleton!\n");
  332. }
  333. }
  334. return out - buf;
  335. }
  336. #define MAX_OUTPUT (64 * 1024)
  337. struct uhci_debug {
  338. int size;
  339. char *data;
  340. struct uhci_hcd *uhci;
  341. };
  342. static int uhci_debug_open(struct inode *inode, struct file *file)
  343. {
  344. struct uhci_hcd *uhci = inode->u.generic_ip;
  345. struct uhci_debug *up;
  346. int ret = -ENOMEM;
  347. unsigned long flags;
  348. lock_kernel();
  349. up = kmalloc(sizeof(*up), GFP_KERNEL);
  350. if (!up)
  351. goto out;
  352. up->data = kmalloc(MAX_OUTPUT, GFP_KERNEL);
  353. if (!up->data) {
  354. kfree(up);
  355. goto out;
  356. }
  357. spin_lock_irqsave(&uhci->lock, flags);
  358. up->size = uhci_sprint_schedule(uhci, up->data, MAX_OUTPUT);
  359. spin_unlock_irqrestore(&uhci->lock, flags);
  360. file->private_data = up;
  361. ret = 0;
  362. out:
  363. unlock_kernel();
  364. return ret;
  365. }
  366. static loff_t uhci_debug_lseek(struct file *file, loff_t off, int whence)
  367. {
  368. struct uhci_debug *up;
  369. loff_t new = -1;
  370. lock_kernel();
  371. up = file->private_data;
  372. switch (whence) {
  373. case 0:
  374. new = off;
  375. break;
  376. case 1:
  377. new = file->f_pos + off;
  378. break;
  379. }
  380. if (new < 0 || new > up->size) {
  381. unlock_kernel();
  382. return -EINVAL;
  383. }
  384. unlock_kernel();
  385. return (file->f_pos = new);
  386. }
  387. static ssize_t uhci_debug_read(struct file *file, char __user *buf,
  388. size_t nbytes, loff_t *ppos)
  389. {
  390. struct uhci_debug *up = file->private_data;
  391. return simple_read_from_buffer(buf, nbytes, ppos, up->data, up->size);
  392. }
  393. static int uhci_debug_release(struct inode *inode, struct file *file)
  394. {
  395. struct uhci_debug *up = file->private_data;
  396. kfree(up->data);
  397. kfree(up);
  398. return 0;
  399. }
  400. static struct file_operations uhci_debug_operations = {
  401. .open = uhci_debug_open,
  402. .llseek = uhci_debug_lseek,
  403. .read = uhci_debug_read,
  404. .release = uhci_debug_release,
  405. };
  406. #else /* CONFIG_DEBUG_FS */
  407. #define uhci_debug_operations (* (struct file_operations *) NULL)
  408. #endif