1 /* 2 * Copyright(c) 2017 Intel Corporation. 3 * 4 * This file is provided under a dual BSD/GPLv2 license. When using or 5 * redistributing this file, you may do so under either license. 6 * 7 * GPL LICENSE SUMMARY 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of version 2 of the GNU General Public License as 11 * published by the Free Software Foundation. 12 * 13 * This program is distributed in the hope that it will be useful, but 14 * WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 16 * General Public License for more details. 17 * 18 * BSD LICENSE 19 * 20 * Redistribution and use in source and binary forms, with or without 21 * modification, are permitted provided that the following conditions 22 * are met: 23 * 24 * - Redistributions of source code must retain the above copyright 25 * notice, this list of conditions and the following disclaimer. 26 * - Redistributions in binary form must reproduce the above copyright 27 * notice, this list of conditions and the following disclaimer in 28 * the documentation and/or other materials provided with the 29 * distribution. 30 * - Neither the name of Intel Corporation nor the names of its 31 * contributors may be used to endorse or promote products derived 32 * from this software without specific prior written permission. 33 * 34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 35 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 36 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 37 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 38 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 39 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 40 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 41 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 42 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 43 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 44 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 45 * 46 */ 47 48 /* 49 * This file contains OPA Virtual Network Interface Controller (VNIC) 50 * Ethernet Management Agent (EMA) driver 51 */ 52 53 #include <linux/module.h> 54 #include <linux/xarray.h> 55 #include <rdma/ib_addr.h> 56 #include <rdma/ib_verbs.h> 57 #include <rdma/opa_smi.h> 58 #include <rdma/opa_port_info.h> 59 60 #include "opa_vnic_internal.h" 61 62 char opa_vnic_driver_name[] = "opa_vnic"; 63 64 /* 65 * The trap service level is kept in bits 3 to 7 in the trap_sl_rsvd 66 * field in the class port info MAD. 67 */ 68 #define GET_TRAP_SL_FROM_CLASS_PORT_INFO(x) (((x) >> 3) & 0x1f) 69 70 /* Cap trap bursts to a reasonable limit good for normal cases */ 71 #define OPA_VNIC_TRAP_BURST_LIMIT 4 72 73 /* 74 * VNIC trap limit timeout. 75 * Inverse of cap2_mask response time out (1.0737 secs) = 0.9 76 * secs approx IB spec 13.4.6.2.1 PortInfoSubnetTimeout and 77 * 13.4.9 Traps. 78 */ 79 #define OPA_VNIC_TRAP_TIMEOUT ((4096 * (1UL << 18)) / 1000) 80 81 #define OPA_VNIC_UNSUP_ATTR \ 82 cpu_to_be16(IB_MGMT_MAD_STATUS_UNSUPPORTED_METHOD_ATTRIB) 83 84 #define OPA_VNIC_INVAL_ATTR \ 85 cpu_to_be16(IB_MGMT_MAD_STATUS_INVALID_ATTRIB_VALUE) 86 87 #define OPA_VNIC_CLASS_CAP_TRAP 0x1 88 89 /* Maximum number of VNIC ports supported */ 90 #define OPA_VNIC_MAX_NUM_VPORT 255 91 92 /** 93 * struct opa_vnic_vema_port -- VNIC VEMA port details 94 * @cport: pointer to port 95 * @mad_agent: pointer to mad agent for port 96 * @class_port_info: Class port info information. 97 * @tid: Transaction id 98 * @port_num: OPA port number 99 * @vports: vnic ports 100 * @event_handler: ib event handler 101 * @lock: adapter interface lock 102 */ 103 struct opa_vnic_vema_port { 104 struct opa_vnic_ctrl_port *cport; 105 struct ib_mad_agent *mad_agent; 106 struct opa_class_port_info class_port_info; 107 u64 tid; 108 u8 port_num; 109 struct xarray vports; 110 struct ib_event_handler event_handler; 111 112 /* Lock to query/update network adapter */ 113 struct mutex lock; 114 }; 115 116 static int opa_vnic_vema_add_one(struct ib_device *device); 117 static void opa_vnic_vema_rem_one(struct ib_device *device, 118 void *client_data); 119 120 static struct ib_client opa_vnic_client = { 121 .name = opa_vnic_driver_name, 122 .add = opa_vnic_vema_add_one, 123 .remove = opa_vnic_vema_rem_one, 124 }; 125 126 /** 127 * vema_get_vport_num -- Get the vnic from the mad 128 * @recvd_mad: Received mad 129 * 130 * Return: returns value of the vnic port number 131 */ 132 static inline u8 vema_get_vport_num(struct opa_vnic_vema_mad *recvd_mad) 133 { 134 return be32_to_cpu(recvd_mad->mad_hdr.attr_mod) & 0xff; 135 } 136 137 /** 138 * vema_get_vport_adapter -- Get vnic port adapter from recvd mad 139 * @recvd_mad: received mad 140 * @port: ptr to port struct on which MAD was recvd 141 * 142 * Return: vnic adapter 143 */ 144 static inline struct opa_vnic_adapter * 145 vema_get_vport_adapter(struct opa_vnic_vema_mad *recvd_mad, 146 struct opa_vnic_vema_port *port) 147 { 148 u8 vport_num = vema_get_vport_num(recvd_mad); 149 150 return xa_load(&port->vports, vport_num); 151 } 152 153 /** 154 * vema_mac_tbl_req_ok -- Check if mac request has correct values 155 * @mac_tbl: mac table 156 * 157 * This function checks for the validity of the offset and number of 158 * entries required. 159 * 160 * Return: true if offset and num_entries are valid 161 */ 162 static inline bool vema_mac_tbl_req_ok(struct opa_veswport_mactable *mac_tbl) 163 { 164 u16 offset, num_entries; 165 u16 req_entries = ((OPA_VNIC_EMA_DATA - sizeof(*mac_tbl)) / 166 sizeof(mac_tbl->tbl_entries[0])); 167 168 offset = be16_to_cpu(mac_tbl->offset); 169 num_entries = be16_to_cpu(mac_tbl->num_entries); 170 171 return ((num_entries <= req_entries) && 172 (offset + num_entries <= OPA_VNIC_MAC_TBL_MAX_ENTRIES)); 173 } 174 175 /* 176 * Return the power on default values in the port info structure 177 * in big endian format as required by MAD. 178 */ 179 static inline void vema_get_pod_values(struct opa_veswport_info *port_info) 180 { 181 memset(port_info, 0, sizeof(*port_info)); 182 port_info->vport.max_mac_tbl_ent = 183 cpu_to_be16(OPA_VNIC_MAC_TBL_MAX_ENTRIES); 184 port_info->vport.max_smac_ent = 185 cpu_to_be16(OPA_VNIC_MAX_SMAC_LIMIT); 186 port_info->vport.oper_state = OPA_VNIC_STATE_DROP_ALL; 187 port_info->vport.config_state = OPA_VNIC_STATE_DROP_ALL; 188 port_info->vesw.eth_mtu = cpu_to_be16(ETH_DATA_LEN); 189 } 190 191 /** 192 * vema_add_vport -- Add a new vnic port 193 * @port: ptr to opa_vnic_vema_port struct 194 * @vport_num: vnic port number (to be added) 195 * 196 * Return a pointer to the vnic adapter structure 197 */ 198 static struct opa_vnic_adapter *vema_add_vport(struct opa_vnic_vema_port *port, 199 u8 vport_num) 200 { 201 struct opa_vnic_ctrl_port *cport = port->cport; 202 struct opa_vnic_adapter *adapter; 203 204 adapter = opa_vnic_add_netdev(cport->ibdev, port->port_num, vport_num); 205 if (!IS_ERR(adapter)) { 206 int rc; 207 208 adapter->cport = cport; 209 rc = xa_insert(&port->vports, vport_num, adapter, GFP_KERNEL); 210 if (rc < 0) { 211 opa_vnic_rem_netdev(adapter); 212 adapter = ERR_PTR(rc); 213 } 214 } 215 216 return adapter; 217 } 218 219 /** 220 * vema_get_class_port_info -- Get class info for port 221 * @port: Port on whic MAD was received 222 * @recvd_mad: pointer to the received mad 223 * @rsp_mad: pointer to respose mad 224 * 225 * This function copies the latest class port info value set for the 226 * port and stores it for generating traps 227 */ 228 static void vema_get_class_port_info(struct opa_vnic_vema_port *port, 229 struct opa_vnic_vema_mad *recvd_mad, 230 struct opa_vnic_vema_mad *rsp_mad) 231 { 232 struct opa_class_port_info *port_info; 233 234 port_info = (struct opa_class_port_info *)rsp_mad->data; 235 memcpy(port_info, &port->class_port_info, sizeof(*port_info)); 236 port_info->base_version = OPA_MGMT_BASE_VERSION, 237 port_info->class_version = OPA_EMA_CLASS_VERSION; 238 239 /* 240 * Set capability mask bit indicating agent generates traps, 241 * and set the maximum number of VNIC ports supported. 242 */ 243 port_info->cap_mask = cpu_to_be16((OPA_VNIC_CLASS_CAP_TRAP | 244 (OPA_VNIC_MAX_NUM_VPORT << 8))); 245 246 /* 247 * Since a get routine is always sent by the EM first we 248 * set the expected response time to 249 * 4.096 usec * 2^18 == 1.0737 sec here. 250 */ 251 port_info->cap_mask2_resp_time = cpu_to_be32(18); 252 } 253 254 /** 255 * vema_set_class_port_info -- Get class info for port 256 * @port: Port on whic MAD was received 257 * @recvd_mad: pointer to the received mad 258 * @rsp_mad: pointer to respose mad 259 * 260 * This function updates the port class info for the specific vnic 261 * and sets up the response mad data 262 */ 263 static void vema_set_class_port_info(struct opa_vnic_vema_port *port, 264 struct opa_vnic_vema_mad *recvd_mad, 265 struct opa_vnic_vema_mad *rsp_mad) 266 { 267 memcpy(&port->class_port_info, recvd_mad->data, 268 sizeof(port->class_port_info)); 269 270 vema_get_class_port_info(port, recvd_mad, rsp_mad); 271 } 272 273 /** 274 * vema_get_veswport_info -- Get veswport info 275 * @port: source port on which MAD was received 276 * @recvd_mad: pointer to the received mad 277 * @rsp_mad: pointer to respose mad 278 */ 279 static void vema_get_veswport_info(struct opa_vnic_vema_port *port, 280 struct opa_vnic_vema_mad *recvd_mad, 281 struct opa_vnic_vema_mad *rsp_mad) 282 { 283 struct opa_veswport_info *port_info = 284 (struct opa_veswport_info *)rsp_mad->data; 285 struct opa_vnic_adapter *adapter; 286 287 adapter = vema_get_vport_adapter(recvd_mad, port); 288 if (adapter) { 289 memset(port_info, 0, sizeof(*port_info)); 290 opa_vnic_get_vesw_info(adapter, &port_info->vesw); 291 opa_vnic_get_per_veswport_info(adapter, 292 &port_info->vport); 293 } else { 294 vema_get_pod_values(port_info); 295 } 296 } 297 298 /** 299 * vema_set_veswport_info -- Set veswport info 300 * @port: source port on which MAD was received 301 * @recvd_mad: pointer to the received mad 302 * @rsp_mad: pointer to respose mad 303 * 304 * This function gets the port class infor for vnic 305 */ 306 static void vema_set_veswport_info(struct opa_vnic_vema_port *port, 307 struct opa_vnic_vema_mad *recvd_mad, 308 struct opa_vnic_vema_mad *rsp_mad) 309 { 310 struct opa_vnic_ctrl_port *cport = port->cport; 311 struct opa_veswport_info *port_info; 312 struct opa_vnic_adapter *adapter; 313 u8 vport_num; 314 315 vport_num = vema_get_vport_num(recvd_mad); 316 317 adapter = vema_get_vport_adapter(recvd_mad, port); 318 if (!adapter) { 319 adapter = vema_add_vport(port, vport_num); 320 if (IS_ERR(adapter)) { 321 c_err("failed to add vport %d: %ld\n", 322 vport_num, PTR_ERR(adapter)); 323 goto err_exit; 324 } 325 } 326 327 port_info = (struct opa_veswport_info *)recvd_mad->data; 328 opa_vnic_set_vesw_info(adapter, &port_info->vesw); 329 opa_vnic_set_per_veswport_info(adapter, &port_info->vport); 330 331 /* Process the new config settings */ 332 opa_vnic_process_vema_config(adapter); 333 334 vema_get_veswport_info(port, recvd_mad, rsp_mad); 335 return; 336 337 err_exit: 338 rsp_mad->mad_hdr.status = OPA_VNIC_INVAL_ATTR; 339 } 340 341 /** 342 * vema_get_mac_entries -- Get MAC entries in VNIC MAC table 343 * @port: source port on which MAD was received 344 * @recvd_mad: pointer to the received mad 345 * @rsp_mad: pointer to respose mad 346 * 347 * This function gets the MAC entries that are programmed into 348 * the VNIC MAC forwarding table. It checks for the validity of 349 * the index into the MAC table and the number of entries that 350 * are to be retrieved. 351 */ 352 static void vema_get_mac_entries(struct opa_vnic_vema_port *port, 353 struct opa_vnic_vema_mad *recvd_mad, 354 struct opa_vnic_vema_mad *rsp_mad) 355 { 356 struct opa_veswport_mactable *mac_tbl_in, *mac_tbl_out; 357 struct opa_vnic_adapter *adapter; 358 359 adapter = vema_get_vport_adapter(recvd_mad, port); 360 if (!adapter) { 361 rsp_mad->mad_hdr.status = OPA_VNIC_INVAL_ATTR; 362 return; 363 } 364 365 mac_tbl_in = (struct opa_veswport_mactable *)recvd_mad->data; 366 mac_tbl_out = (struct opa_veswport_mactable *)rsp_mad->data; 367 368 if (vema_mac_tbl_req_ok(mac_tbl_in)) { 369 mac_tbl_out->offset = mac_tbl_in->offset; 370 mac_tbl_out->num_entries = mac_tbl_in->num_entries; 371 opa_vnic_query_mac_tbl(adapter, mac_tbl_out); 372 } else { 373 rsp_mad->mad_hdr.status = OPA_VNIC_INVAL_ATTR; 374 } 375 } 376 377 /** 378 * vema_set_mac_entries -- Set MAC entries in VNIC MAC table 379 * @port: source port on which MAD was received 380 * @recvd_mad: pointer to the received mad 381 * @rsp_mad: pointer to respose mad 382 * 383 * This function sets the MAC entries in the VNIC forwarding table 384 * It checks for the validity of the index and the number of forwarding 385 * table entries to be programmed. 386 */ 387 static void vema_set_mac_entries(struct opa_vnic_vema_port *port, 388 struct opa_vnic_vema_mad *recvd_mad, 389 struct opa_vnic_vema_mad *rsp_mad) 390 { 391 struct opa_veswport_mactable *mac_tbl; 392 struct opa_vnic_adapter *adapter; 393 394 adapter = vema_get_vport_adapter(recvd_mad, port); 395 if (!adapter) { 396 rsp_mad->mad_hdr.status = OPA_VNIC_INVAL_ATTR; 397 return; 398 } 399 400 mac_tbl = (struct opa_veswport_mactable *)recvd_mad->data; 401 if (vema_mac_tbl_req_ok(mac_tbl)) { 402 if (opa_vnic_update_mac_tbl(adapter, mac_tbl)) 403 rsp_mad->mad_hdr.status = OPA_VNIC_UNSUP_ATTR; 404 } else { 405 rsp_mad->mad_hdr.status = OPA_VNIC_UNSUP_ATTR; 406 } 407 vema_get_mac_entries(port, recvd_mad, rsp_mad); 408 } 409 410 /** 411 * vema_set_delete_vesw -- Reset VESW info to POD values 412 * @port: source port on which MAD was received 413 * @recvd_mad: pointer to the received mad 414 * @rsp_mad: pointer to respose mad 415 * 416 * This function clears all the fields of veswport info for the requested vesw 417 * and sets them back to the power-on default values. It does not delete the 418 * vesw. 419 */ 420 static void vema_set_delete_vesw(struct opa_vnic_vema_port *port, 421 struct opa_vnic_vema_mad *recvd_mad, 422 struct opa_vnic_vema_mad *rsp_mad) 423 { 424 struct opa_veswport_info *port_info = 425 (struct opa_veswport_info *)rsp_mad->data; 426 struct opa_vnic_adapter *adapter; 427 428 adapter = vema_get_vport_adapter(recvd_mad, port); 429 if (!adapter) { 430 rsp_mad->mad_hdr.status = OPA_VNIC_INVAL_ATTR; 431 return; 432 } 433 434 vema_get_pod_values(port_info); 435 opa_vnic_set_vesw_info(adapter, &port_info->vesw); 436 opa_vnic_set_per_veswport_info(adapter, &port_info->vport); 437 438 /* Process the new config settings */ 439 opa_vnic_process_vema_config(adapter); 440 441 opa_vnic_release_mac_tbl(adapter); 442 443 vema_get_veswport_info(port, recvd_mad, rsp_mad); 444 } 445 446 /** 447 * vema_get_mac_list -- Get the unicast/multicast macs. 448 * @port: source port on which MAD was received 449 * @recvd_mad: Received mad contains fields to set vnic parameters 450 * @rsp_mad: Response mad to be built 451 * @attr_id: Attribute ID indicating multicast or unicast mac list 452 */ 453 static void vema_get_mac_list(struct opa_vnic_vema_port *port, 454 struct opa_vnic_vema_mad *recvd_mad, 455 struct opa_vnic_vema_mad *rsp_mad, 456 u16 attr_id) 457 { 458 struct opa_veswport_iface_macs *macs_in, *macs_out; 459 int max_entries = (OPA_VNIC_EMA_DATA - sizeof(*macs_out)) / ETH_ALEN; 460 struct opa_vnic_adapter *adapter; 461 462 adapter = vema_get_vport_adapter(recvd_mad, port); 463 if (!adapter) { 464 rsp_mad->mad_hdr.status = OPA_VNIC_INVAL_ATTR; 465 return; 466 } 467 468 macs_in = (struct opa_veswport_iface_macs *)recvd_mad->data; 469 macs_out = (struct opa_veswport_iface_macs *)rsp_mad->data; 470 471 macs_out->start_idx = macs_in->start_idx; 472 if (macs_in->num_macs_in_msg) 473 macs_out->num_macs_in_msg = macs_in->num_macs_in_msg; 474 else 475 macs_out->num_macs_in_msg = cpu_to_be16(max_entries); 476 477 if (attr_id == OPA_EM_ATTR_IFACE_MCAST_MACS) 478 opa_vnic_query_mcast_macs(adapter, macs_out); 479 else 480 opa_vnic_query_ucast_macs(adapter, macs_out); 481 } 482 483 /** 484 * vema_get_summary_counters -- Gets summary counters. 485 * @port: source port on which MAD was received 486 * @recvd_mad: Received mad contains fields to set vnic parameters 487 * @rsp_mad: Response mad to be built 488 */ 489 static void vema_get_summary_counters(struct opa_vnic_vema_port *port, 490 struct opa_vnic_vema_mad *recvd_mad, 491 struct opa_vnic_vema_mad *rsp_mad) 492 { 493 struct opa_veswport_summary_counters *cntrs; 494 struct opa_vnic_adapter *adapter; 495 496 adapter = vema_get_vport_adapter(recvd_mad, port); 497 if (adapter) { 498 cntrs = (struct opa_veswport_summary_counters *)rsp_mad->data; 499 opa_vnic_get_summary_counters(adapter, cntrs); 500 } else { 501 rsp_mad->mad_hdr.status = OPA_VNIC_INVAL_ATTR; 502 } 503 } 504 505 /** 506 * vema_get_error_counters -- Gets summary counters. 507 * @port: source port on which MAD was received 508 * @recvd_mad: Received mad contains fields to set vnic parameters 509 * @rsp_mad: Response mad to be built 510 */ 511 static void vema_get_error_counters(struct opa_vnic_vema_port *port, 512 struct opa_vnic_vema_mad *recvd_mad, 513 struct opa_vnic_vema_mad *rsp_mad) 514 { 515 struct opa_veswport_error_counters *cntrs; 516 struct opa_vnic_adapter *adapter; 517 518 adapter = vema_get_vport_adapter(recvd_mad, port); 519 if (adapter) { 520 cntrs = (struct opa_veswport_error_counters *)rsp_mad->data; 521 opa_vnic_get_error_counters(adapter, cntrs); 522 } else { 523 rsp_mad->mad_hdr.status = OPA_VNIC_INVAL_ATTR; 524 } 525 } 526 527 /** 528 * vema_get -- Process received get MAD 529 * @port: source port on which MAD was received 530 * @recvd_mad: Received mad 531 * @rsp_mad: Response mad to be built 532 */ 533 static void vema_get(struct opa_vnic_vema_port *port, 534 struct opa_vnic_vema_mad *recvd_mad, 535 struct opa_vnic_vema_mad *rsp_mad) 536 { 537 u16 attr_id = be16_to_cpu(recvd_mad->mad_hdr.attr_id); 538 539 switch (attr_id) { 540 case OPA_EM_ATTR_CLASS_PORT_INFO: 541 vema_get_class_port_info(port, recvd_mad, rsp_mad); 542 break; 543 case OPA_EM_ATTR_VESWPORT_INFO: 544 vema_get_veswport_info(port, recvd_mad, rsp_mad); 545 break; 546 case OPA_EM_ATTR_VESWPORT_MAC_ENTRIES: 547 vema_get_mac_entries(port, recvd_mad, rsp_mad); 548 break; 549 case OPA_EM_ATTR_IFACE_UCAST_MACS: 550 /* fall through */ 551 case OPA_EM_ATTR_IFACE_MCAST_MACS: 552 vema_get_mac_list(port, recvd_mad, rsp_mad, attr_id); 553 break; 554 case OPA_EM_ATTR_VESWPORT_SUMMARY_COUNTERS: 555 vema_get_summary_counters(port, recvd_mad, rsp_mad); 556 break; 557 case OPA_EM_ATTR_VESWPORT_ERROR_COUNTERS: 558 vema_get_error_counters(port, recvd_mad, rsp_mad); 559 break; 560 default: 561 rsp_mad->mad_hdr.status = OPA_VNIC_UNSUP_ATTR; 562 break; 563 } 564 } 565 566 /** 567 * vema_set -- Process received set MAD 568 * @port: source port on which MAD was received 569 * @recvd_mad: Received mad contains fields to set vnic parameters 570 * @rsp_mad: Response mad to be built 571 */ 572 static void vema_set(struct opa_vnic_vema_port *port, 573 struct opa_vnic_vema_mad *recvd_mad, 574 struct opa_vnic_vema_mad *rsp_mad) 575 { 576 u16 attr_id = be16_to_cpu(recvd_mad->mad_hdr.attr_id); 577 578 switch (attr_id) { 579 case OPA_EM_ATTR_CLASS_PORT_INFO: 580 vema_set_class_port_info(port, recvd_mad, rsp_mad); 581 break; 582 case OPA_EM_ATTR_VESWPORT_INFO: 583 vema_set_veswport_info(port, recvd_mad, rsp_mad); 584 break; 585 case OPA_EM_ATTR_VESWPORT_MAC_ENTRIES: 586 vema_set_mac_entries(port, recvd_mad, rsp_mad); 587 break; 588 case OPA_EM_ATTR_DELETE_VESW: 589 vema_set_delete_vesw(port, recvd_mad, rsp_mad); 590 break; 591 default: 592 rsp_mad->mad_hdr.status = OPA_VNIC_UNSUP_ATTR; 593 break; 594 } 595 } 596 597 /** 598 * vema_send -- Send handler for VEMA MAD agent 599 * @mad_agent: pointer to the mad agent 600 * @mad_wc: pointer to mad send work completion information 601 * 602 * Free all the data structures associated with the sent MAD 603 */ 604 static void vema_send(struct ib_mad_agent *mad_agent, 605 struct ib_mad_send_wc *mad_wc) 606 { 607 rdma_destroy_ah(mad_wc->send_buf->ah, RDMA_DESTROY_AH_SLEEPABLE); 608 ib_free_send_mad(mad_wc->send_buf); 609 } 610 611 /** 612 * vema_recv -- Recv handler for VEMA MAD agent 613 * @mad_agent: pointer to the mad agent 614 * @send_buf: Send buffer if found, else NULL 615 * @mad_wc: pointer to mad send work completion information 616 * 617 * Handle only set and get methods and respond to other methods 618 * as unsupported. Allocate response buffer and address handle 619 * for the response MAD. 620 */ 621 static void vema_recv(struct ib_mad_agent *mad_agent, 622 struct ib_mad_send_buf *send_buf, 623 struct ib_mad_recv_wc *mad_wc) 624 { 625 struct opa_vnic_vema_port *port; 626 struct ib_ah *ah; 627 struct ib_mad_send_buf *rsp; 628 struct opa_vnic_vema_mad *vema_mad; 629 630 if (!mad_wc || !mad_wc->recv_buf.mad) 631 return; 632 633 port = mad_agent->context; 634 ah = ib_create_ah_from_wc(mad_agent->qp->pd, mad_wc->wc, 635 mad_wc->recv_buf.grh, mad_agent->port_num); 636 if (IS_ERR(ah)) 637 goto free_recv_mad; 638 639 rsp = ib_create_send_mad(mad_agent, mad_wc->wc->src_qp, 640 mad_wc->wc->pkey_index, 0, 641 IB_MGMT_VENDOR_HDR, OPA_VNIC_EMA_DATA, 642 GFP_KERNEL, OPA_MGMT_BASE_VERSION); 643 if (IS_ERR(rsp)) 644 goto err_rsp; 645 646 rsp->ah = ah; 647 vema_mad = rsp->mad; 648 memcpy(vema_mad, mad_wc->recv_buf.mad, IB_MGMT_VENDOR_HDR); 649 vema_mad->mad_hdr.method = IB_MGMT_METHOD_GET_RESP; 650 vema_mad->mad_hdr.status = 0; 651 652 /* Lock ensures network adapter is not removed */ 653 mutex_lock(&port->lock); 654 655 switch (mad_wc->recv_buf.mad->mad_hdr.method) { 656 case IB_MGMT_METHOD_GET: 657 vema_get(port, (struct opa_vnic_vema_mad *)mad_wc->recv_buf.mad, 658 vema_mad); 659 break; 660 case IB_MGMT_METHOD_SET: 661 vema_set(port, (struct opa_vnic_vema_mad *)mad_wc->recv_buf.mad, 662 vema_mad); 663 break; 664 default: 665 vema_mad->mad_hdr.status = OPA_VNIC_UNSUP_ATTR; 666 break; 667 } 668 mutex_unlock(&port->lock); 669 670 if (!ib_post_send_mad(rsp, NULL)) { 671 /* 672 * with post send successful ah and send mad 673 * will be destroyed in send handler 674 */ 675 goto free_recv_mad; 676 } 677 678 ib_free_send_mad(rsp); 679 680 err_rsp: 681 rdma_destroy_ah(ah, RDMA_DESTROY_AH_SLEEPABLE); 682 free_recv_mad: 683 ib_free_recv_mad(mad_wc); 684 } 685 686 /** 687 * vema_get_port -- Gets the opa_vnic_vema_port 688 * @cport: pointer to control dev 689 * @port_num: Port number 690 * 691 * This function loops through the ports and returns 692 * the opa_vnic_vema port structure that is associated 693 * with the OPA port number 694 * 695 * Return: ptr to requested opa_vnic_vema_port strucure 696 * if success, NULL if not 697 */ 698 static struct opa_vnic_vema_port * 699 vema_get_port(struct opa_vnic_ctrl_port *cport, u8 port_num) 700 { 701 struct opa_vnic_vema_port *port = (void *)cport + sizeof(*cport); 702 703 if (port_num > cport->num_ports) 704 return NULL; 705 706 return port + (port_num - 1); 707 } 708 709 /** 710 * opa_vnic_vema_send_trap -- This function sends a trap to the EM 711 * @adapter: pointer to vnic adapter 712 * @data: pointer to trap data filled by calling function 713 * @lid: issuers lid (encap_slid from vesw_port_info) 714 * 715 * This function is called from the VNIC driver to send a trap if there 716 * is somethng the EM should be notified about. These events currently 717 * are 718 * 1) UNICAST INTERFACE MACADDRESS changes 719 * 2) MULTICAST INTERFACE MACADDRESS changes 720 * 3) ETHERNET LINK STATUS changes 721 * While allocating the send mad the remote site qpn used is 1 722 * as this is the well known QP. 723 * 724 */ 725 void opa_vnic_vema_send_trap(struct opa_vnic_adapter *adapter, 726 struct __opa_veswport_trap *data, u32 lid) 727 { 728 struct opa_vnic_ctrl_port *cport = adapter->cport; 729 struct ib_mad_send_buf *send_buf; 730 struct opa_vnic_vema_port *port; 731 struct ib_device *ibp; 732 struct opa_vnic_vema_mad_trap *trap_mad; 733 struct opa_class_port_info *class; 734 struct rdma_ah_attr ah_attr; 735 struct ib_ah *ah; 736 struct opa_veswport_trap *trap; 737 u32 trap_lid; 738 u16 pkey_idx; 739 740 if (!cport) 741 goto err_exit; 742 ibp = cport->ibdev; 743 port = vema_get_port(cport, data->opaportnum); 744 if (!port || !port->mad_agent) 745 goto err_exit; 746 747 if (time_before(jiffies, adapter->trap_timeout)) { 748 if (adapter->trap_count == OPA_VNIC_TRAP_BURST_LIMIT) { 749 v_warn("Trap rate exceeded\n"); 750 goto err_exit; 751 } else { 752 adapter->trap_count++; 753 } 754 } else { 755 adapter->trap_count = 0; 756 } 757 758 class = &port->class_port_info; 759 /* Set up address handle */ 760 memset(&ah_attr, 0, sizeof(ah_attr)); 761 ah_attr.type = rdma_ah_find_type(ibp, port->port_num); 762 rdma_ah_set_sl(&ah_attr, 763 GET_TRAP_SL_FROM_CLASS_PORT_INFO(class->trap_sl_rsvd)); 764 rdma_ah_set_port_num(&ah_attr, port->port_num); 765 trap_lid = be32_to_cpu(class->trap_lid); 766 /* 767 * check for trap lid validity, must not be zero 768 * The trap sink could change after we fashion the MAD but since traps 769 * are not guaranteed we won't use a lock as anyway the change will take 770 * place even with locking. 771 */ 772 if (!trap_lid) { 773 c_err("%s: Invalid dlid\n", __func__); 774 goto err_exit; 775 } 776 777 rdma_ah_set_dlid(&ah_attr, trap_lid); 778 ah = rdma_create_ah(port->mad_agent->qp->pd, &ah_attr, 0); 779 if (IS_ERR(ah)) { 780 c_err("%s:Couldn't create new AH = %p\n", __func__, ah); 781 c_err("%s:dlid = %d, sl = %d, port = %d\n", __func__, 782 rdma_ah_get_dlid(&ah_attr), rdma_ah_get_sl(&ah_attr), 783 rdma_ah_get_port_num(&ah_attr)); 784 goto err_exit; 785 } 786 787 if (ib_find_pkey(ibp, data->opaportnum, IB_DEFAULT_PKEY_FULL, 788 &pkey_idx) < 0) { 789 c_err("%s:full key not found, defaulting to partial\n", 790 __func__); 791 if (ib_find_pkey(ibp, data->opaportnum, IB_DEFAULT_PKEY_PARTIAL, 792 &pkey_idx) < 0) 793 pkey_idx = 1; 794 } 795 796 send_buf = ib_create_send_mad(port->mad_agent, 1, pkey_idx, 0, 797 IB_MGMT_VENDOR_HDR, IB_MGMT_MAD_DATA, 798 GFP_ATOMIC, OPA_MGMT_BASE_VERSION); 799 if (IS_ERR(send_buf)) { 800 c_err("%s:Couldn't allocate send buf\n", __func__); 801 goto err_sndbuf; 802 } 803 804 send_buf->ah = ah; 805 806 /* Set up common MAD hdr */ 807 trap_mad = send_buf->mad; 808 trap_mad->mad_hdr.base_version = OPA_MGMT_BASE_VERSION; 809 trap_mad->mad_hdr.mgmt_class = OPA_MGMT_CLASS_INTEL_EMA; 810 trap_mad->mad_hdr.class_version = OPA_EMA_CLASS_VERSION; 811 trap_mad->mad_hdr.method = IB_MGMT_METHOD_TRAP; 812 port->tid++; 813 trap_mad->mad_hdr.tid = cpu_to_be64(port->tid); 814 trap_mad->mad_hdr.attr_id = IB_SMP_ATTR_NOTICE; 815 816 /* Set up vendor OUI */ 817 trap_mad->oui[0] = INTEL_OUI_1; 818 trap_mad->oui[1] = INTEL_OUI_2; 819 trap_mad->oui[2] = INTEL_OUI_3; 820 821 /* Setup notice attribute portion */ 822 trap_mad->notice.gen_type = OPA_INTEL_EMA_NOTICE_TYPE_INFO << 1; 823 trap_mad->notice.oui_1 = INTEL_OUI_1; 824 trap_mad->notice.oui_2 = INTEL_OUI_2; 825 trap_mad->notice.oui_3 = INTEL_OUI_3; 826 trap_mad->notice.issuer_lid = cpu_to_be32(lid); 827 828 /* copy the actual trap data */ 829 trap = (struct opa_veswport_trap *)trap_mad->notice.raw_data; 830 trap->fabric_id = cpu_to_be16(data->fabric_id); 831 trap->veswid = cpu_to_be16(data->veswid); 832 trap->veswportnum = cpu_to_be32(data->veswportnum); 833 trap->opaportnum = cpu_to_be16(data->opaportnum); 834 trap->veswportindex = data->veswportindex; 835 trap->opcode = data->opcode; 836 837 /* If successful send set up rate limit timeout else bail */ 838 if (ib_post_send_mad(send_buf, NULL)) { 839 ib_free_send_mad(send_buf); 840 } else { 841 if (adapter->trap_count) 842 return; 843 adapter->trap_timeout = jiffies + 844 usecs_to_jiffies(OPA_VNIC_TRAP_TIMEOUT); 845 return; 846 } 847 848 err_sndbuf: 849 rdma_destroy_ah(ah, 0); 850 err_exit: 851 v_err("Aborting trap\n"); 852 } 853 854 static void opa_vnic_event(struct ib_event_handler *handler, 855 struct ib_event *record) 856 { 857 struct opa_vnic_vema_port *port = 858 container_of(handler, struct opa_vnic_vema_port, event_handler); 859 struct opa_vnic_ctrl_port *cport = port->cport; 860 struct opa_vnic_adapter *adapter; 861 unsigned long index; 862 863 if (record->element.port_num != port->port_num) 864 return; 865 866 c_dbg("OPA_VNIC received event %d on device %s port %d\n", 867 record->event, dev_name(&record->device->dev), 868 record->element.port_num); 869 870 if (record->event != IB_EVENT_PORT_ERR && 871 record->event != IB_EVENT_PORT_ACTIVE) 872 return; 873 874 xa_for_each(&port->vports, index, adapter) { 875 if (record->event == IB_EVENT_PORT_ACTIVE) 876 netif_carrier_on(adapter->netdev); 877 else 878 netif_carrier_off(adapter->netdev); 879 } 880 } 881 882 /** 883 * vema_unregister -- Unregisters agent 884 * @cport: pointer to control port 885 * 886 * This deletes the registration by VEMA for MADs 887 */ 888 static void vema_unregister(struct opa_vnic_ctrl_port *cport) 889 { 890 struct opa_vnic_adapter *adapter; 891 unsigned long index; 892 int i; 893 894 for (i = 1; i <= cport->num_ports; i++) { 895 struct opa_vnic_vema_port *port = vema_get_port(cport, i); 896 897 if (!port->mad_agent) 898 continue; 899 900 /* Lock ensures no MAD is being processed */ 901 mutex_lock(&port->lock); 902 xa_for_each(&port->vports, index, adapter) 903 opa_vnic_rem_netdev(adapter); 904 mutex_unlock(&port->lock); 905 906 ib_unregister_mad_agent(port->mad_agent); 907 port->mad_agent = NULL; 908 mutex_destroy(&port->lock); 909 xa_destroy(&port->vports); 910 ib_unregister_event_handler(&port->event_handler); 911 } 912 } 913 914 /** 915 * vema_register -- Registers agent 916 * @cport: pointer to control port 917 * 918 * This function registers the handlers for the VEMA MADs 919 * 920 * Return: returns 0 on success. non zero otherwise 921 */ 922 static int vema_register(struct opa_vnic_ctrl_port *cport) 923 { 924 struct ib_mad_reg_req reg_req = { 925 .mgmt_class = OPA_MGMT_CLASS_INTEL_EMA, 926 .mgmt_class_version = OPA_MGMT_BASE_VERSION, 927 .oui = { INTEL_OUI_1, INTEL_OUI_2, INTEL_OUI_3 } 928 }; 929 int i; 930 931 set_bit(IB_MGMT_METHOD_GET, reg_req.method_mask); 932 set_bit(IB_MGMT_METHOD_SET, reg_req.method_mask); 933 934 /* register ib event handler and mad agent for each port on dev */ 935 for (i = 1; i <= cport->num_ports; i++) { 936 struct opa_vnic_vema_port *port = vema_get_port(cport, i); 937 int ret; 938 939 port->cport = cport; 940 port->port_num = i; 941 942 INIT_IB_EVENT_HANDLER(&port->event_handler, 943 cport->ibdev, opa_vnic_event); 944 ib_register_event_handler(&port->event_handler); 945 946 xa_init(&port->vports); 947 mutex_init(&port->lock); 948 port->mad_agent = ib_register_mad_agent(cport->ibdev, i, 949 IB_QPT_GSI, ®_req, 950 IB_MGMT_RMPP_VERSION, 951 vema_send, vema_recv, 952 port, 0); 953 if (IS_ERR(port->mad_agent)) { 954 ret = PTR_ERR(port->mad_agent); 955 port->mad_agent = NULL; 956 mutex_destroy(&port->lock); 957 vema_unregister(cport); 958 return ret; 959 } 960 } 961 962 return 0; 963 } 964 965 /** 966 * opa_vnic_ctrl_config_dev -- This function sends a trap to the EM 967 * by way of ib_modify_port to indicate support for ethernet on the 968 * fabric. 969 * @cport: pointer to control port 970 * @en: enable or disable ethernet on fabric support 971 */ 972 static void opa_vnic_ctrl_config_dev(struct opa_vnic_ctrl_port *cport, bool en) 973 { 974 struct ib_port_modify pm = { 0 }; 975 int i; 976 977 if (en) 978 pm.set_port_cap_mask = OPA_CAP_MASK3_IsEthOnFabricSupported; 979 else 980 pm.clr_port_cap_mask = OPA_CAP_MASK3_IsEthOnFabricSupported; 981 982 for (i = 1; i <= cport->num_ports; i++) 983 ib_modify_port(cport->ibdev, i, IB_PORT_OPA_MASK_CHG, &pm); 984 } 985 986 /** 987 * opa_vnic_vema_add_one -- Handle new ib device 988 * @device: ib device pointer 989 * 990 * Allocate the vnic control port and initialize it. 991 */ 992 static int opa_vnic_vema_add_one(struct ib_device *device) 993 { 994 struct opa_vnic_ctrl_port *cport; 995 int rc, size = sizeof(*cport); 996 997 if (!rdma_cap_opa_vnic(device)) 998 return -EOPNOTSUPP; 999 1000 size += device->phys_port_cnt * sizeof(struct opa_vnic_vema_port); 1001 cport = kzalloc(size, GFP_KERNEL); 1002 if (!cport) 1003 return -ENOMEM; 1004 1005 cport->num_ports = device->phys_port_cnt; 1006 cport->ibdev = device; 1007 1008 /* Initialize opa vnic management agent (vema) */ 1009 rc = vema_register(cport); 1010 if (!rc) 1011 c_info("VNIC client initialized\n"); 1012 1013 ib_set_client_data(device, &opa_vnic_client, cport); 1014 opa_vnic_ctrl_config_dev(cport, true); 1015 return 0; 1016 } 1017 1018 /** 1019 * opa_vnic_vema_rem_one -- Handle ib device removal 1020 * @device: ib device pointer 1021 * @client_data: ib client data 1022 * 1023 * Uninitialize and free the vnic control port. 1024 */ 1025 static void opa_vnic_vema_rem_one(struct ib_device *device, 1026 void *client_data) 1027 { 1028 struct opa_vnic_ctrl_port *cport = client_data; 1029 1030 c_info("removing VNIC client\n"); 1031 opa_vnic_ctrl_config_dev(cport, false); 1032 vema_unregister(cport); 1033 kfree(cport); 1034 } 1035 1036 static int __init opa_vnic_init(void) 1037 { 1038 int rc; 1039 1040 rc = ib_register_client(&opa_vnic_client); 1041 if (rc) 1042 pr_err("VNIC driver register failed %d\n", rc); 1043 1044 return rc; 1045 } 1046 module_init(opa_vnic_init); 1047 1048 static void opa_vnic_deinit(void) 1049 { 1050 ib_unregister_client(&opa_vnic_client); 1051 } 1052 module_exit(opa_vnic_deinit); 1053 1054 MODULE_LICENSE("Dual BSD/GPL"); 1055 MODULE_AUTHOR("Intel Corporation"); 1056 MODULE_DESCRIPTION("Intel OPA Virtual Network driver"); 1057