1 /* SPDX-License-Identifier: BSD-3-Clause
2 * Copyright 2020 Mellanox Technologies Ltd
7 #include <rte_malloc.h>
8 #include <rte_devargs.h>
10 #include <rte_class.h>
12 #include <rte_bus_pci.h>
14 #include "mlx5_common_log.h"
15 #include "mlx5_common_private.h"
17 static struct rte_pci_driver mlx5_common_pci_driver;
19 /* PCI ID table is build dynamically based on registered mlx5 drivers. */
20 static struct rte_pci_id *mlx5_pci_id_table;
23 pci_id_table_size_get(const struct rte_pci_id *id_table)
27 for (; id_table->vendor_id != 0; id_table++)
33 pci_id_exists(const struct rte_pci_id *id, const struct rte_pci_id *table,
36 int current_size = next_idx - 1;
39 for (i = 0; i < current_size; i++) {
40 if (id->device_id == table[i].device_id &&
41 id->vendor_id == table[i].vendor_id &&
42 id->subsystem_vendor_id == table[i].subsystem_vendor_id &&
43 id->subsystem_device_id == table[i].subsystem_device_id)
50 pci_id_insert(struct rte_pci_id *new_table, int *next_idx,
51 const struct rte_pci_id *id_table)
53 /* Traverse the id_table, check if entry exists in new_table;
54 * Add non duplicate entries to new table.
56 for (; id_table->vendor_id != 0; id_table++) {
57 if (!pci_id_exists(id_table, new_table, *next_idx)) {
58 /* New entry; add to the table. */
59 new_table[*next_idx] = *id_table;
66 pci_ids_table_update(const struct rte_pci_id *driver_id_table)
68 const struct rte_pci_id *id_iter;
69 struct rte_pci_id *updated_table;
70 struct rte_pci_id *old_table;
74 old_table = mlx5_pci_id_table;
76 num_ids = pci_id_table_size_get(old_table);
77 num_ids += pci_id_table_size_get(driver_id_table);
78 /* Increase size by one for the termination entry of vendor_id = 0. */
80 updated_table = calloc(num_ids, sizeof(*updated_table));
83 if (old_table == NULL) {
84 /* Copy the first driver's ID table. */
85 for (id_iter = driver_id_table; id_iter->vendor_id != 0;
87 updated_table[i] = *id_iter;
89 /* First copy existing table entries. */
90 for (id_iter = old_table; id_iter->vendor_id != 0;
92 updated_table[i] = *id_iter;
93 /* New id to be added at the end of current ID table. */
94 pci_id_insert(updated_table, &i, driver_id_table);
96 /* Terminate table with empty entry. */
97 updated_table[i].vendor_id = 0;
98 mlx5_common_pci_driver.id_table = updated_table;
99 mlx5_pci_id_table = updated_table;
106 mlx5_dev_is_pci(const struct rte_device *dev)
108 return strcmp(dev->bus->name, "pci") == 0;
112 mlx5_dev_pci_match(const struct mlx5_class_driver *drv,
113 const struct rte_device *dev)
115 const struct rte_pci_device *pci_dev;
116 const struct rte_pci_id *id_table;
118 if (!mlx5_dev_is_pci(dev))
120 pci_dev = RTE_DEV_TO_PCI_CONST(dev);
121 for (id_table = drv->id_table; id_table->vendor_id != 0;
123 /* Check if device's ids match the class driver's ids. */
124 if (id_table->vendor_id != pci_dev->id.vendor_id &&
125 id_table->vendor_id != RTE_PCI_ANY_ID)
127 if (id_table->device_id != pci_dev->id.device_id &&
128 id_table->device_id != RTE_PCI_ANY_ID)
130 if (id_table->subsystem_vendor_id !=
131 pci_dev->id.subsystem_vendor_id &&
132 id_table->subsystem_vendor_id != RTE_PCI_ANY_ID)
134 if (id_table->subsystem_device_id !=
135 pci_dev->id.subsystem_device_id &&
136 id_table->subsystem_device_id != RTE_PCI_ANY_ID)
138 if (id_table->class_id != pci_dev->id.class_id &&
139 id_table->class_id != RTE_CLASS_ANY_ID)
147 mlx5_common_pci_probe(struct rte_pci_driver *pci_drv __rte_unused,
148 struct rte_pci_device *pci_dev)
150 return mlx5_common_dev_probe(&pci_dev->device);
154 mlx5_common_pci_remove(struct rte_pci_device *pci_dev)
156 return mlx5_common_dev_remove(&pci_dev->device);
160 mlx5_common_pci_dma_map(struct rte_pci_device *pci_dev, void *addr,
161 uint64_t iova, size_t len)
163 return mlx5_common_dev_dma_map(&pci_dev->device, addr, iova, len);
167 mlx5_common_pci_dma_unmap(struct rte_pci_device *pci_dev, void *addr,
168 uint64_t iova, size_t len)
170 return mlx5_common_dev_dma_unmap(&pci_dev->device, addr, iova, len);
174 mlx5_common_driver_on_register_pci(struct mlx5_class_driver *driver)
176 if (driver->id_table != NULL) {
177 if (pci_ids_table_update(driver->id_table) != 0)
180 if (driver->probe_again)
181 mlx5_common_pci_driver.drv_flags |= RTE_PCI_DRV_PROBE_AGAIN;
182 if (driver->intr_lsc)
183 mlx5_common_pci_driver.drv_flags |= RTE_PCI_DRV_INTR_LSC;
184 if (driver->intr_rmv)
185 mlx5_common_pci_driver.drv_flags |= RTE_PCI_DRV_INTR_RMV;
188 static struct rte_pci_driver mlx5_common_pci_driver = {
190 .name = MLX5_PCI_DRIVER_NAME,
192 .probe = mlx5_common_pci_probe,
193 .remove = mlx5_common_pci_remove,
194 .dma_map = mlx5_common_pci_dma_map,
195 .dma_unmap = mlx5_common_pci_dma_unmap,
198 void mlx5_common_pci_init(void)
200 const struct rte_pci_id empty_table[] = {
206 /* All mlx5 PMDs constructor runs at same priority. So any of the PMD
207 * including this one can register the PCI table first. If any other
208 * PMD(s) have registered the PCI ID table, No need to register an empty
211 if (mlx5_pci_id_table == NULL && pci_ids_table_update(empty_table))
213 rte_pci_register(&mlx5_common_pci_driver);
216 RTE_FINI(mlx5_common_pci_finish)
218 if (mlx5_pci_id_table != NULL) {
219 /* Constructor doesn't register with PCI bus if it failed
220 * to build the table.
222 rte_pci_unregister(&mlx5_common_pci_driver);
223 free(mlx5_pci_id_table);
227 RTE_PMD_EXPORT_NAME(mlx5_common_pci, __COUNTER__);