xref: /linux/drivers/net/ethernet/intel/i40e/i40e_virtchnl_pf.c (revision 1d227fcc72223cbdd34d0ce13541cbaab5e0d72f)
1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
3 
4 #include "i40e.h"
5 #include "i40e_lan_hmc.h"
6 #include "i40e_virtchnl_pf.h"
7 
8 /*********************notification routines***********************/
9 
10 /**
11  * i40e_vc_vf_broadcast
12  * @pf: pointer to the PF structure
13  * @v_opcode: operation code
14  * @v_retval: return value
15  * @msg: pointer to the msg buffer
16  * @msglen: msg length
17  *
18  * send a message to all VFs on a given PF
19  **/
i40e_vc_vf_broadcast(struct i40e_pf * pf,enum virtchnl_ops v_opcode,int v_retval,u8 * msg,u16 msglen)20 static void i40e_vc_vf_broadcast(struct i40e_pf *pf,
21 				 enum virtchnl_ops v_opcode,
22 				 int v_retval, u8 *msg,
23 				 u16 msglen)
24 {
25 	struct i40e_hw *hw = &pf->hw;
26 	struct i40e_vf *vf = pf->vf;
27 	int i;
28 
29 	for (i = 0; i < pf->num_alloc_vfs; i++, vf++) {
30 		int abs_vf_id = vf->vf_id + (int)hw->func_caps.vf_base_id;
31 		/* Not all vfs are enabled so skip the ones that are not */
32 		if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states) &&
33 		    !test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states))
34 			continue;
35 
36 		/* Ignore return value on purpose - a given VF may fail, but
37 		 * we need to keep going and send to all of them
38 		 */
39 		i40e_aq_send_msg_to_vf(hw, abs_vf_id, v_opcode, v_retval,
40 				       msg, msglen, NULL);
41 	}
42 }
43 
44 /**
45  * i40e_vc_link_speed2mbps
46  * converts i40e_aq_link_speed to integer value of Mbps
47  * @link_speed: the speed to convert
48  *
49  * return the speed as direct value of Mbps.
50  **/
51 static u32
i40e_vc_link_speed2mbps(enum i40e_aq_link_speed link_speed)52 i40e_vc_link_speed2mbps(enum i40e_aq_link_speed link_speed)
53 {
54 	switch (link_speed) {
55 	case I40E_LINK_SPEED_100MB:
56 		return SPEED_100;
57 	case I40E_LINK_SPEED_1GB:
58 		return SPEED_1000;
59 	case I40E_LINK_SPEED_2_5GB:
60 		return SPEED_2500;
61 	case I40E_LINK_SPEED_5GB:
62 		return SPEED_5000;
63 	case I40E_LINK_SPEED_10GB:
64 		return SPEED_10000;
65 	case I40E_LINK_SPEED_20GB:
66 		return SPEED_20000;
67 	case I40E_LINK_SPEED_25GB:
68 		return SPEED_25000;
69 	case I40E_LINK_SPEED_40GB:
70 		return SPEED_40000;
71 	case I40E_LINK_SPEED_UNKNOWN:
72 		return SPEED_UNKNOWN;
73 	}
74 	return SPEED_UNKNOWN;
75 }
76 
77 /**
78  * i40e_set_vf_link_state
79  * @vf: pointer to the VF structure
80  * @pfe: pointer to PF event structure
81  * @ls: pointer to link status structure
82  *
83  * set a link state on a single vf
84  **/
i40e_set_vf_link_state(struct i40e_vf * vf,struct virtchnl_pf_event * pfe,struct i40e_link_status * ls)85 static void i40e_set_vf_link_state(struct i40e_vf *vf,
86 				   struct virtchnl_pf_event *pfe, struct i40e_link_status *ls)
87 {
88 	u8 link_status = ls->link_info & I40E_AQ_LINK_UP;
89 
90 	if (vf->link_forced)
91 		link_status = vf->link_up;
92 
93 	if (vf->driver_caps & VIRTCHNL_VF_CAP_ADV_LINK_SPEED) {
94 		pfe->event_data.link_event_adv.link_speed = link_status ?
95 			i40e_vc_link_speed2mbps(ls->link_speed) : 0;
96 		pfe->event_data.link_event_adv.link_status = link_status;
97 	} else {
98 		pfe->event_data.link_event.link_speed = link_status ?
99 			i40e_virtchnl_link_speed(ls->link_speed) : 0;
100 		pfe->event_data.link_event.link_status = link_status;
101 	}
102 }
103 
104 /**
105  * i40e_vc_notify_vf_link_state
106  * @vf: pointer to the VF structure
107  *
108  * send a link status message to a single VF
109  **/
i40e_vc_notify_vf_link_state(struct i40e_vf * vf)110 static void i40e_vc_notify_vf_link_state(struct i40e_vf *vf)
111 {
112 	struct virtchnl_pf_event pfe;
113 	struct i40e_pf *pf = vf->pf;
114 	struct i40e_hw *hw = &pf->hw;
115 	struct i40e_link_status *ls = &pf->hw.phy.link_info;
116 	int abs_vf_id = vf->vf_id + (int)hw->func_caps.vf_base_id;
117 
118 	pfe.event = VIRTCHNL_EVENT_LINK_CHANGE;
119 	pfe.severity = PF_EVENT_SEVERITY_INFO;
120 
121 	i40e_set_vf_link_state(vf, &pfe, ls);
122 
123 	i40e_aq_send_msg_to_vf(hw, abs_vf_id, VIRTCHNL_OP_EVENT,
124 			       0, (u8 *)&pfe, sizeof(pfe), NULL);
125 }
126 
127 /**
128  * i40e_vc_notify_link_state
129  * @pf: pointer to the PF structure
130  *
131  * send a link status message to all VFs on a given PF
132  **/
i40e_vc_notify_link_state(struct i40e_pf * pf)133 void i40e_vc_notify_link_state(struct i40e_pf *pf)
134 {
135 	int i;
136 
137 	for (i = 0; i < pf->num_alloc_vfs; i++)
138 		i40e_vc_notify_vf_link_state(&pf->vf[i]);
139 }
140 
141 /**
142  * i40e_vc_notify_reset
143  * @pf: pointer to the PF structure
144  *
145  * indicate a pending reset to all VFs on a given PF
146  **/
i40e_vc_notify_reset(struct i40e_pf * pf)147 void i40e_vc_notify_reset(struct i40e_pf *pf)
148 {
149 	struct virtchnl_pf_event pfe;
150 
151 	pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
152 	pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
153 	i40e_vc_vf_broadcast(pf, VIRTCHNL_OP_EVENT, 0,
154 			     (u8 *)&pfe, sizeof(struct virtchnl_pf_event));
155 }
156 
157 #ifdef CONFIG_PCI_IOV
i40e_restore_all_vfs_msi_state(struct pci_dev * pdev)158 void i40e_restore_all_vfs_msi_state(struct pci_dev *pdev)
159 {
160 	u16 vf_id;
161 	u16 pos;
162 
163 	/* Continue only if this is a PF */
164 	if (!pdev->is_physfn)
165 		return;
166 
167 	if (!pci_num_vf(pdev))
168 		return;
169 
170 	pos = pci_find_ext_capability(pdev, PCI_EXT_CAP_ID_SRIOV);
171 	if (pos) {
172 		struct pci_dev *vf_dev = NULL;
173 
174 		pci_read_config_word(pdev, pos + PCI_SRIOV_VF_DID, &vf_id);
175 		while ((vf_dev = pci_get_device(pdev->vendor, vf_id, vf_dev))) {
176 			if (vf_dev->is_virtfn && vf_dev->physfn == pdev)
177 				pci_restore_msi_state(vf_dev);
178 		}
179 	}
180 }
181 #endif /* CONFIG_PCI_IOV */
182 
183 /**
184  * i40e_vc_notify_vf_reset
185  * @vf: pointer to the VF structure
186  *
187  * indicate a pending reset to the given VF
188  **/
i40e_vc_notify_vf_reset(struct i40e_vf * vf)189 void i40e_vc_notify_vf_reset(struct i40e_vf *vf)
190 {
191 	struct virtchnl_pf_event pfe;
192 	int abs_vf_id;
193 
194 	/* validate the request */
195 	if (!vf || vf->vf_id >= vf->pf->num_alloc_vfs)
196 		return;
197 
198 	/* verify if the VF is in either init or active before proceeding */
199 	if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states) &&
200 	    !test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states))
201 		return;
202 
203 	abs_vf_id = vf->vf_id + (int)vf->pf->hw.func_caps.vf_base_id;
204 
205 	pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
206 	pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
207 	i40e_aq_send_msg_to_vf(&vf->pf->hw, abs_vf_id, VIRTCHNL_OP_EVENT,
208 			       0, (u8 *)&pfe,
209 			       sizeof(struct virtchnl_pf_event), NULL);
210 }
211 /***********************misc routines*****************************/
212 
213 /**
214  * i40e_vc_reset_vf
215  * @vf: pointer to the VF info
216  * @notify_vf: notify vf about reset or not
217  * Reset VF handler.
218  **/
i40e_vc_reset_vf(struct i40e_vf * vf,bool notify_vf)219 static void i40e_vc_reset_vf(struct i40e_vf *vf, bool notify_vf)
220 {
221 	struct i40e_pf *pf = vf->pf;
222 	int i;
223 
224 	if (notify_vf)
225 		i40e_vc_notify_vf_reset(vf);
226 
227 	/* We want to ensure that an actual reset occurs initiated after this
228 	 * function was called. However, we do not want to wait forever, so
229 	 * we'll give a reasonable time and print a message if we failed to
230 	 * ensure a reset.
231 	 */
232 	for (i = 0; i < 20; i++) {
233 		/* If PF is in VFs releasing state reset VF is impossible,
234 		 * so leave it.
235 		 */
236 		if (test_bit(__I40E_VFS_RELEASING, pf->state))
237 			return;
238 		if (i40e_reset_vf(vf, false))
239 			return;
240 		usleep_range(10000, 20000);
241 	}
242 
243 	if (notify_vf)
244 		dev_warn(&vf->pf->pdev->dev,
245 			 "Failed to initiate reset for VF %d after 200 milliseconds\n",
246 			 vf->vf_id);
247 	else
248 		dev_dbg(&vf->pf->pdev->dev,
249 			"Failed to initiate reset for VF %d after 200 milliseconds\n",
250 			vf->vf_id);
251 }
252 
253 /**
254  * i40e_vc_isvalid_vsi_id
255  * @vf: pointer to the VF info
256  * @vsi_id: VF relative VSI id
257  *
258  * check for the valid VSI id
259  **/
i40e_vc_isvalid_vsi_id(struct i40e_vf * vf,u16 vsi_id)260 static inline bool i40e_vc_isvalid_vsi_id(struct i40e_vf *vf, u16 vsi_id)
261 {
262 	struct i40e_pf *pf = vf->pf;
263 	struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id);
264 
265 	return (vsi && (vsi->vf_id == vf->vf_id));
266 }
267 
268 /**
269  * i40e_vc_isvalid_queue_id
270  * @vf: pointer to the VF info
271  * @vsi_id: vsi id
272  * @qid: vsi relative queue id
273  *
274  * check for the valid queue id
275  **/
i40e_vc_isvalid_queue_id(struct i40e_vf * vf,u16 vsi_id,u16 qid)276 static inline bool i40e_vc_isvalid_queue_id(struct i40e_vf *vf, u16 vsi_id,
277 					    u16 qid)
278 {
279 	struct i40e_pf *pf = vf->pf;
280 	struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id);
281 
282 	return (vsi && (qid < vsi->alloc_queue_pairs));
283 }
284 
285 /**
286  * i40e_vc_isvalid_vector_id
287  * @vf: pointer to the VF info
288  * @vector_id: VF relative vector id
289  *
290  * check for the valid vector id
291  **/
i40e_vc_isvalid_vector_id(struct i40e_vf * vf,u32 vector_id)292 static inline bool i40e_vc_isvalid_vector_id(struct i40e_vf *vf, u32 vector_id)
293 {
294 	struct i40e_pf *pf = vf->pf;
295 
296 	return vector_id < pf->hw.func_caps.num_msix_vectors_vf;
297 }
298 
299 /***********************vf resource mgmt routines*****************/
300 
301 /**
302  * i40e_vc_get_pf_queue_id
303  * @vf: pointer to the VF info
304  * @vsi_id: id of VSI as provided by the FW
305  * @vsi_queue_id: vsi relative queue id
306  *
307  * return PF relative queue id
308  **/
i40e_vc_get_pf_queue_id(struct i40e_vf * vf,u16 vsi_id,u8 vsi_queue_id)309 static u16 i40e_vc_get_pf_queue_id(struct i40e_vf *vf, u16 vsi_id,
310 				   u8 vsi_queue_id)
311 {
312 	struct i40e_pf *pf = vf->pf;
313 	struct i40e_vsi *vsi = i40e_find_vsi_from_id(pf, vsi_id);
314 	u16 pf_queue_id = I40E_QUEUE_END_OF_LIST;
315 
316 	if (!vsi)
317 		return pf_queue_id;
318 
319 	if (le16_to_cpu(vsi->info.mapping_flags) &
320 	    I40E_AQ_VSI_QUE_MAP_NONCONTIG)
321 		pf_queue_id =
322 			le16_to_cpu(vsi->info.queue_mapping[vsi_queue_id]);
323 	else
324 		pf_queue_id = le16_to_cpu(vsi->info.queue_mapping[0]) +
325 			      vsi_queue_id;
326 
327 	return pf_queue_id;
328 }
329 
330 /**
331  * i40e_get_real_pf_qid
332  * @vf: pointer to the VF info
333  * @vsi_id: vsi id
334  * @queue_id: queue number
335  *
336  * wrapper function to get pf_queue_id handling ADq code as well
337  **/
i40e_get_real_pf_qid(struct i40e_vf * vf,u16 vsi_id,u16 queue_id)338 static u16 i40e_get_real_pf_qid(struct i40e_vf *vf, u16 vsi_id, u16 queue_id)
339 {
340 	int i;
341 
342 	if (vf->adq_enabled) {
343 		/* Although VF considers all the queues(can be 1 to 16) as its
344 		 * own but they may actually belong to different VSIs(up to 4).
345 		 * We need to find which queues belongs to which VSI.
346 		 */
347 		for (i = 0; i < vf->num_tc; i++) {
348 			if (queue_id < vf->ch[i].num_qps) {
349 				vsi_id = vf->ch[i].vsi_id;
350 				break;
351 			}
352 			/* find right queue id which is relative to a
353 			 * given VSI.
354 			 */
355 			queue_id -= vf->ch[i].num_qps;
356 			}
357 		}
358 
359 	return i40e_vc_get_pf_queue_id(vf, vsi_id, queue_id);
360 }
361 
362 /**
363  * i40e_config_irq_link_list
364  * @vf: pointer to the VF info
365  * @vsi_id: id of VSI as given by the FW
366  * @vecmap: irq map info
367  *
368  * configure irq link list from the map
369  **/
i40e_config_irq_link_list(struct i40e_vf * vf,u16 vsi_id,struct virtchnl_vector_map * vecmap)370 static void i40e_config_irq_link_list(struct i40e_vf *vf, u16 vsi_id,
371 				      struct virtchnl_vector_map *vecmap)
372 {
373 	unsigned long linklistmap = 0, tempmap;
374 	struct i40e_pf *pf = vf->pf;
375 	struct i40e_hw *hw = &pf->hw;
376 	u16 vsi_queue_id, pf_queue_id;
377 	enum i40e_queue_type qtype;
378 	u16 next_q, vector_id, size;
379 	u32 reg, reg_idx;
380 	u16 itr_idx = 0;
381 
382 	vector_id = vecmap->vector_id;
383 	/* setup the head */
384 	if (0 == vector_id)
385 		reg_idx = I40E_VPINT_LNKLST0(vf->vf_id);
386 	else
387 		reg_idx = I40E_VPINT_LNKLSTN(
388 		     ((pf->hw.func_caps.num_msix_vectors_vf - 1) * vf->vf_id) +
389 		     (vector_id - 1));
390 
391 	if (vecmap->rxq_map == 0 && vecmap->txq_map == 0) {
392 		/* Special case - No queues mapped on this vector */
393 		wr32(hw, reg_idx, I40E_VPINT_LNKLST0_FIRSTQ_INDX_MASK);
394 		goto irq_list_done;
395 	}
396 	tempmap = vecmap->rxq_map;
397 	for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) {
398 		linklistmap |= (BIT(I40E_VIRTCHNL_SUPPORTED_QTYPES *
399 				    vsi_queue_id));
400 	}
401 
402 	tempmap = vecmap->txq_map;
403 	for_each_set_bit(vsi_queue_id, &tempmap, I40E_MAX_VSI_QP) {
404 		linklistmap |= (BIT(I40E_VIRTCHNL_SUPPORTED_QTYPES *
405 				     vsi_queue_id + 1));
406 	}
407 
408 	size = I40E_MAX_VSI_QP * I40E_VIRTCHNL_SUPPORTED_QTYPES;
409 	next_q = find_first_bit(&linklistmap, size);
410 	if (unlikely(next_q == size))
411 		goto irq_list_done;
412 
413 	vsi_queue_id = next_q / I40E_VIRTCHNL_SUPPORTED_QTYPES;
414 	qtype = next_q % I40E_VIRTCHNL_SUPPORTED_QTYPES;
415 	pf_queue_id = i40e_get_real_pf_qid(vf, vsi_id, vsi_queue_id);
416 	reg = ((qtype << I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT) | pf_queue_id);
417 
418 	wr32(hw, reg_idx, reg);
419 
420 	while (next_q < size) {
421 		switch (qtype) {
422 		case I40E_QUEUE_TYPE_RX:
423 			reg_idx = I40E_QINT_RQCTL(pf_queue_id);
424 			itr_idx = vecmap->rxitr_idx;
425 			break;
426 		case I40E_QUEUE_TYPE_TX:
427 			reg_idx = I40E_QINT_TQCTL(pf_queue_id);
428 			itr_idx = vecmap->txitr_idx;
429 			break;
430 		default:
431 			break;
432 		}
433 
434 		next_q = find_next_bit(&linklistmap, size, next_q + 1);
435 		if (next_q < size) {
436 			vsi_queue_id = next_q / I40E_VIRTCHNL_SUPPORTED_QTYPES;
437 			qtype = next_q % I40E_VIRTCHNL_SUPPORTED_QTYPES;
438 			pf_queue_id = i40e_get_real_pf_qid(vf,
439 							   vsi_id,
440 							   vsi_queue_id);
441 		} else {
442 			pf_queue_id = I40E_QUEUE_END_OF_LIST;
443 			qtype = 0;
444 		}
445 
446 		/* format for the RQCTL & TQCTL regs is same */
447 		reg = (vector_id) |
448 		    (qtype << I40E_QINT_RQCTL_NEXTQ_TYPE_SHIFT) |
449 		    (pf_queue_id << I40E_QINT_RQCTL_NEXTQ_INDX_SHIFT) |
450 		    BIT(I40E_QINT_RQCTL_CAUSE_ENA_SHIFT) |
451 		    (itr_idx << I40E_QINT_RQCTL_ITR_INDX_SHIFT);
452 		wr32(hw, reg_idx, reg);
453 	}
454 
455 	/* if the vf is running in polling mode and using interrupt zero,
456 	 * need to disable auto-mask on enabling zero interrupt for VFs.
457 	 */
458 	if ((vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_POLLING) &&
459 	    (vector_id == 0)) {
460 		reg = rd32(hw, I40E_GLINT_CTL);
461 		if (!(reg & I40E_GLINT_CTL_DIS_AUTOMASK_VF0_MASK)) {
462 			reg |= I40E_GLINT_CTL_DIS_AUTOMASK_VF0_MASK;
463 			wr32(hw, I40E_GLINT_CTL, reg);
464 		}
465 	}
466 
467 irq_list_done:
468 	i40e_flush(hw);
469 }
470 
471 /**
472  * i40e_release_rdma_qvlist
473  * @vf: pointer to the VF.
474  *
475  **/
i40e_release_rdma_qvlist(struct i40e_vf * vf)476 static void i40e_release_rdma_qvlist(struct i40e_vf *vf)
477 {
478 	struct i40e_pf *pf = vf->pf;
479 	struct virtchnl_rdma_qvlist_info *qvlist_info = vf->qvlist_info;
480 	u32 msix_vf;
481 	u32 i;
482 
483 	if (!vf->qvlist_info)
484 		return;
485 
486 	msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
487 	for (i = 0; i < qvlist_info->num_vectors; i++) {
488 		struct virtchnl_rdma_qv_info *qv_info;
489 		u32 next_q_index, next_q_type;
490 		struct i40e_hw *hw = &pf->hw;
491 		u32 v_idx, reg_idx, reg;
492 
493 		qv_info = &qvlist_info->qv_info[i];
494 		v_idx = qv_info->v_idx;
495 		if (qv_info->ceq_idx != I40E_QUEUE_INVALID_IDX) {
496 			/* Figure out the queue after CEQ and make that the
497 			 * first queue.
498 			 */
499 			reg_idx = (msix_vf - 1) * vf->vf_id + qv_info->ceq_idx;
500 			reg = rd32(hw, I40E_VPINT_CEQCTL(reg_idx));
501 			next_q_index = FIELD_GET(I40E_VPINT_CEQCTL_NEXTQ_INDX_MASK,
502 						 reg);
503 			next_q_type = FIELD_GET(I40E_VPINT_CEQCTL_NEXTQ_TYPE_MASK,
504 						reg);
505 
506 			reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
507 			reg = (next_q_index &
508 			       I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) |
509 			       (next_q_type <<
510 			       I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
511 
512 			wr32(hw, I40E_VPINT_LNKLSTN(reg_idx), reg);
513 		}
514 	}
515 	kfree(vf->qvlist_info);
516 	vf->qvlist_info = NULL;
517 }
518 
519 /**
520  * i40e_config_rdma_qvlist
521  * @vf: pointer to the VF info
522  * @qvlist_info: queue and vector list
523  *
524  * Return 0 on success or < 0 on error
525  **/
526 static int
i40e_config_rdma_qvlist(struct i40e_vf * vf,struct virtchnl_rdma_qvlist_info * qvlist_info)527 i40e_config_rdma_qvlist(struct i40e_vf *vf,
528 			struct virtchnl_rdma_qvlist_info *qvlist_info)
529 {
530 	struct i40e_pf *pf = vf->pf;
531 	struct i40e_hw *hw = &pf->hw;
532 	struct virtchnl_rdma_qv_info *qv_info;
533 	u32 v_idx, i, reg_idx, reg;
534 	u32 next_q_idx, next_q_type;
535 	size_t size;
536 	u32 msix_vf;
537 	int ret = 0;
538 
539 	msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
540 
541 	if (qvlist_info->num_vectors > msix_vf) {
542 		dev_warn(&pf->pdev->dev,
543 			 "Incorrect number of iwarp vectors %u. Maximum %u allowed.\n",
544 			 qvlist_info->num_vectors,
545 			 msix_vf);
546 		ret = -EINVAL;
547 		goto err_out;
548 	}
549 
550 	kfree(vf->qvlist_info);
551 	size = virtchnl_struct_size(vf->qvlist_info, qv_info,
552 				    qvlist_info->num_vectors);
553 	vf->qvlist_info = kzalloc(size, GFP_KERNEL);
554 	if (!vf->qvlist_info) {
555 		ret = -ENOMEM;
556 		goto err_out;
557 	}
558 	vf->qvlist_info->num_vectors = qvlist_info->num_vectors;
559 
560 	msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
561 	for (i = 0; i < qvlist_info->num_vectors; i++) {
562 		qv_info = &qvlist_info->qv_info[i];
563 
564 		/* Validate vector id belongs to this vf */
565 		if (!i40e_vc_isvalid_vector_id(vf, qv_info->v_idx)) {
566 			ret = -EINVAL;
567 			goto err_free;
568 		}
569 
570 		v_idx = qv_info->v_idx;
571 
572 		vf->qvlist_info->qv_info[i] = *qv_info;
573 
574 		reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
575 		/* We might be sharing the interrupt, so get the first queue
576 		 * index and type, push it down the list by adding the new
577 		 * queue on top. Also link it with the new queue in CEQCTL.
578 		 */
579 		reg = rd32(hw, I40E_VPINT_LNKLSTN(reg_idx));
580 		next_q_idx = FIELD_GET(I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK,
581 				       reg);
582 		next_q_type = FIELD_GET(I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_MASK,
583 					reg);
584 
585 		if (qv_info->ceq_idx != I40E_QUEUE_INVALID_IDX) {
586 			reg_idx = (msix_vf - 1) * vf->vf_id + qv_info->ceq_idx;
587 			reg = (I40E_VPINT_CEQCTL_CAUSE_ENA_MASK |
588 			(v_idx << I40E_VPINT_CEQCTL_MSIX_INDX_SHIFT) |
589 			(qv_info->itr_idx << I40E_VPINT_CEQCTL_ITR_INDX_SHIFT) |
590 			(next_q_type << I40E_VPINT_CEQCTL_NEXTQ_TYPE_SHIFT) |
591 			(next_q_idx << I40E_VPINT_CEQCTL_NEXTQ_INDX_SHIFT));
592 			wr32(hw, I40E_VPINT_CEQCTL(reg_idx), reg);
593 
594 			reg_idx = ((msix_vf - 1) * vf->vf_id) + (v_idx - 1);
595 			reg = (qv_info->ceq_idx &
596 			       I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK) |
597 			       (I40E_QUEUE_TYPE_PE_CEQ <<
598 			       I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_SHIFT);
599 			wr32(hw, I40E_VPINT_LNKLSTN(reg_idx), reg);
600 		}
601 
602 		if (qv_info->aeq_idx != I40E_QUEUE_INVALID_IDX) {
603 			reg = (I40E_VPINT_AEQCTL_CAUSE_ENA_MASK |
604 			(v_idx << I40E_VPINT_AEQCTL_MSIX_INDX_SHIFT) |
605 			(qv_info->itr_idx << I40E_VPINT_AEQCTL_ITR_INDX_SHIFT));
606 
607 			wr32(hw, I40E_VPINT_AEQCTL(vf->vf_id), reg);
608 		}
609 	}
610 
611 	return 0;
612 err_free:
613 	kfree(vf->qvlist_info);
614 	vf->qvlist_info = NULL;
615 err_out:
616 	return ret;
617 }
618 
619 /**
620  * i40e_config_vsi_tx_queue
621  * @vf: pointer to the VF info
622  * @vsi_id: id of VSI as provided by the FW
623  * @vsi_queue_id: vsi relative queue index
624  * @info: config. info
625  *
626  * configure tx queue
627  **/
i40e_config_vsi_tx_queue(struct i40e_vf * vf,u16 vsi_id,u16 vsi_queue_id,struct virtchnl_txq_info * info)628 static int i40e_config_vsi_tx_queue(struct i40e_vf *vf, u16 vsi_id,
629 				    u16 vsi_queue_id,
630 				    struct virtchnl_txq_info *info)
631 {
632 	struct i40e_pf *pf = vf->pf;
633 	struct i40e_hw *hw = &pf->hw;
634 	struct i40e_hmc_obj_txq tx_ctx;
635 	struct i40e_vsi *vsi;
636 	u16 pf_queue_id;
637 	u32 qtx_ctl;
638 	int ret = 0;
639 
640 	if (!i40e_vc_isvalid_vsi_id(vf, info->vsi_id)) {
641 		ret = -ENOENT;
642 		goto error_context;
643 	}
644 	pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_id, vsi_queue_id);
645 	vsi = i40e_find_vsi_from_id(pf, vsi_id);
646 	if (!vsi) {
647 		ret = -ENOENT;
648 		goto error_context;
649 	}
650 
651 	/* clear the context structure first */
652 	memset(&tx_ctx, 0, sizeof(struct i40e_hmc_obj_txq));
653 
654 	/* only set the required fields */
655 	tx_ctx.base = info->dma_ring_addr / 128;
656 	tx_ctx.qlen = info->ring_len;
657 	tx_ctx.rdylist = le16_to_cpu(vsi->info.qs_handle[0]);
658 	tx_ctx.rdylist_act = 0;
659 	tx_ctx.head_wb_ena = info->headwb_enabled;
660 	tx_ctx.head_wb_addr = info->dma_headwb_addr;
661 
662 	/* clear the context in the HMC */
663 	ret = i40e_clear_lan_tx_queue_context(hw, pf_queue_id);
664 	if (ret) {
665 		dev_err(&pf->pdev->dev,
666 			"Failed to clear VF LAN Tx queue context %d, error: %d\n",
667 			pf_queue_id, ret);
668 		ret = -ENOENT;
669 		goto error_context;
670 	}
671 
672 	/* set the context in the HMC */
673 	ret = i40e_set_lan_tx_queue_context(hw, pf_queue_id, &tx_ctx);
674 	if (ret) {
675 		dev_err(&pf->pdev->dev,
676 			"Failed to set VF LAN Tx queue context %d error: %d\n",
677 			pf_queue_id, ret);
678 		ret = -ENOENT;
679 		goto error_context;
680 	}
681 
682 	/* associate this queue with the PCI VF function */
683 	qtx_ctl = I40E_QTX_CTL_VF_QUEUE;
684 	qtx_ctl |= FIELD_PREP(I40E_QTX_CTL_PF_INDX_MASK, hw->pf_id);
685 	qtx_ctl |= FIELD_PREP(I40E_QTX_CTL_VFVM_INDX_MASK,
686 			      vf->vf_id + hw->func_caps.vf_base_id);
687 	wr32(hw, I40E_QTX_CTL(pf_queue_id), qtx_ctl);
688 	i40e_flush(hw);
689 
690 error_context:
691 	return ret;
692 }
693 
694 /**
695  * i40e_config_vsi_rx_queue
696  * @vf: pointer to the VF info
697  * @vsi_id: id of VSI  as provided by the FW
698  * @vsi_queue_id: vsi relative queue index
699  * @info: config. info
700  *
701  * configure rx queue
702  **/
i40e_config_vsi_rx_queue(struct i40e_vf * vf,u16 vsi_id,u16 vsi_queue_id,struct virtchnl_rxq_info * info)703 static int i40e_config_vsi_rx_queue(struct i40e_vf *vf, u16 vsi_id,
704 				    u16 vsi_queue_id,
705 				    struct virtchnl_rxq_info *info)
706 {
707 	u16 pf_queue_id = i40e_vc_get_pf_queue_id(vf, vsi_id, vsi_queue_id);
708 	struct i40e_pf *pf = vf->pf;
709 	struct i40e_vsi *vsi = pf->vsi[vf->lan_vsi_idx];
710 	struct i40e_hw *hw = &pf->hw;
711 	struct i40e_hmc_obj_rxq rx_ctx;
712 	int ret = 0;
713 
714 	/* clear the context structure first */
715 	memset(&rx_ctx, 0, sizeof(struct i40e_hmc_obj_rxq));
716 
717 	/* only set the required fields */
718 	rx_ctx.base = info->dma_ring_addr / 128;
719 	rx_ctx.qlen = info->ring_len;
720 
721 	if (info->splithdr_enabled) {
722 		rx_ctx.hsplit_0 = I40E_RX_SPLIT_L2      |
723 				  I40E_RX_SPLIT_IP      |
724 				  I40E_RX_SPLIT_TCP_UDP |
725 				  I40E_RX_SPLIT_SCTP;
726 		/* header length validation */
727 		if (info->hdr_size > ((2 * 1024) - 64)) {
728 			ret = -EINVAL;
729 			goto error_param;
730 		}
731 		rx_ctx.hbuff = info->hdr_size >> I40E_RXQ_CTX_HBUFF_SHIFT;
732 
733 		/* set split mode 10b */
734 		rx_ctx.dtype = I40E_RX_DTYPE_HEADER_SPLIT;
735 	}
736 
737 	/* databuffer length validation */
738 	if (info->databuffer_size > ((16 * 1024) - 128)) {
739 		ret = -EINVAL;
740 		goto error_param;
741 	}
742 	rx_ctx.dbuff = info->databuffer_size >> I40E_RXQ_CTX_DBUFF_SHIFT;
743 
744 	/* max pkt. length validation */
745 	if (info->max_pkt_size >= (16 * 1024) || info->max_pkt_size < 64) {
746 		ret = -EINVAL;
747 		goto error_param;
748 	}
749 	rx_ctx.rxmax = info->max_pkt_size;
750 
751 	/* if port VLAN is configured increase the max packet size */
752 	if (vsi->info.pvid)
753 		rx_ctx.rxmax += VLAN_HLEN;
754 
755 	/* enable 32bytes desc always */
756 	rx_ctx.dsize = 1;
757 
758 	/* default values */
759 	rx_ctx.lrxqthresh = 1;
760 	rx_ctx.crcstrip = 1;
761 	rx_ctx.prefena = 1;
762 	rx_ctx.l2tsel = 1;
763 
764 	/* clear the context in the HMC */
765 	ret = i40e_clear_lan_rx_queue_context(hw, pf_queue_id);
766 	if (ret) {
767 		dev_err(&pf->pdev->dev,
768 			"Failed to clear VF LAN Rx queue context %d, error: %d\n",
769 			pf_queue_id, ret);
770 		ret = -ENOENT;
771 		goto error_param;
772 	}
773 
774 	/* set the context in the HMC */
775 	ret = i40e_set_lan_rx_queue_context(hw, pf_queue_id, &rx_ctx);
776 	if (ret) {
777 		dev_err(&pf->pdev->dev,
778 			"Failed to set VF LAN Rx queue context %d error: %d\n",
779 			pf_queue_id, ret);
780 		ret = -ENOENT;
781 		goto error_param;
782 	}
783 
784 error_param:
785 	return ret;
786 }
787 
788 /**
789  * i40e_alloc_vsi_res
790  * @vf: pointer to the VF info
791  * @idx: VSI index, applies only for ADq mode, zero otherwise
792  *
793  * alloc VF vsi context & resources
794  **/
i40e_alloc_vsi_res(struct i40e_vf * vf,u8 idx)795 static int i40e_alloc_vsi_res(struct i40e_vf *vf, u8 idx)
796 {
797 	struct i40e_mac_filter *f = NULL;
798 	struct i40e_vsi *main_vsi, *vsi;
799 	struct i40e_pf *pf = vf->pf;
800 	u64 max_tx_rate = 0;
801 	int ret = 0;
802 
803 	main_vsi = i40e_pf_get_main_vsi(pf);
804 	vsi = i40e_vsi_setup(pf, I40E_VSI_SRIOV, main_vsi->seid, vf->vf_id);
805 
806 	if (!vsi) {
807 		dev_err(&pf->pdev->dev,
808 			"add vsi failed for VF %d, aq_err %d\n",
809 			vf->vf_id, pf->hw.aq.asq_last_status);
810 		ret = -ENOENT;
811 		goto error_alloc_vsi_res;
812 	}
813 
814 	if (!idx) {
815 		u64 hena = i40e_pf_get_default_rss_hena(pf);
816 		u8 broadcast[ETH_ALEN];
817 
818 		vf->lan_vsi_idx = vsi->idx;
819 		vf->lan_vsi_id = vsi->id;
820 		/* If the port VLAN has been configured and then the
821 		 * VF driver was removed then the VSI port VLAN
822 		 * configuration was destroyed.  Check if there is
823 		 * a port VLAN and restore the VSI configuration if
824 		 * needed.
825 		 */
826 		if (vf->port_vlan_id)
827 			i40e_vsi_add_pvid(vsi, vf->port_vlan_id);
828 
829 		spin_lock_bh(&vsi->mac_filter_hash_lock);
830 		if (is_valid_ether_addr(vf->default_lan_addr.addr)) {
831 			f = i40e_add_mac_filter(vsi,
832 						vf->default_lan_addr.addr);
833 			if (!f)
834 				dev_info(&pf->pdev->dev,
835 					 "Could not add MAC filter %pM for VF %d\n",
836 					vf->default_lan_addr.addr, vf->vf_id);
837 		}
838 		eth_broadcast_addr(broadcast);
839 		f = i40e_add_mac_filter(vsi, broadcast);
840 		if (!f)
841 			dev_info(&pf->pdev->dev,
842 				 "Could not allocate VF broadcast filter\n");
843 		spin_unlock_bh(&vsi->mac_filter_hash_lock);
844 		wr32(&pf->hw, I40E_VFQF_HENA1(0, vf->vf_id), (u32)hena);
845 		wr32(&pf->hw, I40E_VFQF_HENA1(1, vf->vf_id), (u32)(hena >> 32));
846 		/* program mac filter only for VF VSI */
847 		ret = i40e_sync_vsi_filters(vsi);
848 		if (ret)
849 			dev_err(&pf->pdev->dev, "Unable to program ucast filters\n");
850 	}
851 
852 	/* storing VSI index and id for ADq and don't apply the mac filter */
853 	if (vf->adq_enabled) {
854 		vf->ch[idx].vsi_idx = vsi->idx;
855 		vf->ch[idx].vsi_id = vsi->id;
856 	}
857 
858 	/* Set VF bandwidth if specified */
859 	if (vf->tx_rate) {
860 		max_tx_rate = vf->tx_rate;
861 	} else if (vf->ch[idx].max_tx_rate) {
862 		max_tx_rate = vf->ch[idx].max_tx_rate;
863 	}
864 
865 	if (max_tx_rate) {
866 		max_tx_rate = div_u64(max_tx_rate, I40E_BW_CREDIT_DIVISOR);
867 		ret = i40e_aq_config_vsi_bw_limit(&pf->hw, vsi->seid,
868 						  max_tx_rate, 0, NULL);
869 		if (ret)
870 			dev_err(&pf->pdev->dev, "Unable to set tx rate, VF %d, error code %d.\n",
871 				vf->vf_id, ret);
872 	}
873 
874 error_alloc_vsi_res:
875 	return ret;
876 }
877 
878 /**
879  * i40e_map_pf_queues_to_vsi
880  * @vf: pointer to the VF info
881  *
882  * PF maps LQPs to a VF by programming VSILAN_QTABLE & VPLAN_QTABLE. This
883  * function takes care of first part VSILAN_QTABLE, mapping pf queues to VSI.
884  **/
i40e_map_pf_queues_to_vsi(struct i40e_vf * vf)885 static void i40e_map_pf_queues_to_vsi(struct i40e_vf *vf)
886 {
887 	struct i40e_pf *pf = vf->pf;
888 	struct i40e_hw *hw = &pf->hw;
889 	u32 reg, num_tc = 1; /* VF has at least one traffic class */
890 	u16 vsi_id, qps;
891 	int i, j;
892 
893 	if (vf->adq_enabled)
894 		num_tc = vf->num_tc;
895 
896 	for (i = 0; i < num_tc; i++) {
897 		if (vf->adq_enabled) {
898 			qps = vf->ch[i].num_qps;
899 			vsi_id =  vf->ch[i].vsi_id;
900 		} else {
901 			qps = pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs;
902 			vsi_id = vf->lan_vsi_id;
903 		}
904 
905 		for (j = 0; j < 7; j++) {
906 			if (j * 2 >= qps) {
907 				/* end of list */
908 				reg = 0x07FF07FF;
909 			} else {
910 				u16 qid = i40e_vc_get_pf_queue_id(vf,
911 								  vsi_id,
912 								  j * 2);
913 				reg = qid;
914 				qid = i40e_vc_get_pf_queue_id(vf, vsi_id,
915 							      (j * 2) + 1);
916 				reg |= qid << 16;
917 			}
918 			i40e_write_rx_ctl(hw,
919 					  I40E_VSILAN_QTABLE(j, vsi_id),
920 					  reg);
921 		}
922 	}
923 }
924 
925 /**
926  * i40e_map_pf_to_vf_queues
927  * @vf: pointer to the VF info
928  *
929  * PF maps LQPs to a VF by programming VSILAN_QTABLE & VPLAN_QTABLE. This
930  * function takes care of the second part VPLAN_QTABLE & completes VF mappings.
931  **/
i40e_map_pf_to_vf_queues(struct i40e_vf * vf)932 static void i40e_map_pf_to_vf_queues(struct i40e_vf *vf)
933 {
934 	struct i40e_pf *pf = vf->pf;
935 	struct i40e_hw *hw = &pf->hw;
936 	u32 reg, total_qps = 0;
937 	u32 qps, num_tc = 1; /* VF has at least one traffic class */
938 	u16 vsi_id, qid;
939 	int i, j;
940 
941 	if (vf->adq_enabled)
942 		num_tc = vf->num_tc;
943 
944 	for (i = 0; i < num_tc; i++) {
945 		if (vf->adq_enabled) {
946 			qps = vf->ch[i].num_qps;
947 			vsi_id =  vf->ch[i].vsi_id;
948 		} else {
949 			qps = pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs;
950 			vsi_id = vf->lan_vsi_id;
951 		}
952 
953 		for (j = 0; j < qps; j++) {
954 			qid = i40e_vc_get_pf_queue_id(vf, vsi_id, j);
955 
956 			reg = (qid & I40E_VPLAN_QTABLE_QINDEX_MASK);
957 			wr32(hw, I40E_VPLAN_QTABLE(total_qps, vf->vf_id),
958 			     reg);
959 			total_qps++;
960 		}
961 	}
962 }
963 
964 /**
965  * i40e_enable_vf_mappings
966  * @vf: pointer to the VF info
967  *
968  * enable VF mappings
969  **/
i40e_enable_vf_mappings(struct i40e_vf * vf)970 static void i40e_enable_vf_mappings(struct i40e_vf *vf)
971 {
972 	struct i40e_pf *pf = vf->pf;
973 	struct i40e_hw *hw = &pf->hw;
974 	u32 reg;
975 
976 	/* Tell the hardware we're using noncontiguous mapping. HW requires
977 	 * that VF queues be mapped using this method, even when they are
978 	 * contiguous in real life
979 	 */
980 	i40e_write_rx_ctl(hw, I40E_VSILAN_QBASE(vf->lan_vsi_id),
981 			  I40E_VSILAN_QBASE_VSIQTABLE_ENA_MASK);
982 
983 	/* enable VF vplan_qtable mappings */
984 	reg = I40E_VPLAN_MAPENA_TXRX_ENA_MASK;
985 	wr32(hw, I40E_VPLAN_MAPENA(vf->vf_id), reg);
986 
987 	i40e_map_pf_to_vf_queues(vf);
988 	i40e_map_pf_queues_to_vsi(vf);
989 
990 	i40e_flush(hw);
991 }
992 
993 /**
994  * i40e_disable_vf_mappings
995  * @vf: pointer to the VF info
996  *
997  * disable VF mappings
998  **/
i40e_disable_vf_mappings(struct i40e_vf * vf)999 static void i40e_disable_vf_mappings(struct i40e_vf *vf)
1000 {
1001 	struct i40e_pf *pf = vf->pf;
1002 	struct i40e_hw *hw = &pf->hw;
1003 	int i;
1004 
1005 	/* disable qp mappings */
1006 	wr32(hw, I40E_VPLAN_MAPENA(vf->vf_id), 0);
1007 	for (i = 0; i < I40E_MAX_VSI_QP; i++)
1008 		wr32(hw, I40E_VPLAN_QTABLE(i, vf->vf_id),
1009 		     I40E_QUEUE_END_OF_LIST);
1010 	i40e_flush(hw);
1011 }
1012 
1013 /**
1014  * i40e_free_vf_res
1015  * @vf: pointer to the VF info
1016  *
1017  * free VF resources
1018  **/
i40e_free_vf_res(struct i40e_vf * vf)1019 static void i40e_free_vf_res(struct i40e_vf *vf)
1020 {
1021 	struct i40e_pf *pf = vf->pf;
1022 	struct i40e_hw *hw = &pf->hw;
1023 	u32 reg_idx, reg;
1024 	int i, j, msix_vf;
1025 
1026 	/* Start by disabling VF's configuration API to prevent the OS from
1027 	 * accessing the VF's VSI after it's freed / invalidated.
1028 	 */
1029 	clear_bit(I40E_VF_STATE_INIT, &vf->vf_states);
1030 
1031 	/* It's possible the VF had requeuested more queues than the default so
1032 	 * do the accounting here when we're about to free them.
1033 	 */
1034 	if (vf->num_queue_pairs > I40E_DEFAULT_QUEUES_PER_VF) {
1035 		pf->queues_left += vf->num_queue_pairs -
1036 				   I40E_DEFAULT_QUEUES_PER_VF;
1037 	}
1038 
1039 	/* free vsi & disconnect it from the parent uplink */
1040 	if (vf->lan_vsi_idx) {
1041 		i40e_vsi_release(pf->vsi[vf->lan_vsi_idx]);
1042 		vf->lan_vsi_idx = 0;
1043 		vf->lan_vsi_id = 0;
1044 	}
1045 
1046 	/* do the accounting and remove additional ADq VSI's */
1047 	if (vf->adq_enabled && vf->ch[0].vsi_idx) {
1048 		for (j = 0; j < vf->num_tc; j++) {
1049 			/* At this point VSI0 is already released so don't
1050 			 * release it again and only clear their values in
1051 			 * structure variables
1052 			 */
1053 			if (j)
1054 				i40e_vsi_release(pf->vsi[vf->ch[j].vsi_idx]);
1055 			vf->ch[j].vsi_idx = 0;
1056 			vf->ch[j].vsi_id = 0;
1057 		}
1058 	}
1059 	msix_vf = pf->hw.func_caps.num_msix_vectors_vf;
1060 
1061 	/* disable interrupts so the VF starts in a known state */
1062 	for (i = 0; i < msix_vf; i++) {
1063 		/* format is same for both registers */
1064 		if (0 == i)
1065 			reg_idx = I40E_VFINT_DYN_CTL0(vf->vf_id);
1066 		else
1067 			reg_idx = I40E_VFINT_DYN_CTLN(((msix_vf - 1) *
1068 						      (vf->vf_id))
1069 						     + (i - 1));
1070 		wr32(hw, reg_idx, I40E_VFINT_DYN_CTLN_CLEARPBA_MASK);
1071 		i40e_flush(hw);
1072 	}
1073 
1074 	/* clear the irq settings */
1075 	for (i = 0; i < msix_vf; i++) {
1076 		/* format is same for both registers */
1077 		if (0 == i)
1078 			reg_idx = I40E_VPINT_LNKLST0(vf->vf_id);
1079 		else
1080 			reg_idx = I40E_VPINT_LNKLSTN(((msix_vf - 1) *
1081 						      (vf->vf_id))
1082 						     + (i - 1));
1083 		reg = (I40E_VPINT_LNKLSTN_FIRSTQ_TYPE_MASK |
1084 		       I40E_VPINT_LNKLSTN_FIRSTQ_INDX_MASK);
1085 		wr32(hw, reg_idx, reg);
1086 		i40e_flush(hw);
1087 	}
1088 	/* reset some of the state variables keeping track of the resources */
1089 	vf->num_queue_pairs = 0;
1090 	clear_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states);
1091 	clear_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states);
1092 }
1093 
1094 /**
1095  * i40e_alloc_vf_res
1096  * @vf: pointer to the VF info
1097  *
1098  * allocate VF resources
1099  **/
i40e_alloc_vf_res(struct i40e_vf * vf)1100 static int i40e_alloc_vf_res(struct i40e_vf *vf)
1101 {
1102 	struct i40e_pf *pf = vf->pf;
1103 	int total_queue_pairs = 0;
1104 	int ret, idx;
1105 
1106 	if (vf->num_req_queues &&
1107 	    vf->num_req_queues <= pf->queues_left + I40E_DEFAULT_QUEUES_PER_VF)
1108 		pf->num_vf_qps = vf->num_req_queues;
1109 	else
1110 		pf->num_vf_qps = I40E_DEFAULT_QUEUES_PER_VF;
1111 
1112 	/* allocate hw vsi context & associated resources */
1113 	ret = i40e_alloc_vsi_res(vf, 0);
1114 	if (ret)
1115 		goto error_alloc;
1116 	total_queue_pairs += pf->vsi[vf->lan_vsi_idx]->alloc_queue_pairs;
1117 
1118 	/* allocate additional VSIs based on tc information for ADq */
1119 	if (vf->adq_enabled) {
1120 		if (pf->queues_left >=
1121 		    (I40E_MAX_VF_QUEUES - I40E_DEFAULT_QUEUES_PER_VF)) {
1122 			/* TC 0 always belongs to VF VSI */
1123 			for (idx = 1; idx < vf->num_tc; idx++) {
1124 				ret = i40e_alloc_vsi_res(vf, idx);
1125 				if (ret)
1126 					goto error_alloc;
1127 			}
1128 			/* send correct number of queues */
1129 			total_queue_pairs = I40E_MAX_VF_QUEUES;
1130 		} else {
1131 			dev_info(&pf->pdev->dev, "VF %d: Not enough queues to allocate, disabling ADq\n",
1132 				 vf->vf_id);
1133 			vf->adq_enabled = false;
1134 		}
1135 	}
1136 
1137 	/* We account for each VF to get a default number of queue pairs.  If
1138 	 * the VF has now requested more, we need to account for that to make
1139 	 * certain we never request more queues than we actually have left in
1140 	 * HW.
1141 	 */
1142 	if (total_queue_pairs > I40E_DEFAULT_QUEUES_PER_VF)
1143 		pf->queues_left -=
1144 			total_queue_pairs - I40E_DEFAULT_QUEUES_PER_VF;
1145 
1146 	if (vf->trusted)
1147 		set_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
1148 	else
1149 		clear_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
1150 
1151 	/* store the total qps number for the runtime
1152 	 * VF req validation
1153 	 */
1154 	vf->num_queue_pairs = total_queue_pairs;
1155 
1156 	/* VF is now completely initialized */
1157 	set_bit(I40E_VF_STATE_INIT, &vf->vf_states);
1158 
1159 error_alloc:
1160 	if (ret)
1161 		i40e_free_vf_res(vf);
1162 
1163 	return ret;
1164 }
1165 
1166 #define VF_DEVICE_STATUS 0xAA
1167 #define VF_TRANS_PENDING_MASK 0x20
1168 /**
1169  * i40e_quiesce_vf_pci
1170  * @vf: pointer to the VF structure
1171  *
1172  * Wait for VF PCI transactions to be cleared after reset. Returns -EIO
1173  * if the transactions never clear.
1174  **/
i40e_quiesce_vf_pci(struct i40e_vf * vf)1175 static int i40e_quiesce_vf_pci(struct i40e_vf *vf)
1176 {
1177 	struct i40e_pf *pf = vf->pf;
1178 	struct i40e_hw *hw = &pf->hw;
1179 	int vf_abs_id, i;
1180 	u32 reg;
1181 
1182 	vf_abs_id = vf->vf_id + hw->func_caps.vf_base_id;
1183 
1184 	wr32(hw, I40E_PF_PCI_CIAA,
1185 	     VF_DEVICE_STATUS | (vf_abs_id << I40E_PF_PCI_CIAA_VF_NUM_SHIFT));
1186 	for (i = 0; i < 100; i++) {
1187 		reg = rd32(hw, I40E_PF_PCI_CIAD);
1188 		if ((reg & VF_TRANS_PENDING_MASK) == 0)
1189 			return 0;
1190 		udelay(1);
1191 	}
1192 	return -EIO;
1193 }
1194 
1195 /**
1196  * __i40e_getnum_vf_vsi_vlan_filters
1197  * @vsi: pointer to the vsi
1198  *
1199  * called to get the number of VLANs offloaded on this VF
1200  **/
__i40e_getnum_vf_vsi_vlan_filters(struct i40e_vsi * vsi)1201 static int __i40e_getnum_vf_vsi_vlan_filters(struct i40e_vsi *vsi)
1202 {
1203 	struct i40e_mac_filter *f;
1204 	u16 num_vlans = 0, bkt;
1205 
1206 	hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) {
1207 		if (f->vlan >= 0 && f->vlan <= I40E_MAX_VLANID)
1208 			num_vlans++;
1209 	}
1210 
1211 	return num_vlans;
1212 }
1213 
1214 /**
1215  * i40e_getnum_vf_vsi_vlan_filters
1216  * @vsi: pointer to the vsi
1217  *
1218  * wrapper for __i40e_getnum_vf_vsi_vlan_filters() with spinlock held
1219  **/
i40e_getnum_vf_vsi_vlan_filters(struct i40e_vsi * vsi)1220 static int i40e_getnum_vf_vsi_vlan_filters(struct i40e_vsi *vsi)
1221 {
1222 	int num_vlans;
1223 
1224 	spin_lock_bh(&vsi->mac_filter_hash_lock);
1225 	num_vlans = __i40e_getnum_vf_vsi_vlan_filters(vsi);
1226 	spin_unlock_bh(&vsi->mac_filter_hash_lock);
1227 
1228 	return num_vlans;
1229 }
1230 
1231 /**
1232  * i40e_get_vlan_list_sync
1233  * @vsi: pointer to the VSI
1234  * @num_vlans: number of VLANs in mac_filter_hash, returned to caller
1235  * @vlan_list: list of VLANs present in mac_filter_hash, returned to caller.
1236  *             This array is allocated here, but has to be freed in caller.
1237  *
1238  * Called to get number of VLANs and VLAN list present in mac_filter_hash.
1239  **/
i40e_get_vlan_list_sync(struct i40e_vsi * vsi,u16 * num_vlans,s16 ** vlan_list)1240 static void i40e_get_vlan_list_sync(struct i40e_vsi *vsi, u16 *num_vlans,
1241 				    s16 **vlan_list)
1242 {
1243 	struct i40e_mac_filter *f;
1244 	int i = 0;
1245 	int bkt;
1246 
1247 	spin_lock_bh(&vsi->mac_filter_hash_lock);
1248 	*num_vlans = __i40e_getnum_vf_vsi_vlan_filters(vsi);
1249 	*vlan_list = kcalloc(*num_vlans, sizeof(**vlan_list), GFP_ATOMIC);
1250 	if (!(*vlan_list))
1251 		goto err;
1252 
1253 	hash_for_each(vsi->mac_filter_hash, bkt, f, hlist) {
1254 		if (f->vlan < 0 || f->vlan > I40E_MAX_VLANID)
1255 			continue;
1256 		(*vlan_list)[i++] = f->vlan;
1257 	}
1258 err:
1259 	spin_unlock_bh(&vsi->mac_filter_hash_lock);
1260 }
1261 
1262 /**
1263  * i40e_set_vsi_promisc
1264  * @vf: pointer to the VF struct
1265  * @seid: VSI number
1266  * @multi_enable: set MAC L2 layer multicast promiscuous enable/disable
1267  *                for a given VLAN
1268  * @unicast_enable: set MAC L2 layer unicast promiscuous enable/disable
1269  *                  for a given VLAN
1270  * @vl: List of VLANs - apply filter for given VLANs
1271  * @num_vlans: Number of elements in @vl
1272  **/
1273 static int
i40e_set_vsi_promisc(struct i40e_vf * vf,u16 seid,bool multi_enable,bool unicast_enable,s16 * vl,u16 num_vlans)1274 i40e_set_vsi_promisc(struct i40e_vf *vf, u16 seid, bool multi_enable,
1275 		     bool unicast_enable, s16 *vl, u16 num_vlans)
1276 {
1277 	struct i40e_pf *pf = vf->pf;
1278 	struct i40e_hw *hw = &pf->hw;
1279 	int aq_ret, aq_tmp = 0;
1280 	int i;
1281 
1282 	/* No VLAN to set promisc on, set on VSI */
1283 	if (!num_vlans || !vl) {
1284 		aq_ret = i40e_aq_set_vsi_multicast_promiscuous(hw, seid,
1285 							       multi_enable,
1286 							       NULL);
1287 		if (aq_ret) {
1288 			int aq_err = pf->hw.aq.asq_last_status;
1289 
1290 			dev_err(&pf->pdev->dev,
1291 				"VF %d failed to set multicast promiscuous mode err %pe aq_err %s\n",
1292 				vf->vf_id,
1293 				ERR_PTR(aq_ret),
1294 				i40e_aq_str(&pf->hw, aq_err));
1295 
1296 			return aq_ret;
1297 		}
1298 
1299 		aq_ret = i40e_aq_set_vsi_unicast_promiscuous(hw, seid,
1300 							     unicast_enable,
1301 							     NULL, true);
1302 
1303 		if (aq_ret) {
1304 			int aq_err = pf->hw.aq.asq_last_status;
1305 
1306 			dev_err(&pf->pdev->dev,
1307 				"VF %d failed to set unicast promiscuous mode err %pe aq_err %s\n",
1308 				vf->vf_id,
1309 				ERR_PTR(aq_ret),
1310 				i40e_aq_str(&pf->hw, aq_err));
1311 		}
1312 
1313 		return aq_ret;
1314 	}
1315 
1316 	for (i = 0; i < num_vlans; i++) {
1317 		aq_ret = i40e_aq_set_vsi_mc_promisc_on_vlan(hw, seid,
1318 							    multi_enable,
1319 							    vl[i], NULL);
1320 		if (aq_ret) {
1321 			int aq_err = pf->hw.aq.asq_last_status;
1322 
1323 			dev_err(&pf->pdev->dev,
1324 				"VF %d failed to set multicast promiscuous mode err %pe aq_err %s\n",
1325 				vf->vf_id,
1326 				ERR_PTR(aq_ret),
1327 				i40e_aq_str(&pf->hw, aq_err));
1328 
1329 			if (!aq_tmp)
1330 				aq_tmp = aq_ret;
1331 		}
1332 
1333 		aq_ret = i40e_aq_set_vsi_uc_promisc_on_vlan(hw, seid,
1334 							    unicast_enable,
1335 							    vl[i], NULL);
1336 		if (aq_ret) {
1337 			int aq_err = pf->hw.aq.asq_last_status;
1338 
1339 			dev_err(&pf->pdev->dev,
1340 				"VF %d failed to set unicast promiscuous mode err %pe aq_err %s\n",
1341 				vf->vf_id,
1342 				ERR_PTR(aq_ret),
1343 				i40e_aq_str(&pf->hw, aq_err));
1344 
1345 			if (!aq_tmp)
1346 				aq_tmp = aq_ret;
1347 		}
1348 	}
1349 
1350 	if (aq_tmp)
1351 		aq_ret = aq_tmp;
1352 
1353 	return aq_ret;
1354 }
1355 
1356 /**
1357  * i40e_config_vf_promiscuous_mode
1358  * @vf: pointer to the VF info
1359  * @vsi_id: VSI id
1360  * @allmulti: set MAC L2 layer multicast promiscuous enable/disable
1361  * @alluni: set MAC L2 layer unicast promiscuous enable/disable
1362  *
1363  * Called from the VF to configure the promiscuous mode of
1364  * VF vsis and from the VF reset path to reset promiscuous mode.
1365  **/
i40e_config_vf_promiscuous_mode(struct i40e_vf * vf,u16 vsi_id,bool allmulti,bool alluni)1366 static int i40e_config_vf_promiscuous_mode(struct i40e_vf *vf,
1367 					   u16 vsi_id,
1368 					   bool allmulti,
1369 					   bool alluni)
1370 {
1371 	struct i40e_pf *pf = vf->pf;
1372 	struct i40e_vsi *vsi;
1373 	int aq_ret = 0;
1374 	u16 num_vlans;
1375 	s16 *vl;
1376 
1377 	vsi = i40e_find_vsi_from_id(pf, vsi_id);
1378 	if (!i40e_vc_isvalid_vsi_id(vf, vsi_id) || !vsi)
1379 		return -EINVAL;
1380 
1381 	if (vf->port_vlan_id) {
1382 		aq_ret = i40e_set_vsi_promisc(vf, vsi->seid, allmulti,
1383 					      alluni, &vf->port_vlan_id, 1);
1384 		return aq_ret;
1385 	} else if (i40e_getnum_vf_vsi_vlan_filters(vsi)) {
1386 		i40e_get_vlan_list_sync(vsi, &num_vlans, &vl);
1387 
1388 		if (!vl)
1389 			return -ENOMEM;
1390 
1391 		aq_ret = i40e_set_vsi_promisc(vf, vsi->seid, allmulti, alluni,
1392 					      vl, num_vlans);
1393 		kfree(vl);
1394 		return aq_ret;
1395 	}
1396 
1397 	/* no VLANs to set on, set on VSI */
1398 	aq_ret = i40e_set_vsi_promisc(vf, vsi->seid, allmulti, alluni,
1399 				      NULL, 0);
1400 	return aq_ret;
1401 }
1402 
1403 /**
1404  * i40e_sync_vfr_reset
1405  * @hw: pointer to hw struct
1406  * @vf_id: VF identifier
1407  *
1408  * Before trigger hardware reset, we need to know if no other process has
1409  * reserved the hardware for any reset operations. This check is done by
1410  * examining the status of the RSTAT1 register used to signal the reset.
1411  **/
i40e_sync_vfr_reset(struct i40e_hw * hw,int vf_id)1412 static int i40e_sync_vfr_reset(struct i40e_hw *hw, int vf_id)
1413 {
1414 	u32 reg;
1415 	int i;
1416 
1417 	for (i = 0; i < I40E_VFR_WAIT_COUNT; i++) {
1418 		reg = rd32(hw, I40E_VFINT_ICR0_ENA(vf_id)) &
1419 			   I40E_VFINT_ICR0_ADMINQ_MASK;
1420 		if (reg)
1421 			return 0;
1422 
1423 		usleep_range(100, 200);
1424 	}
1425 
1426 	return -EAGAIN;
1427 }
1428 
1429 /**
1430  * i40e_trigger_vf_reset
1431  * @vf: pointer to the VF structure
1432  * @flr: VFLR was issued or not
1433  *
1434  * Trigger hardware to start a reset for a particular VF. Expects the caller
1435  * to wait the proper amount of time to allow hardware to reset the VF before
1436  * it cleans up and restores VF functionality.
1437  **/
i40e_trigger_vf_reset(struct i40e_vf * vf,bool flr)1438 static void i40e_trigger_vf_reset(struct i40e_vf *vf, bool flr)
1439 {
1440 	struct i40e_pf *pf = vf->pf;
1441 	struct i40e_hw *hw = &pf->hw;
1442 	u32 reg, reg_idx, bit_idx;
1443 	bool vf_active;
1444 	u32 radq;
1445 
1446 	/* warn the VF */
1447 	vf_active = test_and_clear_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states);
1448 
1449 	/* Disable VF's configuration API during reset. The flag is re-enabled
1450 	 * in i40e_alloc_vf_res(), when it's safe again to access VF's VSI.
1451 	 * It's normally disabled in i40e_free_vf_res(), but it's safer
1452 	 * to do it earlier to give some time to finish to any VF config
1453 	 * functions that may still be running at this point.
1454 	 */
1455 	clear_bit(I40E_VF_STATE_INIT, &vf->vf_states);
1456 
1457 	/* In the case of a VFLR, the HW has already reset the VF and we
1458 	 * just need to clean up, so don't hit the VFRTRIG register.
1459 	 */
1460 	if (!flr) {
1461 		/* Sync VFR reset before trigger next one */
1462 		radq = rd32(hw, I40E_VFINT_ICR0_ENA(vf->vf_id)) &
1463 			    I40E_VFINT_ICR0_ADMINQ_MASK;
1464 		if (vf_active && !radq)
1465 			/* waiting for finish reset by virtual driver */
1466 			if (i40e_sync_vfr_reset(hw, vf->vf_id))
1467 				dev_info(&pf->pdev->dev,
1468 					 "Reset VF %d never finished\n",
1469 				vf->vf_id);
1470 
1471 		/* Reset VF using VPGEN_VFRTRIG reg. It is also setting
1472 		 * in progress state in rstat1 register.
1473 		 */
1474 		reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id));
1475 		reg |= I40E_VPGEN_VFRTRIG_VFSWR_MASK;
1476 		wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg);
1477 		i40e_flush(hw);
1478 	}
1479 	/* clear the VFLR bit in GLGEN_VFLRSTAT */
1480 	reg_idx = (hw->func_caps.vf_base_id + vf->vf_id) / 32;
1481 	bit_idx = (hw->func_caps.vf_base_id + vf->vf_id) % 32;
1482 	wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
1483 	i40e_flush(hw);
1484 
1485 	if (i40e_quiesce_vf_pci(vf))
1486 		dev_err(&pf->pdev->dev, "VF %d PCI transactions stuck\n",
1487 			vf->vf_id);
1488 }
1489 
1490 /**
1491  * i40e_cleanup_reset_vf
1492  * @vf: pointer to the VF structure
1493  *
1494  * Cleanup a VF after the hardware reset is finished. Expects the caller to
1495  * have verified whether the reset is finished properly, and ensure the
1496  * minimum amount of wait time has passed.
1497  **/
i40e_cleanup_reset_vf(struct i40e_vf * vf)1498 static void i40e_cleanup_reset_vf(struct i40e_vf *vf)
1499 {
1500 	struct i40e_pf *pf = vf->pf;
1501 	struct i40e_hw *hw = &pf->hw;
1502 	u32 reg;
1503 
1504 	/* disable promisc modes in case they were enabled */
1505 	i40e_config_vf_promiscuous_mode(vf, vf->lan_vsi_id, false, false);
1506 
1507 	/* free VF resources to begin resetting the VSI state */
1508 	i40e_free_vf_res(vf);
1509 
1510 	/* Enable hardware by clearing the reset bit in the VPGEN_VFRTRIG reg.
1511 	 * By doing this we allow HW to access VF memory at any point. If we
1512 	 * did it any sooner, HW could access memory while it was being freed
1513 	 * in i40e_free_vf_res(), causing an IOMMU fault.
1514 	 *
1515 	 * On the other hand, this needs to be done ASAP, because the VF driver
1516 	 * is waiting for this to happen and may report a timeout. It's
1517 	 * harmless, but it gets logged into Guest OS kernel log, so best avoid
1518 	 * it.
1519 	 */
1520 	reg = rd32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id));
1521 	reg &= ~I40E_VPGEN_VFRTRIG_VFSWR_MASK;
1522 	wr32(hw, I40E_VPGEN_VFRTRIG(vf->vf_id), reg);
1523 
1524 	/* reallocate VF resources to finish resetting the VSI state */
1525 	if (!i40e_alloc_vf_res(vf)) {
1526 		int abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
1527 		i40e_enable_vf_mappings(vf);
1528 		set_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states);
1529 		clear_bit(I40E_VF_STATE_DISABLED, &vf->vf_states);
1530 		/* Do not notify the client during VF init */
1531 		if (!test_and_clear_bit(I40E_VF_STATE_PRE_ENABLE,
1532 					&vf->vf_states))
1533 			i40e_notify_client_of_vf_reset(pf, abs_vf_id);
1534 		vf->num_vlan = 0;
1535 	}
1536 
1537 	/* Tell the VF driver the reset is done. This needs to be done only
1538 	 * after VF has been fully initialized, because the VF driver may
1539 	 * request resources immediately after setting this flag.
1540 	 */
1541 	wr32(hw, I40E_VFGEN_RSTAT1(vf->vf_id), VIRTCHNL_VFR_VFACTIVE);
1542 }
1543 
1544 /**
1545  * i40e_reset_vf
1546  * @vf: pointer to the VF structure
1547  * @flr: VFLR was issued or not
1548  *
1549  * Returns true if the VF is in reset, resets successfully, or resets
1550  * are disabled and false otherwise.
1551  **/
i40e_reset_vf(struct i40e_vf * vf,bool flr)1552 bool i40e_reset_vf(struct i40e_vf *vf, bool flr)
1553 {
1554 	struct i40e_pf *pf = vf->pf;
1555 	struct i40e_hw *hw = &pf->hw;
1556 	bool rsd = false;
1557 	u32 reg;
1558 	int i;
1559 
1560 	if (test_bit(__I40E_VF_RESETS_DISABLED, pf->state))
1561 		return true;
1562 
1563 	/* Bail out if VFs are disabled. */
1564 	if (test_bit(__I40E_VF_DISABLE, pf->state))
1565 		return true;
1566 
1567 	/* If VF is being reset already we don't need to continue. */
1568 	if (test_and_set_bit(I40E_VF_STATE_RESETTING, &vf->vf_states))
1569 		return true;
1570 
1571 	i40e_trigger_vf_reset(vf, flr);
1572 
1573 	/* poll VPGEN_VFRSTAT reg to make sure
1574 	 * that reset is complete
1575 	 */
1576 	for (i = 0; i < 10; i++) {
1577 		/* VF reset requires driver to first reset the VF and then
1578 		 * poll the status register to make sure that the reset
1579 		 * completed successfully. Due to internal HW FIFO flushes,
1580 		 * we must wait 10ms before the register will be valid.
1581 		 */
1582 		usleep_range(10000, 20000);
1583 		reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id));
1584 		if (reg & I40E_VPGEN_VFRSTAT_VFRD_MASK) {
1585 			rsd = true;
1586 			break;
1587 		}
1588 	}
1589 
1590 	if (flr)
1591 		usleep_range(10000, 20000);
1592 
1593 	if (!rsd)
1594 		dev_err(&pf->pdev->dev, "VF reset check timeout on VF %d\n",
1595 			vf->vf_id);
1596 	usleep_range(10000, 20000);
1597 
1598 	/* On initial reset, we don't have any queues to disable */
1599 	if (vf->lan_vsi_idx != 0)
1600 		i40e_vsi_stop_rings(pf->vsi[vf->lan_vsi_idx]);
1601 
1602 	i40e_cleanup_reset_vf(vf);
1603 
1604 	i40e_flush(hw);
1605 	usleep_range(20000, 40000);
1606 	clear_bit(I40E_VF_STATE_RESETTING, &vf->vf_states);
1607 
1608 	return true;
1609 }
1610 
1611 /**
1612  * i40e_reset_all_vfs
1613  * @pf: pointer to the PF structure
1614  * @flr: VFLR was issued or not
1615  *
1616  * Reset all allocated VFs in one go. First, tell the hardware to reset each
1617  * VF, then do all the waiting in one chunk, and finally finish restoring each
1618  * VF after the wait. This is useful during PF routines which need to reset
1619  * all VFs, as otherwise it must perform these resets in a serialized fashion.
1620  *
1621  * Returns true if any VFs were reset, and false otherwise.
1622  **/
i40e_reset_all_vfs(struct i40e_pf * pf,bool flr)1623 bool i40e_reset_all_vfs(struct i40e_pf *pf, bool flr)
1624 {
1625 	struct i40e_hw *hw = &pf->hw;
1626 	struct i40e_vf *vf;
1627 	u32 reg;
1628 	int i;
1629 
1630 	/* If we don't have any VFs, then there is nothing to reset */
1631 	if (!pf->num_alloc_vfs)
1632 		return false;
1633 
1634 	/* If VFs have been disabled, there is no need to reset */
1635 	if (test_and_set_bit(__I40E_VF_DISABLE, pf->state))
1636 		return false;
1637 
1638 	/* Begin reset on all VFs at once */
1639 	for (vf = &pf->vf[0]; vf < &pf->vf[pf->num_alloc_vfs]; ++vf) {
1640 		/* If VF is being reset no need to trigger reset again */
1641 		if (!test_bit(I40E_VF_STATE_RESETTING, &vf->vf_states))
1642 			i40e_trigger_vf_reset(vf, flr);
1643 	}
1644 
1645 	/* HW requires some time to make sure it can flush the FIFO for a VF
1646 	 * when it resets it. Poll the VPGEN_VFRSTAT register for each VF in
1647 	 * sequence to make sure that it has completed. We'll keep track of
1648 	 * the VFs using a simple iterator that increments once that VF has
1649 	 * finished resetting.
1650 	 */
1651 	for (i = 0, vf = &pf->vf[0]; i < 10 && vf < &pf->vf[pf->num_alloc_vfs]; ++i) {
1652 		usleep_range(10000, 20000);
1653 
1654 		/* Check each VF in sequence, beginning with the VF to fail
1655 		 * the previous check.
1656 		 */
1657 		while (vf < &pf->vf[pf->num_alloc_vfs]) {
1658 			if (!test_bit(I40E_VF_STATE_RESETTING, &vf->vf_states)) {
1659 				reg = rd32(hw, I40E_VPGEN_VFRSTAT(vf->vf_id));
1660 				if (!(reg & I40E_VPGEN_VFRSTAT_VFRD_MASK))
1661 					break;
1662 			}
1663 
1664 			/* If the current VF has finished resetting, move on
1665 			 * to the next VF in sequence.
1666 			 */
1667 			++vf;
1668 		}
1669 	}
1670 
1671 	if (flr)
1672 		usleep_range(10000, 20000);
1673 
1674 	/* Display a warning if at least one VF didn't manage to reset in
1675 	 * time, but continue on with the operation.
1676 	 */
1677 	if (vf < &pf->vf[pf->num_alloc_vfs])
1678 		dev_err(&pf->pdev->dev, "VF reset check timeout on VF %d\n",
1679 			vf->vf_id);
1680 	usleep_range(10000, 20000);
1681 
1682 	/* Begin disabling all the rings associated with VFs, but do not wait
1683 	 * between each VF.
1684 	 */
1685 	for (vf = &pf->vf[0]; vf < &pf->vf[pf->num_alloc_vfs]; ++vf) {
1686 		/* On initial reset, we don't have any queues to disable */
1687 		if (vf->lan_vsi_idx == 0)
1688 			continue;
1689 
1690 		/* If VF is reset in another thread just continue */
1691 		if (test_bit(I40E_VF_STATE_RESETTING, &vf->vf_states))
1692 			continue;
1693 
1694 		i40e_vsi_stop_rings_no_wait(pf->vsi[vf->lan_vsi_idx]);
1695 	}
1696 
1697 	/* Now that we've notified HW to disable all of the VF rings, wait
1698 	 * until they finish.
1699 	 */
1700 	for (vf = &pf->vf[0]; vf < &pf->vf[pf->num_alloc_vfs]; ++vf) {
1701 		/* On initial reset, we don't have any queues to disable */
1702 		if (vf->lan_vsi_idx == 0)
1703 			continue;
1704 
1705 		/* If VF is reset in another thread just continue */
1706 		if (test_bit(I40E_VF_STATE_RESETTING, &vf->vf_states))
1707 			continue;
1708 
1709 		i40e_vsi_wait_queues_disabled(pf->vsi[vf->lan_vsi_idx]);
1710 	}
1711 
1712 	/* Hw may need up to 50ms to finish disabling the RX queues. We
1713 	 * minimize the wait by delaying only once for all VFs.
1714 	 */
1715 	mdelay(50);
1716 
1717 	/* Finish the reset on each VF */
1718 	for (vf = &pf->vf[0]; vf < &pf->vf[pf->num_alloc_vfs]; ++vf) {
1719 		/* If VF is reset in another thread just continue */
1720 		if (test_bit(I40E_VF_STATE_RESETTING, &vf->vf_states))
1721 			continue;
1722 
1723 		i40e_cleanup_reset_vf(vf);
1724 	}
1725 
1726 	i40e_flush(hw);
1727 	usleep_range(20000, 40000);
1728 	clear_bit(__I40E_VF_DISABLE, pf->state);
1729 
1730 	return true;
1731 }
1732 
1733 /**
1734  * i40e_free_vfs
1735  * @pf: pointer to the PF structure
1736  *
1737  * free VF resources
1738  **/
i40e_free_vfs(struct i40e_pf * pf)1739 void i40e_free_vfs(struct i40e_pf *pf)
1740 {
1741 	struct i40e_hw *hw = &pf->hw;
1742 	u32 reg_idx, bit_idx;
1743 	int i, tmp, vf_id;
1744 
1745 	if (!pf->vf)
1746 		return;
1747 
1748 	set_bit(__I40E_VFS_RELEASING, pf->state);
1749 	while (test_and_set_bit(__I40E_VF_DISABLE, pf->state))
1750 		usleep_range(1000, 2000);
1751 
1752 	i40e_notify_client_of_vf_enable(pf, 0);
1753 
1754 	/* Disable IOV before freeing resources. This lets any VF drivers
1755 	 * running in the host get themselves cleaned up before we yank
1756 	 * the carpet out from underneath their feet.
1757 	 */
1758 	if (!pci_vfs_assigned(pf->pdev))
1759 		pci_disable_sriov(pf->pdev);
1760 	else
1761 		dev_warn(&pf->pdev->dev, "VFs are assigned - not disabling SR-IOV\n");
1762 
1763 	/* Amortize wait time by stopping all VFs at the same time */
1764 	for (i = 0; i < pf->num_alloc_vfs; i++) {
1765 		if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states))
1766 			continue;
1767 
1768 		i40e_vsi_stop_rings_no_wait(pf->vsi[pf->vf[i].lan_vsi_idx]);
1769 	}
1770 
1771 	for (i = 0; i < pf->num_alloc_vfs; i++) {
1772 		if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states))
1773 			continue;
1774 
1775 		i40e_vsi_wait_queues_disabled(pf->vsi[pf->vf[i].lan_vsi_idx]);
1776 	}
1777 
1778 	/* free up VF resources */
1779 	tmp = pf->num_alloc_vfs;
1780 	pf->num_alloc_vfs = 0;
1781 	for (i = 0; i < tmp; i++) {
1782 		if (test_bit(I40E_VF_STATE_INIT, &pf->vf[i].vf_states))
1783 			i40e_free_vf_res(&pf->vf[i]);
1784 		/* disable qp mappings */
1785 		i40e_disable_vf_mappings(&pf->vf[i]);
1786 	}
1787 
1788 	kfree(pf->vf);
1789 	pf->vf = NULL;
1790 
1791 	/* This check is for when the driver is unloaded while VFs are
1792 	 * assigned. Setting the number of VFs to 0 through sysfs is caught
1793 	 * before this function ever gets called.
1794 	 */
1795 	if (!pci_vfs_assigned(pf->pdev)) {
1796 		/* Acknowledge VFLR for all VFS. Without this, VFs will fail to
1797 		 * work correctly when SR-IOV gets re-enabled.
1798 		 */
1799 		for (vf_id = 0; vf_id < tmp; vf_id++) {
1800 			reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32;
1801 			bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
1802 			wr32(hw, I40E_GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
1803 		}
1804 	}
1805 	clear_bit(__I40E_VF_DISABLE, pf->state);
1806 	clear_bit(__I40E_VFS_RELEASING, pf->state);
1807 }
1808 
1809 #ifdef CONFIG_PCI_IOV
1810 /**
1811  * i40e_alloc_vfs
1812  * @pf: pointer to the PF structure
1813  * @num_alloc_vfs: number of VFs to allocate
1814  *
1815  * allocate VF resources
1816  **/
i40e_alloc_vfs(struct i40e_pf * pf,u16 num_alloc_vfs)1817 int i40e_alloc_vfs(struct i40e_pf *pf, u16 num_alloc_vfs)
1818 {
1819 	struct i40e_vf *vfs;
1820 	int i, ret = 0;
1821 
1822 	/* Disable interrupt 0 so we don't try to handle the VFLR. */
1823 	i40e_irq_dynamic_disable_icr0(pf);
1824 
1825 	/* Check to see if we're just allocating resources for extant VFs */
1826 	if (pci_num_vf(pf->pdev) != num_alloc_vfs) {
1827 		ret = pci_enable_sriov(pf->pdev, num_alloc_vfs);
1828 		if (ret) {
1829 			clear_bit(I40E_FLAG_VEB_MODE_ENA, pf->flags);
1830 			pf->num_alloc_vfs = 0;
1831 			goto err_iov;
1832 		}
1833 	}
1834 	/* allocate memory */
1835 	vfs = kcalloc(num_alloc_vfs, sizeof(struct i40e_vf), GFP_KERNEL);
1836 	if (!vfs) {
1837 		ret = -ENOMEM;
1838 		goto err_alloc;
1839 	}
1840 	pf->vf = vfs;
1841 
1842 	/* apply default profile */
1843 	for (i = 0; i < num_alloc_vfs; i++) {
1844 		vfs[i].pf = pf;
1845 		vfs[i].parent_type = I40E_SWITCH_ELEMENT_TYPE_VEB;
1846 		vfs[i].vf_id = i;
1847 
1848 		/* assign default capabilities */
1849 		set_bit(I40E_VIRTCHNL_VF_CAP_L2, &vfs[i].vf_caps);
1850 		vfs[i].spoofchk = true;
1851 
1852 		set_bit(I40E_VF_STATE_PRE_ENABLE, &vfs[i].vf_states);
1853 
1854 	}
1855 	pf->num_alloc_vfs = num_alloc_vfs;
1856 
1857 	/* VF resources get allocated during reset */
1858 	i40e_reset_all_vfs(pf, false);
1859 
1860 	i40e_notify_client_of_vf_enable(pf, num_alloc_vfs);
1861 
1862 err_alloc:
1863 	if (ret)
1864 		i40e_free_vfs(pf);
1865 err_iov:
1866 	/* Re-enable interrupt 0. */
1867 	i40e_irq_dynamic_enable_icr0(pf);
1868 	return ret;
1869 }
1870 
1871 #endif
1872 /**
1873  * i40e_pci_sriov_enable
1874  * @pdev: pointer to a pci_dev structure
1875  * @num_vfs: number of VFs to allocate
1876  *
1877  * Enable or change the number of VFs
1878  **/
i40e_pci_sriov_enable(struct pci_dev * pdev,int num_vfs)1879 static int i40e_pci_sriov_enable(struct pci_dev *pdev, int num_vfs)
1880 {
1881 #ifdef CONFIG_PCI_IOV
1882 	struct i40e_pf *pf = pci_get_drvdata(pdev);
1883 	int pre_existing_vfs = pci_num_vf(pdev);
1884 	int err = 0;
1885 
1886 	if (test_bit(__I40E_TESTING, pf->state)) {
1887 		dev_warn(&pdev->dev,
1888 			 "Cannot enable SR-IOV virtual functions while the device is undergoing diagnostic testing\n");
1889 		err = -EPERM;
1890 		goto err_out;
1891 	}
1892 
1893 	if (pre_existing_vfs && pre_existing_vfs != num_vfs)
1894 		i40e_free_vfs(pf);
1895 	else if (pre_existing_vfs && pre_existing_vfs == num_vfs)
1896 		goto out;
1897 
1898 	if (num_vfs > pf->num_req_vfs) {
1899 		dev_warn(&pdev->dev, "Unable to enable %d VFs. Limited to %d VFs due to device resource constraints.\n",
1900 			 num_vfs, pf->num_req_vfs);
1901 		err = -EPERM;
1902 		goto err_out;
1903 	}
1904 
1905 	dev_info(&pdev->dev, "Allocating %d VFs.\n", num_vfs);
1906 	err = i40e_alloc_vfs(pf, num_vfs);
1907 	if (err) {
1908 		dev_warn(&pdev->dev, "Failed to enable SR-IOV: %d\n", err);
1909 		goto err_out;
1910 	}
1911 
1912 out:
1913 	return num_vfs;
1914 
1915 err_out:
1916 	return err;
1917 #endif
1918 	return 0;
1919 }
1920 
1921 /**
1922  * i40e_pci_sriov_configure
1923  * @pdev: pointer to a pci_dev structure
1924  * @num_vfs: number of VFs to allocate
1925  *
1926  * Enable or change the number of VFs. Called when the user updates the number
1927  * of VFs in sysfs.
1928  **/
i40e_pci_sriov_configure(struct pci_dev * pdev,int num_vfs)1929 int i40e_pci_sriov_configure(struct pci_dev *pdev, int num_vfs)
1930 {
1931 	struct i40e_pf *pf = pci_get_drvdata(pdev);
1932 	int ret = 0;
1933 
1934 	if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
1935 		dev_warn(&pdev->dev, "Unable to configure VFs, other operation is pending.\n");
1936 		return -EAGAIN;
1937 	}
1938 
1939 	if (num_vfs) {
1940 		if (!test_bit(I40E_FLAG_VEB_MODE_ENA, pf->flags)) {
1941 			set_bit(I40E_FLAG_VEB_MODE_ENA, pf->flags);
1942 			i40e_do_reset_safe(pf, I40E_PF_RESET_AND_REBUILD_FLAG);
1943 		}
1944 		ret = i40e_pci_sriov_enable(pdev, num_vfs);
1945 		goto sriov_configure_out;
1946 	}
1947 
1948 	if (!pci_vfs_assigned(pf->pdev)) {
1949 		i40e_free_vfs(pf);
1950 		clear_bit(I40E_FLAG_VEB_MODE_ENA, pf->flags);
1951 		i40e_do_reset_safe(pf, I40E_PF_RESET_AND_REBUILD_FLAG);
1952 	} else {
1953 		dev_warn(&pdev->dev, "Unable to free VFs because some are assigned to VMs.\n");
1954 		ret = -EINVAL;
1955 		goto sriov_configure_out;
1956 	}
1957 sriov_configure_out:
1958 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
1959 	return ret;
1960 }
1961 
1962 /***********************virtual channel routines******************/
1963 
1964 /**
1965  * i40e_vc_send_msg_to_vf
1966  * @vf: pointer to the VF info
1967  * @v_opcode: virtual channel opcode
1968  * @v_retval: virtual channel return value
1969  * @msg: pointer to the msg buffer
1970  * @msglen: msg length
1971  *
1972  * send msg to VF
1973  **/
i40e_vc_send_msg_to_vf(struct i40e_vf * vf,u32 v_opcode,u32 v_retval,u8 * msg,u16 msglen)1974 static int i40e_vc_send_msg_to_vf(struct i40e_vf *vf, u32 v_opcode,
1975 				  u32 v_retval, u8 *msg, u16 msglen)
1976 {
1977 	struct i40e_pf *pf;
1978 	struct i40e_hw *hw;
1979 	int abs_vf_id;
1980 	int aq_ret;
1981 
1982 	/* validate the request */
1983 	if (!vf || vf->vf_id >= vf->pf->num_alloc_vfs)
1984 		return -EINVAL;
1985 
1986 	pf = vf->pf;
1987 	hw = &pf->hw;
1988 	abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
1989 
1990 	aq_ret = i40e_aq_send_msg_to_vf(hw, abs_vf_id,	v_opcode, v_retval,
1991 					msg, msglen, NULL);
1992 	if (aq_ret) {
1993 		dev_info(&pf->pdev->dev,
1994 			 "Unable to send the message to VF %d aq_err %d\n",
1995 			 vf->vf_id, pf->hw.aq.asq_last_status);
1996 		return -EIO;
1997 	}
1998 
1999 	return 0;
2000 }
2001 
2002 /**
2003  * i40e_vc_send_resp_to_vf
2004  * @vf: pointer to the VF info
2005  * @opcode: operation code
2006  * @retval: return value
2007  *
2008  * send resp msg to VF
2009  **/
i40e_vc_send_resp_to_vf(struct i40e_vf * vf,enum virtchnl_ops opcode,int retval)2010 static int i40e_vc_send_resp_to_vf(struct i40e_vf *vf,
2011 				   enum virtchnl_ops opcode,
2012 				   int retval)
2013 {
2014 	return i40e_vc_send_msg_to_vf(vf, opcode, retval, NULL, 0);
2015 }
2016 
2017 /**
2018  * i40e_sync_vf_state
2019  * @vf: pointer to the VF info
2020  * @state: VF state
2021  *
2022  * Called from a VF message to synchronize the service with a potential
2023  * VF reset state
2024  **/
i40e_sync_vf_state(struct i40e_vf * vf,enum i40e_vf_states state)2025 static bool i40e_sync_vf_state(struct i40e_vf *vf, enum i40e_vf_states state)
2026 {
2027 	int i;
2028 
2029 	/* When handling some messages, it needs VF state to be set.
2030 	 * It is possible that this flag is cleared during VF reset,
2031 	 * so there is a need to wait until the end of the reset to
2032 	 * handle the request message correctly.
2033 	 */
2034 	for (i = 0; i < I40E_VF_STATE_WAIT_COUNT; i++) {
2035 		if (test_bit(state, &vf->vf_states))
2036 			return true;
2037 		usleep_range(10000, 20000);
2038 	}
2039 
2040 	return test_bit(state, &vf->vf_states);
2041 }
2042 
2043 /**
2044  * i40e_vc_get_version_msg
2045  * @vf: pointer to the VF info
2046  * @msg: pointer to the msg buffer
2047  *
2048  * called from the VF to request the API version used by the PF
2049  **/
i40e_vc_get_version_msg(struct i40e_vf * vf,u8 * msg)2050 static int i40e_vc_get_version_msg(struct i40e_vf *vf, u8 *msg)
2051 {
2052 	struct virtchnl_version_info info = {
2053 		VIRTCHNL_VERSION_MAJOR, VIRTCHNL_VERSION_MINOR
2054 	};
2055 
2056 	vf->vf_ver = *(struct virtchnl_version_info *)msg;
2057 	/* VFs running the 1.0 API expect to get 1.0 back or they will cry. */
2058 	if (VF_IS_V10(&vf->vf_ver))
2059 		info.minor = VIRTCHNL_VERSION_MINOR_NO_VF_CAPS;
2060 	return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_VERSION,
2061 				      0, (u8 *)&info,
2062 				      sizeof(struct virtchnl_version_info));
2063 }
2064 
2065 /**
2066  * i40e_del_qch - delete all the additional VSIs created as a part of ADq
2067  * @vf: pointer to VF structure
2068  **/
i40e_del_qch(struct i40e_vf * vf)2069 static void i40e_del_qch(struct i40e_vf *vf)
2070 {
2071 	struct i40e_pf *pf = vf->pf;
2072 	int i;
2073 
2074 	/* first element in the array belongs to primary VF VSI and we shouldn't
2075 	 * delete it. We should however delete the rest of the VSIs created
2076 	 */
2077 	for (i = 1; i < vf->num_tc; i++) {
2078 		if (vf->ch[i].vsi_idx) {
2079 			i40e_vsi_release(pf->vsi[vf->ch[i].vsi_idx]);
2080 			vf->ch[i].vsi_idx = 0;
2081 			vf->ch[i].vsi_id = 0;
2082 		}
2083 	}
2084 }
2085 
2086 /**
2087  * i40e_vc_get_max_frame_size
2088  * @vf: pointer to the VF
2089  *
2090  * Max frame size is determined based on the current port's max frame size and
2091  * whether a port VLAN is configured on this VF. The VF is not aware whether
2092  * it's in a port VLAN so the PF needs to account for this in max frame size
2093  * checks and sending the max frame size to the VF.
2094  **/
i40e_vc_get_max_frame_size(struct i40e_vf * vf)2095 static u16 i40e_vc_get_max_frame_size(struct i40e_vf *vf)
2096 {
2097 	u16 max_frame_size = vf->pf->hw.phy.link_info.max_frame_size;
2098 
2099 	if (vf->port_vlan_id)
2100 		max_frame_size -= VLAN_HLEN;
2101 
2102 	return max_frame_size;
2103 }
2104 
2105 /**
2106  * i40e_vc_get_vf_resources_msg
2107  * @vf: pointer to the VF info
2108  * @msg: pointer to the msg buffer
2109  *
2110  * called from the VF to request its resources
2111  **/
i40e_vc_get_vf_resources_msg(struct i40e_vf * vf,u8 * msg)2112 static int i40e_vc_get_vf_resources_msg(struct i40e_vf *vf, u8 *msg)
2113 {
2114 	struct virtchnl_vf_resource *vfres = NULL;
2115 	struct i40e_pf *pf = vf->pf;
2116 	struct i40e_vsi *vsi;
2117 	int num_vsis = 1;
2118 	int aq_ret = 0;
2119 	size_t len = 0;
2120 	int ret;
2121 
2122 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_INIT)) {
2123 		aq_ret = -EINVAL;
2124 		goto err;
2125 	}
2126 
2127 	len = virtchnl_struct_size(vfres, vsi_res, num_vsis);
2128 	vfres = kzalloc(len, GFP_KERNEL);
2129 	if (!vfres) {
2130 		aq_ret = -ENOMEM;
2131 		len = 0;
2132 		goto err;
2133 	}
2134 	if (VF_IS_V11(&vf->vf_ver))
2135 		vf->driver_caps = *(u32 *)msg;
2136 	else
2137 		vf->driver_caps = VIRTCHNL_VF_OFFLOAD_L2 |
2138 				  VIRTCHNL_VF_OFFLOAD_RSS_REG |
2139 				  VIRTCHNL_VF_OFFLOAD_VLAN;
2140 
2141 	vfres->vf_cap_flags = VIRTCHNL_VF_OFFLOAD_L2;
2142 	vfres->vf_cap_flags |= VIRTCHNL_VF_CAP_ADV_LINK_SPEED;
2143 	vsi = pf->vsi[vf->lan_vsi_idx];
2144 	if (!vsi->info.pvid)
2145 		vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_VLAN;
2146 
2147 	if (i40e_vf_client_capable(pf, vf->vf_id) &&
2148 	    (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RDMA)) {
2149 		vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RDMA;
2150 		set_bit(I40E_VF_STATE_RDMAENA, &vf->vf_states);
2151 	} else {
2152 		clear_bit(I40E_VF_STATE_RDMAENA, &vf->vf_states);
2153 	}
2154 
2155 	if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_PF) {
2156 		vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_PF;
2157 	} else {
2158 		if (test_bit(I40E_HW_CAP_RSS_AQ, pf->hw.caps) &&
2159 		    (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_AQ))
2160 			vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_AQ;
2161 		else
2162 			vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_REG;
2163 	}
2164 
2165 	if (test_bit(I40E_HW_CAP_MULTI_TCP_UDP_RSS_PCTYPE, pf->hw.caps)) {
2166 		if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2)
2167 			vfres->vf_cap_flags |=
2168 				VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2;
2169 	}
2170 
2171 	if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ENCAP)
2172 		vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ENCAP;
2173 
2174 	if (test_bit(I40E_HW_CAP_OUTER_UDP_CSUM, pf->hw.caps) &&
2175 	    (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM))
2176 		vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM;
2177 
2178 	if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_POLLING) {
2179 		if (test_bit(I40E_FLAG_MFP_ENA, pf->flags)) {
2180 			dev_err(&pf->pdev->dev,
2181 				"VF %d requested polling mode: this feature is supported only when the device is running in single function per port (SFP) mode\n",
2182 				 vf->vf_id);
2183 			aq_ret = -EINVAL;
2184 			goto err;
2185 		}
2186 		vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RX_POLLING;
2187 	}
2188 
2189 	if (test_bit(I40E_HW_CAP_WB_ON_ITR, pf->hw.caps)) {
2190 		if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_WB_ON_ITR)
2191 			vfres->vf_cap_flags |=
2192 					VIRTCHNL_VF_OFFLOAD_WB_ON_ITR;
2193 	}
2194 
2195 	if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_REQ_QUEUES)
2196 		vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_REQ_QUEUES;
2197 
2198 	if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ADQ)
2199 		vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ADQ;
2200 
2201 	vfres->num_vsis = num_vsis;
2202 	vfres->num_queue_pairs = vf->num_queue_pairs;
2203 	vfres->max_vectors = pf->hw.func_caps.num_msix_vectors_vf;
2204 	vfres->rss_key_size = I40E_HKEY_ARRAY_SIZE;
2205 	vfres->rss_lut_size = I40E_VF_HLUT_ARRAY_SIZE;
2206 	vfres->max_mtu = i40e_vc_get_max_frame_size(vf);
2207 
2208 	if (vf->lan_vsi_idx) {
2209 		vfres->vsi_res[0].vsi_id = vf->lan_vsi_id;
2210 		vfres->vsi_res[0].vsi_type = VIRTCHNL_VSI_SRIOV;
2211 		vfres->vsi_res[0].num_queue_pairs = vsi->alloc_queue_pairs;
2212 		/* VFs only use TC 0 */
2213 		vfres->vsi_res[0].qset_handle
2214 					  = le16_to_cpu(vsi->info.qs_handle[0]);
2215 		if (!(vf->driver_caps & VIRTCHNL_VF_OFFLOAD_USO) && !vf->pf_set_mac) {
2216 			spin_lock_bh(&vsi->mac_filter_hash_lock);
2217 			i40e_del_mac_filter(vsi, vf->default_lan_addr.addr);
2218 			eth_zero_addr(vf->default_lan_addr.addr);
2219 			spin_unlock_bh(&vsi->mac_filter_hash_lock);
2220 		}
2221 		ether_addr_copy(vfres->vsi_res[0].default_mac_addr,
2222 				vf->default_lan_addr.addr);
2223 	}
2224 	set_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states);
2225 
2226 err:
2227 	/* send the response back to the VF */
2228 	ret = i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_VF_RESOURCES,
2229 				     aq_ret, (u8 *)vfres, len);
2230 
2231 	kfree(vfres);
2232 	return ret;
2233 }
2234 
2235 /**
2236  * i40e_vc_config_promiscuous_mode_msg
2237  * @vf: pointer to the VF info
2238  * @msg: pointer to the msg buffer
2239  *
2240  * called from the VF to configure the promiscuous mode of
2241  * VF vsis
2242  **/
i40e_vc_config_promiscuous_mode_msg(struct i40e_vf * vf,u8 * msg)2243 static int i40e_vc_config_promiscuous_mode_msg(struct i40e_vf *vf, u8 *msg)
2244 {
2245 	struct virtchnl_promisc_info *info =
2246 	    (struct virtchnl_promisc_info *)msg;
2247 	struct i40e_pf *pf = vf->pf;
2248 	bool allmulti = false;
2249 	bool alluni = false;
2250 	int aq_ret = 0;
2251 
2252 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
2253 		aq_ret = -EINVAL;
2254 		goto err_out;
2255 	}
2256 	if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) {
2257 		dev_err(&pf->pdev->dev,
2258 			"Unprivileged VF %d is attempting to configure promiscuous mode\n",
2259 			vf->vf_id);
2260 
2261 		/* Lie to the VF on purpose, because this is an error we can
2262 		 * ignore. Unprivileged VF is not a virtual channel error.
2263 		 */
2264 		aq_ret = 0;
2265 		goto err_out;
2266 	}
2267 
2268 	if (info->flags > I40E_MAX_VF_PROMISC_FLAGS) {
2269 		aq_ret = -EINVAL;
2270 		goto err_out;
2271 	}
2272 
2273 	if (!i40e_vc_isvalid_vsi_id(vf, info->vsi_id)) {
2274 		aq_ret = -EINVAL;
2275 		goto err_out;
2276 	}
2277 
2278 	/* Multicast promiscuous handling*/
2279 	if (info->flags & FLAG_VF_MULTICAST_PROMISC)
2280 		allmulti = true;
2281 
2282 	if (info->flags & FLAG_VF_UNICAST_PROMISC)
2283 		alluni = true;
2284 	aq_ret = i40e_config_vf_promiscuous_mode(vf, info->vsi_id, allmulti,
2285 						 alluni);
2286 	if (aq_ret)
2287 		goto err_out;
2288 
2289 	if (allmulti) {
2290 		if (!test_and_set_bit(I40E_VF_STATE_MC_PROMISC,
2291 				      &vf->vf_states))
2292 			dev_info(&pf->pdev->dev,
2293 				 "VF %d successfully set multicast promiscuous mode\n",
2294 				 vf->vf_id);
2295 	} else if (test_and_clear_bit(I40E_VF_STATE_MC_PROMISC,
2296 				      &vf->vf_states))
2297 		dev_info(&pf->pdev->dev,
2298 			 "VF %d successfully unset multicast promiscuous mode\n",
2299 			 vf->vf_id);
2300 
2301 	if (alluni) {
2302 		if (!test_and_set_bit(I40E_VF_STATE_UC_PROMISC,
2303 				      &vf->vf_states))
2304 			dev_info(&pf->pdev->dev,
2305 				 "VF %d successfully set unicast promiscuous mode\n",
2306 				 vf->vf_id);
2307 	} else if (test_and_clear_bit(I40E_VF_STATE_UC_PROMISC,
2308 				      &vf->vf_states))
2309 		dev_info(&pf->pdev->dev,
2310 			 "VF %d successfully unset unicast promiscuous mode\n",
2311 			 vf->vf_id);
2312 
2313 err_out:
2314 	/* send the response to the VF */
2315 	return i40e_vc_send_resp_to_vf(vf,
2316 				       VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE,
2317 				       aq_ret);
2318 }
2319 
2320 /**
2321  * i40e_vc_config_queues_msg
2322  * @vf: pointer to the VF info
2323  * @msg: pointer to the msg buffer
2324  *
2325  * called from the VF to configure the rx/tx
2326  * queues
2327  **/
i40e_vc_config_queues_msg(struct i40e_vf * vf,u8 * msg)2328 static int i40e_vc_config_queues_msg(struct i40e_vf *vf, u8 *msg)
2329 {
2330 	struct virtchnl_vsi_queue_config_info *qci =
2331 	    (struct virtchnl_vsi_queue_config_info *)msg;
2332 	struct virtchnl_queue_pair_info *qpi;
2333 	u16 vsi_id, vsi_queue_id = 0;
2334 	struct i40e_pf *pf = vf->pf;
2335 	int i, j = 0, idx = 0;
2336 	struct i40e_vsi *vsi;
2337 	u16 num_qps_all = 0;
2338 	int aq_ret = 0;
2339 
2340 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
2341 		aq_ret = -EINVAL;
2342 		goto error_param;
2343 	}
2344 
2345 	if (!i40e_vc_isvalid_vsi_id(vf, qci->vsi_id)) {
2346 		aq_ret = -EINVAL;
2347 		goto error_param;
2348 	}
2349 
2350 	if (qci->num_queue_pairs > I40E_MAX_VF_QUEUES) {
2351 		aq_ret = -EINVAL;
2352 		goto error_param;
2353 	}
2354 
2355 	if (vf->adq_enabled) {
2356 		for (i = 0; i < vf->num_tc; i++)
2357 			num_qps_all += vf->ch[i].num_qps;
2358 		if (num_qps_all != qci->num_queue_pairs) {
2359 			aq_ret = -EINVAL;
2360 			goto error_param;
2361 		}
2362 	}
2363 
2364 	vsi_id = qci->vsi_id;
2365 
2366 	for (i = 0; i < qci->num_queue_pairs; i++) {
2367 		qpi = &qci->qpair[i];
2368 
2369 		if (!vf->adq_enabled) {
2370 			if (!i40e_vc_isvalid_queue_id(vf, vsi_id,
2371 						      qpi->txq.queue_id)) {
2372 				aq_ret = -EINVAL;
2373 				goto error_param;
2374 			}
2375 
2376 			vsi_queue_id = qpi->txq.queue_id;
2377 
2378 			if (qpi->txq.vsi_id != qci->vsi_id ||
2379 			    qpi->rxq.vsi_id != qci->vsi_id ||
2380 			    qpi->rxq.queue_id != vsi_queue_id) {
2381 				aq_ret = -EINVAL;
2382 				goto error_param;
2383 			}
2384 		}
2385 
2386 		if (vf->adq_enabled) {
2387 			if (idx >= ARRAY_SIZE(vf->ch)) {
2388 				aq_ret = -ENODEV;
2389 				goto error_param;
2390 			}
2391 			vsi_id = vf->ch[idx].vsi_id;
2392 		}
2393 
2394 		if (i40e_config_vsi_rx_queue(vf, vsi_id, vsi_queue_id,
2395 					     &qpi->rxq) ||
2396 		    i40e_config_vsi_tx_queue(vf, vsi_id, vsi_queue_id,
2397 					     &qpi->txq)) {
2398 			aq_ret = -EINVAL;
2399 			goto error_param;
2400 		}
2401 
2402 		/* For ADq there can be up to 4 VSIs with max 4 queues each.
2403 		 * VF does not know about these additional VSIs and all
2404 		 * it cares is about its own queues. PF configures these queues
2405 		 * to its appropriate VSIs based on TC mapping
2406 		 */
2407 		if (vf->adq_enabled) {
2408 			if (idx >= ARRAY_SIZE(vf->ch)) {
2409 				aq_ret = -ENODEV;
2410 				goto error_param;
2411 			}
2412 			if (j == (vf->ch[idx].num_qps - 1)) {
2413 				idx++;
2414 				j = 0; /* resetting the queue count */
2415 				vsi_queue_id = 0;
2416 			} else {
2417 				j++;
2418 				vsi_queue_id++;
2419 			}
2420 		}
2421 	}
2422 	/* set vsi num_queue_pairs in use to num configured by VF */
2423 	if (!vf->adq_enabled) {
2424 		pf->vsi[vf->lan_vsi_idx]->num_queue_pairs =
2425 			qci->num_queue_pairs;
2426 	} else {
2427 		for (i = 0; i < vf->num_tc; i++) {
2428 			vsi = pf->vsi[vf->ch[i].vsi_idx];
2429 			vsi->num_queue_pairs = vf->ch[i].num_qps;
2430 
2431 			if (i40e_update_adq_vsi_queues(vsi, i)) {
2432 				aq_ret = -EIO;
2433 				goto error_param;
2434 			}
2435 		}
2436 	}
2437 
2438 error_param:
2439 	/* send the response to the VF */
2440 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_VSI_QUEUES,
2441 				       aq_ret);
2442 }
2443 
2444 /**
2445  * i40e_validate_queue_map - check queue map is valid
2446  * @vf: the VF structure pointer
2447  * @vsi_id: vsi id
2448  * @queuemap: Tx or Rx queue map
2449  *
2450  * check if Tx or Rx queue map is valid
2451  **/
i40e_validate_queue_map(struct i40e_vf * vf,u16 vsi_id,unsigned long queuemap)2452 static int i40e_validate_queue_map(struct i40e_vf *vf, u16 vsi_id,
2453 				   unsigned long queuemap)
2454 {
2455 	u16 vsi_queue_id, queue_id;
2456 
2457 	for_each_set_bit(vsi_queue_id, &queuemap, I40E_MAX_VSI_QP) {
2458 		if (vf->adq_enabled) {
2459 			vsi_id = vf->ch[vsi_queue_id / I40E_MAX_VF_VSI].vsi_id;
2460 			queue_id = (vsi_queue_id % I40E_DEFAULT_QUEUES_PER_VF);
2461 		} else {
2462 			queue_id = vsi_queue_id;
2463 		}
2464 
2465 		if (!i40e_vc_isvalid_queue_id(vf, vsi_id, queue_id))
2466 			return -EINVAL;
2467 	}
2468 
2469 	return 0;
2470 }
2471 
2472 /**
2473  * i40e_vc_config_irq_map_msg
2474  * @vf: pointer to the VF info
2475  * @msg: pointer to the msg buffer
2476  *
2477  * called from the VF to configure the irq to
2478  * queue map
2479  **/
i40e_vc_config_irq_map_msg(struct i40e_vf * vf,u8 * msg)2480 static int i40e_vc_config_irq_map_msg(struct i40e_vf *vf, u8 *msg)
2481 {
2482 	struct virtchnl_irq_map_info *irqmap_info =
2483 	    (struct virtchnl_irq_map_info *)msg;
2484 	struct virtchnl_vector_map *map;
2485 	int aq_ret = 0;
2486 	u16 vsi_id;
2487 	int i;
2488 
2489 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
2490 		aq_ret = -EINVAL;
2491 		goto error_param;
2492 	}
2493 
2494 	if (irqmap_info->num_vectors >
2495 	    vf->pf->hw.func_caps.num_msix_vectors_vf) {
2496 		aq_ret = -EINVAL;
2497 		goto error_param;
2498 	}
2499 
2500 	for (i = 0; i < irqmap_info->num_vectors; i++) {
2501 		map = &irqmap_info->vecmap[i];
2502 		/* validate msg params */
2503 		if (!i40e_vc_isvalid_vector_id(vf, map->vector_id) ||
2504 		    !i40e_vc_isvalid_vsi_id(vf, map->vsi_id)) {
2505 			aq_ret = -EINVAL;
2506 			goto error_param;
2507 		}
2508 		vsi_id = map->vsi_id;
2509 
2510 		if (i40e_validate_queue_map(vf, vsi_id, map->rxq_map)) {
2511 			aq_ret = -EINVAL;
2512 			goto error_param;
2513 		}
2514 
2515 		if (i40e_validate_queue_map(vf, vsi_id, map->txq_map)) {
2516 			aq_ret = -EINVAL;
2517 			goto error_param;
2518 		}
2519 
2520 		i40e_config_irq_link_list(vf, vsi_id, map);
2521 	}
2522 error_param:
2523 	/* send the response to the VF */
2524 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_IRQ_MAP,
2525 				       aq_ret);
2526 }
2527 
2528 /**
2529  * i40e_ctrl_vf_tx_rings
2530  * @vsi: the SRIOV VSI being configured
2531  * @q_map: bit map of the queues to be enabled
2532  * @enable: start or stop the queue
2533  **/
i40e_ctrl_vf_tx_rings(struct i40e_vsi * vsi,unsigned long q_map,bool enable)2534 static int i40e_ctrl_vf_tx_rings(struct i40e_vsi *vsi, unsigned long q_map,
2535 				 bool enable)
2536 {
2537 	struct i40e_pf *pf = vsi->back;
2538 	int ret = 0;
2539 	u16 q_id;
2540 
2541 	for_each_set_bit(q_id, &q_map, I40E_MAX_VF_QUEUES) {
2542 		ret = i40e_control_wait_tx_q(vsi->seid, pf,
2543 					     vsi->base_queue + q_id,
2544 					     false /*is xdp*/, enable);
2545 		if (ret)
2546 			break;
2547 	}
2548 	return ret;
2549 }
2550 
2551 /**
2552  * i40e_ctrl_vf_rx_rings
2553  * @vsi: the SRIOV VSI being configured
2554  * @q_map: bit map of the queues to be enabled
2555  * @enable: start or stop the queue
2556  **/
i40e_ctrl_vf_rx_rings(struct i40e_vsi * vsi,unsigned long q_map,bool enable)2557 static int i40e_ctrl_vf_rx_rings(struct i40e_vsi *vsi, unsigned long q_map,
2558 				 bool enable)
2559 {
2560 	struct i40e_pf *pf = vsi->back;
2561 	int ret = 0;
2562 	u16 q_id;
2563 
2564 	for_each_set_bit(q_id, &q_map, I40E_MAX_VF_QUEUES) {
2565 		ret = i40e_control_wait_rx_q(pf, vsi->base_queue + q_id,
2566 					     enable);
2567 		if (ret)
2568 			break;
2569 	}
2570 	return ret;
2571 }
2572 
2573 /**
2574  * i40e_vc_validate_vqs_bitmaps - validate Rx/Tx queue bitmaps from VIRTHCHNL
2575  * @vqs: virtchnl_queue_select structure containing bitmaps to validate
2576  *
2577  * Returns true if validation was successful, else false.
2578  */
i40e_vc_validate_vqs_bitmaps(struct virtchnl_queue_select * vqs)2579 static bool i40e_vc_validate_vqs_bitmaps(struct virtchnl_queue_select *vqs)
2580 {
2581 	if ((!vqs->rx_queues && !vqs->tx_queues) ||
2582 	    vqs->rx_queues >= BIT(I40E_MAX_VF_QUEUES) ||
2583 	    vqs->tx_queues >= BIT(I40E_MAX_VF_QUEUES))
2584 		return false;
2585 
2586 	return true;
2587 }
2588 
2589 /**
2590  * i40e_vc_enable_queues_msg
2591  * @vf: pointer to the VF info
2592  * @msg: pointer to the msg buffer
2593  *
2594  * called from the VF to enable all or specific queue(s)
2595  **/
i40e_vc_enable_queues_msg(struct i40e_vf * vf,u8 * msg)2596 static int i40e_vc_enable_queues_msg(struct i40e_vf *vf, u8 *msg)
2597 {
2598 	struct virtchnl_queue_select *vqs =
2599 	    (struct virtchnl_queue_select *)msg;
2600 	struct i40e_pf *pf = vf->pf;
2601 	int aq_ret = 0;
2602 	int i;
2603 
2604 	if (vf->is_disabled_from_host) {
2605 		aq_ret = -EPERM;
2606 		dev_info(&pf->pdev->dev,
2607 			 "Admin has disabled VF %d, will not enable queues\n",
2608 			 vf->vf_id);
2609 		goto error_param;
2610 	}
2611 
2612 	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states)) {
2613 		aq_ret = -EINVAL;
2614 		goto error_param;
2615 	}
2616 
2617 	if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
2618 		aq_ret = -EINVAL;
2619 		goto error_param;
2620 	}
2621 
2622 	if (!i40e_vc_validate_vqs_bitmaps(vqs)) {
2623 		aq_ret = -EINVAL;
2624 		goto error_param;
2625 	}
2626 
2627 	/* Use the queue bit map sent by the VF */
2628 	if (i40e_ctrl_vf_rx_rings(pf->vsi[vf->lan_vsi_idx], vqs->rx_queues,
2629 				  true)) {
2630 		aq_ret = -EIO;
2631 		goto error_param;
2632 	}
2633 	if (i40e_ctrl_vf_tx_rings(pf->vsi[vf->lan_vsi_idx], vqs->tx_queues,
2634 				  true)) {
2635 		aq_ret = -EIO;
2636 		goto error_param;
2637 	}
2638 
2639 	/* need to start the rings for additional ADq VSI's as well */
2640 	if (vf->adq_enabled) {
2641 		/* zero belongs to LAN VSI */
2642 		for (i = 1; i < vf->num_tc; i++) {
2643 			if (i40e_vsi_start_rings(pf->vsi[vf->ch[i].vsi_idx]))
2644 				aq_ret = -EIO;
2645 		}
2646 	}
2647 
2648 error_param:
2649 	/* send the response to the VF */
2650 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_QUEUES,
2651 				       aq_ret);
2652 }
2653 
2654 /**
2655  * i40e_vc_disable_queues_msg
2656  * @vf: pointer to the VF info
2657  * @msg: pointer to the msg buffer
2658  *
2659  * called from the VF to disable all or specific
2660  * queue(s)
2661  **/
i40e_vc_disable_queues_msg(struct i40e_vf * vf,u8 * msg)2662 static int i40e_vc_disable_queues_msg(struct i40e_vf *vf, u8 *msg)
2663 {
2664 	struct virtchnl_queue_select *vqs =
2665 	    (struct virtchnl_queue_select *)msg;
2666 	struct i40e_pf *pf = vf->pf;
2667 	int aq_ret = 0;
2668 
2669 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
2670 		aq_ret = -EINVAL;
2671 		goto error_param;
2672 	}
2673 
2674 	if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
2675 		aq_ret = -EINVAL;
2676 		goto error_param;
2677 	}
2678 
2679 	if (!i40e_vc_validate_vqs_bitmaps(vqs)) {
2680 		aq_ret = -EINVAL;
2681 		goto error_param;
2682 	}
2683 
2684 	/* Use the queue bit map sent by the VF */
2685 	if (i40e_ctrl_vf_tx_rings(pf->vsi[vf->lan_vsi_idx], vqs->tx_queues,
2686 				  false)) {
2687 		aq_ret = -EIO;
2688 		goto error_param;
2689 	}
2690 	if (i40e_ctrl_vf_rx_rings(pf->vsi[vf->lan_vsi_idx], vqs->rx_queues,
2691 				  false)) {
2692 		aq_ret = -EIO;
2693 		goto error_param;
2694 	}
2695 error_param:
2696 	/* send the response to the VF */
2697 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_QUEUES,
2698 				       aq_ret);
2699 }
2700 
2701 /**
2702  * i40e_check_enough_queue - find big enough queue number
2703  * @vf: pointer to the VF info
2704  * @needed: the number of items needed
2705  *
2706  * Returns the base item index of the queue, or negative for error
2707  **/
i40e_check_enough_queue(struct i40e_vf * vf,u16 needed)2708 static int i40e_check_enough_queue(struct i40e_vf *vf, u16 needed)
2709 {
2710 	unsigned int  i, cur_queues, more, pool_size;
2711 	struct i40e_lump_tracking *pile;
2712 	struct i40e_pf *pf = vf->pf;
2713 	struct i40e_vsi *vsi;
2714 
2715 	vsi = pf->vsi[vf->lan_vsi_idx];
2716 	cur_queues = vsi->alloc_queue_pairs;
2717 
2718 	/* if current allocated queues are enough for need */
2719 	if (cur_queues >= needed)
2720 		return vsi->base_queue;
2721 
2722 	pile = pf->qp_pile;
2723 	if (cur_queues > 0) {
2724 		/* if the allocated queues are not zero
2725 		 * just check if there are enough queues for more
2726 		 * behind the allocated queues.
2727 		 */
2728 		more = needed - cur_queues;
2729 		for (i = vsi->base_queue + cur_queues;
2730 			i < pile->num_entries; i++) {
2731 			if (pile->list[i] & I40E_PILE_VALID_BIT)
2732 				break;
2733 
2734 			if (more-- == 1)
2735 				/* there is enough */
2736 				return vsi->base_queue;
2737 		}
2738 	}
2739 
2740 	pool_size = 0;
2741 	for (i = 0; i < pile->num_entries; i++) {
2742 		if (pile->list[i] & I40E_PILE_VALID_BIT) {
2743 			pool_size = 0;
2744 			continue;
2745 		}
2746 		if (needed <= ++pool_size)
2747 			/* there is enough */
2748 			return i;
2749 	}
2750 
2751 	return -ENOMEM;
2752 }
2753 
2754 /**
2755  * i40e_vc_request_queues_msg
2756  * @vf: pointer to the VF info
2757  * @msg: pointer to the msg buffer
2758  *
2759  * VFs get a default number of queues but can use this message to request a
2760  * different number.  If the request is successful, PF will reset the VF and
2761  * return 0.  If unsuccessful, PF will send message informing VF of number of
2762  * available queues and return result of sending VF a message.
2763  **/
i40e_vc_request_queues_msg(struct i40e_vf * vf,u8 * msg)2764 static int i40e_vc_request_queues_msg(struct i40e_vf *vf, u8 *msg)
2765 {
2766 	struct virtchnl_vf_res_request *vfres =
2767 		(struct virtchnl_vf_res_request *)msg;
2768 	u16 req_pairs = vfres->num_queue_pairs;
2769 	u8 cur_pairs = vf->num_queue_pairs;
2770 	struct i40e_pf *pf = vf->pf;
2771 
2772 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE))
2773 		return -EINVAL;
2774 
2775 	if (req_pairs > I40E_MAX_VF_QUEUES) {
2776 		dev_err(&pf->pdev->dev,
2777 			"VF %d tried to request more than %d queues.\n",
2778 			vf->vf_id,
2779 			I40E_MAX_VF_QUEUES);
2780 		vfres->num_queue_pairs = I40E_MAX_VF_QUEUES;
2781 	} else if (req_pairs - cur_pairs > pf->queues_left) {
2782 		dev_warn(&pf->pdev->dev,
2783 			 "VF %d requested %d more queues, but only %d left.\n",
2784 			 vf->vf_id,
2785 			 req_pairs - cur_pairs,
2786 			 pf->queues_left);
2787 		vfres->num_queue_pairs = pf->queues_left + cur_pairs;
2788 	} else if (i40e_check_enough_queue(vf, req_pairs) < 0) {
2789 		dev_warn(&pf->pdev->dev,
2790 			 "VF %d requested %d more queues, but there is not enough for it.\n",
2791 			 vf->vf_id,
2792 			 req_pairs - cur_pairs);
2793 		vfres->num_queue_pairs = cur_pairs;
2794 	} else {
2795 		/* successful request */
2796 		vf->num_req_queues = req_pairs;
2797 		i40e_vc_reset_vf(vf, true);
2798 		return 0;
2799 	}
2800 
2801 	return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_REQUEST_QUEUES, 0,
2802 				      (u8 *)vfres, sizeof(*vfres));
2803 }
2804 
2805 /**
2806  * i40e_vc_get_stats_msg
2807  * @vf: pointer to the VF info
2808  * @msg: pointer to the msg buffer
2809  *
2810  * called from the VF to get vsi stats
2811  **/
i40e_vc_get_stats_msg(struct i40e_vf * vf,u8 * msg)2812 static int i40e_vc_get_stats_msg(struct i40e_vf *vf, u8 *msg)
2813 {
2814 	struct virtchnl_queue_select *vqs =
2815 	    (struct virtchnl_queue_select *)msg;
2816 	struct i40e_pf *pf = vf->pf;
2817 	struct i40e_eth_stats stats;
2818 	int aq_ret = 0;
2819 	struct i40e_vsi *vsi;
2820 
2821 	memset(&stats, 0, sizeof(struct i40e_eth_stats));
2822 
2823 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
2824 		aq_ret = -EINVAL;
2825 		goto error_param;
2826 	}
2827 
2828 	if (!i40e_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
2829 		aq_ret = -EINVAL;
2830 		goto error_param;
2831 	}
2832 
2833 	vsi = pf->vsi[vf->lan_vsi_idx];
2834 	if (!vsi) {
2835 		aq_ret = -EINVAL;
2836 		goto error_param;
2837 	}
2838 	i40e_update_eth_stats(vsi);
2839 	stats = vsi->eth_stats;
2840 
2841 error_param:
2842 	/* send the response back to the VF */
2843 	return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_STATS, aq_ret,
2844 				      (u8 *)&stats, sizeof(stats));
2845 }
2846 
2847 /**
2848  * i40e_can_vf_change_mac
2849  * @vf: pointer to the VF info
2850  *
2851  * Return true if the VF is allowed to change its MAC filters, false otherwise
2852  */
i40e_can_vf_change_mac(struct i40e_vf * vf)2853 static bool i40e_can_vf_change_mac(struct i40e_vf *vf)
2854 {
2855 	/* If the VF MAC address has been set administratively (via the
2856 	 * ndo_set_vf_mac command), then deny permission to the VF to
2857 	 * add/delete unicast MAC addresses, unless the VF is trusted
2858 	 */
2859 	if (vf->pf_set_mac && !vf->trusted)
2860 		return false;
2861 
2862 	return true;
2863 }
2864 
2865 #define I40E_MAX_MACVLAN_PER_HW 3072
2866 #define I40E_MAX_MACVLAN_PER_PF(num_ports) (I40E_MAX_MACVLAN_PER_HW /	\
2867 	(num_ports))
2868 /* If the VF is not trusted restrict the number of MAC/VLAN it can program
2869  * MAC filters: 16 for multicast, 1 for MAC, 1 for broadcast
2870  */
2871 #define I40E_VC_MAX_MAC_ADDR_PER_VF (16 + 1 + 1)
2872 #define I40E_VC_MAX_VLAN_PER_VF 16
2873 
2874 #define I40E_VC_MAX_MACVLAN_PER_TRUSTED_VF(vf_num, num_ports)		\
2875 ({	typeof(vf_num) vf_num_ = (vf_num);				\
2876 	typeof(num_ports) num_ports_ = (num_ports);			\
2877 	((I40E_MAX_MACVLAN_PER_PF(num_ports_) - vf_num_ *		\
2878 	I40E_VC_MAX_MAC_ADDR_PER_VF) / vf_num_) +			\
2879 	I40E_VC_MAX_MAC_ADDR_PER_VF; })
2880 /**
2881  * i40e_check_vf_permission
2882  * @vf: pointer to the VF info
2883  * @al: MAC address list from virtchnl
2884  *
2885  * Check that the given list of MAC addresses is allowed. Will return -EPERM
2886  * if any address in the list is not valid. Checks the following conditions:
2887  *
2888  * 1) broadcast and zero addresses are never valid
2889  * 2) unicast addresses are not allowed if the VMM has administratively set
2890  *    the VF MAC address, unless the VF is marked as privileged.
2891  * 3) There is enough space to add all the addresses.
2892  *
2893  * Note that to guarantee consistency, it is expected this function be called
2894  * while holding the mac_filter_hash_lock, as otherwise the current number of
2895  * addresses might not be accurate.
2896  **/
i40e_check_vf_permission(struct i40e_vf * vf,struct virtchnl_ether_addr_list * al)2897 static inline int i40e_check_vf_permission(struct i40e_vf *vf,
2898 					   struct virtchnl_ether_addr_list *al)
2899 {
2900 	struct i40e_pf *pf = vf->pf;
2901 	struct i40e_vsi *vsi = pf->vsi[vf->lan_vsi_idx];
2902 	struct i40e_hw *hw = &pf->hw;
2903 	int mac2add_cnt = 0;
2904 	int i;
2905 
2906 	for (i = 0; i < al->num_elements; i++) {
2907 		struct i40e_mac_filter *f;
2908 		u8 *addr = al->list[i].addr;
2909 
2910 		if (is_broadcast_ether_addr(addr) ||
2911 		    is_zero_ether_addr(addr)) {
2912 			dev_err(&pf->pdev->dev, "invalid VF MAC addr %pM\n",
2913 				addr);
2914 			return -EINVAL;
2915 		}
2916 
2917 		/* If the host VMM administrator has set the VF MAC address
2918 		 * administratively via the ndo_set_vf_mac command then deny
2919 		 * permission to the VF to add or delete unicast MAC addresses.
2920 		 * Unless the VF is privileged and then it can do whatever.
2921 		 * The VF may request to set the MAC address filter already
2922 		 * assigned to it so do not return an error in that case.
2923 		 */
2924 		if (!i40e_can_vf_change_mac(vf) &&
2925 		    !is_multicast_ether_addr(addr) &&
2926 		    !ether_addr_equal(addr, vf->default_lan_addr.addr)) {
2927 			dev_err(&pf->pdev->dev,
2928 				"VF attempting to override administratively set MAC address, bring down and up the VF interface to resume normal operation\n");
2929 			return -EPERM;
2930 		}
2931 
2932 		/*count filters that really will be added*/
2933 		f = i40e_find_mac(vsi, addr);
2934 		if (!f)
2935 			++mac2add_cnt;
2936 	}
2937 
2938 	/* If this VF is not privileged, then we can't add more than a limited
2939 	 * number of addresses. Check to make sure that the additions do not
2940 	 * push us over the limit.
2941 	 */
2942 	if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) {
2943 		if ((i40e_count_filters(vsi) + mac2add_cnt) >
2944 		    I40E_VC_MAX_MAC_ADDR_PER_VF) {
2945 			dev_err(&pf->pdev->dev,
2946 				"Cannot add more MAC addresses, VF is not trusted, switch the VF to trusted to add more functionality\n");
2947 			return -EPERM;
2948 		}
2949 	/* If this VF is trusted, it can use more resources than untrusted.
2950 	 * However to ensure that every trusted VF has appropriate number of
2951 	 * resources, divide whole pool of resources per port and then across
2952 	 * all VFs.
2953 	 */
2954 	} else {
2955 		if ((i40e_count_filters(vsi) + mac2add_cnt) >
2956 		    I40E_VC_MAX_MACVLAN_PER_TRUSTED_VF(pf->num_alloc_vfs,
2957 						       hw->num_ports)) {
2958 			dev_err(&pf->pdev->dev,
2959 				"Cannot add more MAC addresses, trusted VF exhausted it's resources\n");
2960 			return -EPERM;
2961 		}
2962 	}
2963 	return 0;
2964 }
2965 
2966 /**
2967  * i40e_vc_ether_addr_type - get type of virtchnl_ether_addr
2968  * @vc_ether_addr: used to extract the type
2969  **/
2970 static u8
i40e_vc_ether_addr_type(struct virtchnl_ether_addr * vc_ether_addr)2971 i40e_vc_ether_addr_type(struct virtchnl_ether_addr *vc_ether_addr)
2972 {
2973 	return vc_ether_addr->type & VIRTCHNL_ETHER_ADDR_TYPE_MASK;
2974 }
2975 
2976 /**
2977  * i40e_is_vc_addr_legacy
2978  * @vc_ether_addr: VIRTCHNL structure that contains MAC and type
2979  *
2980  * check if the MAC address is from an older VF
2981  **/
2982 static bool
i40e_is_vc_addr_legacy(struct virtchnl_ether_addr * vc_ether_addr)2983 i40e_is_vc_addr_legacy(struct virtchnl_ether_addr *vc_ether_addr)
2984 {
2985 	return i40e_vc_ether_addr_type(vc_ether_addr) ==
2986 		VIRTCHNL_ETHER_ADDR_LEGACY;
2987 }
2988 
2989 /**
2990  * i40e_is_vc_addr_primary
2991  * @vc_ether_addr: VIRTCHNL structure that contains MAC and type
2992  *
2993  * check if the MAC address is the VF's primary MAC
2994  * This function should only be called when the MAC address in
2995  * virtchnl_ether_addr is a valid unicast MAC
2996  **/
2997 static bool
i40e_is_vc_addr_primary(struct virtchnl_ether_addr * vc_ether_addr)2998 i40e_is_vc_addr_primary(struct virtchnl_ether_addr *vc_ether_addr)
2999 {
3000 	return i40e_vc_ether_addr_type(vc_ether_addr) ==
3001 		VIRTCHNL_ETHER_ADDR_PRIMARY;
3002 }
3003 
3004 /**
3005  * i40e_update_vf_mac_addr
3006  * @vf: VF to update
3007  * @vc_ether_addr: structure from VIRTCHNL with MAC to add
3008  *
3009  * update the VF's cached hardware MAC if allowed
3010  **/
3011 static void
i40e_update_vf_mac_addr(struct i40e_vf * vf,struct virtchnl_ether_addr * vc_ether_addr)3012 i40e_update_vf_mac_addr(struct i40e_vf *vf,
3013 			struct virtchnl_ether_addr *vc_ether_addr)
3014 {
3015 	u8 *mac_addr = vc_ether_addr->addr;
3016 
3017 	if (!is_valid_ether_addr(mac_addr))
3018 		return;
3019 
3020 	/* If request to add MAC filter is a primary request update its default
3021 	 * MAC address with the requested one. If it is a legacy request then
3022 	 * check if current default is empty if so update the default MAC
3023 	 */
3024 	if (i40e_is_vc_addr_primary(vc_ether_addr)) {
3025 		ether_addr_copy(vf->default_lan_addr.addr, mac_addr);
3026 	} else if (i40e_is_vc_addr_legacy(vc_ether_addr)) {
3027 		if (is_zero_ether_addr(vf->default_lan_addr.addr))
3028 			ether_addr_copy(vf->default_lan_addr.addr, mac_addr);
3029 	}
3030 }
3031 
3032 /**
3033  * i40e_vc_add_mac_addr_msg
3034  * @vf: pointer to the VF info
3035  * @msg: pointer to the msg buffer
3036  *
3037  * add guest mac address filter
3038  **/
i40e_vc_add_mac_addr_msg(struct i40e_vf * vf,u8 * msg)3039 static int i40e_vc_add_mac_addr_msg(struct i40e_vf *vf, u8 *msg)
3040 {
3041 	struct virtchnl_ether_addr_list *al =
3042 	    (struct virtchnl_ether_addr_list *)msg;
3043 	struct i40e_pf *pf = vf->pf;
3044 	struct i40e_vsi *vsi = NULL;
3045 	int ret = 0;
3046 	int i;
3047 
3048 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
3049 	    !i40e_vc_isvalid_vsi_id(vf, al->vsi_id)) {
3050 		ret = -EINVAL;
3051 		goto error_param;
3052 	}
3053 
3054 	vsi = pf->vsi[vf->lan_vsi_idx];
3055 
3056 	/* Lock once, because all function inside for loop accesses VSI's
3057 	 * MAC filter list which needs to be protected using same lock.
3058 	 */
3059 	spin_lock_bh(&vsi->mac_filter_hash_lock);
3060 
3061 	ret = i40e_check_vf_permission(vf, al);
3062 	if (ret) {
3063 		spin_unlock_bh(&vsi->mac_filter_hash_lock);
3064 		goto error_param;
3065 	}
3066 
3067 	/* add new addresses to the list */
3068 	for (i = 0; i < al->num_elements; i++) {
3069 		struct i40e_mac_filter *f;
3070 
3071 		f = i40e_find_mac(vsi, al->list[i].addr);
3072 		if (!f) {
3073 			f = i40e_add_mac_filter(vsi, al->list[i].addr);
3074 
3075 			if (!f) {
3076 				dev_err(&pf->pdev->dev,
3077 					"Unable to add MAC filter %pM for VF %d\n",
3078 					al->list[i].addr, vf->vf_id);
3079 				ret = -EINVAL;
3080 				spin_unlock_bh(&vsi->mac_filter_hash_lock);
3081 				goto error_param;
3082 			}
3083 		}
3084 		i40e_update_vf_mac_addr(vf, &al->list[i]);
3085 	}
3086 	spin_unlock_bh(&vsi->mac_filter_hash_lock);
3087 
3088 	/* program the updated filter list */
3089 	ret = i40e_sync_vsi_filters(vsi);
3090 	if (ret)
3091 		dev_err(&pf->pdev->dev, "Unable to program VF %d MAC filters, error %d\n",
3092 			vf->vf_id, ret);
3093 
3094 error_param:
3095 	/* send the response to the VF */
3096 	return i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_ETH_ADDR,
3097 				      ret, NULL, 0);
3098 }
3099 
3100 /**
3101  * i40e_vc_del_mac_addr_msg
3102  * @vf: pointer to the VF info
3103  * @msg: pointer to the msg buffer
3104  *
3105  * remove guest mac address filter
3106  **/
i40e_vc_del_mac_addr_msg(struct i40e_vf * vf,u8 * msg)3107 static int i40e_vc_del_mac_addr_msg(struct i40e_vf *vf, u8 *msg)
3108 {
3109 	struct virtchnl_ether_addr_list *al =
3110 	    (struct virtchnl_ether_addr_list *)msg;
3111 	bool was_unimac_deleted = false;
3112 	struct i40e_pf *pf = vf->pf;
3113 	struct i40e_vsi *vsi = NULL;
3114 	int ret = 0;
3115 	int i;
3116 
3117 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
3118 	    !i40e_vc_isvalid_vsi_id(vf, al->vsi_id)) {
3119 		ret = -EINVAL;
3120 		goto error_param;
3121 	}
3122 
3123 	for (i = 0; i < al->num_elements; i++) {
3124 		if (is_broadcast_ether_addr(al->list[i].addr) ||
3125 		    is_zero_ether_addr(al->list[i].addr)) {
3126 			dev_err(&pf->pdev->dev, "Invalid MAC addr %pM for VF %d\n",
3127 				al->list[i].addr, vf->vf_id);
3128 			ret = -EINVAL;
3129 			goto error_param;
3130 		}
3131 	}
3132 	vsi = pf->vsi[vf->lan_vsi_idx];
3133 
3134 	spin_lock_bh(&vsi->mac_filter_hash_lock);
3135 	/* delete addresses from the list */
3136 	for (i = 0; i < al->num_elements; i++) {
3137 		const u8 *addr = al->list[i].addr;
3138 
3139 		/* Allow to delete VF primary MAC only if it was not set
3140 		 * administratively by PF or if VF is trusted.
3141 		 */
3142 		if (ether_addr_equal(addr, vf->default_lan_addr.addr)) {
3143 			if (i40e_can_vf_change_mac(vf))
3144 				was_unimac_deleted = true;
3145 			else
3146 				continue;
3147 		}
3148 
3149 		if (i40e_del_mac_filter(vsi, al->list[i].addr)) {
3150 			ret = -EINVAL;
3151 			spin_unlock_bh(&vsi->mac_filter_hash_lock);
3152 			goto error_param;
3153 		}
3154 	}
3155 
3156 	spin_unlock_bh(&vsi->mac_filter_hash_lock);
3157 
3158 	if (was_unimac_deleted)
3159 		eth_zero_addr(vf->default_lan_addr.addr);
3160 
3161 	/* program the updated filter list */
3162 	ret = i40e_sync_vsi_filters(vsi);
3163 	if (ret)
3164 		dev_err(&pf->pdev->dev, "Unable to program VF %d MAC filters, error %d\n",
3165 			vf->vf_id, ret);
3166 
3167 	if (vf->trusted && was_unimac_deleted) {
3168 		struct i40e_mac_filter *f;
3169 		struct hlist_node *h;
3170 		u8 *macaddr = NULL;
3171 		int bkt;
3172 
3173 		/* set last unicast mac address as default */
3174 		spin_lock_bh(&vsi->mac_filter_hash_lock);
3175 		hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist) {
3176 			if (is_valid_ether_addr(f->macaddr))
3177 				macaddr = f->macaddr;
3178 		}
3179 		if (macaddr)
3180 			ether_addr_copy(vf->default_lan_addr.addr, macaddr);
3181 		spin_unlock_bh(&vsi->mac_filter_hash_lock);
3182 	}
3183 error_param:
3184 	/* send the response to the VF */
3185 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_ETH_ADDR, ret);
3186 }
3187 
3188 /**
3189  * i40e_vc_add_vlan_msg
3190  * @vf: pointer to the VF info
3191  * @msg: pointer to the msg buffer
3192  *
3193  * program guest vlan id
3194  **/
i40e_vc_add_vlan_msg(struct i40e_vf * vf,u8 * msg)3195 static int i40e_vc_add_vlan_msg(struct i40e_vf *vf, u8 *msg)
3196 {
3197 	struct virtchnl_vlan_filter_list *vfl =
3198 	    (struct virtchnl_vlan_filter_list *)msg;
3199 	struct i40e_pf *pf = vf->pf;
3200 	struct i40e_vsi *vsi = NULL;
3201 	int aq_ret = 0;
3202 	int i;
3203 
3204 	if ((vf->num_vlan >= I40E_VC_MAX_VLAN_PER_VF) &&
3205 	    !test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) {
3206 		dev_err(&pf->pdev->dev,
3207 			"VF is not trusted, switch the VF to trusted to add more VLAN addresses\n");
3208 		goto error_param;
3209 	}
3210 	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
3211 	    !i40e_vc_isvalid_vsi_id(vf, vfl->vsi_id)) {
3212 		aq_ret = -EINVAL;
3213 		goto error_param;
3214 	}
3215 
3216 	for (i = 0; i < vfl->num_elements; i++) {
3217 		if (vfl->vlan_id[i] > I40E_MAX_VLANID) {
3218 			aq_ret = -EINVAL;
3219 			dev_err(&pf->pdev->dev,
3220 				"invalid VF VLAN id %d\n", vfl->vlan_id[i]);
3221 			goto error_param;
3222 		}
3223 	}
3224 	vsi = pf->vsi[vf->lan_vsi_idx];
3225 	if (vsi->info.pvid) {
3226 		aq_ret = -EINVAL;
3227 		goto error_param;
3228 	}
3229 
3230 	i40e_vlan_stripping_enable(vsi);
3231 	for (i = 0; i < vfl->num_elements; i++) {
3232 		/* add new VLAN filter */
3233 		int ret = i40e_vsi_add_vlan(vsi, vfl->vlan_id[i]);
3234 		if (!ret)
3235 			vf->num_vlan++;
3236 
3237 		if (test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states))
3238 			i40e_aq_set_vsi_uc_promisc_on_vlan(&pf->hw, vsi->seid,
3239 							   true,
3240 							   vfl->vlan_id[i],
3241 							   NULL);
3242 		if (test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states))
3243 			i40e_aq_set_vsi_mc_promisc_on_vlan(&pf->hw, vsi->seid,
3244 							   true,
3245 							   vfl->vlan_id[i],
3246 							   NULL);
3247 
3248 		if (ret)
3249 			dev_err(&pf->pdev->dev,
3250 				"Unable to add VLAN filter %d for VF %d, error %d\n",
3251 				vfl->vlan_id[i], vf->vf_id, ret);
3252 	}
3253 
3254 error_param:
3255 	/* send the response to the VF */
3256 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ADD_VLAN, aq_ret);
3257 }
3258 
3259 /**
3260  * i40e_vc_remove_vlan_msg
3261  * @vf: pointer to the VF info
3262  * @msg: pointer to the msg buffer
3263  *
3264  * remove programmed guest vlan id
3265  **/
i40e_vc_remove_vlan_msg(struct i40e_vf * vf,u8 * msg)3266 static int i40e_vc_remove_vlan_msg(struct i40e_vf *vf, u8 *msg)
3267 {
3268 	struct virtchnl_vlan_filter_list *vfl =
3269 	    (struct virtchnl_vlan_filter_list *)msg;
3270 	struct i40e_pf *pf = vf->pf;
3271 	struct i40e_vsi *vsi = NULL;
3272 	int aq_ret = 0;
3273 	int i;
3274 
3275 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
3276 	    !i40e_vc_isvalid_vsi_id(vf, vfl->vsi_id)) {
3277 		aq_ret = -EINVAL;
3278 		goto error_param;
3279 	}
3280 
3281 	for (i = 0; i < vfl->num_elements; i++) {
3282 		if (vfl->vlan_id[i] > I40E_MAX_VLANID) {
3283 			aq_ret = -EINVAL;
3284 			goto error_param;
3285 		}
3286 	}
3287 
3288 	vsi = pf->vsi[vf->lan_vsi_idx];
3289 	if (vsi->info.pvid) {
3290 		if (vfl->num_elements > 1 || vfl->vlan_id[0])
3291 			aq_ret = -EINVAL;
3292 		goto error_param;
3293 	}
3294 
3295 	for (i = 0; i < vfl->num_elements; i++) {
3296 		i40e_vsi_kill_vlan(vsi, vfl->vlan_id[i]);
3297 		vf->num_vlan--;
3298 
3299 		if (test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states))
3300 			i40e_aq_set_vsi_uc_promisc_on_vlan(&pf->hw, vsi->seid,
3301 							   false,
3302 							   vfl->vlan_id[i],
3303 							   NULL);
3304 		if (test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states))
3305 			i40e_aq_set_vsi_mc_promisc_on_vlan(&pf->hw, vsi->seid,
3306 							   false,
3307 							   vfl->vlan_id[i],
3308 							   NULL);
3309 	}
3310 
3311 error_param:
3312 	/* send the response to the VF */
3313 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_VLAN, aq_ret);
3314 }
3315 
3316 /**
3317  * i40e_vc_rdma_msg
3318  * @vf: pointer to the VF info
3319  * @msg: pointer to the msg buffer
3320  * @msglen: msg length
3321  *
3322  * called from the VF for the iwarp msgs
3323  **/
i40e_vc_rdma_msg(struct i40e_vf * vf,u8 * msg,u16 msglen)3324 static int i40e_vc_rdma_msg(struct i40e_vf *vf, u8 *msg, u16 msglen)
3325 {
3326 	struct i40e_pf *pf = vf->pf;
3327 	struct i40e_vsi *main_vsi;
3328 	int aq_ret = 0;
3329 	int abs_vf_id;
3330 
3331 	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
3332 	    !test_bit(I40E_VF_STATE_RDMAENA, &vf->vf_states)) {
3333 		aq_ret = -EINVAL;
3334 		goto error_param;
3335 	}
3336 
3337 	main_vsi = i40e_pf_get_main_vsi(pf);
3338 	abs_vf_id = vf->vf_id + pf->hw.func_caps.vf_base_id;
3339 	i40e_notify_client_of_vf_msg(main_vsi, abs_vf_id, msg, msglen);
3340 
3341 error_param:
3342 	/* send the response to the VF */
3343 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_RDMA,
3344 				       aq_ret);
3345 }
3346 
3347 /**
3348  * i40e_vc_rdma_qvmap_msg
3349  * @vf: pointer to the VF info
3350  * @msg: pointer to the msg buffer
3351  * @config: config qvmap or release it
3352  *
3353  * called from the VF for the iwarp msgs
3354  **/
i40e_vc_rdma_qvmap_msg(struct i40e_vf * vf,u8 * msg,bool config)3355 static int i40e_vc_rdma_qvmap_msg(struct i40e_vf *vf, u8 *msg, bool config)
3356 {
3357 	struct virtchnl_rdma_qvlist_info *qvlist_info =
3358 				(struct virtchnl_rdma_qvlist_info *)msg;
3359 	int aq_ret = 0;
3360 
3361 	if (!test_bit(I40E_VF_STATE_ACTIVE, &vf->vf_states) ||
3362 	    !test_bit(I40E_VF_STATE_RDMAENA, &vf->vf_states)) {
3363 		aq_ret = -EINVAL;
3364 		goto error_param;
3365 	}
3366 
3367 	if (config) {
3368 		if (i40e_config_rdma_qvlist(vf, qvlist_info))
3369 			aq_ret = -EINVAL;
3370 	} else {
3371 		i40e_release_rdma_qvlist(vf);
3372 	}
3373 
3374 error_param:
3375 	/* send the response to the VF */
3376 	return i40e_vc_send_resp_to_vf(vf,
3377 			       config ? VIRTCHNL_OP_CONFIG_RDMA_IRQ_MAP :
3378 			       VIRTCHNL_OP_RELEASE_RDMA_IRQ_MAP,
3379 			       aq_ret);
3380 }
3381 
3382 /**
3383  * i40e_vc_config_rss_key
3384  * @vf: pointer to the VF info
3385  * @msg: pointer to the msg buffer
3386  *
3387  * Configure the VF's RSS key
3388  **/
i40e_vc_config_rss_key(struct i40e_vf * vf,u8 * msg)3389 static int i40e_vc_config_rss_key(struct i40e_vf *vf, u8 *msg)
3390 {
3391 	struct virtchnl_rss_key *vrk =
3392 		(struct virtchnl_rss_key *)msg;
3393 	struct i40e_pf *pf = vf->pf;
3394 	struct i40e_vsi *vsi = NULL;
3395 	int aq_ret = 0;
3396 
3397 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
3398 	    !i40e_vc_isvalid_vsi_id(vf, vrk->vsi_id) ||
3399 	    vrk->key_len != I40E_HKEY_ARRAY_SIZE) {
3400 		aq_ret = -EINVAL;
3401 		goto err;
3402 	}
3403 
3404 	vsi = pf->vsi[vf->lan_vsi_idx];
3405 	aq_ret = i40e_config_rss(vsi, vrk->key, NULL, 0);
3406 err:
3407 	/* send the response to the VF */
3408 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_KEY,
3409 				       aq_ret);
3410 }
3411 
3412 /**
3413  * i40e_vc_config_rss_lut
3414  * @vf: pointer to the VF info
3415  * @msg: pointer to the msg buffer
3416  *
3417  * Configure the VF's RSS LUT
3418  **/
i40e_vc_config_rss_lut(struct i40e_vf * vf,u8 * msg)3419 static int i40e_vc_config_rss_lut(struct i40e_vf *vf, u8 *msg)
3420 {
3421 	struct virtchnl_rss_lut *vrl =
3422 		(struct virtchnl_rss_lut *)msg;
3423 	struct i40e_pf *pf = vf->pf;
3424 	struct i40e_vsi *vsi = NULL;
3425 	int aq_ret = 0;
3426 	u16 i;
3427 
3428 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE) ||
3429 	    !i40e_vc_isvalid_vsi_id(vf, vrl->vsi_id) ||
3430 	    vrl->lut_entries != I40E_VF_HLUT_ARRAY_SIZE) {
3431 		aq_ret = -EINVAL;
3432 		goto err;
3433 	}
3434 
3435 	for (i = 0; i < vrl->lut_entries; i++)
3436 		if (vrl->lut[i] >= vf->num_queue_pairs) {
3437 			aq_ret = -EINVAL;
3438 			goto err;
3439 		}
3440 
3441 	vsi = pf->vsi[vf->lan_vsi_idx];
3442 	aq_ret = i40e_config_rss(vsi, NULL, vrl->lut, I40E_VF_HLUT_ARRAY_SIZE);
3443 	/* send the response to the VF */
3444 err:
3445 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_LUT,
3446 				       aq_ret);
3447 }
3448 
3449 /**
3450  * i40e_vc_get_rss_hena
3451  * @vf: pointer to the VF info
3452  * @msg: pointer to the msg buffer
3453  *
3454  * Return the RSS HENA bits allowed by the hardware
3455  **/
i40e_vc_get_rss_hena(struct i40e_vf * vf,u8 * msg)3456 static int i40e_vc_get_rss_hena(struct i40e_vf *vf, u8 *msg)
3457 {
3458 	struct virtchnl_rss_hena *vrh = NULL;
3459 	struct i40e_pf *pf = vf->pf;
3460 	int aq_ret = 0;
3461 	int len = 0;
3462 
3463 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
3464 		aq_ret = -EINVAL;
3465 		goto err;
3466 	}
3467 	len = sizeof(struct virtchnl_rss_hena);
3468 
3469 	vrh = kzalloc(len, GFP_KERNEL);
3470 	if (!vrh) {
3471 		aq_ret = -ENOMEM;
3472 		len = 0;
3473 		goto err;
3474 	}
3475 	vrh->hena = i40e_pf_get_default_rss_hena(pf);
3476 err:
3477 	/* send the response back to the VF */
3478 	aq_ret = i40e_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_RSS_HENA_CAPS,
3479 					aq_ret, (u8 *)vrh, len);
3480 	kfree(vrh);
3481 	return aq_ret;
3482 }
3483 
3484 /**
3485  * i40e_vc_set_rss_hena
3486  * @vf: pointer to the VF info
3487  * @msg: pointer to the msg buffer
3488  *
3489  * Set the RSS HENA bits for the VF
3490  **/
i40e_vc_set_rss_hena(struct i40e_vf * vf,u8 * msg)3491 static int i40e_vc_set_rss_hena(struct i40e_vf *vf, u8 *msg)
3492 {
3493 	struct virtchnl_rss_hena *vrh =
3494 		(struct virtchnl_rss_hena *)msg;
3495 	struct i40e_pf *pf = vf->pf;
3496 	struct i40e_hw *hw = &pf->hw;
3497 	int aq_ret = 0;
3498 
3499 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
3500 		aq_ret = -EINVAL;
3501 		goto err;
3502 	}
3503 	i40e_write_rx_ctl(hw, I40E_VFQF_HENA1(0, vf->vf_id), (u32)vrh->hena);
3504 	i40e_write_rx_ctl(hw, I40E_VFQF_HENA1(1, vf->vf_id),
3505 			  (u32)(vrh->hena >> 32));
3506 
3507 	/* send the response to the VF */
3508 err:
3509 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_SET_RSS_HENA, aq_ret);
3510 }
3511 
3512 /**
3513  * i40e_vc_enable_vlan_stripping
3514  * @vf: pointer to the VF info
3515  * @msg: pointer to the msg buffer
3516  *
3517  * Enable vlan header stripping for the VF
3518  **/
i40e_vc_enable_vlan_stripping(struct i40e_vf * vf,u8 * msg)3519 static int i40e_vc_enable_vlan_stripping(struct i40e_vf *vf, u8 *msg)
3520 {
3521 	struct i40e_vsi *vsi;
3522 	int aq_ret = 0;
3523 
3524 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
3525 		aq_ret = -EINVAL;
3526 		goto err;
3527 	}
3528 
3529 	vsi = vf->pf->vsi[vf->lan_vsi_idx];
3530 	i40e_vlan_stripping_enable(vsi);
3531 
3532 	/* send the response to the VF */
3533 err:
3534 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING,
3535 				       aq_ret);
3536 }
3537 
3538 /**
3539  * i40e_vc_disable_vlan_stripping
3540  * @vf: pointer to the VF info
3541  * @msg: pointer to the msg buffer
3542  *
3543  * Disable vlan header stripping for the VF
3544  **/
i40e_vc_disable_vlan_stripping(struct i40e_vf * vf,u8 * msg)3545 static int i40e_vc_disable_vlan_stripping(struct i40e_vf *vf, u8 *msg)
3546 {
3547 	struct i40e_vsi *vsi;
3548 	int aq_ret = 0;
3549 
3550 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
3551 		aq_ret = -EINVAL;
3552 		goto err;
3553 	}
3554 
3555 	vsi = vf->pf->vsi[vf->lan_vsi_idx];
3556 	i40e_vlan_stripping_disable(vsi);
3557 
3558 	/* send the response to the VF */
3559 err:
3560 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING,
3561 				       aq_ret);
3562 }
3563 
3564 /**
3565  * i40e_validate_cloud_filter
3566  * @vf: pointer to VF structure
3567  * @tc_filter: pointer to filter requested
3568  *
3569  * This function validates cloud filter programmed as TC filter for ADq
3570  **/
i40e_validate_cloud_filter(struct i40e_vf * vf,struct virtchnl_filter * tc_filter)3571 static int i40e_validate_cloud_filter(struct i40e_vf *vf,
3572 				      struct virtchnl_filter *tc_filter)
3573 {
3574 	struct virtchnl_l4_spec mask = tc_filter->mask.tcp_spec;
3575 	struct virtchnl_l4_spec data = tc_filter->data.tcp_spec;
3576 	struct i40e_pf *pf = vf->pf;
3577 	struct i40e_vsi *vsi = NULL;
3578 	struct i40e_mac_filter *f;
3579 	struct hlist_node *h;
3580 	bool found = false;
3581 	int bkt;
3582 
3583 	if (tc_filter->action != VIRTCHNL_ACTION_TC_REDIRECT) {
3584 		dev_info(&pf->pdev->dev,
3585 			 "VF %d: ADQ doesn't support this action (%d)\n",
3586 			 vf->vf_id, tc_filter->action);
3587 		goto err;
3588 	}
3589 
3590 	/* action_meta is TC number here to which the filter is applied */
3591 	if (!tc_filter->action_meta ||
3592 	    tc_filter->action_meta > vf->num_tc) {
3593 		dev_info(&pf->pdev->dev, "VF %d: Invalid TC number %u\n",
3594 			 vf->vf_id, tc_filter->action_meta);
3595 		goto err;
3596 	}
3597 
3598 	/* Check filter if it's programmed for advanced mode or basic mode.
3599 	 * There are two ADq modes (for VF only),
3600 	 * 1. Basic mode: intended to allow as many filter options as possible
3601 	 *		  to be added to a VF in Non-trusted mode. Main goal is
3602 	 *		  to add filters to its own MAC and VLAN id.
3603 	 * 2. Advanced mode: is for allowing filters to be applied other than
3604 	 *		  its own MAC or VLAN. This mode requires the VF to be
3605 	 *		  Trusted.
3606 	 */
3607 	if (mask.dst_mac[0] && !mask.dst_ip[0]) {
3608 		vsi = pf->vsi[vf->lan_vsi_idx];
3609 		f = i40e_find_mac(vsi, data.dst_mac);
3610 
3611 		if (!f) {
3612 			dev_info(&pf->pdev->dev,
3613 				 "Destination MAC %pM doesn't belong to VF %d\n",
3614 				 data.dst_mac, vf->vf_id);
3615 			goto err;
3616 		}
3617 
3618 		if (mask.vlan_id) {
3619 			hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f,
3620 					   hlist) {
3621 				if (f->vlan == ntohs(data.vlan_id)) {
3622 					found = true;
3623 					break;
3624 				}
3625 			}
3626 			if (!found) {
3627 				dev_info(&pf->pdev->dev,
3628 					 "VF %d doesn't have any VLAN id %u\n",
3629 					 vf->vf_id, ntohs(data.vlan_id));
3630 				goto err;
3631 			}
3632 		}
3633 	} else {
3634 		/* Check if VF is trusted */
3635 		if (!test_bit(I40E_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps)) {
3636 			dev_err(&pf->pdev->dev,
3637 				"VF %d not trusted, make VF trusted to add advanced mode ADq cloud filters\n",
3638 				vf->vf_id);
3639 			return -EIO;
3640 		}
3641 	}
3642 
3643 	if (mask.dst_mac[0] & data.dst_mac[0]) {
3644 		if (is_broadcast_ether_addr(data.dst_mac) ||
3645 		    is_zero_ether_addr(data.dst_mac)) {
3646 			dev_info(&pf->pdev->dev, "VF %d: Invalid Dest MAC addr %pM\n",
3647 				 vf->vf_id, data.dst_mac);
3648 			goto err;
3649 		}
3650 	}
3651 
3652 	if (mask.src_mac[0] & data.src_mac[0]) {
3653 		if (is_broadcast_ether_addr(data.src_mac) ||
3654 		    is_zero_ether_addr(data.src_mac)) {
3655 			dev_info(&pf->pdev->dev, "VF %d: Invalid Source MAC addr %pM\n",
3656 				 vf->vf_id, data.src_mac);
3657 			goto err;
3658 		}
3659 	}
3660 
3661 	if (mask.dst_port & data.dst_port) {
3662 		if (!data.dst_port) {
3663 			dev_info(&pf->pdev->dev, "VF %d: Invalid Dest port\n",
3664 				 vf->vf_id);
3665 			goto err;
3666 		}
3667 	}
3668 
3669 	if (mask.src_port & data.src_port) {
3670 		if (!data.src_port) {
3671 			dev_info(&pf->pdev->dev, "VF %d: Invalid Source port\n",
3672 				 vf->vf_id);
3673 			goto err;
3674 		}
3675 	}
3676 
3677 	if (tc_filter->flow_type != VIRTCHNL_TCP_V6_FLOW &&
3678 	    tc_filter->flow_type != VIRTCHNL_TCP_V4_FLOW) {
3679 		dev_info(&pf->pdev->dev, "VF %d: Invalid Flow type\n",
3680 			 vf->vf_id);
3681 		goto err;
3682 	}
3683 
3684 	if (mask.vlan_id & data.vlan_id) {
3685 		if (ntohs(data.vlan_id) > I40E_MAX_VLANID) {
3686 			dev_info(&pf->pdev->dev, "VF %d: invalid VLAN ID\n",
3687 				 vf->vf_id);
3688 			goto err;
3689 		}
3690 	}
3691 
3692 	return 0;
3693 err:
3694 	return -EIO;
3695 }
3696 
3697 /**
3698  * i40e_find_vsi_from_seid - searches for the vsi with the given seid
3699  * @vf: pointer to the VF info
3700  * @seid: seid of the vsi it is searching for
3701  **/
i40e_find_vsi_from_seid(struct i40e_vf * vf,u16 seid)3702 static struct i40e_vsi *i40e_find_vsi_from_seid(struct i40e_vf *vf, u16 seid)
3703 {
3704 	struct i40e_pf *pf = vf->pf;
3705 	struct i40e_vsi *vsi = NULL;
3706 	int i;
3707 
3708 	for (i = 0; i < vf->num_tc ; i++) {
3709 		vsi = i40e_find_vsi_from_id(pf, vf->ch[i].vsi_id);
3710 		if (vsi && vsi->seid == seid)
3711 			return vsi;
3712 	}
3713 	return NULL;
3714 }
3715 
3716 /**
3717  * i40e_del_all_cloud_filters
3718  * @vf: pointer to the VF info
3719  *
3720  * This function deletes all cloud filters
3721  **/
i40e_del_all_cloud_filters(struct i40e_vf * vf)3722 static void i40e_del_all_cloud_filters(struct i40e_vf *vf)
3723 {
3724 	struct i40e_cloud_filter *cfilter = NULL;
3725 	struct i40e_pf *pf = vf->pf;
3726 	struct i40e_vsi *vsi = NULL;
3727 	struct hlist_node *node;
3728 	int ret;
3729 
3730 	hlist_for_each_entry_safe(cfilter, node,
3731 				  &vf->cloud_filter_list, cloud_node) {
3732 		vsi = i40e_find_vsi_from_seid(vf, cfilter->seid);
3733 
3734 		if (!vsi) {
3735 			dev_err(&pf->pdev->dev, "VF %d: no VSI found for matching %u seid, can't delete cloud filter\n",
3736 				vf->vf_id, cfilter->seid);
3737 			continue;
3738 		}
3739 
3740 		if (cfilter->dst_port)
3741 			ret = i40e_add_del_cloud_filter_big_buf(vsi, cfilter,
3742 								false);
3743 		else
3744 			ret = i40e_add_del_cloud_filter(vsi, cfilter, false);
3745 		if (ret)
3746 			dev_err(&pf->pdev->dev,
3747 				"VF %d: Failed to delete cloud filter, err %pe aq_err %s\n",
3748 				vf->vf_id, ERR_PTR(ret),
3749 				i40e_aq_str(&pf->hw,
3750 					    pf->hw.aq.asq_last_status));
3751 
3752 		hlist_del(&cfilter->cloud_node);
3753 		kfree(cfilter);
3754 		vf->num_cloud_filters--;
3755 	}
3756 }
3757 
3758 /**
3759  * i40e_vc_del_cloud_filter
3760  * @vf: pointer to the VF info
3761  * @msg: pointer to the msg buffer
3762  *
3763  * This function deletes a cloud filter programmed as TC filter for ADq
3764  **/
i40e_vc_del_cloud_filter(struct i40e_vf * vf,u8 * msg)3765 static int i40e_vc_del_cloud_filter(struct i40e_vf *vf, u8 *msg)
3766 {
3767 	struct virtchnl_filter *vcf = (struct virtchnl_filter *)msg;
3768 	struct virtchnl_l4_spec mask = vcf->mask.tcp_spec;
3769 	struct virtchnl_l4_spec tcf = vcf->data.tcp_spec;
3770 	struct i40e_cloud_filter cfilter, *cf = NULL;
3771 	struct i40e_pf *pf = vf->pf;
3772 	struct i40e_vsi *vsi = NULL;
3773 	struct hlist_node *node;
3774 	int aq_ret = 0;
3775 	int i, ret;
3776 
3777 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
3778 		aq_ret = -EINVAL;
3779 		goto err;
3780 	}
3781 
3782 	if (!vf->adq_enabled) {
3783 		dev_info(&pf->pdev->dev,
3784 			 "VF %d: ADq not enabled, can't apply cloud filter\n",
3785 			 vf->vf_id);
3786 		aq_ret = -EINVAL;
3787 		goto err;
3788 	}
3789 
3790 	if (i40e_validate_cloud_filter(vf, vcf)) {
3791 		dev_info(&pf->pdev->dev,
3792 			 "VF %d: Invalid input, can't apply cloud filter\n",
3793 			 vf->vf_id);
3794 		aq_ret = -EINVAL;
3795 		goto err;
3796 	}
3797 
3798 	memset(&cfilter, 0, sizeof(cfilter));
3799 	/* parse destination mac address */
3800 	for (i = 0; i < ETH_ALEN; i++)
3801 		cfilter.dst_mac[i] = mask.dst_mac[i] & tcf.dst_mac[i];
3802 
3803 	/* parse source mac address */
3804 	for (i = 0; i < ETH_ALEN; i++)
3805 		cfilter.src_mac[i] = mask.src_mac[i] & tcf.src_mac[i];
3806 
3807 	cfilter.vlan_id = mask.vlan_id & tcf.vlan_id;
3808 	cfilter.dst_port = mask.dst_port & tcf.dst_port;
3809 	cfilter.src_port = mask.src_port & tcf.src_port;
3810 
3811 	switch (vcf->flow_type) {
3812 	case VIRTCHNL_TCP_V4_FLOW:
3813 		cfilter.n_proto = ETH_P_IP;
3814 		if (mask.dst_ip[0] & tcf.dst_ip[0])
3815 			memcpy(&cfilter.ip.v4.dst_ip, tcf.dst_ip,
3816 			       ARRAY_SIZE(tcf.dst_ip));
3817 		else if (mask.src_ip[0] & tcf.dst_ip[0])
3818 			memcpy(&cfilter.ip.v4.src_ip, tcf.src_ip,
3819 			       ARRAY_SIZE(tcf.dst_ip));
3820 		break;
3821 	case VIRTCHNL_TCP_V6_FLOW:
3822 		cfilter.n_proto = ETH_P_IPV6;
3823 		if (mask.dst_ip[3] & tcf.dst_ip[3])
3824 			memcpy(&cfilter.ip.v6.dst_ip6, tcf.dst_ip,
3825 			       sizeof(cfilter.ip.v6.dst_ip6));
3826 		if (mask.src_ip[3] & tcf.src_ip[3])
3827 			memcpy(&cfilter.ip.v6.src_ip6, tcf.src_ip,
3828 			       sizeof(cfilter.ip.v6.src_ip6));
3829 		break;
3830 	default:
3831 		/* TC filter can be configured based on different combinations
3832 		 * and in this case IP is not a part of filter config
3833 		 */
3834 		dev_info(&pf->pdev->dev, "VF %d: Flow type not configured\n",
3835 			 vf->vf_id);
3836 	}
3837 
3838 	/* get the vsi to which the tc belongs to */
3839 	vsi = pf->vsi[vf->ch[vcf->action_meta].vsi_idx];
3840 	cfilter.seid = vsi->seid;
3841 	cfilter.flags = vcf->field_flags;
3842 
3843 	/* Deleting TC filter */
3844 	if (tcf.dst_port)
3845 		ret = i40e_add_del_cloud_filter_big_buf(vsi, &cfilter, false);
3846 	else
3847 		ret = i40e_add_del_cloud_filter(vsi, &cfilter, false);
3848 	if (ret) {
3849 		dev_err(&pf->pdev->dev,
3850 			"VF %d: Failed to delete cloud filter, err %pe aq_err %s\n",
3851 			vf->vf_id, ERR_PTR(ret),
3852 			i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status));
3853 		goto err;
3854 	}
3855 
3856 	hlist_for_each_entry_safe(cf, node,
3857 				  &vf->cloud_filter_list, cloud_node) {
3858 		if (cf->seid != cfilter.seid)
3859 			continue;
3860 		if (mask.dst_port)
3861 			if (cfilter.dst_port != cf->dst_port)
3862 				continue;
3863 		if (mask.dst_mac[0])
3864 			if (!ether_addr_equal(cf->src_mac, cfilter.src_mac))
3865 				continue;
3866 		/* for ipv4 data to be valid, only first byte of mask is set */
3867 		if (cfilter.n_proto == ETH_P_IP && mask.dst_ip[0])
3868 			if (memcmp(&cfilter.ip.v4.dst_ip, &cf->ip.v4.dst_ip,
3869 				   ARRAY_SIZE(tcf.dst_ip)))
3870 				continue;
3871 		/* for ipv6, mask is set for all sixteen bytes (4 words) */
3872 		if (cfilter.n_proto == ETH_P_IPV6 && mask.dst_ip[3])
3873 			if (memcmp(&cfilter.ip.v6.dst_ip6, &cf->ip.v6.dst_ip6,
3874 				   sizeof(cfilter.ip.v6.src_ip6)))
3875 				continue;
3876 		if (mask.vlan_id)
3877 			if (cfilter.vlan_id != cf->vlan_id)
3878 				continue;
3879 
3880 		hlist_del(&cf->cloud_node);
3881 		kfree(cf);
3882 		vf->num_cloud_filters--;
3883 	}
3884 
3885 err:
3886 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DEL_CLOUD_FILTER,
3887 				       aq_ret);
3888 }
3889 
3890 /**
3891  * i40e_vc_add_cloud_filter
3892  * @vf: pointer to the VF info
3893  * @msg: pointer to the msg buffer
3894  *
3895  * This function adds a cloud filter programmed as TC filter for ADq
3896  **/
i40e_vc_add_cloud_filter(struct i40e_vf * vf,u8 * msg)3897 static int i40e_vc_add_cloud_filter(struct i40e_vf *vf, u8 *msg)
3898 {
3899 	struct virtchnl_filter *vcf = (struct virtchnl_filter *)msg;
3900 	struct virtchnl_l4_spec mask = vcf->mask.tcp_spec;
3901 	struct virtchnl_l4_spec tcf = vcf->data.tcp_spec;
3902 	struct i40e_cloud_filter *cfilter = NULL;
3903 	struct i40e_pf *pf = vf->pf;
3904 	struct i40e_vsi *vsi = NULL;
3905 	int aq_ret = 0;
3906 	int i;
3907 
3908 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
3909 		aq_ret = -EINVAL;
3910 		goto err_out;
3911 	}
3912 
3913 	if (!vf->adq_enabled) {
3914 		dev_info(&pf->pdev->dev,
3915 			 "VF %d: ADq is not enabled, can't apply cloud filter\n",
3916 			 vf->vf_id);
3917 		aq_ret = -EINVAL;
3918 		goto err_out;
3919 	}
3920 
3921 	if (i40e_validate_cloud_filter(vf, vcf)) {
3922 		dev_info(&pf->pdev->dev,
3923 			 "VF %d: Invalid input/s, can't apply cloud filter\n",
3924 			 vf->vf_id);
3925 		aq_ret = -EINVAL;
3926 		goto err_out;
3927 	}
3928 
3929 	cfilter = kzalloc(sizeof(*cfilter), GFP_KERNEL);
3930 	if (!cfilter) {
3931 		aq_ret = -ENOMEM;
3932 		goto err_out;
3933 	}
3934 
3935 	/* parse destination mac address */
3936 	for (i = 0; i < ETH_ALEN; i++)
3937 		cfilter->dst_mac[i] = mask.dst_mac[i] & tcf.dst_mac[i];
3938 
3939 	/* parse source mac address */
3940 	for (i = 0; i < ETH_ALEN; i++)
3941 		cfilter->src_mac[i] = mask.src_mac[i] & tcf.src_mac[i];
3942 
3943 	cfilter->vlan_id = mask.vlan_id & tcf.vlan_id;
3944 	cfilter->dst_port = mask.dst_port & tcf.dst_port;
3945 	cfilter->src_port = mask.src_port & tcf.src_port;
3946 
3947 	switch (vcf->flow_type) {
3948 	case VIRTCHNL_TCP_V4_FLOW:
3949 		cfilter->n_proto = ETH_P_IP;
3950 		if (mask.dst_ip[0] & tcf.dst_ip[0])
3951 			memcpy(&cfilter->ip.v4.dst_ip, tcf.dst_ip,
3952 			       ARRAY_SIZE(tcf.dst_ip));
3953 		else if (mask.src_ip[0] & tcf.dst_ip[0])
3954 			memcpy(&cfilter->ip.v4.src_ip, tcf.src_ip,
3955 			       ARRAY_SIZE(tcf.dst_ip));
3956 		break;
3957 	case VIRTCHNL_TCP_V6_FLOW:
3958 		cfilter->n_proto = ETH_P_IPV6;
3959 		if (mask.dst_ip[3] & tcf.dst_ip[3])
3960 			memcpy(&cfilter->ip.v6.dst_ip6, tcf.dst_ip,
3961 			       sizeof(cfilter->ip.v6.dst_ip6));
3962 		if (mask.src_ip[3] & tcf.src_ip[3])
3963 			memcpy(&cfilter->ip.v6.src_ip6, tcf.src_ip,
3964 			       sizeof(cfilter->ip.v6.src_ip6));
3965 		break;
3966 	default:
3967 		/* TC filter can be configured based on different combinations
3968 		 * and in this case IP is not a part of filter config
3969 		 */
3970 		dev_info(&pf->pdev->dev, "VF %d: Flow type not configured\n",
3971 			 vf->vf_id);
3972 	}
3973 
3974 	/* get the VSI to which the TC belongs to */
3975 	vsi = pf->vsi[vf->ch[vcf->action_meta].vsi_idx];
3976 	cfilter->seid = vsi->seid;
3977 	cfilter->flags = vcf->field_flags;
3978 
3979 	/* Adding cloud filter programmed as TC filter */
3980 	if (tcf.dst_port)
3981 		aq_ret = i40e_add_del_cloud_filter_big_buf(vsi, cfilter, true);
3982 	else
3983 		aq_ret = i40e_add_del_cloud_filter(vsi, cfilter, true);
3984 	if (aq_ret) {
3985 		dev_err(&pf->pdev->dev,
3986 			"VF %d: Failed to add cloud filter, err %pe aq_err %s\n",
3987 			vf->vf_id, ERR_PTR(aq_ret),
3988 			i40e_aq_str(&pf->hw, pf->hw.aq.asq_last_status));
3989 		goto err_free;
3990 	}
3991 
3992 	INIT_HLIST_NODE(&cfilter->cloud_node);
3993 	hlist_add_head(&cfilter->cloud_node, &vf->cloud_filter_list);
3994 	/* release the pointer passing it to the collection */
3995 	cfilter = NULL;
3996 	vf->num_cloud_filters++;
3997 err_free:
3998 	kfree(cfilter);
3999 err_out:
4000 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ADD_CLOUD_FILTER,
4001 				       aq_ret);
4002 }
4003 
4004 /**
4005  * i40e_vc_add_qch_msg: Add queue channel and enable ADq
4006  * @vf: pointer to the VF info
4007  * @msg: pointer to the msg buffer
4008  **/
i40e_vc_add_qch_msg(struct i40e_vf * vf,u8 * msg)4009 static int i40e_vc_add_qch_msg(struct i40e_vf *vf, u8 *msg)
4010 {
4011 	struct virtchnl_tc_info *tci =
4012 		(struct virtchnl_tc_info *)msg;
4013 	struct i40e_pf *pf = vf->pf;
4014 	struct i40e_link_status *ls = &pf->hw.phy.link_info;
4015 	int i, adq_request_qps = 0;
4016 	int aq_ret = 0;
4017 	u64 speed = 0;
4018 
4019 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
4020 		aq_ret = -EINVAL;
4021 		goto err;
4022 	}
4023 
4024 	/* ADq cannot be applied if spoof check is ON */
4025 	if (vf->spoofchk) {
4026 		dev_err(&pf->pdev->dev,
4027 			"Spoof check is ON, turn it OFF to enable ADq\n");
4028 		aq_ret = -EINVAL;
4029 		goto err;
4030 	}
4031 
4032 	if (!(vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ADQ)) {
4033 		dev_err(&pf->pdev->dev,
4034 			"VF %d attempting to enable ADq, but hasn't properly negotiated that capability\n",
4035 			vf->vf_id);
4036 		aq_ret = -EINVAL;
4037 		goto err;
4038 	}
4039 
4040 	/* max number of traffic classes for VF currently capped at 4 */
4041 	if (!tci->num_tc || tci->num_tc > I40E_MAX_VF_VSI) {
4042 		dev_err(&pf->pdev->dev,
4043 			"VF %d trying to set %u TCs, valid range 1-%u TCs per VF\n",
4044 			vf->vf_id, tci->num_tc, I40E_MAX_VF_VSI);
4045 		aq_ret = -EINVAL;
4046 		goto err;
4047 	}
4048 
4049 	/* validate queues for each TC */
4050 	for (i = 0; i < tci->num_tc; i++)
4051 		if (!tci->list[i].count ||
4052 		    tci->list[i].count > I40E_DEFAULT_QUEUES_PER_VF) {
4053 			dev_err(&pf->pdev->dev,
4054 				"VF %d: TC %d trying to set %u queues, valid range 1-%u queues per TC\n",
4055 				vf->vf_id, i, tci->list[i].count,
4056 				I40E_DEFAULT_QUEUES_PER_VF);
4057 			aq_ret = -EINVAL;
4058 			goto err;
4059 		}
4060 
4061 	/* need Max VF queues but already have default number of queues */
4062 	adq_request_qps = I40E_MAX_VF_QUEUES - I40E_DEFAULT_QUEUES_PER_VF;
4063 
4064 	if (pf->queues_left < adq_request_qps) {
4065 		dev_err(&pf->pdev->dev,
4066 			"No queues left to allocate to VF %d\n",
4067 			vf->vf_id);
4068 		aq_ret = -EINVAL;
4069 		goto err;
4070 	} else {
4071 		/* we need to allocate max VF queues to enable ADq so as to
4072 		 * make sure ADq enabled VF always gets back queues when it
4073 		 * goes through a reset.
4074 		 */
4075 		vf->num_queue_pairs = I40E_MAX_VF_QUEUES;
4076 	}
4077 
4078 	/* get link speed in MB to validate rate limit */
4079 	speed = i40e_vc_link_speed2mbps(ls->link_speed);
4080 	if (speed == SPEED_UNKNOWN) {
4081 		dev_err(&pf->pdev->dev,
4082 			"Cannot detect link speed\n");
4083 		aq_ret = -EINVAL;
4084 		goto err;
4085 	}
4086 
4087 	/* parse data from the queue channel info */
4088 	vf->num_tc = tci->num_tc;
4089 	for (i = 0; i < vf->num_tc; i++) {
4090 		if (tci->list[i].max_tx_rate) {
4091 			if (tci->list[i].max_tx_rate > speed) {
4092 				dev_err(&pf->pdev->dev,
4093 					"Invalid max tx rate %llu specified for VF %d.",
4094 					tci->list[i].max_tx_rate,
4095 					vf->vf_id);
4096 				aq_ret = -EINVAL;
4097 				goto err;
4098 			} else {
4099 				vf->ch[i].max_tx_rate =
4100 					tci->list[i].max_tx_rate;
4101 			}
4102 		}
4103 		vf->ch[i].num_qps = tci->list[i].count;
4104 	}
4105 
4106 	/* set this flag only after making sure all inputs are sane */
4107 	vf->adq_enabled = true;
4108 
4109 	/* reset the VF in order to allocate resources */
4110 	i40e_vc_reset_vf(vf, true);
4111 
4112 	return 0;
4113 
4114 	/* send the response to the VF */
4115 err:
4116 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_ENABLE_CHANNELS,
4117 				       aq_ret);
4118 }
4119 
4120 /**
4121  * i40e_vc_del_qch_msg
4122  * @vf: pointer to the VF info
4123  * @msg: pointer to the msg buffer
4124  **/
i40e_vc_del_qch_msg(struct i40e_vf * vf,u8 * msg)4125 static int i40e_vc_del_qch_msg(struct i40e_vf *vf, u8 *msg)
4126 {
4127 	struct i40e_pf *pf = vf->pf;
4128 	int aq_ret = 0;
4129 
4130 	if (!i40e_sync_vf_state(vf, I40E_VF_STATE_ACTIVE)) {
4131 		aq_ret = -EINVAL;
4132 		goto err;
4133 	}
4134 
4135 	if (vf->adq_enabled) {
4136 		i40e_del_all_cloud_filters(vf);
4137 		i40e_del_qch(vf);
4138 		vf->adq_enabled = false;
4139 		vf->num_tc = 0;
4140 		dev_info(&pf->pdev->dev,
4141 			 "Deleting Queue Channels and cloud filters for ADq on VF %d\n",
4142 			 vf->vf_id);
4143 	} else {
4144 		dev_info(&pf->pdev->dev, "VF %d trying to delete queue channels but ADq isn't enabled\n",
4145 			 vf->vf_id);
4146 		aq_ret = -EINVAL;
4147 	}
4148 
4149 	/* reset the VF in order to allocate resources */
4150 	i40e_vc_reset_vf(vf, true);
4151 
4152 	return 0;
4153 
4154 err:
4155 	return i40e_vc_send_resp_to_vf(vf, VIRTCHNL_OP_DISABLE_CHANNELS,
4156 				       aq_ret);
4157 }
4158 
4159 /**
4160  * i40e_vc_process_vf_msg
4161  * @pf: pointer to the PF structure
4162  * @vf_id: source VF id
4163  * @v_opcode: operation code
4164  * @v_retval: unused return value code
4165  * @msg: pointer to the msg buffer
4166  * @msglen: msg length
4167  *
4168  * called from the common aeq/arq handler to
4169  * process request from VF
4170  **/
i40e_vc_process_vf_msg(struct i40e_pf * pf,s16 vf_id,u32 v_opcode,u32 __always_unused v_retval,u8 * msg,u16 msglen)4171 int i40e_vc_process_vf_msg(struct i40e_pf *pf, s16 vf_id, u32 v_opcode,
4172 			   u32 __always_unused v_retval, u8 *msg, u16 msglen)
4173 {
4174 	struct i40e_hw *hw = &pf->hw;
4175 	int local_vf_id = vf_id - (s16)hw->func_caps.vf_base_id;
4176 	struct i40e_vf *vf;
4177 	int ret;
4178 
4179 	pf->vf_aq_requests++;
4180 	if (local_vf_id < 0 || local_vf_id >= pf->num_alloc_vfs)
4181 		return -EINVAL;
4182 	vf = &(pf->vf[local_vf_id]);
4183 
4184 	/* Check if VF is disabled. */
4185 	if (test_bit(I40E_VF_STATE_DISABLED, &vf->vf_states))
4186 		return -EINVAL;
4187 
4188 	/* perform basic checks on the msg */
4189 	ret = virtchnl_vc_validate_vf_msg(&vf->vf_ver, v_opcode, msg, msglen);
4190 
4191 	if (ret) {
4192 		i40e_vc_send_resp_to_vf(vf, v_opcode, -EINVAL);
4193 		dev_err(&pf->pdev->dev, "Invalid message from VF %d, opcode %d, len %d\n",
4194 			local_vf_id, v_opcode, msglen);
4195 		return ret;
4196 	}
4197 
4198 	switch (v_opcode) {
4199 	case VIRTCHNL_OP_VERSION:
4200 		ret = i40e_vc_get_version_msg(vf, msg);
4201 		break;
4202 	case VIRTCHNL_OP_GET_VF_RESOURCES:
4203 		ret = i40e_vc_get_vf_resources_msg(vf, msg);
4204 		i40e_vc_notify_vf_link_state(vf);
4205 		break;
4206 	case VIRTCHNL_OP_RESET_VF:
4207 		i40e_vc_reset_vf(vf, false);
4208 		ret = 0;
4209 		break;
4210 	case VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE:
4211 		ret = i40e_vc_config_promiscuous_mode_msg(vf, msg);
4212 		break;
4213 	case VIRTCHNL_OP_CONFIG_VSI_QUEUES:
4214 		ret = i40e_vc_config_queues_msg(vf, msg);
4215 		break;
4216 	case VIRTCHNL_OP_CONFIG_IRQ_MAP:
4217 		ret = i40e_vc_config_irq_map_msg(vf, msg);
4218 		break;
4219 	case VIRTCHNL_OP_ENABLE_QUEUES:
4220 		ret = i40e_vc_enable_queues_msg(vf, msg);
4221 		i40e_vc_notify_vf_link_state(vf);
4222 		break;
4223 	case VIRTCHNL_OP_DISABLE_QUEUES:
4224 		ret = i40e_vc_disable_queues_msg(vf, msg);
4225 		break;
4226 	case VIRTCHNL_OP_ADD_ETH_ADDR:
4227 		ret = i40e_vc_add_mac_addr_msg(vf, msg);
4228 		break;
4229 	case VIRTCHNL_OP_DEL_ETH_ADDR:
4230 		ret = i40e_vc_del_mac_addr_msg(vf, msg);
4231 		break;
4232 	case VIRTCHNL_OP_ADD_VLAN:
4233 		ret = i40e_vc_add_vlan_msg(vf, msg);
4234 		break;
4235 	case VIRTCHNL_OP_DEL_VLAN:
4236 		ret = i40e_vc_remove_vlan_msg(vf, msg);
4237 		break;
4238 	case VIRTCHNL_OP_GET_STATS:
4239 		ret = i40e_vc_get_stats_msg(vf, msg);
4240 		break;
4241 	case VIRTCHNL_OP_RDMA:
4242 		ret = i40e_vc_rdma_msg(vf, msg, msglen);
4243 		break;
4244 	case VIRTCHNL_OP_CONFIG_RDMA_IRQ_MAP:
4245 		ret = i40e_vc_rdma_qvmap_msg(vf, msg, true);
4246 		break;
4247 	case VIRTCHNL_OP_RELEASE_RDMA_IRQ_MAP:
4248 		ret = i40e_vc_rdma_qvmap_msg(vf, msg, false);
4249 		break;
4250 	case VIRTCHNL_OP_CONFIG_RSS_KEY:
4251 		ret = i40e_vc_config_rss_key(vf, msg);
4252 		break;
4253 	case VIRTCHNL_OP_CONFIG_RSS_LUT:
4254 		ret = i40e_vc_config_rss_lut(vf, msg);
4255 		break;
4256 	case VIRTCHNL_OP_GET_RSS_HENA_CAPS:
4257 		ret = i40e_vc_get_rss_hena(vf, msg);
4258 		break;
4259 	case VIRTCHNL_OP_SET_RSS_HENA:
4260 		ret = i40e_vc_set_rss_hena(vf, msg);
4261 		break;
4262 	case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING:
4263 		ret = i40e_vc_enable_vlan_stripping(vf, msg);
4264 		break;
4265 	case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING:
4266 		ret = i40e_vc_disable_vlan_stripping(vf, msg);
4267 		break;
4268 	case VIRTCHNL_OP_REQUEST_QUEUES:
4269 		ret = i40e_vc_request_queues_msg(vf, msg);
4270 		break;
4271 	case VIRTCHNL_OP_ENABLE_CHANNELS:
4272 		ret = i40e_vc_add_qch_msg(vf, msg);
4273 		break;
4274 	case VIRTCHNL_OP_DISABLE_CHANNELS:
4275 		ret = i40e_vc_del_qch_msg(vf, msg);
4276 		break;
4277 	case VIRTCHNL_OP_ADD_CLOUD_FILTER:
4278 		ret = i40e_vc_add_cloud_filter(vf, msg);
4279 		break;
4280 	case VIRTCHNL_OP_DEL_CLOUD_FILTER:
4281 		ret = i40e_vc_del_cloud_filter(vf, msg);
4282 		break;
4283 	case VIRTCHNL_OP_UNKNOWN:
4284 	default:
4285 		dev_err(&pf->pdev->dev, "Unsupported opcode %d from VF %d\n",
4286 			v_opcode, local_vf_id);
4287 		ret = i40e_vc_send_resp_to_vf(vf, v_opcode,
4288 					      -EOPNOTSUPP);
4289 		break;
4290 	}
4291 
4292 	return ret;
4293 }
4294 
4295 /**
4296  * i40e_vc_process_vflr_event
4297  * @pf: pointer to the PF structure
4298  *
4299  * called from the vlfr irq handler to
4300  * free up VF resources and state variables
4301  **/
i40e_vc_process_vflr_event(struct i40e_pf * pf)4302 int i40e_vc_process_vflr_event(struct i40e_pf *pf)
4303 {
4304 	struct i40e_hw *hw = &pf->hw;
4305 	u32 reg, reg_idx, bit_idx;
4306 	struct i40e_vf *vf;
4307 	int vf_id;
4308 
4309 	if (!test_bit(__I40E_VFLR_EVENT_PENDING, pf->state))
4310 		return 0;
4311 
4312 	/* Re-enable the VFLR interrupt cause here, before looking for which
4313 	 * VF got reset. Otherwise, if another VF gets a reset while the
4314 	 * first one is being processed, that interrupt will be lost, and
4315 	 * that VF will be stuck in reset forever.
4316 	 */
4317 	reg = rd32(hw, I40E_PFINT_ICR0_ENA);
4318 	reg |= I40E_PFINT_ICR0_ENA_VFLR_MASK;
4319 	wr32(hw, I40E_PFINT_ICR0_ENA, reg);
4320 	i40e_flush(hw);
4321 
4322 	clear_bit(__I40E_VFLR_EVENT_PENDING, pf->state);
4323 	for (vf_id = 0; vf_id < pf->num_alloc_vfs; vf_id++) {
4324 		reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32;
4325 		bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
4326 		/* read GLGEN_VFLRSTAT register to find out the flr VFs */
4327 		vf = &pf->vf[vf_id];
4328 		reg = rd32(hw, I40E_GLGEN_VFLRSTAT(reg_idx));
4329 		if (reg & BIT(bit_idx))
4330 			/* i40e_reset_vf will clear the bit in GLGEN_VFLRSTAT */
4331 			i40e_reset_vf(vf, true);
4332 	}
4333 
4334 	return 0;
4335 }
4336 
4337 /**
4338  * i40e_validate_vf
4339  * @pf: the physical function
4340  * @vf_id: VF identifier
4341  *
4342  * Check that the VF is enabled and the VSI exists.
4343  *
4344  * Returns 0 on success, negative on failure
4345  **/
i40e_validate_vf(struct i40e_pf * pf,int vf_id)4346 static int i40e_validate_vf(struct i40e_pf *pf, int vf_id)
4347 {
4348 	struct i40e_vsi *vsi;
4349 	struct i40e_vf *vf;
4350 	int ret = 0;
4351 
4352 	if (vf_id >= pf->num_alloc_vfs) {
4353 		dev_err(&pf->pdev->dev,
4354 			"Invalid VF Identifier %d\n", vf_id);
4355 		ret = -EINVAL;
4356 		goto err_out;
4357 	}
4358 	vf = &pf->vf[vf_id];
4359 	vsi = i40e_find_vsi_from_id(pf, vf->lan_vsi_id);
4360 	if (!vsi)
4361 		ret = -EINVAL;
4362 err_out:
4363 	return ret;
4364 }
4365 
4366 /**
4367  * i40e_check_vf_init_timeout
4368  * @vf: the virtual function
4369  *
4370  * Check that the VF's initialization was successfully done and if not
4371  * wait up to 300ms for its finish.
4372  *
4373  * Returns true when VF is initialized, false on timeout
4374  **/
i40e_check_vf_init_timeout(struct i40e_vf * vf)4375 static bool i40e_check_vf_init_timeout(struct i40e_vf *vf)
4376 {
4377 	int i;
4378 
4379 	/* When the VF is resetting wait until it is done.
4380 	 * It can take up to 200 milliseconds, but wait for
4381 	 * up to 300 milliseconds to be safe.
4382 	 */
4383 	for (i = 0; i < 15; i++) {
4384 		if (test_bit(I40E_VF_STATE_INIT, &vf->vf_states))
4385 			return true;
4386 		msleep(20);
4387 	}
4388 
4389 	if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
4390 		dev_err(&vf->pf->pdev->dev,
4391 			"VF %d still in reset. Try again.\n", vf->vf_id);
4392 		return false;
4393 	}
4394 
4395 	return true;
4396 }
4397 
4398 /**
4399  * i40e_ndo_set_vf_mac
4400  * @netdev: network interface device structure
4401  * @vf_id: VF identifier
4402  * @mac: mac address
4403  *
4404  * program VF mac address
4405  **/
i40e_ndo_set_vf_mac(struct net_device * netdev,int vf_id,u8 * mac)4406 int i40e_ndo_set_vf_mac(struct net_device *netdev, int vf_id, u8 *mac)
4407 {
4408 	struct i40e_netdev_priv *np = netdev_priv(netdev);
4409 	struct i40e_vsi *vsi = np->vsi;
4410 	struct i40e_pf *pf = vsi->back;
4411 	struct i40e_mac_filter *f;
4412 	struct i40e_vf *vf;
4413 	int ret = 0;
4414 	struct hlist_node *h;
4415 	int bkt;
4416 
4417 	if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4418 		dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4419 		return -EAGAIN;
4420 	}
4421 
4422 	/* validate the request */
4423 	ret = i40e_validate_vf(pf, vf_id);
4424 	if (ret)
4425 		goto error_param;
4426 
4427 	vf = &pf->vf[vf_id];
4428 	if (!i40e_check_vf_init_timeout(vf)) {
4429 		ret = -EAGAIN;
4430 		goto error_param;
4431 	}
4432 	vsi = pf->vsi[vf->lan_vsi_idx];
4433 
4434 	if (is_multicast_ether_addr(mac)) {
4435 		dev_err(&pf->pdev->dev,
4436 			"Invalid Ethernet address %pM for VF %d\n", mac, vf_id);
4437 		ret = -EINVAL;
4438 		goto error_param;
4439 	}
4440 
4441 	/* Lock once because below invoked function add/del_filter requires
4442 	 * mac_filter_hash_lock to be held
4443 	 */
4444 	spin_lock_bh(&vsi->mac_filter_hash_lock);
4445 
4446 	/* delete the temporary mac address */
4447 	if (!is_zero_ether_addr(vf->default_lan_addr.addr))
4448 		i40e_del_mac_filter(vsi, vf->default_lan_addr.addr);
4449 
4450 	/* Delete all the filters for this VSI - we're going to kill it
4451 	 * anyway.
4452 	 */
4453 	hash_for_each_safe(vsi->mac_filter_hash, bkt, h, f, hlist)
4454 		__i40e_del_filter(vsi, f);
4455 
4456 	spin_unlock_bh(&vsi->mac_filter_hash_lock);
4457 
4458 	/* program mac filter */
4459 	if (i40e_sync_vsi_filters(vsi)) {
4460 		dev_err(&pf->pdev->dev, "Unable to program ucast filters\n");
4461 		ret = -EIO;
4462 		goto error_param;
4463 	}
4464 	ether_addr_copy(vf->default_lan_addr.addr, mac);
4465 
4466 	if (is_zero_ether_addr(mac)) {
4467 		vf->pf_set_mac = false;
4468 		dev_info(&pf->pdev->dev, "Removing MAC on VF %d\n", vf_id);
4469 	} else {
4470 		vf->pf_set_mac = true;
4471 		dev_info(&pf->pdev->dev, "Setting MAC %pM on VF %d\n",
4472 			 mac, vf_id);
4473 	}
4474 
4475 	/* Force the VF interface down so it has to bring up with new MAC
4476 	 * address
4477 	 */
4478 	i40e_vc_reset_vf(vf, true);
4479 	dev_info(&pf->pdev->dev, "Bring down and up the VF interface to make this change effective.\n");
4480 
4481 error_param:
4482 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4483 	return ret;
4484 }
4485 
4486 /**
4487  * i40e_ndo_set_vf_port_vlan
4488  * @netdev: network interface device structure
4489  * @vf_id: VF identifier
4490  * @vlan_id: mac address
4491  * @qos: priority setting
4492  * @vlan_proto: vlan protocol
4493  *
4494  * program VF vlan id and/or qos
4495  **/
i40e_ndo_set_vf_port_vlan(struct net_device * netdev,int vf_id,u16 vlan_id,u8 qos,__be16 vlan_proto)4496 int i40e_ndo_set_vf_port_vlan(struct net_device *netdev, int vf_id,
4497 			      u16 vlan_id, u8 qos, __be16 vlan_proto)
4498 {
4499 	u16 vlanprio = vlan_id | (qos << I40E_VLAN_PRIORITY_SHIFT);
4500 	struct i40e_netdev_priv *np = netdev_priv(netdev);
4501 	bool allmulti = false, alluni = false;
4502 	struct i40e_pf *pf = np->vsi->back;
4503 	struct i40e_vsi *vsi;
4504 	struct i40e_vf *vf;
4505 	int ret = 0;
4506 
4507 	if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4508 		dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4509 		return -EAGAIN;
4510 	}
4511 
4512 	/* validate the request */
4513 	ret = i40e_validate_vf(pf, vf_id);
4514 	if (ret)
4515 		goto error_pvid;
4516 
4517 	if ((vlan_id > I40E_MAX_VLANID) || (qos > 7)) {
4518 		dev_err(&pf->pdev->dev, "Invalid VF Parameters\n");
4519 		ret = -EINVAL;
4520 		goto error_pvid;
4521 	}
4522 
4523 	if (vlan_proto != htons(ETH_P_8021Q)) {
4524 		dev_err(&pf->pdev->dev, "VF VLAN protocol is not supported\n");
4525 		ret = -EPROTONOSUPPORT;
4526 		goto error_pvid;
4527 	}
4528 
4529 	vf = &pf->vf[vf_id];
4530 	if (!i40e_check_vf_init_timeout(vf)) {
4531 		ret = -EAGAIN;
4532 		goto error_pvid;
4533 	}
4534 	vsi = pf->vsi[vf->lan_vsi_idx];
4535 
4536 	if (le16_to_cpu(vsi->info.pvid) == vlanprio)
4537 		/* duplicate request, so just return success */
4538 		goto error_pvid;
4539 
4540 	i40e_vlan_stripping_enable(vsi);
4541 
4542 	/* Locked once because multiple functions below iterate list */
4543 	spin_lock_bh(&vsi->mac_filter_hash_lock);
4544 
4545 	/* Check for condition where there was already a port VLAN ID
4546 	 * filter set and now it is being deleted by setting it to zero.
4547 	 * Additionally check for the condition where there was a port
4548 	 * VLAN but now there is a new and different port VLAN being set.
4549 	 * Before deleting all the old VLAN filters we must add new ones
4550 	 * with -1 (I40E_VLAN_ANY) or otherwise we're left with all our
4551 	 * MAC addresses deleted.
4552 	 */
4553 	if ((!(vlan_id || qos) ||
4554 	     vlanprio != le16_to_cpu(vsi->info.pvid)) &&
4555 	    vsi->info.pvid) {
4556 		ret = i40e_add_vlan_all_mac(vsi, I40E_VLAN_ANY);
4557 		if (ret) {
4558 			dev_info(&vsi->back->pdev->dev,
4559 				 "add VF VLAN failed, ret=%d aq_err=%d\n", ret,
4560 				 vsi->back->hw.aq.asq_last_status);
4561 			spin_unlock_bh(&vsi->mac_filter_hash_lock);
4562 			goto error_pvid;
4563 		}
4564 	}
4565 
4566 	if (vsi->info.pvid) {
4567 		/* remove all filters on the old VLAN */
4568 		i40e_rm_vlan_all_mac(vsi, (le16_to_cpu(vsi->info.pvid) &
4569 					   VLAN_VID_MASK));
4570 	}
4571 
4572 	spin_unlock_bh(&vsi->mac_filter_hash_lock);
4573 
4574 	/* disable promisc modes in case they were enabled */
4575 	ret = i40e_config_vf_promiscuous_mode(vf, vf->lan_vsi_id,
4576 					      allmulti, alluni);
4577 	if (ret) {
4578 		dev_err(&pf->pdev->dev, "Unable to config VF promiscuous mode\n");
4579 		goto error_pvid;
4580 	}
4581 
4582 	if (vlan_id || qos)
4583 		ret = i40e_vsi_add_pvid(vsi, vlanprio);
4584 	else
4585 		i40e_vsi_remove_pvid(vsi);
4586 	spin_lock_bh(&vsi->mac_filter_hash_lock);
4587 
4588 	if (vlan_id) {
4589 		dev_info(&pf->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n",
4590 			 vlan_id, qos, vf_id);
4591 
4592 		/* add new VLAN filter for each MAC */
4593 		ret = i40e_add_vlan_all_mac(vsi, vlan_id);
4594 		if (ret) {
4595 			dev_info(&vsi->back->pdev->dev,
4596 				 "add VF VLAN failed, ret=%d aq_err=%d\n", ret,
4597 				 vsi->back->hw.aq.asq_last_status);
4598 			spin_unlock_bh(&vsi->mac_filter_hash_lock);
4599 			goto error_pvid;
4600 		}
4601 
4602 		/* remove the previously added non-VLAN MAC filters */
4603 		i40e_rm_vlan_all_mac(vsi, I40E_VLAN_ANY);
4604 	}
4605 
4606 	spin_unlock_bh(&vsi->mac_filter_hash_lock);
4607 
4608 	if (test_bit(I40E_VF_STATE_UC_PROMISC, &vf->vf_states))
4609 		alluni = true;
4610 
4611 	if (test_bit(I40E_VF_STATE_MC_PROMISC, &vf->vf_states))
4612 		allmulti = true;
4613 
4614 	/* Schedule the worker thread to take care of applying changes */
4615 	i40e_service_event_schedule(vsi->back);
4616 
4617 	if (ret) {
4618 		dev_err(&pf->pdev->dev, "Unable to update VF vsi context\n");
4619 		goto error_pvid;
4620 	}
4621 
4622 	/* The Port VLAN needs to be saved across resets the same as the
4623 	 * default LAN MAC address.
4624 	 */
4625 	vf->port_vlan_id = le16_to_cpu(vsi->info.pvid);
4626 
4627 	i40e_vc_reset_vf(vf, true);
4628 	/* During reset the VF got a new VSI, so refresh a pointer. */
4629 	vsi = pf->vsi[vf->lan_vsi_idx];
4630 
4631 	ret = i40e_config_vf_promiscuous_mode(vf, vsi->id, allmulti, alluni);
4632 	if (ret) {
4633 		dev_err(&pf->pdev->dev, "Unable to config vf promiscuous mode\n");
4634 		goto error_pvid;
4635 	}
4636 
4637 	ret = 0;
4638 
4639 error_pvid:
4640 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4641 	return ret;
4642 }
4643 
4644 /**
4645  * i40e_ndo_set_vf_bw
4646  * @netdev: network interface device structure
4647  * @vf_id: VF identifier
4648  * @min_tx_rate: Minimum Tx rate
4649  * @max_tx_rate: Maximum Tx rate
4650  *
4651  * configure VF Tx rate
4652  **/
i40e_ndo_set_vf_bw(struct net_device * netdev,int vf_id,int min_tx_rate,int max_tx_rate)4653 int i40e_ndo_set_vf_bw(struct net_device *netdev, int vf_id, int min_tx_rate,
4654 		       int max_tx_rate)
4655 {
4656 	struct i40e_netdev_priv *np = netdev_priv(netdev);
4657 	struct i40e_pf *pf = np->vsi->back;
4658 	struct i40e_vsi *vsi;
4659 	struct i40e_vf *vf;
4660 	int ret = 0;
4661 
4662 	if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4663 		dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4664 		return -EAGAIN;
4665 	}
4666 
4667 	/* validate the request */
4668 	ret = i40e_validate_vf(pf, vf_id);
4669 	if (ret)
4670 		goto error;
4671 
4672 	if (min_tx_rate) {
4673 		dev_err(&pf->pdev->dev, "Invalid min tx rate (%d) (greater than 0) specified for VF %d.\n",
4674 			min_tx_rate, vf_id);
4675 		ret = -EINVAL;
4676 		goto error;
4677 	}
4678 
4679 	vf = &pf->vf[vf_id];
4680 	if (!i40e_check_vf_init_timeout(vf)) {
4681 		ret = -EAGAIN;
4682 		goto error;
4683 	}
4684 	vsi = pf->vsi[vf->lan_vsi_idx];
4685 
4686 	ret = i40e_set_bw_limit(vsi, vsi->seid, max_tx_rate);
4687 	if (ret)
4688 		goto error;
4689 
4690 	vf->tx_rate = max_tx_rate;
4691 error:
4692 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4693 	return ret;
4694 }
4695 
4696 /**
4697  * i40e_ndo_get_vf_config
4698  * @netdev: network interface device structure
4699  * @vf_id: VF identifier
4700  * @ivi: VF configuration structure
4701  *
4702  * return VF configuration
4703  **/
i40e_ndo_get_vf_config(struct net_device * netdev,int vf_id,struct ifla_vf_info * ivi)4704 int i40e_ndo_get_vf_config(struct net_device *netdev,
4705 			   int vf_id, struct ifla_vf_info *ivi)
4706 {
4707 	struct i40e_netdev_priv *np = netdev_priv(netdev);
4708 	struct i40e_vsi *vsi = np->vsi;
4709 	struct i40e_pf *pf = vsi->back;
4710 	struct i40e_vf *vf;
4711 	int ret = 0;
4712 
4713 	if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4714 		dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4715 		return -EAGAIN;
4716 	}
4717 
4718 	/* validate the request */
4719 	ret = i40e_validate_vf(pf, vf_id);
4720 	if (ret)
4721 		goto error_param;
4722 
4723 	vf = &pf->vf[vf_id];
4724 	/* first vsi is always the LAN vsi */
4725 	vsi = pf->vsi[vf->lan_vsi_idx];
4726 	if (!vsi) {
4727 		ret = -ENOENT;
4728 		goto error_param;
4729 	}
4730 
4731 	ivi->vf = vf_id;
4732 
4733 	ether_addr_copy(ivi->mac, vf->default_lan_addr.addr);
4734 
4735 	ivi->max_tx_rate = vf->tx_rate;
4736 	ivi->min_tx_rate = 0;
4737 	ivi->vlan = le16_get_bits(vsi->info.pvid, I40E_VLAN_MASK);
4738 	ivi->qos = le16_get_bits(vsi->info.pvid, I40E_PRIORITY_MASK);
4739 	if (vf->link_forced == false)
4740 		ivi->linkstate = IFLA_VF_LINK_STATE_AUTO;
4741 	else if (vf->link_up == true)
4742 		ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE;
4743 	else
4744 		ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE;
4745 	ivi->spoofchk = vf->spoofchk;
4746 	ivi->trusted = vf->trusted;
4747 	ret = 0;
4748 
4749 error_param:
4750 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4751 	return ret;
4752 }
4753 
4754 /**
4755  * i40e_ndo_set_vf_link_state
4756  * @netdev: network interface device structure
4757  * @vf_id: VF identifier
4758  * @link: required link state
4759  *
4760  * Set the link state of a specified VF, regardless of physical link state
4761  **/
i40e_ndo_set_vf_link_state(struct net_device * netdev,int vf_id,int link)4762 int i40e_ndo_set_vf_link_state(struct net_device *netdev, int vf_id, int link)
4763 {
4764 	struct i40e_netdev_priv *np = netdev_priv(netdev);
4765 	struct i40e_pf *pf = np->vsi->back;
4766 	struct i40e_link_status *ls = &pf->hw.phy.link_info;
4767 	struct virtchnl_pf_event pfe;
4768 	struct i40e_hw *hw = &pf->hw;
4769 	struct i40e_vsi *vsi;
4770 	unsigned long q_map;
4771 	struct i40e_vf *vf;
4772 	int abs_vf_id;
4773 	int ret = 0;
4774 	int tmp;
4775 
4776 	if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4777 		dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4778 		return -EAGAIN;
4779 	}
4780 
4781 	/* validate the request */
4782 	if (vf_id >= pf->num_alloc_vfs) {
4783 		dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
4784 		ret = -EINVAL;
4785 		goto error_out;
4786 	}
4787 
4788 	vf = &pf->vf[vf_id];
4789 	abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
4790 
4791 	pfe.event = VIRTCHNL_EVENT_LINK_CHANGE;
4792 	pfe.severity = PF_EVENT_SEVERITY_INFO;
4793 
4794 	switch (link) {
4795 	case IFLA_VF_LINK_STATE_AUTO:
4796 		vf->link_forced = false;
4797 		vf->is_disabled_from_host = false;
4798 		/* reset needed to reinit VF resources */
4799 		i40e_vc_reset_vf(vf, true);
4800 		i40e_set_vf_link_state(vf, &pfe, ls);
4801 		break;
4802 	case IFLA_VF_LINK_STATE_ENABLE:
4803 		vf->link_forced = true;
4804 		vf->link_up = true;
4805 		vf->is_disabled_from_host = false;
4806 		/* reset needed to reinit VF resources */
4807 		i40e_vc_reset_vf(vf, true);
4808 		i40e_set_vf_link_state(vf, &pfe, ls);
4809 		break;
4810 	case IFLA_VF_LINK_STATE_DISABLE:
4811 		vf->link_forced = true;
4812 		vf->link_up = false;
4813 		i40e_set_vf_link_state(vf, &pfe, ls);
4814 
4815 		vsi = pf->vsi[vf->lan_vsi_idx];
4816 		q_map = BIT(vsi->num_queue_pairs) - 1;
4817 
4818 		vf->is_disabled_from_host = true;
4819 
4820 		/* Try to stop both Tx&Rx rings even if one of the calls fails
4821 		 * to ensure we stop the rings even in case of errors.
4822 		 * If any of them returns with an error then the first
4823 		 * error that occurred will be returned.
4824 		 */
4825 		tmp = i40e_ctrl_vf_tx_rings(vsi, q_map, false);
4826 		ret = i40e_ctrl_vf_rx_rings(vsi, q_map, false);
4827 
4828 		ret = tmp ? tmp : ret;
4829 		break;
4830 	default:
4831 		ret = -EINVAL;
4832 		goto error_out;
4833 	}
4834 	/* Notify the VF of its new link state */
4835 	i40e_aq_send_msg_to_vf(hw, abs_vf_id, VIRTCHNL_OP_EVENT,
4836 			       0, (u8 *)&pfe, sizeof(pfe), NULL);
4837 
4838 error_out:
4839 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4840 	return ret;
4841 }
4842 
4843 /**
4844  * i40e_ndo_set_vf_spoofchk
4845  * @netdev: network interface device structure
4846  * @vf_id: VF identifier
4847  * @enable: flag to enable or disable feature
4848  *
4849  * Enable or disable VF spoof checking
4850  **/
i40e_ndo_set_vf_spoofchk(struct net_device * netdev,int vf_id,bool enable)4851 int i40e_ndo_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool enable)
4852 {
4853 	struct i40e_netdev_priv *np = netdev_priv(netdev);
4854 	struct i40e_vsi *vsi = np->vsi;
4855 	struct i40e_pf *pf = vsi->back;
4856 	struct i40e_vsi_context ctxt;
4857 	struct i40e_hw *hw = &pf->hw;
4858 	struct i40e_vf *vf;
4859 	int ret = 0;
4860 
4861 	if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4862 		dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4863 		return -EAGAIN;
4864 	}
4865 
4866 	/* validate the request */
4867 	if (vf_id >= pf->num_alloc_vfs) {
4868 		dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
4869 		ret = -EINVAL;
4870 		goto out;
4871 	}
4872 
4873 	vf = &(pf->vf[vf_id]);
4874 	if (!i40e_check_vf_init_timeout(vf)) {
4875 		ret = -EAGAIN;
4876 		goto out;
4877 	}
4878 
4879 	if (enable == vf->spoofchk)
4880 		goto out;
4881 
4882 	vf->spoofchk = enable;
4883 	memset(&ctxt, 0, sizeof(ctxt));
4884 	ctxt.seid = pf->vsi[vf->lan_vsi_idx]->seid;
4885 	ctxt.pf_num = pf->hw.pf_id;
4886 	ctxt.info.valid_sections = cpu_to_le16(I40E_AQ_VSI_PROP_SECURITY_VALID);
4887 	if (enable)
4888 		ctxt.info.sec_flags |= (I40E_AQ_VSI_SEC_FLAG_ENABLE_VLAN_CHK |
4889 					I40E_AQ_VSI_SEC_FLAG_ENABLE_MAC_CHK);
4890 	ret = i40e_aq_update_vsi_params(hw, &ctxt, NULL);
4891 	if (ret) {
4892 		dev_err(&pf->pdev->dev, "Error %d updating VSI parameters\n",
4893 			ret);
4894 		ret = -EIO;
4895 	}
4896 out:
4897 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4898 	return ret;
4899 }
4900 
4901 /**
4902  * i40e_ndo_set_vf_trust
4903  * @netdev: network interface device structure of the pf
4904  * @vf_id: VF identifier
4905  * @setting: trust setting
4906  *
4907  * Enable or disable VF trust setting
4908  **/
i40e_ndo_set_vf_trust(struct net_device * netdev,int vf_id,bool setting)4909 int i40e_ndo_set_vf_trust(struct net_device *netdev, int vf_id, bool setting)
4910 {
4911 	struct i40e_netdev_priv *np = netdev_priv(netdev);
4912 	struct i40e_pf *pf = np->vsi->back;
4913 	struct i40e_vf *vf;
4914 	int ret = 0;
4915 
4916 	if (test_and_set_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state)) {
4917 		dev_warn(&pf->pdev->dev, "Unable to configure VFs, other operation is pending.\n");
4918 		return -EAGAIN;
4919 	}
4920 
4921 	/* validate the request */
4922 	if (vf_id >= pf->num_alloc_vfs) {
4923 		dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
4924 		ret = -EINVAL;
4925 		goto out;
4926 	}
4927 
4928 	if (test_bit(I40E_FLAG_MFP_ENA, pf->flags)) {
4929 		dev_err(&pf->pdev->dev, "Trusted VF not supported in MFP mode.\n");
4930 		ret = -EINVAL;
4931 		goto out;
4932 	}
4933 
4934 	vf = &pf->vf[vf_id];
4935 
4936 	if (setting == vf->trusted)
4937 		goto out;
4938 
4939 	vf->trusted = setting;
4940 
4941 	/* request PF to sync mac/vlan filters for the VF */
4942 	set_bit(__I40E_MACVLAN_SYNC_PENDING, pf->state);
4943 	pf->vsi[vf->lan_vsi_idx]->flags |= I40E_VSI_FLAG_FILTER_CHANGED;
4944 
4945 	i40e_vc_reset_vf(vf, true);
4946 	dev_info(&pf->pdev->dev, "VF %u is now %strusted\n",
4947 		 vf_id, setting ? "" : "un");
4948 
4949 	if (vf->adq_enabled) {
4950 		if (!vf->trusted) {
4951 			dev_info(&pf->pdev->dev,
4952 				 "VF %u no longer Trusted, deleting all cloud filters\n",
4953 				 vf_id);
4954 			i40e_del_all_cloud_filters(vf);
4955 		}
4956 	}
4957 
4958 out:
4959 	clear_bit(__I40E_VIRTCHNL_OP_PENDING, pf->state);
4960 	return ret;
4961 }
4962 
4963 /**
4964  * i40e_get_vf_stats - populate some stats for the VF
4965  * @netdev: the netdev of the PF
4966  * @vf_id: the host OS identifier (0-127)
4967  * @vf_stats: pointer to the OS memory to be initialized
4968  */
i40e_get_vf_stats(struct net_device * netdev,int vf_id,struct ifla_vf_stats * vf_stats)4969 int i40e_get_vf_stats(struct net_device *netdev, int vf_id,
4970 		      struct ifla_vf_stats *vf_stats)
4971 {
4972 	struct i40e_netdev_priv *np = netdev_priv(netdev);
4973 	struct i40e_pf *pf = np->vsi->back;
4974 	struct i40e_eth_stats *stats;
4975 	struct i40e_vsi *vsi;
4976 	struct i40e_vf *vf;
4977 
4978 	/* validate the request */
4979 	if (i40e_validate_vf(pf, vf_id))
4980 		return -EINVAL;
4981 
4982 	vf = &pf->vf[vf_id];
4983 	if (!test_bit(I40E_VF_STATE_INIT, &vf->vf_states)) {
4984 		dev_err(&pf->pdev->dev, "VF %d in reset. Try again.\n", vf_id);
4985 		return -EBUSY;
4986 	}
4987 
4988 	vsi = pf->vsi[vf->lan_vsi_idx];
4989 	if (!vsi)
4990 		return -EINVAL;
4991 
4992 	i40e_update_eth_stats(vsi);
4993 	stats = &vsi->eth_stats;
4994 
4995 	memset(vf_stats, 0, sizeof(*vf_stats));
4996 
4997 	vf_stats->rx_packets = stats->rx_unicast + stats->rx_broadcast +
4998 		stats->rx_multicast;
4999 	vf_stats->tx_packets = stats->tx_unicast + stats->tx_broadcast +
5000 		stats->tx_multicast;
5001 	vf_stats->rx_bytes   = stats->rx_bytes;
5002 	vf_stats->tx_bytes   = stats->tx_bytes;
5003 	vf_stats->broadcast  = stats->rx_broadcast;
5004 	vf_stats->multicast  = stats->rx_multicast;
5005 	vf_stats->rx_dropped = stats->rx_discards + stats->rx_discards_other;
5006 	vf_stats->tx_dropped = stats->tx_discards;
5007 
5008 	return 0;
5009 }
5010