ntb/test/ntb_msi_test.c

0001 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
0002
0003 #include <linux/module.h>
0004 #include <linux/debugfs.h>
0005 #include <linux/ntb.h>
0006 #include <linux/pci.h>
0007 #include <linux/radix-tree.h>
0008 #include <linux/workqueue.h>
0009
0010 MODULE_LICENSE("Dual BSD/GPL");
0011 MODULE_VERSION("0.1");
0012 MODULE_AUTHOR("Logan Gunthorpe <logang@deltatee.com>");
0013 MODULE_DESCRIPTION("Test for sending MSI interrupts over an NTB memory window");
0014
0015 static int num_irqs = 4;
0016 module_param(num_irqs, int, 0644);
0017 MODULE_PARM_DESC(num_irqs, "number of irqs to use");
0018
0019 struct ntb_msit_ctx {
0020     struct ntb_dev *ntb;
0021     struct dentry *dbgfs_dir;
0022     struct work_struct setup_work;
0023
0024     struct ntb_msit_isr_ctx {
0025         int irq_idx;
0026         int irq_num;
0027         int occurrences;
0028         struct ntb_msit_ctx *nm;
0029         struct ntb_msi_desc desc;
0030     } *isr_ctx;
0031
0032     struct ntb_msit_peer {
0033         struct ntb_msit_ctx *nm;
0034         int pidx;
0035         int num_irqs;
0036         struct completion init_comp;
0037         struct ntb_msi_desc *msi_desc;
0038     } peers[];
0039 };
0040
0041 static struct dentry *ntb_msit_dbgfs_topdir;
0042
0043 static irqreturn_t ntb_msit_isr(int irq, void *dev)
0044 {
0045     struct ntb_msit_isr_ctx *isr_ctx = dev;
0046     struct ntb_msit_ctx *nm = isr_ctx->nm;
0047
0048     dev_dbg(&nm->ntb->dev, "Interrupt Occurred: %d",
0049         isr_ctx->irq_idx);
0050
0051     isr_ctx->occurrences++;
0052
0053     return IRQ_HANDLED;
0054 }
0055
0056 static void ntb_msit_setup_work(struct work_struct *work)
0057 {
0058     struct ntb_msit_ctx *nm = container_of(work, struct ntb_msit_ctx,
0059                            setup_work);
0060     int irq_count = 0;
0061     int irq;
0062     int ret;
0063     uintptr_t i;
0064
0065     ret = ntb_msi_setup_mws(nm->ntb);
0066     if (ret) {
0067         dev_err(&nm->ntb->dev, "Unable to setup MSI windows: %d\n",
0068             ret);
0069         return;
0070     }
0071
0072     for (i = 0; i < num_irqs; i++) {
0073         nm->isr_ctx[i].irq_idx = i;
0074         nm->isr_ctx[i].nm = nm;
0075
0076         if (!nm->isr_ctx[i].irq_num) {
0077             irq = ntbm_msi_request_irq(nm->ntb, ntb_msit_isr,
0078                            KBUILD_MODNAME,
0079                            &nm->isr_ctx[i],
0080                            &nm->isr_ctx[i].desc);
0081             if (irq < 0)
0082                 break;
0083
0084             nm->isr_ctx[i].irq_num = irq;
0085         }
0086
0087         ret = ntb_spad_write(nm->ntb, 2 * i + 1,
0088                      nm->isr_ctx[i].desc.addr_offset);
0089         if (ret)
0090             break;
0091
0092         ret = ntb_spad_write(nm->ntb, 2 * i + 2,
0093                      nm->isr_ctx[i].desc.data);
0094         if (ret)
0095             break;
0096
0097         irq_count++;
0098     }
0099
0100     ntb_spad_write(nm->ntb, 0, irq_count);
0101     ntb_peer_db_set(nm->ntb, BIT(ntb_port_number(nm->ntb)));
0102 }
0103
0104 static void ntb_msit_desc_changed(void *ctx)
0105 {
0106     struct ntb_msit_ctx *nm = ctx;
0107     int i;
0108
0109     dev_dbg(&nm->ntb->dev, "MSI Descriptors Changed\n");
0110
0111     for (i = 0; i < num_irqs; i++) {
0112         ntb_spad_write(nm->ntb, 2 * i + 1,
0113                    nm->isr_ctx[i].desc.addr_offset);
0114         ntb_spad_write(nm->ntb, 2 * i + 2,
0115                    nm->isr_ctx[i].desc.data);
0116     }
0117
0118     ntb_peer_db_set(nm->ntb, BIT(ntb_port_number(nm->ntb)));
0119 }
0120
0121 static void ntb_msit_link_event(void *ctx)
0122 {
0123     struct ntb_msit_ctx *nm = ctx;
0124
0125     if (!ntb_link_is_up(nm->ntb, NULL, NULL))
0126         return;
0127
0128     schedule_work(&nm->setup_work);
0129 }
0130
0131 static void ntb_msit_copy_peer_desc(struct ntb_msit_ctx *nm, int peer)
0132 {
0133     int i;
0134     struct ntb_msi_desc *desc = nm->peers[peer].msi_desc;
0135     int irq_count = nm->peers[peer].num_irqs;
0136
0137     for (i = 0; i < irq_count; i++) {
0138         desc[i].addr_offset = ntb_peer_spad_read(nm->ntb, peer,
0139                              2 * i + 1);
0140         desc[i].data = ntb_peer_spad_read(nm->ntb, peer, 2 * i + 2);
0141     }
0142
0143     dev_info(&nm->ntb->dev, "Found %d interrupts on peer %d\n",
0144          irq_count, peer);
0145
0146     complete_all(&nm->peers[peer].init_comp);
0147 }
0148
0149 static void ntb_msit_db_event(void *ctx, int vec)
0150 {
0151     struct ntb_msit_ctx *nm = ctx;
0152     struct ntb_msi_desc *desc;
0153     u64 peer_mask = ntb_db_read(nm->ntb);
0154     u32 irq_count;
0155     int peer;
0156
0157     ntb_db_clear(nm->ntb, peer_mask);
0158
0159     for (peer = 0; peer < sizeof(peer_mask) * 8; peer++) {
0160         if (!(peer_mask & BIT(peer)))
0161             continue;
0162
0163         irq_count = ntb_peer_spad_read(nm->ntb, peer, 0);
0164         if (irq_count == -1)
0165             continue;
0166
0167         desc = kcalloc(irq_count, sizeof(*desc), GFP_ATOMIC);
0168         if (!desc)
0169             continue;
0170
0171         kfree(nm->peers[peer].msi_desc);
0172         nm->peers[peer].msi_desc = desc;
0173         nm->peers[peer].num_irqs = irq_count;
0174
0175         ntb_msit_copy_peer_desc(nm, peer);
0176     }
0177 }
0178
0179 static const struct ntb_ctx_ops ntb_msit_ops = {
0180     .link_event = ntb_msit_link_event,
0181     .db_event = ntb_msit_db_event,
0182 };
0183
0184 static int ntb_msit_dbgfs_trigger(void *data, u64 idx)
0185 {
0186     struct ntb_msit_peer *peer = data;
0187
0188     if (idx >= peer->num_irqs)
0189         return -EINVAL;
0190
0191     dev_dbg(&peer->nm->ntb->dev, "trigger irq %llu on peer %u\n",
0192         idx, peer->pidx);
0193
0194     return ntb_msi_peer_trigger(peer->nm->ntb, peer->pidx,
0195                     &peer->msi_desc[idx]);
0196 }
0197
0198 DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_trigger_fops, NULL,
0199              ntb_msit_dbgfs_trigger, "%llu\n");
0200
0201 static int ntb_msit_dbgfs_port_get(void *data, u64 *port)
0202 {
0203     struct ntb_msit_peer *peer = data;
0204
0205     *port = ntb_peer_port_number(peer->nm->ntb, peer->pidx);
0206
0207     return 0;
0208 }
0209
0210 DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_port_fops, ntb_msit_dbgfs_port_get,
0211              NULL, "%llu\n");
0212
0213 static int ntb_msit_dbgfs_count_get(void *data, u64 *count)
0214 {
0215     struct ntb_msit_peer *peer = data;
0216
0217     *count = peer->num_irqs;
0218
0219     return 0;
0220 }
0221
0222 DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_count_fops, ntb_msit_dbgfs_count_get,
0223              NULL, "%llu\n");
0224
0225 static int ntb_msit_dbgfs_ready_get(void *data, u64 *ready)
0226 {
0227     struct ntb_msit_peer *peer = data;
0228
0229     *ready = try_wait_for_completion(&peer->init_comp);
0230
0231     return 0;
0232 }
0233
0234 static int ntb_msit_dbgfs_ready_set(void *data, u64 ready)
0235 {
0236     struct ntb_msit_peer *peer = data;
0237
0238     return wait_for_completion_interruptible(&peer->init_comp);
0239 }
0240
0241 DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_ready_fops, ntb_msit_dbgfs_ready_get,
0242              ntb_msit_dbgfs_ready_set, "%llu\n");
0243
0244 static int ntb_msit_dbgfs_occurrences_get(void *data, u64 *occurrences)
0245 {
0246     struct ntb_msit_isr_ctx *isr_ctx = data;
0247
0248     *occurrences = isr_ctx->occurrences;
0249
0250     return 0;
0251 }
0252
0253 DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_occurrences_fops,
0254              ntb_msit_dbgfs_occurrences_get,
0255              NULL, "%llu\n");
0256
0257 static int ntb_msit_dbgfs_local_port_get(void *data, u64 *port)
0258 {
0259     struct ntb_msit_ctx *nm = data;
0260
0261     *port = ntb_port_number(nm->ntb);
0262
0263     return 0;
0264 }
0265
0266 DEFINE_DEBUGFS_ATTRIBUTE(ntb_msit_local_port_fops,
0267              ntb_msit_dbgfs_local_port_get,
0268              NULL, "%llu\n");
0269
0270 static void ntb_msit_create_dbgfs(struct ntb_msit_ctx *nm)
0271 {
0272     struct pci_dev *pdev = nm->ntb->pdev;
0273     char buf[32];
0274     int i;
0275     struct dentry *peer_dir;
0276
0277     nm->dbgfs_dir = debugfs_create_dir(pci_name(pdev),
0278                        ntb_msit_dbgfs_topdir);
0279     debugfs_create_file("port", 0400, nm->dbgfs_dir, nm,
0280                 &ntb_msit_local_port_fops);
0281
0282     for (i = 0; i < ntb_peer_port_count(nm->ntb); i++) {
0283         nm->peers[i].pidx = i;
0284         nm->peers[i].nm = nm;
0285         init_completion(&nm->peers[i].init_comp);
0286
0287         snprintf(buf, sizeof(buf), "peer%d", i);
0288         peer_dir = debugfs_create_dir(buf, nm->dbgfs_dir);
0289
0290         debugfs_create_file_unsafe("trigger", 0200, peer_dir,
0291                        &nm->peers[i],
0292                        &ntb_msit_trigger_fops);
0293
0294         debugfs_create_file_unsafe("port", 0400, peer_dir,
0295                        &nm->peers[i], &ntb_msit_port_fops);
0296
0297         debugfs_create_file_unsafe("count", 0400, peer_dir,
0298                        &nm->peers[i],
0299                        &ntb_msit_count_fops);
0300
0301         debugfs_create_file_unsafe("ready", 0600, peer_dir,
0302                        &nm->peers[i],
0303                        &ntb_msit_ready_fops);
0304     }
0305
0306     for (i = 0; i < num_irqs; i++) {
0307         snprintf(buf, sizeof(buf), "irq%d_occurrences", i);
0308         debugfs_create_file_unsafe(buf, 0400, nm->dbgfs_dir,
0309                        &nm->isr_ctx[i],
0310                        &ntb_msit_occurrences_fops);
0311     }
0312 }
0313
0314 static void ntb_msit_remove_dbgfs(struct ntb_msit_ctx *nm)
0315 {
0316     debugfs_remove_recursive(nm->dbgfs_dir);
0317 }
0318
0319 static int ntb_msit_probe(struct ntb_client *client, struct ntb_dev *ntb)
0320 {
0321     struct ntb_msit_ctx *nm;
0322     int peers;
0323     int ret;
0324
0325     peers = ntb_peer_port_count(ntb);
0326     if (peers <= 0)
0327         return -EINVAL;
0328
0329     if (ntb_spad_is_unsafe(ntb) || ntb_spad_count(ntb) < 2 * num_irqs + 1) {
0330         dev_err(&ntb->dev, "NTB MSI test requires at least %d spads for %d irqs\n",
0331             2 * num_irqs + 1, num_irqs);
0332         return -EFAULT;
0333     }
0334
0335     ret = ntb_spad_write(ntb, 0, -1);
0336     if (ret) {
0337         dev_err(&ntb->dev, "Unable to write spads: %d\n", ret);
0338         return ret;
0339     }
0340
0341     ret = ntb_db_clear_mask(ntb, GENMASK(peers - 1, 0));
0342     if (ret) {
0343         dev_err(&ntb->dev, "Unable to clear doorbell mask: %d\n", ret);
0344         return ret;
0345     }
0346
0347     ret = ntb_msi_init(ntb, ntb_msit_desc_changed);
0348     if (ret) {
0349         dev_err(&ntb->dev, "Unable to initialize MSI library: %d\n",
0350             ret);
0351         return ret;
0352     }
0353
0354     nm = devm_kzalloc(&ntb->dev, struct_size(nm, peers, peers), GFP_KERNEL);
0355     if (!nm)
0356         return -ENOMEM;
0357
0358     nm->isr_ctx = devm_kcalloc(&ntb->dev, num_irqs, sizeof(*nm->isr_ctx),
0359                    GFP_KERNEL);
0360     if (!nm->isr_ctx)
0361         return -ENOMEM;
0362
0363     INIT_WORK(&nm->setup_work, ntb_msit_setup_work);
0364     nm->ntb = ntb;
0365
0366     ntb_msit_create_dbgfs(nm);
0367
0368     ret = ntb_set_ctx(ntb, nm, &ntb_msit_ops);
0369     if (ret)
0370         goto remove_dbgfs;
0371
0372     if (!nm->isr_ctx) {
0373         ret = -ENOMEM;
0374         goto remove_dbgfs;
0375     }
0376
0377     ntb_link_enable(ntb, NTB_SPEED_AUTO, NTB_WIDTH_AUTO);
0378
0379     return 0;
0380
0381 remove_dbgfs:
0382     ntb_msit_remove_dbgfs(nm);
0383     devm_kfree(&ntb->dev, nm->isr_ctx);
0384     devm_kfree(&ntb->dev, nm);
0385     return ret;
0386 }
0387
0388 static void ntb_msit_remove(struct ntb_client *client, struct ntb_dev *ntb)
0389 {
0390     struct ntb_msit_ctx *nm = ntb->ctx;
0391     int i;
0392
0393     ntb_link_disable(ntb);
0394     ntb_db_set_mask(ntb, ntb_db_valid_mask(ntb));
0395     ntb_msi_clear_mws(ntb);
0396
0397     for (i = 0; i < ntb_peer_port_count(ntb); i++)
0398         kfree(nm->peers[i].msi_desc);
0399
0400     ntb_clear_ctx(ntb);
0401     ntb_msit_remove_dbgfs(nm);
0402 }
0403
0404 static struct ntb_client ntb_msit_client = {
0405     .ops = {
0406         .probe = ntb_msit_probe,
0407         .remove = ntb_msit_remove
0408     }
0409 };
0410
0411 static int __init ntb_msit_init(void)
0412 {
0413     int ret;
0414
0415     if (debugfs_initialized())
0416         ntb_msit_dbgfs_topdir = debugfs_create_dir(KBUILD_MODNAME,
0417                                NULL);
0418
0419     ret = ntb_register_client(&ntb_msit_client);
0420     if (ret)
0421         debugfs_remove_recursive(ntb_msit_dbgfs_topdir);
0422
0423     return ret;
0424 }
0425 module_init(ntb_msit_init);
0426
0427 static void __exit ntb_msit_exit(void)
0428 {
0429     ntb_unregister_client(&ntb_msit_client);
0430     debugfs_remove_recursive(ntb_msit_dbgfs_topdir);
0431 }
0432 module_exit(ntb_msit_exit);