+ struct rte_kvargs *kvlist;
+ int ret = 0;
+
+ if (devargs == NULL)
+ return 0;
+ if (devargs->cls != NULL && devargs->cls->name != NULL)
+ /* Global syntax, only one class type. */
+ return class_name_to_value(devargs->cls->name);
+ /* Legacy devargs support multiple classes. */
+ kvlist = rte_kvargs_parse(devargs->args, NULL);
+ if (kvlist == NULL)
+ return 0;
+ rte_kvargs_process(kvlist, RTE_DEVARGS_KEY_CLASS,
+ devargs_class_handler, &ret);
+ rte_kvargs_free(kvlist);
+ return ret;
+}
+
+static const unsigned int mlx5_class_invalid_combinations[] = {
+ MLX5_CLASS_ETH | MLX5_CLASS_VDPA,
+ /* New class combination should be added here. */
+};
+
+static int
+is_valid_class_combination(uint32_t user_classes)
+{
+ unsigned int i;
+
+ /* Verify if user specified unsupported combination. */
+ for (i = 0; i < RTE_DIM(mlx5_class_invalid_combinations); i++) {
+ if ((mlx5_class_invalid_combinations[i] & user_classes) ==
+ mlx5_class_invalid_combinations[i])
+ return -EINVAL;
+ }
+ /* Not found any invalid class combination. */
+ return 0;
+}
+
+static bool
+device_class_enabled(const struct mlx5_common_device *device, uint32_t class)
+{
+ return (device->classes_loaded & class) > 0;
+}
+
+static bool
+mlx5_bus_match(const struct mlx5_class_driver *drv,
+ const struct rte_device *dev)
+{
+ if (mlx5_dev_is_pci(dev))
+ return mlx5_dev_pci_match(drv, dev);
+ return true;
+}
+
+static struct mlx5_common_device *
+to_mlx5_device(const struct rte_device *rte_dev)
+{
+ struct mlx5_common_device *dev;
+
+ TAILQ_FOREACH(dev, &devices_list, next) {
+ if (rte_dev == dev->dev)
+ return dev;
+ }
+ return NULL;
+}
+
+int
+mlx5_dev_to_pci_str(const struct rte_device *dev, char *addr, size_t size)
+{
+ struct rte_pci_addr pci_addr = { 0 };
+ int ret;
+
+ if (mlx5_dev_is_pci(dev)) {
+ /* Input might be <BDF>, format PCI address to <DBDF>. */
+ ret = rte_pci_addr_parse(dev->name, &pci_addr);
+ if (ret != 0)
+ return -ENODEV;
+ rte_pci_device_name(&pci_addr, addr, size);
+ return 0;
+ }
+#ifdef RTE_EXEC_ENV_LINUX
+ return mlx5_auxiliary_get_pci_str(RTE_DEV_TO_AUXILIARY_CONST(dev),
+ addr, size);
+#else
+ rte_errno = ENODEV;
+ return -rte_errno;
+#endif
+}
+
+static void
+dev_release(struct mlx5_common_device *dev)
+{
+ pthread_mutex_lock(&devices_list_lock);
+ TAILQ_REMOVE(&devices_list, dev, next);
+ pthread_mutex_unlock(&devices_list_lock);
+ rte_free(dev);
+}
+
+static int
+drivers_remove(struct mlx5_common_device *dev, uint32_t enabled_classes)
+{
+ struct mlx5_class_driver *driver;
+ int local_ret = -ENODEV;
+ unsigned int i = 0;
+ int ret = 0;
+
+ enabled_classes &= dev->classes_loaded;
+ while (enabled_classes) {
+ driver = driver_get(RTE_BIT64(i));
+ if (driver != NULL) {
+ local_ret = driver->remove(dev);
+ if (local_ret == 0)
+ dev->classes_loaded &= ~RTE_BIT64(i);
+ else if (ret == 0)
+ ret = local_ret;
+ }
+ enabled_classes &= ~RTE_BIT64(i);
+ i++;
+ }
+ if (local_ret != 0 && ret == 0)
+ ret = local_ret;
+ return ret;
+}
+
+static int
+drivers_probe(struct mlx5_common_device *dev, uint32_t user_classes)
+{
+ struct mlx5_class_driver *driver;
+ uint32_t enabled_classes = 0;
+ bool already_loaded;
+ int ret;
+
+ TAILQ_FOREACH(driver, &drivers_list, next) {
+ if ((driver->drv_class & user_classes) == 0)
+ continue;
+ if (!mlx5_bus_match(driver, dev->dev))
+ continue;
+ already_loaded = dev->classes_loaded & driver->drv_class;
+ if (already_loaded && driver->probe_again == 0) {
+ DRV_LOG(ERR, "Device %s is already probed",
+ dev->dev->name);
+ ret = -EEXIST;
+ goto probe_err;
+ }
+ ret = driver->probe(dev);
+ if (ret < 0) {
+ DRV_LOG(ERR, "Failed to load driver %s",
+ driver->name);
+ goto probe_err;
+ }
+ enabled_classes |= driver->drv_class;
+ }
+ dev->classes_loaded |= enabled_classes;
+ return 0;
+probe_err:
+ /* Only unload drivers which are enabled which were enabled
+ * in this probe instance.
+ */
+ drivers_remove(dev, enabled_classes);
+ return ret;
+}
+
+int
+mlx5_common_dev_probe(struct rte_device *eal_dev)
+{
+ struct mlx5_common_device *dev;
+ uint32_t classes = 0;
+ bool new_device = false;
+ int ret;
+
+ DRV_LOG(INFO, "probe device \"%s\".", eal_dev->name);
+ ret = parse_class_options(eal_dev->devargs);
+ if (ret < 0) {
+ DRV_LOG(ERR, "Unsupported mlx5 class type: %s",
+ eal_dev->devargs->args);
+ return ret;
+ }
+ classes = ret;
+ if (classes == 0)
+ /* Default to net class. */
+ classes = MLX5_CLASS_ETH;
+ dev = to_mlx5_device(eal_dev);
+ if (!dev) {
+ dev = rte_zmalloc("mlx5_common_device", sizeof(*dev), 0);
+ if (!dev)
+ return -ENOMEM;
+ dev->dev = eal_dev;
+ pthread_mutex_lock(&devices_list_lock);
+ TAILQ_INSERT_HEAD(&devices_list, dev, next);
+ pthread_mutex_unlock(&devices_list_lock);
+ new_device = true;
+ }
+ /*
+ * Validate combination here.
+ * For new device, the classes_loaded field is 0 and it check only
+ * the classes given as user device arguments.
+ */
+ ret = is_valid_class_combination(classes | dev->classes_loaded);
+ if (ret != 0) {
+ DRV_LOG(ERR, "Unsupported mlx5 classes combination.");
+ goto class_err;
+ }
+ ret = drivers_probe(dev, classes);
+ if (ret)
+ goto class_err;
+ return 0;
+class_err:
+ if (new_device)
+ dev_release(dev);
+ return ret;
+}
+
+int
+mlx5_common_dev_remove(struct rte_device *eal_dev)
+{
+ struct mlx5_common_device *dev;
+ int ret;
+
+ dev = to_mlx5_device(eal_dev);
+ if (!dev)
+ return -ENODEV;
+ /* Matching device found, cleanup and unload drivers. */
+ ret = drivers_remove(dev, dev->classes_loaded);
+ if (ret == 0)
+ dev_release(dev);
+ return ret;
+}
+
+int
+mlx5_common_dev_dma_map(struct rte_device *dev, void *addr, uint64_t iova,
+ size_t len)
+{
+ struct mlx5_class_driver *driver = NULL;
+ struct mlx5_class_driver *temp;
+ struct mlx5_common_device *mdev;
+ int ret = -EINVAL;
+
+ mdev = to_mlx5_device(dev);
+ if (!mdev)
+ return -ENODEV;
+ TAILQ_FOREACH(driver, &drivers_list, next) {
+ if (!device_class_enabled(mdev, driver->drv_class) ||
+ driver->dma_map == NULL)
+ continue;
+ ret = driver->dma_map(dev, addr, iova, len);
+ if (ret)
+ goto map_err;
+ }
+ return ret;
+map_err:
+ TAILQ_FOREACH(temp, &drivers_list, next) {
+ if (temp == driver)
+ break;
+ if (device_class_enabled(mdev, temp->drv_class) &&
+ temp->dma_map && temp->dma_unmap)
+ temp->dma_unmap(dev, addr, iova, len);
+ }
+ return ret;
+}
+
+int
+mlx5_common_dev_dma_unmap(struct rte_device *dev, void *addr, uint64_t iova,
+ size_t len)
+{
+ struct mlx5_class_driver *driver;
+ struct mlx5_common_device *mdev;
+ int local_ret = -EINVAL;
+ int ret = 0;
+
+ mdev = to_mlx5_device(dev);
+ if (!mdev)
+ return -ENODEV;
+ /* There is no unmap error recovery in current implementation. */
+ TAILQ_FOREACH_REVERSE(driver, &drivers_list, mlx5_drivers, next) {
+ if (!device_class_enabled(mdev, driver->drv_class) ||
+ driver->dma_unmap == NULL)
+ continue;
+ local_ret = driver->dma_unmap(dev, addr, iova, len);
+ if (local_ret && (ret == 0))
+ ret = local_ret;
+ }
+ if (local_ret)
+ ret = local_ret;
+ return ret;
+}
+
+void
+mlx5_class_driver_register(struct mlx5_class_driver *driver)
+{
+ mlx5_common_driver_on_register_pci(driver);
+ TAILQ_INSERT_TAIL(&drivers_list, driver, next);
+}
+
+static void mlx5_common_driver_init(void)
+{
+ mlx5_common_pci_init();
+#ifdef RTE_EXEC_ENV_LINUX
+ mlx5_common_auxiliary_init();
+#endif