drivers/common/mlx5/linux/mlx5_common_os.h

   1 /* SPDX-License-Identifier: BSD-3-Clause
   2  * Copyright 2020 Mellanox Technologies, Ltd
   3  */
   4
   5 #ifndef RTE_PMD_MLX5_COMMON_OS_H_
   6 #define RTE_PMD_MLX5_COMMON_OS_H_
   7
   8 #include <stdio.h>
   9 #include <malloc.h>
  10
  11 #include <rte_pci.h>
  12 #include <rte_debug.h>
  13 #include <rte_atomic.h>
  14 #include <rte_log.h>
  15 #include <rte_kvargs.h>
  16 #include <rte_devargs.h>
  17
  18 #include "mlx5_autoconf.h"
  19 #include "mlx5_glue.h"
  20 #include "mlx5_malloc.h"
  21
  22 /**
  23  * Get device name. Given an ibv_device pointer - return a
  24  * pointer to the corresponding device name.
  25  *
  26  * @param[in] dev
  27  *   Pointer to ibv device.
  28  *
  29  * @return
  30  *   Pointer to device name if dev is valid, NULL otherwise.
  31  */
  32 static inline const char *
  33 mlx5_os_get_dev_device_name(void *dev)
  34 {
  35         if (!dev)
  36                 return NULL;
  37         return ((struct ibv_device *)dev)->name;
  38 }
  39
  40 /**
  41  * Get ibv device name. Given an ibv_context pointer - return a
  42  * pointer to the corresponding device name.
  43  *
  44  * @param[in] ctx
  45  *   Pointer to ibv context.
  46  *
  47  * @return
  48  *   Pointer to device name if ctx is valid, NULL otherwise.
  49  */
  50 static inline const char *
  51 mlx5_os_get_ctx_device_name(void *ctx)
  52 {
  53         if (!ctx)
  54                 return NULL;
  55         return ((struct ibv_context *)ctx)->device->name;
  56 }
  57
  58 /**
  59  * Get ibv device path name. Given an ibv_context pointer - return a
  60  * pointer to the corresponding device path name.
  61  *
  62  * @param[in] ctx
  63  *   Pointer to ibv context.
  64  *
  65  * @return
  66  *   Pointer to device path name if ctx is valid, NULL otherwise.
  67  */
  68
  69 static inline const char *
  70 mlx5_os_get_ctx_device_path(void *ctx)
  71 {
  72         if (!ctx)
  73                 return NULL;
  74
  75         return ((struct ibv_context *)ctx)->device->ibdev_path;
  76 }
  77
  78 /**
  79  * Get umem id. Given a pointer to umem object of type
  80  * 'struct mlx5dv_devx_umem *' - return its id.
  81  *
  82  * @param[in] umem
  83  *    Pointer to umem object.
  84  *
  85  * @return
  86  *    The umem id if umem is valid, 0 otherwise.
  87  */
  88 static inline uint32_t
  89 mlx5_os_get_umem_id(void *umem)
  90 {
  91         if (!umem)
  92                 return 0;
  93         return ((struct mlx5dv_devx_umem *)umem)->umem_id;
  94 }
  95
  96 /**
  97  * Get fd. Given a pointer to DevX channel object of type
  98  * 'struct mlx5dv_devx_event_channel*' - return its fd.
  99  *
 100  * @param[in] channel
 101  *    Pointer to channel object.
 102  *
 103  * @return
 104  *    The fd if channel is valid, 0 otherwise.
 105  */
 106 static inline int
 107 mlx5_os_get_devx_channel_fd(void *channel)
 108 {
 109         if (!channel)
 110                 return 0;
 111         return ((struct mlx5dv_devx_event_channel *)channel)->fd;
 112 }
 113
 114 /**
 115  * Get mmap offset. Given a pointer to an DevX UAR object of type
 116  * 'struct mlx5dv_devx_uar *' - return its mmap offset.
 117  *
 118  * @param[in] uar
 119  *    Pointer to UAR object.
 120  *
 121  * @return
 122  *    The mmap offset if uar is valid, 0 otherwise.
 123  */
 124 static inline off_t
 125 mlx5_os_get_devx_uar_mmap_offset(void *uar)
 126 {
 127 #ifdef HAVE_MLX5DV_DEVX_UAR_OFFSET
 128         if (!uar)
 129                 return 0;
 130         return ((struct mlx5dv_devx_uar *)uar)->mmap_off;
 131 #else
 132         RTE_SET_USED(uar);
 133         return 0;
 134 #endif
 135 }
 136
 137 /**
 138  * Get base addr pointer. Given a pointer to an UAR object of type
 139  * 'struct mlx5dv_devx_uar *' - return its base address.
 140  *
 141  * @param[in] uar
 142  *    Pointer to an UAR object.
 143  *
 144  * @return
 145  *    The base address if UAR is valid, 0 otherwise.
 146  */
 147 static inline void *
 148 mlx5_os_get_devx_uar_base_addr(void *uar)
 149 {
 150 #ifdef HAVE_MLX5DV_DEVX_UAR_OFFSET
 151         if (!uar)
 152                 return NULL;
 153         return ((struct mlx5dv_devx_uar *)uar)->base_addr;
 154 #else
 155         RTE_SET_USED(uar);
 156         return NULL;
 157 #endif
 158 }
 159
 160 /**
 161  * Get reg addr pointer. Given a pointer to an UAR object of type
 162  * 'struct mlx5dv_devx_uar *' - return its reg address.
 163  *
 164  * @param[in] uar
 165  *    Pointer to an UAR object.
 166  *
 167  * @return
 168  *    The reg address if UAR is valid, 0 otherwise.
 169  */
 170 static inline void *
 171 mlx5_os_get_devx_uar_reg_addr(void *uar)
 172 {
 173 #ifdef HAVE_MLX5DV_DEVX_UAR_OFFSET
 174         if (!uar)
 175                 return NULL;
 176         return ((struct mlx5dv_devx_uar *)uar)->reg_addr;
 177 #else
 178         RTE_SET_USED(uar);
 179         return NULL;
 180 #endif
 181 }
 182
 183 /**
 184  * Get page id. Given a pointer to an UAR object of type
 185  * 'struct mlx5dv_devx_uar *' - return its page id.
 186  *
 187  * @param[in] uar
 188  *    Pointer to an UAR object.
 189  *
 190  * @return
 191  *    The page id if UAR is valid, 0 otherwise.
 192  */
 193 static inline uint32_t
 194 mlx5_os_get_devx_uar_page_id(void *uar)
 195 {
 196 #ifdef HAVE_MLX5DV_DEVX_UAR_OFFSET
 197         if (!uar)
 198                 return 0;
 199         return ((struct mlx5dv_devx_uar *)uar)->page_id;
 200 #else
 201         RTE_SET_USED(uar);
 202         return 0;
 203 #endif
 204 }
 205
 206 static inline void *
 207 mlx5_os_alloc_pd(void *ctx)
 208 {
 209         return mlx5_glue->alloc_pd(ctx);
 210 }
 211
 212 static inline int
 213 mlx5_os_dealloc_pd(void *pd)
 214 {
 215         return mlx5_glue->dealloc_pd(pd);
 216 }
 217
 218 static inline void *
 219 mlx5_os_umem_reg(void *ctx, void *addr, size_t size, uint32_t access)
 220 {
 221         return mlx5_glue->devx_umem_reg(ctx, addr, size, access);
 222 }
 223
 224 static inline int
 225 mlx5_os_umem_dereg(void *pumem)
 226 {
 227         return mlx5_glue->devx_umem_dereg(pumem);
 228 }
 229
 230 static inline void *
 231 mlx5_os_devx_create_event_channel(void *ctx, int flags)
 232 {
 233         return mlx5_glue->devx_create_event_channel(ctx, flags);
 234 }
 235
 236 static inline void
 237 mlx5_os_devx_destroy_event_channel(void *eventc)
 238 {
 239         mlx5_glue->devx_destroy_event_channel(eventc);
 240 }
 241
 242 static inline int
 243 mlx5_os_devx_subscribe_devx_event(void *eventc,
 244                                   void *obj,
 245                                   uint16_t events_sz, uint16_t events_num[],
 246                                   uint64_t cookie)
 247 {
 248         return mlx5_glue->devx_subscribe_devx_event(eventc, obj, events_sz,
 249                                                     events_num, cookie);
 250 }
 251
 252 /**
 253  * Memory allocation optionally with alignment.
 254  *
 255  * @param[in] align
 256  *    Alignment size (may be zero)
 257  * @param[in] size
 258  *    Size in bytes to allocate
 259  *
 260  * @return
 261  *    Valid pointer to allocated memory, NULL in case of failure
 262  */
 263 static inline void *
 264 mlx5_os_malloc(size_t align, size_t size)
 265 {
 266         void *buf;
 267
 268         if (posix_memalign(&buf, align, size))
 269                 return NULL;
 270         return buf;
 271 }
 272
 273 /**
 274  * This API de-allocates a memory that originally could have been
 275  * allocated aligned or non-aligned. In Linux it is a wrapper
 276  * around free().
 277  *
 278  * @param[in] addr
 279  *    Pointer to address to free
 280  *
 281  */
 282 static inline void
 283 mlx5_os_free(void *addr)
 284 {
 285         free(addr);
 286 }
 287 #endif /* RTE_PMD_MLX5_COMMON_OS_H_ */