Branch data     Line data    Source code

       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright 2018 Gaëtan Rivet
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <sys/queue.h>
       6                 :            : 
       7                 :            : #include <bus_driver.h>
       8                 :            : #include <rte_bus_pci.h>
       9                 :            : #include <dev_driver.h>
      10                 :            : #include <rte_errno.h>
      11                 :            : #include <rte_kvargs.h>
      12                 :            : #include <rte_devargs.h>
      13                 :            : #include <rte_pci.h>
      14                 :            : #include <rte_debug.h>
      15                 :            : 
      16                 :            : #include "private.h"
      17                 :            : 
      18                 :            : enum pci_params {
      19                 :            :         RTE_PCI_PARAM_ADDR,
      20                 :            :         RTE_PCI_PARAM_MAX,
      21                 :            : };
      22                 :            : 
      23                 :            : static const char * const pci_params_keys[] = {
      24                 :            :         [RTE_PCI_PARAM_ADDR] = "addr",
      25                 :            :         [RTE_PCI_PARAM_MAX] = NULL,
      26                 :            : };
      27                 :            : 
      28                 :            : static int
      29                 :          0 : pci_addr_kv_cmp(const char *key __rte_unused,
      30                 :            :                 const char *value,
      31                 :            :                 void *_addr2)
      32                 :            : {
      33                 :            :         struct rte_pci_addr _addr1;
      34                 :            :         struct rte_pci_addr *addr1 = &_addr1;
      35                 :            :         struct rte_pci_addr *addr2 = _addr2;
      36                 :            : 
      37         [ #  # ]:          0 :         if (rte_pci_addr_parse(value, addr1))
      38                 :            :                 return -1;
      39                 :          0 :         return -abs(rte_pci_addr_cmp(addr1, addr2));
      40                 :            : }
      41                 :            : 
      42                 :            : static int
      43                 :          0 : pci_dev_match(const struct rte_device *dev,
      44                 :            :               const void *_kvlist)
      45                 :            : {
      46                 :            :         const struct rte_kvargs *kvlist = _kvlist;
      47                 :            :         const struct rte_pci_device *pdev;
      48                 :            : 
      49         [ #  # ]:          0 :         if (kvlist == NULL)
      50                 :            :                 /* Empty string matches everything. */
      51                 :            :                 return 0;
      52                 :          0 :         pdev = RTE_DEV_TO_PCI_CONST(dev);
      53                 :            :         /* if any field does not match. */
      54         [ #  # ]:          0 :         if (rte_kvargs_process(kvlist, pci_params_keys[RTE_PCI_PARAM_ADDR],
      55                 :            :                                &pci_addr_kv_cmp,
      56                 :          0 :                                (void *)(intptr_t)&pdev->addr))
      57                 :          0 :                 return 1;
      58                 :            :         return 0;
      59                 :            : }
      60                 :            : 
      61                 :            : void *
      62                 :          0 : rte_pci_dev_iterate(const void *start,
      63                 :            :                     const char *str,
      64                 :            :                     const struct rte_dev_iterator *it __rte_unused)
      65                 :            : {
      66                 :            :         rte_bus_find_device_t find_device;
      67                 :            :         struct rte_kvargs *kvargs = NULL;
      68                 :            :         struct rte_device *dev;
      69                 :            : 
      70         [ #  # ]:          0 :         if (str != NULL) {
      71                 :          0 :                 kvargs = rte_kvargs_parse(str, pci_params_keys);
      72         [ #  # ]:          0 :                 if (kvargs == NULL) {
      73                 :          0 :                         PCI_LOG(ERR, "cannot parse argument list");
      74                 :          0 :                         rte_errno = EINVAL;
      75                 :          0 :                         return NULL;
      76                 :            :                 }
      77                 :            :         }
      78                 :          0 :         find_device = rte_pci_bus.bus.find_device;
      79                 :          0 :         dev = find_device(start, pci_dev_match, kvargs);
      80                 :          0 :         rte_kvargs_free(kvargs);
      81                 :          0 :         return dev;
      82                 :            : }
      83                 :            : 
      84                 :            : int
      85                 :          2 : rte_pci_devargs_parse(struct rte_devargs *da)
      86                 :            : {
      87                 :            :         struct rte_kvargs *kvargs;
      88                 :            :         const char *addr_str;
      89                 :            :         struct rte_pci_addr addr;
      90                 :            :         int ret = 0;
      91                 :            : 
      92   [ +  -  +  - ]:          2 :         if (da == NULL || da->bus_str == NULL)
      93                 :            :                 return 0;
      94                 :            : 
      95                 :          2 :         kvargs = rte_kvargs_parse(da->bus_str, NULL);
      96         [ -  + ]:          2 :         if (kvargs == NULL) {
      97                 :          0 :                 PCI_LOG(ERR, "cannot parse argument list: %s", da->bus_str);
      98                 :            :                 ret = -ENODEV;
      99                 :          0 :                 goto out;
     100                 :            :         }
     101                 :            : 
     102                 :          2 :         addr_str = rte_kvargs_get(kvargs, pci_params_keys[RTE_PCI_PARAM_ADDR]);
     103         [ +  + ]:          2 :         if (addr_str == NULL) {
     104                 :          1 :                 PCI_LOG(DEBUG, "No PCI address specified using '%s=<id>' in: %s",
     105                 :            :                         pci_params_keys[RTE_PCI_PARAM_ADDR], da->bus_str);
     106                 :          1 :                 goto out;
     107                 :            :         }
     108                 :            : 
     109                 :          1 :         ret = rte_pci_addr_parse(addr_str, &addr);
     110         [ -  + ]:          1 :         if (ret != 0) {
     111                 :          0 :                 PCI_LOG(ERR, "PCI address invalid: %s", da->bus_str);
     112                 :            :                 ret = -EINVAL;
     113                 :          0 :                 goto out;
     114                 :            :         }
     115                 :            : 
     116                 :          1 :         rte_pci_device_name(&addr, da->name, sizeof(da->name));
     117                 :            : 
     118                 :          2 : out:
     119                 :          2 :         rte_kvargs_free(kvargs);
     120         [ -  + ]:          2 :         if (ret != 0)
     121                 :          0 :                 rte_errno = -ret;
     122                 :            :         return ret;
     123                 :            : }