ntb_msi_test.c 9.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432
  1. // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
  2. #include <linux/module.h>
  3. #include <linux/debugfs.h>
  4. #include <linux/ntb.h>
  5. #include <linux/pci.h>
  6. #include <linux/radix-tree.h>
  7. #include <linux/workqueue.h>
  8. MODULE_LICENSE("Dual BSD/GPL");
  9. MODULE_VERSION("0.1");
  10. MODULE_AUTHOR("Logan Gunthorpe <logang@deltatee.com>");
  11. MODULE_DESCRIPTION("Test for sending MSI interrupts over an NTB memory window");
  12. static int num_irqs = 4;
  13. module_param(num_irqs, int, 0644);
  14. MODULE_PARM_DESC(num_irqs, "number of irqs to use");
  15. struct ntb_msit_ctx {
  16. struct ntb_dev *ntb;
  17. struct dentry *dbgfs_dir;
  18. struct work_struct setup_work;
  19. struct ntb_msit_isr_ctx {
  20. int irq_idx;
  21. int irq_num;
  22. int occurrences;
  23. struct ntb_msit_ctx *nm;
  24. struct ntb_msi_desc desc;
  25. } *isr_ctx;
  26. struct ntb_msit_peer {
  27. struct ntb_msit_ctx *nm;
  28. int pidx;
  29. int num_irqs;
  30. struct completion init_comp;
  31. struct ntb_msi_desc *msi_desc;
  32. } peers[];
  33. };
  34. static struct dentry *ntb_msit_dbgfs_topdir;
  35. static irqreturn_t ntb_msit_isr(int irq, void *dev)
  36. {
  37. struct ntb_msit_isr_ctx *isr_ctx = dev;
  38. struct ntb_msit_ctx *nm = isr_ctx->nm;
  39. dev_dbg(&nm->ntb->dev, "Interrupt Occurred: %d",
  40. isr_ctx->irq_idx);
  41. isr_ctx->occurrences++;
  42. return IRQ_HANDLED;
  43. }
  44. static void ntb_msit_setup_work(struct work_struct *work)
  45. {
  46. struct ntb_msit_ctx *nm = container_of(work, struct ntb_msit_ctx,
  47. setup_work);
  48. int irq_count = 0;
  49. int irq;
  50. int ret;
  51. uintptr_t i;
  52. ret = ntb_msi_setup_mws(nm->ntb);
  53. if (ret) {
  54. dev_err(&nm->ntb->dev, "Unable to setup MSI windows: %d\n",
  55. ret);
  56. return;
  57. }
  58. for (i = 0; i < num_irqs; i++) {
  59. nm->isr_ctx[i].irq_idx = i;
  60. nm->isr_ctx[i].nm = nm;
  61. if (!nm->isr_ctx[i].irq_num) {
  62. irq = ntbm_msi_request_irq(nm->ntb, ntb_msit_isr,
  63. KBUILD_MODNAME,
  64. &nm->isr_ctx[i],
  65. &nm->isr_ctx[i].desc);
  66. if (irq < 0)
  67. break;
  68. nm->isr_ctx[i].irq_num = irq;
  69. }
  70. ret = ntb_spad_write(nm->ntb, 2 * i + 1,
  71. nm->isr_ctx[i].desc.addr_offset);
  72. if (ret)
  73. break;
  74. ret = ntb_spad_write(nm->ntb, 2 * i + 2,
  75. nm->isr_ctx[i].desc.data);
  76. if (ret)
  77. break;
  78. irq_count++;
  79. }
  80. ntb_spad_write(nm->ntb, 0, irq_count);
  81. ntb_peer_db_set(nm->ntb, BIT(ntb_port_number(nm->ntb)));
  82. }
  83. static void ntb_msit_desc_changed(void *ctx)
  84. {
  85. struct ntb_msit_ctx *nm = ctx;
  86. int i;
  87. dev_dbg(&nm->ntb->dev, "MSI Descriptors Changed\n");
  88. for (i = 0; i < num_irqs; i++) {
  89. ntb_spad_write(nm->ntb, 2 * i + 1,
  90. nm->isr_ctx[i].desc.addr_offset);
  91. ntb_spad_write(nm->ntb, 2 * i + 2,
  92. nm->isr_ctx[i].desc.data);
  93. }
  94. ntb_peer_db_set(nm->ntb, BIT(ntb_port_number(nm->ntb)));
  95. }
  96. static void ntb_msit_link_event(void *ctx)
  97. {
  98. struct ntb_msit_ctx *nm = ctx;
  99. if (!ntb_link_is_up(nm->ntb, NULL, NULL))
  100. return;
  101. schedule_work(&nm->setup_work);
  102. }
  103. static void ntb_msit_copy_peer_desc(struct ntb_msit_ctx *nm, int peer)
  104. {
  105. int i;
  106. struct ntb_msi_desc *desc = nm->peers[peer].msi_desc;
  107. int irq_count = nm->peers[peer].num_irqs;
  108. for (i = 0; i < irq_count; i++) {
  109. desc[i].addr_offset = ntb_peer_spad_read(nm->ntb, peer,
  110. 2 * i + 1);
  111. desc[i].data = ntb_peer_spad_read(nm->ntb, peer, 2 * i + 2);
  112. }
  113. dev_info(&nm->ntb->dev, "Found %d interrupts on peer %d\n",
  114. irq_count, peer);
  115. complete_all(&nm->peers[peer].init_comp);
  116. }
  117. static void ntb_msit_db_event(void *ctx, int vec)
  118. {
  119. struct ntb_msit_ctx *nm = ctx;
  120. struct ntb_msi_desc *desc;
  121. u64 peer_mask = ntb_db_read(nm->ntb);
  122. u32 irq_count;
  123. int peer;
  124. ntb_db_clear(nm->ntb, peer_mask);
  125. for (peer = 0; peer < sizeof(peer_mask) * 8; peer++) {
  126. if (!(peer_mask & BIT(peer)))
  127. continue;
  128. irq_count = ntb_peer_spad_read(nm->ntb, peer, 0);
  129. if (irq_count == -1)
  130. continue;
  131. desc = kcalloc(irq_count, sizeof(*desc), GFP_ATOMIC);
  132. if (!desc)
  133. continue;
  134. kfree(nm->peers[peer].msi_desc);
  135. nm->peers[peer].msi_desc = desc;
  136. nm->peers[peer].num_irqs = irq_count;
  137. ntb_msit_copy_peer_desc(nm, peer);
  138. }
  139. }
  140. static const struct ntb_ctx_ops ntb_msit_ops = {
  141. .link_event = ntb_msit_link_event,
  142. .db_event = ntb_msit_db_event,
  143. };
  144. static int ntb_msit_dbgfs_trigger(void *data, u64 idx)
  145. {
  146. struct ntb_msit_peer *peer = data;
  147. if (idx >= peer->num_irqs)
  148. return -EINVAL;
  149. dev_dbg(&peer->nm->ntb->dev, "trigger irq %llu on peer %u\n",
  150. idx, peer->pidx);
  151. return ntb_msi_peer_trigger(peer->nm->ntb, peer->pidx,
  152. &peer->msi_desc[idx]);
  153. }
  154. DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_trigger_fops, NULL,
  155. ntb_msit_dbgfs_trigger, "%llu\n");
  156. static int ntb_msit_dbgfs_port_get(void *data, u64 *port)
  157. {
  158. struct ntb_msit_peer *peer = data;
  159. *port = ntb_peer_port_number(peer->nm->ntb, peer->pidx);
  160. return 0;
  161. }
  162. DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_port_fops, ntb_msit_dbgfs_port_get,
  163. NULL, "%llu\n");
  164. static int ntb_msit_dbgfs_count_get(void *data, u64 *count)
  165. {
  166. struct ntb_msit_peer *peer = data;
  167. *count = peer->num_irqs;
  168. return 0;
  169. }
  170. DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_count_fops, ntb_msit_dbgfs_count_get,
  171. NULL, "%llu\n");
  172. static int ntb_msit_dbgfs_ready_get(void *data, u64 *ready)
  173. {
  174. struct ntb_msit_peer *peer = data;
  175. *ready = try_wait_for_completion(&peer->init_comp);
  176. return 0;
  177. }
  178. static int ntb_msit_dbgfs_ready_set(void *data, u64 ready)
  179. {
  180. struct ntb_msit_peer *peer = data;
  181. return wait_for_completion_interruptible(&peer->init_comp);
  182. }
  183. DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_ready_fops, ntb_msit_dbgfs_ready_get,
  184. ntb_msit_dbgfs_ready_set, "%llu\n");
  185. static int ntb_msit_dbgfs_occurrences_get(void *data, u64 *occurrences)
  186. {
  187. struct ntb_msit_isr_ctx *isr_ctx = data;
  188. *occurrences = isr_ctx->occurrences;
  189. return 0;
  190. }
  191. DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_occurrences_fops,
  192. ntb_msit_dbgfs_occurrences_get,
  193. NULL, "%llu\n");
  194. static int ntb_msit_dbgfs_local_port_get(void *data, u64 *port)
  195. {
  196. struct ntb_msit_ctx *nm = data;
  197. *port = ntb_port_number(nm->ntb);
  198. return 0;
  199. }
  200. DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_local_port_fops,
  201. ntb_msit_dbgfs_local_port_get,
  202. NULL, "%llu\n");
  203. static void ntb_msit_create_dbgfs(struct ntb_msit_ctx *nm)
  204. {
  205. struct pci_dev *pdev = nm->ntb->pdev;
  206. char buf[32];
  207. int i;
  208. struct dentry *peer_dir;
  209. nm->dbgfs_dir = debugfs_create_dir(pci_name(pdev),
  210. ntb_msit_dbgfs_topdir);
  211. debugfs_create_file("port", 0400, nm->dbgfs_dir, nm,
  212. &ntb_msit_local_port_fops);
  213. for (i = 0; i < ntb_peer_port_count(nm->ntb); i++) {
  214. nm->peers[i].pidx = i;
  215. nm->peers[i].nm = nm;
  216. init_completion(&nm->peers[i].init_comp);
  217. snprintf(buf, sizeof(buf), "peer%d", i);
  218. peer_dir = debugfs_create_dir(buf, nm->dbgfs_dir);
  219. debugfs_create_file_unsafe("trigger", 0200, peer_dir,
  220. &nm->peers[i],
  221. &ntb_msit_trigger_fops);
  222. debugfs_create_file_unsafe("port", 0400, peer_dir,
  223. &nm->peers[i], &ntb_msit_port_fops);
  224. debugfs_create_file_unsafe("count", 0400, peer_dir,
  225. &nm->peers[i],
  226. &ntb_msit_count_fops);
  227. debugfs_create_file_unsafe("ready", 0600, peer_dir,
  228. &nm->peers[i],
  229. &ntb_msit_ready_fops);
  230. }
  231. for (i = 0; i < num_irqs; i++) {
  232. snprintf(buf, sizeof(buf), "irq%d_occurrences", i);
  233. debugfs_create_file_unsafe(buf, 0400, nm->dbgfs_dir,
  234. &nm->isr_ctx[i],
  235. &ntb_msit_occurrences_fops);
  236. }
  237. }
  238. static void ntb_msit_remove_dbgfs(struct ntb_msit_ctx *nm)
  239. {
  240. debugfs_remove_recursive(nm->dbgfs_dir);
  241. }
  242. static int ntb_msit_probe(struct ntb_client *client, struct ntb_dev *ntb)
  243. {
  244. struct ntb_msit_ctx *nm;
  245. int peers;
  246. int ret;
  247. peers = ntb_peer_port_count(ntb);
  248. if (peers <= 0)
  249. return -EINVAL;
  250. if (ntb_spad_is_unsafe(ntb) || ntb_spad_count(ntb) < 2 * num_irqs + 1) {
  251. dev_err(&ntb->dev, "NTB MSI test requires at least %d spads for %d irqs\n",
  252. 2 * num_irqs + 1, num_irqs);
  253. return -EFAULT;
  254. }
  255. ret = ntb_spad_write(ntb, 0, -1);
  256. if (ret) {
  257. dev_err(&ntb->dev, "Unable to write spads: %d\n", ret);
  258. return ret;
  259. }
  260. ret = ntb_db_clear_mask(ntb, GENMASK(peers - 1, 0));
  261. if (ret) {
  262. dev_err(&ntb->dev, "Unable to clear doorbell mask: %d\n", ret);
  263. return ret;
  264. }
  265. ret = ntb_msi_init(ntb, ntb_msit_desc_changed);
  266. if (ret) {
  267. dev_err(&ntb->dev, "Unable to initialize MSI library: %d\n",
  268. ret);
  269. return ret;
  270. }
  271. nm = devm_kzalloc(&ntb->dev, struct_size(nm, peers, peers), GFP_KERNEL);
  272. if (!nm)
  273. return -ENOMEM;
  274. nm->isr_ctx = devm_kcalloc(&ntb->dev, num_irqs, sizeof(*nm->isr_ctx),
  275. GFP_KERNEL);
  276. if (!nm->isr_ctx)
  277. return -ENOMEM;
  278. INIT_WORK(&nm->setup_work, ntb_msit_setup_work);
  279. nm->ntb = ntb;
  280. ntb_msit_create_dbgfs(nm);
  281. ret = ntb_set_ctx(ntb, nm, &ntb_msit_ops);
  282. if (ret)
  283. goto remove_dbgfs;
  284. if (!nm->isr_ctx) {
  285. ret = -ENOMEM;
  286. goto remove_dbgfs;
  287. }
  288. ntb_link_enable(ntb, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
  289. return 0;
  290. remove_dbgfs:
  291. ntb_msit_remove_dbgfs(nm);
  292. devm_kfree(&ntb->dev, nm->isr_ctx);
  293. devm_kfree(&ntb->dev, nm);
  294. return ret;
  295. }
  296. static void ntb_msit_remove(struct ntb_client *client, struct ntb_dev *ntb)
  297. {
  298. struct ntb_msit_ctx *nm = ntb->ctx;
  299. int i;
  300. ntb_link_disable(ntb);
  301. ntb_db_set_mask(ntb, ntb_db_valid_mask(ntb));
  302. ntb_msi_clear_mws(ntb);
  303. for (i = 0; i < ntb_peer_port_count(ntb); i++)
  304. kfree(nm->peers[i].msi_desc);
  305. ntb_clear_ctx(ntb);
  306. ntb_msit_remove_dbgfs(nm);
  307. }
  308. static struct ntb_client ntb_msit_client = {
  309. .ops = {
  310. .probe = ntb_msit_probe,
  311. .remove = ntb_msit_remove
  312. }
  313. };
  314. static int __init ntb_msit_init(void)
  315. {
  316. int ret;
  317. if (debugfs_initialized())
  318. ntb_msit_dbgfs_topdir = debugfs_create_dir(KBUILD_MODNAME,
  319. NULL);
  320. ret = ntb_register_client(&ntb_msit_client);
  321. if (ret)
  322. debugfs_remove_recursive(ntb_msit_dbgfs_topdir);
  323. return ret;
  324. }
  325. module_init(ntb_msit_init);
  326. static void __exit ntb_msit_exit(void)
  327. {
  328. ntb_unregister_client(&ntb_msit_client);
  329. debugfs_remove_recursive(ntb_msit_dbgfs_topdir);
  330. }
  331. module_exit(ntb_msit_exit);