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 72 0.0 %
Date: 2024-07-10 13:30:00 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 == 3 && 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 24.x or higher is not supported. */
      44           0 :         if (year > 23) {
      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 < 21 || (year == 21 && month < 11)) {
      72           0 :                 SPDK_ERRLOG("DPDK version %02d.%02d.%d is not supported.\n", year, month, minor);
      73           0 :                 return -EINVAL;
      74             :         } else {
      75             :                 /* Everything else we use the 22.07 implementation. */
      76           0 :                 g_dpdk_fn_table = &fn_table_2207;
      77             :         }
      78           0 :         return 0;
      79             : }
      80             : 
      81             : struct rte_mem_resource *
      82           0 : dpdk_pci_device_get_mem_resource(struct rte_pci_device *dev, uint32_t bar)
      83             : {
      84           0 :         return g_dpdk_fn_table->pci_device_get_mem_resource(dev, bar);
      85             : }
      86             : 
      87             : const char *
      88           0 : dpdk_pci_device_get_name(struct rte_pci_device *rte_dev)
      89             : {
      90           0 :         return g_dpdk_fn_table->pci_device_get_name(rte_dev);
      91             : }
      92             : 
      93             : struct rte_devargs *
      94           0 : dpdk_pci_device_get_devargs(struct rte_pci_device *rte_dev)
      95             : {
      96           0 :         return g_dpdk_fn_table->pci_device_get_devargs(rte_dev);
      97             : }
      98             : 
      99             : struct rte_pci_addr *
     100           0 : dpdk_pci_device_get_addr(struct rte_pci_device *rte_dev)
     101             : {
     102           0 :         return g_dpdk_fn_table->pci_device_get_addr(rte_dev);
     103             : }
     104             : 
     105             : struct rte_pci_id *
     106           0 : dpdk_pci_device_get_id(struct rte_pci_device *rte_dev)
     107             : {
     108           0 :         return g_dpdk_fn_table->pci_device_get_id(rte_dev);
     109             : }
     110             : 
     111             : int
     112           0 : dpdk_pci_device_get_numa_node(struct rte_pci_device *_dev)
     113             : {
     114           0 :         return g_dpdk_fn_table->pci_device_get_numa_node(_dev);
     115             : }
     116             : 
     117             : int
     118           0 : dpdk_pci_device_read_config(struct rte_pci_device *dev, void *value, uint32_t len, uint32_t offset)
     119             : {
     120           0 :         return g_dpdk_fn_table->pci_device_read_config(dev, value, len, offset);
     121             : }
     122             : 
     123             : int
     124           0 : dpdk_pci_device_write_config(struct rte_pci_device *dev, void *value, uint32_t len, uint32_t offset)
     125             : {
     126           0 :         return g_dpdk_fn_table->pci_device_write_config(dev, value, len, offset);
     127             : }
     128             : 
     129             : int
     130           0 : dpdk_pci_driver_register(struct spdk_pci_driver *driver,
     131             :                          int (*probe_fn)(struct rte_pci_driver *driver, struct rte_pci_device *device),
     132             :                          int (*remove_fn)(struct rte_pci_device *device))
     133             : 
     134             : {
     135           0 :         return g_dpdk_fn_table->pci_driver_register(driver, probe_fn, remove_fn);
     136             : }
     137             : 
     138             : int
     139           0 : dpdk_pci_device_enable_interrupt(struct rte_pci_device *rte_dev)
     140             : {
     141           0 :         return g_dpdk_fn_table->pci_device_enable_interrupt(rte_dev);
     142             : }
     143             : 
     144             : int
     145           0 : dpdk_pci_device_disable_interrupt(struct rte_pci_device *rte_dev)
     146             : {
     147           0 :         return g_dpdk_fn_table->pci_device_disable_interrupt(rte_dev);
     148             : }
     149             : 
     150             : int
     151           0 : dpdk_pci_device_get_interrupt_efd(struct rte_pci_device *rte_dev)
     152             : {
     153           0 :         return g_dpdk_fn_table->pci_device_get_interrupt_efd(rte_dev);
     154             : }
     155             : 
     156             : int
     157           0 : dpdk_bus_probe(void)
     158             : {
     159           0 :         return g_dpdk_fn_table->bus_probe();
     160             : }
     161             : 
     162             : void
     163           0 : dpdk_bus_scan(void)
     164             : {
     165           0 :         g_dpdk_fn_table->bus_scan();
     166           0 : }
     167             : 
     168             : struct rte_devargs *
     169           0 : dpdk_device_get_devargs(struct rte_device *dev)
     170             : {
     171           0 :         return g_dpdk_fn_table->device_get_devargs(dev);
     172             : }
     173             : 
     174             : void
     175           0 : dpdk_device_set_devargs(struct rte_device *dev, struct rte_devargs *devargs)
     176             : {
     177           0 :         g_dpdk_fn_table->device_set_devargs(dev, devargs);
     178           0 : }
     179             : 
     180             : const char *
     181           0 : dpdk_device_get_name(struct rte_device *dev)
     182             : {
     183           0 :         return g_dpdk_fn_table->device_get_name(dev);
     184             : }
     185             : 
     186             : bool
     187           0 : dpdk_device_scan_allowed(struct rte_device *dev)
     188             : {
     189           0 :         return g_dpdk_fn_table->device_scan_allowed(dev);
     190             : }

Generated by: LCOV version 1.15