LCOV - code coverage report
Current view: top level - lib/env_dpdk - pci_dpdk.c (source / functions) Hit Total Coverage
Test: ut_cov_unit.info Lines: 0 77 0.0 %
Date: 2024-07-15 17:15:55 Functions: 0 19 0.0 %

          Line data    Source code
       1             : /*   SPDX-License-Identifier: BSD-3-Clause
       2             :  *   Copyright (C) 2022 Intel Corporation.
       3             :  *   All rights reserved.
       4             :  */
       5             : 
       6             : #include <rte_config.h>
       7             : #include <rte_version.h>
       8             : #include "pci_dpdk.h"
       9             : #include "spdk/log.h"
      10             : 
      11             : extern struct dpdk_fn_table fn_table_2207;
      12             : extern struct dpdk_fn_table fn_table_2211;
      13             : 
      14             : static struct dpdk_fn_table *g_dpdk_fn_table;
      15             : 
      16             : int
      17           0 : dpdk_pci_init(void)
      18             : {
      19           0 :         uint32_t year;
      20           0 :         uint32_t month;
      21           0 :         uint32_t minor;
      22           0 :         char release[32] = {0}; /* Max size of DPDK version string */
      23             :         int count;
      24             : 
      25           0 :         count = sscanf(rte_version(), "DPDK %u.%u.%u%s", &year, &month, &minor, release);
      26           0 :         if (count != 3 && count != 4) {
      27           0 :                 SPDK_ERRLOG("Unrecognized DPDK version format '%s'\n", rte_version());
      28           0 :                 return -EINVAL;
      29             :         }
      30             : 
      31             :         /* Add support for DPDK main branch, should be updated after each new release.
      32             :          * Only DPDK in development has additional suffix past minor version.
      33             :          */
      34           0 :         if (strlen(release) != 0) {
      35           0 :                 if (year == 24 && month == 7 && minor == 0) {
      36           0 :                         g_dpdk_fn_table = &fn_table_2211;
      37           0 :                         SPDK_NOTICELOG("In-development %s is used. There is no support for it in SPDK. "
      38             :                                        "Enabled only for validation.\n", rte_version());
      39           0 :                         return 0;
      40             :                 }
      41             :         }
      42             : 
      43             :         /* Anything 25.x or higher is not supported. */
      44           0 :         if (year >= 25) {
      45           0 :                 SPDK_ERRLOG("DPDK version %d.%02d.%d not supported.\n", year, month, minor);
      46           0 :                 return -EINVAL;
      47             :         }
      48             : 
      49           0 :         if (year == 22 && month == 11) {
      50           0 :                 if (minor > 4) {
      51             :                         /* It is possible that LTS minor release changed private ABI, so we
      52             :                          * cannot assume fn_table_2211 works for minor releases.  As 22.11
      53             :                          * minor releases occur, this will need to be updated to either affirm
      54             :                          * no ABI changes for the minor release, or add new header files and
      55             :                          * pci_dpdk_xxx.c implementation for the new minor release.
      56             :                          */
      57           0 :                         SPDK_ERRLOG("DPDK LTS version 22.11.%d not supported.\n", minor);
      58           0 :                         return -EINVAL;
      59             :                 }
      60           0 :                 g_dpdk_fn_table = &fn_table_2211;
      61           0 :         } else if (year == 23) {
      62             :                 /* Only 23.11.0, 23.07.0 and 23.03.0 are supported. */
      63           0 :                 if ((month != 11 || minor != 0) &&
      64           0 :                     (month != 7 || minor != 0) &&
      65           0 :                     (month != 3 || minor != 0)) {
      66           0 :                         SPDK_ERRLOG("DPDK version 23.%02d.%d is not supported.\n", month, minor);
      67           0 :                         return -EINVAL;
      68             :                 }
      69             :                 /* There were no changes between 22.11 and 23.11, so use the 22.11 implementation. */
      70           0 :                 g_dpdk_fn_table = &fn_table_2211;
      71           0 :         } else if (year == 24) {
      72             :                 /* Only 24.03.0 is supported. */
      73           0 :                 if (month != 3 || minor != 0) {
      74           0 :                         SPDK_ERRLOG("DPDK version 24.%02d.%d is not supported.\n", month, minor);
      75           0 :                         return -EINVAL;
      76             :                 }
      77             :                 /* There were no changes between 22.11 and 24.03, so use the 22.11 implementation. */
      78           0 :                 g_dpdk_fn_table = &fn_table_2211;
      79           0 :         } else if (year < 21 || (year == 21 && month < 11)) {
      80           0 :                 SPDK_ERRLOG("DPDK version %02d.%02d.%d is not supported.\n", year, month, minor);
      81           0 :                 return -EINVAL;
      82             :         } else {
      83             :                 /* Everything else we use the 22.07 implementation. */
      84           0 :                 g_dpdk_fn_table = &fn_table_2207;
      85             :         }
      86           0 :         return 0;
      87             : }
      88             : 
      89             : struct rte_mem_resource *
      90           0 : dpdk_pci_device_get_mem_resource(struct rte_pci_device *dev, uint32_t bar)
      91             : {
      92           0 :         return g_dpdk_fn_table->pci_device_get_mem_resource(dev, bar);
      93             : }
      94             : 
      95             : const char *
      96           0 : dpdk_pci_device_get_name(struct rte_pci_device *rte_dev)
      97             : {
      98           0 :         return g_dpdk_fn_table->pci_device_get_name(rte_dev);
      99             : }
     100             : 
     101             : struct rte_devargs *
     102           0 : dpdk_pci_device_get_devargs(struct rte_pci_device *rte_dev)
     103             : {
     104           0 :         return g_dpdk_fn_table->pci_device_get_devargs(rte_dev);
     105             : }
     106             : 
     107             : struct rte_pci_addr *
     108           0 : dpdk_pci_device_get_addr(struct rte_pci_device *rte_dev)
     109             : {
     110           0 :         return g_dpdk_fn_table->pci_device_get_addr(rte_dev);
     111             : }
     112             : 
     113             : struct rte_pci_id *
     114           0 : dpdk_pci_device_get_id(struct rte_pci_device *rte_dev)
     115             : {
     116           0 :         return g_dpdk_fn_table->pci_device_get_id(rte_dev);
     117             : }
     118             : 
     119             : int
     120           0 : dpdk_pci_device_get_numa_node(struct rte_pci_device *_dev)
     121             : {
     122           0 :         return g_dpdk_fn_table->pci_device_get_numa_node(_dev);
     123             : }
     124             : 
     125             : int
     126           0 : dpdk_pci_device_read_config(struct rte_pci_device *dev, void *value, uint32_t len, uint32_t offset)
     127             : {
     128           0 :         return g_dpdk_fn_table->pci_device_read_config(dev, value, len, offset);
     129             : }
     130             : 
     131             : int
     132           0 : dpdk_pci_device_write_config(struct rte_pci_device *dev, void *value, uint32_t len, uint32_t offset)
     133             : {
     134           0 :         return g_dpdk_fn_table->pci_device_write_config(dev, value, len, offset);
     135             : }
     136             : 
     137             : int
     138           0 : dpdk_pci_driver_register(struct spdk_pci_driver *driver,
     139             :                          int (*probe_fn)(struct rte_pci_driver *driver, struct rte_pci_device *device),
     140             :                          int (*remove_fn)(struct rte_pci_device *device))
     141             : 
     142             : {
     143           0 :         return g_dpdk_fn_table->pci_driver_register(driver, probe_fn, remove_fn);
     144             : }
     145             : 
     146             : int
     147           0 : dpdk_pci_device_enable_interrupt(struct rte_pci_device *rte_dev)
     148             : {
     149           0 :         return g_dpdk_fn_table->pci_device_enable_interrupt(rte_dev);
     150             : }
     151             : 
     152             : int
     153           0 : dpdk_pci_device_disable_interrupt(struct rte_pci_device *rte_dev)
     154             : {
     155           0 :         return g_dpdk_fn_table->pci_device_disable_interrupt(rte_dev);
     156             : }
     157             : 
     158             : int
     159           0 : dpdk_pci_device_get_interrupt_efd(struct rte_pci_device *rte_dev)
     160             : {
     161           0 :         return g_dpdk_fn_table->pci_device_get_interrupt_efd(rte_dev);
     162             : }
     163             : 
     164             : int
     165           0 : dpdk_bus_probe(void)
     166             : {
     167           0 :         return g_dpdk_fn_table->bus_probe();
     168             : }
     169             : 
     170             : void
     171           0 : dpdk_bus_scan(void)
     172             : {
     173           0 :         g_dpdk_fn_table->bus_scan();
     174           0 : }
     175             : 
     176             : struct rte_devargs *
     177           0 : dpdk_device_get_devargs(struct rte_device *dev)
     178             : {
     179           0 :         return g_dpdk_fn_table->device_get_devargs(dev);
     180             : }
     181             : 
     182             : void
     183           0 : dpdk_device_set_devargs(struct rte_device *dev, struct rte_devargs *devargs)
     184             : {
     185           0 :         g_dpdk_fn_table->device_set_devargs(dev, devargs);
     186           0 : }
     187             : 
     188             : const char *
     189           0 : dpdk_device_get_name(struct rte_device *dev)
     190             : {
     191           0 :         return g_dpdk_fn_table->device_get_name(dev);
     192             : }
     193             : 
     194             : bool
     195           0 : dpdk_device_scan_allowed(struct rte_device *dev)
     196             : {
     197           0 :         return g_dpdk_fn_table->device_scan_allowed(dev);
     198             : }

Generated by: LCOV version 1.15