opa_vnic_vema_iface.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 VNIC EMA Interface functions.
 50 */
 51
 52#include "opa_vnic_internal.h"
 53
 54/**
 55 * opa_vnic_vema_report_event - sent trap to report the specified event
 56 * @adapter: vnic port adapter
 57 * @event: event to be reported
 58 *
 59 * This function calls vema api to sent a trap for the given event.
 60 */
 61void opa_vnic_vema_report_event(struct opa_vnic_adapter *adapter, u8 event)
 62{
 63	struct __opa_veswport_info *info = &adapter->info;
 64	struct __opa_veswport_trap trap_data;
 65
 66	trap_data.fabric_id = info->vesw.fabric_id;
 67	trap_data.veswid = info->vesw.vesw_id;
 68	trap_data.veswportnum = info->vport.port_num;
 69	trap_data.opaportnum = adapter->port_num;
 70	trap_data.veswportindex = adapter->vport_num;
 71	trap_data.opcode = event;
 72
 73	opa_vnic_vema_send_trap(adapter, &trap_data, info->vport.encap_slid);
 74}
 75
 76/**
 77 * opa_vnic_get_summary_counters - get summary counters
 78 * @adapter: vnic port adapter
 79 * @cntrs: pointer to destination summary counters structure
 80 *
 81 * This function populates the summary counters that is maintained by the
 82 * given adapter to destination address provided.
 83 */
 84void opa_vnic_get_summary_counters(struct opa_vnic_adapter *adapter,
 85				   struct opa_veswport_summary_counters *cntrs)
 86{
 87	struct opa_vnic_stats vstats;
 88	__be64 *dst;
 89	u64 *src;
 90
 91	memset(&vstats, 0, sizeof(vstats));
 92	spin_lock(&adapter->stats_lock);
 93	adapter->rn_ops->ndo_get_stats64(adapter->netdev, &vstats.netstats);
 94	spin_unlock(&adapter->stats_lock);
 95
 96	cntrs->vp_instance = cpu_to_be16(adapter->vport_num);
 97	cntrs->vesw_id = cpu_to_be16(adapter->info.vesw.vesw_id);
 98	cntrs->veswport_num = cpu_to_be32(adapter->port_num);
 99
100	cntrs->tx_errors = cpu_to_be64(vstats.netstats.tx_errors);
101	cntrs->rx_errors = cpu_to_be64(vstats.netstats.rx_errors);
102	cntrs->tx_packets = cpu_to_be64(vstats.netstats.tx_packets);
103	cntrs->rx_packets = cpu_to_be64(vstats.netstats.rx_packets);
104	cntrs->tx_bytes = cpu_to_be64(vstats.netstats.tx_bytes);
105	cntrs->rx_bytes = cpu_to_be64(vstats.netstats.rx_bytes);
106
107	/*
108	 * This loop depends on layout of
109	 * opa_veswport_summary_counters opa_vnic_stats structures.
110	 */
111	for (dst = &cntrs->tx_unicast, src = &vstats.tx_grp.unicast;
112	     dst < &cntrs->reserved[0]; dst++, src++) {
113		*dst = cpu_to_be64(*src);
114	}
115}
116
117/**
118 * opa_vnic_get_error_counters - get error counters
119 * @adapter: vnic port adapter
120 * @cntrs: pointer to destination error counters structure
121 *
122 * This function populates the error counters that is maintained by the
123 * given adapter to destination address provided.
124 */
125void opa_vnic_get_error_counters(struct opa_vnic_adapter *adapter,
126				 struct opa_veswport_error_counters *cntrs)
127{
128	struct opa_vnic_stats vstats;
129
130	memset(&vstats, 0, sizeof(vstats));
131	spin_lock(&adapter->stats_lock);
132	adapter->rn_ops->ndo_get_stats64(adapter->netdev, &vstats.netstats);
133	spin_unlock(&adapter->stats_lock);
134
135	cntrs->vp_instance = cpu_to_be16(adapter->vport_num);
136	cntrs->vesw_id = cpu_to_be16(adapter->info.vesw.vesw_id);
137	cntrs->veswport_num = cpu_to_be32(adapter->port_num);
138
139	cntrs->tx_errors = cpu_to_be64(vstats.netstats.tx_errors);
140	cntrs->rx_errors = cpu_to_be64(vstats.netstats.rx_errors);
141	cntrs->tx_dlid_zero = cpu_to_be64(vstats.tx_dlid_zero);
142	cntrs->tx_drop_state = cpu_to_be64(vstats.tx_drop_state);
143	cntrs->tx_logic = cpu_to_be64(vstats.netstats.tx_fifo_errors +
144				      vstats.netstats.tx_carrier_errors);
145
146	cntrs->rx_bad_veswid = cpu_to_be64(vstats.netstats.rx_nohandler);
147	cntrs->rx_runt = cpu_to_be64(vstats.rx_runt);
148	cntrs->rx_oversize = cpu_to_be64(vstats.rx_oversize);
149	cntrs->rx_drop_state = cpu_to_be64(vstats.rx_drop_state);
150	cntrs->rx_logic = cpu_to_be64(vstats.netstats.rx_fifo_errors);
151}
152
153/**
154 * opa_vnic_get_vesw_info -- Get the vesw information
155 * @adapter: vnic port adapter
156 * @info: pointer to destination vesw info structure
157 *
158 * This function copies the vesw info that is maintained by the
159 * given adapter to destination address provided.
160 */
161void opa_vnic_get_vesw_info(struct opa_vnic_adapter *adapter,
162			    struct opa_vesw_info *info)
163{
164	struct __opa_vesw_info *src = &adapter->info.vesw;
165	int i;
166
167	info->fabric_id = cpu_to_be16(src->fabric_id);
168	info->vesw_id = cpu_to_be16(src->vesw_id);
169	memcpy(info->rsvd0, src->rsvd0, ARRAY_SIZE(src->rsvd0));
170	info->def_port_mask = cpu_to_be16(src->def_port_mask);
171	memcpy(info->rsvd1, src->rsvd1, ARRAY_SIZE(src->rsvd1));
172	info->pkey = cpu_to_be16(src->pkey);
173
174	memcpy(info->rsvd2, src->rsvd2, ARRAY_SIZE(src->rsvd2));
175	info->u_mcast_dlid = cpu_to_be32(src->u_mcast_dlid);
176	for (i = 0; i < OPA_VESW_MAX_NUM_DEF_PORT; i++)
177		info->u_ucast_dlid[i] = cpu_to_be32(src->u_ucast_dlid[i]);
178
179	info->rc = cpu_to_be32(src->rc);
180
181	memcpy(info->rsvd3, src->rsvd3, ARRAY_SIZE(src->rsvd3));
182	info->eth_mtu = cpu_to_be16(src->eth_mtu);
183	memcpy(info->rsvd4, src->rsvd4, ARRAY_SIZE(src->rsvd4));
184}
185
186/**
187 * opa_vnic_set_vesw_info -- Set the vesw information
188 * @adapter: vnic port adapter
189 * @info: pointer to vesw info structure
190 *
191 * This function updates the vesw info that is maintained by the
192 * given adapter with vesw info provided. Reserved fields are stored
193 * and returned back to EM as is.
194 */
195void opa_vnic_set_vesw_info(struct opa_vnic_adapter *adapter,
196			    struct opa_vesw_info *info)
197{
198	struct __opa_vesw_info *dst = &adapter->info.vesw;
199	int i;
200
201	dst->fabric_id = be16_to_cpu(info->fabric_id);
202	dst->vesw_id = be16_to_cpu(info->vesw_id);
203	memcpy(dst->rsvd0, info->rsvd0, ARRAY_SIZE(info->rsvd0));
204	dst->def_port_mask = be16_to_cpu(info->def_port_mask);
205	memcpy(dst->rsvd1, info->rsvd1, ARRAY_SIZE(info->rsvd1));
206	dst->pkey = be16_to_cpu(info->pkey);
207
208	memcpy(dst->rsvd2, info->rsvd2, ARRAY_SIZE(info->rsvd2));
209	dst->u_mcast_dlid = be32_to_cpu(info->u_mcast_dlid);
210	for (i = 0; i < OPA_VESW_MAX_NUM_DEF_PORT; i++)
211		dst->u_ucast_dlid[i] = be32_to_cpu(info->u_ucast_dlid[i]);
212
213	dst->rc = be32_to_cpu(info->rc);
214
215	memcpy(dst->rsvd3, info->rsvd3, ARRAY_SIZE(info->rsvd3));
216	dst->eth_mtu = be16_to_cpu(info->eth_mtu);
217	memcpy(dst->rsvd4, info->rsvd4, ARRAY_SIZE(info->rsvd4));
218}
219
220/**
221 * opa_vnic_get_per_veswport_info -- Get the vesw per port information
222 * @adapter: vnic port adapter
223 * @info: pointer to destination vport info structure
224 *
225 * This function copies the vesw per port info that is maintained by the
226 * given adapter to destination address provided.
227 * Note that the read only fields are not copied.
228 */
229void opa_vnic_get_per_veswport_info(struct opa_vnic_adapter *adapter,
230				    struct opa_per_veswport_info *info)
231{
232	struct __opa_per_veswport_info *src = &adapter->info.vport;
233
234	info->port_num = cpu_to_be32(src->port_num);
235	info->eth_link_status = src->eth_link_status;
236	memcpy(info->rsvd0, src->rsvd0, ARRAY_SIZE(src->rsvd0));
237
238	memcpy(info->base_mac_addr, src->base_mac_addr,
239	       ARRAY_SIZE(info->base_mac_addr));
240	info->config_state = src->config_state;
241	info->oper_state = src->oper_state;
242	info->max_mac_tbl_ent = cpu_to_be16(src->max_mac_tbl_ent);
243	info->max_smac_ent = cpu_to_be16(src->max_smac_ent);
244	info->mac_tbl_digest = cpu_to_be32(src->mac_tbl_digest);
245	memcpy(info->rsvd1, src->rsvd1, ARRAY_SIZE(src->rsvd1));
246
247	info->encap_slid = cpu_to_be32(src->encap_slid);
248	memcpy(info->pcp_to_sc_uc, src->pcp_to_sc_uc,
249	       ARRAY_SIZE(info->pcp_to_sc_uc));
250	memcpy(info->pcp_to_vl_uc, src->pcp_to_vl_uc,
251	       ARRAY_SIZE(info->pcp_to_vl_uc));
252	memcpy(info->pcp_to_sc_mc, src->pcp_to_sc_mc,
253	       ARRAY_SIZE(info->pcp_to_sc_mc));
254	memcpy(info->pcp_to_vl_mc, src->pcp_to_vl_mc,
255	       ARRAY_SIZE(info->pcp_to_vl_mc));
256	info->non_vlan_sc_uc = src->non_vlan_sc_uc;
257	info->non_vlan_vl_uc = src->non_vlan_vl_uc;
258	info->non_vlan_sc_mc = src->non_vlan_sc_mc;
259	info->non_vlan_vl_mc = src->non_vlan_vl_mc;
260	memcpy(info->rsvd2, src->rsvd2, ARRAY_SIZE(src->rsvd2));
261
262	info->uc_macs_gen_count = cpu_to_be16(src->uc_macs_gen_count);
263	info->mc_macs_gen_count = cpu_to_be16(src->mc_macs_gen_count);
264	memcpy(info->rsvd3, src->rsvd3, ARRAY_SIZE(src->rsvd3));
265}
266
267/**
268 * opa_vnic_set_per_veswport_info -- Set vesw per port information
269 * @adapter: vnic port adapter
270 * @info: pointer to vport info structure
271 *
272 * This function updates the vesw per port info that is maintained by the
273 * given adapter with vesw per port info provided. Reserved fields are
274 * stored and returned back to EM as is.
275 */
276void opa_vnic_set_per_veswport_info(struct opa_vnic_adapter *adapter,
277				    struct opa_per_veswport_info *info)
278{
279	struct __opa_per_veswport_info *dst = &adapter->info.vport;
280
281	dst->port_num = be32_to_cpu(info->port_num);
282	memcpy(dst->rsvd0, info->rsvd0, ARRAY_SIZE(info->rsvd0));
283
284	memcpy(dst->base_mac_addr, info->base_mac_addr,
285	       ARRAY_SIZE(dst->base_mac_addr));
286	dst->config_state = info->config_state;
287	memcpy(dst->rsvd1, info->rsvd1, ARRAY_SIZE(info->rsvd1));
288
289	dst->encap_slid = be32_to_cpu(info->encap_slid);
290	memcpy(dst->pcp_to_sc_uc, info->pcp_to_sc_uc,
291	       ARRAY_SIZE(dst->pcp_to_sc_uc));
292	memcpy(dst->pcp_to_vl_uc, info->pcp_to_vl_uc,
293	       ARRAY_SIZE(dst->pcp_to_vl_uc));
294	memcpy(dst->pcp_to_sc_mc, info->pcp_to_sc_mc,
295	       ARRAY_SIZE(dst->pcp_to_sc_mc));
296	memcpy(dst->pcp_to_vl_mc, info->pcp_to_vl_mc,
297	       ARRAY_SIZE(dst->pcp_to_vl_mc));
298	dst->non_vlan_sc_uc = info->non_vlan_sc_uc;
299	dst->non_vlan_vl_uc = info->non_vlan_vl_uc;
300	dst->non_vlan_sc_mc = info->non_vlan_sc_mc;
301	dst->non_vlan_vl_mc = info->non_vlan_vl_mc;
302	memcpy(dst->rsvd2, info->rsvd2, ARRAY_SIZE(info->rsvd2));
303	memcpy(dst->rsvd3, info->rsvd3, ARRAY_SIZE(info->rsvd3));
304}
305
306/**
307 * opa_vnic_query_mcast_macs - query multicast mac list
308 * @adapter: vnic port adapter
309 * @macs: pointer mac list
310 *
311 * This function populates the provided mac list with the configured
312 * multicast addresses in the adapter.
313 */
314void opa_vnic_query_mcast_macs(struct opa_vnic_adapter *adapter,
315			       struct opa_veswport_iface_macs *macs)
316{
317	u16 start_idx, num_macs, idx = 0, count = 0;
318	struct netdev_hw_addr *ha;
319
320	start_idx = be16_to_cpu(macs->start_idx);
321	num_macs = be16_to_cpu(macs->num_macs_in_msg);
322	netdev_for_each_mc_addr(ha, adapter->netdev) {
323		struct opa_vnic_iface_mac_entry *entry = &macs->entry[count];
324
325		if (start_idx > idx++)
326			continue;
327		else if (num_macs == count)
328			break;
329		memcpy(entry, ha->addr, sizeof(*entry));
330		count++;
331	}
332
333	macs->tot_macs_in_lst = cpu_to_be16(netdev_mc_count(adapter->netdev));
334	macs->num_macs_in_msg = cpu_to_be16(count);
335	macs->gen_count = cpu_to_be16(adapter->info.vport.mc_macs_gen_count);
336}
337
338/**
339 * opa_vnic_query_ucast_macs - query unicast mac list
340 * @adapter: vnic port adapter
341 * @macs: pointer mac list
342 *
343 * This function populates the provided mac list with the configured
344 * unicast addresses in the adapter.
345 */
346void opa_vnic_query_ucast_macs(struct opa_vnic_adapter *adapter,
347			       struct opa_veswport_iface_macs *macs)
348{
349	u16 start_idx, tot_macs, num_macs, idx = 0, count = 0, em_macs = 0;
350	struct netdev_hw_addr *ha;
351
352	start_idx = be16_to_cpu(macs->start_idx);
353	num_macs = be16_to_cpu(macs->num_macs_in_msg);
354	/* loop through dev_addrs list first */
355	for_each_dev_addr(adapter->netdev, ha) {
356		struct opa_vnic_iface_mac_entry *entry = &macs->entry[count];
357
358		/* Do not include EM specified MAC address */
359		if (!memcmp(adapter->info.vport.base_mac_addr, ha->addr,
360			    ARRAY_SIZE(adapter->info.vport.base_mac_addr))) {
361			em_macs++;
362			continue;
363		}
364
365		if (start_idx > idx++)
366			continue;
367		else if (num_macs == count)
368			break;
369		memcpy(entry, ha->addr, sizeof(*entry));
370		count++;
371	}
372
373	/* loop through uc list */
374	netdev_for_each_uc_addr(ha, adapter->netdev) {
375		struct opa_vnic_iface_mac_entry *entry = &macs->entry[count];
376
377		if (start_idx > idx++)
378			continue;
379		else if (num_macs == count)
380			break;
381		memcpy(entry, ha->addr, sizeof(*entry));
382		count++;
383	}
384
385	tot_macs = netdev_hw_addr_list_count(&adapter->netdev->dev_addrs) +
386		   netdev_uc_count(adapter->netdev) - em_macs;
387	macs->tot_macs_in_lst = cpu_to_be16(tot_macs);
388	macs->num_macs_in_msg = cpu_to_be16(count);
389	macs->gen_count = cpu_to_be16(adapter->info.vport.uc_macs_gen_count);
390}