Loading...
Note: File does not exist in v3.1.
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 **/
21static 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 **/
46int 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 **/
66int 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
114out_alloc:
115 kfree(event.msg_buf);
116out:
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 **/
128int 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 **/
162static 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 **/
190int 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);
229out_alloc:
230 kfree(event.msg_buf);
231out:
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 **/
241void 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 **/
300void 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 **/
325void 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 **/
351void 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 **/
406void 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 **/
476void 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 **/
546void 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 **/
616void 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 **/
688void 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 **/
735void 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 **/
758void 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 **/
777void 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 **/
800void 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 **/
832void 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 **/
863void 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 **/
882void 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 */
903static 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 = kcalloc(1, 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
953print_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 **/
979static bool
980iavf_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 **/
996static void
997iavf_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 **/
1014void 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 **/
1054void 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 **/
1077static 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 **/
1111void 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 **/
1159void 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 **/
1206void 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 **/
1225void 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}