ARM: s3c64xx: bring back notes from removed debug-macro.S
[linux-2.6-microblaze.git] / 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                 /* 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, &reg_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");