1 // SPDX-License-Identifier: GPL-2.0
3 * Endpoint Function Driver to implement Non-Transparent Bridge functionality
4 * Between PCI RC and EP
6 * Copyright (C) 2020 Texas Instruments
7 * Copyright (C) 2022 NXP
9 * Based on pci-epf-ntb.c
10 * Author: Frank Li <Frank.Li@nxp.com>
11 * Author: Kishon Vijay Abraham I <kishon@ti.com>
15 * +------------+ +---------------------------------------+
17 * +------------+ | +--------------+
19 * | NetDev | | | NetDev |
20 * +------------+ | +--------------+
22 * | Transfer | | | Transfer |
23 * +------------+ | +--------------+
27 * | Driver | | | PCI Virtual |
28 * | | +---------------+ | NTB Driver |
29 * | | | PCI EP NTB |<------>| |
30 * | | | FN Driver | | |
31 * +------------+ +---------------+ +--------------+
33 * | PCI Bus | <-----> | PCI EP Bus | | Virtual PCI |
35 * +------------+ +---------------+--------+--------------+
36 * PCIe Root Port PCI EP
39 #include <linux/delay.h>
41 #include <linux/module.h>
42 #include <linux/slab.h>
44 #include <linux/pci-epc.h>
45 #include <linux/pci-epf.h>
46 #include <linux/ntb.h>
48 static struct workqueue_struct *kpcintb_workqueue;
50 #define COMMAND_CONFIGURE_DOORBELL 1
51 #define COMMAND_TEARDOWN_DOORBELL 2
52 #define COMMAND_CONFIGURE_MW 3
53 #define COMMAND_TEARDOWN_MW 4
54 #define COMMAND_LINK_UP 5
55 #define COMMAND_LINK_DOWN 6
57 #define COMMAND_STATUS_OK 1
58 #define COMMAND_STATUS_ERROR 2
60 #define LINK_STATUS_UP BIT(0)
64 #define NTB_MW_OFFSET 2
65 #define DB_COUNT_MASK GENMASK(15, 0)
66 #define MSIX_ENABLE BIT(16)
67 #define MAX_DB_COUNT 32
79 * +--------------------------------------------------+ Base
83 * | Common Control Register |
87 * +-----------------------+--------------------------+ Base+span_offset
89 * | Peer Span Space | Span Space |
92 * +-----------------------+--------------------------+ Base+span_offset
93 * | | | +span_count * 4
95 * | Span Space | Peer Span Space |
97 * +-----------------------+--------------------------+
98 * Virtual PCI PCIe Endpoint
99 * NTB Driver NTB Driver
101 struct epf_ntb_ctrl {
114 u32 db_data[MAX_DB_COUNT];
115 u32 db_offset[MAX_DB_COUNT];
121 struct config_group group;
126 u64 mws_size[MAX_MW];
135 enum pci_barno epf_ntb_bar[6];
137 struct epf_ntb_ctrl *reg;
139 phys_addr_t epf_db_phy;
140 void __iomem *epf_db;
142 phys_addr_t vpci_mw_phy[MAX_MW];
143 void __iomem *vpci_mw_addr[MAX_MW];
145 struct delayed_work cmd_handler;
148 #define to_epf_ntb(epf_group) container_of((epf_group), struct epf_ntb, group)
149 #define ntb_ndev(__ntb) container_of(__ntb, struct epf_ntb, ntb)
151 static struct pci_epf_header epf_ntb_header = {
152 .vendorid = PCI_ANY_ID,
153 .deviceid = PCI_ANY_ID,
154 .baseclass_code = PCI_BASE_CLASS_MEMORY,
155 .interrupt_pin = PCI_INTERRUPT_INTA,
159 * epf_ntb_link_up() - Raise link_up interrupt to Virtual Host (VHOST)
160 * @ntb: NTB device that facilitates communication between HOST and VHOST
161 * @link_up: true or false indicating Link is UP or Down
163 * Once NTB function in HOST invoke ntb_link_enable(),
164 * this NTB function driver will trigger a link event to VHOST.
166 * Returns: Zero for success, or an error code in case of failure
168 static int epf_ntb_link_up(struct epf_ntb *ntb, bool link_up)
171 ntb->reg->link_status |= LINK_STATUS_UP;
173 ntb->reg->link_status &= ~LINK_STATUS_UP;
175 ntb_link_event(&ntb->ntb);
180 * epf_ntb_configure_mw() - Configure the Outbound Address Space for VHOST
181 * to access the memory window of HOST
182 * @ntb: NTB device that facilitates communication between HOST and VHOST
183 * @mw: Index of the memory window (either 0, 1, 2 or 3)
186 * +--------+ +-----------+
192 * | Virtual| | Memory Win|
193 * | NTB | -----------> | |
198 * +--------+ +-----------+
201 * Returns: Zero for success, or an error code in case of failure
203 static int epf_ntb_configure_mw(struct epf_ntb *ntb, u32 mw)
205 phys_addr_t phys_addr;
206 u8 func_no, vfunc_no;
210 phys_addr = ntb->vpci_mw_phy[mw];
211 addr = ntb->reg->addr;
212 size = ntb->reg->size;
214 func_no = ntb->epf->func_no;
215 vfunc_no = ntb->epf->vfunc_no;
217 ret = pci_epc_map_addr(ntb->epf->epc, func_no, vfunc_no, phys_addr, addr, size);
219 dev_err(&ntb->epf->epc->dev,
220 "Failed to map memory window %d address\n", mw);
225 * epf_ntb_teardown_mw() - Teardown the configured OB ATU
226 * @ntb: NTB device that facilitates communication between HOST and VHOST
227 * @mw: Index of the memory window (either 0, 1, 2 or 3)
229 * Teardown the configured OB ATU configured in epf_ntb_configure_mw() using
230 * pci_epc_unmap_addr()
232 static void epf_ntb_teardown_mw(struct epf_ntb *ntb, u32 mw)
234 pci_epc_unmap_addr(ntb->epf->epc,
237 ntb->vpci_mw_phy[mw]);
241 * epf_ntb_cmd_handler() - Handle commands provided by the NTB HOST
242 * @work: work_struct for the epf_ntb_epc
244 * Workqueue function that gets invoked for the two epf_ntb_epc
245 * periodically (once every 5ms) to see if it has received any commands
246 * from NTB HOST. The HOST can send commands to configure doorbell or
247 * configure memory window or to update link status.
249 static void epf_ntb_cmd_handler(struct work_struct *work)
251 struct epf_ntb_ctrl *ctrl;
252 u32 command, argument;
258 ntb = container_of(work, struct epf_ntb, cmd_handler.work);
260 for (i = 1; i < ntb->db_count; i++) {
261 if (readl(ntb->epf_db + i * 4)) {
262 if (readl(ntb->epf_db + i * 4))
263 ntb->db |= 1 << (i - 1);
265 ntb_db_event(&ntb->ntb, i);
266 writel(0, ntb->epf_db + i * 4);
271 command = ctrl->command;
274 argument = ctrl->argument;
280 dev = &ntb->epf->dev;
283 case COMMAND_CONFIGURE_DOORBELL:
284 ctrl->command_status = COMMAND_STATUS_OK;
286 case COMMAND_TEARDOWN_DOORBELL:
287 ctrl->command_status = COMMAND_STATUS_OK;
289 case COMMAND_CONFIGURE_MW:
290 ret = epf_ntb_configure_mw(ntb, argument);
292 ctrl->command_status = COMMAND_STATUS_ERROR;
294 ctrl->command_status = COMMAND_STATUS_OK;
296 case COMMAND_TEARDOWN_MW:
297 epf_ntb_teardown_mw(ntb, argument);
298 ctrl->command_status = COMMAND_STATUS_OK;
300 case COMMAND_LINK_UP:
302 ret = epf_ntb_link_up(ntb, true);
304 ctrl->command_status = COMMAND_STATUS_ERROR;
306 ctrl->command_status = COMMAND_STATUS_OK;
308 case COMMAND_LINK_DOWN:
310 ret = epf_ntb_link_up(ntb, false);
312 ctrl->command_status = COMMAND_STATUS_ERROR;
314 ctrl->command_status = COMMAND_STATUS_OK;
317 dev_err(dev, "UNKNOWN command: %d\n", command);
322 queue_delayed_work(kpcintb_workqueue, &ntb->cmd_handler,
323 msecs_to_jiffies(5));
327 * epf_ntb_config_sspad_bar_clear() - Clear Config + Self scratchpad BAR
328 * @ntb: EPC associated with one of the HOST which holds peer's outbound
331 * Clear BAR0 of EP CONTROLLER 1 which contains the HOST1's config and
332 * self scratchpad region (removes inbound ATU configuration). While BAR0 is
333 * the default self scratchpad BAR, an NTB could have other BARs for self
334 * scratchpad (because of reserved BARs). This function can get the exact BAR
335 * used for self scratchpad from epf_ntb_bar[BAR_CONFIG].
337 * Please note the self scratchpad region and config region is combined to
338 * a single region and mapped using the same BAR. Also note VHOST's peer
339 * scratchpad is HOST's self scratchpad.
343 static void epf_ntb_config_sspad_bar_clear(struct epf_ntb *ntb)
345 struct pci_epf_bar *epf_bar;
346 enum pci_barno barno;
348 barno = ntb->epf_ntb_bar[BAR_CONFIG];
349 epf_bar = &ntb->epf->bar[barno];
351 pci_epc_clear_bar(ntb->epf->epc, ntb->epf->func_no, ntb->epf->vfunc_no, epf_bar);
355 * epf_ntb_config_sspad_bar_set() - Set Config + Self scratchpad BAR
356 * @ntb: NTB device that facilitates communication between HOST and VHOST
358 * Map BAR0 of EP CONTROLLER which contains the VHOST's config and
359 * self scratchpad region.
361 * Please note the self scratchpad region and config region is combined to
362 * a single region and mapped using the same BAR.
364 * Returns: Zero for success, or an error code in case of failure
366 static int epf_ntb_config_sspad_bar_set(struct epf_ntb *ntb)
368 struct pci_epf_bar *epf_bar;
369 enum pci_barno barno;
370 u8 func_no, vfunc_no;
374 dev = &ntb->epf->dev;
375 func_no = ntb->epf->func_no;
376 vfunc_no = ntb->epf->vfunc_no;
377 barno = ntb->epf_ntb_bar[BAR_CONFIG];
378 epf_bar = &ntb->epf->bar[barno];
380 ret = pci_epc_set_bar(ntb->epf->epc, func_no, vfunc_no, epf_bar);
382 dev_err(dev, "inft: Config/Status/SPAD BAR set failed\n");
389 * epf_ntb_config_spad_bar_free() - Free the physical memory associated with
390 * config + scratchpad region
391 * @ntb: NTB device that facilitates communication between HOST and VHOST
393 static void epf_ntb_config_spad_bar_free(struct epf_ntb *ntb)
395 enum pci_barno barno;
397 barno = ntb->epf_ntb_bar[BAR_CONFIG];
398 pci_epf_free_space(ntb->epf, ntb->reg, barno, 0);
402 * epf_ntb_config_spad_bar_alloc() - Allocate memory for config + scratchpad
404 * @ntb: NTB device that facilitates communication between HOST and VHOST
406 * Allocate the Local Memory mentioned in the above diagram. The size of
407 * CONFIG REGION is sizeof(struct epf_ntb_ctrl) and size of SCRATCHPAD REGION
408 * is obtained from "spad-count" configfs entry.
410 * Returns: Zero for success, or an error code in case of failure
412 static int epf_ntb_config_spad_bar_alloc(struct epf_ntb *ntb)
415 enum pci_barno barno;
416 struct epf_ntb_ctrl *ctrl;
417 u32 spad_size, ctrl_size;
419 struct pci_epf *epf = ntb->epf;
420 struct device *dev = &epf->dev;
424 const struct pci_epc_features *epc_features = pci_epc_get_features(epf->epc,
427 barno = ntb->epf_ntb_bar[BAR_CONFIG];
428 size = epc_features->bar_fixed_size[barno];
429 align = epc_features->align;
431 if ((!IS_ALIGNED(size, align)))
434 spad_count = ntb->spad_count;
436 ctrl_size = sizeof(struct epf_ntb_ctrl);
437 spad_size = 2 * spad_count * 4;
440 ctrl_size = roundup_pow_of_two(ctrl_size);
441 spad_size = roundup_pow_of_two(spad_size);
443 ctrl_size = ALIGN(ctrl_size, align);
444 spad_size = ALIGN(spad_size, align);
448 size = ctrl_size + spad_size;
449 else if (size < ctrl_size + spad_size)
452 base = pci_epf_alloc_space(epf, size, barno, align, 0);
454 dev_err(dev, "Config/Status/SPAD alloc region fail\n");
461 ctrl->spad_offset = ctrl_size;
463 ctrl->spad_count = spad_count;
464 ctrl->num_mws = ntb->num_mws;
465 ntb->spad_size = spad_size;
467 ctrl->db_entry_size = 4;
469 for (i = 0; i < ntb->db_count; i++) {
470 ntb->reg->db_data[i] = 1 + i;
471 ntb->reg->db_offset[i] = 0;
478 * epf_ntb_configure_interrupt() - Configure MSI/MSI-X capability
479 * @ntb: NTB device that facilitates communication between HOST and VHOST
481 * Configure MSI/MSI-X capability for each interface with number of
482 * interrupts equal to "db_count" configfs entry.
484 * Returns: Zero for success, or an error code in case of failure
486 static int epf_ntb_configure_interrupt(struct epf_ntb *ntb)
488 const struct pci_epc_features *epc_features;
493 dev = &ntb->epf->dev;
495 epc_features = pci_epc_get_features(ntb->epf->epc, ntb->epf->func_no, ntb->epf->vfunc_no);
497 if (!(epc_features->msix_capable || epc_features->msi_capable)) {
498 dev_err(dev, "MSI or MSI-X is required for doorbell\n");
502 db_count = ntb->db_count;
503 if (db_count > MAX_DB_COUNT) {
504 dev_err(dev, "DB count cannot be more than %d\n", MAX_DB_COUNT);
508 ntb->db_count = db_count;
510 if (epc_features->msi_capable) {
511 ret = pci_epc_set_msi(ntb->epf->epc,
516 dev_err(dev, "MSI configuration failed\n");
525 * epf_ntb_db_bar_init() - Configure Doorbell window BARs
526 * @ntb: NTB device that facilitates communication between HOST and VHOST
528 * Returns: Zero for success, or an error code in case of failure
530 static int epf_ntb_db_bar_init(struct epf_ntb *ntb)
532 const struct pci_epc_features *epc_features;
534 struct device *dev = &ntb->epf->dev;
536 struct pci_epf_bar *epf_bar;
537 void __iomem *mw_addr;
538 enum pci_barno barno;
539 size_t size = 4 * ntb->db_count;
541 epc_features = pci_epc_get_features(ntb->epf->epc,
544 align = epc_features->align;
550 size = ALIGN(size, align);
552 size = roundup_pow_of_two(size);
554 barno = ntb->epf_ntb_bar[BAR_DB];
556 mw_addr = pci_epf_alloc_space(ntb->epf, size, barno, align, 0);
558 dev_err(dev, "Failed to allocate OB address\n");
562 ntb->epf_db = mw_addr;
564 epf_bar = &ntb->epf->bar[barno];
566 ret = pci_epc_set_bar(ntb->epf->epc, ntb->epf->func_no, ntb->epf->vfunc_no, epf_bar);
568 dev_err(dev, "Doorbell BAR set failed\n");
569 goto err_alloc_peer_mem;
574 pci_epc_mem_free_addr(ntb->epf->epc, epf_bar->phys_addr, mw_addr, epf_bar->size);
578 static void epf_ntb_mw_bar_clear(struct epf_ntb *ntb, int num_mws);
581 * epf_ntb_db_bar_clear() - Clear doorbell BAR and free memory
582 * allocated in peer's outbound address space
583 * @ntb: NTB device that facilitates communication between HOST and VHOST
585 static void epf_ntb_db_bar_clear(struct epf_ntb *ntb)
587 enum pci_barno barno;
589 barno = ntb->epf_ntb_bar[BAR_DB];
590 pci_epf_free_space(ntb->epf, ntb->epf_db, barno, 0);
591 pci_epc_clear_bar(ntb->epf->epc,
594 &ntb->epf->bar[barno]);
598 * epf_ntb_mw_bar_init() - Configure Memory window BARs
599 * @ntb: NTB device that facilitates communication between HOST and VHOST
601 * Returns: Zero for success, or an error code in case of failure
603 static int epf_ntb_mw_bar_init(struct epf_ntb *ntb)
608 enum pci_barno barno;
609 struct device *dev = &ntb->epf->dev;
611 for (i = 0; i < ntb->num_mws; i++) {
612 size = ntb->mws_size[i];
613 barno = ntb->epf_ntb_bar[BAR_MW0 + i];
615 ntb->epf->bar[barno].barno = barno;
616 ntb->epf->bar[barno].size = size;
617 ntb->epf->bar[barno].addr = NULL;
618 ntb->epf->bar[barno].phys_addr = 0;
619 ntb->epf->bar[barno].flags |= upper_32_bits(size) ?
620 PCI_BASE_ADDRESS_MEM_TYPE_64 :
621 PCI_BASE_ADDRESS_MEM_TYPE_32;
623 ret = pci_epc_set_bar(ntb->epf->epc,
626 &ntb->epf->bar[barno]);
628 dev_err(dev, "MW set failed\n");
632 /* Allocate EPC outbound memory windows to vpci vntb device */
633 ntb->vpci_mw_addr[i] = pci_epc_mem_alloc_addr(ntb->epf->epc,
634 &ntb->vpci_mw_phy[i],
636 if (!ntb->vpci_mw_addr[i]) {
638 dev_err(dev, "Failed to allocate source address\n");
646 pci_epc_clear_bar(ntb->epf->epc,
649 &ntb->epf->bar[barno]);
651 epf_ntb_mw_bar_clear(ntb, i);
656 * epf_ntb_mw_bar_clear() - Clear Memory window BARs
657 * @ntb: NTB device that facilitates communication between HOST and VHOST
659 static void epf_ntb_mw_bar_clear(struct epf_ntb *ntb, int num_mws)
661 enum pci_barno barno;
664 for (i = 0; i < num_mws; i++) {
665 barno = ntb->epf_ntb_bar[BAR_MW0 + i];
666 pci_epc_clear_bar(ntb->epf->epc,
669 &ntb->epf->bar[barno]);
671 pci_epc_mem_free_addr(ntb->epf->epc,
673 ntb->vpci_mw_addr[i],
679 * epf_ntb_epc_destroy() - Cleanup NTB EPC interface
680 * @ntb: NTB device that facilitates communication between HOST and VHOST
682 * Wrapper for epf_ntb_epc_destroy_interface() to cleanup all the NTB interfaces
684 static void epf_ntb_epc_destroy(struct epf_ntb *ntb)
686 pci_epc_remove_epf(ntb->epf->epc, ntb->epf, 0);
687 pci_epc_put(ntb->epf->epc);
691 * epf_ntb_init_epc_bar() - Identify BARs to be used for each of the NTB
692 * constructs (scratchpad region, doorbell, memorywindow)
693 * @ntb: NTB device that facilitates communication between HOST and VHOST
695 * Returns: Zero for success, or an error code in case of failure
697 static int epf_ntb_init_epc_bar(struct epf_ntb *ntb)
699 const struct pci_epc_features *epc_features;
700 enum pci_barno barno;
701 enum epf_ntb_bar bar;
707 num_mws = ntb->num_mws;
708 dev = &ntb->epf->dev;
709 epc_features = pci_epc_get_features(ntb->epf->epc, ntb->epf->func_no, ntb->epf->vfunc_no);
711 /* These are required BARs which are mandatory for NTB functionality */
712 for (bar = BAR_CONFIG; bar <= BAR_MW0; bar++, barno++) {
713 barno = pci_epc_get_next_free_bar(epc_features, barno);
715 dev_err(dev, "Fail to get NTB function BAR\n");
718 ntb->epf_ntb_bar[bar] = barno;
721 /* These are optional BARs which don't impact NTB functionality */
722 for (bar = BAR_MW1, i = 1; i < num_mws; bar++, barno++, i++) {
723 barno = pci_epc_get_next_free_bar(epc_features, barno);
726 dev_dbg(dev, "BAR not available for > MW%d\n", i + 1);
728 ntb->epf_ntb_bar[bar] = barno;
735 * epf_ntb_epc_init() - Initialize NTB interface
736 * @ntb: NTB device that facilitates communication between HOST and VHOST
738 * Wrapper to initialize a particular EPC interface and start the workqueue
739 * to check for commands from HOST. This function will write to the
740 * EP controller HW for configuring it.
742 * Returns: Zero for success, or an error code in case of failure
744 static int epf_ntb_epc_init(struct epf_ntb *ntb)
746 u8 func_no, vfunc_no;
755 func_no = ntb->epf->func_no;
756 vfunc_no = ntb->epf->vfunc_no;
758 ret = epf_ntb_config_sspad_bar_set(ntb);
760 dev_err(dev, "Config/self SPAD BAR init failed");
764 ret = epf_ntb_configure_interrupt(ntb);
766 dev_err(dev, "Interrupt configuration failed\n");
767 goto err_config_interrupt;
770 ret = epf_ntb_db_bar_init(ntb);
772 dev_err(dev, "DB BAR init failed\n");
773 goto err_db_bar_init;
776 ret = epf_ntb_mw_bar_init(ntb);
778 dev_err(dev, "MW BAR init failed\n");
779 goto err_mw_bar_init;
783 ret = pci_epc_write_header(epc, func_no, vfunc_no, epf->header);
785 dev_err(dev, "Configuration header write failed\n");
786 goto err_write_header;
790 INIT_DELAYED_WORK(&ntb->cmd_handler, epf_ntb_cmd_handler);
791 queue_work(kpcintb_workqueue, &ntb->cmd_handler.work);
796 epf_ntb_mw_bar_clear(ntb, ntb->num_mws);
798 epf_ntb_db_bar_clear(ntb);
800 err_config_interrupt:
801 epf_ntb_config_sspad_bar_clear(ntb);
808 * epf_ntb_epc_cleanup() - Cleanup all NTB interfaces
809 * @ntb: NTB device that facilitates communication between HOST and VHOST
811 * Wrapper to cleanup all NTB interfaces.
813 static void epf_ntb_epc_cleanup(struct epf_ntb *ntb)
815 epf_ntb_db_bar_clear(ntb);
816 epf_ntb_mw_bar_clear(ntb, ntb->num_mws);
819 #define EPF_NTB_R(_name) \
820 static ssize_t epf_ntb_##_name##_show(struct config_item *item, \
823 struct config_group *group = to_config_group(item); \
824 struct epf_ntb *ntb = to_epf_ntb(group); \
826 return sprintf(page, "%d\n", ntb->_name); \
829 #define EPF_NTB_W(_name) \
830 static ssize_t epf_ntb_##_name##_store(struct config_item *item, \
831 const char *page, size_t len) \
833 struct config_group *group = to_config_group(item); \
834 struct epf_ntb *ntb = to_epf_ntb(group); \
838 ret = kstrtou32(page, 0, &val); \
847 #define EPF_NTB_MW_R(_name) \
848 static ssize_t epf_ntb_##_name##_show(struct config_item *item, \
851 struct config_group *group = to_config_group(item); \
852 struct epf_ntb *ntb = to_epf_ntb(group); \
853 struct device *dev = &ntb->epf->dev; \
856 if (sscanf(#_name, "mw%d", &win_no) != 1) \
859 if (win_no <= 0 || win_no > ntb->num_mws) { \
860 dev_err(dev, "Invalid num_nws: %d value\n", ntb->num_mws); \
864 return sprintf(page, "%lld\n", ntb->mws_size[win_no - 1]); \
867 #define EPF_NTB_MW_W(_name) \
868 static ssize_t epf_ntb_##_name##_store(struct config_item *item, \
869 const char *page, size_t len) \
871 struct config_group *group = to_config_group(item); \
872 struct epf_ntb *ntb = to_epf_ntb(group); \
873 struct device *dev = &ntb->epf->dev; \
878 ret = kstrtou64(page, 0, &val); \
882 if (sscanf(#_name, "mw%d", &win_no) != 1) \
885 if (win_no <= 0 || win_no > ntb->num_mws) { \
886 dev_err(dev, "Invalid num_nws: %d value\n", ntb->num_mws); \
890 ntb->mws_size[win_no - 1] = val; \
895 static ssize_t epf_ntb_num_mws_store(struct config_item *item,
896 const char *page, size_t len)
898 struct config_group *group = to_config_group(item);
899 struct epf_ntb *ntb = to_epf_ntb(group);
903 ret = kstrtou32(page, 0, &val);
915 EPF_NTB_R(spad_count)
916 EPF_NTB_W(spad_count)
920 EPF_NTB_R(vbus_number)
921 EPF_NTB_W(vbus_number)
935 CONFIGFS_ATTR(epf_ntb_, spad_count);
936 CONFIGFS_ATTR(epf_ntb_, db_count);
937 CONFIGFS_ATTR(epf_ntb_, num_mws);
938 CONFIGFS_ATTR(epf_ntb_, mw1);
939 CONFIGFS_ATTR(epf_ntb_, mw2);
940 CONFIGFS_ATTR(epf_ntb_, mw3);
941 CONFIGFS_ATTR(epf_ntb_, mw4);
942 CONFIGFS_ATTR(epf_ntb_, vbus_number);
943 CONFIGFS_ATTR(epf_ntb_, vntb_pid);
944 CONFIGFS_ATTR(epf_ntb_, vntb_vid);
946 static struct configfs_attribute *epf_ntb_attrs[] = {
947 &epf_ntb_attr_spad_count,
948 &epf_ntb_attr_db_count,
949 &epf_ntb_attr_num_mws,
954 &epf_ntb_attr_vbus_number,
955 &epf_ntb_attr_vntb_pid,
956 &epf_ntb_attr_vntb_vid,
960 static const struct config_item_type ntb_group_type = {
961 .ct_attrs = epf_ntb_attrs,
962 .ct_owner = THIS_MODULE,
966 * epf_ntb_add_cfs() - Add configfs directory specific to NTB
967 * @epf: NTB endpoint function device
968 * @group: A pointer to the config_group structure referencing a group of
969 * config_items of a specific type that belong to a specific sub-system.
971 * Add configfs directory specific to NTB. This directory will hold
972 * NTB specific properties like db_count, spad_count, num_mws etc.,
974 * Returns: Pointer to config_group
976 static struct config_group *epf_ntb_add_cfs(struct pci_epf *epf,
977 struct config_group *group)
979 struct epf_ntb *ntb = epf_get_drvdata(epf);
980 struct config_group *ntb_group = &ntb->group;
981 struct device *dev = &epf->dev;
983 config_group_init_type_name(ntb_group, dev_name(dev), &ntb_group_type);
988 /*==== virtual PCI bus driver, which only load virtual NTB PCI driver ====*/
990 static u32 pci_space[] = {
991 0xffffffff, /*DeviceID, Vendor ID*/
992 0, /*Status, Command*/
993 0xffffffff, /*Class code, subclass, prog if, revision id*/
994 0x40, /*bist, header type, latency Timer, cache line size*/
1001 0, /*Cardbus cis point*/
1002 0, /*Subsystem ID Subystem vendor id*/
1003 0, /*ROM Base Address*/
1004 0, /*Reserved, Cap. Point*/
1006 0, /*Max Lat, Min Gnt, interrupt pin, interrupt line*/
1009 static int pci_read(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val)
1012 memcpy(val, ((u8 *)pci_space) + where, size);
1013 return PCIBIOS_SUCCESSFUL;
1015 return PCIBIOS_DEVICE_NOT_FOUND;
1018 static int pci_write(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val)
1023 static struct pci_ops vpci_ops = {
1028 static int vpci_scan_bus(void *sysdata)
1030 struct pci_bus *vpci_bus;
1031 struct epf_ntb *ndev = sysdata;
1033 vpci_bus = pci_scan_bus(ndev->vbus_number, &vpci_ops, sysdata);
1035 pr_err("create pci bus\n");
1037 pci_bus_add_devices(vpci_bus);
1042 /*==================== Virtual PCIe NTB driver ==========================*/
1044 static int vntb_epf_mw_count(struct ntb_dev *ntb, int pidx)
1046 struct epf_ntb *ndev = ntb_ndev(ntb);
1048 return ndev->num_mws;
1051 static int vntb_epf_spad_count(struct ntb_dev *ntb)
1053 return ntb_ndev(ntb)->spad_count;
1056 static int vntb_epf_peer_mw_count(struct ntb_dev *ntb)
1058 return ntb_ndev(ntb)->num_mws;
1061 static u64 vntb_epf_db_valid_mask(struct ntb_dev *ntb)
1063 return BIT_ULL(ntb_ndev(ntb)->db_count) - 1;
1066 static int vntb_epf_db_set_mask(struct ntb_dev *ntb, u64 db_bits)
1071 static int vntb_epf_mw_set_trans(struct ntb_dev *ndev, int pidx, int idx,
1072 dma_addr_t addr, resource_size_t size)
1074 struct epf_ntb *ntb = ntb_ndev(ndev);
1075 struct pci_epf_bar *epf_bar;
1076 enum pci_barno barno;
1080 dev = &ntb->ntb.dev;
1081 barno = ntb->epf_ntb_bar[BAR_MW0 + idx];
1082 epf_bar = &ntb->epf->bar[barno];
1083 epf_bar->phys_addr = addr;
1084 epf_bar->barno = barno;
1085 epf_bar->size = size;
1087 ret = pci_epc_set_bar(ntb->epf->epc, 0, 0, epf_bar);
1089 dev_err(dev, "failure set mw trans\n");
1095 static int vntb_epf_mw_clear_trans(struct ntb_dev *ntb, int pidx, int idx)
1100 static int vntb_epf_peer_mw_get_addr(struct ntb_dev *ndev, int idx,
1101 phys_addr_t *base, resource_size_t *size)
1104 struct epf_ntb *ntb = ntb_ndev(ndev);
1107 *base = ntb->vpci_mw_phy[idx];
1110 *size = ntb->mws_size[idx];
1115 static int vntb_epf_link_enable(struct ntb_dev *ntb,
1116 enum ntb_speed max_speed,
1117 enum ntb_width max_width)
1122 static u32 vntb_epf_spad_read(struct ntb_dev *ndev, int idx)
1124 struct epf_ntb *ntb = ntb_ndev(ndev);
1125 int off = ntb->reg->spad_offset, ct = ntb->reg->spad_count * 4;
1127 void __iomem *base = ntb->reg;
1129 val = readl(base + off + ct + idx * 4);
1133 static int vntb_epf_spad_write(struct ntb_dev *ndev, int idx, u32 val)
1135 struct epf_ntb *ntb = ntb_ndev(ndev);
1136 struct epf_ntb_ctrl *ctrl = ntb->reg;
1137 int off = ctrl->spad_offset, ct = ctrl->spad_count * 4;
1138 void __iomem *base = ntb->reg;
1140 writel(val, base + off + ct + idx * 4);
1144 static u32 vntb_epf_peer_spad_read(struct ntb_dev *ndev, int pidx, int idx)
1146 struct epf_ntb *ntb = ntb_ndev(ndev);
1147 struct epf_ntb_ctrl *ctrl = ntb->reg;
1148 int off = ctrl->spad_offset;
1149 void __iomem *base = ntb->reg;
1152 val = readl(base + off + idx * 4);
1156 static int vntb_epf_peer_spad_write(struct ntb_dev *ndev, int pidx, int idx, u32 val)
1158 struct epf_ntb *ntb = ntb_ndev(ndev);
1159 struct epf_ntb_ctrl *ctrl = ntb->reg;
1160 int off = ctrl->spad_offset;
1161 void __iomem *base = ntb->reg;
1163 writel(val, base + off + idx * 4);
1167 static int vntb_epf_peer_db_set(struct ntb_dev *ndev, u64 db_bits)
1169 u32 interrupt_num = ffs(db_bits) + 1;
1170 struct epf_ntb *ntb = ntb_ndev(ndev);
1171 u8 func_no, vfunc_no;
1174 func_no = ntb->epf->func_no;
1175 vfunc_no = ntb->epf->vfunc_no;
1177 ret = pci_epc_raise_irq(ntb->epf->epc,
1183 dev_err(&ntb->ntb.dev, "Failed to raise IRQ\n");
1188 static u64 vntb_epf_db_read(struct ntb_dev *ndev)
1190 struct epf_ntb *ntb = ntb_ndev(ndev);
1195 static int vntb_epf_mw_get_align(struct ntb_dev *ndev, int pidx, int idx,
1196 resource_size_t *addr_align,
1197 resource_size_t *size_align,
1198 resource_size_t *size_max)
1200 struct epf_ntb *ntb = ntb_ndev(ndev);
1203 *addr_align = SZ_4K;
1209 *size_max = ntb->mws_size[idx];
1214 static u64 vntb_epf_link_is_up(struct ntb_dev *ndev,
1215 enum ntb_speed *speed,
1216 enum ntb_width *width)
1218 struct epf_ntb *ntb = ntb_ndev(ndev);
1220 return ntb->reg->link_status;
1223 static int vntb_epf_db_clear_mask(struct ntb_dev *ndev, u64 db_bits)
1228 static int vntb_epf_db_clear(struct ntb_dev *ndev, u64 db_bits)
1230 struct epf_ntb *ntb = ntb_ndev(ndev);
1232 ntb->db &= ~db_bits;
1236 static int vntb_epf_link_disable(struct ntb_dev *ntb)
1241 static const struct ntb_dev_ops vntb_epf_ops = {
1242 .mw_count = vntb_epf_mw_count,
1243 .spad_count = vntb_epf_spad_count,
1244 .peer_mw_count = vntb_epf_peer_mw_count,
1245 .db_valid_mask = vntb_epf_db_valid_mask,
1246 .db_set_mask = vntb_epf_db_set_mask,
1247 .mw_set_trans = vntb_epf_mw_set_trans,
1248 .mw_clear_trans = vntb_epf_mw_clear_trans,
1249 .peer_mw_get_addr = vntb_epf_peer_mw_get_addr,
1250 .link_enable = vntb_epf_link_enable,
1251 .spad_read = vntb_epf_spad_read,
1252 .spad_write = vntb_epf_spad_write,
1253 .peer_spad_read = vntb_epf_peer_spad_read,
1254 .peer_spad_write = vntb_epf_peer_spad_write,
1255 .peer_db_set = vntb_epf_peer_db_set,
1256 .db_read = vntb_epf_db_read,
1257 .mw_get_align = vntb_epf_mw_get_align,
1258 .link_is_up = vntb_epf_link_is_up,
1259 .db_clear_mask = vntb_epf_db_clear_mask,
1260 .db_clear = vntb_epf_db_clear,
1261 .link_disable = vntb_epf_link_disable,
1264 static int pci_vntb_probe(struct pci_dev *pdev, const struct pci_device_id *id)
1267 struct epf_ntb *ndev = (struct epf_ntb *)pdev->sysdata;
1268 struct device *dev = &pdev->dev;
1270 ndev->ntb.pdev = pdev;
1271 ndev->ntb.topo = NTB_TOPO_NONE;
1272 ndev->ntb.ops = &vntb_epf_ops;
1274 ret = dma_set_mask_and_coherent(dev, DMA_BIT_MASK(32));
1276 dev_err(dev, "Cannot set DMA mask\n");
1280 ret = ntb_register_device(&ndev->ntb);
1282 dev_err(dev, "Failed to register NTB device\n");
1283 goto err_register_dev;
1286 dev_dbg(dev, "PCI Virtual NTB driver loaded\n");
1293 static struct pci_device_id pci_vntb_table[] = {
1295 PCI_DEVICE(0xffff, 0xffff),
1300 static struct pci_driver vntb_pci_driver = {
1302 .id_table = pci_vntb_table,
1303 .probe = pci_vntb_probe,
1306 /* ============ PCIe EPF Driver Bind ====================*/
1309 * epf_ntb_bind() - Initialize endpoint controller to provide NTB functionality
1310 * @epf: NTB endpoint function device
1312 * Initialize both the endpoint controllers associated with NTB function device.
1313 * Invoked when a primary interface or secondary interface is bound to EPC
1314 * device. This function will succeed only when EPC is bound to both the
1317 * Returns: Zero for success, or an error code in case of failure
1319 static int epf_ntb_bind(struct pci_epf *epf)
1321 struct epf_ntb *ntb = epf_get_drvdata(epf);
1322 struct device *dev = &epf->dev;
1326 dev_dbg(dev, "PRIMARY EPC interface not yet bound\n");
1330 ret = epf_ntb_init_epc_bar(ntb);
1332 dev_err(dev, "Failed to create NTB EPC\n");
1336 ret = epf_ntb_config_spad_bar_alloc(ntb);
1338 dev_err(dev, "Failed to allocate BAR memory\n");
1342 ret = epf_ntb_epc_init(ntb);
1344 dev_err(dev, "Failed to initialize EPC\n");
1348 epf_set_drvdata(epf, ntb);
1350 pci_space[0] = (ntb->vntb_pid << 16) | ntb->vntb_vid;
1351 pci_vntb_table[0].vendor = ntb->vntb_vid;
1352 pci_vntb_table[0].device = ntb->vntb_pid;
1354 ret = pci_register_driver(&vntb_pci_driver);
1356 dev_err(dev, "failure register vntb pci driver\n");
1365 epf_ntb_config_spad_bar_free(ntb);
1368 epf_ntb_epc_destroy(ntb);
1374 * epf_ntb_unbind() - Cleanup the initialization from epf_ntb_bind()
1375 * @epf: NTB endpoint function device
1377 * Cleanup the initialization from epf_ntb_bind()
1379 static void epf_ntb_unbind(struct pci_epf *epf)
1381 struct epf_ntb *ntb = epf_get_drvdata(epf);
1383 epf_ntb_epc_cleanup(ntb);
1384 epf_ntb_config_spad_bar_free(ntb);
1385 epf_ntb_epc_destroy(ntb);
1387 pci_unregister_driver(&vntb_pci_driver);
1391 static struct pci_epf_ops epf_ntb_ops = {
1392 .bind = epf_ntb_bind,
1393 .unbind = epf_ntb_unbind,
1394 .add_cfs = epf_ntb_add_cfs,
1398 * epf_ntb_probe() - Probe NTB function driver
1399 * @epf: NTB endpoint function device
1401 * Probe NTB function driver when endpoint function bus detects a NTB
1402 * endpoint function.
1404 * Returns: Zero for success, or an error code in case of failure
1406 static int epf_ntb_probe(struct pci_epf *epf)
1408 struct epf_ntb *ntb;
1413 ntb = devm_kzalloc(dev, sizeof(*ntb), GFP_KERNEL);
1417 epf->header = &epf_ntb_header;
1419 ntb->vbus_number = 0xff;
1420 epf_set_drvdata(epf, ntb);
1422 dev_info(dev, "pci-ep epf driver loaded\n");
1426 static const struct pci_epf_device_id epf_ntb_ids[] = {
1428 .name = "pci_epf_vntb",
1433 static struct pci_epf_driver epf_ntb_driver = {
1434 .driver.name = "pci_epf_vntb",
1435 .probe = epf_ntb_probe,
1436 .id_table = epf_ntb_ids,
1437 .ops = &epf_ntb_ops,
1438 .owner = THIS_MODULE,
1441 static int __init epf_ntb_init(void)
1445 kpcintb_workqueue = alloc_workqueue("kpcintb", WQ_MEM_RECLAIM |
1447 ret = pci_epf_register_driver(&epf_ntb_driver);
1449 destroy_workqueue(kpcintb_workqueue);
1450 pr_err("Failed to register pci epf ntb driver --> %d\n", ret);
1456 module_init(epf_ntb_init);
1458 static void __exit epf_ntb_exit(void)
1460 pci_epf_unregister_driver(&epf_ntb_driver);
1461 destroy_workqueue(kpcintb_workqueue);
1463 module_exit(epf_ntb_exit);
1465 MODULE_DESCRIPTION("PCI EPF NTB DRIVER");
1466 MODULE_AUTHOR("Frank Li <Frank.li@nxp.com>");
1467 MODULE_LICENSE("GPL v2");