1 // SPDX-License-Identifier: (GPL-2.0 OR BSD-3-Clause)
4 #include <linux/module.h>
9 MODULE_LICENSE("Dual BSD/GPL");
10 MODULE_VERSION("0.1");
11 MODULE_AUTHOR("Logan Gunthorpe <logang@deltatee.com>");
12 MODULE_DESCRIPTION("NTB MSI Interrupt Library");
18 void (*desc_changed)(void *ctx);
20 u32 __iomem *peer_mws[];
24 * ntb_msi_init() - Initialize the MSI context
25 * @ntb: NTB device context
27 * This function must be called before any other ntb_msi function.
28 * It initializes the context for MSI operations and maps
29 * the peer memory windows.
31 * This function reserves the last N outbound memory windows (where N
32 * is the number of peers).
34 * Return: Zero on success, otherwise a negative error number.
36 int ntb_msi_init(struct ntb_dev *ntb,
37 void (*desc_changed)(void *ctx))
39 phys_addr_t mw_phys_addr;
40 resource_size_t mw_size;
47 peers = ntb_peer_port_count(ntb);
51 struct_size = sizeof(*ntb->msi) + sizeof(*ntb->msi->peer_mws) * peers;
53 ntb->msi = devm_kzalloc(&ntb->dev, struct_size, GFP_KERNEL);
57 ntb->msi->desc_changed = desc_changed;
59 for (i = 0; i < peers; i++) {
60 peer_widx = ntb_peer_mw_count(ntb) - 1 - i;
62 ret = ntb_peer_mw_get_addr(ntb, peer_widx, &mw_phys_addr,
67 ntb->msi->peer_mws[i] = devm_ioremap(&ntb->dev, mw_phys_addr,
69 if (!ntb->msi->peer_mws[i]) {
78 for (i = 0; i < peers; i++)
79 if (ntb->msi->peer_mws[i])
80 devm_iounmap(&ntb->dev, ntb->msi->peer_mws[i]);
82 devm_kfree(&ntb->dev, ntb->msi);
86 EXPORT_SYMBOL(ntb_msi_init);
89 * ntb_msi_setup_mws() - Initialize the MSI inbound memory windows
90 * @ntb: NTB device context
92 * This function sets up the required inbound memory windows. It should be
93 * called from a work function after a link up event.
95 * Over the entire network, this function will reserves the last N
96 * inbound memory windows for each peer (where N is the number of peers).
98 * ntb_msi_init() must be called before this function.
100 * Return: Zero on success, otherwise a negative error number.
102 int ntb_msi_setup_mws(struct ntb_dev *ntb)
104 struct msi_desc *desc;
107 resource_size_t addr_align, size_align, size_max;
108 resource_size_t mw_size = SZ_32K;
109 resource_size_t mw_min_size = mw_size;
116 desc = first_msi_entry(&ntb->pdev->dev);
117 addr = desc->msg.address_lo + ((uint64_t)desc->msg.address_hi << 32);
119 for (peer = 0; peer < ntb_peer_port_count(ntb); peer++) {
120 peer_widx = ntb_peer_highest_mw_idx(ntb, peer);
124 ret = ntb_mw_get_align(ntb, peer, peer_widx, &addr_align,
129 addr &= ~(addr_align - 1);
132 for (peer = 0; peer < ntb_peer_port_count(ntb); peer++) {
133 peer_widx = ntb_peer_highest_mw_idx(ntb, peer);
139 ret = ntb_mw_get_align(ntb, peer, peer_widx, NULL,
140 &size_align, &size_max);
144 mw_size = round_up(mw_size, size_align);
145 mw_size = max(mw_size, size_max);
146 if (mw_size < mw_min_size)
147 mw_min_size = mw_size;
149 ret = ntb_mw_set_trans(ntb, peer, peer_widx,
155 ntb->msi->base_addr = addr;
156 ntb->msi->end_addr = addr + mw_min_size;
161 for (i = 0; i < peer; i++) {
162 peer_widx = ntb_peer_highest_mw_idx(ntb, peer);
166 ntb_mw_clear_trans(ntb, i, peer_widx);
171 EXPORT_SYMBOL(ntb_msi_setup_mws);
174 * ntb_msi_clear_mws() - Clear all inbound memory windows
175 * @ntb: NTB device context
177 * This function tears down the resources used by ntb_msi_setup_mws().
179 void ntb_msi_clear_mws(struct ntb_dev *ntb)
184 for (peer = 0; peer < ntb_peer_port_count(ntb); peer++) {
185 peer_widx = ntb_peer_highest_mw_idx(ntb, peer);
189 ntb_mw_clear_trans(ntb, peer, peer_widx);
192 EXPORT_SYMBOL(ntb_msi_clear_mws);
194 struct ntb_msi_devres {
196 struct msi_desc *entry;
197 struct ntb_msi_desc *msi_desc;
200 static int ntb_msi_set_desc(struct ntb_dev *ntb, struct msi_desc *entry,
201 struct ntb_msi_desc *msi_desc)
205 addr = entry->msg.address_lo +
206 ((uint64_t)entry->msg.address_hi << 32);
208 if (addr < ntb->msi->base_addr || addr >= ntb->msi->end_addr) {
209 dev_warn_once(&ntb->dev,
210 "IRQ %d: MSI Address not within the memory window (%llx, [%llx %llx])\n",
211 entry->irq, addr, ntb->msi->base_addr,
216 msi_desc->addr_offset = addr - ntb->msi->base_addr;
217 msi_desc->data = entry->msg.data;
222 static void ntb_msi_write_msg(struct msi_desc *entry, void *data)
224 struct ntb_msi_devres *dr = data;
226 WARN_ON(ntb_msi_set_desc(dr->ntb, entry, dr->msi_desc));
228 if (dr->ntb->msi->desc_changed)
229 dr->ntb->msi->desc_changed(dr->ntb->ctx);
232 static void ntbm_msi_callback_release(struct device *dev, void *res)
234 struct ntb_msi_devres *dr = res;
236 dr->entry->write_msi_msg = NULL;
237 dr->entry->write_msi_msg_data = NULL;
240 static int ntbm_msi_setup_callback(struct ntb_dev *ntb, struct msi_desc *entry,
241 struct ntb_msi_desc *msi_desc)
243 struct ntb_msi_devres *dr;
245 dr = devres_alloc(ntbm_msi_callback_release,
246 sizeof(struct ntb_msi_devres), GFP_KERNEL);
252 dr->msi_desc = msi_desc;
254 devres_add(&ntb->dev, dr);
256 dr->entry->write_msi_msg = ntb_msi_write_msg;
257 dr->entry->write_msi_msg_data = dr;
263 * ntbm_msi_request_threaded_irq() - allocate an MSI interrupt
264 * @ntb: NTB device context
265 * @handler: Function to be called when the IRQ occurs
266 * @thread_fn: Function to be called in a threaded interrupt context. NULL
267 * for clients which handle everything in @handler
268 * @devname: An ascii name for the claiming device, dev_name(dev) if NULL
269 * @dev_id: A cookie passed back to the handler function
271 * This function assigns an interrupt handler to an unused
272 * MSI interrupt and returns the descriptor used to trigger
273 * it. The descriptor can then be sent to a peer to trigger
276 * The interrupt resource is managed with devres so it will
277 * be automatically freed when the NTB device is torn down.
279 * If an IRQ allocated with this function needs to be freed
280 * separately, ntbm_free_irq() must be used.
282 * Return: IRQ number assigned on success, otherwise a negative error number.
284 int ntbm_msi_request_threaded_irq(struct ntb_dev *ntb, irq_handler_t handler,
285 irq_handler_t thread_fn,
286 const char *name, void *dev_id,
287 struct ntb_msi_desc *msi_desc)
289 struct msi_desc *entry;
290 struct irq_desc *desc;
296 for_each_pci_msi_entry(entry, ntb->pdev) {
297 desc = irq_to_desc(entry->irq);
301 ret = devm_request_threaded_irq(&ntb->dev, entry->irq, handler,
302 thread_fn, 0, name, dev_id);
306 if (ntb_msi_set_desc(ntb, entry, msi_desc)) {
307 devm_free_irq(&ntb->dev, entry->irq, dev_id);
311 ret = ntbm_msi_setup_callback(ntb, entry, msi_desc);
313 devm_free_irq(&ntb->dev, entry->irq, dev_id);
323 EXPORT_SYMBOL(ntbm_msi_request_threaded_irq);
325 static int ntbm_msi_callback_match(struct device *dev, void *res, void *data)
327 struct ntb_dev *ntb = dev_ntb(dev);
328 struct ntb_msi_devres *dr = res;
330 return dr->ntb == ntb && dr->entry == data;
334 * ntbm_msi_free_irq() - free an interrupt
335 * @ntb: NTB device context
336 * @irq: Interrupt line to free
337 * @dev_id: Device identity to free
339 * This function should be used to manually free IRQs allocated with
340 * ntbm_request_[threaded_]irq().
342 void ntbm_msi_free_irq(struct ntb_dev *ntb, unsigned int irq, void *dev_id)
344 struct msi_desc *entry = irq_get_msi_desc(irq);
346 entry->write_msi_msg = NULL;
347 entry->write_msi_msg_data = NULL;
349 WARN_ON(devres_destroy(&ntb->dev, ntbm_msi_callback_release,
350 ntbm_msi_callback_match, entry));
352 devm_free_irq(&ntb->dev, irq, dev_id);
354 EXPORT_SYMBOL(ntbm_msi_free_irq);
357 * ntb_msi_peer_trigger() - Trigger an interrupt handler on a peer
358 * @ntb: NTB device context
360 * @desc: MSI descriptor data which triggers the interrupt
362 * This function triggers an interrupt on a peer. It requires
363 * the descriptor structure to have been passed from that peer
364 * by some other means.
366 * Return: Zero on success, otherwise a negative error number.
368 int ntb_msi_peer_trigger(struct ntb_dev *ntb, int peer,
369 struct ntb_msi_desc *desc)
376 idx = desc->addr_offset / sizeof(*ntb->msi->peer_mws[peer]);
378 iowrite32(desc->data, &ntb->msi->peer_mws[peer][idx]);
382 EXPORT_SYMBOL(ntb_msi_peer_trigger);
385 * ntb_msi_peer_addr() - Get the DMA address to trigger a peer's MSI interrupt
386 * @ntb: NTB device context
388 * @desc: MSI descriptor data which triggers the interrupt
389 * @msi_addr: Physical address to trigger the interrupt
391 * This function allows using DMA engines to trigger an interrupt
392 * (for example, trigger an interrupt to process the data after
393 * sending it). To trigger the interrupt, write @desc.data to the address
394 * returned in @msi_addr
396 * Return: Zero on success, otherwise a negative error number.
398 int ntb_msi_peer_addr(struct ntb_dev *ntb, int peer,
399 struct ntb_msi_desc *desc,
400 phys_addr_t *msi_addr)
402 int peer_widx = ntb_peer_mw_count(ntb) - 1 - peer;
403 phys_addr_t mw_phys_addr;
406 ret = ntb_peer_mw_get_addr(ntb, peer_widx, &mw_phys_addr, NULL);
411 *msi_addr = mw_phys_addr + desc->addr_offset;
415 EXPORT_SYMBOL(ntb_msi_peer_addr);