sys/dev/mlx5/mlx5_core/mlx5_vport.c

   1 /*-
   2  * Copyright (c) 2013-2017, Mellanox Technologies, Ltd.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  *
  13  * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS `AS IS' AND
  14  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  16  * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
  17  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  18  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  19  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  20  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  21  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  22  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  23  * SUCH DAMAGE.
  24  *
  25  * $FreeBSD$
  26  */
  27
  28 #include <linux/etherdevice.h>
  29 #include <dev/mlx5/driver.h>
  30 #include <dev/mlx5/vport.h>
  31 #include "mlx5_core.h"
  32
  33 static int mlx5_modify_nic_vport_context(struct mlx5_core_dev *mdev, void *in,
  34                                          int inlen);
  35
  36 static int _mlx5_query_vport_state(struct mlx5_core_dev *mdev, u8 opmod,
  37                                    u16 vport, u32 *out, int outlen)
  38 {
  39         int err;
  40         u32 in[MLX5_ST_SZ_DW(query_vport_state_in)] = {0};
  41
  42         MLX5_SET(query_vport_state_in, in, opcode,
  43                  MLX5_CMD_OP_QUERY_VPORT_STATE);
  44         MLX5_SET(query_vport_state_in, in, op_mod, opmod);
  45         MLX5_SET(query_vport_state_in, in, vport_number, vport);
  46         if (vport)
  47                 MLX5_SET(query_vport_state_in, in, other_vport, 1);
  48
  49         err = mlx5_cmd_exec(mdev, in, sizeof(in), out, outlen);
  50         if (err)
  51                 mlx5_core_warn(mdev, "MLX5_CMD_OP_QUERY_VPORT_STATE failed\n");
  52
  53         return err;
  54 }
  55
  56 u8 mlx5_query_vport_state(struct mlx5_core_dev *mdev, u8 opmod, u16 vport)
  57 {
  58         u32 out[MLX5_ST_SZ_DW(query_vport_state_out)] = {0};
  59
  60         _mlx5_query_vport_state(mdev, opmod, vport, out, sizeof(out));
  61
  62         return MLX5_GET(query_vport_state_out, out, state);
  63 }
  64 EXPORT_SYMBOL_GPL(mlx5_query_vport_state);
  65
  66 u8 mlx5_query_vport_admin_state(struct mlx5_core_dev *mdev, u8 opmod, u16 vport)
  67 {
  68         u32 out[MLX5_ST_SZ_DW(query_vport_state_out)] = {0};
  69
  70         _mlx5_query_vport_state(mdev, opmod, vport, out, sizeof(out));
  71
  72         return MLX5_GET(query_vport_state_out, out, admin_state);
  73 }
  74 EXPORT_SYMBOL(mlx5_query_vport_admin_state);
  75
  76 int mlx5_modify_vport_admin_state(struct mlx5_core_dev *mdev, u8 opmod,
  77                                   u16 vport, u8 state)
  78 {
  79         u32 in[MLX5_ST_SZ_DW(modify_vport_state_in)] = {0};
  80         u32 out[MLX5_ST_SZ_DW(modify_vport_state_out)] = {0};
  81         int err;
  82
  83         MLX5_SET(modify_vport_state_in, in, opcode,
  84                  MLX5_CMD_OP_MODIFY_VPORT_STATE);
  85         MLX5_SET(modify_vport_state_in, in, op_mod, opmod);
  86         MLX5_SET(modify_vport_state_in, in, vport_number, vport);
  87
  88         if (vport)
  89                 MLX5_SET(modify_vport_state_in, in, other_vport, 1);
  90
  91         MLX5_SET(modify_vport_state_in, in, admin_state, state);
  92
  93         err = mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
  94         if (err)
  95                 mlx5_core_warn(mdev, "MLX5_CMD_OP_MODIFY_VPORT_STATE failed\n");
  96
  97         return err;
  98 }
  99 EXPORT_SYMBOL(mlx5_modify_vport_admin_state);
 100
 101 static int mlx5_query_nic_vport_context(struct mlx5_core_dev *mdev, u16 vport,
 102                                         u32 *out, int outlen)
 103 {
 104         u32 in[MLX5_ST_SZ_DW(query_nic_vport_context_in)] = {0};
 105
 106         MLX5_SET(query_nic_vport_context_in, in, opcode,
 107                  MLX5_CMD_OP_QUERY_NIC_VPORT_CONTEXT);
 108
 109         MLX5_SET(query_nic_vport_context_in, in, vport_number, vport);
 110         if (vport)
 111                 MLX5_SET(query_nic_vport_context_in, in, other_vport, 1);
 112
 113         return mlx5_cmd_exec(mdev, in, sizeof(in), out, outlen);
 114 }
 115
 116 static u32 mlx5_vport_max_q_counter_allocator(struct mlx5_core_dev *mdev,
 117                                               int client_id)
 118 {
 119         switch (client_id) {
 120         case MLX5_INTERFACE_PROTOCOL_IB:
 121                 return (MLX5_CAP_GEN(mdev, max_qp_cnt) -
 122                         MLX5_QCOUNTER_SETS_NETDEV);
 123         case MLX5_INTERFACE_PROTOCOL_ETH:
 124                 return MLX5_QCOUNTER_SETS_NETDEV;
 125         default:
 126                 mlx5_core_warn(mdev, "Unknown Client: %d\n", client_id);
 127                 return 0;
 128         }
 129 }
 130
 131 int mlx5_vport_alloc_q_counter(struct mlx5_core_dev *mdev,
 132                                int client_id, u16 *counter_set_id)
 133 {
 134         u32 in[MLX5_ST_SZ_DW(alloc_q_counter_in)] = {0};
 135         u32 out[MLX5_ST_SZ_DW(alloc_q_counter_out)] = {0};
 136         int err;
 137
 138         if (mdev->num_q_counter_allocated[client_id] >
 139             mlx5_vport_max_q_counter_allocator(mdev, client_id))
 140                 return -EINVAL;
 141
 142         MLX5_SET(alloc_q_counter_in, in, opcode,
 143                  MLX5_CMD_OP_ALLOC_Q_COUNTER);
 144
 145         err = mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
 146
 147         if (!err)
 148                 *counter_set_id = MLX5_GET(alloc_q_counter_out, out,
 149                                            counter_set_id);
 150
 151         mdev->num_q_counter_allocated[client_id]++;
 152
 153         return err;
 154 }
 155
 156 int mlx5_vport_dealloc_q_counter(struct mlx5_core_dev *mdev,
 157                                  int client_id, u16 counter_set_id)
 158 {
 159         u32 in[MLX5_ST_SZ_DW(dealloc_q_counter_in)] = {0};
 160         u32 out[MLX5_ST_SZ_DW(dealloc_q_counter_out)] = {0};
 161         int err;
 162
 163         if (mdev->num_q_counter_allocated[client_id] <= 0)
 164                 return -EINVAL;
 165
 166         MLX5_SET(dealloc_q_counter_in, in, opcode,
 167                  MLX5_CMD_OP_DEALLOC_Q_COUNTER);
 168         MLX5_SET(dealloc_q_counter_in, in, counter_set_id,
 169                  counter_set_id);
 170
 171         err = mlx5_cmd_exec(mdev, in, sizeof(in), out, sizeof(out));
 172
 173         mdev->num_q_counter_allocated[client_id]--;
 174
 175         return err;
 176 }
 177
 178 int mlx5_vport_query_q_counter(struct mlx5_core_dev *mdev,
 179                                       u16 counter_set_id,
 180                                       int reset,
 181                                       void *out,
 182                                       int out_size)
 183 {
 184         u32 in[MLX5_ST_SZ_DW(query_q_counter_in)] = {0};
 185
 186         MLX5_SET(query_q_counter_in, in, opcode, MLX5_CMD_OP_QUERY_Q_COUNTER);
 187         MLX5_SET(query_q_counter_in, in, clear, reset);
 188         MLX5_SET(query_q_counter_in, in, counter_set_id, counter_set_id);
 189
 190         return mlx5_cmd_exec(mdev, in, sizeof(in), out, out_size);
 191 }
 192
 193 int mlx5_vport_query_out_of_rx_buffer(struct mlx5_core_dev *mdev,
 194                                       u16 counter_set_id,
 195                                       u32 *out_of_rx_buffer)
 196 {
 197         u32 out[MLX5_ST_SZ_DW(query_q_counter_out)] = {0};
 198         int err;
 199
 200         err = mlx5_vport_query_q_counter(mdev, counter_set_id, 0, out,
 201                                          sizeof(out));
 202
 203         if (err)
 204                 return err;
 205
 206         *out_of_rx_buffer = MLX5_GET(query_q_counter_out, out,
 207                                      out_of_buffer);
 208         return err;
 209 }
 210
 211 int mlx5_query_nic_vport_min_inline(struct mlx5_core_dev *mdev,
 212                                     u16 vport, u8 *min_inline)
 213 {
 214         u32 out[MLX5_ST_SZ_DW(query_nic_vport_context_out)] = {0};
 215         int err;
 216
 217         err = mlx5_query_nic_vport_context(mdev, vport, out, sizeof(out));
 218         if (!err)
 219                 *min_inline = MLX5_GET(query_nic_vport_context_out, out,
 220                                        nic_vport_context.min_wqe_inline_mode);
 221         return err;
 222 }
 223 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_min_inline);
 224
 225 int mlx5_query_min_inline(struct mlx5_core_dev *mdev,
 226                           u8 *min_inline_mode)
 227 {
 228         int err;
 229
 230         switch (MLX5_CAP_ETH(mdev, wqe_inline_mode)) {
 231         case MLX5_CAP_INLINE_MODE_L2:
 232                 *min_inline_mode = MLX5_INLINE_MODE_L2;
 233                 err = 0;
 234                 break;
 235         case MLX5_CAP_INLINE_MODE_VPORT_CONTEXT:
 236                 err = mlx5_query_nic_vport_min_inline(mdev, 0, min_inline_mode);
 237                 break;
 238         case MLX5_CAP_INLINE_MODE_NOT_REQUIRED:
 239                 *min_inline_mode = MLX5_INLINE_MODE_NONE;
 240                 err = 0;
 241                 break;
 242         default:
 243                 err = -EINVAL;
 244                 break;
 245         }
 246         return err;
 247 }
 248 EXPORT_SYMBOL_GPL(mlx5_query_min_inline);
 249
 250 int mlx5_modify_nic_vport_min_inline(struct mlx5_core_dev *mdev,
 251                                      u16 vport, u8 min_inline)
 252 {
 253         u32 in[MLX5_ST_SZ_DW(modify_nic_vport_context_in)] = {0};
 254         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
 255         void *nic_vport_ctx;
 256
 257         MLX5_SET(modify_nic_vport_context_in, in,
 258                  field_select.min_wqe_inline_mode, 1);
 259         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
 260         MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
 261
 262         nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in,
 263                                      in, nic_vport_context);
 264         MLX5_SET(nic_vport_context, nic_vport_ctx,
 265                  min_wqe_inline_mode, min_inline);
 266
 267         return mlx5_modify_nic_vport_context(mdev, in, inlen);
 268 }
 269 EXPORT_SYMBOL_GPL(mlx5_modify_nic_vport_min_inline);
 270
 271 int mlx5_query_nic_vport_mac_address(struct mlx5_core_dev *mdev,
 272                                      u16 vport, u8 *addr)
 273 {
 274         u32 *out;
 275         int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 276         u8 *out_addr;
 277         int err;
 278
 279         out = mlx5_vzalloc(outlen);
 280         if (!out)
 281                 return -ENOMEM;
 282
 283         out_addr = MLX5_ADDR_OF(query_nic_vport_context_out, out,
 284                                 nic_vport_context.permanent_address);
 285
 286         err = mlx5_query_nic_vport_context(mdev, vport, out, outlen);
 287         if (err)
 288                 goto out;
 289
 290         ether_addr_copy(addr, &out_addr[2]);
 291
 292 out:
 293         kvfree(out);
 294         return err;
 295 }
 296 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_mac_address);
 297
 298 int mlx5_modify_nic_vport_mac_address(struct mlx5_core_dev *mdev,
 299                                       u16 vport, u8 *addr)
 300 {
 301         void *in;
 302         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
 303         int err;
 304         void *nic_vport_ctx;
 305         u8 *perm_mac;
 306
 307         in = mlx5_vzalloc(inlen);
 308         if (!in) {
 309                 mlx5_core_warn(mdev, "failed to allocate inbox\n");
 310                 return -ENOMEM;
 311         }
 312
 313         MLX5_SET(modify_nic_vport_context_in, in,
 314                  field_select.permanent_address, 1);
 315         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
 316
 317         if (vport)
 318                 MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
 319
 320         nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in,
 321                                      in, nic_vport_context);
 322         perm_mac = MLX5_ADDR_OF(nic_vport_context, nic_vport_ctx,
 323                                 permanent_address);
 324
 325         ether_addr_copy(&perm_mac[2], addr);
 326
 327         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
 328
 329         kvfree(in);
 330
 331         return err;
 332 }
 333 EXPORT_SYMBOL(mlx5_modify_nic_vport_mac_address);
 334
 335 int mlx5_query_nic_vport_system_image_guid(struct mlx5_core_dev *mdev,
 336                                            u64 *system_image_guid)
 337 {
 338         u32 *out;
 339         int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 340         int err;
 341
 342         out = mlx5_vzalloc(outlen);
 343         if (!out)
 344                 return -ENOMEM;
 345
 346         err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
 347         if (err)
 348                 goto out;
 349
 350         *system_image_guid = MLX5_GET64(query_nic_vport_context_out, out,
 351                                         nic_vport_context.system_image_guid);
 352 out:
 353         kvfree(out);
 354         return err;
 355 }
 356 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_system_image_guid);
 357
 358 int mlx5_query_nic_vport_node_guid(struct mlx5_core_dev *mdev, u64 *node_guid)
 359 {
 360         u32 *out;
 361         int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 362         int err;
 363
 364         out = mlx5_vzalloc(outlen);
 365         if (!out)
 366                 return -ENOMEM;
 367
 368         err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
 369         if (err)
 370                 goto out;
 371
 372         *node_guid = MLX5_GET64(query_nic_vport_context_out, out,
 373                                 nic_vport_context.node_guid);
 374
 375 out:
 376         kvfree(out);
 377         return err;
 378 }
 379 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_node_guid);
 380
 381 static int mlx5_query_nic_vport_port_guid(struct mlx5_core_dev *mdev,
 382                                           u64 *port_guid)
 383 {
 384         u32 *out;
 385         int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 386         int err;
 387
 388         out = mlx5_vzalloc(outlen);
 389         if (!out)
 390                 return -ENOMEM;
 391
 392         err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
 393         if (err)
 394                 goto out;
 395
 396         *port_guid = MLX5_GET64(query_nic_vport_context_out, out,
 397                                 nic_vport_context.port_guid);
 398
 399 out:
 400         kvfree(out);
 401         return err;
 402 }
 403
 404 int mlx5_query_nic_vport_qkey_viol_cntr(struct mlx5_core_dev *mdev,
 405                                         u16 *qkey_viol_cntr)
 406 {
 407         u32 *out;
 408         int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 409         int err;
 410
 411         out = mlx5_vzalloc(outlen);
 412         if (!out)
 413                 return -ENOMEM;
 414
 415         err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
 416         if (err)
 417                 goto out;
 418
 419         *qkey_viol_cntr = MLX5_GET(query_nic_vport_context_out, out,
 420                                 nic_vport_context.qkey_violation_counter);
 421
 422 out:
 423         kvfree(out);
 424         return err;
 425 }
 426 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_qkey_viol_cntr);
 427
 428 static int mlx5_modify_nic_vport_context(struct mlx5_core_dev *mdev, void *in,
 429                                          int inlen)
 430 {
 431         u32 out[MLX5_ST_SZ_DW(modify_nic_vport_context_out)] = {0};
 432
 433         MLX5_SET(modify_nic_vport_context_in, in, opcode,
 434                  MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT);
 435
 436         return mlx5_cmd_exec(mdev, in, inlen, out, sizeof(out));
 437 }
 438
 439 static int mlx5_nic_vport_enable_disable_roce(struct mlx5_core_dev *mdev,
 440                                               int enable_disable)
 441 {
 442         void *in;
 443         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
 444         int err;
 445
 446         in = mlx5_vzalloc(inlen);
 447         if (!in) {
 448                 mlx5_core_warn(mdev, "failed to allocate inbox\n");
 449                 return -ENOMEM;
 450         }
 451
 452         MLX5_SET(modify_nic_vport_context_in, in, field_select.roce_en, 1);
 453         MLX5_SET(modify_nic_vport_context_in, in, nic_vport_context.roce_en,
 454                  enable_disable);
 455
 456         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
 457
 458         kvfree(in);
 459
 460         return err;
 461 }
 462
 463 int mlx5_set_nic_vport_current_mac(struct mlx5_core_dev *mdev, int vport,
 464                                    bool other_vport, u8 *addr)
 465 {
 466         void *in;
 467         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in)
 468                   + MLX5_ST_SZ_BYTES(mac_address_layout);
 469         u8  *mac_layout;
 470         u8  *mac_ptr;
 471         int err;
 472
 473         in = mlx5_vzalloc(inlen);
 474         if (!in) {
 475                 mlx5_core_warn(mdev, "failed to allocate inbox\n");
 476                 return -ENOMEM;
 477         }
 478
 479         MLX5_SET(modify_nic_vport_context_in, in,
 480                  opcode, MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT);
 481         MLX5_SET(modify_nic_vport_context_in, in,
 482                  vport_number, vport);
 483         MLX5_SET(modify_nic_vport_context_in, in,
 484                  other_vport, other_vport);
 485         MLX5_SET(modify_nic_vport_context_in, in,
 486                  field_select.addresses_list, 1);
 487         MLX5_SET(modify_nic_vport_context_in, in,
 488                  nic_vport_context.allowed_list_type,
 489                  MLX5_NIC_VPORT_LIST_TYPE_UC);
 490         MLX5_SET(modify_nic_vport_context_in, in,
 491                  nic_vport_context.allowed_list_size, 1);
 492
 493         mac_layout = (u8 *)MLX5_ADDR_OF(modify_nic_vport_context_in, in,
 494                 nic_vport_context.current_uc_mac_address);
 495         mac_ptr = (u8 *)MLX5_ADDR_OF(mac_address_layout, mac_layout,
 496                 mac_addr_47_32);
 497         ether_addr_copy(mac_ptr, addr);
 498
 499         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
 500
 501         kvfree(in);
 502
 503         return err;
 504 }
 505 EXPORT_SYMBOL_GPL(mlx5_set_nic_vport_current_mac);
 506
 507 int mlx5_modify_nic_vport_node_guid(struct mlx5_core_dev *mdev,
 508                                     u32 vport, u64 node_guid)
 509 {
 510         void *in;
 511         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
 512         int err;
 513         void *nic_vport_context;
 514
 515         if (!vport)
 516                 return -EINVAL;
 517         if (!MLX5_CAP_GEN(mdev, vport_group_manager))
 518                 return -EPERM;
 519         if (!MLX5_CAP_ESW(mdev, nic_vport_node_guid_modify))
 520                 return -ENOTSUPP;
 521
 522         in = mlx5_vzalloc(inlen);
 523         if (!in) {
 524                 mlx5_core_warn(mdev, "failed to allocate inbox\n");
 525                 return -ENOMEM;
 526         }
 527
 528         MLX5_SET(modify_nic_vport_context_in, in,
 529                  field_select.node_guid, 1);
 530         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
 531
 532         MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
 533
 534         nic_vport_context = MLX5_ADDR_OF(modify_nic_vport_context_in,
 535                                          in, nic_vport_context);
 536         MLX5_SET64(nic_vport_context, nic_vport_context, node_guid, node_guid);
 537
 538         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
 539
 540         kvfree(in);
 541
 542         return err;
 543 }
 544 EXPORT_SYMBOL(mlx5_modify_nic_vport_node_guid);
 545
 546 int mlx5_modify_nic_vport_port_guid(struct mlx5_core_dev *mdev,
 547                                     u32 vport, u64 port_guid)
 548 {
 549         void *in;
 550         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
 551         int err;
 552         void *nic_vport_context;
 553
 554         if (!vport)
 555                 return -EINVAL;
 556         if (!MLX5_CAP_GEN(mdev, vport_group_manager))
 557                 return -EPERM;
 558         if (!MLX5_CAP_ESW(mdev, nic_vport_port_guid_modify))
 559                 return -ENOTSUPP;
 560
 561         in = mlx5_vzalloc(inlen);
 562         if (!in) {
 563                 mlx5_core_warn(mdev, "failed to allocate inbox\n");
 564                 return -ENOMEM;
 565         }
 566
 567         MLX5_SET(modify_nic_vport_context_in, in,
 568                  field_select.port_guid, 1);
 569         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
 570
 571         MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
 572
 573         nic_vport_context = MLX5_ADDR_OF(modify_nic_vport_context_in,
 574                                          in, nic_vport_context);
 575         MLX5_SET64(nic_vport_context, nic_vport_context, port_guid, port_guid);
 576
 577         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
 578
 579         kvfree(in);
 580
 581         return err;
 582 }
 583 EXPORT_SYMBOL(mlx5_modify_nic_vport_port_guid);
 584
 585 int mlx5_set_nic_vport_vlan_list(struct mlx5_core_dev *dev, u16 vport,
 586                                  u16 *vlan_list, int list_len)
 587 {
 588         void *in, *ctx;
 589         int i, err;
 590         int  inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in)
 591                 + MLX5_ST_SZ_BYTES(vlan_layout) * (int)list_len;
 592
 593         int max_list_size = 1 << MLX5_CAP_GEN_MAX(dev, log_max_vlan_list);
 594
 595         if (list_len > max_list_size) {
 596                 mlx5_core_warn(dev, "Requested list size (%d) > (%d) max_list_size\n",
 597                                list_len, max_list_size);
 598                 return -ENOSPC;
 599         }
 600
 601         in = mlx5_vzalloc(inlen);
 602         if (!in) {
 603                 mlx5_core_warn(dev, "failed to allocate inbox\n");
 604                 return -ENOMEM;
 605         }
 606
 607         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
 608         if (vport)
 609                 MLX5_SET(modify_nic_vport_context_in, in,
 610                          other_vport, 1);
 611         MLX5_SET(modify_nic_vport_context_in, in,
 612                  field_select.addresses_list, 1);
 613
 614         ctx = MLX5_ADDR_OF(modify_nic_vport_context_in, in, nic_vport_context);
 615
 616         MLX5_SET(nic_vport_context, ctx, allowed_list_type,
 617                  MLX5_NIC_VPORT_LIST_TYPE_VLAN);
 618         MLX5_SET(nic_vport_context, ctx, allowed_list_size, list_len);
 619
 620         for (i = 0; i < list_len; i++) {
 621                 u8 *vlan_lout = MLX5_ADDR_OF(nic_vport_context, ctx,
 622                                          current_uc_mac_address[i]);
 623                 MLX5_SET(vlan_layout, vlan_lout, vlan, vlan_list[i]);
 624         }
 625
 626         err = mlx5_modify_nic_vport_context(dev, in, inlen);
 627
 628         kvfree(in);
 629         return err;
 630 }
 631 EXPORT_SYMBOL_GPL(mlx5_set_nic_vport_vlan_list);
 632
 633 int mlx5_set_nic_vport_mc_list(struct mlx5_core_dev *mdev, int vport,
 634                                u64 *addr_list, size_t addr_list_len)
 635 {
 636         void *in, *ctx;
 637         int  inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in)
 638                   + MLX5_ST_SZ_BYTES(mac_address_layout) * (int)addr_list_len;
 639         int err;
 640         size_t i;
 641         int max_list_sz = 1 << MLX5_CAP_GEN_MAX(mdev, log_max_current_mc_list);
 642
 643         if ((int)addr_list_len > max_list_sz) {
 644                 mlx5_core_warn(mdev, "Requested list size (%d) > (%d) max_list_size\n",
 645                                (int)addr_list_len, max_list_sz);
 646                 return -ENOSPC;
 647         }
 648
 649         in = mlx5_vzalloc(inlen);
 650         if (!in) {
 651                 mlx5_core_warn(mdev, "failed to allocate inbox\n");
 652                 return -ENOMEM;
 653         }
 654
 655         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
 656         if (vport)
 657                 MLX5_SET(modify_nic_vport_context_in, in,
 658                          other_vport, 1);
 659         MLX5_SET(modify_nic_vport_context_in, in,
 660                  field_select.addresses_list, 1);
 661
 662         ctx = MLX5_ADDR_OF(modify_nic_vport_context_in, in, nic_vport_context);
 663
 664         MLX5_SET(nic_vport_context, ctx, allowed_list_type,
 665                  MLX5_NIC_VPORT_LIST_TYPE_MC);
 666         MLX5_SET(nic_vport_context, ctx, allowed_list_size, addr_list_len);
 667
 668         for (i = 0; i < addr_list_len; i++) {
 669                 u8 *mac_lout = (u8 *)MLX5_ADDR_OF(nic_vport_context, ctx,
 670                                                   current_uc_mac_address[i]);
 671                 u8 *mac_ptr = (u8 *)MLX5_ADDR_OF(mac_address_layout, mac_lout,
 672                                                  mac_addr_47_32);
 673                 ether_addr_copy(mac_ptr, (u8 *)&addr_list[i]);
 674         }
 675
 676         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
 677
 678         kvfree(in);
 679
 680         return err;
 681 }
 682 EXPORT_SYMBOL_GPL(mlx5_set_nic_vport_mc_list);
 683
 684 int mlx5_set_nic_vport_promisc(struct mlx5_core_dev *mdev, int vport,
 685                                bool promisc_mc, bool promisc_uc,
 686                                bool promisc_all)
 687 {
 688         u8  in[MLX5_ST_SZ_BYTES(modify_nic_vport_context_in)];
 689         u8 *ctx = MLX5_ADDR_OF(modify_nic_vport_context_in, in,
 690                                nic_vport_context);
 691
 692         memset(in, 0, MLX5_ST_SZ_BYTES(modify_nic_vport_context_in));
 693
 694         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
 695         if (vport)
 696                 MLX5_SET(modify_nic_vport_context_in, in,
 697                          other_vport, 1);
 698         MLX5_SET(modify_nic_vport_context_in, in, field_select.promisc, 1);
 699         if (promisc_mc)
 700                 MLX5_SET(nic_vport_context, ctx, promisc_mc, 1);
 701         if (promisc_uc)
 702                 MLX5_SET(nic_vport_context, ctx, promisc_uc, 1);
 703         if (promisc_all)
 704                 MLX5_SET(nic_vport_context, ctx, promisc_all, 1);
 705
 706         return mlx5_modify_nic_vport_context(mdev, in, sizeof(in));
 707 }
 708 EXPORT_SYMBOL_GPL(mlx5_set_nic_vport_promisc);
 709
 710 int mlx5_query_nic_vport_mac_list(struct mlx5_core_dev *dev,
 711                                   u16 vport,
 712                                   enum mlx5_list_type list_type,
 713                                   u8 addr_list[][ETH_ALEN],
 714                                   int *list_size)
 715 {
 716         u32 in[MLX5_ST_SZ_DW(query_nic_vport_context_in)] = {0};
 717         void *nic_vport_ctx;
 718         int max_list_size;
 719         int req_list_size;
 720         int out_sz;
 721         void *out;
 722         int err;
 723         int i;
 724
 725         req_list_size = *list_size;
 726
 727         max_list_size = (list_type == MLX5_NIC_VPORT_LIST_TYPE_UC) ?
 728                         1 << MLX5_CAP_GEN_MAX(dev, log_max_current_uc_list) :
 729                         1 << MLX5_CAP_GEN_MAX(dev, log_max_current_mc_list);
 730
 731         if (req_list_size > max_list_size) {
 732                 mlx5_core_warn(dev, "Requested list size (%d) > (%d) max_list_size\n",
 733                                req_list_size, max_list_size);
 734                 req_list_size = max_list_size;
 735         }
 736
 737         out_sz = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in) +
 738                  req_list_size * MLX5_ST_SZ_BYTES(mac_address_layout);
 739
 740         out = kzalloc(out_sz, GFP_KERNEL);
 741         if (!out)
 742                 return -ENOMEM;
 743
 744         MLX5_SET(query_nic_vport_context_in, in, opcode,
 745                  MLX5_CMD_OP_QUERY_NIC_VPORT_CONTEXT);
 746         MLX5_SET(query_nic_vport_context_in, in, allowed_list_type, list_type);
 747         MLX5_SET(query_nic_vport_context_in, in, vport_number, vport);
 748
 749         if (vport)
 750                 MLX5_SET(query_nic_vport_context_in, in, other_vport, 1);
 751
 752         err = mlx5_cmd_exec(dev, in, sizeof(in), out, out_sz);
 753         if (err)
 754                 goto out;
 755
 756         nic_vport_ctx = MLX5_ADDR_OF(query_nic_vport_context_out, out,
 757                                      nic_vport_context);
 758         req_list_size = MLX5_GET(nic_vport_context, nic_vport_ctx,
 759                                  allowed_list_size);
 760
 761         *list_size = req_list_size;
 762         for (i = 0; i < req_list_size; i++) {
 763                 u8 *mac_addr = MLX5_ADDR_OF(nic_vport_context,
 764                                         nic_vport_ctx,
 765                                         current_uc_mac_address[i]) + 2;
 766                 ether_addr_copy(addr_list[i], mac_addr);
 767         }
 768 out:
 769         kfree(out);
 770         return err;
 771 }
 772 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_mac_list);
 773
 774 int mlx5_modify_nic_vport_mac_list(struct mlx5_core_dev *dev,
 775                                    enum mlx5_list_type list_type,
 776                                    u8 addr_list[][ETH_ALEN],
 777                                    int list_size)
 778 {
 779         u32 out[MLX5_ST_SZ_DW(modify_nic_vport_context_out)] = {0};
 780         void *nic_vport_ctx;
 781         int max_list_size;
 782         int in_sz;
 783         void *in;
 784         int err;
 785         int i;
 786
 787         max_list_size = list_type == MLX5_NIC_VPORT_LIST_TYPE_UC ?
 788                  1 << MLX5_CAP_GEN(dev, log_max_current_uc_list) :
 789                  1 << MLX5_CAP_GEN(dev, log_max_current_mc_list);
 790
 791         if (list_size > max_list_size)
 792                 return -ENOSPC;
 793
 794         in_sz = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in) +
 795                 list_size * MLX5_ST_SZ_BYTES(mac_address_layout);
 796
 797         in = kzalloc(in_sz, GFP_KERNEL);
 798         if (!in)
 799                 return -ENOMEM;
 800
 801         MLX5_SET(modify_nic_vport_context_in, in, opcode,
 802                  MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT);
 803         MLX5_SET(modify_nic_vport_context_in, in,
 804                  field_select.addresses_list, 1);
 805
 806         nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in, in,
 807                                      nic_vport_context);
 808
 809         MLX5_SET(nic_vport_context, nic_vport_ctx,
 810                  allowed_list_type, list_type);
 811         MLX5_SET(nic_vport_context, nic_vport_ctx,
 812                  allowed_list_size, list_size);
 813
 814         for (i = 0; i < list_size; i++) {
 815                 u8 *curr_mac = MLX5_ADDR_OF(nic_vport_context,
 816                                             nic_vport_ctx,
 817                                             current_uc_mac_address[i]) + 2;
 818                 ether_addr_copy(curr_mac, addr_list[i]);
 819         }
 820
 821         err = mlx5_cmd_exec(dev, in, in_sz, out, sizeof(out));
 822         kfree(in);
 823         return err;
 824 }
 825 EXPORT_SYMBOL_GPL(mlx5_modify_nic_vport_mac_list);
 826
 827 int mlx5_query_nic_vport_vlans(struct mlx5_core_dev *dev,
 828                                u16 vport,
 829                                u16 vlans[],
 830                                int *size)
 831 {
 832         u32 in[MLX5_ST_SZ_DW(query_nic_vport_context_in)] = {0};
 833         void *nic_vport_ctx;
 834         int req_list_size;
 835         int max_list_size;
 836         int out_sz;
 837         void *out;
 838         int err;
 839         int i;
 840
 841         req_list_size = *size;
 842         max_list_size = 1 << MLX5_CAP_GEN(dev, log_max_vlan_list);
 843         if (req_list_size > max_list_size) {
 844                 mlx5_core_warn(dev, "Requested list size (%d) > (%d) max list size\n",
 845                                req_list_size, max_list_size);
 846                 req_list_size = max_list_size;
 847         }
 848
 849         out_sz = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in) +
 850                  req_list_size * MLX5_ST_SZ_BYTES(vlan_layout);
 851
 852         out = kzalloc(out_sz, GFP_KERNEL);
 853         if (!out)
 854                 return -ENOMEM;
 855
 856         MLX5_SET(query_nic_vport_context_in, in, opcode,
 857                  MLX5_CMD_OP_QUERY_NIC_VPORT_CONTEXT);
 858         MLX5_SET(query_nic_vport_context_in, in, allowed_list_type,
 859                  MLX5_NIC_VPORT_CONTEXT_ALLOWED_LIST_TYPE_VLAN_LIST);
 860         MLX5_SET(query_nic_vport_context_in, in, vport_number, vport);
 861
 862         if (vport)
 863                 MLX5_SET(query_nic_vport_context_in, in, other_vport, 1);
 864
 865         err = mlx5_cmd_exec(dev, in, sizeof(in), out, out_sz);
 866         if (err)
 867                 goto out;
 868
 869         nic_vport_ctx = MLX5_ADDR_OF(query_nic_vport_context_out, out,
 870                                      nic_vport_context);
 871         req_list_size = MLX5_GET(nic_vport_context, nic_vport_ctx,
 872                                  allowed_list_size);
 873
 874         *size = req_list_size;
 875         for (i = 0; i < req_list_size; i++) {
 876                 void *vlan_addr = MLX5_ADDR_OF(nic_vport_context,
 877                                                nic_vport_ctx,
 878                                          current_uc_mac_address[i]);
 879                 vlans[i] = MLX5_GET(vlan_layout, vlan_addr, vlan);
 880         }
 881 out:
 882         kfree(out);
 883         return err;
 884 }
 885 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_vlans);
 886
 887 int mlx5_modify_nic_vport_vlans(struct mlx5_core_dev *dev,
 888                                 u16 vlans[],
 889                                 int list_size)
 890 {
 891         u32 out[MLX5_ST_SZ_DW(modify_nic_vport_context_out)] = {0};
 892         void *nic_vport_ctx;
 893         int max_list_size;
 894         int in_sz;
 895         void *in;
 896         int err;
 897         int i;
 898
 899         max_list_size = 1 << MLX5_CAP_GEN(dev, log_max_vlan_list);
 900
 901         if (list_size > max_list_size)
 902                 return -ENOSPC;
 903
 904         in_sz = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in) +
 905                 list_size * MLX5_ST_SZ_BYTES(vlan_layout);
 906
 907         in = kzalloc(in_sz, GFP_KERNEL);
 908         if (!in)
 909                 return -ENOMEM;
 910
 911         MLX5_SET(modify_nic_vport_context_in, in, opcode,
 912                  MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT);
 913         MLX5_SET(modify_nic_vport_context_in, in,
 914                  field_select.addresses_list, 1);
 915
 916         nic_vport_ctx = MLX5_ADDR_OF(modify_nic_vport_context_in, in,
 917                                      nic_vport_context);
 918
 919         MLX5_SET(nic_vport_context, nic_vport_ctx,
 920                  allowed_list_type, MLX5_NIC_VPORT_LIST_TYPE_VLAN);
 921         MLX5_SET(nic_vport_context, nic_vport_ctx,
 922                  allowed_list_size, list_size);
 923
 924         for (i = 0; i < list_size; i++) {
 925                 void *vlan_addr = MLX5_ADDR_OF(nic_vport_context,
 926                                                nic_vport_ctx,
 927                                                current_uc_mac_address[i]);
 928                 MLX5_SET(vlan_layout, vlan_addr, vlan, vlans[i]);
 929         }
 930
 931         err = mlx5_cmd_exec(dev, in, in_sz, out, sizeof(out));
 932         kfree(in);
 933         return err;
 934 }
 935 EXPORT_SYMBOL_GPL(mlx5_modify_nic_vport_vlans);
 936
 937 int mlx5_query_nic_vport_roce_en(struct mlx5_core_dev *mdev, u8 *enable)
 938 {
 939         u32 *out;
 940         int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
 941         int err;
 942
 943         out = kzalloc(outlen, GFP_KERNEL);
 944         if (!out)
 945                 return -ENOMEM;
 946
 947         err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
 948         if (err)
 949                 goto out;
 950
 951         *enable = MLX5_GET(query_nic_vport_context_out, out,
 952                                 nic_vport_context.roce_en);
 953
 954 out:
 955         kfree(out);
 956         return err;
 957 }
 958 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_roce_en);
 959
 960 int mlx5_set_nic_vport_permanent_mac(struct mlx5_core_dev *mdev, int vport,
 961                                      u8 *addr)
 962 {
 963         void *in;
 964         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
 965         u8  *mac_ptr;
 966         int err;
 967
 968         in = mlx5_vzalloc(inlen);
 969         if (!in) {
 970                 mlx5_core_warn(mdev, "failed to allocate inbox\n");
 971                 return -ENOMEM;
 972         }
 973
 974         MLX5_SET(modify_nic_vport_context_in, in,
 975                  opcode, MLX5_CMD_OP_MODIFY_NIC_VPORT_CONTEXT);
 976         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
 977         MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
 978         MLX5_SET(modify_nic_vport_context_in, in,
 979                  field_select.permanent_address, 1);
 980         mac_ptr = (u8 *)MLX5_ADDR_OF(modify_nic_vport_context_in, in,
 981                 nic_vport_context.permanent_address.mac_addr_47_32);
 982         ether_addr_copy(mac_ptr, addr);
 983
 984         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
 985
 986         kvfree(in);
 987
 988         return err;
 989 }
 990 EXPORT_SYMBOL_GPL(mlx5_set_nic_vport_permanent_mac);
 991
 992 int mlx5_nic_vport_enable_roce(struct mlx5_core_dev *mdev)
 993 {
 994         return mlx5_nic_vport_enable_disable_roce(mdev, 1);
 995 }
 996 EXPORT_SYMBOL_GPL(mlx5_nic_vport_enable_roce);
 997
 998 int mlx5_nic_vport_disable_roce(struct mlx5_core_dev *mdev)
 999 {
1000         return mlx5_nic_vport_enable_disable_roce(mdev, 0);
1001 }
1002 EXPORT_SYMBOL_GPL(mlx5_nic_vport_disable_roce);
1003
1004 int mlx5_core_query_vport_counter(struct mlx5_core_dev *dev, u8 other_vport,
1005                                   int vf, u8 port_num, void *out,
1006                                   size_t out_sz)
1007 {
1008         int     in_sz = MLX5_ST_SZ_BYTES(query_vport_counter_in);
1009         int     is_group_manager;
1010         void   *in;
1011         int     err;
1012
1013         is_group_manager = MLX5_CAP_GEN(dev, vport_group_manager);
1014         in = mlx5_vzalloc(in_sz);
1015         if (!in) {
1016                 err = -ENOMEM;
1017                 return err;
1018         }
1019
1020         MLX5_SET(query_vport_counter_in, in, opcode,
1021                  MLX5_CMD_OP_QUERY_VPORT_COUNTER);
1022         if (other_vport) {
1023                 if (is_group_manager) {
1024                         MLX5_SET(query_vport_counter_in, in, other_vport, 1);
1025                         MLX5_SET(query_vport_counter_in, in, vport_number, vf + 1);
1026                 } else {
1027                         err = -EPERM;
1028                         goto free;
1029                 }
1030         }
1031         if (MLX5_CAP_GEN(dev, num_ports) == 2)
1032                 MLX5_SET(query_vport_counter_in, in, port_num, port_num);
1033
1034         err = mlx5_cmd_exec(dev, in, in_sz, out,  out_sz);
1035 free:
1036         kvfree(in);
1037         return err;
1038 }
1039 EXPORT_SYMBOL_GPL(mlx5_core_query_vport_counter);
1040
1041 int mlx5_query_hca_vport_context(struct mlx5_core_dev *mdev,
1042                                  u8 port_num, u8 vport_num, u32 *out,
1043                                  int outlen)
1044 {
1045         u32 in[MLX5_ST_SZ_DW(query_hca_vport_context_in)] = {0};
1046         int is_group_manager;
1047
1048         is_group_manager = MLX5_CAP_GEN(mdev, vport_group_manager);
1049
1050         MLX5_SET(query_hca_vport_context_in, in, opcode,
1051                  MLX5_CMD_OP_QUERY_HCA_VPORT_CONTEXT);
1052
1053         if (vport_num) {
1054                 if (is_group_manager) {
1055                         MLX5_SET(query_hca_vport_context_in, in, other_vport,
1056                                  1);
1057                         MLX5_SET(query_hca_vport_context_in, in, vport_number,
1058                                  vport_num);
1059                 } else {
1060                         return -EPERM;
1061                 }
1062         }
1063
1064         if (MLX5_CAP_GEN(mdev, num_ports) == 2)
1065                 MLX5_SET(query_hca_vport_context_in, in, port_num, port_num);
1066
1067         return mlx5_cmd_exec(mdev, in, sizeof(in), out, outlen);
1068 }
1069
1070 int mlx5_query_hca_vport_system_image_guid(struct mlx5_core_dev *mdev,
1071                                            u64 *system_image_guid)
1072 {
1073         u32 *out;
1074         int outlen = MLX5_ST_SZ_BYTES(query_hca_vport_context_out);
1075         int err;
1076
1077         out = mlx5_vzalloc(outlen);
1078         if (!out)
1079                 return -ENOMEM;
1080
1081         err = mlx5_query_hca_vport_context(mdev, 1, 0, out, outlen);
1082         if (err)
1083                 goto out;
1084
1085         *system_image_guid = MLX5_GET64(query_hca_vport_context_out, out,
1086                                         hca_vport_context.system_image_guid);
1087
1088 out:
1089         kvfree(out);
1090         return err;
1091 }
1092 EXPORT_SYMBOL_GPL(mlx5_query_hca_vport_system_image_guid);
1093
1094 int mlx5_query_hca_vport_node_guid(struct mlx5_core_dev *mdev, u64 *node_guid)
1095 {
1096         u32 *out;
1097         int outlen = MLX5_ST_SZ_BYTES(query_hca_vport_context_out);
1098         int err;
1099
1100         out = mlx5_vzalloc(outlen);
1101         if (!out)
1102                 return -ENOMEM;
1103
1104         err = mlx5_query_hca_vport_context(mdev, 1, 0, out, outlen);
1105         if (err)
1106                 goto out;
1107
1108         *node_guid = MLX5_GET64(query_hca_vport_context_out, out,
1109                                 hca_vport_context.node_guid);
1110
1111 out:
1112         kvfree(out);
1113         return err;
1114 }
1115 EXPORT_SYMBOL_GPL(mlx5_query_hca_vport_node_guid);
1116
1117 static int mlx5_query_hca_vport_port_guid(struct mlx5_core_dev *mdev,
1118                                           u64 *port_guid)
1119 {
1120         u32 *out;
1121         int outlen = MLX5_ST_SZ_BYTES(query_hca_vport_context_out);
1122         int err;
1123
1124         out = mlx5_vzalloc(outlen);
1125         if (!out)
1126                 return -ENOMEM;
1127
1128         err = mlx5_query_hca_vport_context(mdev, 1, 0, out, outlen);
1129         if (err)
1130                 goto out;
1131
1132         *port_guid = MLX5_GET64(query_hca_vport_context_out, out,
1133                                 hca_vport_context.port_guid);
1134
1135 out:
1136         kvfree(out);
1137         return err;
1138 }
1139
1140 int mlx5_query_hca_vport_gid(struct mlx5_core_dev *dev, u8 port_num,
1141                              u16 vport_num, u16 gid_index, union ib_gid *gid)
1142 {
1143         int in_sz = MLX5_ST_SZ_BYTES(query_hca_vport_gid_in);
1144         int out_sz = MLX5_ST_SZ_BYTES(query_hca_vport_gid_out);
1145         int is_group_manager;
1146         void *out = NULL;
1147         void *in = NULL;
1148         union ib_gid *tmp;
1149         int tbsz;
1150         int nout;
1151         int err;
1152
1153         is_group_manager = MLX5_CAP_GEN(dev, vport_group_manager);
1154         tbsz = mlx5_get_gid_table_len(MLX5_CAP_GEN(dev, gid_table_size));
1155
1156         if (gid_index > tbsz && gid_index != 0xffff)
1157                 return -EINVAL;
1158
1159         if (gid_index == 0xffff)
1160                 nout = tbsz;
1161         else
1162                 nout = 1;
1163
1164         out_sz += nout * sizeof(*gid);
1165
1166         in = mlx5_vzalloc(in_sz);
1167         out = mlx5_vzalloc(out_sz);
1168         if (!in || !out) {
1169                 err = -ENOMEM;
1170                 goto out;
1171         }
1172
1173         MLX5_SET(query_hca_vport_gid_in, in, opcode,
1174                  MLX5_CMD_OP_QUERY_HCA_VPORT_GID);
1175         if (vport_num) {
1176                 if (is_group_manager) {
1177                         MLX5_SET(query_hca_vport_gid_in, in, vport_number,
1178                                  vport_num);
1179                         MLX5_SET(query_hca_vport_gid_in, in, other_vport, 1);
1180                 } else {
1181                         err = -EPERM;
1182                         goto out;
1183                 }
1184         }
1185
1186         MLX5_SET(query_hca_vport_gid_in, in, gid_index, gid_index);
1187
1188         if (MLX5_CAP_GEN(dev, num_ports) == 2)
1189                 MLX5_SET(query_hca_vport_gid_in, in, port_num, port_num);
1190
1191         err = mlx5_cmd_exec(dev, in, in_sz, out, out_sz);
1192         if (err)
1193                 goto out;
1194
1195         tmp = (union ib_gid *)MLX5_ADDR_OF(query_hca_vport_gid_out, out, gid);
1196         gid->global.subnet_prefix = tmp->global.subnet_prefix;
1197         gid->global.interface_id = tmp->global.interface_id;
1198
1199 out:
1200         kvfree(in);
1201         kvfree(out);
1202         return err;
1203 }
1204 EXPORT_SYMBOL_GPL(mlx5_query_hca_vport_gid);
1205
1206 int mlx5_query_hca_vport_pkey(struct mlx5_core_dev *dev, u8 other_vport,
1207                               u8 port_num, u16 vf_num, u16 pkey_index,
1208                               u16 *pkey)
1209 {
1210         int in_sz = MLX5_ST_SZ_BYTES(query_hca_vport_pkey_in);
1211         int out_sz = MLX5_ST_SZ_BYTES(query_hca_vport_pkey_out);
1212         int is_group_manager;
1213         void *out = NULL;
1214         void *in = NULL;
1215         void *pkarr;
1216         int nout;
1217         int tbsz;
1218         int err;
1219         int i;
1220
1221         is_group_manager = MLX5_CAP_GEN(dev, vport_group_manager);
1222
1223         tbsz = mlx5_to_sw_pkey_sz(MLX5_CAP_GEN(dev, pkey_table_size));
1224         if (pkey_index > tbsz && pkey_index != 0xffff)
1225                 return -EINVAL;
1226
1227         if (pkey_index == 0xffff)
1228                 nout = tbsz;
1229         else
1230                 nout = 1;
1231
1232         out_sz += nout * MLX5_ST_SZ_BYTES(pkey);
1233
1234         in = kzalloc(in_sz, GFP_KERNEL);
1235         out = kzalloc(out_sz, GFP_KERNEL);
1236
1237         MLX5_SET(query_hca_vport_pkey_in, in, opcode,
1238                  MLX5_CMD_OP_QUERY_HCA_VPORT_PKEY);
1239         if (other_vport) {
1240                 if (is_group_manager) {
1241                         MLX5_SET(query_hca_vport_pkey_in, in, vport_number,
1242                                  vf_num);
1243                         MLX5_SET(query_hca_vport_pkey_in, in, other_vport, 1);
1244                 } else {
1245                         err = -EPERM;
1246                         goto out;
1247                 }
1248         }
1249         MLX5_SET(query_hca_vport_pkey_in, in, pkey_index, pkey_index);
1250
1251         if (MLX5_CAP_GEN(dev, num_ports) == 2)
1252                 MLX5_SET(query_hca_vport_pkey_in, in, port_num, port_num);
1253
1254         err = mlx5_cmd_exec(dev, in, in_sz, out, out_sz);
1255         if (err)
1256                 goto out;
1257
1258         pkarr = MLX5_ADDR_OF(query_hca_vport_pkey_out, out, pkey);
1259         for (i = 0; i < nout; i++, pkey++,
1260              pkarr += MLX5_ST_SZ_BYTES(pkey))
1261                 *pkey = MLX5_GET_PR(pkey, pkarr, pkey);
1262
1263 out:
1264         kfree(in);
1265         kfree(out);
1266         return err;
1267 }
1268 EXPORT_SYMBOL_GPL(mlx5_query_hca_vport_pkey);
1269
1270 static int mlx5_query_hca_min_wqe_header(struct mlx5_core_dev *mdev,
1271                                          int *min_header)
1272 {
1273         u32 *out;
1274         u32 outlen = MLX5_ST_SZ_BYTES(query_hca_vport_context_out);
1275         int err;
1276
1277         out = mlx5_vzalloc(outlen);
1278         if (!out)
1279                 return -ENOMEM;
1280
1281         err = mlx5_query_hca_vport_context(mdev, 1, 0, out, outlen);
1282         if (err)
1283                 goto out;
1284
1285         *min_header = MLX5_GET(query_hca_vport_context_out, out,
1286                                hca_vport_context.min_wqe_inline_mode);
1287
1288 out:
1289         kvfree(out);
1290         return err;
1291 }
1292
1293 static int mlx5_modify_eswitch_vport_context(struct mlx5_core_dev *mdev,
1294                                              u16 vport, void *in, int inlen)
1295 {
1296         u32 out[MLX5_ST_SZ_DW(modify_esw_vport_context_out)] = {0};
1297         int err;
1298
1299         MLX5_SET(modify_esw_vport_context_in, in, vport_number, vport);
1300         if (vport)
1301                 MLX5_SET(modify_esw_vport_context_in, in, other_vport, 1);
1302
1303         MLX5_SET(modify_esw_vport_context_in, in, opcode,
1304                  MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT);
1305
1306         err = mlx5_cmd_exec(mdev, in, inlen, out, sizeof(out));
1307         if (err)
1308                 mlx5_core_warn(mdev, "MLX5_CMD_OP_MODIFY_ESW_VPORT_CONTEXT failed\n");
1309
1310         return err;
1311 }
1312
1313 int mlx5_set_eswitch_cvlan_info(struct mlx5_core_dev *mdev, u8 vport,
1314                                 u8 insert_mode, u8 strip_mode,
1315                                 u16 vlan, u8 cfi, u8 pcp)
1316 {
1317         u32 in[MLX5_ST_SZ_DW(modify_esw_vport_context_in)];
1318
1319         memset(in, 0, sizeof(in));
1320
1321         if (insert_mode != MLX5_MODIFY_ESW_VPORT_CONTEXT_CVLAN_INSERT_NONE) {
1322                 MLX5_SET(modify_esw_vport_context_in, in,
1323                          esw_vport_context.cvlan_cfi, cfi);
1324                 MLX5_SET(modify_esw_vport_context_in, in,
1325                          esw_vport_context.cvlan_pcp, pcp);
1326                 MLX5_SET(modify_esw_vport_context_in, in,
1327                          esw_vport_context.cvlan_id, vlan);
1328         }
1329
1330         MLX5_SET(modify_esw_vport_context_in, in,
1331                  esw_vport_context.vport_cvlan_insert, insert_mode);
1332
1333         MLX5_SET(modify_esw_vport_context_in, in,
1334                  esw_vport_context.vport_cvlan_strip, strip_mode);
1335
1336         MLX5_SET(modify_esw_vport_context_in, in, field_select,
1337                  MLX5_MODIFY_ESW_VPORT_CONTEXT_FIELD_SELECT_CVLAN_STRIP |
1338                  MLX5_MODIFY_ESW_VPORT_CONTEXT_FIELD_SELECT_CVLAN_INSERT);
1339
1340         return mlx5_modify_eswitch_vport_context(mdev, vport, in, sizeof(in));
1341 }
1342 EXPORT_SYMBOL_GPL(mlx5_set_eswitch_cvlan_info);
1343
1344 int mlx5_query_vport_mtu(struct mlx5_core_dev *mdev, int *mtu)
1345 {
1346         u32 *out;
1347         u32 outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
1348         int err;
1349
1350         out = mlx5_vzalloc(outlen);
1351         if (!out)
1352                 return -ENOMEM;
1353
1354         err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
1355         if (err)
1356                 goto out;
1357
1358         *mtu = MLX5_GET(query_nic_vport_context_out, out,
1359                         nic_vport_context.mtu);
1360
1361 out:
1362         kvfree(out);
1363         return err;
1364 }
1365 EXPORT_SYMBOL_GPL(mlx5_query_vport_mtu);
1366
1367 int mlx5_set_vport_mtu(struct mlx5_core_dev *mdev, int mtu)
1368 {
1369         u32 *in;
1370         u32 inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
1371         int err;
1372
1373         in = mlx5_vzalloc(inlen);
1374         if (!in)
1375                 return -ENOMEM;
1376
1377         MLX5_SET(modify_nic_vport_context_in, in, field_select.mtu, 1);
1378         MLX5_SET(modify_nic_vport_context_in, in, nic_vport_context.mtu, mtu);
1379
1380         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
1381
1382         kvfree(in);
1383         return err;
1384 }
1385 EXPORT_SYMBOL_GPL(mlx5_set_vport_mtu);
1386
1387 static int mlx5_query_vport_min_wqe_header(struct mlx5_core_dev *mdev,
1388                                            int *min_header)
1389 {
1390         u32 *out;
1391         u32 outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
1392         int err;
1393
1394         out = mlx5_vzalloc(outlen);
1395         if (!out)
1396                 return -ENOMEM;
1397
1398         err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
1399         if (err)
1400                 goto out;
1401
1402         *min_header = MLX5_GET(query_nic_vport_context_out, out,
1403                                nic_vport_context.min_wqe_inline_mode);
1404
1405 out:
1406         kvfree(out);
1407         return err;
1408 }
1409
1410 int mlx5_set_vport_min_wqe_header(struct mlx5_core_dev *mdev,
1411                                   u8 vport, int min_header)
1412 {
1413         u32 *in;
1414         u32 inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
1415         int err;
1416
1417         in = mlx5_vzalloc(inlen);
1418         if (!in)
1419                 return -ENOMEM;
1420
1421         MLX5_SET(modify_nic_vport_context_in, in,
1422                  field_select.min_wqe_inline_mode, 1);
1423         MLX5_SET(modify_nic_vport_context_in, in,
1424                  nic_vport_context.min_wqe_inline_mode, min_header);
1425         MLX5_SET(modify_nic_vport_context_in, in, vport_number, vport);
1426         MLX5_SET(modify_nic_vport_context_in, in, other_vport, 1);
1427
1428         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
1429
1430         kvfree(in);
1431         return err;
1432 }
1433 EXPORT_SYMBOL_GPL(mlx5_set_vport_min_wqe_header);
1434
1435 int mlx5_query_min_wqe_header(struct mlx5_core_dev *dev, int *min_header)
1436 {
1437         switch (MLX5_CAP_GEN(dev, port_type)) {
1438         case MLX5_CMD_HCA_CAP_PORT_TYPE_IB:
1439                 return mlx5_query_hca_min_wqe_header(dev, min_header);
1440
1441         case MLX5_CMD_HCA_CAP_PORT_TYPE_ETHERNET:
1442                 return mlx5_query_vport_min_wqe_header(dev, min_header);
1443
1444         default:
1445                 return -EINVAL;
1446         }
1447 }
1448 EXPORT_SYMBOL_GPL(mlx5_query_min_wqe_header);
1449
1450 int mlx5_query_nic_vport_promisc(struct mlx5_core_dev *mdev,
1451                                  u16 vport,
1452                                  int *promisc_uc,
1453                                  int *promisc_mc,
1454                                  int *promisc_all)
1455 {
1456         u32 *out;
1457         int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
1458         int err;
1459
1460         out = kzalloc(outlen, GFP_KERNEL);
1461         if (!out)
1462                 return -ENOMEM;
1463
1464         err = mlx5_query_nic_vport_context(mdev, vport, out, outlen);
1465         if (err)
1466                 goto out;
1467
1468         *promisc_uc = MLX5_GET(query_nic_vport_context_out, out,
1469                                nic_vport_context.promisc_uc);
1470         *promisc_mc = MLX5_GET(query_nic_vport_context_out, out,
1471                                nic_vport_context.promisc_mc);
1472         *promisc_all = MLX5_GET(query_nic_vport_context_out, out,
1473                                 nic_vport_context.promisc_all);
1474
1475 out:
1476         kfree(out);
1477         return err;
1478 }
1479 EXPORT_SYMBOL_GPL(mlx5_query_nic_vport_promisc);
1480
1481 int mlx5_modify_nic_vport_promisc(struct mlx5_core_dev *mdev,
1482                                   int promisc_uc,
1483                                   int promisc_mc,
1484                                   int promisc_all)
1485 {
1486         void *in;
1487         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
1488         int err;
1489
1490         in = mlx5_vzalloc(inlen);
1491         if (!in) {
1492                 mlx5_core_err(mdev, "failed to allocate inbox\n");
1493                 return -ENOMEM;
1494         }
1495
1496         MLX5_SET(modify_nic_vport_context_in, in, field_select.promisc, 1);
1497         MLX5_SET(modify_nic_vport_context_in, in,
1498                  nic_vport_context.promisc_uc, promisc_uc);
1499         MLX5_SET(modify_nic_vport_context_in, in,
1500                  nic_vport_context.promisc_mc, promisc_mc);
1501         MLX5_SET(modify_nic_vport_context_in, in,
1502                  nic_vport_context.promisc_all, promisc_all);
1503
1504         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
1505         kvfree(in);
1506         return err;
1507 }
1508 EXPORT_SYMBOL_GPL(mlx5_modify_nic_vport_promisc);
1509
1510 int mlx5_nic_vport_modify_local_lb(struct mlx5_core_dev *mdev,
1511                                    enum mlx5_local_lb_selection selection,
1512                                    u8 value)
1513 {
1514         void *in;
1515         int inlen = MLX5_ST_SZ_BYTES(modify_nic_vport_context_in);
1516         int err;
1517
1518         in = mlx5_vzalloc(inlen);
1519         if (!in) {
1520                 mlx5_core_warn(mdev, "failed to allocate inbox\n");
1521                 return -ENOMEM;
1522         }
1523
1524         MLX5_SET(modify_nic_vport_context_in, in, vport_number, 0);
1525
1526         if (selection == MLX5_LOCAL_MC_LB) {
1527                 MLX5_SET(modify_nic_vport_context_in, in,
1528                          field_select.disable_mc_local_lb, 1);
1529                 MLX5_SET(modify_nic_vport_context_in, in,
1530                          nic_vport_context.disable_mc_local_lb,
1531                          value);
1532         } else {
1533                 MLX5_SET(modify_nic_vport_context_in, in,
1534                          field_select.disable_uc_local_lb, 1);
1535                 MLX5_SET(modify_nic_vport_context_in, in,
1536                          nic_vport_context.disable_uc_local_lb,
1537                          value);
1538         }
1539
1540         err = mlx5_modify_nic_vport_context(mdev, in, inlen);
1541
1542         kvfree(in);
1543         return err;
1544 }
1545 EXPORT_SYMBOL_GPL(mlx5_nic_vport_modify_local_lb);
1546
1547 int mlx5_nic_vport_query_local_lb(struct mlx5_core_dev *mdev,
1548                                   enum mlx5_local_lb_selection selection,
1549                                   u8 *value)
1550 {
1551         void *out;
1552         int outlen = MLX5_ST_SZ_BYTES(query_nic_vport_context_out);
1553         int err;
1554
1555         out = kzalloc(outlen, GFP_KERNEL);
1556         if (!out)
1557                 return -ENOMEM;
1558
1559         err = mlx5_query_nic_vport_context(mdev, 0, out, outlen);
1560         if (err)
1561                 goto done;
1562
1563         if (selection == MLX5_LOCAL_MC_LB)
1564                 *value = MLX5_GET(query_nic_vport_context_out, out,
1565                                   nic_vport_context.disable_mc_local_lb);
1566         else
1567                 *value = MLX5_GET(query_nic_vport_context_out, out,
1568                                   nic_vport_context.disable_uc_local_lb);
1569
1570 done:
1571         kfree(out);
1572         return err;
1573 }
1574 EXPORT_SYMBOL_GPL(mlx5_nic_vport_query_local_lb);
1575
1576 int mlx5_query_vport_counter(struct mlx5_core_dev *dev,
1577                              u8 port_num, u16 vport_num,
1578                              void *out, int out_size)
1579 {
1580         int in_sz = MLX5_ST_SZ_BYTES(query_vport_counter_in);
1581         int is_group_manager;
1582         void *in;
1583         int err;
1584
1585         is_group_manager = MLX5_CAP_GEN(dev, vport_group_manager);
1586
1587         in = mlx5_vzalloc(in_sz);
1588         if (!in)
1589                 return -ENOMEM;
1590
1591         MLX5_SET(query_vport_counter_in, in, opcode,
1592                  MLX5_CMD_OP_QUERY_VPORT_COUNTER);
1593         if (vport_num) {
1594                 if (is_group_manager) {
1595                         MLX5_SET(query_vport_counter_in, in, other_vport, 1);
1596                         MLX5_SET(query_vport_counter_in, in, vport_number,
1597                                  vport_num);
1598                 } else {
1599                         err = -EPERM;
1600                         goto ex;
1601                 }
1602         }
1603         if (MLX5_CAP_GEN(dev, num_ports) == 2)
1604                 MLX5_SET(query_vport_counter_in, in, port_num, port_num);
1605
1606         err = mlx5_cmd_exec(dev, in, in_sz, out,  out_size);
1607
1608 ex:
1609         kvfree(in);
1610         return err;
1611 }
1612 EXPORT_SYMBOL_GPL(mlx5_query_vport_counter);
1613
1614 int mlx5_get_vport_counters(struct mlx5_core_dev *dev, u8 port_num,
1615                             struct mlx5_vport_counters *vc)
1616 {
1617         int out_sz = MLX5_ST_SZ_BYTES(query_vport_counter_out);
1618         void *out;
1619         int err;
1620
1621         out = mlx5_vzalloc(out_sz);
1622         if (!out)
1623                 return -ENOMEM;
1624
1625         err = mlx5_query_vport_counter(dev, port_num, 0, out, out_sz);
1626         if (err)
1627                 goto ex;
1628
1629         vc->received_errors.packets =
1630                 MLX5_GET64(query_vport_counter_out,
1631                            out, received_errors.packets);
1632         vc->received_errors.octets =
1633                 MLX5_GET64(query_vport_counter_out,
1634                            out, received_errors.octets);
1635         vc->transmit_errors.packets =
1636                 MLX5_GET64(query_vport_counter_out,
1637                            out, transmit_errors.packets);
1638         vc->transmit_errors.octets =
1639                 MLX5_GET64(query_vport_counter_out,
1640                            out, transmit_errors.octets);
1641         vc->received_ib_unicast.packets =
1642                 MLX5_GET64(query_vport_counter_out,
1643                            out, received_ib_unicast.packets);
1644         vc->received_ib_unicast.octets =
1645                 MLX5_GET64(query_vport_counter_out,
1646                            out, received_ib_unicast.octets);
1647         vc->transmitted_ib_unicast.packets =
1648                 MLX5_GET64(query_vport_counter_out,
1649                            out, transmitted_ib_unicast.packets);
1650         vc->transmitted_ib_unicast.octets =
1651                 MLX5_GET64(query_vport_counter_out,
1652                            out, transmitted_ib_unicast.octets);
1653         vc->received_ib_multicast.packets =
1654                 MLX5_GET64(query_vport_counter_out,
1655                            out, received_ib_multicast.packets);
1656         vc->received_ib_multicast.octets =
1657                 MLX5_GET64(query_vport_counter_out,
1658                            out, received_ib_multicast.octets);
1659         vc->transmitted_ib_multicast.packets =
1660                 MLX5_GET64(query_vport_counter_out,
1661                            out, transmitted_ib_multicast.packets);
1662         vc->transmitted_ib_multicast.octets =
1663                 MLX5_GET64(query_vport_counter_out,
1664                            out, transmitted_ib_multicast.octets);
1665         vc->received_eth_broadcast.packets =
1666                 MLX5_GET64(query_vport_counter_out,
1667                            out, received_eth_broadcast.packets);
1668         vc->received_eth_broadcast.octets =
1669                 MLX5_GET64(query_vport_counter_out,
1670                            out, received_eth_broadcast.octets);
1671         vc->transmitted_eth_broadcast.packets =
1672                 MLX5_GET64(query_vport_counter_out,
1673                            out, transmitted_eth_broadcast.packets);
1674         vc->transmitted_eth_broadcast.octets =
1675                 MLX5_GET64(query_vport_counter_out,
1676                            out, transmitted_eth_broadcast.octets);
1677         vc->received_eth_unicast.octets =
1678                 MLX5_GET64(query_vport_counter_out,
1679                            out, received_eth_unicast.octets);
1680         vc->received_eth_unicast.packets =
1681                 MLX5_GET64(query_vport_counter_out,
1682                            out, received_eth_unicast.packets);
1683         vc->transmitted_eth_unicast.octets =
1684                 MLX5_GET64(query_vport_counter_out,
1685                            out, transmitted_eth_unicast.octets);
1686         vc->transmitted_eth_unicast.packets =
1687                 MLX5_GET64(query_vport_counter_out,
1688                            out, transmitted_eth_unicast.packets);
1689         vc->received_eth_multicast.octets =
1690                 MLX5_GET64(query_vport_counter_out,
1691                            out, received_eth_multicast.octets);
1692         vc->received_eth_multicast.packets =
1693                 MLX5_GET64(query_vport_counter_out,
1694                            out, received_eth_multicast.packets);
1695         vc->transmitted_eth_multicast.octets =
1696                 MLX5_GET64(query_vport_counter_out,
1697                            out, transmitted_eth_multicast.octets);
1698         vc->transmitted_eth_multicast.packets =
1699                 MLX5_GET64(query_vport_counter_out,
1700                            out, transmitted_eth_multicast.packets);
1701
1702 ex:
1703         kvfree(out);
1704         return err;
1705 }
1706
1707 int mlx5_query_vport_system_image_guid(struct mlx5_core_dev *dev,
1708                                        u64 *sys_image_guid)
1709 {
1710         switch (MLX5_CAP_GEN(dev, port_type)) {
1711         case MLX5_CMD_HCA_CAP_PORT_TYPE_IB:
1712                 return mlx5_query_hca_vport_system_image_guid(dev,
1713                                                               sys_image_guid);
1714
1715         case MLX5_CMD_HCA_CAP_PORT_TYPE_ETHERNET:
1716                 return mlx5_query_nic_vport_system_image_guid(dev,
1717                                                               sys_image_guid);
1718
1719         default:
1720                 return -EINVAL;
1721         }
1722 }
1723 EXPORT_SYMBOL_GPL(mlx5_query_vport_system_image_guid);
1724
1725 int mlx5_query_vport_node_guid(struct mlx5_core_dev *dev, u64 *node_guid)
1726 {
1727         switch (MLX5_CAP_GEN(dev, port_type)) {
1728         case MLX5_CMD_HCA_CAP_PORT_TYPE_IB:
1729                 return mlx5_query_hca_vport_node_guid(dev, node_guid);
1730
1731         case MLX5_CMD_HCA_CAP_PORT_TYPE_ETHERNET:
1732                 return mlx5_query_nic_vport_node_guid(dev, node_guid);
1733
1734         default:
1735                 return -EINVAL;
1736         }
1737 }
1738 EXPORT_SYMBOL_GPL(mlx5_query_vport_node_guid);
1739
1740 int mlx5_query_vport_port_guid(struct mlx5_core_dev *dev, u64 *port_guid)
1741 {
1742         switch (MLX5_CAP_GEN(dev, port_type)) {
1743         case MLX5_CMD_HCA_CAP_PORT_TYPE_IB:
1744                 return mlx5_query_hca_vport_port_guid(dev, port_guid);
1745
1746         case MLX5_CMD_HCA_CAP_PORT_TYPE_ETHERNET:
1747                 return mlx5_query_nic_vport_port_guid(dev, port_guid);
1748
1749         default:
1750                 return -EINVAL;
1751         }
1752 }
1753 EXPORT_SYMBOL_GPL(mlx5_query_vport_port_guid);
1754
1755 int mlx5_query_hca_vport_state(struct mlx5_core_dev *dev, u8 *vport_state)
1756 {
1757         u32 *out;
1758         int outlen = MLX5_ST_SZ_BYTES(query_hca_vport_context_out);
1759         int err;
1760
1761         out = mlx5_vzalloc(outlen);
1762         if (!out)
1763                 return -ENOMEM;
1764
1765         err = mlx5_query_hca_vport_context(dev, 1, 0, out, outlen);
1766         if (err)
1767                 goto out;
1768
1769         *vport_state = MLX5_GET(query_hca_vport_context_out, out,
1770                                 hca_vport_context.vport_state);
1771
1772 out:
1773         kvfree(out);
1774         return err;
1775 }
1776 EXPORT_SYMBOL_GPL(mlx5_query_hca_vport_state);
1777
1778 int mlx5_core_query_ib_ppcnt(struct mlx5_core_dev *dev,
1779                              u8 port_num, void *out, size_t sz)
1780 {
1781         u32 *in;
1782         int err;
1783
1784         in  = mlx5_vzalloc(sz);
1785         if (!in) {
1786                 err = -ENOMEM;
1787                 return err;
1788         }
1789
1790         MLX5_SET(ppcnt_reg, in, local_port, port_num);
1791
1792         MLX5_SET(ppcnt_reg, in, grp, MLX5_INFINIBAND_PORT_COUNTERS_GROUP);
1793         err = mlx5_core_access_reg(dev, in, sz, out,
1794                                    sz, MLX5_REG_PPCNT, 0, 0);
1795
1796         kvfree(in);
1797         return err;
1798 }