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