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 __rte_internal
 207 static inline void *
 208 mlx5_os_alloc_pd(void *ctx)
 209 {
 210         return mlx5_glue->alloc_pd(ctx);
 211 }
 212
 213 __rte_internal
 214 static inline int
 215 mlx5_os_dealloc_pd(void *pd)
 216 {
 217         return mlx5_glue->dealloc_pd(pd);
 218 }
 219
 220 __rte_internal
 221 static inline void *
 222 mlx5_os_umem_reg(void *ctx, void *addr, size_t size, uint32_t access)
 223 {
 224         return mlx5_glue->devx_umem_reg(ctx, addr, size, access);
 225 }
 226
 227 __rte_internal
 228 static inline int
 229 mlx5_os_umem_dereg(void *pumem)
 230 {
 231         return mlx5_glue->devx_umem_dereg(pumem);
 232 }
 233
 234 static inline void *
 235 mlx5_os_devx_create_event_channel(void *ctx, int flags)
 236 {
 237         return mlx5_glue->devx_create_event_channel(ctx, flags);
 238 }
 239
 240 static inline void
 241 mlx5_os_devx_destroy_event_channel(void *eventc)
 242 {
 243         mlx5_glue->devx_destroy_event_channel(eventc);
 244 }
 245
 246 static inline int
 247 mlx5_os_devx_subscribe_devx_event(void *eventc,
 248                                   void *obj,
 249                                   uint16_t events_sz, uint16_t events_num[],
 250                                   uint64_t cookie)
 251 {
 252         return mlx5_glue->devx_subscribe_devx_event(eventc, obj, events_sz,
 253                                                     events_num, cookie);
 254 }
 255
 256 /**
 257  * Memory allocation optionally with alignment.
 258  *
 259  * @param[in] align
 260  *    Alignment size (may be zero)
 261  * @param[in] size
 262  *    Size in bytes to allocate
 263  *
 264  * @return
 265  *    Valid pointer to allocated memory, NULL in case of failure
 266  */
 267 static inline void *
 268 mlx5_os_malloc(size_t align, size_t size)
 269 {
 270         void *buf;
 271
 272         if (posix_memalign(&buf, align, size))
 273                 return NULL;
 274         return buf;
 275 }
 276
 277 /**
 278  * This API de-allocates a memory that originally could have been
 279  * allocated aligned or non-aligned. In Linux it is a wrapper
 280  * around free().
 281  *
 282  * @param[in] addr
 283  *    Pointer to address to free
 284  *
 285  */
 286 static inline void
 287 mlx5_os_free(void *addr)
 288 {
 289         free(addr);
 290 }
 291
 292 void
 293 mlx5_set_context_attr(struct rte_device *dev, struct ibv_context *ctx);
 294
 295 #endif /* RTE_PMD_MLX5_COMMON_OS_H_ */