1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright(c) 2013 - 2018 Intel Corporation. */
3 
4 #include "iavf.h"
5 #include "iavf_prototype.h"
6 #include "iavf_client.h"
7 
8 /* busy wait delay in msec */
9 #define IAVF_BUSY_WAIT_DELAY 10
10 #define IAVF_BUSY_WAIT_COUNT 50
11 
12 /**
13  * iavf_send_pf_msg
14  * @adapter: adapter structure
15  * @op: virtual channel opcode
16  * @msg: pointer to message buffer
17  * @len: message length
18  *
19  * Send message to PF and print status if failure.
20  **/
21 static int iavf_send_pf_msg(struct iavf_adapter *adapter,
22 			    enum virtchnl_ops op, u8 *msg, u16 len)
23 {
24 	struct iavf_hw *hw = &adapter->hw;
25 	enum iavf_status err;
26 
27 	if (adapter->flags & IAVF_FLAG_PF_COMMS_FAILED)
28 		return 0; /* nothing to see here, move along */
29 
30 	err = iavf_aq_send_msg_to_pf(hw, op, 0, msg, len, NULL);
31 	if (err)
32 		dev_dbg(&adapter->pdev->dev, "Unable to send opcode %d to PF, err %s, aq_err %s\n",
33 			op, iavf_stat_str(hw, err),
34 			iavf_aq_str(hw, hw->aq.asq_last_status));
35 	return err;
36 }
37 
38 /**
39  * iavf_send_api_ver
40  * @adapter: adapter structure
41  *
42  * Send API version admin queue message to the PF. The reply is not checked
43  * in this function. Returns 0 if the message was successfully
44  * sent, or one of the IAVF_ADMIN_QUEUE_ERROR_ statuses if not.
45  **/
46 int iavf_send_api_ver(struct iavf_adapter *adapter)
47 {
48 	struct virtchnl_version_info vvi;
49 
50 	vvi.major = VIRTCHNL_VERSION_MAJOR;
51 	vvi.minor = VIRTCHNL_VERSION_MINOR;
52 
53 	return iavf_send_pf_msg(adapter, VIRTCHNL_OP_VERSION, (u8 *)&vvi,
54 				sizeof(vvi));
55 }
56 
57 /**
58  * iavf_verify_api_ver
59  * @adapter: adapter structure
60  *
61  * Compare API versions with the PF. Must be called after admin queue is
62  * initialized. Returns 0 if API versions match, -EIO if they do not,
63  * IAVF_ERR_ADMIN_QUEUE_NO_WORK if the admin queue is empty, and any errors
64  * from the firmware are propagated.
65  **/
66 int iavf_verify_api_ver(struct iavf_adapter *adapter)
67 {
68 	struct virtchnl_version_info *pf_vvi;
69 	struct iavf_hw *hw = &adapter->hw;
70 	struct iavf_arq_event_info event;
71 	enum virtchnl_ops op;
72 	enum iavf_status err;
73 
74 	event.buf_len = IAVF_MAX_AQ_BUF_SIZE;
75 	event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL);
76 	if (!event.msg_buf) {
77 		err = -ENOMEM;
78 		goto out;
79 	}
80 
81 	while (1) {
82 		err = iavf_clean_arq_element(hw, &event, NULL);
83 		/* When the AQ is empty, iavf_clean_arq_element will return
84 		 * nonzero and this loop will terminate.
85 		 */
86 		if (err)
87 			goto out_alloc;
88 		op =
89 		    (enum virtchnl_ops)le32_to_cpu(event.desc.cookie_high);
90 		if (op == VIRTCHNL_OP_VERSION)
91 			break;
92 	}
93 
94 
95 	err = (enum iavf_status)le32_to_cpu(event.desc.cookie_low);
96 	if (err)
97 		goto out_alloc;
98 
99 	if (op != VIRTCHNL_OP_VERSION) {
100 		dev_info(&adapter->pdev->dev, "Invalid reply type %d from PF\n",
101 			op);
102 		err = -EIO;
103 		goto out_alloc;
104 	}
105 
106 	pf_vvi = (struct virtchnl_version_info *)event.msg_buf;
107 	adapter->pf_version = *pf_vvi;
108 
109 	if ((pf_vvi->major > VIRTCHNL_VERSION_MAJOR) ||
110 	    ((pf_vvi->major == VIRTCHNL_VERSION_MAJOR) &&
111 	     (pf_vvi->minor > VIRTCHNL_VERSION_MINOR)))
112 		err = -EIO;
113 
114 out_alloc:
115 	kfree(event.msg_buf);
116 out:
117 	return err;
118 }
119 
120 /**
121  * iavf_send_vf_config_msg
122  * @adapter: adapter structure
123  *
124  * Send VF configuration request admin queue message to the PF. The reply
125  * is not checked in this function. Returns 0 if the message was
126  * successfully sent, or one of the IAVF_ADMIN_QUEUE_ERROR_ statuses if not.
127  **/
128 int iavf_send_vf_config_msg(struct iavf_adapter *adapter)
129 {
130 	u32 caps;
131 
132 	caps = VIRTCHNL_VF_OFFLOAD_L2 |
133 	       VIRTCHNL_VF_OFFLOAD_RSS_PF |
134 	       VIRTCHNL_VF_OFFLOAD_RSS_AQ |
135 	       VIRTCHNL_VF_OFFLOAD_RSS_REG |
136 	       VIRTCHNL_VF_OFFLOAD_VLAN |
137 	       VIRTCHNL_VF_OFFLOAD_WB_ON_ITR |
138 	       VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2 |
139 	       VIRTCHNL_VF_OFFLOAD_ENCAP |
140 	       VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM |
141 	       VIRTCHNL_VF_OFFLOAD_REQ_QUEUES |
142 	       VIRTCHNL_VF_OFFLOAD_ADQ |
143 	       VIRTCHNL_VF_CAP_ADV_LINK_SPEED;
144 
145 	adapter->current_op = VIRTCHNL_OP_GET_VF_RESOURCES;
146 	adapter->aq_required &= ~IAVF_FLAG_AQ_GET_CONFIG;
147 	if (PF_IS_V11(adapter))
148 		return iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_VF_RESOURCES,
149 					(u8 *)&caps, sizeof(caps));
150 	else
151 		return iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_VF_RESOURCES,
152 					NULL, 0);
153 }
154 
155 /**
156  * iavf_validate_num_queues
157  * @adapter: adapter structure
158  *
159  * Validate that the number of queues the PF has sent in
160  * VIRTCHNL_OP_GET_VF_RESOURCES is not larger than the VF can handle.
161  **/
162 static void iavf_validate_num_queues(struct iavf_adapter *adapter)
163 {
164 	if (adapter->vf_res->num_queue_pairs > IAVF_MAX_REQ_QUEUES) {
165 		struct virtchnl_vsi_resource *vsi_res;
166 		int i;
167 
168 		dev_info(&adapter->pdev->dev, "Received %d queues, but can only have a max of %d\n",
169 			 adapter->vf_res->num_queue_pairs,
170 			 IAVF_MAX_REQ_QUEUES);
171 		dev_info(&adapter->pdev->dev, "Fixing by reducing queues to %d\n",
172 			 IAVF_MAX_REQ_QUEUES);
173 		adapter->vf_res->num_queue_pairs = IAVF_MAX_REQ_QUEUES;
174 		for (i = 0; i < adapter->vf_res->num_vsis; i++) {
175 			vsi_res = &adapter->vf_res->vsi_res[i];
176 			vsi_res->num_queue_pairs = IAVF_MAX_REQ_QUEUES;
177 		}
178 	}
179 }
180 
181 /**
182  * iavf_get_vf_config
183  * @adapter: private adapter structure
184  *
185  * Get VF configuration from PF and populate hw structure. Must be called after
186  * admin queue is initialized. Busy waits until response is received from PF,
187  * with maximum timeout. Response from PF is returned in the buffer for further
188  * processing by the caller.
189  **/
190 int iavf_get_vf_config(struct iavf_adapter *adapter)
191 {
192 	struct iavf_hw *hw = &adapter->hw;
193 	struct iavf_arq_event_info event;
194 	enum virtchnl_ops op;
195 	enum iavf_status err;
196 	u16 len;
197 
198 	len =  sizeof(struct virtchnl_vf_resource) +
199 		IAVF_MAX_VF_VSI * sizeof(struct virtchnl_vsi_resource);
200 	event.buf_len = len;
201 	event.msg_buf = kzalloc(event.buf_len, GFP_KERNEL);
202 	if (!event.msg_buf) {
203 		err = -ENOMEM;
204 		goto out;
205 	}
206 
207 	while (1) {
208 		/* When the AQ is empty, iavf_clean_arq_element will return
209 		 * nonzero and this loop will terminate.
210 		 */
211 		err = iavf_clean_arq_element(hw, &event, NULL);
212 		if (err)
213 			goto out_alloc;
214 		op =
215 		    (enum virtchnl_ops)le32_to_cpu(event.desc.cookie_high);
216 		if (op == VIRTCHNL_OP_GET_VF_RESOURCES)
217 			break;
218 	}
219 
220 	err = (enum iavf_status)le32_to_cpu(event.desc.cookie_low);
221 	memcpy(adapter->vf_res, event.msg_buf, min(event.msg_len, len));
222 
223 	/* some PFs send more queues than we should have so validate that
224 	 * we aren't getting too many queues
225 	 */
226 	if (!err)
227 		iavf_validate_num_queues(adapter);
228 	iavf_vf_parse_hw_config(hw, adapter->vf_res);
229 out_alloc:
230 	kfree(event.msg_buf);
231 out:
232 	return err;
233 }
234 
235 /**
236  * iavf_configure_queues
237  * @adapter: adapter structure
238  *
239  * Request that the PF set up our (previously allocated) queues.
240  **/
241 void iavf_configure_queues(struct iavf_adapter *adapter)
242 {
243 	struct virtchnl_vsi_queue_config_info *vqci;
244 	struct virtchnl_queue_pair_info *vqpi;
245 	int pairs = adapter->num_active_queues;
246 	int i, max_frame = IAVF_MAX_RXBUFFER;
247 	size_t len;
248 
249 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
250 		/* bail because we already have a command pending */
251 		dev_err(&adapter->pdev->dev, "Cannot configure queues, command %d pending\n",
252 			adapter->current_op);
253 		return;
254 	}
255 	adapter->current_op = VIRTCHNL_OP_CONFIG_VSI_QUEUES;
256 	len = struct_size(vqci, qpair, pairs);
257 	vqci = kzalloc(len, GFP_KERNEL);
258 	if (!vqci)
259 		return;
260 
261 	/* Limit maximum frame size when jumbo frames is not enabled */
262 	if (!(adapter->flags & IAVF_FLAG_LEGACY_RX) &&
263 	    (adapter->netdev->mtu <= ETH_DATA_LEN))
264 		max_frame = IAVF_RXBUFFER_1536 - NET_IP_ALIGN;
265 
266 	vqci->vsi_id = adapter->vsi_res->vsi_id;
267 	vqci->num_queue_pairs = pairs;
268 	vqpi = vqci->qpair;
269 	/* Size check is not needed here - HW max is 16 queue pairs, and we
270 	 * can fit info for 31 of them into the AQ buffer before it overflows.
271 	 */
272 	for (i = 0; i < pairs; i++) {
273 		vqpi->txq.vsi_id = vqci->vsi_id;
274 		vqpi->txq.queue_id = i;
275 		vqpi->txq.ring_len = adapter->tx_rings[i].count;
276 		vqpi->txq.dma_ring_addr = adapter->tx_rings[i].dma;
277 		vqpi->rxq.vsi_id = vqci->vsi_id;
278 		vqpi->rxq.queue_id = i;
279 		vqpi->rxq.ring_len = adapter->rx_rings[i].count;
280 		vqpi->rxq.dma_ring_addr = adapter->rx_rings[i].dma;
281 		vqpi->rxq.max_pkt_size = max_frame;
282 		vqpi->rxq.databuffer_size =
283 			ALIGN(adapter->rx_rings[i].rx_buf_len,
284 			      BIT_ULL(IAVF_RXQ_CTX_DBUFF_SHIFT));
285 		vqpi++;
286 	}
287 
288 	adapter->aq_required &= ~IAVF_FLAG_AQ_CONFIGURE_QUEUES;
289 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_VSI_QUEUES,
290 			 (u8 *)vqci, len);
291 	kfree(vqci);
292 }
293 
294 /**
295  * iavf_enable_queues
296  * @adapter: adapter structure
297  *
298  * Request that the PF enable all of our queues.
299  **/
300 void iavf_enable_queues(struct iavf_adapter *adapter)
301 {
302 	struct virtchnl_queue_select vqs;
303 
304 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
305 		/* bail because we already have a command pending */
306 		dev_err(&adapter->pdev->dev, "Cannot enable queues, command %d pending\n",
307 			adapter->current_op);
308 		return;
309 	}
310 	adapter->current_op = VIRTCHNL_OP_ENABLE_QUEUES;
311 	vqs.vsi_id = adapter->vsi_res->vsi_id;
312 	vqs.tx_queues = BIT(adapter->num_active_queues) - 1;
313 	vqs.rx_queues = vqs.tx_queues;
314 	adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_QUEUES;
315 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_QUEUES,
316 			 (u8 *)&vqs, sizeof(vqs));
317 }
318 
319 /**
320  * iavf_disable_queues
321  * @adapter: adapter structure
322  *
323  * Request that the PF disable all of our queues.
324  **/
325 void iavf_disable_queues(struct iavf_adapter *adapter)
326 {
327 	struct virtchnl_queue_select vqs;
328 
329 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
330 		/* bail because we already have a command pending */
331 		dev_err(&adapter->pdev->dev, "Cannot disable queues, command %d pending\n",
332 			adapter->current_op);
333 		return;
334 	}
335 	adapter->current_op = VIRTCHNL_OP_DISABLE_QUEUES;
336 	vqs.vsi_id = adapter->vsi_res->vsi_id;
337 	vqs.tx_queues = BIT(adapter->num_active_queues) - 1;
338 	vqs.rx_queues = vqs.tx_queues;
339 	adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_QUEUES;
340 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_QUEUES,
341 			 (u8 *)&vqs, sizeof(vqs));
342 }
343 
344 /**
345  * iavf_map_queues
346  * @adapter: adapter structure
347  *
348  * Request that the PF map queues to interrupt vectors. Misc causes, including
349  * admin queue, are always mapped to vector 0.
350  **/
351 void iavf_map_queues(struct iavf_adapter *adapter)
352 {
353 	struct virtchnl_irq_map_info *vimi;
354 	struct virtchnl_vector_map *vecmap;
355 	struct iavf_q_vector *q_vector;
356 	int v_idx, q_vectors;
357 	size_t len;
358 
359 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
360 		/* bail because we already have a command pending */
361 		dev_err(&adapter->pdev->dev, "Cannot map queues to vectors, command %d pending\n",
362 			adapter->current_op);
363 		return;
364 	}
365 	adapter->current_op = VIRTCHNL_OP_CONFIG_IRQ_MAP;
366 
367 	q_vectors = adapter->num_msix_vectors - NONQ_VECS;
368 
369 	len = struct_size(vimi, vecmap, adapter->num_msix_vectors);
370 	vimi = kzalloc(len, GFP_KERNEL);
371 	if (!vimi)
372 		return;
373 
374 	vimi->num_vectors = adapter->num_msix_vectors;
375 	/* Queue vectors first */
376 	for (v_idx = 0; v_idx < q_vectors; v_idx++) {
377 		q_vector = &adapter->q_vectors[v_idx];
378 		vecmap = &vimi->vecmap[v_idx];
379 
380 		vecmap->vsi_id = adapter->vsi_res->vsi_id;
381 		vecmap->vector_id = v_idx + NONQ_VECS;
382 		vecmap->txq_map = q_vector->ring_mask;
383 		vecmap->rxq_map = q_vector->ring_mask;
384 		vecmap->rxitr_idx = IAVF_RX_ITR;
385 		vecmap->txitr_idx = IAVF_TX_ITR;
386 	}
387 	/* Misc vector last - this is only for AdminQ messages */
388 	vecmap = &vimi->vecmap[v_idx];
389 	vecmap->vsi_id = adapter->vsi_res->vsi_id;
390 	vecmap->vector_id = 0;
391 	vecmap->txq_map = 0;
392 	vecmap->rxq_map = 0;
393 
394 	adapter->aq_required &= ~IAVF_FLAG_AQ_MAP_VECTORS;
395 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_IRQ_MAP,
396 			 (u8 *)vimi, len);
397 	kfree(vimi);
398 }
399 
400 /**
401  * iavf_add_ether_addrs
402  * @adapter: adapter structure
403  *
404  * Request that the PF add one or more addresses to our filters.
405  **/
406 void iavf_add_ether_addrs(struct iavf_adapter *adapter)
407 {
408 	struct virtchnl_ether_addr_list *veal;
409 	struct iavf_mac_filter *f;
410 	int i = 0, count = 0;
411 	bool more = false;
412 	size_t len;
413 
414 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
415 		/* bail because we already have a command pending */
416 		dev_err(&adapter->pdev->dev, "Cannot add filters, command %d pending\n",
417 			adapter->current_op);
418 		return;
419 	}
420 
421 	spin_lock_bh(&adapter->mac_vlan_list_lock);
422 
423 	list_for_each_entry(f, &adapter->mac_filter_list, list) {
424 		if (f->add)
425 			count++;
426 	}
427 	if (!count) {
428 		adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_MAC_FILTER;
429 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
430 		return;
431 	}
432 	adapter->current_op = VIRTCHNL_OP_ADD_ETH_ADDR;
433 
434 	len = struct_size(veal, list, count);
435 	if (len > IAVF_MAX_AQ_BUF_SIZE) {
436 		dev_warn(&adapter->pdev->dev, "Too many add MAC changes in one request\n");
437 		count = (IAVF_MAX_AQ_BUF_SIZE -
438 			 sizeof(struct virtchnl_ether_addr_list)) /
439 			sizeof(struct virtchnl_ether_addr);
440 		len = struct_size(veal, list, count);
441 		more = true;
442 	}
443 
444 	veal = kzalloc(len, GFP_ATOMIC);
445 	if (!veal) {
446 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
447 		return;
448 	}
449 
450 	veal->vsi_id = adapter->vsi_res->vsi_id;
451 	veal->num_elements = count;
452 	list_for_each_entry(f, &adapter->mac_filter_list, list) {
453 		if (f->add) {
454 			ether_addr_copy(veal->list[i].addr, f->macaddr);
455 			i++;
456 			f->add = false;
457 			if (i == count)
458 				break;
459 		}
460 	}
461 	if (!more)
462 		adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_MAC_FILTER;
463 
464 	spin_unlock_bh(&adapter->mac_vlan_list_lock);
465 
466 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_ETH_ADDR, (u8 *)veal, len);
467 	kfree(veal);
468 }
469 
470 /**
471  * iavf_del_ether_addrs
472  * @adapter: adapter structure
473  *
474  * Request that the PF remove one or more addresses from our filters.
475  **/
476 void iavf_del_ether_addrs(struct iavf_adapter *adapter)
477 {
478 	struct virtchnl_ether_addr_list *veal;
479 	struct iavf_mac_filter *f, *ftmp;
480 	int i = 0, count = 0;
481 	bool more = false;
482 	size_t len;
483 
484 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
485 		/* bail because we already have a command pending */
486 		dev_err(&adapter->pdev->dev, "Cannot remove filters, command %d pending\n",
487 			adapter->current_op);
488 		return;
489 	}
490 
491 	spin_lock_bh(&adapter->mac_vlan_list_lock);
492 
493 	list_for_each_entry(f, &adapter->mac_filter_list, list) {
494 		if (f->remove)
495 			count++;
496 	}
497 	if (!count) {
498 		adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_MAC_FILTER;
499 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
500 		return;
501 	}
502 	adapter->current_op = VIRTCHNL_OP_DEL_ETH_ADDR;
503 
504 	len = struct_size(veal, list, count);
505 	if (len > IAVF_MAX_AQ_BUF_SIZE) {
506 		dev_warn(&adapter->pdev->dev, "Too many delete MAC changes in one request\n");
507 		count = (IAVF_MAX_AQ_BUF_SIZE -
508 			 sizeof(struct virtchnl_ether_addr_list)) /
509 			sizeof(struct virtchnl_ether_addr);
510 		len = struct_size(veal, list, count);
511 		more = true;
512 	}
513 	veal = kzalloc(len, GFP_ATOMIC);
514 	if (!veal) {
515 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
516 		return;
517 	}
518 
519 	veal->vsi_id = adapter->vsi_res->vsi_id;
520 	veal->num_elements = count;
521 	list_for_each_entry_safe(f, ftmp, &adapter->mac_filter_list, list) {
522 		if (f->remove) {
523 			ether_addr_copy(veal->list[i].addr, f->macaddr);
524 			i++;
525 			list_del(&f->list);
526 			kfree(f);
527 			if (i == count)
528 				break;
529 		}
530 	}
531 	if (!more)
532 		adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_MAC_FILTER;
533 
534 	spin_unlock_bh(&adapter->mac_vlan_list_lock);
535 
536 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_ETH_ADDR, (u8 *)veal, len);
537 	kfree(veal);
538 }
539 
540 /**
541  * iavf_add_vlans
542  * @adapter: adapter structure
543  *
544  * Request that the PF add one or more VLAN filters to our VSI.
545  **/
546 void iavf_add_vlans(struct iavf_adapter *adapter)
547 {
548 	struct virtchnl_vlan_filter_list *vvfl;
549 	int len, i = 0, count = 0;
550 	struct iavf_vlan_filter *f;
551 	bool more = false;
552 
553 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
554 		/* bail because we already have a command pending */
555 		dev_err(&adapter->pdev->dev, "Cannot add VLANs, command %d pending\n",
556 			adapter->current_op);
557 		return;
558 	}
559 
560 	spin_lock_bh(&adapter->mac_vlan_list_lock);
561 
562 	list_for_each_entry(f, &adapter->vlan_filter_list, list) {
563 		if (f->add)
564 			count++;
565 	}
566 	if (!count) {
567 		adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_VLAN_FILTER;
568 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
569 		return;
570 	}
571 	adapter->current_op = VIRTCHNL_OP_ADD_VLAN;
572 
573 	len = sizeof(struct virtchnl_vlan_filter_list) +
574 	      (count * sizeof(u16));
575 	if (len > IAVF_MAX_AQ_BUF_SIZE) {
576 		dev_warn(&adapter->pdev->dev, "Too many add VLAN changes in one request\n");
577 		count = (IAVF_MAX_AQ_BUF_SIZE -
578 			 sizeof(struct virtchnl_vlan_filter_list)) /
579 			sizeof(u16);
580 		len = sizeof(struct virtchnl_vlan_filter_list) +
581 		      (count * sizeof(u16));
582 		more = true;
583 	}
584 	vvfl = kzalloc(len, GFP_ATOMIC);
585 	if (!vvfl) {
586 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
587 		return;
588 	}
589 
590 	vvfl->vsi_id = adapter->vsi_res->vsi_id;
591 	vvfl->num_elements = count;
592 	list_for_each_entry(f, &adapter->vlan_filter_list, list) {
593 		if (f->add) {
594 			vvfl->vlan_id[i] = f->vlan;
595 			i++;
596 			f->add = false;
597 			if (i == count)
598 				break;
599 		}
600 	}
601 	if (!more)
602 		adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_VLAN_FILTER;
603 
604 	spin_unlock_bh(&adapter->mac_vlan_list_lock);
605 
606 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_VLAN, (u8 *)vvfl, len);
607 	kfree(vvfl);
608 }
609 
610 /**
611  * iavf_del_vlans
612  * @adapter: adapter structure
613  *
614  * Request that the PF remove one or more VLAN filters from our VSI.
615  **/
616 void iavf_del_vlans(struct iavf_adapter *adapter)
617 {
618 	struct virtchnl_vlan_filter_list *vvfl;
619 	struct iavf_vlan_filter *f, *ftmp;
620 	int len, i = 0, count = 0;
621 	bool more = false;
622 
623 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
624 		/* bail because we already have a command pending */
625 		dev_err(&adapter->pdev->dev, "Cannot remove VLANs, command %d pending\n",
626 			adapter->current_op);
627 		return;
628 	}
629 
630 	spin_lock_bh(&adapter->mac_vlan_list_lock);
631 
632 	list_for_each_entry(f, &adapter->vlan_filter_list, list) {
633 		if (f->remove)
634 			count++;
635 	}
636 	if (!count) {
637 		adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_VLAN_FILTER;
638 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
639 		return;
640 	}
641 	adapter->current_op = VIRTCHNL_OP_DEL_VLAN;
642 
643 	len = sizeof(struct virtchnl_vlan_filter_list) +
644 	      (count * sizeof(u16));
645 	if (len > IAVF_MAX_AQ_BUF_SIZE) {
646 		dev_warn(&adapter->pdev->dev, "Too many delete VLAN changes in one request\n");
647 		count = (IAVF_MAX_AQ_BUF_SIZE -
648 			 sizeof(struct virtchnl_vlan_filter_list)) /
649 			sizeof(u16);
650 		len = sizeof(struct virtchnl_vlan_filter_list) +
651 		      (count * sizeof(u16));
652 		more = true;
653 	}
654 	vvfl = kzalloc(len, GFP_ATOMIC);
655 	if (!vvfl) {
656 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
657 		return;
658 	}
659 
660 	vvfl->vsi_id = adapter->vsi_res->vsi_id;
661 	vvfl->num_elements = count;
662 	list_for_each_entry_safe(f, ftmp, &adapter->vlan_filter_list, list) {
663 		if (f->remove) {
664 			vvfl->vlan_id[i] = f->vlan;
665 			i++;
666 			list_del(&f->list);
667 			kfree(f);
668 			if (i == count)
669 				break;
670 		}
671 	}
672 	if (!more)
673 		adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_VLAN_FILTER;
674 
675 	spin_unlock_bh(&adapter->mac_vlan_list_lock);
676 
677 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_VLAN, (u8 *)vvfl, len);
678 	kfree(vvfl);
679 }
680 
681 /**
682  * iavf_set_promiscuous
683  * @adapter: adapter structure
684  * @flags: bitmask to control unicast/multicast promiscuous.
685  *
686  * Request that the PF enable promiscuous mode for our VSI.
687  **/
688 void iavf_set_promiscuous(struct iavf_adapter *adapter, int flags)
689 {
690 	struct virtchnl_promisc_info vpi;
691 	int promisc_all;
692 
693 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
694 		/* bail because we already have a command pending */
695 		dev_err(&adapter->pdev->dev, "Cannot set promiscuous mode, command %d pending\n",
696 			adapter->current_op);
697 		return;
698 	}
699 
700 	promisc_all = FLAG_VF_UNICAST_PROMISC |
701 		      FLAG_VF_MULTICAST_PROMISC;
702 	if ((flags & promisc_all) == promisc_all) {
703 		adapter->flags |= IAVF_FLAG_PROMISC_ON;
704 		adapter->aq_required &= ~IAVF_FLAG_AQ_REQUEST_PROMISC;
705 		dev_info(&adapter->pdev->dev, "Entering promiscuous mode\n");
706 	}
707 
708 	if (flags & FLAG_VF_MULTICAST_PROMISC) {
709 		adapter->flags |= IAVF_FLAG_ALLMULTI_ON;
710 		adapter->aq_required &= ~IAVF_FLAG_AQ_REQUEST_ALLMULTI;
711 		dev_info(&adapter->pdev->dev, "Entering multicast promiscuous mode\n");
712 	}
713 
714 	if (!flags) {
715 		adapter->flags &= ~(IAVF_FLAG_PROMISC_ON |
716 				    IAVF_FLAG_ALLMULTI_ON);
717 		adapter->aq_required &= ~(IAVF_FLAG_AQ_RELEASE_PROMISC |
718 					  IAVF_FLAG_AQ_RELEASE_ALLMULTI);
719 		dev_info(&adapter->pdev->dev, "Leaving promiscuous mode\n");
720 	}
721 
722 	adapter->current_op = VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE;
723 	vpi.vsi_id = adapter->vsi_res->vsi_id;
724 	vpi.flags = flags;
725 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE,
726 			 (u8 *)&vpi, sizeof(vpi));
727 }
728 
729 /**
730  * iavf_request_stats
731  * @adapter: adapter structure
732  *
733  * Request VSI statistics from PF.
734  **/
735 void iavf_request_stats(struct iavf_adapter *adapter)
736 {
737 	struct virtchnl_queue_select vqs;
738 
739 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
740 		/* no error message, this isn't crucial */
741 		return;
742 	}
743 	adapter->current_op = VIRTCHNL_OP_GET_STATS;
744 	vqs.vsi_id = adapter->vsi_res->vsi_id;
745 	/* queue maps are ignored for this message - only the vsi is used */
746 	if (iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_STATS, (u8 *)&vqs,
747 			     sizeof(vqs)))
748 		/* if the request failed, don't lock out others */
749 		adapter->current_op = VIRTCHNL_OP_UNKNOWN;
750 }
751 
752 /**
753  * iavf_get_hena
754  * @adapter: adapter structure
755  *
756  * Request hash enable capabilities from PF
757  **/
758 void iavf_get_hena(struct iavf_adapter *adapter)
759 {
760 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
761 		/* bail because we already have a command pending */
762 		dev_err(&adapter->pdev->dev, "Cannot get RSS hash capabilities, command %d pending\n",
763 			adapter->current_op);
764 		return;
765 	}
766 	adapter->current_op = VIRTCHNL_OP_GET_RSS_HENA_CAPS;
767 	adapter->aq_required &= ~IAVF_FLAG_AQ_GET_HENA;
768 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_GET_RSS_HENA_CAPS, NULL, 0);
769 }
770 
771 /**
772  * iavf_set_hena
773  * @adapter: adapter structure
774  *
775  * Request the PF to set our RSS hash capabilities
776  **/
777 void iavf_set_hena(struct iavf_adapter *adapter)
778 {
779 	struct virtchnl_rss_hena vrh;
780 
781 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
782 		/* bail because we already have a command pending */
783 		dev_err(&adapter->pdev->dev, "Cannot set RSS hash enable, command %d pending\n",
784 			adapter->current_op);
785 		return;
786 	}
787 	vrh.hena = adapter->hena;
788 	adapter->current_op = VIRTCHNL_OP_SET_RSS_HENA;
789 	adapter->aq_required &= ~IAVF_FLAG_AQ_SET_HENA;
790 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_SET_RSS_HENA, (u8 *)&vrh,
791 			 sizeof(vrh));
792 }
793 
794 /**
795  * iavf_set_rss_key
796  * @adapter: adapter structure
797  *
798  * Request the PF to set our RSS hash key
799  **/
800 void iavf_set_rss_key(struct iavf_adapter *adapter)
801 {
802 	struct virtchnl_rss_key *vrk;
803 	int len;
804 
805 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
806 		/* bail because we already have a command pending */
807 		dev_err(&adapter->pdev->dev, "Cannot set RSS key, command %d pending\n",
808 			adapter->current_op);
809 		return;
810 	}
811 	len = sizeof(struct virtchnl_rss_key) +
812 	      (adapter->rss_key_size * sizeof(u8)) - 1;
813 	vrk = kzalloc(len, GFP_KERNEL);
814 	if (!vrk)
815 		return;
816 	vrk->vsi_id = adapter->vsi.id;
817 	vrk->key_len = adapter->rss_key_size;
818 	memcpy(vrk->key, adapter->rss_key, adapter->rss_key_size);
819 
820 	adapter->current_op = VIRTCHNL_OP_CONFIG_RSS_KEY;
821 	adapter->aq_required &= ~IAVF_FLAG_AQ_SET_RSS_KEY;
822 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_RSS_KEY, (u8 *)vrk, len);
823 	kfree(vrk);
824 }
825 
826 /**
827  * iavf_set_rss_lut
828  * @adapter: adapter structure
829  *
830  * Request the PF to set our RSS lookup table
831  **/
832 void iavf_set_rss_lut(struct iavf_adapter *adapter)
833 {
834 	struct virtchnl_rss_lut *vrl;
835 	int len;
836 
837 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
838 		/* bail because we already have a command pending */
839 		dev_err(&adapter->pdev->dev, "Cannot set RSS LUT, command %d pending\n",
840 			adapter->current_op);
841 		return;
842 	}
843 	len = sizeof(struct virtchnl_rss_lut) +
844 	      (adapter->rss_lut_size * sizeof(u8)) - 1;
845 	vrl = kzalloc(len, GFP_KERNEL);
846 	if (!vrl)
847 		return;
848 	vrl->vsi_id = adapter->vsi.id;
849 	vrl->lut_entries = adapter->rss_lut_size;
850 	memcpy(vrl->lut, adapter->rss_lut, adapter->rss_lut_size);
851 	adapter->current_op = VIRTCHNL_OP_CONFIG_RSS_LUT;
852 	adapter->aq_required &= ~IAVF_FLAG_AQ_SET_RSS_LUT;
853 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_CONFIG_RSS_LUT, (u8 *)vrl, len);
854 	kfree(vrl);
855 }
856 
857 /**
858  * iavf_enable_vlan_stripping
859  * @adapter: adapter structure
860  *
861  * Request VLAN header stripping to be enabled
862  **/
863 void iavf_enable_vlan_stripping(struct iavf_adapter *adapter)
864 {
865 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
866 		/* bail because we already have a command pending */
867 		dev_err(&adapter->pdev->dev, "Cannot enable stripping, command %d pending\n",
868 			adapter->current_op);
869 		return;
870 	}
871 	adapter->current_op = VIRTCHNL_OP_ENABLE_VLAN_STRIPPING;
872 	adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_VLAN_STRIPPING;
873 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING, NULL, 0);
874 }
875 
876 /**
877  * iavf_disable_vlan_stripping
878  * @adapter: adapter structure
879  *
880  * Request VLAN header stripping to be disabled
881  **/
882 void iavf_disable_vlan_stripping(struct iavf_adapter *adapter)
883 {
884 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
885 		/* bail because we already have a command pending */
886 		dev_err(&adapter->pdev->dev, "Cannot disable stripping, command %d pending\n",
887 			adapter->current_op);
888 		return;
889 	}
890 	adapter->current_op = VIRTCHNL_OP_DISABLE_VLAN_STRIPPING;
891 	adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_VLAN_STRIPPING;
892 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING, NULL, 0);
893 }
894 
895 #define IAVF_MAX_SPEED_STRLEN	13
896 
897 /**
898  * iavf_print_link_message - print link up or down
899  * @adapter: adapter structure
900  *
901  * Log a message telling the world of our wonderous link status
902  */
903 static void iavf_print_link_message(struct iavf_adapter *adapter)
904 {
905 	struct net_device *netdev = adapter->netdev;
906 	int link_speed_mbps;
907 	char *speed;
908 
909 	if (!adapter->link_up) {
910 		netdev_info(netdev, "NIC Link is Down\n");
911 		return;
912 	}
913 
914 	speed = kzalloc(IAVF_MAX_SPEED_STRLEN, GFP_KERNEL);
915 	if (!speed)
916 		return;
917 
918 	if (ADV_LINK_SUPPORT(adapter)) {
919 		link_speed_mbps = adapter->link_speed_mbps;
920 		goto print_link_msg;
921 	}
922 
923 	switch (adapter->link_speed) {
924 	case VIRTCHNL_LINK_SPEED_40GB:
925 		link_speed_mbps = SPEED_40000;
926 		break;
927 	case VIRTCHNL_LINK_SPEED_25GB:
928 		link_speed_mbps = SPEED_25000;
929 		break;
930 	case VIRTCHNL_LINK_SPEED_20GB:
931 		link_speed_mbps = SPEED_20000;
932 		break;
933 	case VIRTCHNL_LINK_SPEED_10GB:
934 		link_speed_mbps = SPEED_10000;
935 		break;
936 	case VIRTCHNL_LINK_SPEED_5GB:
937 		link_speed_mbps = SPEED_5000;
938 		break;
939 	case VIRTCHNL_LINK_SPEED_2_5GB:
940 		link_speed_mbps = SPEED_2500;
941 		break;
942 	case VIRTCHNL_LINK_SPEED_1GB:
943 		link_speed_mbps = SPEED_1000;
944 		break;
945 	case VIRTCHNL_LINK_SPEED_100MB:
946 		link_speed_mbps = SPEED_100;
947 		break;
948 	default:
949 		link_speed_mbps = SPEED_UNKNOWN;
950 		break;
951 	}
952 
953 print_link_msg:
954 	if (link_speed_mbps > SPEED_1000) {
955 		if (link_speed_mbps == SPEED_2500)
956 			snprintf(speed, IAVF_MAX_SPEED_STRLEN, "2.5 Gbps");
957 		else
958 			/* convert to Gbps inline */
959 			snprintf(speed, IAVF_MAX_SPEED_STRLEN, "%d %s",
960 				 link_speed_mbps / 1000, "Gbps");
961 	} else if (link_speed_mbps == SPEED_UNKNOWN) {
962 		snprintf(speed, IAVF_MAX_SPEED_STRLEN, "%s", "Unknown Mbps");
963 	} else {
964 		snprintf(speed, IAVF_MAX_SPEED_STRLEN, "%u %s",
965 			 link_speed_mbps, "Mbps");
966 	}
967 
968 	netdev_info(netdev, "NIC Link is Up Speed is %s Full Duplex\n", speed);
969 	kfree(speed);
970 }
971 
972 /**
973  * iavf_get_vpe_link_status
974  * @adapter: adapter structure
975  * @vpe: virtchnl_pf_event structure
976  *
977  * Helper function for determining the link status
978  **/
979 static bool
980 iavf_get_vpe_link_status(struct iavf_adapter *adapter,
981 			 struct virtchnl_pf_event *vpe)
982 {
983 	if (ADV_LINK_SUPPORT(adapter))
984 		return vpe->event_data.link_event_adv.link_status;
985 	else
986 		return vpe->event_data.link_event.link_status;
987 }
988 
989 /**
990  * iavf_set_adapter_link_speed_from_vpe
991  * @adapter: adapter structure for which we are setting the link speed
992  * @vpe: virtchnl_pf_event structure that contains the link speed we are setting
993  *
994  * Helper function for setting iavf_adapter link speed
995  **/
996 static void
997 iavf_set_adapter_link_speed_from_vpe(struct iavf_adapter *adapter,
998 				     struct virtchnl_pf_event *vpe)
999 {
1000 	if (ADV_LINK_SUPPORT(adapter))
1001 		adapter->link_speed_mbps =
1002 			vpe->event_data.link_event_adv.link_speed;
1003 	else
1004 		adapter->link_speed = vpe->event_data.link_event.link_speed;
1005 }
1006 
1007 /**
1008  * iavf_enable_channel
1009  * @adapter: adapter structure
1010  *
1011  * Request that the PF enable channels as specified by
1012  * the user via tc tool.
1013  **/
1014 void iavf_enable_channels(struct iavf_adapter *adapter)
1015 {
1016 	struct virtchnl_tc_info *vti = NULL;
1017 	size_t len;
1018 	int i;
1019 
1020 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
1021 		/* bail because we already have a command pending */
1022 		dev_err(&adapter->pdev->dev, "Cannot configure mqprio, command %d pending\n",
1023 			adapter->current_op);
1024 		return;
1025 	}
1026 
1027 	len = struct_size(vti, list, adapter->num_tc - 1);
1028 	vti = kzalloc(len, GFP_KERNEL);
1029 	if (!vti)
1030 		return;
1031 	vti->num_tc = adapter->num_tc;
1032 	for (i = 0; i < vti->num_tc; i++) {
1033 		vti->list[i].count = adapter->ch_config.ch_info[i].count;
1034 		vti->list[i].offset = adapter->ch_config.ch_info[i].offset;
1035 		vti->list[i].pad = 0;
1036 		vti->list[i].max_tx_rate =
1037 				adapter->ch_config.ch_info[i].max_tx_rate;
1038 	}
1039 
1040 	adapter->ch_config.state = __IAVF_TC_RUNNING;
1041 	adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED;
1042 	adapter->current_op = VIRTCHNL_OP_ENABLE_CHANNELS;
1043 	adapter->aq_required &= ~IAVF_FLAG_AQ_ENABLE_CHANNELS;
1044 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_ENABLE_CHANNELS, (u8 *)vti, len);
1045 	kfree(vti);
1046 }
1047 
1048 /**
1049  * iavf_disable_channel
1050  * @adapter: adapter structure
1051  *
1052  * Request that the PF disable channels that are configured
1053  **/
1054 void iavf_disable_channels(struct iavf_adapter *adapter)
1055 {
1056 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
1057 		/* bail because we already have a command pending */
1058 		dev_err(&adapter->pdev->dev, "Cannot configure mqprio, command %d pending\n",
1059 			adapter->current_op);
1060 		return;
1061 	}
1062 
1063 	adapter->ch_config.state = __IAVF_TC_INVALID;
1064 	adapter->flags |= IAVF_FLAG_REINIT_ITR_NEEDED;
1065 	adapter->current_op = VIRTCHNL_OP_DISABLE_CHANNELS;
1066 	adapter->aq_required &= ~IAVF_FLAG_AQ_DISABLE_CHANNELS;
1067 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_DISABLE_CHANNELS, NULL, 0);
1068 }
1069 
1070 /**
1071  * iavf_print_cloud_filter
1072  * @adapter: adapter structure
1073  * @f: cloud filter to print
1074  *
1075  * Print the cloud filter
1076  **/
1077 static void iavf_print_cloud_filter(struct iavf_adapter *adapter,
1078 				    struct virtchnl_filter *f)
1079 {
1080 	switch (f->flow_type) {
1081 	case VIRTCHNL_TCP_V4_FLOW:
1082 		dev_info(&adapter->pdev->dev, "dst_mac: %pM src_mac: %pM vlan_id: %hu dst_ip: %pI4 src_ip %pI4 dst_port %hu src_port %hu\n",
1083 			 &f->data.tcp_spec.dst_mac,
1084 			 &f->data.tcp_spec.src_mac,
1085 			 ntohs(f->data.tcp_spec.vlan_id),
1086 			 &f->data.tcp_spec.dst_ip[0],
1087 			 &f->data.tcp_spec.src_ip[0],
1088 			 ntohs(f->data.tcp_spec.dst_port),
1089 			 ntohs(f->data.tcp_spec.src_port));
1090 		break;
1091 	case VIRTCHNL_TCP_V6_FLOW:
1092 		dev_info(&adapter->pdev->dev, "dst_mac: %pM src_mac: %pM vlan_id: %hu dst_ip: %pI6 src_ip %pI6 dst_port %hu src_port %hu\n",
1093 			 &f->data.tcp_spec.dst_mac,
1094 			 &f->data.tcp_spec.src_mac,
1095 			 ntohs(f->data.tcp_spec.vlan_id),
1096 			 &f->data.tcp_spec.dst_ip,
1097 			 &f->data.tcp_spec.src_ip,
1098 			 ntohs(f->data.tcp_spec.dst_port),
1099 			 ntohs(f->data.tcp_spec.src_port));
1100 		break;
1101 	}
1102 }
1103 
1104 /**
1105  * iavf_add_cloud_filter
1106  * @adapter: adapter structure
1107  *
1108  * Request that the PF add cloud filters as specified
1109  * by the user via tc tool.
1110  **/
1111 void iavf_add_cloud_filter(struct iavf_adapter *adapter)
1112 {
1113 	struct iavf_cloud_filter *cf;
1114 	struct virtchnl_filter *f;
1115 	int len = 0, count = 0;
1116 
1117 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
1118 		/* bail because we already have a command pending */
1119 		dev_err(&adapter->pdev->dev, "Cannot add cloud filter, command %d pending\n",
1120 			adapter->current_op);
1121 		return;
1122 	}
1123 	list_for_each_entry(cf, &adapter->cloud_filter_list, list) {
1124 		if (cf->add) {
1125 			count++;
1126 			break;
1127 		}
1128 	}
1129 	if (!count) {
1130 		adapter->aq_required &= ~IAVF_FLAG_AQ_ADD_CLOUD_FILTER;
1131 		return;
1132 	}
1133 	adapter->current_op = VIRTCHNL_OP_ADD_CLOUD_FILTER;
1134 
1135 	len = sizeof(struct virtchnl_filter);
1136 	f = kzalloc(len, GFP_KERNEL);
1137 	if (!f)
1138 		return;
1139 
1140 	list_for_each_entry(cf, &adapter->cloud_filter_list, list) {
1141 		if (cf->add) {
1142 			memcpy(f, &cf->f, sizeof(struct virtchnl_filter));
1143 			cf->add = false;
1144 			cf->state = __IAVF_CF_ADD_PENDING;
1145 			iavf_send_pf_msg(adapter, VIRTCHNL_OP_ADD_CLOUD_FILTER,
1146 					 (u8 *)f, len);
1147 		}
1148 	}
1149 	kfree(f);
1150 }
1151 
1152 /**
1153  * iavf_del_cloud_filter
1154  * @adapter: adapter structure
1155  *
1156  * Request that the PF delete cloud filters as specified
1157  * by the user via tc tool.
1158  **/
1159 void iavf_del_cloud_filter(struct iavf_adapter *adapter)
1160 {
1161 	struct iavf_cloud_filter *cf, *cftmp;
1162 	struct virtchnl_filter *f;
1163 	int len = 0, count = 0;
1164 
1165 	if (adapter->current_op != VIRTCHNL_OP_UNKNOWN) {
1166 		/* bail because we already have a command pending */
1167 		dev_err(&adapter->pdev->dev, "Cannot remove cloud filter, command %d pending\n",
1168 			adapter->current_op);
1169 		return;
1170 	}
1171 	list_for_each_entry(cf, &adapter->cloud_filter_list, list) {
1172 		if (cf->del) {
1173 			count++;
1174 			break;
1175 		}
1176 	}
1177 	if (!count) {
1178 		adapter->aq_required &= ~IAVF_FLAG_AQ_DEL_CLOUD_FILTER;
1179 		return;
1180 	}
1181 	adapter->current_op = VIRTCHNL_OP_DEL_CLOUD_FILTER;
1182 
1183 	len = sizeof(struct virtchnl_filter);
1184 	f = kzalloc(len, GFP_KERNEL);
1185 	if (!f)
1186 		return;
1187 
1188 	list_for_each_entry_safe(cf, cftmp, &adapter->cloud_filter_list, list) {
1189 		if (cf->del) {
1190 			memcpy(f, &cf->f, sizeof(struct virtchnl_filter));
1191 			cf->del = false;
1192 			cf->state = __IAVF_CF_DEL_PENDING;
1193 			iavf_send_pf_msg(adapter, VIRTCHNL_OP_DEL_CLOUD_FILTER,
1194 					 (u8 *)f, len);
1195 		}
1196 	}
1197 	kfree(f);
1198 }
1199 
1200 /**
1201  * iavf_request_reset
1202  * @adapter: adapter structure
1203  *
1204  * Request that the PF reset this VF. No response is expected.
1205  **/
1206 void iavf_request_reset(struct iavf_adapter *adapter)
1207 {
1208 	/* Don't check CURRENT_OP - this is always higher priority */
1209 	iavf_send_pf_msg(adapter, VIRTCHNL_OP_RESET_VF, NULL, 0);
1210 	adapter->current_op = VIRTCHNL_OP_UNKNOWN;
1211 }
1212 
1213 /**
1214  * iavf_virtchnl_completion
1215  * @adapter: adapter structure
1216  * @v_opcode: opcode sent by PF
1217  * @v_retval: retval sent by PF
1218  * @msg: message sent by PF
1219  * @msglen: message length
1220  *
1221  * Asynchronous completion function for admin queue messages. Rather than busy
1222  * wait, we fire off our requests and assume that no errors will be returned.
1223  * This function handles the reply messages.
1224  **/
1225 void iavf_virtchnl_completion(struct iavf_adapter *adapter,
1226 			      enum virtchnl_ops v_opcode,
1227 			      enum iavf_status v_retval, u8 *msg, u16 msglen)
1228 {
1229 	struct net_device *netdev = adapter->netdev;
1230 
1231 	if (v_opcode == VIRTCHNL_OP_EVENT) {
1232 		struct virtchnl_pf_event *vpe =
1233 			(struct virtchnl_pf_event *)msg;
1234 		bool link_up = iavf_get_vpe_link_status(adapter, vpe);
1235 
1236 		switch (vpe->event) {
1237 		case VIRTCHNL_EVENT_LINK_CHANGE:
1238 			iavf_set_adapter_link_speed_from_vpe(adapter, vpe);
1239 
1240 			/* we've already got the right link status, bail */
1241 			if (adapter->link_up == link_up)
1242 				break;
1243 
1244 			if (link_up) {
1245 				/* If we get link up message and start queues
1246 				 * before our queues are configured it will
1247 				 * trigger a TX hang. In that case, just ignore
1248 				 * the link status message,we'll get another one
1249 				 * after we enable queues and actually prepared
1250 				 * to send traffic.
1251 				 */
1252 				if (adapter->state != __IAVF_RUNNING)
1253 					break;
1254 
1255 				/* For ADq enabled VF, we reconfigure VSIs and
1256 				 * re-allocate queues. Hence wait till all
1257 				 * queues are enabled.
1258 				 */
1259 				if (adapter->flags &
1260 				    IAVF_FLAG_QUEUES_DISABLED)
1261 					break;
1262 			}
1263 
1264 			adapter->link_up = link_up;
1265 			if (link_up) {
1266 				netif_tx_start_all_queues(netdev);
1267 				netif_carrier_on(netdev);
1268 			} else {
1269 				netif_tx_stop_all_queues(netdev);
1270 				netif_carrier_off(netdev);
1271 			}
1272 			iavf_print_link_message(adapter);
1273 			break;
1274 		case VIRTCHNL_EVENT_RESET_IMPENDING:
1275 			dev_info(&adapter->pdev->dev, "Reset warning received from the PF\n");
1276 			if (!(adapter->flags & IAVF_FLAG_RESET_PENDING)) {
1277 				adapter->flags |= IAVF_FLAG_RESET_PENDING;
1278 				dev_info(&adapter->pdev->dev, "Scheduling reset task\n");
1279 				queue_work(iavf_wq, &adapter->reset_task);
1280 			}
1281 			break;
1282 		default:
1283 			dev_err(&adapter->pdev->dev, "Unknown event %d from PF\n",
1284 				vpe->event);
1285 			break;
1286 		}
1287 		return;
1288 	}
1289 	if (v_retval) {
1290 		switch (v_opcode) {
1291 		case VIRTCHNL_OP_ADD_VLAN:
1292 			dev_err(&adapter->pdev->dev, "Failed to add VLAN filter, error %s\n",
1293 				iavf_stat_str(&adapter->hw, v_retval));
1294 			break;
1295 		case VIRTCHNL_OP_ADD_ETH_ADDR:
1296 			dev_err(&adapter->pdev->dev, "Failed to add MAC filter, error %s\n",
1297 				iavf_stat_str(&adapter->hw, v_retval));
1298 			/* restore administratively set MAC address */
1299 			ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr);
1300 			break;
1301 		case VIRTCHNL_OP_DEL_VLAN:
1302 			dev_err(&adapter->pdev->dev, "Failed to delete VLAN filter, error %s\n",
1303 				iavf_stat_str(&adapter->hw, v_retval));
1304 			break;
1305 		case VIRTCHNL_OP_DEL_ETH_ADDR:
1306 			dev_err(&adapter->pdev->dev, "Failed to delete MAC filter, error %s\n",
1307 				iavf_stat_str(&adapter->hw, v_retval));
1308 			break;
1309 		case VIRTCHNL_OP_ENABLE_CHANNELS:
1310 			dev_err(&adapter->pdev->dev, "Failed to configure queue channels, error %s\n",
1311 				iavf_stat_str(&adapter->hw, v_retval));
1312 			adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED;
1313 			adapter->ch_config.state = __IAVF_TC_INVALID;
1314 			netdev_reset_tc(netdev);
1315 			netif_tx_start_all_queues(netdev);
1316 			break;
1317 		case VIRTCHNL_OP_DISABLE_CHANNELS:
1318 			dev_err(&adapter->pdev->dev, "Failed to disable queue channels, error %s\n",
1319 				iavf_stat_str(&adapter->hw, v_retval));
1320 			adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED;
1321 			adapter->ch_config.state = __IAVF_TC_RUNNING;
1322 			netif_tx_start_all_queues(netdev);
1323 			break;
1324 		case VIRTCHNL_OP_ADD_CLOUD_FILTER: {
1325 			struct iavf_cloud_filter *cf, *cftmp;
1326 
1327 			list_for_each_entry_safe(cf, cftmp,
1328 						 &adapter->cloud_filter_list,
1329 						 list) {
1330 				if (cf->state == __IAVF_CF_ADD_PENDING) {
1331 					cf->state = __IAVF_CF_INVALID;
1332 					dev_info(&adapter->pdev->dev, "Failed to add cloud filter, error %s\n",
1333 						 iavf_stat_str(&adapter->hw,
1334 							       v_retval));
1335 					iavf_print_cloud_filter(adapter,
1336 								&cf->f);
1337 					list_del(&cf->list);
1338 					kfree(cf);
1339 					adapter->num_cloud_filters--;
1340 				}
1341 			}
1342 			}
1343 			break;
1344 		case VIRTCHNL_OP_DEL_CLOUD_FILTER: {
1345 			struct iavf_cloud_filter *cf;
1346 
1347 			list_for_each_entry(cf, &adapter->cloud_filter_list,
1348 					    list) {
1349 				if (cf->state == __IAVF_CF_DEL_PENDING) {
1350 					cf->state = __IAVF_CF_ACTIVE;
1351 					dev_info(&adapter->pdev->dev, "Failed to del cloud filter, error %s\n",
1352 						 iavf_stat_str(&adapter->hw,
1353 							       v_retval));
1354 					iavf_print_cloud_filter(adapter,
1355 								&cf->f);
1356 				}
1357 			}
1358 			}
1359 			break;
1360 		default:
1361 			dev_err(&adapter->pdev->dev, "PF returned error %d (%s) to our request %d\n",
1362 				v_retval, iavf_stat_str(&adapter->hw, v_retval),
1363 				v_opcode);
1364 		}
1365 	}
1366 	switch (v_opcode) {
1367 	case VIRTCHNL_OP_ADD_ETH_ADDR: {
1368 		if (!ether_addr_equal(netdev->dev_addr, adapter->hw.mac.addr))
1369 			ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
1370 		}
1371 		break;
1372 	case VIRTCHNL_OP_GET_STATS: {
1373 		struct iavf_eth_stats *stats =
1374 			(struct iavf_eth_stats *)msg;
1375 		netdev->stats.rx_packets = stats->rx_unicast +
1376 					   stats->rx_multicast +
1377 					   stats->rx_broadcast;
1378 		netdev->stats.tx_packets = stats->tx_unicast +
1379 					   stats->tx_multicast +
1380 					   stats->tx_broadcast;
1381 		netdev->stats.rx_bytes = stats->rx_bytes;
1382 		netdev->stats.tx_bytes = stats->tx_bytes;
1383 		netdev->stats.tx_errors = stats->tx_errors;
1384 		netdev->stats.rx_dropped = stats->rx_discards;
1385 		netdev->stats.tx_dropped = stats->tx_discards;
1386 		adapter->current_stats = *stats;
1387 		}
1388 		break;
1389 	case VIRTCHNL_OP_GET_VF_RESOURCES: {
1390 		u16 len = sizeof(struct virtchnl_vf_resource) +
1391 			  IAVF_MAX_VF_VSI *
1392 			  sizeof(struct virtchnl_vsi_resource);
1393 		memcpy(adapter->vf_res, msg, min(msglen, len));
1394 		iavf_validate_num_queues(adapter);
1395 		iavf_vf_parse_hw_config(&adapter->hw, adapter->vf_res);
1396 		if (is_zero_ether_addr(adapter->hw.mac.addr)) {
1397 			/* restore current mac address */
1398 			ether_addr_copy(adapter->hw.mac.addr, netdev->dev_addr);
1399 		} else {
1400 			/* refresh current mac address if changed */
1401 			ether_addr_copy(netdev->dev_addr, adapter->hw.mac.addr);
1402 			ether_addr_copy(netdev->perm_addr,
1403 					adapter->hw.mac.addr);
1404 		}
1405 		spin_lock_bh(&adapter->mac_vlan_list_lock);
1406 		iavf_add_filter(adapter, adapter->hw.mac.addr);
1407 		spin_unlock_bh(&adapter->mac_vlan_list_lock);
1408 		iavf_process_config(adapter);
1409 		}
1410 		break;
1411 	case VIRTCHNL_OP_ENABLE_QUEUES:
1412 		/* enable transmits */
1413 		iavf_irq_enable(adapter, true);
1414 		adapter->flags &= ~IAVF_FLAG_QUEUES_DISABLED;
1415 		break;
1416 	case VIRTCHNL_OP_DISABLE_QUEUES:
1417 		iavf_free_all_tx_resources(adapter);
1418 		iavf_free_all_rx_resources(adapter);
1419 		if (adapter->state == __IAVF_DOWN_PENDING) {
1420 			adapter->state = __IAVF_DOWN;
1421 			wake_up(&adapter->down_waitqueue);
1422 		}
1423 		break;
1424 	case VIRTCHNL_OP_VERSION:
1425 	case VIRTCHNL_OP_CONFIG_IRQ_MAP:
1426 		/* Don't display an error if we get these out of sequence.
1427 		 * If the firmware needed to get kicked, we'll get these and
1428 		 * it's no problem.
1429 		 */
1430 		if (v_opcode != adapter->current_op)
1431 			return;
1432 		break;
1433 	case VIRTCHNL_OP_IWARP:
1434 		/* Gobble zero-length replies from the PF. They indicate that
1435 		 * a previous message was received OK, and the client doesn't
1436 		 * care about that.
1437 		 */
1438 		if (msglen && CLIENT_ENABLED(adapter))
1439 			iavf_notify_client_message(&adapter->vsi, msg, msglen);
1440 		break;
1441 
1442 	case VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP:
1443 		adapter->client_pending &=
1444 				~(BIT(VIRTCHNL_OP_CONFIG_IWARP_IRQ_MAP));
1445 		break;
1446 	case VIRTCHNL_OP_GET_RSS_HENA_CAPS: {
1447 		struct virtchnl_rss_hena *vrh = (struct virtchnl_rss_hena *)msg;
1448 
1449 		if (msglen == sizeof(*vrh))
1450 			adapter->hena = vrh->hena;
1451 		else
1452 			dev_warn(&adapter->pdev->dev,
1453 				 "Invalid message %d from PF\n", v_opcode);
1454 		}
1455 		break;
1456 	case VIRTCHNL_OP_REQUEST_QUEUES: {
1457 		struct virtchnl_vf_res_request *vfres =
1458 			(struct virtchnl_vf_res_request *)msg;
1459 
1460 		if (vfres->num_queue_pairs != adapter->num_req_queues) {
1461 			dev_info(&adapter->pdev->dev,
1462 				 "Requested %d queues, PF can support %d\n",
1463 				 adapter->num_req_queues,
1464 				 vfres->num_queue_pairs);
1465 			adapter->num_req_queues = 0;
1466 			adapter->flags &= ~IAVF_FLAG_REINIT_ITR_NEEDED;
1467 		}
1468 		}
1469 		break;
1470 	case VIRTCHNL_OP_ADD_CLOUD_FILTER: {
1471 		struct iavf_cloud_filter *cf;
1472 
1473 		list_for_each_entry(cf, &adapter->cloud_filter_list, list) {
1474 			if (cf->state == __IAVF_CF_ADD_PENDING)
1475 				cf->state = __IAVF_CF_ACTIVE;
1476 		}
1477 		}
1478 		break;
1479 	case VIRTCHNL_OP_DEL_CLOUD_FILTER: {
1480 		struct iavf_cloud_filter *cf, *cftmp;
1481 
1482 		list_for_each_entry_safe(cf, cftmp, &adapter->cloud_filter_list,
1483 					 list) {
1484 			if (cf->state == __IAVF_CF_DEL_PENDING) {
1485 				cf->state = __IAVF_CF_INVALID;
1486 				list_del(&cf->list);
1487 				kfree(cf);
1488 				adapter->num_cloud_filters--;
1489 			}
1490 		}
1491 		}
1492 		break;
1493 	default:
1494 		if (adapter->current_op && (v_opcode != adapter->current_op))
1495 			dev_warn(&adapter->pdev->dev, "Expected response %d from PF, received %d\n",
1496 				 adapter->current_op, v_opcode);
1497 		break;
1498 	} /* switch v_opcode */
1499 	adapter->current_op = VIRTCHNL_OP_UNKNOWN;
1500 }
1501