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