drivers/infiniband/ulp/opa_vnic/opa_vnic_vema.c

   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         case OPA_EM_ATTR_IFACE_MCAST_MACS:
 551                 vema_get_mac_list(port, recvd_mad, rsp_mad, attr_id);
 552                 break;
 553         case OPA_EM_ATTR_VESWPORT_SUMMARY_COUNTERS:
 554                 vema_get_summary_counters(port, recvd_mad, rsp_mad);
 555                 break;
 556         case OPA_EM_ATTR_VESWPORT_ERROR_COUNTERS:
 557                 vema_get_error_counters(port, recvd_mad, rsp_mad);
 558                 break;
 559         default:
 560                 rsp_mad->mad_hdr.status = OPA_VNIC_UNSUP_ATTR;
 561                 break;
 562         }
 563 }
 564
 565 /**
 566  * vema_set -- Process received set MAD
 567  * @port:      source port on which MAD was received
 568  * @recvd_mad: Received mad contains fields to set vnic parameters
 569  * @rsp_mad:   Response mad to be built
 570  */
 571 static void vema_set(struct opa_vnic_vema_port *port,
 572                      struct opa_vnic_vema_mad *recvd_mad,
 573                      struct opa_vnic_vema_mad *rsp_mad)
 574 {
 575         u16 attr_id = be16_to_cpu(recvd_mad->mad_hdr.attr_id);
 576
 577         switch (attr_id) {
 578         case OPA_EM_ATTR_CLASS_PORT_INFO:
 579                 vema_set_class_port_info(port, recvd_mad, rsp_mad);
 580                 break;
 581         case OPA_EM_ATTR_VESWPORT_INFO:
 582                 vema_set_veswport_info(port, recvd_mad, rsp_mad);
 583                 break;
 584         case OPA_EM_ATTR_VESWPORT_MAC_ENTRIES:
 585                 vema_set_mac_entries(port, recvd_mad, rsp_mad);
 586                 break;
 587         case OPA_EM_ATTR_DELETE_VESW:
 588                 vema_set_delete_vesw(port, recvd_mad, rsp_mad);
 589                 break;
 590         default:
 591                 rsp_mad->mad_hdr.status = OPA_VNIC_UNSUP_ATTR;
 592                 break;
 593         }
 594 }
 595
 596 /**
 597  * vema_send -- Send handler for VEMA MAD agent
 598  * @mad_agent: pointer to the mad agent
 599  * @mad_wc:    pointer to mad send work completion information
 600  *
 601  * Free all the data structures associated with the sent MAD
 602  */
 603 static void vema_send(struct ib_mad_agent *mad_agent,
 604                       struct ib_mad_send_wc *mad_wc)
 605 {
 606         rdma_destroy_ah(mad_wc->send_buf->ah, RDMA_DESTROY_AH_SLEEPABLE);
 607         ib_free_send_mad(mad_wc->send_buf);
 608 }
 609
 610 /**
 611  * vema_recv -- Recv handler for VEMA MAD agent
 612  * @mad_agent: pointer to the mad agent
 613  * @send_buf: Send buffer if found, else NULL
 614  * @mad_wc:    pointer to mad send work completion information
 615  *
 616  * Handle only set and get methods and respond to other methods
 617  * as unsupported. Allocate response buffer and address handle
 618  * for the response MAD.
 619  */
 620 static void vema_recv(struct ib_mad_agent *mad_agent,
 621                       struct ib_mad_send_buf *send_buf,
 622                       struct ib_mad_recv_wc *mad_wc)
 623 {
 624         struct opa_vnic_vema_port *port;
 625         struct ib_ah              *ah;
 626         struct ib_mad_send_buf    *rsp;
 627         struct opa_vnic_vema_mad  *vema_mad;
 628
 629         if (!mad_wc || !mad_wc->recv_buf.mad)
 630                 return;
 631
 632         port = mad_agent->context;
 633         ah = ib_create_ah_from_wc(mad_agent->qp->pd, mad_wc->wc,
 634                                   mad_wc->recv_buf.grh, mad_agent->port_num);
 635         if (IS_ERR(ah))
 636                 goto free_recv_mad;
 637
 638         rsp = ib_create_send_mad(mad_agent, mad_wc->wc->src_qp,
 639                                  mad_wc->wc->pkey_index, 0,
 640                                  IB_MGMT_VENDOR_HDR, OPA_VNIC_EMA_DATA,
 641                                  GFP_KERNEL, OPA_MGMT_BASE_VERSION);
 642         if (IS_ERR(rsp))
 643                 goto err_rsp;
 644
 645         rsp->ah = ah;
 646         vema_mad = rsp->mad;
 647         memcpy(vema_mad, mad_wc->recv_buf.mad, IB_MGMT_VENDOR_HDR);
 648         vema_mad->mad_hdr.method = IB_MGMT_METHOD_GET_RESP;
 649         vema_mad->mad_hdr.status = 0;
 650
 651         /* Lock ensures network adapter is not removed */
 652         mutex_lock(&port->lock);
 653
 654         switch (mad_wc->recv_buf.mad->mad_hdr.method) {
 655         case IB_MGMT_METHOD_GET:
 656                 vema_get(port, (struct opa_vnic_vema_mad *)mad_wc->recv_buf.mad,
 657                          vema_mad);
 658                 break;
 659         case IB_MGMT_METHOD_SET:
 660                 vema_set(port, (struct opa_vnic_vema_mad *)mad_wc->recv_buf.mad,
 661                          vema_mad);
 662                 break;
 663         default:
 664                 vema_mad->mad_hdr.status = OPA_VNIC_UNSUP_ATTR;
 665                 break;
 666         }
 667         mutex_unlock(&port->lock);
 668
 669         if (!ib_post_send_mad(rsp, NULL)) {
 670                 /*
 671                  * with post send successful ah and send mad
 672                  * will be destroyed in send handler
 673                  */
 674                 goto free_recv_mad;
 675         }
 676
 677         ib_free_send_mad(rsp);
 678
 679 err_rsp:
 680         rdma_destroy_ah(ah, RDMA_DESTROY_AH_SLEEPABLE);
 681 free_recv_mad:
 682         ib_free_recv_mad(mad_wc);
 683 }
 684
 685 /**
 686  * vema_get_port -- Gets the opa_vnic_vema_port
 687  * @cport: pointer to control dev
 688  * @port_num: Port number
 689  *
 690  * This function loops through the ports and returns
 691  * the opa_vnic_vema port structure that is associated
 692  * with the OPA port number
 693  *
 694  * Return: ptr to requested opa_vnic_vema_port strucure
 695  *         if success, NULL if not
 696  */
 697 static struct opa_vnic_vema_port *
 698 vema_get_port(struct opa_vnic_ctrl_port *cport, u8 port_num)
 699 {
 700         struct opa_vnic_vema_port *port = (void *)cport + sizeof(*cport);
 701
 702         if (port_num > cport->num_ports)
 703                 return NULL;
 704
 705         return port + (port_num - 1);
 706 }
 707
 708 /**
 709  * opa_vnic_vema_send_trap -- This function sends a trap to the EM
 710  * @adapter: pointer to vnic adapter
 711  * @data: pointer to trap data filled by calling function
 712  * @lid:  issuers lid (encap_slid from vesw_port_info)
 713  *
 714  * This function is called from the VNIC driver to send a trap if there
 715  * is somethng the EM should be notified about. These events currently
 716  * are
 717  * 1) UNICAST INTERFACE MACADDRESS changes
 718  * 2) MULTICAST INTERFACE MACADDRESS changes
 719  * 3) ETHERNET LINK STATUS changes
 720  * While allocating the send mad the remote site qpn used is 1
 721  * as this is the well known QP.
 722  *
 723  */
 724 void opa_vnic_vema_send_trap(struct opa_vnic_adapter *adapter,
 725                              struct __opa_veswport_trap *data, u32 lid)
 726 {
 727         struct opa_vnic_ctrl_port *cport = adapter->cport;
 728         struct ib_mad_send_buf *send_buf;
 729         struct opa_vnic_vema_port *port;
 730         struct ib_device *ibp;
 731         struct opa_vnic_vema_mad_trap *trap_mad;
 732         struct opa_class_port_info *class;
 733         struct rdma_ah_attr ah_attr;
 734         struct ib_ah *ah;
 735         struct opa_veswport_trap *trap;
 736         u32 trap_lid;
 737         u16 pkey_idx;
 738
 739         if (!cport)
 740                 goto err_exit;
 741         ibp = cport->ibdev;
 742         port = vema_get_port(cport, data->opaportnum);
 743         if (!port || !port->mad_agent)
 744                 goto err_exit;
 745
 746         if (time_before(jiffies, adapter->trap_timeout)) {
 747                 if (adapter->trap_count == OPA_VNIC_TRAP_BURST_LIMIT) {
 748                         v_warn("Trap rate exceeded\n");
 749                         goto err_exit;
 750                 } else {
 751                         adapter->trap_count++;
 752                 }
 753         } else {
 754                 adapter->trap_count = 0;
 755         }
 756
 757         class = &port->class_port_info;
 758         /* Set up address handle */
 759         memset(&ah_attr, 0, sizeof(ah_attr));
 760         ah_attr.type = rdma_ah_find_type(ibp, port->port_num);
 761         rdma_ah_set_sl(&ah_attr,
 762                        GET_TRAP_SL_FROM_CLASS_PORT_INFO(class->trap_sl_rsvd));
 763         rdma_ah_set_port_num(&ah_attr, port->port_num);
 764         trap_lid = be32_to_cpu(class->trap_lid);
 765         /*
 766          * check for trap lid validity, must not be zero
 767          * The trap sink could change after we fashion the MAD but since traps
 768          * are not guaranteed we won't use a lock as anyway the change will take
 769          * place even with locking.
 770          */
 771         if (!trap_lid) {
 772                 c_err("%s: Invalid dlid\n", __func__);
 773                 goto err_exit;
 774         }
 775
 776         rdma_ah_set_dlid(&ah_attr, trap_lid);
 777         ah = rdma_create_ah(port->mad_agent->qp->pd, &ah_attr, 0);
 778         if (IS_ERR(ah)) {
 779                 c_err("%s:Couldn't create new AH = %p\n", __func__, ah);
 780                 c_err("%s:dlid = %d, sl = %d, port = %d\n", __func__,
 781                       rdma_ah_get_dlid(&ah_attr), rdma_ah_get_sl(&ah_attr),
 782                       rdma_ah_get_port_num(&ah_attr));
 783                 goto err_exit;
 784         }
 785
 786         if (ib_find_pkey(ibp, data->opaportnum, IB_DEFAULT_PKEY_FULL,
 787                          &pkey_idx) < 0) {
 788                 c_err("%s:full key not found, defaulting to partial\n",
 789                       __func__);
 790                 if (ib_find_pkey(ibp, data->opaportnum, IB_DEFAULT_PKEY_PARTIAL,
 791                                  &pkey_idx) < 0)
 792                         pkey_idx = 1;
 793         }
 794
 795         send_buf = ib_create_send_mad(port->mad_agent, 1, pkey_idx, 0,
 796                                       IB_MGMT_VENDOR_HDR, IB_MGMT_MAD_DATA,
 797                                       GFP_ATOMIC, OPA_MGMT_BASE_VERSION);
 798         if (IS_ERR(send_buf)) {
 799                 c_err("%s:Couldn't allocate send buf\n", __func__);
 800                 goto err_sndbuf;
 801         }
 802
 803         send_buf->ah = ah;
 804
 805         /* Set up common MAD hdr */
 806         trap_mad = send_buf->mad;
 807         trap_mad->mad_hdr.base_version = OPA_MGMT_BASE_VERSION;
 808         trap_mad->mad_hdr.mgmt_class = OPA_MGMT_CLASS_INTEL_EMA;
 809         trap_mad->mad_hdr.class_version = OPA_EMA_CLASS_VERSION;
 810         trap_mad->mad_hdr.method = IB_MGMT_METHOD_TRAP;
 811         port->tid++;
 812         trap_mad->mad_hdr.tid = cpu_to_be64(port->tid);
 813         trap_mad->mad_hdr.attr_id = IB_SMP_ATTR_NOTICE;
 814
 815         /* Set up vendor OUI */
 816         trap_mad->oui[0] = INTEL_OUI_1;
 817         trap_mad->oui[1] = INTEL_OUI_2;
 818         trap_mad->oui[2] = INTEL_OUI_3;
 819
 820         /* Setup notice attribute portion */
 821         trap_mad->notice.gen_type = OPA_INTEL_EMA_NOTICE_TYPE_INFO << 1;
 822         trap_mad->notice.oui_1 = INTEL_OUI_1;
 823         trap_mad->notice.oui_2 = INTEL_OUI_2;
 824         trap_mad->notice.oui_3 = INTEL_OUI_3;
 825         trap_mad->notice.issuer_lid = cpu_to_be32(lid);
 826
 827         /* copy the actual trap data */
 828         trap = (struct opa_veswport_trap *)trap_mad->notice.raw_data;
 829         trap->fabric_id = cpu_to_be16(data->fabric_id);
 830         trap->veswid = cpu_to_be16(data->veswid);
 831         trap->veswportnum = cpu_to_be32(data->veswportnum);
 832         trap->opaportnum = cpu_to_be16(data->opaportnum);
 833         trap->veswportindex = data->veswportindex;
 834         trap->opcode = data->opcode;
 835
 836         /* If successful send set up rate limit timeout else bail */
 837         if (ib_post_send_mad(send_buf, NULL)) {
 838                 ib_free_send_mad(send_buf);
 839         } else {
 840                 if (adapter->trap_count)
 841                         return;
 842                 adapter->trap_timeout = jiffies +
 843                                         usecs_to_jiffies(OPA_VNIC_TRAP_TIMEOUT);
 844                 return;
 845         }
 846
 847 err_sndbuf:
 848         rdma_destroy_ah(ah, 0);
 849 err_exit:
 850         v_err("Aborting trap\n");
 851 }
 852
 853 static void opa_vnic_event(struct ib_event_handler *handler,
 854                            struct ib_event *record)
 855 {
 856         struct opa_vnic_vema_port *port =
 857                 container_of(handler, struct opa_vnic_vema_port, event_handler);
 858         struct opa_vnic_ctrl_port *cport = port->cport;
 859         struct opa_vnic_adapter *adapter;
 860         unsigned long index;
 861
 862         if (record->element.port_num != port->port_num)
 863                 return;
 864
 865         c_dbg("OPA_VNIC received event %d on device %s port %d\n",
 866               record->event, dev_name(&record->device->dev),
 867               record->element.port_num);
 868
 869         if (record->event != IB_EVENT_PORT_ERR &&
 870             record->event != IB_EVENT_PORT_ACTIVE)
 871                 return;
 872
 873         xa_for_each(&port->vports, index, adapter) {
 874                 if (record->event == IB_EVENT_PORT_ACTIVE)
 875                         netif_carrier_on(adapter->netdev);
 876                 else
 877                         netif_carrier_off(adapter->netdev);
 878         }
 879 }
 880
 881 /**
 882  * vema_unregister -- Unregisters agent
 883  * @cport: pointer to control port
 884  *
 885  * This deletes the registration by VEMA for MADs
 886  */
 887 static void vema_unregister(struct opa_vnic_ctrl_port *cport)
 888 {
 889         struct opa_vnic_adapter *adapter;
 890         unsigned long index;
 891         int i;
 892
 893         for (i = 1; i <= cport->num_ports; i++) {
 894                 struct opa_vnic_vema_port *port = vema_get_port(cport, i);
 895
 896                 if (!port->mad_agent)
 897                         continue;
 898
 899                 /* Lock ensures no MAD is being processed */
 900                 mutex_lock(&port->lock);
 901                 xa_for_each(&port->vports, index, adapter)
 902                         opa_vnic_rem_netdev(adapter);
 903                 mutex_unlock(&port->lock);
 904
 905                 ib_unregister_mad_agent(port->mad_agent);
 906                 port->mad_agent = NULL;
 907                 mutex_destroy(&port->lock);
 908                 xa_destroy(&port->vports);
 909                 ib_unregister_event_handler(&port->event_handler);
 910         }
 911 }
 912
 913 /**
 914  * vema_register -- Registers agent
 915  * @cport: pointer to control port
 916  *
 917  * This function registers the handlers for the VEMA MADs
 918  *
 919  * Return: returns 0 on success. non zero otherwise
 920  */
 921 static int vema_register(struct opa_vnic_ctrl_port *cport)
 922 {
 923         struct ib_mad_reg_req reg_req = {
 924                 .mgmt_class = OPA_MGMT_CLASS_INTEL_EMA,
 925                 .mgmt_class_version = OPA_MGMT_BASE_VERSION,
 926                 .oui = { INTEL_OUI_1, INTEL_OUI_2, INTEL_OUI_3 }
 927         };
 928         int i;
 929
 930         set_bit(IB_MGMT_METHOD_GET, reg_req.method_mask);
 931         set_bit(IB_MGMT_METHOD_SET, reg_req.method_mask);
 932
 933         /* register ib event handler and mad agent for each port on dev */
 934         for (i = 1; i <= cport->num_ports; i++) {
 935                 struct opa_vnic_vema_port *port = vema_get_port(cport, i);
 936                 int ret;
 937
 938                 port->cport = cport;
 939                 port->port_num = i;
 940
 941                 INIT_IB_EVENT_HANDLER(&port->event_handler,
 942                                       cport->ibdev, opa_vnic_event);
 943                 ib_register_event_handler(&port->event_handler);
 944
 945                 xa_init(&port->vports);
 946                 mutex_init(&port->lock);
 947                 port->mad_agent = ib_register_mad_agent(cport->ibdev, i,
 948                                                         IB_QPT_GSI, &reg_req,
 949                                                         IB_MGMT_RMPP_VERSION,
 950                                                         vema_send, vema_recv,
 951                                                         port, 0);
 952                 if (IS_ERR(port->mad_agent)) {
 953                         ret = PTR_ERR(port->mad_agent);
 954                         port->mad_agent = NULL;
 955                         mutex_destroy(&port->lock);
 956                         vema_unregister(cport);
 957                         return ret;
 958                 }
 959         }
 960
 961         return 0;
 962 }
 963
 964 /**
 965  * opa_vnic_ctrl_config_dev -- This function sends a trap to the EM
 966  * by way of ib_modify_port to indicate support for ethernet on the
 967  * fabric.
 968  * @cport: pointer to control port
 969  * @en: enable or disable ethernet on fabric support
 970  */
 971 static void opa_vnic_ctrl_config_dev(struct opa_vnic_ctrl_port *cport, bool en)
 972 {
 973         struct ib_port_modify pm = { 0 };
 974         int i;
 975
 976         if (en)
 977                 pm.set_port_cap_mask = OPA_CAP_MASK3_IsEthOnFabricSupported;
 978         else
 979                 pm.clr_port_cap_mask = OPA_CAP_MASK3_IsEthOnFabricSupported;
 980
 981         for (i = 1; i <= cport->num_ports; i++)
 982                 ib_modify_port(cport->ibdev, i, IB_PORT_OPA_MASK_CHG, &pm);
 983 }
 984
 985 /**
 986  * opa_vnic_vema_add_one -- Handle new ib device
 987  * @device: ib device pointer
 988  *
 989  * Allocate the vnic control port and initialize it.
 990  */
 991 static int opa_vnic_vema_add_one(struct ib_device *device)
 992 {
 993         struct opa_vnic_ctrl_port *cport;
 994         int rc, size = sizeof(*cport);
 995
 996         if (!rdma_cap_opa_vnic(device))
 997                 return -EOPNOTSUPP;
 998
 999         size += device->phys_port_cnt * sizeof(struct opa_vnic_vema_port);
1000         cport = kzalloc(size, GFP_KERNEL);
1001         if (!cport)
1002                 return -ENOMEM;
1003
1004         cport->num_ports = device->phys_port_cnt;
1005         cport->ibdev = device;
1006
1007         /* Initialize opa vnic management agent (vema) */
1008         rc = vema_register(cport);
1009         if (!rc)
1010                 c_info("VNIC client initialized\n");
1011
1012         ib_set_client_data(device, &opa_vnic_client, cport);
1013         opa_vnic_ctrl_config_dev(cport, true);
1014         return 0;
1015 }
1016
1017 /**
1018  * opa_vnic_vema_rem_one -- Handle ib device removal
1019  * @device: ib device pointer
1020  * @client_data: ib client data
1021  *
1022  * Uninitialize and free the vnic control port.
1023  */
1024 static void opa_vnic_vema_rem_one(struct ib_device *device,
1025                                   void *client_data)
1026 {
1027         struct opa_vnic_ctrl_port *cport = client_data;
1028
1029         c_info("removing VNIC client\n");
1030         opa_vnic_ctrl_config_dev(cport, false);
1031         vema_unregister(cport);
1032         kfree(cport);
1033 }
1034
1035 static int __init opa_vnic_init(void)
1036 {
1037         int rc;
1038
1039         rc = ib_register_client(&opa_vnic_client);
1040         if (rc)
1041                 pr_err("VNIC driver register failed %d\n", rc);
1042
1043         return rc;
1044 }
1045 module_init(opa_vnic_init);
1046
1047 static void opa_vnic_deinit(void)
1048 {
1049         ib_unregister_client(&opa_vnic_client);
1050 }
1051 module_exit(opa_vnic_deinit);
1052
1053 MODULE_LICENSE("Dual BSD/GPL");
1054 MODULE_AUTHOR("Intel Corporation");
1055 MODULE_DESCRIPTION("Intel OPA Virtual Network driver");