LCOV - code coverage report
Current view: top level - drivers/common/cnxk - roc_model.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 106 0.0 %
Date: 2024-04-01 19:00:53 Functions: 0 7 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 73 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(C) 2021 Marvell.
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <dirent.h>
       6                 :            : #include <fcntl.h>
       7                 :            : #include <unistd.h>
       8                 :            : 
       9                 :            : #include "roc_api.h"
      10                 :            : #include "roc_priv.h"
      11                 :            : 
      12                 :            : struct roc_model *roc_model;
      13                 :            : 
      14                 :            : /* RoC and CPU IDs and revisions */
      15                 :            : #define VENDOR_ARM    0x41 /* 'A' */
      16                 :            : #define VENDOR_CAVIUM 0x43 /* 'C' */
      17                 :            : 
      18                 :            : #define SOC_PART_CN10K 0xD49
      19                 :            : 
      20                 :            : #define PART_106xx  0xB9
      21                 :            : #define PART_105xx  0xBA
      22                 :            : #define PART_105xxN 0xBC
      23                 :            : #define PART_103xx  0xBD
      24                 :            : #define PART_98xx   0xB1
      25                 :            : #define PART_96xx   0xB2
      26                 :            : #define PART_95xx   0xB3
      27                 :            : #define PART_95xxN  0xB4
      28                 :            : #define PART_95xxMM 0xB5
      29                 :            : #define PART_95O    0xB6
      30                 :            : 
      31                 :            : #define MODEL_IMPL_BITS   8
      32                 :            : #define MODEL_IMPL_SHIFT  24
      33                 :            : #define MODEL_IMPL_MASK   ((1 << MODEL_IMPL_BITS) - 1)
      34                 :            : #define MODEL_PART_BITS   12
      35                 :            : #define MODEL_PART_SHIFT  4
      36                 :            : #define MODEL_PART_MASK   ((1 << MODEL_PART_BITS) - 1)
      37                 :            : #define MODEL_MAJOR_BITS  4
      38                 :            : #define MODEL_MAJOR_SHIFT 20
      39                 :            : #define MODEL_MAJOR_MASK  ((1 << MODEL_MAJOR_BITS) - 1)
      40                 :            : #define MODEL_MINOR_BITS  4
      41                 :            : #define MODEL_MINOR_SHIFT 0
      42                 :            : #define MODEL_MINOR_MASK  ((1 << MODEL_MINOR_BITS) - 1)
      43                 :            : 
      44                 :            : #define MODEL_CN10K_PART_SHIFT  8
      45                 :            : #define MODEL_CN10K_PASS_BITS   4
      46                 :            : #define MODEL_CN10K_PASS_MASK   ((1 << MODEL_CN10K_PASS_BITS) - 1)
      47                 :            : #define MODEL_CN10K_MAJOR_BITS  2
      48                 :            : #define MODEL_CN10K_MAJOR_SHIFT 2
      49                 :            : #define MODEL_CN10K_MAJOR_MASK  ((1 << MODEL_CN10K_MAJOR_BITS) - 1)
      50                 :            : #define MODEL_CN10K_MINOR_BITS  2
      51                 :            : #define MODEL_CN10K_MINOR_SHIFT 0
      52                 :            : #define MODEL_CN10K_MINOR_MASK  ((1 << MODEL_CN10K_MINOR_BITS) - 1)
      53                 :            : 
      54                 :            : static const struct model_db {
      55                 :            :         uint32_t impl;
      56                 :            :         uint32_t part;
      57                 :            :         uint32_t major;
      58                 :            :         uint32_t minor;
      59                 :            :         uint64_t flag;
      60                 :            :         char name[ROC_MODEL_STR_LEN_MAX];
      61                 :            : } model_db[] = {
      62                 :            :         {VENDOR_ARM, PART_106xx, 0, 0, ROC_MODEL_CN106xx_A0, "cn10ka_a0"},
      63                 :            :         {VENDOR_ARM, PART_106xx, 0, 1, ROC_MODEL_CN106xx_A1, "cn10ka_a1"},
      64                 :            :         {VENDOR_ARM, PART_106xx, 1, 0, ROC_MODEL_CN106xx_B0, "cn10ka_b0"},
      65                 :            :         {VENDOR_ARM, PART_105xx, 0, 0, ROC_MODEL_CNF105xx_A0, "cnf10ka_a0"},
      66                 :            :         {VENDOR_ARM, PART_105xx, 0, 1, ROC_MODEL_CNF105xx_A1, "cnf10ka_a1"},
      67                 :            :         {VENDOR_ARM, PART_103xx, 0, 0, ROC_MODEL_CN103xx_A0, "cn10kb_a0"},
      68                 :            :         {VENDOR_ARM, PART_105xxN, 0, 0, ROC_MODEL_CNF105xxN_A0, "cnf10kb_a0"},
      69                 :            :         {VENDOR_ARM, PART_105xxN, 1, 0, ROC_MODEL_CNF105xxN_B0, "cnf10kb_b0"},
      70                 :            :         {VENDOR_CAVIUM, PART_98xx, 0, 0, ROC_MODEL_CN98xx_A0, "cn98xx_a0"},
      71                 :            :         {VENDOR_CAVIUM, PART_98xx, 0, 1, ROC_MODEL_CN98xx_A1, "cn98xx_a1"},
      72                 :            :         {VENDOR_CAVIUM, PART_96xx, 0, 0, ROC_MODEL_CN96xx_A0, "cn96xx_a0"},
      73                 :            :         {VENDOR_CAVIUM, PART_96xx, 0, 1, ROC_MODEL_CN96xx_B0, "cn96xx_b0"},
      74                 :            :         {VENDOR_CAVIUM, PART_96xx, 2, 0, ROC_MODEL_CN96xx_C0, "cn96xx_c0"},
      75                 :            :         {VENDOR_CAVIUM, PART_96xx, 2, 1, ROC_MODEL_CN96xx_C0, "cn96xx_c1"},
      76                 :            :         {VENDOR_CAVIUM, PART_95xx, 0, 0, ROC_MODEL_CNF95xx_A0, "cnf95xx_a0"},
      77                 :            :         {VENDOR_CAVIUM, PART_95xx, 1, 0, ROC_MODEL_CNF95xx_B0, "cnf95xx_b0"},
      78                 :            :         {VENDOR_CAVIUM, PART_95xxN, 0, 0, ROC_MODEL_CNF95xxN_A0, "cnf95xxn_a0"},
      79                 :            :         {VENDOR_CAVIUM, PART_95xxN, 0, 1, ROC_MODEL_CNF95xxN_A0, "cnf95xxn_a1"},
      80                 :            :         {VENDOR_CAVIUM, PART_95xxN, 1, 0, ROC_MODEL_CNF95xxN_B0, "cnf95xxn_b0"},
      81                 :            :         {VENDOR_CAVIUM, PART_95O, 0, 0, ROC_MODEL_CNF95xxO_A0, "cnf95O_a0"},
      82                 :            :         {VENDOR_CAVIUM, PART_95xxMM, 0, 0, ROC_MODEL_CNF95xxMM_A0,
      83                 :            :          "cnf95xxmm_a0"}};
      84                 :            : 
      85                 :            : /* Detect if RVU device */
      86                 :            : static bool
      87                 :            : is_rvu_device(unsigned long val)
      88                 :            : {
      89                 :            :         return (val == PCI_DEVID_CNXK_RVU_PF || val == PCI_DEVID_CNXK_RVU_VF ||
      90                 :            :                 val == PCI_DEVID_CNXK_RVU_AF ||
      91                 :            :                 val == PCI_DEVID_CNXK_RVU_AF_VF ||
      92                 :            :                 val == PCI_DEVID_CNXK_RVU_NPA_PF ||
      93                 :            :                 val == PCI_DEVID_CNXK_RVU_NPA_VF ||
      94                 :            :                 val == PCI_DEVID_CNXK_RVU_SSO_TIM_PF ||
      95                 :            :                 val == PCI_DEVID_CNXK_RVU_SSO_TIM_VF ||
      96                 :          0 :                 val == PCI_DEVID_CN10K_RVU_CPT_PF ||
      97                 :            :                 val == PCI_DEVID_CN10K_RVU_CPT_VF);
      98                 :            : }
      99                 :            : 
     100                 :            : static int
     101                 :          0 : rvu_device_lookup(const char *dirname, uint32_t *part, uint32_t *pass)
     102                 :            : {
     103                 :            :         char filename[PATH_MAX];
     104                 :            :         unsigned long val;
     105                 :            : 
     106                 :            :         /* Check if vendor id is cavium */
     107                 :            :         snprintf(filename, sizeof(filename), "%s/vendor", dirname);
     108         [ #  # ]:          0 :         if (plt_sysfs_value_parse(filename, &val) < 0)
     109                 :          0 :                 goto error;
     110                 :            : 
     111         [ #  # ]:          0 :         if (val != PCI_VENDOR_ID_CAVIUM)
     112                 :          0 :                 goto error;
     113                 :            : 
     114                 :            :         /* Get device id  */
     115                 :            :         snprintf(filename, sizeof(filename), "%s/device", dirname);
     116         [ #  # ]:          0 :         if (plt_sysfs_value_parse(filename, &val) < 0)
     117                 :          0 :                 goto error;
     118                 :            : 
     119                 :            :         /* Check if device ID belongs to any RVU device */
     120   [ #  #  #  #  :          0 :         if (!is_rvu_device(val))
                #  #  # ]
     121                 :          0 :                 goto error;
     122                 :            : 
     123                 :            :         /* Get subsystem_device id */
     124                 :            :         snprintf(filename, sizeof(filename), "%s/subsystem_device", dirname);
     125         [ #  # ]:          0 :         if (plt_sysfs_value_parse(filename, &val) < 0)
     126                 :          0 :                 goto error;
     127                 :            : 
     128                 :          0 :         *part = val >> MODEL_CN10K_PART_SHIFT;
     129                 :            : 
     130                 :            :         /* Get revision for pass value*/
     131                 :            :         snprintf(filename, sizeof(filename), "%s/revision", dirname);
     132         [ #  # ]:          0 :         if (plt_sysfs_value_parse(filename, &val) < 0)
     133                 :          0 :                 goto error;
     134                 :            : 
     135                 :          0 :         *pass = val & MODEL_CN10K_PASS_MASK;
     136                 :            : 
     137                 :          0 :         return 0;
     138                 :            : error:
     139                 :            :         return -EINVAL;
     140                 :            : }
     141                 :            : 
     142                 :            : /* Scans through all PCI devices, detects RVU device and returns
     143                 :            :  * subsystem_device
     144                 :            :  */
     145                 :            : static int
     146                 :          0 : cn10k_part_pass_get(uint32_t *part, uint32_t *pass)
     147                 :            : {
     148                 :            : #define SYSFS_PCI_DEVICES "/sys/bus/pci/devices"
     149                 :            :         char dirname[PATH_MAX];
     150                 :            :         struct dirent *e;
     151                 :            :         int ret = -1;
     152                 :            :         DIR *dir;
     153                 :            : 
     154                 :          0 :         dir = opendir(SYSFS_PCI_DEVICES);
     155         [ #  # ]:          0 :         if (dir == NULL) {
     156                 :          0 :                 plt_err("%s(): opendir failed: %s\n", __func__,
     157                 :            :                         strerror(errno));
     158                 :          0 :                 return -errno;
     159                 :            :         }
     160                 :            : 
     161         [ #  # ]:          0 :         while ((e = readdir(dir)) != NULL) {
     162         [ #  # ]:          0 :                 if (e->d_name[0] == '.')
     163                 :          0 :                         continue;
     164                 :            : 
     165                 :            :                 snprintf(dirname, sizeof(dirname), "%s/%s", SYSFS_PCI_DEVICES,
     166                 :          0 :                          e->d_name);
     167                 :            : 
     168                 :            :                 /* Lookup for rvu device and get part pass information */
     169                 :          0 :                 ret = rvu_device_lookup(dirname, part, pass);
     170         [ #  # ]:          0 :                 if (!ret)
     171                 :            :                         break;
     172                 :            :         }
     173                 :            : 
     174                 :          0 :         closedir(dir);
     175                 :          0 :         return ret;
     176                 :            : }
     177                 :            : 
     178                 :            : static bool
     179                 :          0 : populate_model(struct roc_model *model, uint32_t midr)
     180                 :            : {
     181                 :          0 :         uint32_t impl, major, part, minor, pass = 0;
     182                 :            :         bool found = false;
     183                 :            :         size_t i;
     184                 :            : 
     185                 :          0 :         impl = (midr >> MODEL_IMPL_SHIFT) & MODEL_IMPL_MASK;
     186                 :          0 :         part = (midr >> MODEL_PART_SHIFT) & MODEL_PART_MASK;
     187                 :          0 :         major = (midr >> MODEL_MAJOR_SHIFT) & MODEL_MAJOR_MASK;
     188                 :          0 :         minor = (midr >> MODEL_MINOR_SHIFT) & MODEL_MINOR_MASK;
     189                 :            : 
     190                 :            :         /* Update part number for cn10k from device-tree */
     191         [ #  # ]:          0 :         if (part == SOC_PART_CN10K) {
     192         [ #  # ]:          0 :                 if (cn10k_part_pass_get(&part, &pass))
     193                 :          0 :                         goto not_found;
     194                 :            :                 /*
     195                 :            :                  * Pass value format:
     196                 :            :                  * Bits 0..1: minor pass
     197                 :            :                  * Bits 3..2: major pass
     198                 :            :                  */
     199                 :          0 :                 minor = (pass >> MODEL_CN10K_MINOR_SHIFT) &
     200                 :            :                         MODEL_CN10K_MINOR_MASK;
     201                 :          0 :                 major = (pass >> MODEL_CN10K_MAJOR_SHIFT) &
     202                 :            :                         MODEL_CN10K_MAJOR_MASK;
     203                 :            :         }
     204                 :            : 
     205         [ #  # ]:          0 :         for (i = 0; i < PLT_DIM(model_db); i++)
     206   [ #  #  #  # ]:          0 :                 if (model_db[i].impl == impl && model_db[i].part == part &&
     207   [ #  #  #  # ]:          0 :                     model_db[i].major == major && model_db[i].minor == minor) {
     208                 :          0 :                         model->flag = model_db[i].flag;
     209                 :          0 :                         strncpy(model->name, model_db[i].name,
     210                 :            :                                 ROC_MODEL_STR_LEN_MAX - 1);
     211                 :            :                         found = true;
     212                 :          0 :                         break;
     213                 :            :                 }
     214                 :          0 : not_found:
     215         [ #  # ]:          0 :         if (!found) {
     216                 :          0 :                 model->flag = 0;
     217                 :          0 :                 strncpy(model->name, "unknown", ROC_MODEL_STR_LEN_MAX - 1);
     218                 :          0 :                 plt_err("Invalid RoC model (impl=0x%x, part=0x%x, major=0x%x, minor=0x%x)",
     219                 :            :                         impl, part, major, minor);
     220                 :            :         }
     221                 :            : 
     222                 :          0 :         return found;
     223                 :            : }
     224                 :            : 
     225                 :            : static int
     226                 :          0 : midr_get(unsigned long *val)
     227                 :            : {
     228                 :            :         const char *file =
     229                 :            :                 "/sys/devices/system/cpu/cpu0/regs/identification/midr_el1";
     230                 :            :         int rc = UTIL_ERR_FS;
     231                 :            :         char buf[BUFSIZ];
     232                 :          0 :         char *end = NULL;
     233                 :            :         FILE *f;
     234                 :            : 
     235         [ #  # ]:          0 :         if (val == NULL)
     236                 :          0 :                 goto err;
     237                 :          0 :         f = fopen(file, "r");
     238         [ #  # ]:          0 :         if (f == NULL)
     239                 :          0 :                 goto err;
     240                 :            : 
     241         [ #  # ]:          0 :         if (fgets(buf, sizeof(buf), f) == NULL)
     242                 :          0 :                 goto fclose;
     243                 :            : 
     244                 :          0 :         *val = strtoul(buf, &end, 0);
     245   [ #  #  #  #  :          0 :         if ((buf[0] == '\0') || (end == NULL) || (*end != '\n'))
                   #  # ]
     246                 :          0 :                 goto fclose;
     247                 :            : 
     248                 :            :         rc = 0;
     249                 :          0 : fclose:
     250                 :          0 :         fclose(f);
     251                 :          0 : err:
     252                 :          0 :         return rc;
     253                 :            : }
     254                 :            : 
     255                 :            : static void
     256                 :            : detect_invalid_config(void)
     257                 :            : {
     258                 :            : #ifdef ROC_PLATFORM_CN9K
     259                 :            : #ifdef ROC_PLATFORM_CN10K
     260                 :            :         PLT_STATIC_ASSERT(0);
     261                 :            : #endif
     262                 :            : #endif
     263                 :            : }
     264                 :            : 
     265                 :            : static uint64_t
     266                 :          0 : env_lookup_flag(const char *name)
     267                 :            : {
     268                 :            :         unsigned int i;
     269                 :            :         struct {
     270                 :            :                 const char *name;
     271                 :            :                 uint64_t flag;
     272                 :          0 :         } envs[] = {
     273                 :            :                 {"HW_PLATFORM", ROC_ENV_HW},
     274                 :            :                 {"EMUL_PLATFORM", ROC_ENV_EMUL},
     275                 :            :                 {"ASIM_PLATFORM", ROC_ENV_ASIM},
     276                 :            :         };
     277                 :            : 
     278         [ #  # ]:          0 :         for (i = 0; i < PLT_DIM(envs); i++)
     279         [ #  # ]:          0 :                 if (!strncmp(envs[i].name, name, strlen(envs[i].name)))
     280                 :          0 :                         return envs[i].flag;
     281                 :            : 
     282                 :            :         return 0;
     283                 :            : }
     284                 :            : 
     285                 :            : static void
     286                 :          0 : of_env_get(struct roc_model *model)
     287                 :            : {
     288                 :            :         const char *const path = "/proc/device-tree/soc@0/runplatform";
     289                 :            :         uint64_t flag;
     290                 :            :         FILE *fp;
     291                 :            : 
     292         [ #  # ]:          0 :         if (access(path, F_OK) != 0) {
     293                 :          0 :                 strncpy(model->env, "HW_PLATFORM", ROC_MODEL_STR_LEN_MAX - 1);
     294                 :          0 :                 model->flag |= ROC_ENV_HW;
     295                 :          0 :                 return;
     296                 :            :         }
     297                 :            : 
     298                 :          0 :         fp = fopen(path, "r");
     299         [ #  # ]:          0 :         if (!fp) {
     300                 :          0 :                 plt_err("Failed to open %s", path);
     301                 :          0 :                 return;
     302                 :            :         }
     303                 :            : 
     304   [ #  #  #  # ]:          0 :         if (!fgets(model->env, sizeof(model->env), fp)) {
     305                 :          0 :                 plt_err("Failed to read %s", path);
     306                 :          0 :                 goto err;
     307                 :            :         }
     308                 :            : 
     309                 :          0 :         flag = env_lookup_flag(model->env);
     310         [ #  # ]:          0 :         if (flag == 0) {
     311                 :          0 :                 plt_err("Unknown platform: %s", model->env);
     312                 :          0 :                 goto err;
     313                 :            :         }
     314                 :            : 
     315                 :          0 :         model->flag |= flag;
     316                 :          0 : err:
     317                 :          0 :         fclose(fp);
     318                 :            : }
     319                 :            : 
     320                 :            : int
     321                 :          0 : roc_model_init(struct roc_model *model)
     322                 :            : {
     323                 :            :         int rc = UTIL_ERR_PARAM;
     324                 :            :         unsigned long midr;
     325                 :            : 
     326                 :            :         detect_invalid_config();
     327                 :            : 
     328         [ #  # ]:          0 :         if (!model)
     329                 :          0 :                 goto err;
     330                 :            : 
     331                 :          0 :         rc = midr_get(&midr);
     332         [ #  # ]:          0 :         if (rc)
     333                 :          0 :                 goto err;
     334                 :            : 
     335                 :            :         rc = UTIL_ERR_INVALID_MODEL;
     336         [ #  # ]:          0 :         if (!populate_model(model, midr))
     337                 :          0 :                 goto err;
     338                 :            : 
     339                 :          0 :         of_env_get(model);
     340                 :            : 
     341                 :            :         rc = 0;
     342                 :          0 :         plt_info("RoC Model: %s (%s)", model->name, model->env);
     343                 :          0 :         roc_model = model;
     344                 :          0 : err:
     345                 :          0 :         return rc;
     346                 :            : }

Generated by: LCOV version 1.14