card_debugfs.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * IBM Accelerator Family 'GenWQE'
  4. *
  5. * (C) Copyright IBM Corp. 2013
  6. *
  7. * Author: Frank Haverkamp <haver@linux.vnet.ibm.com>
  8. * Author: Joerg-Stephan Vogt <jsvogt@de.ibm.com>
  9. * Author: Michael Jung <mijung@gmx.net>
  10. * Author: Michael Ruettger <michael@ibmra.de>
  11. */
  12. /*
  13. * Debugfs interfaces for the GenWQE card. Help to debug potential
  14. * problems. Dump internal chip state for debugging and failure
  15. * determination.
  16. */
  17. #include <linux/module.h>
  18. #include <linux/kernel.h>
  19. #include <linux/debugfs.h>
  20. #include <linux/seq_file.h>
  21. #include <linux/uaccess.h>
  22. #include "card_base.h"
  23. #include "card_ddcb.h"
  24. static void dbg_uidn_show(struct seq_file *s, struct genwqe_reg *regs,
  25. int entries)
  26. {
  27. unsigned int i;
  28. u32 v_hi, v_lo;
  29. for (i = 0; i < entries; i++) {
  30. v_hi = (regs[i].val >> 32) & 0xffffffff;
  31. v_lo = (regs[i].val) & 0xffffffff;
  32. seq_printf(s, " 0x%08x 0x%08x 0x%08x 0x%08x EXT_ERR_REC\n",
  33. regs[i].addr, regs[i].idx, v_hi, v_lo);
  34. }
  35. }
  36. static int curr_dbg_uidn_show(struct seq_file *s, void *unused, int uid)
  37. {
  38. struct genwqe_dev *cd = s->private;
  39. int entries;
  40. struct genwqe_reg *regs;
  41. entries = genwqe_ffdc_buff_size(cd, uid);
  42. if (entries < 0)
  43. return -EINVAL;
  44. if (entries == 0)
  45. return 0;
  46. regs = kcalloc(entries, sizeof(*regs), GFP_KERNEL);
  47. if (regs == NULL)
  48. return -ENOMEM;
  49. genwqe_stop_traps(cd); /* halt the traps while dumping data */
  50. genwqe_ffdc_buff_read(cd, uid, regs, entries);
  51. genwqe_start_traps(cd);
  52. dbg_uidn_show(s, regs, entries);
  53. kfree(regs);
  54. return 0;
  55. }
  56. static int curr_dbg_uid0_show(struct seq_file *s, void *unused)
  57. {
  58. return curr_dbg_uidn_show(s, unused, 0);
  59. }
  60. DEFINE_SHOW_ATTRIBUTE(curr_dbg_uid0);
  61. static int curr_dbg_uid1_show(struct seq_file *s, void *unused)
  62. {
  63. return curr_dbg_uidn_show(s, unused, 1);
  64. }
  65. DEFINE_SHOW_ATTRIBUTE(curr_dbg_uid1);
  66. static int curr_dbg_uid2_show(struct seq_file *s, void *unused)
  67. {
  68. return curr_dbg_uidn_show(s, unused, 2);
  69. }
  70. DEFINE_SHOW_ATTRIBUTE(curr_dbg_uid2);
  71. static int prev_dbg_uidn_show(struct seq_file *s, void *unused, int uid)
  72. {
  73. struct genwqe_dev *cd = s->private;
  74. dbg_uidn_show(s, cd->ffdc[uid].regs, cd->ffdc[uid].entries);
  75. return 0;
  76. }
  77. static int prev_dbg_uid0_show(struct seq_file *s, void *unused)
  78. {
  79. return prev_dbg_uidn_show(s, unused, 0);
  80. }
  81. DEFINE_SHOW_ATTRIBUTE(prev_dbg_uid0);
  82. static int prev_dbg_uid1_show(struct seq_file *s, void *unused)
  83. {
  84. return prev_dbg_uidn_show(s, unused, 1);
  85. }
  86. DEFINE_SHOW_ATTRIBUTE(prev_dbg_uid1);
  87. static int prev_dbg_uid2_show(struct seq_file *s, void *unused)
  88. {
  89. return prev_dbg_uidn_show(s, unused, 2);
  90. }
  91. DEFINE_SHOW_ATTRIBUTE(prev_dbg_uid2);
  92. static int curr_regs_show(struct seq_file *s, void *unused)
  93. {
  94. struct genwqe_dev *cd = s->private;
  95. unsigned int i;
  96. struct genwqe_reg *regs;
  97. regs = kcalloc(GENWQE_FFDC_REGS, sizeof(*regs), GFP_KERNEL);
  98. if (regs == NULL)
  99. return -ENOMEM;
  100. genwqe_stop_traps(cd);
  101. genwqe_read_ffdc_regs(cd, regs, GENWQE_FFDC_REGS, 1);
  102. genwqe_start_traps(cd);
  103. for (i = 0; i < GENWQE_FFDC_REGS; i++) {
  104. if (regs[i].addr == 0xffffffff)
  105. break; /* invalid entries */
  106. if (regs[i].val == 0x0ull)
  107. continue; /* do not print 0x0 FIRs */
  108. seq_printf(s, " 0x%08x 0x%016llx\n",
  109. regs[i].addr, regs[i].val);
  110. }
  111. return 0;
  112. }
  113. DEFINE_SHOW_ATTRIBUTE(curr_regs);
  114. static int prev_regs_show(struct seq_file *s, void *unused)
  115. {
  116. struct genwqe_dev *cd = s->private;
  117. unsigned int i;
  118. struct genwqe_reg *regs = cd->ffdc[GENWQE_DBG_REGS].regs;
  119. if (regs == NULL)
  120. return -EINVAL;
  121. for (i = 0; i < GENWQE_FFDC_REGS; i++) {
  122. if (regs[i].addr == 0xffffffff)
  123. break; /* invalid entries */
  124. if (regs[i].val == 0x0ull)
  125. continue; /* do not print 0x0 FIRs */
  126. seq_printf(s, " 0x%08x 0x%016llx\n",
  127. regs[i].addr, regs[i].val);
  128. }
  129. return 0;
  130. }
  131. DEFINE_SHOW_ATTRIBUTE(prev_regs);
  132. static int jtimer_show(struct seq_file *s, void *unused)
  133. {
  134. struct genwqe_dev *cd = s->private;
  135. unsigned int vf_num;
  136. u64 jtimer;
  137. jtimer = genwqe_read_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT, 0);
  138. seq_printf(s, " PF 0x%016llx %d msec\n", jtimer,
  139. GENWQE_PF_JOBTIMEOUT_MSEC);
  140. for (vf_num = 0; vf_num < cd->num_vfs; vf_num++) {
  141. jtimer = genwqe_read_vreg(cd, IO_SLC_VF_APPJOB_TIMEOUT,
  142. vf_num + 1);
  143. seq_printf(s, " VF%-2d 0x%016llx %d msec\n", vf_num, jtimer,
  144. cd->vf_jobtimeout_msec[vf_num]);
  145. }
  146. return 0;
  147. }
  148. DEFINE_SHOW_ATTRIBUTE(jtimer);
  149. static int queue_working_time_show(struct seq_file *s, void *unused)
  150. {
  151. struct genwqe_dev *cd = s->private;
  152. unsigned int vf_num;
  153. u64 t;
  154. t = genwqe_read_vreg(cd, IO_SLC_VF_QUEUE_WTIME, 0);
  155. seq_printf(s, " PF 0x%016llx\n", t);
  156. for (vf_num = 0; vf_num < cd->num_vfs; vf_num++) {
  157. t = genwqe_read_vreg(cd, IO_SLC_VF_QUEUE_WTIME, vf_num + 1);
  158. seq_printf(s, " VF%-2d 0x%016llx\n", vf_num, t);
  159. }
  160. return 0;
  161. }
  162. DEFINE_SHOW_ATTRIBUTE(queue_working_time);
  163. static int ddcb_info_show(struct seq_file *s, void *unused)
  164. {
  165. struct genwqe_dev *cd = s->private;
  166. unsigned int i;
  167. struct ddcb_queue *queue;
  168. struct ddcb *pddcb;
  169. queue = &cd->queue;
  170. seq_puts(s, "DDCB QUEUE:\n");
  171. seq_printf(s, " ddcb_max: %d\n"
  172. " ddcb_daddr: %016llx - %016llx\n"
  173. " ddcb_vaddr: %p\n"
  174. " ddcbs_in_flight: %u\n"
  175. " ddcbs_max_in_flight: %u\n"
  176. " ddcbs_completed: %u\n"
  177. " return_on_busy: %u\n"
  178. " wait_on_busy: %u\n"
  179. " irqs_processed: %u\n",
  180. queue->ddcb_max, (long long)queue->ddcb_daddr,
  181. (long long)queue->ddcb_daddr +
  182. (queue->ddcb_max * DDCB_LENGTH),
  183. queue->ddcb_vaddr, queue->ddcbs_in_flight,
  184. queue->ddcbs_max_in_flight, queue->ddcbs_completed,
  185. queue->return_on_busy, queue->wait_on_busy,
  186. cd->irqs_processed);
  187. /* Hardware State */
  188. seq_printf(s, " 0x%08x 0x%016llx IO_QUEUE_CONFIG\n"
  189. " 0x%08x 0x%016llx IO_QUEUE_STATUS\n"
  190. " 0x%08x 0x%016llx IO_QUEUE_SEGMENT\n"
  191. " 0x%08x 0x%016llx IO_QUEUE_INITSQN\n"
  192. " 0x%08x 0x%016llx IO_QUEUE_WRAP\n"
  193. " 0x%08x 0x%016llx IO_QUEUE_OFFSET\n"
  194. " 0x%08x 0x%016llx IO_QUEUE_WTIME\n"
  195. " 0x%08x 0x%016llx IO_QUEUE_ERRCNTS\n"
  196. " 0x%08x 0x%016llx IO_QUEUE_LRW\n",
  197. queue->IO_QUEUE_CONFIG,
  198. __genwqe_readq(cd, queue->IO_QUEUE_CONFIG),
  199. queue->IO_QUEUE_STATUS,
  200. __genwqe_readq(cd, queue->IO_QUEUE_STATUS),
  201. queue->IO_QUEUE_SEGMENT,
  202. __genwqe_readq(cd, queue->IO_QUEUE_SEGMENT),
  203. queue->IO_QUEUE_INITSQN,
  204. __genwqe_readq(cd, queue->IO_QUEUE_INITSQN),
  205. queue->IO_QUEUE_WRAP,
  206. __genwqe_readq(cd, queue->IO_QUEUE_WRAP),
  207. queue->IO_QUEUE_OFFSET,
  208. __genwqe_readq(cd, queue->IO_QUEUE_OFFSET),
  209. queue->IO_QUEUE_WTIME,
  210. __genwqe_readq(cd, queue->IO_QUEUE_WTIME),
  211. queue->IO_QUEUE_ERRCNTS,
  212. __genwqe_readq(cd, queue->IO_QUEUE_ERRCNTS),
  213. queue->IO_QUEUE_LRW,
  214. __genwqe_readq(cd, queue->IO_QUEUE_LRW));
  215. seq_printf(s, "DDCB list (ddcb_act=%d/ddcb_next=%d):\n",
  216. queue->ddcb_act, queue->ddcb_next);
  217. pddcb = queue->ddcb_vaddr;
  218. for (i = 0; i < queue->ddcb_max; i++) {
  219. seq_printf(s, " %-3d: RETC=%03x SEQ=%04x HSI/SHI=%02x/%02x ",
  220. i, be16_to_cpu(pddcb->retc_16),
  221. be16_to_cpu(pddcb->seqnum_16),
  222. pddcb->hsi, pddcb->shi);
  223. seq_printf(s, "PRIV=%06llx CMD=%02x\n",
  224. be64_to_cpu(pddcb->priv_64), pddcb->cmd);
  225. pddcb++;
  226. }
  227. return 0;
  228. }
  229. DEFINE_SHOW_ATTRIBUTE(ddcb_info);
  230. static int info_show(struct seq_file *s, void *unused)
  231. {
  232. struct genwqe_dev *cd = s->private;
  233. u64 app_id, slu_id, bitstream = -1;
  234. struct pci_dev *pci_dev = cd->pci_dev;
  235. slu_id = __genwqe_readq(cd, IO_SLU_UNITCFG);
  236. app_id = __genwqe_readq(cd, IO_APP_UNITCFG);
  237. if (genwqe_is_privileged(cd))
  238. bitstream = __genwqe_readq(cd, IO_SLU_BITSTREAM);
  239. seq_printf(s, "%s driver version: %s\n"
  240. " Device Name/Type: %s %s CardIdx: %d\n"
  241. " SLU/APP Config : 0x%016llx/0x%016llx\n"
  242. " Build Date : %u/%x/%u\n"
  243. " Base Clock : %u MHz\n"
  244. " Arch/SVN Release: %u/%llx\n"
  245. " Bitstream : %llx\n",
  246. GENWQE_DEVNAME, DRV_VERSION, dev_name(&pci_dev->dev),
  247. genwqe_is_privileged(cd) ?
  248. "Physical" : "Virtual or no SR-IOV",
  249. cd->card_idx, slu_id, app_id,
  250. (u16)((slu_id >> 12) & 0x0fLLU), /* month */
  251. (u16)((slu_id >> 4) & 0xffLLU), /* day */
  252. (u16)((slu_id >> 16) & 0x0fLLU) + 2010, /* year */
  253. genwqe_base_clock_frequency(cd),
  254. (u16)((slu_id >> 32) & 0xffLLU), slu_id >> 40,
  255. bitstream);
  256. return 0;
  257. }
  258. DEFINE_SHOW_ATTRIBUTE(info);
  259. void genwqe_init_debugfs(struct genwqe_dev *cd)
  260. {
  261. struct dentry *root;
  262. char card_name[64];
  263. char name[64];
  264. unsigned int i;
  265. sprintf(card_name, "%s%d_card", GENWQE_DEVNAME, cd->card_idx);
  266. root = debugfs_create_dir(card_name, cd->debugfs_genwqe);
  267. /* non privileged interfaces are done here */
  268. debugfs_create_file("ddcb_info", S_IRUGO, root, cd, &ddcb_info_fops);
  269. debugfs_create_file("info", S_IRUGO, root, cd, &info_fops);
  270. debugfs_create_x64("err_inject", 0666, root, &cd->err_inject);
  271. debugfs_create_u32("ddcb_software_timeout", 0666, root,
  272. &cd->ddcb_software_timeout);
  273. debugfs_create_u32("kill_timeout", 0666, root, &cd->kill_timeout);
  274. /* privileged interfaces follow here */
  275. if (!genwqe_is_privileged(cd)) {
  276. cd->debugfs_root = root;
  277. return;
  278. }
  279. debugfs_create_file("curr_regs", S_IRUGO, root, cd, &curr_regs_fops);
  280. debugfs_create_file("curr_dbg_uid0", S_IRUGO, root, cd,
  281. &curr_dbg_uid0_fops);
  282. debugfs_create_file("curr_dbg_uid1", S_IRUGO, root, cd,
  283. &curr_dbg_uid1_fops);
  284. debugfs_create_file("curr_dbg_uid2", S_IRUGO, root, cd,
  285. &curr_dbg_uid2_fops);
  286. debugfs_create_file("prev_regs", S_IRUGO, root, cd, &prev_regs_fops);
  287. debugfs_create_file("prev_dbg_uid0", S_IRUGO, root, cd,
  288. &prev_dbg_uid0_fops);
  289. debugfs_create_file("prev_dbg_uid1", S_IRUGO, root, cd,
  290. &prev_dbg_uid1_fops);
  291. debugfs_create_file("prev_dbg_uid2", S_IRUGO, root, cd,
  292. &prev_dbg_uid2_fops);
  293. for (i = 0; i < GENWQE_MAX_VFS; i++) {
  294. sprintf(name, "vf%u_jobtimeout_msec", i);
  295. debugfs_create_u32(name, 0666, root,
  296. &cd->vf_jobtimeout_msec[i]);
  297. }
  298. debugfs_create_file("jobtimer", S_IRUGO, root, cd, &jtimer_fops);
  299. debugfs_create_file("queue_working_time", S_IRUGO, root, cd,
  300. &queue_working_time_fops);
  301. debugfs_create_u32("skip_recovery", 0666, root, &cd->skip_recovery);
  302. debugfs_create_u32("use_platform_recovery", 0666, root,
  303. &cd->use_platform_recovery);
  304. cd->debugfs_root = root;
  305. }
  306. void genqwe_exit_debugfs(struct genwqe_dev *cd)
  307. {
  308. debugfs_remove_recursive(cd->debugfs_root);
  309. }