Loading...
Note: File does not exist in v3.1.
1// SPDX-License-Identifier: GPL-2.0
2/* Copyright (c) 2018, Intel Corporation. */
3
4/* Intel(R) Ethernet Connection E800 Series Linux Driver */
5
6#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
7
8#include "ice.h"
9
10#define DRV_VERSION "ice-0.7.0-k"
11#define DRV_SUMMARY "Intel(R) Ethernet Connection E800 Series Linux Driver"
12const char ice_drv_ver[] = DRV_VERSION;
13static const char ice_driver_string[] = DRV_SUMMARY;
14static const char ice_copyright[] = "Copyright (c) 2018, Intel Corporation.";
15
16MODULE_AUTHOR("Intel Corporation, <linux.nics@intel.com>");
17MODULE_DESCRIPTION(DRV_SUMMARY);
18MODULE_LICENSE("GPL");
19MODULE_VERSION(DRV_VERSION);
20
21static int debug = -1;
22module_param(debug, int, 0644);
23#ifndef CONFIG_DYNAMIC_DEBUG
24MODULE_PARM_DESC(debug, "netif level (0=none,...,16=all), hw debug_mask (0x8XXXXXXX)");
25#else
26MODULE_PARM_DESC(debug, "netif level (0=none,...,16=all)");
27#endif /* !CONFIG_DYNAMIC_DEBUG */
28
29static struct workqueue_struct *ice_wq;
30static const struct net_device_ops ice_netdev_ops;
31
32static void ice_pf_dis_all_vsi(struct ice_pf *pf);
33static void ice_rebuild(struct ice_pf *pf);
34static int ice_vsi_release(struct ice_vsi *vsi);
35static void ice_update_vsi_stats(struct ice_vsi *vsi);
36static void ice_update_pf_stats(struct ice_pf *pf);
37
38/**
39 * ice_get_free_slot - get the next non-NULL location index in array
40 * @array: array to search
41 * @size: size of the array
42 * @curr: last known occupied index to be used as a search hint
43 *
44 * void * is being used to keep the functionality generic. This lets us use this
45 * function on any array of pointers.
46 */
47static int ice_get_free_slot(void *array, int size, int curr)
48{
49 int **tmp_array = (int **)array;
50 int next;
51
52 if (curr < (size - 1) && !tmp_array[curr + 1]) {
53 next = curr + 1;
54 } else {
55 int i = 0;
56
57 while ((i < size) && (tmp_array[i]))
58 i++;
59 if (i == size)
60 next = ICE_NO_VSI;
61 else
62 next = i;
63 }
64 return next;
65}
66
67/**
68 * ice_search_res - Search the tracker for a block of resources
69 * @res: pointer to the resource
70 * @needed: size of the block needed
71 * @id: identifier to track owner
72 * Returns the base item index of the block, or -ENOMEM for error
73 */
74static int ice_search_res(struct ice_res_tracker *res, u16 needed, u16 id)
75{
76 int start = res->search_hint;
77 int end = start;
78
79 id |= ICE_RES_VALID_BIT;
80
81 do {
82 /* skip already allocated entries */
83 if (res->list[end++] & ICE_RES_VALID_BIT) {
84 start = end;
85 if ((start + needed) > res->num_entries)
86 break;
87 }
88
89 if (end == (start + needed)) {
90 int i = start;
91
92 /* there was enough, so assign it to the requestor */
93 while (i != end)
94 res->list[i++] = id;
95
96 if (end == res->num_entries)
97 end = 0;
98
99 res->search_hint = end;
100 return start;
101 }
102 } while (1);
103
104 return -ENOMEM;
105}
106
107/**
108 * ice_get_res - get a block of resources
109 * @pf: board private structure
110 * @res: pointer to the resource
111 * @needed: size of the block needed
112 * @id: identifier to track owner
113 *
114 * Returns the base item index of the block, or -ENOMEM for error
115 * The search_hint trick and lack of advanced fit-finding only works
116 * because we're highly likely to have all the same sized requests.
117 * Linear search time and any fragmentation should be minimal.
118 */
119static int
120ice_get_res(struct ice_pf *pf, struct ice_res_tracker *res, u16 needed, u16 id)
121{
122 int ret;
123
124 if (!res || !pf)
125 return -EINVAL;
126
127 if (!needed || needed > res->num_entries || id >= ICE_RES_VALID_BIT) {
128 dev_err(&pf->pdev->dev,
129 "param err: needed=%d, num_entries = %d id=0x%04x\n",
130 needed, res->num_entries, id);
131 return -EINVAL;
132 }
133
134 /* search based on search_hint */
135 ret = ice_search_res(res, needed, id);
136
137 if (ret < 0) {
138 /* previous search failed. Reset search hint and try again */
139 res->search_hint = 0;
140 ret = ice_search_res(res, needed, id);
141 }
142
143 return ret;
144}
145
146/**
147 * ice_free_res - free a block of resources
148 * @res: pointer to the resource
149 * @index: starting index previously returned by ice_get_res
150 * @id: identifier to track owner
151 * Returns number of resources freed
152 */
153static int ice_free_res(struct ice_res_tracker *res, u16 index, u16 id)
154{
155 int count = 0;
156 int i;
157
158 if (!res || index >= res->num_entries)
159 return -EINVAL;
160
161 id |= ICE_RES_VALID_BIT;
162 for (i = index; i < res->num_entries && res->list[i] == id; i++) {
163 res->list[i] = 0;
164 count++;
165 }
166
167 return count;
168}
169
170/**
171 * ice_add_mac_to_list - Add a mac address filter entry to the list
172 * @vsi: the VSI to be forwarded to
173 * @add_list: pointer to the list which contains MAC filter entries
174 * @macaddr: the MAC address to be added.
175 *
176 * Adds mac address filter entry to the temp list
177 *
178 * Returns 0 on success or ENOMEM on failure.
179 */
180static int ice_add_mac_to_list(struct ice_vsi *vsi, struct list_head *add_list,
181 const u8 *macaddr)
182{
183 struct ice_fltr_list_entry *tmp;
184 struct ice_pf *pf = vsi->back;
185
186 tmp = devm_kzalloc(&pf->pdev->dev, sizeof(*tmp), GFP_ATOMIC);
187 if (!tmp)
188 return -ENOMEM;
189
190 tmp->fltr_info.flag = ICE_FLTR_TX;
191 tmp->fltr_info.src = vsi->vsi_num;
192 tmp->fltr_info.lkup_type = ICE_SW_LKUP_MAC;
193 tmp->fltr_info.fltr_act = ICE_FWD_TO_VSI;
194 tmp->fltr_info.fwd_id.vsi_id = vsi->vsi_num;
195 ether_addr_copy(tmp->fltr_info.l_data.mac.mac_addr, macaddr);
196
197 INIT_LIST_HEAD(&tmp->list_entry);
198 list_add(&tmp->list_entry, add_list);
199
200 return 0;
201}
202
203/**
204 * ice_add_mac_to_sync_list - creates list of mac addresses to be synced
205 * @netdev: the net device on which the sync is happening
206 * @addr: mac address to sync
207 *
208 * This is a callback function which is called by the in kernel device sync
209 * functions (like __dev_uc_sync, __dev_mc_sync, etc). This function only
210 * populates the tmp_sync_list, which is later used by ice_add_mac to add the
211 * mac filters from the hardware.
212 */
213static int ice_add_mac_to_sync_list(struct net_device *netdev, const u8 *addr)
214{
215 struct ice_netdev_priv *np = netdev_priv(netdev);
216 struct ice_vsi *vsi = np->vsi;
217
218 if (ice_add_mac_to_list(vsi, &vsi->tmp_sync_list, addr))
219 return -EINVAL;
220
221 return 0;
222}
223
224/**
225 * ice_add_mac_to_unsync_list - creates list of mac addresses to be unsynced
226 * @netdev: the net device on which the unsync is happening
227 * @addr: mac address to unsync
228 *
229 * This is a callback function which is called by the in kernel device unsync
230 * functions (like __dev_uc_unsync, __dev_mc_unsync, etc). This function only
231 * populates the tmp_unsync_list, which is later used by ice_remove_mac to
232 * delete the mac filters from the hardware.
233 */
234static int ice_add_mac_to_unsync_list(struct net_device *netdev, const u8 *addr)
235{
236 struct ice_netdev_priv *np = netdev_priv(netdev);
237 struct ice_vsi *vsi = np->vsi;
238
239 if (ice_add_mac_to_list(vsi, &vsi->tmp_unsync_list, addr))
240 return -EINVAL;
241
242 return 0;
243}
244
245/**
246 * ice_free_fltr_list - free filter lists helper
247 * @dev: pointer to the device struct
248 * @h: pointer to the list head to be freed
249 *
250 * Helper function to free filter lists previously created using
251 * ice_add_mac_to_list
252 */
253static void ice_free_fltr_list(struct device *dev, struct list_head *h)
254{
255 struct ice_fltr_list_entry *e, *tmp;
256
257 list_for_each_entry_safe(e, tmp, h, list_entry) {
258 list_del(&e->list_entry);
259 devm_kfree(dev, e);
260 }
261}
262
263/**
264 * ice_vsi_fltr_changed - check if filter state changed
265 * @vsi: VSI to be checked
266 *
267 * returns true if filter state has changed, false otherwise.
268 */
269static bool ice_vsi_fltr_changed(struct ice_vsi *vsi)
270{
271 return test_bit(ICE_VSI_FLAG_UMAC_FLTR_CHANGED, vsi->flags) ||
272 test_bit(ICE_VSI_FLAG_MMAC_FLTR_CHANGED, vsi->flags) ||
273 test_bit(ICE_VSI_FLAG_VLAN_FLTR_CHANGED, vsi->flags);
274}
275
276/**
277 * ice_vsi_sync_fltr - Update the VSI filter list to the HW
278 * @vsi: ptr to the VSI
279 *
280 * Push any outstanding VSI filter changes through the AdminQ.
281 */
282static int ice_vsi_sync_fltr(struct ice_vsi *vsi)
283{
284 struct device *dev = &vsi->back->pdev->dev;
285 struct net_device *netdev = vsi->netdev;
286 bool promisc_forced_on = false;
287 struct ice_pf *pf = vsi->back;
288 struct ice_hw *hw = &pf->hw;
289 enum ice_status status = 0;
290 u32 changed_flags = 0;
291 int err = 0;
292
293 if (!vsi->netdev)
294 return -EINVAL;
295
296 while (test_and_set_bit(__ICE_CFG_BUSY, vsi->state))
297 usleep_range(1000, 2000);
298
299 changed_flags = vsi->current_netdev_flags ^ vsi->netdev->flags;
300 vsi->current_netdev_flags = vsi->netdev->flags;
301
302 INIT_LIST_HEAD(&vsi->tmp_sync_list);
303 INIT_LIST_HEAD(&vsi->tmp_unsync_list);
304
305 if (ice_vsi_fltr_changed(vsi)) {
306 clear_bit(ICE_VSI_FLAG_UMAC_FLTR_CHANGED, vsi->flags);
307 clear_bit(ICE_VSI_FLAG_MMAC_FLTR_CHANGED, vsi->flags);
308 clear_bit(ICE_VSI_FLAG_VLAN_FLTR_CHANGED, vsi->flags);
309
310 /* grab the netdev's addr_list_lock */
311 netif_addr_lock_bh(netdev);
312 __dev_uc_sync(netdev, ice_add_mac_to_sync_list,
313 ice_add_mac_to_unsync_list);
314 __dev_mc_sync(netdev, ice_add_mac_to_sync_list,
315 ice_add_mac_to_unsync_list);
316 /* our temp lists are populated. release lock */
317 netif_addr_unlock_bh(netdev);
318 }
319
320 /* Remove mac addresses in the unsync list */
321 status = ice_remove_mac(hw, &vsi->tmp_unsync_list);
322 ice_free_fltr_list(dev, &vsi->tmp_unsync_list);
323 if (status) {
324 netdev_err(netdev, "Failed to delete MAC filters\n");
325 /* if we failed because of alloc failures, just bail */
326 if (status == ICE_ERR_NO_MEMORY) {
327 err = -ENOMEM;
328 goto out;
329 }
330 }
331
332 /* Add mac addresses in the sync list */
333 status = ice_add_mac(hw, &vsi->tmp_sync_list);
334 ice_free_fltr_list(dev, &vsi->tmp_sync_list);
335 if (status) {
336 netdev_err(netdev, "Failed to add MAC filters\n");
337 /* If there is no more space for new umac filters, vsi
338 * should go into promiscuous mode. There should be some
339 * space reserved for promiscuous filters.
340 */
341 if (hw->adminq.sq_last_status == ICE_AQ_RC_ENOSPC &&
342 !test_and_set_bit(__ICE_FLTR_OVERFLOW_PROMISC,
343 vsi->state)) {
344 promisc_forced_on = true;
345 netdev_warn(netdev,
346 "Reached MAC filter limit, forcing promisc mode on VSI %d\n",
347 vsi->vsi_num);
348 } else {
349 err = -EIO;
350 goto out;
351 }
352 }
353 /* check for changes in promiscuous modes */
354 if (changed_flags & IFF_ALLMULTI)
355 netdev_warn(netdev, "Unsupported configuration\n");
356
357 if (((changed_flags & IFF_PROMISC) || promisc_forced_on) ||
358 test_bit(ICE_VSI_FLAG_PROMISC_CHANGED, vsi->flags)) {
359 clear_bit(ICE_VSI_FLAG_PROMISC_CHANGED, vsi->flags);
360 if (vsi->current_netdev_flags & IFF_PROMISC) {
361 /* Apply TX filter rule to get traffic from VMs */
362 status = ice_cfg_dflt_vsi(hw, vsi->vsi_num, true,
363 ICE_FLTR_TX);
364 if (status) {
365 netdev_err(netdev, "Error setting default VSI %i tx rule\n",
366 vsi->vsi_num);
367 vsi->current_netdev_flags &= ~IFF_PROMISC;
368 err = -EIO;
369 goto out_promisc;
370 }
371 /* Apply RX filter rule to get traffic from wire */
372 status = ice_cfg_dflt_vsi(hw, vsi->vsi_num, true,
373 ICE_FLTR_RX);
374 if (status) {
375 netdev_err(netdev, "Error setting default VSI %i rx rule\n",
376 vsi->vsi_num);
377 vsi->current_netdev_flags &= ~IFF_PROMISC;
378 err = -EIO;
379 goto out_promisc;
380 }
381 } else {
382 /* Clear TX filter rule to stop traffic from VMs */
383 status = ice_cfg_dflt_vsi(hw, vsi->vsi_num, false,
384 ICE_FLTR_TX);
385 if (status) {
386 netdev_err(netdev, "Error clearing default VSI %i tx rule\n",
387 vsi->vsi_num);
388 vsi->current_netdev_flags |= IFF_PROMISC;
389 err = -EIO;
390 goto out_promisc;
391 }
392 /* Clear filter RX to remove traffic from wire */
393 status = ice_cfg_dflt_vsi(hw, vsi->vsi_num, false,
394 ICE_FLTR_RX);
395 if (status) {
396 netdev_err(netdev, "Error clearing default VSI %i rx rule\n",
397 vsi->vsi_num);
398 vsi->current_netdev_flags |= IFF_PROMISC;
399 err = -EIO;
400 goto out_promisc;
401 }
402 }
403 }
404 goto exit;
405
406out_promisc:
407 set_bit(ICE_VSI_FLAG_PROMISC_CHANGED, vsi->flags);
408 goto exit;
409out:
410 /* if something went wrong then set the changed flag so we try again */
411 set_bit(ICE_VSI_FLAG_UMAC_FLTR_CHANGED, vsi->flags);
412 set_bit(ICE_VSI_FLAG_MMAC_FLTR_CHANGED, vsi->flags);
413exit:
414 clear_bit(__ICE_CFG_BUSY, vsi->state);
415 return err;
416}
417
418/**
419 * ice_sync_fltr_subtask - Sync the VSI filter list with HW
420 * @pf: board private structure
421 */
422static void ice_sync_fltr_subtask(struct ice_pf *pf)
423{
424 int v;
425
426 if (!pf || !(test_bit(ICE_FLAG_FLTR_SYNC, pf->flags)))
427 return;
428
429 clear_bit(ICE_FLAG_FLTR_SYNC, pf->flags);
430
431 for (v = 0; v < pf->num_alloc_vsi; v++)
432 if (pf->vsi[v] && ice_vsi_fltr_changed(pf->vsi[v]) &&
433 ice_vsi_sync_fltr(pf->vsi[v])) {
434 /* come back and try again later */
435 set_bit(ICE_FLAG_FLTR_SYNC, pf->flags);
436 break;
437 }
438}
439
440/**
441 * ice_is_reset_recovery_pending - schedule a reset
442 * @state: pf state field
443 */
444static bool ice_is_reset_recovery_pending(unsigned long int *state)
445{
446 return test_bit(__ICE_RESET_RECOVERY_PENDING, state);
447}
448
449/**
450 * ice_prepare_for_reset - prep for the core to reset
451 * @pf: board private structure
452 *
453 * Inform or close all dependent features in prep for reset.
454 */
455static void
456ice_prepare_for_reset(struct ice_pf *pf)
457{
458 struct ice_hw *hw = &pf->hw;
459 u32 v;
460
461 ice_for_each_vsi(pf, v)
462 if (pf->vsi[v])
463 ice_remove_vsi_fltr(hw, pf->vsi[v]->vsi_num);
464
465 dev_dbg(&pf->pdev->dev, "Tearing down internal switch for reset\n");
466
467 /* disable the VSIs and their queues that are not already DOWN */
468 /* pf_dis_all_vsi modifies netdev structures -rtnl_lock needed */
469 ice_pf_dis_all_vsi(pf);
470
471 ice_for_each_vsi(pf, v)
472 if (pf->vsi[v])
473 pf->vsi[v]->vsi_num = 0;
474
475 ice_shutdown_all_ctrlq(hw);
476}
477
478/**
479 * ice_do_reset - Initiate one of many types of resets
480 * @pf: board private structure
481 * @reset_type: reset type requested
482 * before this function was called.
483 */
484static void ice_do_reset(struct ice_pf *pf, enum ice_reset_req reset_type)
485{
486 struct device *dev = &pf->pdev->dev;
487 struct ice_hw *hw = &pf->hw;
488
489 dev_dbg(dev, "reset_type 0x%x requested\n", reset_type);
490 WARN_ON(in_interrupt());
491
492 /* PFR is a bit of a special case because it doesn't result in an OICR
493 * interrupt. So for PFR, we prepare for reset, issue the reset and
494 * rebuild sequentially.
495 */
496 if (reset_type == ICE_RESET_PFR) {
497 set_bit(__ICE_RESET_RECOVERY_PENDING, pf->state);
498 ice_prepare_for_reset(pf);
499 }
500
501 /* trigger the reset */
502 if (ice_reset(hw, reset_type)) {
503 dev_err(dev, "reset %d failed\n", reset_type);
504 set_bit(__ICE_RESET_FAILED, pf->state);
505 clear_bit(__ICE_RESET_RECOVERY_PENDING, pf->state);
506 return;
507 }
508
509 if (reset_type == ICE_RESET_PFR) {
510 pf->pfr_count++;
511 ice_rebuild(pf);
512 clear_bit(__ICE_RESET_RECOVERY_PENDING, pf->state);
513 }
514}
515
516/**
517 * ice_reset_subtask - Set up for resetting the device and driver
518 * @pf: board private structure
519 */
520static void ice_reset_subtask(struct ice_pf *pf)
521{
522 enum ice_reset_req reset_type;
523
524 rtnl_lock();
525
526 /* When a CORER/GLOBR/EMPR is about to happen, the hardware triggers an
527 * OICR interrupt. The OICR handler (ice_misc_intr) determines what
528 * type of reset happened and sets __ICE_RESET_RECOVERY_PENDING bit in
529 * pf->state. So if reset/recovery is pending (as indicated by this bit)
530 * we do a rebuild and return.
531 */
532 if (ice_is_reset_recovery_pending(pf->state)) {
533 clear_bit(__ICE_GLOBR_RECV, pf->state);
534 clear_bit(__ICE_CORER_RECV, pf->state);
535 ice_prepare_for_reset(pf);
536
537 /* make sure we are ready to rebuild */
538 if (ice_check_reset(&pf->hw))
539 set_bit(__ICE_RESET_FAILED, pf->state);
540 else
541 ice_rebuild(pf);
542 clear_bit(__ICE_RESET_RECOVERY_PENDING, pf->state);
543 goto unlock;
544 }
545
546 /* No pending resets to finish processing. Check for new resets */
547 if (test_and_clear_bit(__ICE_GLOBR_REQ, pf->state))
548 reset_type = ICE_RESET_GLOBR;
549 else if (test_and_clear_bit(__ICE_CORER_REQ, pf->state))
550 reset_type = ICE_RESET_CORER;
551 else if (test_and_clear_bit(__ICE_PFR_REQ, pf->state))
552 reset_type = ICE_RESET_PFR;
553 else
554 goto unlock;
555
556 /* reset if not already down or resetting */
557 if (!test_bit(__ICE_DOWN, pf->state) &&
558 !test_bit(__ICE_CFG_BUSY, pf->state)) {
559 ice_do_reset(pf, reset_type);
560 }
561
562unlock:
563 rtnl_unlock();
564}
565
566/**
567 * ice_watchdog_subtask - periodic tasks not using event driven scheduling
568 * @pf: board private structure
569 */
570static void ice_watchdog_subtask(struct ice_pf *pf)
571{
572 int i;
573
574 /* if interface is down do nothing */
575 if (test_bit(__ICE_DOWN, pf->state) ||
576 test_bit(__ICE_CFG_BUSY, pf->state))
577 return;
578
579 /* make sure we don't do these things too often */
580 if (time_before(jiffies,
581 pf->serv_tmr_prev + pf->serv_tmr_period))
582 return;
583
584 pf->serv_tmr_prev = jiffies;
585
586 /* Update the stats for active netdevs so the network stack
587 * can look at updated numbers whenever it cares to
588 */
589 ice_update_pf_stats(pf);
590 for (i = 0; i < pf->num_alloc_vsi; i++)
591 if (pf->vsi[i] && pf->vsi[i]->netdev)
592 ice_update_vsi_stats(pf->vsi[i]);
593}
594
595/**
596 * ice_print_link_msg - print link up or down message
597 * @vsi: the VSI whose link status is being queried
598 * @isup: boolean for if the link is now up or down
599 */
600void ice_print_link_msg(struct ice_vsi *vsi, bool isup)
601{
602 const char *speed;
603 const char *fc;
604
605 if (vsi->current_isup == isup)
606 return;
607
608 vsi->current_isup = isup;
609
610 if (!isup) {
611 netdev_info(vsi->netdev, "NIC Link is Down\n");
612 return;
613 }
614
615 switch (vsi->port_info->phy.link_info.link_speed) {
616 case ICE_AQ_LINK_SPEED_40GB:
617 speed = "40 G";
618 break;
619 case ICE_AQ_LINK_SPEED_25GB:
620 speed = "25 G";
621 break;
622 case ICE_AQ_LINK_SPEED_20GB:
623 speed = "20 G";
624 break;
625 case ICE_AQ_LINK_SPEED_10GB:
626 speed = "10 G";
627 break;
628 case ICE_AQ_LINK_SPEED_5GB:
629 speed = "5 G";
630 break;
631 case ICE_AQ_LINK_SPEED_2500MB:
632 speed = "2.5 G";
633 break;
634 case ICE_AQ_LINK_SPEED_1000MB:
635 speed = "1 G";
636 break;
637 case ICE_AQ_LINK_SPEED_100MB:
638 speed = "100 M";
639 break;
640 default:
641 speed = "Unknown";
642 break;
643 }
644
645 switch (vsi->port_info->fc.current_mode) {
646 case ICE_FC_FULL:
647 fc = "RX/TX";
648 break;
649 case ICE_FC_TX_PAUSE:
650 fc = "TX";
651 break;
652 case ICE_FC_RX_PAUSE:
653 fc = "RX";
654 break;
655 default:
656 fc = "Unknown";
657 break;
658 }
659
660 netdev_info(vsi->netdev, "NIC Link is up %sbps, Flow Control: %s\n",
661 speed, fc);
662}
663
664/**
665 * ice_init_link_events - enable/initialize link events
666 * @pi: pointer to the port_info instance
667 *
668 * Returns -EIO on failure, 0 on success
669 */
670static int ice_init_link_events(struct ice_port_info *pi)
671{
672 u16 mask;
673
674 mask = ~((u16)(ICE_AQ_LINK_EVENT_UPDOWN | ICE_AQ_LINK_EVENT_MEDIA_NA |
675 ICE_AQ_LINK_EVENT_MODULE_QUAL_FAIL));
676
677 if (ice_aq_set_event_mask(pi->hw, pi->lport, mask, NULL)) {
678 dev_dbg(ice_hw_to_dev(pi->hw),
679 "Failed to set link event mask for port %d\n",
680 pi->lport);
681 return -EIO;
682 }
683
684 if (ice_aq_get_link_info(pi, true, NULL, NULL)) {
685 dev_dbg(ice_hw_to_dev(pi->hw),
686 "Failed to enable link events for port %d\n",
687 pi->lport);
688 return -EIO;
689 }
690
691 return 0;
692}
693
694/**
695 * ice_vsi_link_event - update the vsi's netdev
696 * @vsi: the vsi on which the link event occurred
697 * @link_up: whether or not the vsi needs to be set up or down
698 */
699static void ice_vsi_link_event(struct ice_vsi *vsi, bool link_up)
700{
701 if (!vsi || test_bit(__ICE_DOWN, vsi->state))
702 return;
703
704 if (vsi->type == ICE_VSI_PF) {
705 if (!vsi->netdev) {
706 dev_dbg(&vsi->back->pdev->dev,
707 "vsi->netdev is not initialized!\n");
708 return;
709 }
710 if (link_up) {
711 netif_carrier_on(vsi->netdev);
712 netif_tx_wake_all_queues(vsi->netdev);
713 } else {
714 netif_carrier_off(vsi->netdev);
715 netif_tx_stop_all_queues(vsi->netdev);
716 }
717 }
718}
719
720/**
721 * ice_link_event - process the link event
722 * @pf: pf that the link event is associated with
723 * @pi: port_info for the port that the link event is associated with
724 *
725 * Returns -EIO if ice_get_link_status() fails
726 * Returns 0 on success
727 */
728static int
729ice_link_event(struct ice_pf *pf, struct ice_port_info *pi)
730{
731 u8 new_link_speed, old_link_speed;
732 struct ice_phy_info *phy_info;
733 bool new_link_same_as_old;
734 bool new_link, old_link;
735 u8 lport;
736 u16 v;
737
738 phy_info = &pi->phy;
739 phy_info->link_info_old = phy_info->link_info;
740 /* Force ice_get_link_status() to update link info */
741 phy_info->get_link_info = true;
742
743 old_link = (phy_info->link_info_old.link_info & ICE_AQ_LINK_UP);
744 old_link_speed = phy_info->link_info_old.link_speed;
745
746 lport = pi->lport;
747 if (ice_get_link_status(pi, &new_link)) {
748 dev_dbg(&pf->pdev->dev,
749 "Could not get link status for port %d\n", lport);
750 return -EIO;
751 }
752
753 new_link_speed = phy_info->link_info.link_speed;
754
755 new_link_same_as_old = (new_link == old_link &&
756 new_link_speed == old_link_speed);
757
758 ice_for_each_vsi(pf, v) {
759 struct ice_vsi *vsi = pf->vsi[v];
760
761 if (!vsi || !vsi->port_info)
762 continue;
763
764 if (new_link_same_as_old &&
765 (test_bit(__ICE_DOWN, vsi->state) ||
766 new_link == netif_carrier_ok(vsi->netdev)))
767 continue;
768
769 if (vsi->port_info->lport == lport) {
770 ice_print_link_msg(vsi, new_link);
771 ice_vsi_link_event(vsi, new_link);
772 }
773 }
774
775 return 0;
776}
777
778/**
779 * ice_handle_link_event - handle link event via ARQ
780 * @pf: pf that the link event is associated with
781 *
782 * Return -EINVAL if port_info is null
783 * Return status on succes
784 */
785static int ice_handle_link_event(struct ice_pf *pf)
786{
787 struct ice_port_info *port_info;
788 int status;
789
790 port_info = pf->hw.port_info;
791 if (!port_info)
792 return -EINVAL;
793
794 status = ice_link_event(pf, port_info);
795 if (status)
796 dev_dbg(&pf->pdev->dev,
797 "Could not process link event, error %d\n", status);
798
799 return status;
800}
801
802/**
803 * __ice_clean_ctrlq - helper function to clean controlq rings
804 * @pf: ptr to struct ice_pf
805 * @q_type: specific Control queue type
806 */
807static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type)
808{
809 struct ice_rq_event_info event;
810 struct ice_hw *hw = &pf->hw;
811 struct ice_ctl_q_info *cq;
812 u16 pending, i = 0;
813 const char *qtype;
814 u32 oldval, val;
815
816 /* Do not clean control queue if/when PF reset fails */
817 if (test_bit(__ICE_RESET_FAILED, pf->state))
818 return 0;
819
820 switch (q_type) {
821 case ICE_CTL_Q_ADMIN:
822 cq = &hw->adminq;
823 qtype = "Admin";
824 break;
825 default:
826 dev_warn(&pf->pdev->dev, "Unknown control queue type 0x%x\n",
827 q_type);
828 return 0;
829 }
830
831 /* check for error indications - PF_xx_AxQLEN register layout for
832 * FW/MBX/SB are identical so just use defines for PF_FW_AxQLEN.
833 */
834 val = rd32(hw, cq->rq.len);
835 if (val & (PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M |
836 PF_FW_ARQLEN_ARQCRIT_M)) {
837 oldval = val;
838 if (val & PF_FW_ARQLEN_ARQVFE_M)
839 dev_dbg(&pf->pdev->dev,
840 "%s Receive Queue VF Error detected\n", qtype);
841 if (val & PF_FW_ARQLEN_ARQOVFL_M) {
842 dev_dbg(&pf->pdev->dev,
843 "%s Receive Queue Overflow Error detected\n",
844 qtype);
845 }
846 if (val & PF_FW_ARQLEN_ARQCRIT_M)
847 dev_dbg(&pf->pdev->dev,
848 "%s Receive Queue Critical Error detected\n",
849 qtype);
850 val &= ~(PF_FW_ARQLEN_ARQVFE_M | PF_FW_ARQLEN_ARQOVFL_M |
851 PF_FW_ARQLEN_ARQCRIT_M);
852 if (oldval != val)
853 wr32(hw, cq->rq.len, val);
854 }
855
856 val = rd32(hw, cq->sq.len);
857 if (val & (PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M |
858 PF_FW_ATQLEN_ATQCRIT_M)) {
859 oldval = val;
860 if (val & PF_FW_ATQLEN_ATQVFE_M)
861 dev_dbg(&pf->pdev->dev,
862 "%s Send Queue VF Error detected\n", qtype);
863 if (val & PF_FW_ATQLEN_ATQOVFL_M) {
864 dev_dbg(&pf->pdev->dev,
865 "%s Send Queue Overflow Error detected\n",
866 qtype);
867 }
868 if (val & PF_FW_ATQLEN_ATQCRIT_M)
869 dev_dbg(&pf->pdev->dev,
870 "%s Send Queue Critical Error detected\n",
871 qtype);
872 val &= ~(PF_FW_ATQLEN_ATQVFE_M | PF_FW_ATQLEN_ATQOVFL_M |
873 PF_FW_ATQLEN_ATQCRIT_M);
874 if (oldval != val)
875 wr32(hw, cq->sq.len, val);
876 }
877
878 event.buf_len = cq->rq_buf_size;
879 event.msg_buf = devm_kzalloc(&pf->pdev->dev, event.buf_len,
880 GFP_KERNEL);
881 if (!event.msg_buf)
882 return 0;
883
884 do {
885 enum ice_status ret;
886 u16 opcode;
887
888 ret = ice_clean_rq_elem(hw, cq, &event, &pending);
889 if (ret == ICE_ERR_AQ_NO_WORK)
890 break;
891 if (ret) {
892 dev_err(&pf->pdev->dev,
893 "%s Receive Queue event error %d\n", qtype,
894 ret);
895 break;
896 }
897
898 opcode = le16_to_cpu(event.desc.opcode);
899
900 switch (opcode) {
901 case ice_aqc_opc_get_link_status:
902 if (ice_handle_link_event(pf))
903 dev_err(&pf->pdev->dev,
904 "Could not handle link event");
905 break;
906 default:
907 dev_dbg(&pf->pdev->dev,
908 "%s Receive Queue unknown event 0x%04x ignored\n",
909 qtype, opcode);
910 break;
911 }
912 } while (pending && (i++ < ICE_DFLT_IRQ_WORK));
913
914 devm_kfree(&pf->pdev->dev, event.msg_buf);
915
916 return pending && (i == ICE_DFLT_IRQ_WORK);
917}
918
919/**
920 * ice_clean_adminq_subtask - clean the AdminQ rings
921 * @pf: board private structure
922 */
923static void ice_clean_adminq_subtask(struct ice_pf *pf)
924{
925 struct ice_hw *hw = &pf->hw;
926 u32 val;
927
928 if (!test_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state))
929 return;
930
931 if (__ice_clean_ctrlq(pf, ICE_CTL_Q_ADMIN))
932 return;
933
934 clear_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state);
935
936 /* re-enable Admin queue interrupt causes */
937 val = rd32(hw, PFINT_FW_CTL);
938 wr32(hw, PFINT_FW_CTL, (val | PFINT_FW_CTL_CAUSE_ENA_M));
939
940 ice_flush(hw);
941}
942
943/**
944 * ice_service_task_schedule - schedule the service task to wake up
945 * @pf: board private structure
946 *
947 * If not already scheduled, this puts the task into the work queue.
948 */
949static void ice_service_task_schedule(struct ice_pf *pf)
950{
951 if (!test_bit(__ICE_DOWN, pf->state) &&
952 !test_and_set_bit(__ICE_SERVICE_SCHED, pf->state))
953 queue_work(ice_wq, &pf->serv_task);
954}
955
956/**
957 * ice_service_task_complete - finish up the service task
958 * @pf: board private structure
959 */
960static void ice_service_task_complete(struct ice_pf *pf)
961{
962 WARN_ON(!test_bit(__ICE_SERVICE_SCHED, pf->state));
963
964 /* force memory (pf->state) to sync before next service task */
965 smp_mb__before_atomic();
966 clear_bit(__ICE_SERVICE_SCHED, pf->state);
967}
968
969/**
970 * ice_service_timer - timer callback to schedule service task
971 * @t: pointer to timer_list
972 */
973static void ice_service_timer(struct timer_list *t)
974{
975 struct ice_pf *pf = from_timer(pf, t, serv_tmr);
976
977 mod_timer(&pf->serv_tmr, round_jiffies(pf->serv_tmr_period + jiffies));
978 ice_service_task_schedule(pf);
979}
980
981/**
982 * ice_service_task - manage and run subtasks
983 * @work: pointer to work_struct contained by the PF struct
984 */
985static void ice_service_task(struct work_struct *work)
986{
987 struct ice_pf *pf = container_of(work, struct ice_pf, serv_task);
988 unsigned long start_time = jiffies;
989
990 /* subtasks */
991
992 /* process reset requests first */
993 ice_reset_subtask(pf);
994
995 /* bail if a reset/recovery cycle is pending */
996 if (ice_is_reset_recovery_pending(pf->state) ||
997 test_bit(__ICE_SUSPENDED, pf->state)) {
998 ice_service_task_complete(pf);
999 return;
1000 }
1001
1002 ice_sync_fltr_subtask(pf);
1003 ice_watchdog_subtask(pf);
1004 ice_clean_adminq_subtask(pf);
1005
1006 /* Clear __ICE_SERVICE_SCHED flag to allow scheduling next event */
1007 ice_service_task_complete(pf);
1008
1009 /* If the tasks have taken longer than one service timer period
1010 * or there is more work to be done, reset the service timer to
1011 * schedule the service task now.
1012 */
1013 if (time_after(jiffies, (start_time + pf->serv_tmr_period)) ||
1014 test_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state))
1015 mod_timer(&pf->serv_tmr, jiffies);
1016}
1017
1018/**
1019 * ice_set_ctrlq_len - helper function to set controlq length
1020 * @hw: pointer to the hw instance
1021 */
1022static void ice_set_ctrlq_len(struct ice_hw *hw)
1023{
1024 hw->adminq.num_rq_entries = ICE_AQ_LEN;
1025 hw->adminq.num_sq_entries = ICE_AQ_LEN;
1026 hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN;
1027 hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN;
1028}
1029
1030/**
1031 * ice_irq_affinity_notify - Callback for affinity changes
1032 * @notify: context as to what irq was changed
1033 * @mask: the new affinity mask
1034 *
1035 * This is a callback function used by the irq_set_affinity_notifier function
1036 * so that we may register to receive changes to the irq affinity masks.
1037 */
1038static void ice_irq_affinity_notify(struct irq_affinity_notify *notify,
1039 const cpumask_t *mask)
1040{
1041 struct ice_q_vector *q_vector =
1042 container_of(notify, struct ice_q_vector, affinity_notify);
1043
1044 cpumask_copy(&q_vector->affinity_mask, mask);
1045}
1046
1047/**
1048 * ice_irq_affinity_release - Callback for affinity notifier release
1049 * @ref: internal core kernel usage
1050 *
1051 * This is a callback function used by the irq_set_affinity_notifier function
1052 * to inform the current notification subscriber that they will no longer
1053 * receive notifications.
1054 */
1055static void ice_irq_affinity_release(struct kref __always_unused *ref) {}
1056
1057/**
1058 * ice_vsi_dis_irq - Mask off queue interrupt generation on the VSI
1059 * @vsi: the VSI being un-configured
1060 */
1061static void ice_vsi_dis_irq(struct ice_vsi *vsi)
1062{
1063 struct ice_pf *pf = vsi->back;
1064 struct ice_hw *hw = &pf->hw;
1065 int base = vsi->base_vector;
1066 u32 val;
1067 int i;
1068
1069 /* disable interrupt causation from each queue */
1070 if (vsi->tx_rings) {
1071 ice_for_each_txq(vsi, i) {
1072 if (vsi->tx_rings[i]) {
1073 u16 reg;
1074
1075 reg = vsi->tx_rings[i]->reg_idx;
1076 val = rd32(hw, QINT_TQCTL(reg));
1077 val &= ~QINT_TQCTL_CAUSE_ENA_M;
1078 wr32(hw, QINT_TQCTL(reg), val);
1079 }
1080 }
1081 }
1082
1083 if (vsi->rx_rings) {
1084 ice_for_each_rxq(vsi, i) {
1085 if (vsi->rx_rings[i]) {
1086 u16 reg;
1087
1088 reg = vsi->rx_rings[i]->reg_idx;
1089 val = rd32(hw, QINT_RQCTL(reg));
1090 val &= ~QINT_RQCTL_CAUSE_ENA_M;
1091 wr32(hw, QINT_RQCTL(reg), val);
1092 }
1093 }
1094 }
1095
1096 /* disable each interrupt */
1097 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags)) {
1098 for (i = vsi->base_vector;
1099 i < (vsi->num_q_vectors + vsi->base_vector); i++)
1100 wr32(hw, GLINT_DYN_CTL(i), 0);
1101
1102 ice_flush(hw);
1103 for (i = 0; i < vsi->num_q_vectors; i++)
1104 synchronize_irq(pf->msix_entries[i + base].vector);
1105 }
1106}
1107
1108/**
1109 * ice_vsi_ena_irq - Enable IRQ for the given VSI
1110 * @vsi: the VSI being configured
1111 */
1112static int ice_vsi_ena_irq(struct ice_vsi *vsi)
1113{
1114 struct ice_pf *pf = vsi->back;
1115 struct ice_hw *hw = &pf->hw;
1116
1117 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags)) {
1118 int i;
1119
1120 for (i = 0; i < vsi->num_q_vectors; i++)
1121 ice_irq_dynamic_ena(hw, vsi, vsi->q_vectors[i]);
1122 }
1123
1124 ice_flush(hw);
1125 return 0;
1126}
1127
1128/**
1129 * ice_vsi_delete - delete a VSI from the switch
1130 * @vsi: pointer to VSI being removed
1131 */
1132static void ice_vsi_delete(struct ice_vsi *vsi)
1133{
1134 struct ice_pf *pf = vsi->back;
1135 struct ice_vsi_ctx ctxt;
1136 enum ice_status status;
1137
1138 ctxt.vsi_num = vsi->vsi_num;
1139
1140 memcpy(&ctxt.info, &vsi->info, sizeof(struct ice_aqc_vsi_props));
1141
1142 status = ice_aq_free_vsi(&pf->hw, &ctxt, false, NULL);
1143 if (status)
1144 dev_err(&pf->pdev->dev, "Failed to delete VSI %i in FW\n",
1145 vsi->vsi_num);
1146}
1147
1148/**
1149 * ice_vsi_req_irq_msix - get MSI-X vectors from the OS for the VSI
1150 * @vsi: the VSI being configured
1151 * @basename: name for the vector
1152 */
1153static int ice_vsi_req_irq_msix(struct ice_vsi *vsi, char *basename)
1154{
1155 int q_vectors = vsi->num_q_vectors;
1156 struct ice_pf *pf = vsi->back;
1157 int base = vsi->base_vector;
1158 int rx_int_idx = 0;
1159 int tx_int_idx = 0;
1160 int vector, err;
1161 int irq_num;
1162
1163 for (vector = 0; vector < q_vectors; vector++) {
1164 struct ice_q_vector *q_vector = vsi->q_vectors[vector];
1165
1166 irq_num = pf->msix_entries[base + vector].vector;
1167
1168 if (q_vector->tx.ring && q_vector->rx.ring) {
1169 snprintf(q_vector->name, sizeof(q_vector->name) - 1,
1170 "%s-%s-%d", basename, "TxRx", rx_int_idx++);
1171 tx_int_idx++;
1172 } else if (q_vector->rx.ring) {
1173 snprintf(q_vector->name, sizeof(q_vector->name) - 1,
1174 "%s-%s-%d", basename, "rx", rx_int_idx++);
1175 } else if (q_vector->tx.ring) {
1176 snprintf(q_vector->name, sizeof(q_vector->name) - 1,
1177 "%s-%s-%d", basename, "tx", tx_int_idx++);
1178 } else {
1179 /* skip this unused q_vector */
1180 continue;
1181 }
1182 err = devm_request_irq(&pf->pdev->dev,
1183 pf->msix_entries[base + vector].vector,
1184 vsi->irq_handler, 0, q_vector->name,
1185 q_vector);
1186 if (err) {
1187 netdev_err(vsi->netdev,
1188 "MSIX request_irq failed, error: %d\n", err);
1189 goto free_q_irqs;
1190 }
1191
1192 /* register for affinity change notifications */
1193 q_vector->affinity_notify.notify = ice_irq_affinity_notify;
1194 q_vector->affinity_notify.release = ice_irq_affinity_release;
1195 irq_set_affinity_notifier(irq_num, &q_vector->affinity_notify);
1196
1197 /* assign the mask for this irq */
1198 irq_set_affinity_hint(irq_num, &q_vector->affinity_mask);
1199 }
1200
1201 vsi->irqs_ready = true;
1202 return 0;
1203
1204free_q_irqs:
1205 while (vector) {
1206 vector--;
1207 irq_num = pf->msix_entries[base + vector].vector,
1208 irq_set_affinity_notifier(irq_num, NULL);
1209 irq_set_affinity_hint(irq_num, NULL);
1210 devm_free_irq(&pf->pdev->dev, irq_num, &vsi->q_vectors[vector]);
1211 }
1212 return err;
1213}
1214
1215/**
1216 * ice_vsi_set_rss_params - Setup RSS capabilities per VSI type
1217 * @vsi: the VSI being configured
1218 */
1219static void ice_vsi_set_rss_params(struct ice_vsi *vsi)
1220{
1221 struct ice_hw_common_caps *cap;
1222 struct ice_pf *pf = vsi->back;
1223
1224 if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags)) {
1225 vsi->rss_size = 1;
1226 return;
1227 }
1228
1229 cap = &pf->hw.func_caps.common_cap;
1230 switch (vsi->type) {
1231 case ICE_VSI_PF:
1232 /* PF VSI will inherit RSS instance of PF */
1233 vsi->rss_table_size = cap->rss_table_size;
1234 vsi->rss_size = min_t(int, num_online_cpus(),
1235 BIT(cap->rss_table_entry_width));
1236 vsi->rss_lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF;
1237 break;
1238 default:
1239 dev_warn(&pf->pdev->dev, "Unknown VSI type %d\n", vsi->type);
1240 break;
1241 }
1242}
1243
1244/**
1245 * ice_vsi_setup_q_map - Setup a VSI queue map
1246 * @vsi: the VSI being configured
1247 * @ctxt: VSI context structure
1248 */
1249static void ice_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt)
1250{
1251 u16 offset = 0, qmap = 0, numq_tc;
1252 u16 pow = 0, max_rss = 0, qcount;
1253 u16 qcount_tx = vsi->alloc_txq;
1254 u16 qcount_rx = vsi->alloc_rxq;
1255 bool ena_tc0 = false;
1256 int i;
1257
1258 /* at least TC0 should be enabled by default */
1259 if (vsi->tc_cfg.numtc) {
1260 if (!(vsi->tc_cfg.ena_tc & BIT(0)))
1261 ena_tc0 = true;
1262 } else {
1263 ena_tc0 = true;
1264 }
1265
1266 if (ena_tc0) {
1267 vsi->tc_cfg.numtc++;
1268 vsi->tc_cfg.ena_tc |= 1;
1269 }
1270
1271 numq_tc = qcount_rx / vsi->tc_cfg.numtc;
1272
1273 /* TC mapping is a function of the number of Rx queues assigned to the
1274 * VSI for each traffic class and the offset of these queues.
1275 * The first 10 bits are for queue offset for TC0, next 4 bits for no:of
1276 * queues allocated to TC0. No:of queues is a power-of-2.
1277 *
1278 * If TC is not enabled, the queue offset is set to 0, and allocate one
1279 * queue, this way, traffic for the given TC will be sent to the default
1280 * queue.
1281 *
1282 * Setup number and offset of Rx queues for all TCs for the VSI
1283 */
1284
1285 /* qcount will change if RSS is enabled */
1286 if (test_bit(ICE_FLAG_RSS_ENA, vsi->back->flags)) {
1287 if (vsi->type == ICE_VSI_PF)
1288 max_rss = ICE_MAX_LG_RSS_QS;
1289 else
1290 max_rss = ICE_MAX_SMALL_RSS_QS;
1291
1292 qcount = min_t(int, numq_tc, max_rss);
1293 qcount = min_t(int, qcount, vsi->rss_size);
1294 } else {
1295 qcount = numq_tc;
1296 }
1297
1298 /* find higher power-of-2 of qcount */
1299 pow = ilog2(qcount);
1300
1301 if (!is_power_of_2(qcount))
1302 pow++;
1303
1304 for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) {
1305 if (!(vsi->tc_cfg.ena_tc & BIT(i))) {
1306 /* TC is not enabled */
1307 vsi->tc_cfg.tc_info[i].qoffset = 0;
1308 vsi->tc_cfg.tc_info[i].qcount = 1;
1309 ctxt->info.tc_mapping[i] = 0;
1310 continue;
1311 }
1312
1313 /* TC is enabled */
1314 vsi->tc_cfg.tc_info[i].qoffset = offset;
1315 vsi->tc_cfg.tc_info[i].qcount = qcount;
1316
1317 qmap = ((offset << ICE_AQ_VSI_TC_Q_OFFSET_S) &
1318 ICE_AQ_VSI_TC_Q_OFFSET_M) |
1319 ((pow << ICE_AQ_VSI_TC_Q_NUM_S) &
1320 ICE_AQ_VSI_TC_Q_NUM_M);
1321 offset += qcount;
1322 ctxt->info.tc_mapping[i] = cpu_to_le16(qmap);
1323 }
1324
1325 vsi->num_txq = qcount_tx;
1326 vsi->num_rxq = offset;
1327
1328 /* Rx queue mapping */
1329 ctxt->info.mapping_flags |= cpu_to_le16(ICE_AQ_VSI_Q_MAP_CONTIG);
1330 /* q_mapping buffer holds the info for the first queue allocated for
1331 * this VSI in the PF space and also the number of queues associated
1332 * with this VSI.
1333 */
1334 ctxt->info.q_mapping[0] = cpu_to_le16(vsi->rxq_map[0]);
1335 ctxt->info.q_mapping[1] = cpu_to_le16(vsi->num_rxq);
1336}
1337
1338/**
1339 * ice_set_dflt_vsi_ctx - Set default VSI context before adding a VSI
1340 * @ctxt: the VSI context being set
1341 *
1342 * This initializes a default VSI context for all sections except the Queues.
1343 */
1344static void ice_set_dflt_vsi_ctx(struct ice_vsi_ctx *ctxt)
1345{
1346 u32 table = 0;
1347
1348 memset(&ctxt->info, 0, sizeof(ctxt->info));
1349 /* VSI's should be allocated from shared pool */
1350 ctxt->alloc_from_pool = true;
1351 /* Src pruning enabled by default */
1352 ctxt->info.sw_flags = ICE_AQ_VSI_SW_FLAG_SRC_PRUNE;
1353 /* Traffic from VSI can be sent to LAN */
1354 ctxt->info.sw_flags2 = ICE_AQ_VSI_SW_FLAG_LAN_ENA;
1355 /* Allow all packets untagged/tagged */
1356 ctxt->info.port_vlan_flags = ((ICE_AQ_VSI_PVLAN_MODE_ALL &
1357 ICE_AQ_VSI_PVLAN_MODE_M) >>
1358 ICE_AQ_VSI_PVLAN_MODE_S);
1359 /* Show VLAN/UP from packets in Rx descriptors */
1360 ctxt->info.port_vlan_flags |= ((ICE_AQ_VSI_PVLAN_EMOD_STR_BOTH &
1361 ICE_AQ_VSI_PVLAN_EMOD_M) >>
1362 ICE_AQ_VSI_PVLAN_EMOD_S);
1363 /* Have 1:1 UP mapping for both ingress/egress tables */
1364 table |= ICE_UP_TABLE_TRANSLATE(0, 0);
1365 table |= ICE_UP_TABLE_TRANSLATE(1, 1);
1366 table |= ICE_UP_TABLE_TRANSLATE(2, 2);
1367 table |= ICE_UP_TABLE_TRANSLATE(3, 3);
1368 table |= ICE_UP_TABLE_TRANSLATE(4, 4);
1369 table |= ICE_UP_TABLE_TRANSLATE(5, 5);
1370 table |= ICE_UP_TABLE_TRANSLATE(6, 6);
1371 table |= ICE_UP_TABLE_TRANSLATE(7, 7);
1372 ctxt->info.ingress_table = cpu_to_le32(table);
1373 ctxt->info.egress_table = cpu_to_le32(table);
1374 /* Have 1:1 UP mapping for outer to inner UP table */
1375 ctxt->info.outer_up_table = cpu_to_le32(table);
1376 /* No Outer tag support outer_tag_flags remains to zero */
1377}
1378
1379/**
1380 * ice_set_rss_vsi_ctx - Set RSS VSI context before adding a VSI
1381 * @ctxt: the VSI context being set
1382 * @vsi: the VSI being configured
1383 */
1384static void ice_set_rss_vsi_ctx(struct ice_vsi_ctx *ctxt, struct ice_vsi *vsi)
1385{
1386 u8 lut_type, hash_type;
1387
1388 switch (vsi->type) {
1389 case ICE_VSI_PF:
1390 /* PF VSI will inherit RSS instance of PF */
1391 lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_PF;
1392 hash_type = ICE_AQ_VSI_Q_OPT_RSS_TPLZ;
1393 break;
1394 default:
1395 dev_warn(&vsi->back->pdev->dev, "Unknown VSI type %d\n",
1396 vsi->type);
1397 return;
1398 }
1399
1400 ctxt->info.q_opt_rss = ((lut_type << ICE_AQ_VSI_Q_OPT_RSS_LUT_S) &
1401 ICE_AQ_VSI_Q_OPT_RSS_LUT_M) |
1402 ((hash_type << ICE_AQ_VSI_Q_OPT_RSS_HASH_S) &
1403 ICE_AQ_VSI_Q_OPT_RSS_HASH_M);
1404}
1405
1406/**
1407 * ice_vsi_add - Create a new VSI or fetch preallocated VSI
1408 * @vsi: the VSI being configured
1409 *
1410 * This initializes a VSI context depending on the VSI type to be added and
1411 * passes it down to the add_vsi aq command to create a new VSI.
1412 */
1413static int ice_vsi_add(struct ice_vsi *vsi)
1414{
1415 struct ice_vsi_ctx ctxt = { 0 };
1416 struct ice_pf *pf = vsi->back;
1417 struct ice_hw *hw = &pf->hw;
1418 int ret = 0;
1419
1420 switch (vsi->type) {
1421 case ICE_VSI_PF:
1422 ctxt.flags = ICE_AQ_VSI_TYPE_PF;
1423 break;
1424 default:
1425 return -ENODEV;
1426 }
1427
1428 ice_set_dflt_vsi_ctx(&ctxt);
1429 /* if the switch is in VEB mode, allow VSI loopback */
1430 if (vsi->vsw->bridge_mode == BRIDGE_MODE_VEB)
1431 ctxt.info.sw_flags |= ICE_AQ_VSI_SW_FLAG_ALLOW_LB;
1432
1433 /* Set LUT type and HASH type if RSS is enabled */
1434 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags))
1435 ice_set_rss_vsi_ctx(&ctxt, vsi);
1436
1437 ctxt.info.sw_id = vsi->port_info->sw_id;
1438 ice_vsi_setup_q_map(vsi, &ctxt);
1439
1440 ret = ice_aq_add_vsi(hw, &ctxt, NULL);
1441 if (ret) {
1442 dev_err(&vsi->back->pdev->dev,
1443 "Add VSI AQ call failed, err %d\n", ret);
1444 return -EIO;
1445 }
1446 vsi->info = ctxt.info;
1447 vsi->vsi_num = ctxt.vsi_num;
1448
1449 return ret;
1450}
1451
1452/**
1453 * ice_vsi_release_msix - Clear the queue to Interrupt mapping in HW
1454 * @vsi: the VSI being cleaned up
1455 */
1456static void ice_vsi_release_msix(struct ice_vsi *vsi)
1457{
1458 struct ice_pf *pf = vsi->back;
1459 u16 vector = vsi->base_vector;
1460 struct ice_hw *hw = &pf->hw;
1461 u32 txq = 0;
1462 u32 rxq = 0;
1463 int i, q;
1464
1465 for (i = 0; i < vsi->num_q_vectors; i++, vector++) {
1466 struct ice_q_vector *q_vector = vsi->q_vectors[i];
1467
1468 wr32(hw, GLINT_ITR(ICE_RX_ITR, vector), 0);
1469 wr32(hw, GLINT_ITR(ICE_TX_ITR, vector), 0);
1470 for (q = 0; q < q_vector->num_ring_tx; q++) {
1471 wr32(hw, QINT_TQCTL(vsi->txq_map[txq]), 0);
1472 txq++;
1473 }
1474
1475 for (q = 0; q < q_vector->num_ring_rx; q++) {
1476 wr32(hw, QINT_RQCTL(vsi->rxq_map[rxq]), 0);
1477 rxq++;
1478 }
1479 }
1480
1481 ice_flush(hw);
1482}
1483
1484/**
1485 * ice_vsi_clear_rings - Deallocates the Tx and Rx rings for VSI
1486 * @vsi: the VSI having rings deallocated
1487 */
1488static void ice_vsi_clear_rings(struct ice_vsi *vsi)
1489{
1490 int i;
1491
1492 if (vsi->tx_rings) {
1493 for (i = 0; i < vsi->alloc_txq; i++) {
1494 if (vsi->tx_rings[i]) {
1495 kfree_rcu(vsi->tx_rings[i], rcu);
1496 vsi->tx_rings[i] = NULL;
1497 }
1498 }
1499 }
1500 if (vsi->rx_rings) {
1501 for (i = 0; i < vsi->alloc_rxq; i++) {
1502 if (vsi->rx_rings[i]) {
1503 kfree_rcu(vsi->rx_rings[i], rcu);
1504 vsi->rx_rings[i] = NULL;
1505 }
1506 }
1507 }
1508}
1509
1510/**
1511 * ice_vsi_alloc_rings - Allocates Tx and Rx rings for the VSI
1512 * @vsi: VSI which is having rings allocated
1513 */
1514static int ice_vsi_alloc_rings(struct ice_vsi *vsi)
1515{
1516 struct ice_pf *pf = vsi->back;
1517 int i;
1518
1519 /* Allocate tx_rings */
1520 for (i = 0; i < vsi->alloc_txq; i++) {
1521 struct ice_ring *ring;
1522
1523 /* allocate with kzalloc(), free with kfree_rcu() */
1524 ring = kzalloc(sizeof(*ring), GFP_KERNEL);
1525
1526 if (!ring)
1527 goto err_out;
1528
1529 ring->q_index = i;
1530 ring->reg_idx = vsi->txq_map[i];
1531 ring->ring_active = false;
1532 ring->vsi = vsi;
1533 ring->netdev = vsi->netdev;
1534 ring->dev = &pf->pdev->dev;
1535 ring->count = vsi->num_desc;
1536
1537 vsi->tx_rings[i] = ring;
1538 }
1539
1540 /* Allocate rx_rings */
1541 for (i = 0; i < vsi->alloc_rxq; i++) {
1542 struct ice_ring *ring;
1543
1544 /* allocate with kzalloc(), free with kfree_rcu() */
1545 ring = kzalloc(sizeof(*ring), GFP_KERNEL);
1546 if (!ring)
1547 goto err_out;
1548
1549 ring->q_index = i;
1550 ring->reg_idx = vsi->rxq_map[i];
1551 ring->ring_active = false;
1552 ring->vsi = vsi;
1553 ring->netdev = vsi->netdev;
1554 ring->dev = &pf->pdev->dev;
1555 ring->count = vsi->num_desc;
1556 vsi->rx_rings[i] = ring;
1557 }
1558
1559 return 0;
1560
1561err_out:
1562 ice_vsi_clear_rings(vsi);
1563 return -ENOMEM;
1564}
1565
1566/**
1567 * ice_vsi_free_irq - Free the irq association with the OS
1568 * @vsi: the VSI being configured
1569 */
1570static void ice_vsi_free_irq(struct ice_vsi *vsi)
1571{
1572 struct ice_pf *pf = vsi->back;
1573 int base = vsi->base_vector;
1574
1575 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags)) {
1576 int i;
1577
1578 if (!vsi->q_vectors || !vsi->irqs_ready)
1579 return;
1580
1581 vsi->irqs_ready = false;
1582 for (i = 0; i < vsi->num_q_vectors; i++) {
1583 u16 vector = i + base;
1584 int irq_num;
1585
1586 irq_num = pf->msix_entries[vector].vector;
1587
1588 /* free only the irqs that were actually requested */
1589 if (!vsi->q_vectors[i] ||
1590 !(vsi->q_vectors[i]->num_ring_tx ||
1591 vsi->q_vectors[i]->num_ring_rx))
1592 continue;
1593
1594 /* clear the affinity notifier in the IRQ descriptor */
1595 irq_set_affinity_notifier(irq_num, NULL);
1596
1597 /* clear the affinity_mask in the IRQ descriptor */
1598 irq_set_affinity_hint(irq_num, NULL);
1599 synchronize_irq(irq_num);
1600 devm_free_irq(&pf->pdev->dev, irq_num,
1601 vsi->q_vectors[i]);
1602 }
1603 ice_vsi_release_msix(vsi);
1604 }
1605}
1606
1607/**
1608 * ice_vsi_cfg_msix - MSIX mode Interrupt Config in the HW
1609 * @vsi: the VSI being configured
1610 */
1611static void ice_vsi_cfg_msix(struct ice_vsi *vsi)
1612{
1613 struct ice_pf *pf = vsi->back;
1614 u16 vector = vsi->base_vector;
1615 struct ice_hw *hw = &pf->hw;
1616 u32 txq = 0, rxq = 0;
1617 int i, q, itr;
1618 u8 itr_gran;
1619
1620 for (i = 0; i < vsi->num_q_vectors; i++, vector++) {
1621 struct ice_q_vector *q_vector = vsi->q_vectors[i];
1622
1623 itr_gran = hw->itr_gran_200;
1624
1625 if (q_vector->num_ring_rx) {
1626 q_vector->rx.itr =
1627 ITR_TO_REG(vsi->rx_rings[rxq]->rx_itr_setting,
1628 itr_gran);
1629 q_vector->rx.latency_range = ICE_LOW_LATENCY;
1630 }
1631
1632 if (q_vector->num_ring_tx) {
1633 q_vector->tx.itr =
1634 ITR_TO_REG(vsi->tx_rings[txq]->tx_itr_setting,
1635 itr_gran);
1636 q_vector->tx.latency_range = ICE_LOW_LATENCY;
1637 }
1638 wr32(hw, GLINT_ITR(ICE_RX_ITR, vector), q_vector->rx.itr);
1639 wr32(hw, GLINT_ITR(ICE_TX_ITR, vector), q_vector->tx.itr);
1640
1641 /* Both Transmit Queue Interrupt Cause Control register
1642 * and Receive Queue Interrupt Cause control register
1643 * expects MSIX_INDX field to be the vector index
1644 * within the function space and not the absolute
1645 * vector index across PF or across device.
1646 * For SR-IOV VF VSIs queue vector index always starts
1647 * with 1 since first vector index(0) is used for OICR
1648 * in VF space. Since VMDq and other PF VSIs are withtin
1649 * the PF function space, use the vector index thats
1650 * tracked for this PF.
1651 */
1652 for (q = 0; q < q_vector->num_ring_tx; q++) {
1653 u32 val;
1654
1655 itr = ICE_TX_ITR;
1656 val = QINT_TQCTL_CAUSE_ENA_M |
1657 (itr << QINT_TQCTL_ITR_INDX_S) |
1658 (vector << QINT_TQCTL_MSIX_INDX_S);
1659 wr32(hw, QINT_TQCTL(vsi->txq_map[txq]), val);
1660 txq++;
1661 }
1662
1663 for (q = 0; q < q_vector->num_ring_rx; q++) {
1664 u32 val;
1665
1666 itr = ICE_RX_ITR;
1667 val = QINT_RQCTL_CAUSE_ENA_M |
1668 (itr << QINT_RQCTL_ITR_INDX_S) |
1669 (vector << QINT_RQCTL_MSIX_INDX_S);
1670 wr32(hw, QINT_RQCTL(vsi->rxq_map[rxq]), val);
1671 rxq++;
1672 }
1673 }
1674
1675 ice_flush(hw);
1676}
1677
1678/**
1679 * ice_ena_misc_vector - enable the non-queue interrupts
1680 * @pf: board private structure
1681 */
1682static void ice_ena_misc_vector(struct ice_pf *pf)
1683{
1684 struct ice_hw *hw = &pf->hw;
1685 u32 val;
1686
1687 /* clear things first */
1688 wr32(hw, PFINT_OICR_ENA, 0); /* disable all */
1689 rd32(hw, PFINT_OICR); /* read to clear */
1690
1691 val = (PFINT_OICR_HLP_RDY_M |
1692 PFINT_OICR_CPM_RDY_M |
1693 PFINT_OICR_ECC_ERR_M |
1694 PFINT_OICR_MAL_DETECT_M |
1695 PFINT_OICR_GRST_M |
1696 PFINT_OICR_PCI_EXCEPTION_M |
1697 PFINT_OICR_GPIO_M |
1698 PFINT_OICR_STORM_DETECT_M |
1699 PFINT_OICR_HMC_ERR_M);
1700
1701 wr32(hw, PFINT_OICR_ENA, val);
1702
1703 /* SW_ITR_IDX = 0, but don't change INTENA */
1704 wr32(hw, GLINT_DYN_CTL(pf->oicr_idx),
1705 GLINT_DYN_CTL_SW_ITR_INDX_M | GLINT_DYN_CTL_INTENA_MSK_M);
1706}
1707
1708/**
1709 * ice_misc_intr - misc interrupt handler
1710 * @irq: interrupt number
1711 * @data: pointer to a q_vector
1712 */
1713static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
1714{
1715 struct ice_pf *pf = (struct ice_pf *)data;
1716 struct ice_hw *hw = &pf->hw;
1717 irqreturn_t ret = IRQ_NONE;
1718 u32 oicr, ena_mask;
1719
1720 set_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state);
1721
1722 oicr = rd32(hw, PFINT_OICR);
1723 ena_mask = rd32(hw, PFINT_OICR_ENA);
1724
1725 if (oicr & PFINT_OICR_GRST_M) {
1726 u32 reset;
1727 /* we have a reset warning */
1728 ena_mask &= ~PFINT_OICR_GRST_M;
1729 reset = (rd32(hw, GLGEN_RSTAT) & GLGEN_RSTAT_RESET_TYPE_M) >>
1730 GLGEN_RSTAT_RESET_TYPE_S;
1731
1732 if (reset == ICE_RESET_CORER)
1733 pf->corer_count++;
1734 else if (reset == ICE_RESET_GLOBR)
1735 pf->globr_count++;
1736 else
1737 pf->empr_count++;
1738
1739 /* If a reset cycle isn't already in progress, we set a bit in
1740 * pf->state so that the service task can start a reset/rebuild.
1741 * We also make note of which reset happened so that peer
1742 * devices/drivers can be informed.
1743 */
1744 if (!test_bit(__ICE_RESET_RECOVERY_PENDING, pf->state)) {
1745 if (reset == ICE_RESET_CORER)
1746 set_bit(__ICE_CORER_RECV, pf->state);
1747 else if (reset == ICE_RESET_GLOBR)
1748 set_bit(__ICE_GLOBR_RECV, pf->state);
1749 else
1750 set_bit(__ICE_EMPR_RECV, pf->state);
1751
1752 set_bit(__ICE_RESET_RECOVERY_PENDING, pf->state);
1753 }
1754 }
1755
1756 if (oicr & PFINT_OICR_HMC_ERR_M) {
1757 ena_mask &= ~PFINT_OICR_HMC_ERR_M;
1758 dev_dbg(&pf->pdev->dev,
1759 "HMC Error interrupt - info 0x%x, data 0x%x\n",
1760 rd32(hw, PFHMC_ERRORINFO),
1761 rd32(hw, PFHMC_ERRORDATA));
1762 }
1763
1764 /* Report and mask off any remaining unexpected interrupts */
1765 oicr &= ena_mask;
1766 if (oicr) {
1767 dev_dbg(&pf->pdev->dev, "unhandled interrupt oicr=0x%08x\n",
1768 oicr);
1769 /* If a critical error is pending there is no choice but to
1770 * reset the device.
1771 */
1772 if (oicr & (PFINT_OICR_PE_CRITERR_M |
1773 PFINT_OICR_PCI_EXCEPTION_M |
1774 PFINT_OICR_ECC_ERR_M)) {
1775 set_bit(__ICE_PFR_REQ, pf->state);
1776 ice_service_task_schedule(pf);
1777 }
1778 ena_mask &= ~oicr;
1779 }
1780 ret = IRQ_HANDLED;
1781
1782 /* re-enable interrupt causes that are not handled during this pass */
1783 wr32(hw, PFINT_OICR_ENA, ena_mask);
1784 if (!test_bit(__ICE_DOWN, pf->state)) {
1785 ice_service_task_schedule(pf);
1786 ice_irq_dynamic_ena(hw, NULL, NULL);
1787 }
1788
1789 return ret;
1790}
1791
1792/**
1793 * ice_vsi_map_rings_to_vectors - Map VSI rings to interrupt vectors
1794 * @vsi: the VSI being configured
1795 *
1796 * This function maps descriptor rings to the queue-specific vectors allotted
1797 * through the MSI-X enabling code. On a constrained vector budget, we map Tx
1798 * and Rx rings to the vector as "efficiently" as possible.
1799 */
1800static void ice_vsi_map_rings_to_vectors(struct ice_vsi *vsi)
1801{
1802 int q_vectors = vsi->num_q_vectors;
1803 int tx_rings_rem, rx_rings_rem;
1804 int v_id;
1805
1806 /* initially assigning remaining rings count to VSIs num queue value */
1807 tx_rings_rem = vsi->num_txq;
1808 rx_rings_rem = vsi->num_rxq;
1809
1810 for (v_id = 0; v_id < q_vectors; v_id++) {
1811 struct ice_q_vector *q_vector = vsi->q_vectors[v_id];
1812 int tx_rings_per_v, rx_rings_per_v, q_id, q_base;
1813
1814 /* Tx rings mapping to vector */
1815 tx_rings_per_v = DIV_ROUND_UP(tx_rings_rem, q_vectors - v_id);
1816 q_vector->num_ring_tx = tx_rings_per_v;
1817 q_vector->tx.ring = NULL;
1818 q_base = vsi->num_txq - tx_rings_rem;
1819
1820 for (q_id = q_base; q_id < (q_base + tx_rings_per_v); q_id++) {
1821 struct ice_ring *tx_ring = vsi->tx_rings[q_id];
1822
1823 tx_ring->q_vector = q_vector;
1824 tx_ring->next = q_vector->tx.ring;
1825 q_vector->tx.ring = tx_ring;
1826 }
1827 tx_rings_rem -= tx_rings_per_v;
1828
1829 /* Rx rings mapping to vector */
1830 rx_rings_per_v = DIV_ROUND_UP(rx_rings_rem, q_vectors - v_id);
1831 q_vector->num_ring_rx = rx_rings_per_v;
1832 q_vector->rx.ring = NULL;
1833 q_base = vsi->num_rxq - rx_rings_rem;
1834
1835 for (q_id = q_base; q_id < (q_base + rx_rings_per_v); q_id++) {
1836 struct ice_ring *rx_ring = vsi->rx_rings[q_id];
1837
1838 rx_ring->q_vector = q_vector;
1839 rx_ring->next = q_vector->rx.ring;
1840 q_vector->rx.ring = rx_ring;
1841 }
1842 rx_rings_rem -= rx_rings_per_v;
1843 }
1844}
1845
1846/**
1847 * ice_vsi_set_num_qs - Set num queues, descriptors and vectors for a VSI
1848 * @vsi: the VSI being configured
1849 *
1850 * Return 0 on success and a negative value on error
1851 */
1852static void ice_vsi_set_num_qs(struct ice_vsi *vsi)
1853{
1854 struct ice_pf *pf = vsi->back;
1855
1856 switch (vsi->type) {
1857 case ICE_VSI_PF:
1858 vsi->alloc_txq = pf->num_lan_tx;
1859 vsi->alloc_rxq = pf->num_lan_rx;
1860 vsi->num_desc = ALIGN(ICE_DFLT_NUM_DESC, ICE_REQ_DESC_MULTIPLE);
1861 vsi->num_q_vectors = max_t(int, pf->num_lan_rx, pf->num_lan_tx);
1862 break;
1863 default:
1864 dev_warn(&vsi->back->pdev->dev, "Unknown VSI type %d\n",
1865 vsi->type);
1866 break;
1867 }
1868}
1869
1870/**
1871 * ice_vsi_alloc_arrays - Allocate queue and vector pointer arrays for the vsi
1872 * @vsi: VSI pointer
1873 * @alloc_qvectors: a bool to specify if q_vectors need to be allocated.
1874 *
1875 * On error: returns error code (negative)
1876 * On success: returns 0
1877 */
1878static int ice_vsi_alloc_arrays(struct ice_vsi *vsi, bool alloc_qvectors)
1879{
1880 struct ice_pf *pf = vsi->back;
1881
1882 /* allocate memory for both Tx and Rx ring pointers */
1883 vsi->tx_rings = devm_kcalloc(&pf->pdev->dev, vsi->alloc_txq,
1884 sizeof(struct ice_ring *), GFP_KERNEL);
1885 if (!vsi->tx_rings)
1886 goto err_txrings;
1887
1888 vsi->rx_rings = devm_kcalloc(&pf->pdev->dev, vsi->alloc_rxq,
1889 sizeof(struct ice_ring *), GFP_KERNEL);
1890 if (!vsi->rx_rings)
1891 goto err_rxrings;
1892
1893 if (alloc_qvectors) {
1894 /* allocate memory for q_vector pointers */
1895 vsi->q_vectors = devm_kcalloc(&pf->pdev->dev,
1896 vsi->num_q_vectors,
1897 sizeof(struct ice_q_vector *),
1898 GFP_KERNEL);
1899 if (!vsi->q_vectors)
1900 goto err_vectors;
1901 }
1902
1903 return 0;
1904
1905err_vectors:
1906 devm_kfree(&pf->pdev->dev, vsi->rx_rings);
1907err_rxrings:
1908 devm_kfree(&pf->pdev->dev, vsi->tx_rings);
1909err_txrings:
1910 return -ENOMEM;
1911}
1912
1913/**
1914 * ice_msix_clean_rings - MSIX mode Interrupt Handler
1915 * @irq: interrupt number
1916 * @data: pointer to a q_vector
1917 */
1918static irqreturn_t ice_msix_clean_rings(int __always_unused irq, void *data)
1919{
1920 struct ice_q_vector *q_vector = (struct ice_q_vector *)data;
1921
1922 if (!q_vector->tx.ring && !q_vector->rx.ring)
1923 return IRQ_HANDLED;
1924
1925 napi_schedule(&q_vector->napi);
1926
1927 return IRQ_HANDLED;
1928}
1929
1930/**
1931 * ice_vsi_alloc - Allocates the next available struct vsi in the PF
1932 * @pf: board private structure
1933 * @type: type of VSI
1934 *
1935 * returns a pointer to a VSI on success, NULL on failure.
1936 */
1937static struct ice_vsi *ice_vsi_alloc(struct ice_pf *pf, enum ice_vsi_type type)
1938{
1939 struct ice_vsi *vsi = NULL;
1940
1941 /* Need to protect the allocation of the VSIs at the PF level */
1942 mutex_lock(&pf->sw_mutex);
1943
1944 /* If we have already allocated our maximum number of VSIs,
1945 * pf->next_vsi will be ICE_NO_VSI. If not, pf->next_vsi index
1946 * is available to be populated
1947 */
1948 if (pf->next_vsi == ICE_NO_VSI) {
1949 dev_dbg(&pf->pdev->dev, "out of VSI slots!\n");
1950 goto unlock_pf;
1951 }
1952
1953 vsi = devm_kzalloc(&pf->pdev->dev, sizeof(*vsi), GFP_KERNEL);
1954 if (!vsi)
1955 goto unlock_pf;
1956
1957 vsi->type = type;
1958 vsi->back = pf;
1959 set_bit(__ICE_DOWN, vsi->state);
1960 vsi->idx = pf->next_vsi;
1961 vsi->work_lmt = ICE_DFLT_IRQ_WORK;
1962
1963 ice_vsi_set_num_qs(vsi);
1964
1965 switch (vsi->type) {
1966 case ICE_VSI_PF:
1967 if (ice_vsi_alloc_arrays(vsi, true))
1968 goto err_rings;
1969
1970 /* Setup default MSIX irq handler for VSI */
1971 vsi->irq_handler = ice_msix_clean_rings;
1972 break;
1973 default:
1974 dev_warn(&pf->pdev->dev, "Unknown VSI type %d\n", vsi->type);
1975 goto unlock_pf;
1976 }
1977
1978 /* fill VSI slot in the PF struct */
1979 pf->vsi[pf->next_vsi] = vsi;
1980
1981 /* prepare pf->next_vsi for next use */
1982 pf->next_vsi = ice_get_free_slot(pf->vsi, pf->num_alloc_vsi,
1983 pf->next_vsi);
1984 goto unlock_pf;
1985
1986err_rings:
1987 devm_kfree(&pf->pdev->dev, vsi);
1988 vsi = NULL;
1989unlock_pf:
1990 mutex_unlock(&pf->sw_mutex);
1991 return vsi;
1992}
1993
1994/**
1995 * ice_free_irq_msix_misc - Unroll misc vector setup
1996 * @pf: board private structure
1997 */
1998static void ice_free_irq_msix_misc(struct ice_pf *pf)
1999{
2000 /* disable OICR interrupt */
2001 wr32(&pf->hw, PFINT_OICR_ENA, 0);
2002 ice_flush(&pf->hw);
2003
2004 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags) && pf->msix_entries) {
2005 synchronize_irq(pf->msix_entries[pf->oicr_idx].vector);
2006 devm_free_irq(&pf->pdev->dev,
2007 pf->msix_entries[pf->oicr_idx].vector, pf);
2008 }
2009
2010 ice_free_res(pf->irq_tracker, pf->oicr_idx, ICE_RES_MISC_VEC_ID);
2011}
2012
2013/**
2014 * ice_req_irq_msix_misc - Setup the misc vector to handle non queue events
2015 * @pf: board private structure
2016 *
2017 * This sets up the handler for MSIX 0, which is used to manage the
2018 * non-queue interrupts, e.g. AdminQ and errors. This is not used
2019 * when in MSI or Legacy interrupt mode.
2020 */
2021static int ice_req_irq_msix_misc(struct ice_pf *pf)
2022{
2023 struct ice_hw *hw = &pf->hw;
2024 int oicr_idx, err = 0;
2025 u8 itr_gran;
2026 u32 val;
2027
2028 if (!pf->int_name[0])
2029 snprintf(pf->int_name, sizeof(pf->int_name) - 1, "%s-%s:misc",
2030 dev_driver_string(&pf->pdev->dev),
2031 dev_name(&pf->pdev->dev));
2032
2033 /* Do not request IRQ but do enable OICR interrupt since settings are
2034 * lost during reset. Note that this function is called only during
2035 * rebuild path and not while reset is in progress.
2036 */
2037 if (ice_is_reset_recovery_pending(pf->state))
2038 goto skip_req_irq;
2039
2040 /* reserve one vector in irq_tracker for misc interrupts */
2041 oicr_idx = ice_get_res(pf, pf->irq_tracker, 1, ICE_RES_MISC_VEC_ID);
2042 if (oicr_idx < 0)
2043 return oicr_idx;
2044
2045 pf->oicr_idx = oicr_idx;
2046
2047 err = devm_request_irq(&pf->pdev->dev,
2048 pf->msix_entries[pf->oicr_idx].vector,
2049 ice_misc_intr, 0, pf->int_name, pf);
2050 if (err) {
2051 dev_err(&pf->pdev->dev,
2052 "devm_request_irq for %s failed: %d\n",
2053 pf->int_name, err);
2054 ice_free_res(pf->irq_tracker, 1, ICE_RES_MISC_VEC_ID);
2055 return err;
2056 }
2057
2058skip_req_irq:
2059 ice_ena_misc_vector(pf);
2060
2061 val = (pf->oicr_idx & PFINT_OICR_CTL_MSIX_INDX_M) |
2062 (ICE_RX_ITR & PFINT_OICR_CTL_ITR_INDX_M) |
2063 PFINT_OICR_CTL_CAUSE_ENA_M;
2064 wr32(hw, PFINT_OICR_CTL, val);
2065
2066 /* This enables Admin queue Interrupt causes */
2067 val = (pf->oicr_idx & PFINT_FW_CTL_MSIX_INDX_M) |
2068 (ICE_RX_ITR & PFINT_FW_CTL_ITR_INDX_M) |
2069 PFINT_FW_CTL_CAUSE_ENA_M;
2070 wr32(hw, PFINT_FW_CTL, val);
2071
2072 itr_gran = hw->itr_gran_200;
2073
2074 wr32(hw, GLINT_ITR(ICE_RX_ITR, pf->oicr_idx),
2075 ITR_TO_REG(ICE_ITR_8K, itr_gran));
2076
2077 ice_flush(hw);
2078 ice_irq_dynamic_ena(hw, NULL, NULL);
2079
2080 return 0;
2081}
2082
2083/**
2084 * ice_vsi_get_qs_contig - Assign a contiguous chunk of queues to VSI
2085 * @vsi: the VSI getting queues
2086 *
2087 * Return 0 on success and a negative value on error
2088 */
2089static int ice_vsi_get_qs_contig(struct ice_vsi *vsi)
2090{
2091 struct ice_pf *pf = vsi->back;
2092 int offset, ret = 0;
2093
2094 mutex_lock(&pf->avail_q_mutex);
2095 /* look for contiguous block of queues for tx */
2096 offset = bitmap_find_next_zero_area(pf->avail_txqs, ICE_MAX_TXQS,
2097 0, vsi->alloc_txq, 0);
2098 if (offset < ICE_MAX_TXQS) {
2099 int i;
2100
2101 bitmap_set(pf->avail_txqs, offset, vsi->alloc_txq);
2102 for (i = 0; i < vsi->alloc_txq; i++)
2103 vsi->txq_map[i] = i + offset;
2104 } else {
2105 ret = -ENOMEM;
2106 vsi->tx_mapping_mode = ICE_VSI_MAP_SCATTER;
2107 }
2108
2109 /* look for contiguous block of queues for rx */
2110 offset = bitmap_find_next_zero_area(pf->avail_rxqs, ICE_MAX_RXQS,
2111 0, vsi->alloc_rxq, 0);
2112 if (offset < ICE_MAX_RXQS) {
2113 int i;
2114
2115 bitmap_set(pf->avail_rxqs, offset, vsi->alloc_rxq);
2116 for (i = 0; i < vsi->alloc_rxq; i++)
2117 vsi->rxq_map[i] = i + offset;
2118 } else {
2119 ret = -ENOMEM;
2120 vsi->rx_mapping_mode = ICE_VSI_MAP_SCATTER;
2121 }
2122 mutex_unlock(&pf->avail_q_mutex);
2123
2124 return ret;
2125}
2126
2127/**
2128 * ice_vsi_get_qs_scatter - Assign a scattered queues to VSI
2129 * @vsi: the VSI getting queues
2130 *
2131 * Return 0 on success and a negative value on error
2132 */
2133static int ice_vsi_get_qs_scatter(struct ice_vsi *vsi)
2134{
2135 struct ice_pf *pf = vsi->back;
2136 int i, index = 0;
2137
2138 mutex_lock(&pf->avail_q_mutex);
2139
2140 if (vsi->tx_mapping_mode == ICE_VSI_MAP_SCATTER) {
2141 for (i = 0; i < vsi->alloc_txq; i++) {
2142 index = find_next_zero_bit(pf->avail_txqs,
2143 ICE_MAX_TXQS, index);
2144 if (index < ICE_MAX_TXQS) {
2145 set_bit(index, pf->avail_txqs);
2146 vsi->txq_map[i] = index;
2147 } else {
2148 goto err_scatter_tx;
2149 }
2150 }
2151 }
2152
2153 if (vsi->rx_mapping_mode == ICE_VSI_MAP_SCATTER) {
2154 for (i = 0; i < vsi->alloc_rxq; i++) {
2155 index = find_next_zero_bit(pf->avail_rxqs,
2156 ICE_MAX_RXQS, index);
2157 if (index < ICE_MAX_RXQS) {
2158 set_bit(index, pf->avail_rxqs);
2159 vsi->rxq_map[i] = index;
2160 } else {
2161 goto err_scatter_rx;
2162 }
2163 }
2164 }
2165
2166 mutex_unlock(&pf->avail_q_mutex);
2167 return 0;
2168
2169err_scatter_rx:
2170 /* unflag any queues we have grabbed (i is failed position) */
2171 for (index = 0; index < i; index++) {
2172 clear_bit(vsi->rxq_map[index], pf->avail_rxqs);
2173 vsi->rxq_map[index] = 0;
2174 }
2175 i = vsi->alloc_txq;
2176err_scatter_tx:
2177 /* i is either position of failed attempt or vsi->alloc_txq */
2178 for (index = 0; index < i; index++) {
2179 clear_bit(vsi->txq_map[index], pf->avail_txqs);
2180 vsi->txq_map[index] = 0;
2181 }
2182
2183 mutex_unlock(&pf->avail_q_mutex);
2184 return -ENOMEM;
2185}
2186
2187/**
2188 * ice_vsi_get_qs - Assign queues from PF to VSI
2189 * @vsi: the VSI to assign queues to
2190 *
2191 * Returns 0 on success and a negative value on error
2192 */
2193static int ice_vsi_get_qs(struct ice_vsi *vsi)
2194{
2195 int ret = 0;
2196
2197 vsi->tx_mapping_mode = ICE_VSI_MAP_CONTIG;
2198 vsi->rx_mapping_mode = ICE_VSI_MAP_CONTIG;
2199
2200 /* NOTE: ice_vsi_get_qs_contig() will set the rx/tx mapping
2201 * modes individually to scatter if assigning contiguous queues
2202 * to rx or tx fails
2203 */
2204 ret = ice_vsi_get_qs_contig(vsi);
2205 if (ret < 0) {
2206 if (vsi->tx_mapping_mode == ICE_VSI_MAP_SCATTER)
2207 vsi->alloc_txq = max_t(u16, vsi->alloc_txq,
2208 ICE_MAX_SCATTER_TXQS);
2209 if (vsi->rx_mapping_mode == ICE_VSI_MAP_SCATTER)
2210 vsi->alloc_rxq = max_t(u16, vsi->alloc_rxq,
2211 ICE_MAX_SCATTER_RXQS);
2212 ret = ice_vsi_get_qs_scatter(vsi);
2213 }
2214
2215 return ret;
2216}
2217
2218/**
2219 * ice_vsi_put_qs - Release queues from VSI to PF
2220 * @vsi: the VSI thats going to release queues
2221 */
2222static void ice_vsi_put_qs(struct ice_vsi *vsi)
2223{
2224 struct ice_pf *pf = vsi->back;
2225 int i;
2226
2227 mutex_lock(&pf->avail_q_mutex);
2228
2229 for (i = 0; i < vsi->alloc_txq; i++) {
2230 clear_bit(vsi->txq_map[i], pf->avail_txqs);
2231 vsi->txq_map[i] = ICE_INVAL_Q_INDEX;
2232 }
2233
2234 for (i = 0; i < vsi->alloc_rxq; i++) {
2235 clear_bit(vsi->rxq_map[i], pf->avail_rxqs);
2236 vsi->rxq_map[i] = ICE_INVAL_Q_INDEX;
2237 }
2238
2239 mutex_unlock(&pf->avail_q_mutex);
2240}
2241
2242/**
2243 * ice_free_q_vector - Free memory allocated for a specific interrupt vector
2244 * @vsi: VSI having the memory freed
2245 * @v_idx: index of the vector to be freed
2246 */
2247static void ice_free_q_vector(struct ice_vsi *vsi, int v_idx)
2248{
2249 struct ice_q_vector *q_vector;
2250 struct ice_ring *ring;
2251
2252 if (!vsi->q_vectors[v_idx]) {
2253 dev_dbg(&vsi->back->pdev->dev, "Queue vector at index %d not found\n",
2254 v_idx);
2255 return;
2256 }
2257 q_vector = vsi->q_vectors[v_idx];
2258
2259 ice_for_each_ring(ring, q_vector->tx)
2260 ring->q_vector = NULL;
2261 ice_for_each_ring(ring, q_vector->rx)
2262 ring->q_vector = NULL;
2263
2264 /* only VSI with an associated netdev is set up with NAPI */
2265 if (vsi->netdev)
2266 netif_napi_del(&q_vector->napi);
2267
2268 devm_kfree(&vsi->back->pdev->dev, q_vector);
2269 vsi->q_vectors[v_idx] = NULL;
2270}
2271
2272/**
2273 * ice_vsi_free_q_vectors - Free memory allocated for interrupt vectors
2274 * @vsi: the VSI having memory freed
2275 */
2276static void ice_vsi_free_q_vectors(struct ice_vsi *vsi)
2277{
2278 int v_idx;
2279
2280 for (v_idx = 0; v_idx < vsi->num_q_vectors; v_idx++)
2281 ice_free_q_vector(vsi, v_idx);
2282}
2283
2284/**
2285 * ice_cfg_netdev - Setup the netdev flags
2286 * @vsi: the VSI being configured
2287 *
2288 * Returns 0 on success, negative value on failure
2289 */
2290static int ice_cfg_netdev(struct ice_vsi *vsi)
2291{
2292 netdev_features_t csumo_features;
2293 netdev_features_t vlano_features;
2294 netdev_features_t dflt_features;
2295 netdev_features_t tso_features;
2296 struct ice_netdev_priv *np;
2297 struct net_device *netdev;
2298 u8 mac_addr[ETH_ALEN];
2299
2300 netdev = alloc_etherdev_mqs(sizeof(struct ice_netdev_priv),
2301 vsi->alloc_txq, vsi->alloc_rxq);
2302 if (!netdev)
2303 return -ENOMEM;
2304
2305 vsi->netdev = netdev;
2306 np = netdev_priv(netdev);
2307 np->vsi = vsi;
2308
2309 dflt_features = NETIF_F_SG |
2310 NETIF_F_HIGHDMA |
2311 NETIF_F_RXHASH;
2312
2313 csumo_features = NETIF_F_RXCSUM |
2314 NETIF_F_IP_CSUM |
2315 NETIF_F_IPV6_CSUM;
2316
2317 vlano_features = NETIF_F_HW_VLAN_CTAG_FILTER |
2318 NETIF_F_HW_VLAN_CTAG_TX |
2319 NETIF_F_HW_VLAN_CTAG_RX;
2320
2321 tso_features = NETIF_F_TSO;
2322
2323 /* set features that user can change */
2324 netdev->hw_features = dflt_features | csumo_features |
2325 vlano_features | tso_features;
2326
2327 /* enable features */
2328 netdev->features |= netdev->hw_features;
2329 /* encap and VLAN devices inherit default, csumo and tso features */
2330 netdev->hw_enc_features |= dflt_features | csumo_features |
2331 tso_features;
2332 netdev->vlan_features |= dflt_features | csumo_features |
2333 tso_features;
2334
2335 if (vsi->type == ICE_VSI_PF) {
2336 SET_NETDEV_DEV(netdev, &vsi->back->pdev->dev);
2337 ether_addr_copy(mac_addr, vsi->port_info->mac.perm_addr);
2338
2339 ether_addr_copy(netdev->dev_addr, mac_addr);
2340 ether_addr_copy(netdev->perm_addr, mac_addr);
2341 }
2342
2343 netdev->priv_flags |= IFF_UNICAST_FLT;
2344
2345 /* assign netdev_ops */
2346 netdev->netdev_ops = &ice_netdev_ops;
2347
2348 /* setup watchdog timeout value to be 5 second */
2349 netdev->watchdog_timeo = 5 * HZ;
2350
2351 ice_set_ethtool_ops(netdev);
2352
2353 netdev->min_mtu = ETH_MIN_MTU;
2354 netdev->max_mtu = ICE_MAX_MTU;
2355
2356 return 0;
2357}
2358
2359/**
2360 * ice_vsi_free_arrays - clean up vsi resources
2361 * @vsi: pointer to VSI being cleared
2362 * @free_qvectors: bool to specify if q_vectors should be deallocated
2363 */
2364static void ice_vsi_free_arrays(struct ice_vsi *vsi, bool free_qvectors)
2365{
2366 struct ice_pf *pf = vsi->back;
2367
2368 /* free the ring and vector containers */
2369 if (free_qvectors && vsi->q_vectors) {
2370 devm_kfree(&pf->pdev->dev, vsi->q_vectors);
2371 vsi->q_vectors = NULL;
2372 }
2373 if (vsi->tx_rings) {
2374 devm_kfree(&pf->pdev->dev, vsi->tx_rings);
2375 vsi->tx_rings = NULL;
2376 }
2377 if (vsi->rx_rings) {
2378 devm_kfree(&pf->pdev->dev, vsi->rx_rings);
2379 vsi->rx_rings = NULL;
2380 }
2381}
2382
2383/**
2384 * ice_vsi_clear - clean up and deallocate the provided vsi
2385 * @vsi: pointer to VSI being cleared
2386 *
2387 * This deallocates the vsi's queue resources, removes it from the PF's
2388 * VSI array if necessary, and deallocates the VSI
2389 *
2390 * Returns 0 on success, negative on failure
2391 */
2392static int ice_vsi_clear(struct ice_vsi *vsi)
2393{
2394 struct ice_pf *pf = NULL;
2395
2396 if (!vsi)
2397 return 0;
2398
2399 if (!vsi->back)
2400 return -EINVAL;
2401
2402 pf = vsi->back;
2403
2404 if (!pf->vsi[vsi->idx] || pf->vsi[vsi->idx] != vsi) {
2405 dev_dbg(&pf->pdev->dev, "vsi does not exist at pf->vsi[%d]\n",
2406 vsi->idx);
2407 return -EINVAL;
2408 }
2409
2410 mutex_lock(&pf->sw_mutex);
2411 /* updates the PF for this cleared vsi */
2412
2413 pf->vsi[vsi->idx] = NULL;
2414 if (vsi->idx < pf->next_vsi)
2415 pf->next_vsi = vsi->idx;
2416
2417 ice_vsi_free_arrays(vsi, true);
2418 mutex_unlock(&pf->sw_mutex);
2419 devm_kfree(&pf->pdev->dev, vsi);
2420
2421 return 0;
2422}
2423
2424/**
2425 * ice_vsi_alloc_q_vector - Allocate memory for a single interrupt vector
2426 * @vsi: the VSI being configured
2427 * @v_idx: index of the vector in the vsi struct
2428 *
2429 * We allocate one q_vector. If allocation fails we return -ENOMEM.
2430 */
2431static int ice_vsi_alloc_q_vector(struct ice_vsi *vsi, int v_idx)
2432{
2433 struct ice_pf *pf = vsi->back;
2434 struct ice_q_vector *q_vector;
2435
2436 /* allocate q_vector */
2437 q_vector = devm_kzalloc(&pf->pdev->dev, sizeof(*q_vector), GFP_KERNEL);
2438 if (!q_vector)
2439 return -ENOMEM;
2440
2441 q_vector->vsi = vsi;
2442 q_vector->v_idx = v_idx;
2443 /* only set affinity_mask if the CPU is online */
2444 if (cpu_online(v_idx))
2445 cpumask_set_cpu(v_idx, &q_vector->affinity_mask);
2446
2447 if (vsi->netdev)
2448 netif_napi_add(vsi->netdev, &q_vector->napi, ice_napi_poll,
2449 NAPI_POLL_WEIGHT);
2450 /* tie q_vector and vsi together */
2451 vsi->q_vectors[v_idx] = q_vector;
2452
2453 return 0;
2454}
2455
2456/**
2457 * ice_vsi_alloc_q_vectors - Allocate memory for interrupt vectors
2458 * @vsi: the VSI being configured
2459 *
2460 * We allocate one q_vector per queue interrupt. If allocation fails we
2461 * return -ENOMEM.
2462 */
2463static int ice_vsi_alloc_q_vectors(struct ice_vsi *vsi)
2464{
2465 struct ice_pf *pf = vsi->back;
2466 int v_idx = 0, num_q_vectors;
2467 int err;
2468
2469 if (vsi->q_vectors[0]) {
2470 dev_dbg(&pf->pdev->dev, "VSI %d has existing q_vectors\n",
2471 vsi->vsi_num);
2472 return -EEXIST;
2473 }
2474
2475 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags)) {
2476 num_q_vectors = vsi->num_q_vectors;
2477 } else {
2478 err = -EINVAL;
2479 goto err_out;
2480 }
2481
2482 for (v_idx = 0; v_idx < num_q_vectors; v_idx++) {
2483 err = ice_vsi_alloc_q_vector(vsi, v_idx);
2484 if (err)
2485 goto err_out;
2486 }
2487
2488 return 0;
2489
2490err_out:
2491 while (v_idx--)
2492 ice_free_q_vector(vsi, v_idx);
2493
2494 dev_err(&pf->pdev->dev,
2495 "Failed to allocate %d q_vector for VSI %d, ret=%d\n",
2496 vsi->num_q_vectors, vsi->vsi_num, err);
2497 vsi->num_q_vectors = 0;
2498 return err;
2499}
2500
2501/**
2502 * ice_vsi_setup_vector_base - Set up the base vector for the given VSI
2503 * @vsi: ptr to the VSI
2504 *
2505 * This should only be called after ice_vsi_alloc() which allocates the
2506 * corresponding SW VSI structure and initializes num_queue_pairs for the
2507 * newly allocated VSI.
2508 *
2509 * Returns 0 on success or negative on failure
2510 */
2511static int ice_vsi_setup_vector_base(struct ice_vsi *vsi)
2512{
2513 struct ice_pf *pf = vsi->back;
2514 int num_q_vectors = 0;
2515
2516 if (vsi->base_vector) {
2517 dev_dbg(&pf->pdev->dev, "VSI %d has non-zero base vector %d\n",
2518 vsi->vsi_num, vsi->base_vector);
2519 return -EEXIST;
2520 }
2521
2522 if (!test_bit(ICE_FLAG_MSIX_ENA, pf->flags))
2523 return -ENOENT;
2524
2525 switch (vsi->type) {
2526 case ICE_VSI_PF:
2527 num_q_vectors = vsi->num_q_vectors;
2528 break;
2529 default:
2530 dev_warn(&vsi->back->pdev->dev, "Unknown VSI type %d\n",
2531 vsi->type);
2532 break;
2533 }
2534
2535 if (num_q_vectors)
2536 vsi->base_vector = ice_get_res(pf, pf->irq_tracker,
2537 num_q_vectors, vsi->idx);
2538
2539 if (vsi->base_vector < 0) {
2540 dev_err(&pf->pdev->dev,
2541 "Failed to get tracking for %d vectors for VSI %d, err=%d\n",
2542 num_q_vectors, vsi->vsi_num, vsi->base_vector);
2543 return -ENOENT;
2544 }
2545
2546 return 0;
2547}
2548
2549/**
2550 * ice_fill_rss_lut - Fill the RSS lookup table with default values
2551 * @lut: Lookup table
2552 * @rss_table_size: Lookup table size
2553 * @rss_size: Range of queue number for hashing
2554 */
2555void ice_fill_rss_lut(u8 *lut, u16 rss_table_size, u16 rss_size)
2556{
2557 u16 i;
2558
2559 for (i = 0; i < rss_table_size; i++)
2560 lut[i] = i % rss_size;
2561}
2562
2563/**
2564 * ice_vsi_cfg_rss - Configure RSS params for a VSI
2565 * @vsi: VSI to be configured
2566 */
2567static int ice_vsi_cfg_rss(struct ice_vsi *vsi)
2568{
2569 u8 seed[ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE];
2570 struct ice_aqc_get_set_rss_keys *key;
2571 struct ice_pf *pf = vsi->back;
2572 enum ice_status status;
2573 int err = 0;
2574 u8 *lut;
2575
2576 vsi->rss_size = min_t(int, vsi->rss_size, vsi->num_rxq);
2577
2578 lut = devm_kzalloc(&pf->pdev->dev, vsi->rss_table_size, GFP_KERNEL);
2579 if (!lut)
2580 return -ENOMEM;
2581
2582 if (vsi->rss_lut_user)
2583 memcpy(lut, vsi->rss_lut_user, vsi->rss_table_size);
2584 else
2585 ice_fill_rss_lut(lut, vsi->rss_table_size, vsi->rss_size);
2586
2587 status = ice_aq_set_rss_lut(&pf->hw, vsi->vsi_num, vsi->rss_lut_type,
2588 lut, vsi->rss_table_size);
2589
2590 if (status) {
2591 dev_err(&vsi->back->pdev->dev,
2592 "set_rss_lut failed, error %d\n", status);
2593 err = -EIO;
2594 goto ice_vsi_cfg_rss_exit;
2595 }
2596
2597 key = devm_kzalloc(&vsi->back->pdev->dev, sizeof(*key), GFP_KERNEL);
2598 if (!key) {
2599 err = -ENOMEM;
2600 goto ice_vsi_cfg_rss_exit;
2601 }
2602
2603 if (vsi->rss_hkey_user)
2604 memcpy(seed, vsi->rss_hkey_user,
2605 ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE);
2606 else
2607 netdev_rss_key_fill((void *)seed,
2608 ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE);
2609 memcpy(&key->standard_rss_key, seed,
2610 ICE_AQC_GET_SET_RSS_KEY_DATA_RSS_KEY_SIZE);
2611
2612 status = ice_aq_set_rss_key(&pf->hw, vsi->vsi_num, key);
2613
2614 if (status) {
2615 dev_err(&vsi->back->pdev->dev, "set_rss_key failed, error %d\n",
2616 status);
2617 err = -EIO;
2618 }
2619
2620 devm_kfree(&pf->pdev->dev, key);
2621ice_vsi_cfg_rss_exit:
2622 devm_kfree(&pf->pdev->dev, lut);
2623 return err;
2624}
2625
2626/**
2627 * ice_vsi_reinit_setup - return resource and reallocate resource for a VSI
2628 * @vsi: pointer to the ice_vsi
2629 *
2630 * This reallocates the VSIs queue resources
2631 *
2632 * Returns 0 on success and negative value on failure
2633 */
2634static int ice_vsi_reinit_setup(struct ice_vsi *vsi)
2635{
2636 u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };
2637 int ret, i;
2638
2639 if (!vsi)
2640 return -EINVAL;
2641
2642 ice_vsi_free_q_vectors(vsi);
2643 ice_free_res(vsi->back->irq_tracker, vsi->base_vector, vsi->idx);
2644 vsi->base_vector = 0;
2645 ice_vsi_clear_rings(vsi);
2646 ice_vsi_free_arrays(vsi, false);
2647 ice_vsi_set_num_qs(vsi);
2648
2649 /* Initialize VSI struct elements and create VSI in FW */
2650 ret = ice_vsi_add(vsi);
2651 if (ret < 0)
2652 goto err_vsi;
2653
2654 ret = ice_vsi_alloc_arrays(vsi, false);
2655 if (ret < 0)
2656 goto err_vsi;
2657
2658 switch (vsi->type) {
2659 case ICE_VSI_PF:
2660 if (!vsi->netdev) {
2661 ret = ice_cfg_netdev(vsi);
2662 if (ret)
2663 goto err_rings;
2664
2665 ret = register_netdev(vsi->netdev);
2666 if (ret)
2667 goto err_rings;
2668
2669 netif_carrier_off(vsi->netdev);
2670 netif_tx_stop_all_queues(vsi->netdev);
2671 }
2672
2673 ret = ice_vsi_alloc_q_vectors(vsi);
2674 if (ret)
2675 goto err_rings;
2676
2677 ret = ice_vsi_setup_vector_base(vsi);
2678 if (ret)
2679 goto err_vectors;
2680
2681 ret = ice_vsi_alloc_rings(vsi);
2682 if (ret)
2683 goto err_vectors;
2684
2685 ice_vsi_map_rings_to_vectors(vsi);
2686 break;
2687 default:
2688 break;
2689 }
2690
2691 ice_vsi_set_tc_cfg(vsi);
2692
2693 /* configure VSI nodes based on number of queues and TC's */
2694 for (i = 0; i < vsi->tc_cfg.numtc; i++)
2695 max_txqs[i] = vsi->num_txq;
2696
2697 ret = ice_cfg_vsi_lan(vsi->port_info, vsi->vsi_num,
2698 vsi->tc_cfg.ena_tc, max_txqs);
2699 if (ret) {
2700 dev_info(&vsi->back->pdev->dev,
2701 "Failed VSI lan queue config\n");
2702 goto err_vectors;
2703 }
2704 return 0;
2705
2706err_vectors:
2707 ice_vsi_free_q_vectors(vsi);
2708err_rings:
2709 if (vsi->netdev) {
2710 vsi->current_netdev_flags = 0;
2711 unregister_netdev(vsi->netdev);
2712 free_netdev(vsi->netdev);
2713 vsi->netdev = NULL;
2714 }
2715err_vsi:
2716 ice_vsi_clear(vsi);
2717 set_bit(__ICE_RESET_FAILED, vsi->back->state);
2718 return ret;
2719}
2720
2721/**
2722 * ice_vsi_setup - Set up a VSI by a given type
2723 * @pf: board private structure
2724 * @type: VSI type
2725 * @pi: pointer to the port_info instance
2726 *
2727 * This allocates the sw VSI structure and its queue resources.
2728 *
2729 * Returns pointer to the successfully allocated and configure VSI sw struct on
2730 * success, otherwise returns NULL on failure.
2731 */
2732static struct ice_vsi *
2733ice_vsi_setup(struct ice_pf *pf, enum ice_vsi_type type,
2734 struct ice_port_info *pi)
2735{
2736 u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };
2737 struct device *dev = &pf->pdev->dev;
2738 struct ice_vsi_ctx ctxt = { 0 };
2739 struct ice_vsi *vsi;
2740 int ret, i;
2741
2742 vsi = ice_vsi_alloc(pf, type);
2743 if (!vsi) {
2744 dev_err(dev, "could not allocate VSI\n");
2745 return NULL;
2746 }
2747
2748 vsi->port_info = pi;
2749 vsi->vsw = pf->first_sw;
2750
2751 if (ice_vsi_get_qs(vsi)) {
2752 dev_err(dev, "Failed to allocate queues. vsi->idx = %d\n",
2753 vsi->idx);
2754 goto err_get_qs;
2755 }
2756
2757 /* set RSS capabilities */
2758 ice_vsi_set_rss_params(vsi);
2759
2760 /* create the VSI */
2761 ret = ice_vsi_add(vsi);
2762 if (ret)
2763 goto err_vsi;
2764
2765 ctxt.vsi_num = vsi->vsi_num;
2766
2767 switch (vsi->type) {
2768 case ICE_VSI_PF:
2769 ret = ice_cfg_netdev(vsi);
2770 if (ret)
2771 goto err_cfg_netdev;
2772
2773 ret = register_netdev(vsi->netdev);
2774 if (ret)
2775 goto err_register_netdev;
2776
2777 netif_carrier_off(vsi->netdev);
2778
2779 /* make sure transmit queues start off as stopped */
2780 netif_tx_stop_all_queues(vsi->netdev);
2781 ret = ice_vsi_alloc_q_vectors(vsi);
2782 if (ret)
2783 goto err_msix;
2784
2785 ret = ice_vsi_setup_vector_base(vsi);
2786 if (ret)
2787 goto err_rings;
2788
2789 ret = ice_vsi_alloc_rings(vsi);
2790 if (ret)
2791 goto err_rings;
2792
2793 ice_vsi_map_rings_to_vectors(vsi);
2794
2795 /* Do not exit if configuring RSS had an issue, at least
2796 * receive traffic on first queue. Hence no need to capture
2797 * return value
2798 */
2799 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags))
2800 ice_vsi_cfg_rss(vsi);
2801 break;
2802 default:
2803 /* if vsi type is not recognized, clean up the resources and
2804 * exit
2805 */
2806 goto err_rings;
2807 }
2808
2809 ice_vsi_set_tc_cfg(vsi);
2810
2811 /* configure VSI nodes based on number of queues and TC's */
2812 for (i = 0; i < vsi->tc_cfg.numtc; i++)
2813 max_txqs[i] = vsi->num_txq;
2814
2815 ret = ice_cfg_vsi_lan(vsi->port_info, vsi->vsi_num,
2816 vsi->tc_cfg.ena_tc, max_txqs);
2817 if (ret) {
2818 dev_info(&pf->pdev->dev, "Failed VSI lan queue config\n");
2819 goto err_rings;
2820 }
2821
2822 return vsi;
2823
2824err_rings:
2825 ice_vsi_free_q_vectors(vsi);
2826err_msix:
2827 if (vsi->netdev && vsi->netdev->reg_state == NETREG_REGISTERED)
2828 unregister_netdev(vsi->netdev);
2829err_register_netdev:
2830 if (vsi->netdev) {
2831 free_netdev(vsi->netdev);
2832 vsi->netdev = NULL;
2833 }
2834err_cfg_netdev:
2835 ret = ice_aq_free_vsi(&pf->hw, &ctxt, false, NULL);
2836 if (ret)
2837 dev_err(&vsi->back->pdev->dev,
2838 "Free VSI AQ call failed, err %d\n", ret);
2839err_vsi:
2840 ice_vsi_put_qs(vsi);
2841err_get_qs:
2842 pf->q_left_tx += vsi->alloc_txq;
2843 pf->q_left_rx += vsi->alloc_rxq;
2844 ice_vsi_clear(vsi);
2845
2846 return NULL;
2847}
2848
2849/**
2850 * ice_vsi_add_vlan - Add vsi membership for given vlan
2851 * @vsi: the vsi being configured
2852 * @vid: vlan id to be added
2853 */
2854static int ice_vsi_add_vlan(struct ice_vsi *vsi, u16 vid)
2855{
2856 struct ice_fltr_list_entry *tmp;
2857 struct ice_pf *pf = vsi->back;
2858 LIST_HEAD(tmp_add_list);
2859 enum ice_status status;
2860 int err = 0;
2861
2862 tmp = devm_kzalloc(&pf->pdev->dev, sizeof(*tmp), GFP_KERNEL);
2863 if (!tmp)
2864 return -ENOMEM;
2865
2866 tmp->fltr_info.lkup_type = ICE_SW_LKUP_VLAN;
2867 tmp->fltr_info.fltr_act = ICE_FWD_TO_VSI;
2868 tmp->fltr_info.flag = ICE_FLTR_TX;
2869 tmp->fltr_info.src = vsi->vsi_num;
2870 tmp->fltr_info.fwd_id.vsi_id = vsi->vsi_num;
2871 tmp->fltr_info.l_data.vlan.vlan_id = vid;
2872
2873 INIT_LIST_HEAD(&tmp->list_entry);
2874 list_add(&tmp->list_entry, &tmp_add_list);
2875
2876 status = ice_add_vlan(&pf->hw, &tmp_add_list);
2877 if (status) {
2878 err = -ENODEV;
2879 dev_err(&pf->pdev->dev, "Failure Adding VLAN %d on VSI %i\n",
2880 vid, vsi->vsi_num);
2881 }
2882
2883 ice_free_fltr_list(&pf->pdev->dev, &tmp_add_list);
2884 return err;
2885}
2886
2887/**
2888 * ice_vlan_rx_add_vid - Add a vlan id filter to HW offload
2889 * @netdev: network interface to be adjusted
2890 * @proto: unused protocol
2891 * @vid: vlan id to be added
2892 *
2893 * net_device_ops implementation for adding vlan ids
2894 */
2895static int ice_vlan_rx_add_vid(struct net_device *netdev,
2896 __always_unused __be16 proto, u16 vid)
2897{
2898 struct ice_netdev_priv *np = netdev_priv(netdev);
2899 struct ice_vsi *vsi = np->vsi;
2900 int ret = 0;
2901
2902 if (vid >= VLAN_N_VID) {
2903 netdev_err(netdev, "VLAN id requested %d is out of range %d\n",
2904 vid, VLAN_N_VID);
2905 return -EINVAL;
2906 }
2907
2908 if (vsi->info.pvid)
2909 return -EINVAL;
2910
2911 /* Add all VLAN ids including 0 to the switch filter. VLAN id 0 is
2912 * needed to continue allowing all untagged packets since VLAN prune
2913 * list is applied to all packets by the switch
2914 */
2915 ret = ice_vsi_add_vlan(vsi, vid);
2916
2917 if (!ret)
2918 set_bit(vid, vsi->active_vlans);
2919
2920 return ret;
2921}
2922
2923/**
2924 * ice_vsi_kill_vlan - Remove VSI membership for a given VLAN
2925 * @vsi: the VSI being configured
2926 * @vid: VLAN id to be removed
2927 */
2928static void ice_vsi_kill_vlan(struct ice_vsi *vsi, u16 vid)
2929{
2930 struct ice_fltr_list_entry *list;
2931 struct ice_pf *pf = vsi->back;
2932 LIST_HEAD(tmp_add_list);
2933
2934 list = devm_kzalloc(&pf->pdev->dev, sizeof(*list), GFP_KERNEL);
2935 if (!list)
2936 return;
2937
2938 list->fltr_info.lkup_type = ICE_SW_LKUP_VLAN;
2939 list->fltr_info.fwd_id.vsi_id = vsi->vsi_num;
2940 list->fltr_info.fltr_act = ICE_FWD_TO_VSI;
2941 list->fltr_info.l_data.vlan.vlan_id = vid;
2942 list->fltr_info.flag = ICE_FLTR_TX;
2943 list->fltr_info.src = vsi->vsi_num;
2944
2945 INIT_LIST_HEAD(&list->list_entry);
2946 list_add(&list->list_entry, &tmp_add_list);
2947
2948 if (ice_remove_vlan(&pf->hw, &tmp_add_list))
2949 dev_err(&pf->pdev->dev, "Error removing VLAN %d on vsi %i\n",
2950 vid, vsi->vsi_num);
2951
2952 ice_free_fltr_list(&pf->pdev->dev, &tmp_add_list);
2953}
2954
2955/**
2956 * ice_vlan_rx_kill_vid - Remove a vlan id filter from HW offload
2957 * @netdev: network interface to be adjusted
2958 * @proto: unused protocol
2959 * @vid: vlan id to be removed
2960 *
2961 * net_device_ops implementation for removing vlan ids
2962 */
2963static int ice_vlan_rx_kill_vid(struct net_device *netdev,
2964 __always_unused __be16 proto, u16 vid)
2965{
2966 struct ice_netdev_priv *np = netdev_priv(netdev);
2967 struct ice_vsi *vsi = np->vsi;
2968
2969 if (vsi->info.pvid)
2970 return -EINVAL;
2971
2972 /* return code is ignored as there is nothing a user
2973 * can do about failure to remove and a log message was
2974 * already printed from the other function
2975 */
2976 ice_vsi_kill_vlan(vsi, vid);
2977
2978 clear_bit(vid, vsi->active_vlans);
2979
2980 return 0;
2981}
2982
2983/**
2984 * ice_setup_pf_sw - Setup the HW switch on startup or after reset
2985 * @pf: board private structure
2986 *
2987 * Returns 0 on success, negative value on failure
2988 */
2989static int ice_setup_pf_sw(struct ice_pf *pf)
2990{
2991 LIST_HEAD(tmp_add_list);
2992 u8 broadcast[ETH_ALEN];
2993 struct ice_vsi *vsi;
2994 int status = 0;
2995
2996 if (!ice_is_reset_recovery_pending(pf->state)) {
2997 vsi = ice_vsi_setup(pf, ICE_VSI_PF, pf->hw.port_info);
2998 if (!vsi) {
2999 status = -ENOMEM;
3000 goto error_exit;
3001 }
3002 } else {
3003 vsi = pf->vsi[0];
3004 status = ice_vsi_reinit_setup(vsi);
3005 if (status < 0)
3006 return -EIO;
3007 }
3008
3009 /* tmp_add_list contains a list of MAC addresses for which MAC
3010 * filters need to be programmed. Add the VSI's unicast MAC to
3011 * this list
3012 */
3013 status = ice_add_mac_to_list(vsi, &tmp_add_list,
3014 vsi->port_info->mac.perm_addr);
3015 if (status)
3016 goto error_exit;
3017
3018 /* VSI needs to receive broadcast traffic, so add the broadcast
3019 * MAC address to the list.
3020 */
3021 eth_broadcast_addr(broadcast);
3022 status = ice_add_mac_to_list(vsi, &tmp_add_list, broadcast);
3023 if (status)
3024 goto error_exit;
3025
3026 /* program MAC filters for entries in tmp_add_list */
3027 status = ice_add_mac(&pf->hw, &tmp_add_list);
3028 if (status) {
3029 dev_err(&pf->pdev->dev, "Could not add MAC filters\n");
3030 status = -ENOMEM;
3031 goto error_exit;
3032 }
3033
3034 ice_free_fltr_list(&pf->pdev->dev, &tmp_add_list);
3035 return status;
3036
3037error_exit:
3038 ice_free_fltr_list(&pf->pdev->dev, &tmp_add_list);
3039
3040 if (vsi) {
3041 ice_vsi_free_q_vectors(vsi);
3042 if (vsi->netdev && vsi->netdev->reg_state == NETREG_REGISTERED)
3043 unregister_netdev(vsi->netdev);
3044 if (vsi->netdev) {
3045 free_netdev(vsi->netdev);
3046 vsi->netdev = NULL;
3047 }
3048
3049 ice_vsi_delete(vsi);
3050 ice_vsi_put_qs(vsi);
3051 pf->q_left_tx += vsi->alloc_txq;
3052 pf->q_left_rx += vsi->alloc_rxq;
3053 ice_vsi_clear(vsi);
3054 }
3055 return status;
3056}
3057
3058/**
3059 * ice_determine_q_usage - Calculate queue distribution
3060 * @pf: board private structure
3061 *
3062 * Return -ENOMEM if we don't get enough queues for all ports
3063 */
3064static void ice_determine_q_usage(struct ice_pf *pf)
3065{
3066 u16 q_left_tx, q_left_rx;
3067
3068 q_left_tx = pf->hw.func_caps.common_cap.num_txq;
3069 q_left_rx = pf->hw.func_caps.common_cap.num_rxq;
3070
3071 pf->num_lan_tx = min_t(int, q_left_tx, num_online_cpus());
3072
3073 /* only 1 rx queue unless RSS is enabled */
3074 if (!test_bit(ICE_FLAG_RSS_ENA, pf->flags))
3075 pf->num_lan_rx = 1;
3076 else
3077 pf->num_lan_rx = min_t(int, q_left_rx, num_online_cpus());
3078
3079 pf->q_left_tx = q_left_tx - pf->num_lan_tx;
3080 pf->q_left_rx = q_left_rx - pf->num_lan_rx;
3081}
3082
3083/**
3084 * ice_deinit_pf - Unrolls initialziations done by ice_init_pf
3085 * @pf: board private structure to initialize
3086 */
3087static void ice_deinit_pf(struct ice_pf *pf)
3088{
3089 if (pf->serv_tmr.function)
3090 del_timer_sync(&pf->serv_tmr);
3091 if (pf->serv_task.func)
3092 cancel_work_sync(&pf->serv_task);
3093 mutex_destroy(&pf->sw_mutex);
3094 mutex_destroy(&pf->avail_q_mutex);
3095}
3096
3097/**
3098 * ice_init_pf - Initialize general software structures (struct ice_pf)
3099 * @pf: board private structure to initialize
3100 */
3101static void ice_init_pf(struct ice_pf *pf)
3102{
3103 bitmap_zero(pf->flags, ICE_PF_FLAGS_NBITS);
3104 set_bit(ICE_FLAG_MSIX_ENA, pf->flags);
3105
3106 mutex_init(&pf->sw_mutex);
3107 mutex_init(&pf->avail_q_mutex);
3108
3109 /* Clear avail_[t|r]x_qs bitmaps (set all to avail) */
3110 mutex_lock(&pf->avail_q_mutex);
3111 bitmap_zero(pf->avail_txqs, ICE_MAX_TXQS);
3112 bitmap_zero(pf->avail_rxqs, ICE_MAX_RXQS);
3113 mutex_unlock(&pf->avail_q_mutex);
3114
3115 if (pf->hw.func_caps.common_cap.rss_table_size)
3116 set_bit(ICE_FLAG_RSS_ENA, pf->flags);
3117
3118 /* setup service timer and periodic service task */
3119 timer_setup(&pf->serv_tmr, ice_service_timer, 0);
3120 pf->serv_tmr_period = HZ;
3121 INIT_WORK(&pf->serv_task, ice_service_task);
3122 clear_bit(__ICE_SERVICE_SCHED, pf->state);
3123}
3124
3125/**
3126 * ice_ena_msix_range - Request a range of MSIX vectors from the OS
3127 * @pf: board private structure
3128 *
3129 * compute the number of MSIX vectors required (v_budget) and request from
3130 * the OS. Return the number of vectors reserved or negative on failure
3131 */
3132static int ice_ena_msix_range(struct ice_pf *pf)
3133{
3134 int v_left, v_actual, v_budget = 0;
3135 int needed, err, i;
3136
3137 v_left = pf->hw.func_caps.common_cap.num_msix_vectors;
3138
3139 /* reserve one vector for miscellaneous handler */
3140 needed = 1;
3141 v_budget += needed;
3142 v_left -= needed;
3143
3144 /* reserve vectors for LAN traffic */
3145 pf->num_lan_msix = min_t(int, num_online_cpus(), v_left);
3146 v_budget += pf->num_lan_msix;
3147
3148 pf->msix_entries = devm_kcalloc(&pf->pdev->dev, v_budget,
3149 sizeof(struct msix_entry), GFP_KERNEL);
3150
3151 if (!pf->msix_entries) {
3152 err = -ENOMEM;
3153 goto exit_err;
3154 }
3155
3156 for (i = 0; i < v_budget; i++)
3157 pf->msix_entries[i].entry = i;
3158
3159 /* actually reserve the vectors */
3160 v_actual = pci_enable_msix_range(pf->pdev, pf->msix_entries,
3161 ICE_MIN_MSIX, v_budget);
3162
3163 if (v_actual < 0) {
3164 dev_err(&pf->pdev->dev, "unable to reserve MSI-X vectors\n");
3165 err = v_actual;
3166 goto msix_err;
3167 }
3168
3169 if (v_actual < v_budget) {
3170 dev_warn(&pf->pdev->dev,
3171 "not enough vectors. requested = %d, obtained = %d\n",
3172 v_budget, v_actual);
3173 if (v_actual >= (pf->num_lan_msix + 1)) {
3174 pf->num_avail_msix = v_actual - (pf->num_lan_msix + 1);
3175 } else if (v_actual >= 2) {
3176 pf->num_lan_msix = 1;
3177 pf->num_avail_msix = v_actual - 2;
3178 } else {
3179 pci_disable_msix(pf->pdev);
3180 err = -ERANGE;
3181 goto msix_err;
3182 }
3183 }
3184
3185 return v_actual;
3186
3187msix_err:
3188 devm_kfree(&pf->pdev->dev, pf->msix_entries);
3189 goto exit_err;
3190
3191exit_err:
3192 pf->num_lan_msix = 0;
3193 clear_bit(ICE_FLAG_MSIX_ENA, pf->flags);
3194 return err;
3195}
3196
3197/**
3198 * ice_dis_msix - Disable MSI-X interrupt setup in OS
3199 * @pf: board private structure
3200 */
3201static void ice_dis_msix(struct ice_pf *pf)
3202{
3203 pci_disable_msix(pf->pdev);
3204 devm_kfree(&pf->pdev->dev, pf->msix_entries);
3205 pf->msix_entries = NULL;
3206 clear_bit(ICE_FLAG_MSIX_ENA, pf->flags);
3207}
3208
3209/**
3210 * ice_init_interrupt_scheme - Determine proper interrupt scheme
3211 * @pf: board private structure to initialize
3212 */
3213static int ice_init_interrupt_scheme(struct ice_pf *pf)
3214{
3215 int vectors = 0;
3216 ssize_t size;
3217
3218 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags))
3219 vectors = ice_ena_msix_range(pf);
3220 else
3221 return -ENODEV;
3222
3223 if (vectors < 0)
3224 return vectors;
3225
3226 /* set up vector assignment tracking */
3227 size = sizeof(struct ice_res_tracker) + (sizeof(u16) * vectors);
3228
3229 pf->irq_tracker = devm_kzalloc(&pf->pdev->dev, size, GFP_KERNEL);
3230 if (!pf->irq_tracker) {
3231 ice_dis_msix(pf);
3232 return -ENOMEM;
3233 }
3234
3235 pf->irq_tracker->num_entries = vectors;
3236
3237 return 0;
3238}
3239
3240/**
3241 * ice_clear_interrupt_scheme - Undo things done by ice_init_interrupt_scheme
3242 * @pf: board private structure
3243 */
3244static void ice_clear_interrupt_scheme(struct ice_pf *pf)
3245{
3246 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags))
3247 ice_dis_msix(pf);
3248
3249 devm_kfree(&pf->pdev->dev, pf->irq_tracker);
3250 pf->irq_tracker = NULL;
3251}
3252
3253/**
3254 * ice_probe - Device initialization routine
3255 * @pdev: PCI device information struct
3256 * @ent: entry in ice_pci_tbl
3257 *
3258 * Returns 0 on success, negative on failure
3259 */
3260static int ice_probe(struct pci_dev *pdev,
3261 const struct pci_device_id __always_unused *ent)
3262{
3263 struct ice_pf *pf;
3264 struct ice_hw *hw;
3265 int err;
3266
3267 /* this driver uses devres, see Documentation/driver-model/devres.txt */
3268 err = pcim_enable_device(pdev);
3269 if (err)
3270 return err;
3271
3272 err = pcim_iomap_regions(pdev, BIT(ICE_BAR0), pci_name(pdev));
3273 if (err) {
3274 dev_err(&pdev->dev, "I/O map error %d\n", err);
3275 return err;
3276 }
3277
3278 pf = devm_kzalloc(&pdev->dev, sizeof(*pf), GFP_KERNEL);
3279 if (!pf)
3280 return -ENOMEM;
3281
3282 /* set up for high or low dma */
3283 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
3284 if (err)
3285 err = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
3286 if (err) {
3287 dev_err(&pdev->dev, "DMA configuration failed: 0x%x\n", err);
3288 return err;
3289 }
3290
3291 pci_enable_pcie_error_reporting(pdev);
3292 pci_set_master(pdev);
3293
3294 pf->pdev = pdev;
3295 pci_set_drvdata(pdev, pf);
3296 set_bit(__ICE_DOWN, pf->state);
3297
3298 hw = &pf->hw;
3299 hw->hw_addr = pcim_iomap_table(pdev)[ICE_BAR0];
3300 hw->back = pf;
3301 hw->vendor_id = pdev->vendor;
3302 hw->device_id = pdev->device;
3303 pci_read_config_byte(pdev, PCI_REVISION_ID, &hw->revision_id);
3304 hw->subsystem_vendor_id = pdev->subsystem_vendor;
3305 hw->subsystem_device_id = pdev->subsystem_device;
3306 hw->bus.device = PCI_SLOT(pdev->devfn);
3307 hw->bus.func = PCI_FUNC(pdev->devfn);
3308 ice_set_ctrlq_len(hw);
3309
3310 pf->msg_enable = netif_msg_init(debug, ICE_DFLT_NETIF_M);
3311
3312#ifndef CONFIG_DYNAMIC_DEBUG
3313 if (debug < -1)
3314 hw->debug_mask = debug;
3315#endif
3316
3317 err = ice_init_hw(hw);
3318 if (err) {
3319 dev_err(&pdev->dev, "ice_init_hw failed: %d\n", err);
3320 err = -EIO;
3321 goto err_exit_unroll;
3322 }
3323
3324 dev_info(&pdev->dev, "firmware %d.%d.%05d api %d.%d\n",
3325 hw->fw_maj_ver, hw->fw_min_ver, hw->fw_build,
3326 hw->api_maj_ver, hw->api_min_ver);
3327
3328 ice_init_pf(pf);
3329
3330 ice_determine_q_usage(pf);
3331
3332 pf->num_alloc_vsi = min_t(u16, ICE_MAX_VSI_ALLOC,
3333 hw->func_caps.guaranteed_num_vsi);
3334 if (!pf->num_alloc_vsi) {
3335 err = -EIO;
3336 goto err_init_pf_unroll;
3337 }
3338
3339 pf->vsi = devm_kcalloc(&pdev->dev, pf->num_alloc_vsi,
3340 sizeof(struct ice_vsi *), GFP_KERNEL);
3341 if (!pf->vsi) {
3342 err = -ENOMEM;
3343 goto err_init_pf_unroll;
3344 }
3345
3346 err = ice_init_interrupt_scheme(pf);
3347 if (err) {
3348 dev_err(&pdev->dev,
3349 "ice_init_interrupt_scheme failed: %d\n", err);
3350 err = -EIO;
3351 goto err_init_interrupt_unroll;
3352 }
3353
3354 /* In case of MSIX we are going to setup the misc vector right here
3355 * to handle admin queue events etc. In case of legacy and MSI
3356 * the misc functionality and queue processing is combined in
3357 * the same vector and that gets setup at open.
3358 */
3359 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags)) {
3360 err = ice_req_irq_msix_misc(pf);
3361 if (err) {
3362 dev_err(&pdev->dev,
3363 "setup of misc vector failed: %d\n", err);
3364 goto err_init_interrupt_unroll;
3365 }
3366 }
3367
3368 /* create switch struct for the switch element created by FW on boot */
3369 pf->first_sw = devm_kzalloc(&pdev->dev, sizeof(struct ice_sw),
3370 GFP_KERNEL);
3371 if (!pf->first_sw) {
3372 err = -ENOMEM;
3373 goto err_msix_misc_unroll;
3374 }
3375
3376 pf->first_sw->bridge_mode = BRIDGE_MODE_VEB;
3377 pf->first_sw->pf = pf;
3378
3379 /* record the sw_id available for later use */
3380 pf->first_sw->sw_id = hw->port_info->sw_id;
3381
3382 err = ice_setup_pf_sw(pf);
3383 if (err) {
3384 dev_err(&pdev->dev,
3385 "probe failed due to setup pf switch:%d\n", err);
3386 goto err_alloc_sw_unroll;
3387 }
3388
3389 /* Driver is mostly up */
3390 clear_bit(__ICE_DOWN, pf->state);
3391
3392 /* since everything is good, start the service timer */
3393 mod_timer(&pf->serv_tmr, round_jiffies(jiffies + pf->serv_tmr_period));
3394
3395 err = ice_init_link_events(pf->hw.port_info);
3396 if (err) {
3397 dev_err(&pdev->dev, "ice_init_link_events failed: %d\n", err);
3398 goto err_alloc_sw_unroll;
3399 }
3400
3401 return 0;
3402
3403err_alloc_sw_unroll:
3404 set_bit(__ICE_DOWN, pf->state);
3405 devm_kfree(&pf->pdev->dev, pf->first_sw);
3406err_msix_misc_unroll:
3407 ice_free_irq_msix_misc(pf);
3408err_init_interrupt_unroll:
3409 ice_clear_interrupt_scheme(pf);
3410 devm_kfree(&pdev->dev, pf->vsi);
3411err_init_pf_unroll:
3412 ice_deinit_pf(pf);
3413 ice_deinit_hw(hw);
3414err_exit_unroll:
3415 pci_disable_pcie_error_reporting(pdev);
3416 return err;
3417}
3418
3419/**
3420 * ice_remove - Device removal routine
3421 * @pdev: PCI device information struct
3422 */
3423static void ice_remove(struct pci_dev *pdev)
3424{
3425 struct ice_pf *pf = pci_get_drvdata(pdev);
3426 int i = 0;
3427 int err;
3428
3429 if (!pf)
3430 return;
3431
3432 set_bit(__ICE_DOWN, pf->state);
3433
3434 for (i = 0; i < pf->num_alloc_vsi; i++) {
3435 if (!pf->vsi[i])
3436 continue;
3437
3438 err = ice_vsi_release(pf->vsi[i]);
3439 if (err)
3440 dev_dbg(&pf->pdev->dev, "Failed to release VSI index %d (err %d)\n",
3441 i, err);
3442 }
3443
3444 ice_free_irq_msix_misc(pf);
3445 ice_clear_interrupt_scheme(pf);
3446 ice_deinit_pf(pf);
3447 ice_deinit_hw(&pf->hw);
3448 pci_disable_pcie_error_reporting(pdev);
3449}
3450
3451/* ice_pci_tbl - PCI Device ID Table
3452 *
3453 * Wildcard entries (PCI_ANY_ID) should come last
3454 * Last entry must be all 0s
3455 *
3456 * { Vendor ID, Device ID, SubVendor ID, SubDevice ID,
3457 * Class, Class Mask, private data (not used) }
3458 */
3459static const struct pci_device_id ice_pci_tbl[] = {
3460 { PCI_VDEVICE(INTEL, ICE_DEV_ID_C810_BACKPLANE), 0 },
3461 { PCI_VDEVICE(INTEL, ICE_DEV_ID_C810_QSFP), 0 },
3462 { PCI_VDEVICE(INTEL, ICE_DEV_ID_C810_SFP), 0 },
3463 { PCI_VDEVICE(INTEL, ICE_DEV_ID_C810_10G_BASE_T), 0 },
3464 { PCI_VDEVICE(INTEL, ICE_DEV_ID_C810_SGMII), 0 },
3465 /* required last entry */
3466 { 0, }
3467};
3468MODULE_DEVICE_TABLE(pci, ice_pci_tbl);
3469
3470static struct pci_driver ice_driver = {
3471 .name = KBUILD_MODNAME,
3472 .id_table = ice_pci_tbl,
3473 .probe = ice_probe,
3474 .remove = ice_remove,
3475};
3476
3477/**
3478 * ice_module_init - Driver registration routine
3479 *
3480 * ice_module_init is the first routine called when the driver is
3481 * loaded. All it does is register with the PCI subsystem.
3482 */
3483static int __init ice_module_init(void)
3484{
3485 int status;
3486
3487 pr_info("%s - version %s\n", ice_driver_string, ice_drv_ver);
3488 pr_info("%s\n", ice_copyright);
3489
3490 ice_wq = alloc_ordered_workqueue("%s", WQ_MEM_RECLAIM, KBUILD_MODNAME);
3491 if (!ice_wq) {
3492 pr_err("Failed to create workqueue\n");
3493 return -ENOMEM;
3494 }
3495
3496 status = pci_register_driver(&ice_driver);
3497 if (status) {
3498 pr_err("failed to register pci driver, err %d\n", status);
3499 destroy_workqueue(ice_wq);
3500 }
3501
3502 return status;
3503}
3504module_init(ice_module_init);
3505
3506/**
3507 * ice_module_exit - Driver exit cleanup routine
3508 *
3509 * ice_module_exit is called just before the driver is removed
3510 * from memory.
3511 */
3512static void __exit ice_module_exit(void)
3513{
3514 pci_unregister_driver(&ice_driver);
3515 destroy_workqueue(ice_wq);
3516 pr_info("module unloaded\n");
3517}
3518module_exit(ice_module_exit);
3519
3520/**
3521 * ice_set_mac_address - NDO callback to set mac address
3522 * @netdev: network interface device structure
3523 * @pi: pointer to an address structure
3524 *
3525 * Returns 0 on success, negative on failure
3526 */
3527static int ice_set_mac_address(struct net_device *netdev, void *pi)
3528{
3529 struct ice_netdev_priv *np = netdev_priv(netdev);
3530 struct ice_vsi *vsi = np->vsi;
3531 struct ice_pf *pf = vsi->back;
3532 struct ice_hw *hw = &pf->hw;
3533 struct sockaddr *addr = pi;
3534 enum ice_status status;
3535 LIST_HEAD(a_mac_list);
3536 LIST_HEAD(r_mac_list);
3537 u8 flags = 0;
3538 int err;
3539 u8 *mac;
3540
3541 mac = (u8 *)addr->sa_data;
3542
3543 if (!is_valid_ether_addr(mac))
3544 return -EADDRNOTAVAIL;
3545
3546 if (ether_addr_equal(netdev->dev_addr, mac)) {
3547 netdev_warn(netdev, "already using mac %pM\n", mac);
3548 return 0;
3549 }
3550
3551 if (test_bit(__ICE_DOWN, pf->state) ||
3552 ice_is_reset_recovery_pending(pf->state)) {
3553 netdev_err(netdev, "can't set mac %pM. device not ready\n",
3554 mac);
3555 return -EBUSY;
3556 }
3557
3558 /* When we change the mac address we also have to change the mac address
3559 * based filter rules that were created previously for the old mac
3560 * address. So first, we remove the old filter rule using ice_remove_mac
3561 * and then create a new filter rule using ice_add_mac. Note that for
3562 * both these operations, we first need to form a "list" of mac
3563 * addresses (even though in this case, we have only 1 mac address to be
3564 * added/removed) and this done using ice_add_mac_to_list. Depending on
3565 * the ensuing operation this "list" of mac addresses is either to be
3566 * added or removed from the filter.
3567 */
3568 err = ice_add_mac_to_list(vsi, &r_mac_list, netdev->dev_addr);
3569 if (err) {
3570 err = -EADDRNOTAVAIL;
3571 goto free_lists;
3572 }
3573
3574 status = ice_remove_mac(hw, &r_mac_list);
3575 if (status) {
3576 err = -EADDRNOTAVAIL;
3577 goto free_lists;
3578 }
3579
3580 err = ice_add_mac_to_list(vsi, &a_mac_list, mac);
3581 if (err) {
3582 err = -EADDRNOTAVAIL;
3583 goto free_lists;
3584 }
3585
3586 status = ice_add_mac(hw, &a_mac_list);
3587 if (status) {
3588 err = -EADDRNOTAVAIL;
3589 goto free_lists;
3590 }
3591
3592free_lists:
3593 /* free list entries */
3594 ice_free_fltr_list(&pf->pdev->dev, &r_mac_list);
3595 ice_free_fltr_list(&pf->pdev->dev, &a_mac_list);
3596
3597 if (err) {
3598 netdev_err(netdev, "can't set mac %pM. filter update failed\n",
3599 mac);
3600 return err;
3601 }
3602
3603 /* change the netdev's mac address */
3604 memcpy(netdev->dev_addr, mac, netdev->addr_len);
3605 netdev_dbg(vsi->netdev, "updated mac address to %pM\n",
3606 netdev->dev_addr);
3607
3608 /* write new mac address to the firmware */
3609 flags = ICE_AQC_MAN_MAC_UPDATE_LAA_WOL;
3610 status = ice_aq_manage_mac_write(hw, mac, flags, NULL);
3611 if (status) {
3612 netdev_err(netdev, "can't set mac %pM. write to firmware failed.\n",
3613 mac);
3614 }
3615 return 0;
3616}
3617
3618/**
3619 * ice_set_rx_mode - NDO callback to set the netdev filters
3620 * @netdev: network interface device structure
3621 */
3622static void ice_set_rx_mode(struct net_device *netdev)
3623{
3624 struct ice_netdev_priv *np = netdev_priv(netdev);
3625 struct ice_vsi *vsi = np->vsi;
3626
3627 if (!vsi)
3628 return;
3629
3630 /* Set the flags to synchronize filters
3631 * ndo_set_rx_mode may be triggered even without a change in netdev
3632 * flags
3633 */
3634 set_bit(ICE_VSI_FLAG_UMAC_FLTR_CHANGED, vsi->flags);
3635 set_bit(ICE_VSI_FLAG_MMAC_FLTR_CHANGED, vsi->flags);
3636 set_bit(ICE_FLAG_FLTR_SYNC, vsi->back->flags);
3637
3638 /* schedule our worker thread which will take care of
3639 * applying the new filter changes
3640 */
3641 ice_service_task_schedule(vsi->back);
3642}
3643
3644/**
3645 * ice_fdb_add - add an entry to the hardware database
3646 * @ndm: the input from the stack
3647 * @tb: pointer to array of nladdr (unused)
3648 * @dev: the net device pointer
3649 * @addr: the MAC address entry being added
3650 * @vid: VLAN id
3651 * @flags: instructions from stack about fdb operation
3652 */
3653static int ice_fdb_add(struct ndmsg *ndm, struct nlattr __always_unused *tb[],
3654 struct net_device *dev, const unsigned char *addr,
3655 u16 vid, u16 flags)
3656{
3657 int err;
3658
3659 if (vid) {
3660 netdev_err(dev, "VLANs aren't supported yet for dev_uc|mc_add()\n");
3661 return -EINVAL;
3662 }
3663 if (ndm->ndm_state && !(ndm->ndm_state & NUD_PERMANENT)) {
3664 netdev_err(dev, "FDB only supports static addresses\n");
3665 return -EINVAL;
3666 }
3667
3668 if (is_unicast_ether_addr(addr) || is_link_local_ether_addr(addr))
3669 err = dev_uc_add_excl(dev, addr);
3670 else if (is_multicast_ether_addr(addr))
3671 err = dev_mc_add_excl(dev, addr);
3672 else
3673 err = -EINVAL;
3674
3675 /* Only return duplicate errors if NLM_F_EXCL is set */
3676 if (err == -EEXIST && !(flags & NLM_F_EXCL))
3677 err = 0;
3678
3679 return err;
3680}
3681
3682/**
3683 * ice_fdb_del - delete an entry from the hardware database
3684 * @ndm: the input from the stack
3685 * @tb: pointer to array of nladdr (unused)
3686 * @dev: the net device pointer
3687 * @addr: the MAC address entry being added
3688 * @vid: VLAN id
3689 */
3690static int ice_fdb_del(struct ndmsg *ndm, __always_unused struct nlattr *tb[],
3691 struct net_device *dev, const unsigned char *addr,
3692 __always_unused u16 vid)
3693{
3694 int err;
3695
3696 if (ndm->ndm_state & NUD_PERMANENT) {
3697 netdev_err(dev, "FDB only supports static addresses\n");
3698 return -EINVAL;
3699 }
3700
3701 if (is_unicast_ether_addr(addr))
3702 err = dev_uc_del(dev, addr);
3703 else if (is_multicast_ether_addr(addr))
3704 err = dev_mc_del(dev, addr);
3705 else
3706 err = -EINVAL;
3707
3708 return err;
3709}
3710
3711/**
3712 * ice_vsi_manage_vlan_insertion - Manage VLAN insertion for the VSI for Tx
3713 * @vsi: the vsi being changed
3714 */
3715static int ice_vsi_manage_vlan_insertion(struct ice_vsi *vsi)
3716{
3717 struct device *dev = &vsi->back->pdev->dev;
3718 struct ice_hw *hw = &vsi->back->hw;
3719 struct ice_vsi_ctx ctxt = { 0 };
3720 enum ice_status status;
3721
3722 /* Here we are configuring the VSI to let the driver add VLAN tags by
3723 * setting port_vlan_flags to ICE_AQ_VSI_PVLAN_MODE_ALL. The actual VLAN
3724 * tag insertion happens in the Tx hot path, in ice_tx_map.
3725 */
3726 ctxt.info.port_vlan_flags = ICE_AQ_VSI_PVLAN_MODE_ALL;
3727
3728 ctxt.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);
3729 ctxt.vsi_num = vsi->vsi_num;
3730
3731 status = ice_aq_update_vsi(hw, &ctxt, NULL);
3732 if (status) {
3733 dev_err(dev, "update VSI for VLAN insert failed, err %d aq_err %d\n",
3734 status, hw->adminq.sq_last_status);
3735 return -EIO;
3736 }
3737
3738 vsi->info.port_vlan_flags = ctxt.info.port_vlan_flags;
3739 return 0;
3740}
3741
3742/**
3743 * ice_vsi_manage_vlan_stripping - Manage VLAN stripping for the VSI for Rx
3744 * @vsi: the vsi being changed
3745 * @ena: boolean value indicating if this is a enable or disable request
3746 */
3747static int ice_vsi_manage_vlan_stripping(struct ice_vsi *vsi, bool ena)
3748{
3749 struct device *dev = &vsi->back->pdev->dev;
3750 struct ice_hw *hw = &vsi->back->hw;
3751 struct ice_vsi_ctx ctxt = { 0 };
3752 enum ice_status status;
3753
3754 /* Here we are configuring what the VSI should do with the VLAN tag in
3755 * the Rx packet. We can either leave the tag in the packet or put it in
3756 * the Rx descriptor.
3757 */
3758 if (ena) {
3759 /* Strip VLAN tag from Rx packet and put it in the desc */
3760 ctxt.info.port_vlan_flags = ICE_AQ_VSI_PVLAN_EMOD_STR_BOTH;
3761 } else {
3762 /* Disable stripping. Leave tag in packet */
3763 ctxt.info.port_vlan_flags = ICE_AQ_VSI_PVLAN_EMOD_NOTHING;
3764 }
3765
3766 ctxt.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);
3767 ctxt.vsi_num = vsi->vsi_num;
3768
3769 status = ice_aq_update_vsi(hw, &ctxt, NULL);
3770 if (status) {
3771 dev_err(dev, "update VSI for VALN strip failed, ena = %d err %d aq_err %d\n",
3772 ena, status, hw->adminq.sq_last_status);
3773 return -EIO;
3774 }
3775
3776 vsi->info.port_vlan_flags = ctxt.info.port_vlan_flags;
3777 return 0;
3778}
3779
3780/**
3781 * ice_set_features - set the netdev feature flags
3782 * @netdev: ptr to the netdev being adjusted
3783 * @features: the feature set that the stack is suggesting
3784 */
3785static int ice_set_features(struct net_device *netdev,
3786 netdev_features_t features)
3787{
3788 struct ice_netdev_priv *np = netdev_priv(netdev);
3789 struct ice_vsi *vsi = np->vsi;
3790 int ret = 0;
3791
3792 if ((features & NETIF_F_HW_VLAN_CTAG_RX) &&
3793 !(netdev->features & NETIF_F_HW_VLAN_CTAG_RX))
3794 ret = ice_vsi_manage_vlan_stripping(vsi, true);
3795 else if (!(features & NETIF_F_HW_VLAN_CTAG_RX) &&
3796 (netdev->features & NETIF_F_HW_VLAN_CTAG_RX))
3797 ret = ice_vsi_manage_vlan_stripping(vsi, false);
3798 else if ((features & NETIF_F_HW_VLAN_CTAG_TX) &&
3799 !(netdev->features & NETIF_F_HW_VLAN_CTAG_TX))
3800 ret = ice_vsi_manage_vlan_insertion(vsi);
3801 else if (!(features & NETIF_F_HW_VLAN_CTAG_TX) &&
3802 (netdev->features & NETIF_F_HW_VLAN_CTAG_TX))
3803 ret = ice_vsi_manage_vlan_insertion(vsi);
3804
3805 return ret;
3806}
3807
3808/**
3809 * ice_vsi_vlan_setup - Setup vlan offload properties on a VSI
3810 * @vsi: VSI to setup vlan properties for
3811 */
3812static int ice_vsi_vlan_setup(struct ice_vsi *vsi)
3813{
3814 int ret = 0;
3815
3816 if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_RX)
3817 ret = ice_vsi_manage_vlan_stripping(vsi, true);
3818 if (vsi->netdev->features & NETIF_F_HW_VLAN_CTAG_TX)
3819 ret = ice_vsi_manage_vlan_insertion(vsi);
3820
3821 return ret;
3822}
3823
3824/**
3825 * ice_restore_vlan - Reinstate VLANs when vsi/netdev comes back up
3826 * @vsi: the VSI being brought back up
3827 */
3828static int ice_restore_vlan(struct ice_vsi *vsi)
3829{
3830 int err;
3831 u16 vid;
3832
3833 if (!vsi->netdev)
3834 return -EINVAL;
3835
3836 err = ice_vsi_vlan_setup(vsi);
3837 if (err)
3838 return err;
3839
3840 for_each_set_bit(vid, vsi->active_vlans, VLAN_N_VID) {
3841 err = ice_vlan_rx_add_vid(vsi->netdev, htons(ETH_P_8021Q), vid);
3842 if (err)
3843 break;
3844 }
3845
3846 return err;
3847}
3848
3849/**
3850 * ice_setup_tx_ctx - setup a struct ice_tlan_ctx instance
3851 * @ring: The Tx ring to configure
3852 * @tlan_ctx: Pointer to the Tx LAN queue context structure to be initialized
3853 * @pf_q: queue index in the PF space
3854 *
3855 * Configure the Tx descriptor ring in TLAN context.
3856 */
3857static void
3858ice_setup_tx_ctx(struct ice_ring *ring, struct ice_tlan_ctx *tlan_ctx, u16 pf_q)
3859{
3860 struct ice_vsi *vsi = ring->vsi;
3861 struct ice_hw *hw = &vsi->back->hw;
3862
3863 tlan_ctx->base = ring->dma >> ICE_TLAN_CTX_BASE_S;
3864
3865 tlan_ctx->port_num = vsi->port_info->lport;
3866
3867 /* Transmit Queue Length */
3868 tlan_ctx->qlen = ring->count;
3869
3870 /* PF number */
3871 tlan_ctx->pf_num = hw->pf_id;
3872
3873 /* queue belongs to a specific VSI type
3874 * VF / VM index should be programmed per vmvf_type setting:
3875 * for vmvf_type = VF, it is VF number between 0-256
3876 * for vmvf_type = VM, it is VM number between 0-767
3877 * for PF or EMP this field should be set to zero
3878 */
3879 switch (vsi->type) {
3880 case ICE_VSI_PF:
3881 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_PF;
3882 break;
3883 default:
3884 return;
3885 }
3886
3887 /* make sure the context is associated with the right VSI */
3888 tlan_ctx->src_vsi = vsi->vsi_num;
3889
3890 tlan_ctx->tso_ena = ICE_TX_LEGACY;
3891 tlan_ctx->tso_qnum = pf_q;
3892
3893 /* Legacy or Advanced Host Interface:
3894 * 0: Advanced Host Interface
3895 * 1: Legacy Host Interface
3896 */
3897 tlan_ctx->legacy_int = ICE_TX_LEGACY;
3898}
3899
3900/**
3901 * ice_vsi_cfg_txqs - Configure the VSI for Tx
3902 * @vsi: the VSI being configured
3903 *
3904 * Return 0 on success and a negative value on error
3905 * Configure the Tx VSI for operation.
3906 */
3907static int ice_vsi_cfg_txqs(struct ice_vsi *vsi)
3908{
3909 struct ice_aqc_add_tx_qgrp *qg_buf;
3910 struct ice_aqc_add_txqs_perq *txq;
3911 struct ice_pf *pf = vsi->back;
3912 enum ice_status status;
3913 u16 buf_len, i, pf_q;
3914 int err = 0, tc = 0;
3915 u8 num_q_grps;
3916
3917 buf_len = sizeof(struct ice_aqc_add_tx_qgrp);
3918 qg_buf = devm_kzalloc(&pf->pdev->dev, buf_len, GFP_KERNEL);
3919 if (!qg_buf)
3920 return -ENOMEM;
3921
3922 if (vsi->num_txq > ICE_MAX_TXQ_PER_TXQG) {
3923 err = -EINVAL;
3924 goto err_cfg_txqs;
3925 }
3926 qg_buf->num_txqs = 1;
3927 num_q_grps = 1;
3928
3929 /* set up and configure the tx queues */
3930 ice_for_each_txq(vsi, i) {
3931 struct ice_tlan_ctx tlan_ctx = { 0 };
3932
3933 pf_q = vsi->txq_map[i];
3934 ice_setup_tx_ctx(vsi->tx_rings[i], &tlan_ctx, pf_q);
3935 /* copy context contents into the qg_buf */
3936 qg_buf->txqs[0].txq_id = cpu_to_le16(pf_q);
3937 ice_set_ctx((u8 *)&tlan_ctx, qg_buf->txqs[0].txq_ctx,
3938 ice_tlan_ctx_info);
3939
3940 /* init queue specific tail reg. It is referred as transmit
3941 * comm scheduler queue doorbell.
3942 */
3943 vsi->tx_rings[i]->tail = pf->hw.hw_addr + QTX_COMM_DBELL(pf_q);
3944 status = ice_ena_vsi_txq(vsi->port_info, vsi->vsi_num, tc,
3945 num_q_grps, qg_buf, buf_len, NULL);
3946 if (status) {
3947 dev_err(&vsi->back->pdev->dev,
3948 "Failed to set LAN Tx queue context, error: %d\n",
3949 status);
3950 err = -ENODEV;
3951 goto err_cfg_txqs;
3952 }
3953
3954 /* Add Tx Queue TEID into the VSI tx ring from the response
3955 * This will complete configuring and enabling the queue.
3956 */
3957 txq = &qg_buf->txqs[0];
3958 if (pf_q == le16_to_cpu(txq->txq_id))
3959 vsi->tx_rings[i]->txq_teid =
3960 le32_to_cpu(txq->q_teid);
3961 }
3962err_cfg_txqs:
3963 devm_kfree(&pf->pdev->dev, qg_buf);
3964 return err;
3965}
3966
3967/**
3968 * ice_setup_rx_ctx - Configure a receive ring context
3969 * @ring: The Rx ring to configure
3970 *
3971 * Configure the Rx descriptor ring in RLAN context.
3972 */
3973static int ice_setup_rx_ctx(struct ice_ring *ring)
3974{
3975 struct ice_vsi *vsi = ring->vsi;
3976 struct ice_hw *hw = &vsi->back->hw;
3977 u32 rxdid = ICE_RXDID_FLEX_NIC;
3978 struct ice_rlan_ctx rlan_ctx;
3979 u32 regval;
3980 u16 pf_q;
3981 int err;
3982
3983 /* what is RX queue number in global space of 2K rx queues */
3984 pf_q = vsi->rxq_map[ring->q_index];
3985
3986 /* clear the context structure first */
3987 memset(&rlan_ctx, 0, sizeof(rlan_ctx));
3988
3989 rlan_ctx.base = ring->dma >> 7;
3990
3991 rlan_ctx.qlen = ring->count;
3992
3993 /* Receive Packet Data Buffer Size.
3994 * The Packet Data Buffer Size is defined in 128 byte units.
3995 */
3996 rlan_ctx.dbuf = vsi->rx_buf_len >> ICE_RLAN_CTX_DBUF_S;
3997
3998 /* use 32 byte descriptors */
3999 rlan_ctx.dsize = 1;
4000
4001 /* Strip the Ethernet CRC bytes before the packet is posted to host
4002 * memory.
4003 */
4004 rlan_ctx.crcstrip = 1;
4005
4006 /* L2TSEL flag defines the reported L2 Tags in the receive descriptor */
4007 rlan_ctx.l2tsel = 1;
4008
4009 rlan_ctx.dtype = ICE_RX_DTYPE_NO_SPLIT;
4010 rlan_ctx.hsplit_0 = ICE_RLAN_RX_HSPLIT_0_NO_SPLIT;
4011 rlan_ctx.hsplit_1 = ICE_RLAN_RX_HSPLIT_1_NO_SPLIT;
4012
4013 /* This controls whether VLAN is stripped from inner headers
4014 * The VLAN in the inner L2 header is stripped to the receive
4015 * descriptor if enabled by this flag.
4016 */
4017 rlan_ctx.showiv = 0;
4018
4019 /* Max packet size for this queue - must not be set to a larger value
4020 * than 5 x DBUF
4021 */
4022 rlan_ctx.rxmax = min_t(u16, vsi->max_frame,
4023 ICE_MAX_CHAINED_RX_BUFS * vsi->rx_buf_len);
4024
4025 /* Rx queue threshold in units of 64 */
4026 rlan_ctx.lrxqthresh = 1;
4027
4028 /* Enable Flexible Descriptors in the queue context which
4029 * allows this driver to select a specific receive descriptor format
4030 */
4031 regval = rd32(hw, QRXFLXP_CNTXT(pf_q));
4032 regval |= (rxdid << QRXFLXP_CNTXT_RXDID_IDX_S) &
4033 QRXFLXP_CNTXT_RXDID_IDX_M;
4034
4035 /* increasing context priority to pick up profile id;
4036 * default is 0x01; setting to 0x03 to ensure profile
4037 * is programming if prev context is of same priority
4038 */
4039 regval |= (0x03 << QRXFLXP_CNTXT_RXDID_PRIO_S) &
4040 QRXFLXP_CNTXT_RXDID_PRIO_M;
4041
4042 wr32(hw, QRXFLXP_CNTXT(pf_q), regval);
4043
4044 /* Absolute queue number out of 2K needs to be passed */
4045 err = ice_write_rxq_ctx(hw, &rlan_ctx, pf_q);
4046 if (err) {
4047 dev_err(&vsi->back->pdev->dev,
4048 "Failed to set LAN Rx queue context for absolute Rx queue %d error: %d\n",
4049 pf_q, err);
4050 return -EIO;
4051 }
4052
4053 /* init queue specific tail register */
4054 ring->tail = hw->hw_addr + QRX_TAIL(pf_q);
4055 writel(0, ring->tail);
4056 ice_alloc_rx_bufs(ring, ICE_DESC_UNUSED(ring));
4057
4058 return 0;
4059}
4060
4061/**
4062 * ice_vsi_cfg_rxqs - Configure the VSI for Rx
4063 * @vsi: the VSI being configured
4064 *
4065 * Return 0 on success and a negative value on error
4066 * Configure the Rx VSI for operation.
4067 */
4068static int ice_vsi_cfg_rxqs(struct ice_vsi *vsi)
4069{
4070 int err = 0;
4071 u16 i;
4072
4073 if (vsi->netdev && vsi->netdev->mtu > ETH_DATA_LEN)
4074 vsi->max_frame = vsi->netdev->mtu +
4075 ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN;
4076 else
4077 vsi->max_frame = ICE_RXBUF_2048;
4078
4079 vsi->rx_buf_len = ICE_RXBUF_2048;
4080 /* set up individual rings */
4081 for (i = 0; i < vsi->num_rxq && !err; i++)
4082 err = ice_setup_rx_ctx(vsi->rx_rings[i]);
4083
4084 if (err) {
4085 dev_err(&vsi->back->pdev->dev, "ice_setup_rx_ctx failed\n");
4086 return -EIO;
4087 }
4088 return err;
4089}
4090
4091/**
4092 * ice_vsi_cfg - Setup the VSI
4093 * @vsi: the VSI being configured
4094 *
4095 * Return 0 on success and negative value on error
4096 */
4097static int ice_vsi_cfg(struct ice_vsi *vsi)
4098{
4099 int err;
4100
4101 ice_set_rx_mode(vsi->netdev);
4102
4103 err = ice_restore_vlan(vsi);
4104 if (err)
4105 return err;
4106
4107 err = ice_vsi_cfg_txqs(vsi);
4108 if (!err)
4109 err = ice_vsi_cfg_rxqs(vsi);
4110
4111 return err;
4112}
4113
4114/**
4115 * ice_vsi_stop_tx_rings - Disable Tx rings
4116 * @vsi: the VSI being configured
4117 */
4118static int ice_vsi_stop_tx_rings(struct ice_vsi *vsi)
4119{
4120 struct ice_pf *pf = vsi->back;
4121 struct ice_hw *hw = &pf->hw;
4122 enum ice_status status;
4123 u32 *q_teids, val;
4124 u16 *q_ids, i;
4125 int err = 0;
4126
4127 if (vsi->num_txq > ICE_LAN_TXQ_MAX_QDIS)
4128 return -EINVAL;
4129
4130 q_teids = devm_kcalloc(&pf->pdev->dev, vsi->num_txq, sizeof(*q_teids),
4131 GFP_KERNEL);
4132 if (!q_teids)
4133 return -ENOMEM;
4134
4135 q_ids = devm_kcalloc(&pf->pdev->dev, vsi->num_txq, sizeof(*q_ids),
4136 GFP_KERNEL);
4137 if (!q_ids) {
4138 err = -ENOMEM;
4139 goto err_alloc_q_ids;
4140 }
4141
4142 /* set up the tx queue list to be disabled */
4143 ice_for_each_txq(vsi, i) {
4144 u16 v_idx;
4145
4146 if (!vsi->tx_rings || !vsi->tx_rings[i]) {
4147 err = -EINVAL;
4148 goto err_out;
4149 }
4150
4151 q_ids[i] = vsi->txq_map[i];
4152 q_teids[i] = vsi->tx_rings[i]->txq_teid;
4153
4154 /* clear cause_ena bit for disabled queues */
4155 val = rd32(hw, QINT_TQCTL(vsi->tx_rings[i]->reg_idx));
4156 val &= ~QINT_TQCTL_CAUSE_ENA_M;
4157 wr32(hw, QINT_TQCTL(vsi->tx_rings[i]->reg_idx), val);
4158
4159 /* software is expected to wait for 100 ns */
4160 ndelay(100);
4161
4162 /* trigger a software interrupt for the vector associated to
4163 * the queue to schedule napi handler
4164 */
4165 v_idx = vsi->tx_rings[i]->q_vector->v_idx;
4166 wr32(hw, GLINT_DYN_CTL(vsi->base_vector + v_idx),
4167 GLINT_DYN_CTL_SWINT_TRIG_M | GLINT_DYN_CTL_INTENA_MSK_M);
4168 }
4169 status = ice_dis_vsi_txq(vsi->port_info, vsi->num_txq, q_ids, q_teids,
4170 NULL);
4171 if (status) {
4172 dev_err(&pf->pdev->dev,
4173 "Failed to disable LAN Tx queues, error: %d\n",
4174 status);
4175 err = -ENODEV;
4176 }
4177
4178err_out:
4179 devm_kfree(&pf->pdev->dev, q_ids);
4180
4181err_alloc_q_ids:
4182 devm_kfree(&pf->pdev->dev, q_teids);
4183
4184 return err;
4185}
4186
4187/**
4188 * ice_pf_rxq_wait - Wait for a PF's Rx queue to be enabled or disabled
4189 * @pf: the PF being configured
4190 * @pf_q: the PF queue
4191 * @ena: enable or disable state of the queue
4192 *
4193 * This routine will wait for the given Rx queue of the PF to reach the
4194 * enabled or disabled state.
4195 * Returns -ETIMEDOUT in case of failing to reach the requested state after
4196 * multiple retries; else will return 0 in case of success.
4197 */
4198static int ice_pf_rxq_wait(struct ice_pf *pf, int pf_q, bool ena)
4199{
4200 int i;
4201
4202 for (i = 0; i < ICE_Q_WAIT_RETRY_LIMIT; i++) {
4203 u32 rx_reg = rd32(&pf->hw, QRX_CTRL(pf_q));
4204
4205 if (ena == !!(rx_reg & QRX_CTRL_QENA_STAT_M))
4206 break;
4207
4208 usleep_range(10, 20);
4209 }
4210 if (i >= ICE_Q_WAIT_RETRY_LIMIT)
4211 return -ETIMEDOUT;
4212
4213 return 0;
4214}
4215
4216/**
4217 * ice_vsi_ctrl_rx_rings - Start or stop a VSI's rx rings
4218 * @vsi: the VSI being configured
4219 * @ena: start or stop the rx rings
4220 */
4221static int ice_vsi_ctrl_rx_rings(struct ice_vsi *vsi, bool ena)
4222{
4223 struct ice_pf *pf = vsi->back;
4224 struct ice_hw *hw = &pf->hw;
4225 int i, j, ret = 0;
4226
4227 for (i = 0; i < vsi->num_rxq; i++) {
4228 int pf_q = vsi->rxq_map[i];
4229 u32 rx_reg;
4230
4231 for (j = 0; j < ICE_Q_WAIT_MAX_RETRY; j++) {
4232 rx_reg = rd32(hw, QRX_CTRL(pf_q));
4233 if (((rx_reg >> QRX_CTRL_QENA_REQ_S) & 1) ==
4234 ((rx_reg >> QRX_CTRL_QENA_STAT_S) & 1))
4235 break;
4236 usleep_range(1000, 2000);
4237 }
4238
4239 /* Skip if the queue is already in the requested state */
4240 if (ena == !!(rx_reg & QRX_CTRL_QENA_STAT_M))
4241 continue;
4242
4243 /* turn on/off the queue */
4244 if (ena)
4245 rx_reg |= QRX_CTRL_QENA_REQ_M;
4246 else
4247 rx_reg &= ~QRX_CTRL_QENA_REQ_M;
4248 wr32(hw, QRX_CTRL(pf_q), rx_reg);
4249
4250 /* wait for the change to finish */
4251 ret = ice_pf_rxq_wait(pf, pf_q, ena);
4252 if (ret) {
4253 dev_err(&pf->pdev->dev,
4254 "VSI idx %d Rx ring %d %sable timeout\n",
4255 vsi->idx, pf_q, (ena ? "en" : "dis"));
4256 break;
4257 }
4258 }
4259
4260 return ret;
4261}
4262
4263/**
4264 * ice_vsi_start_rx_rings - start VSI's rx rings
4265 * @vsi: the VSI whose rings are to be started
4266 *
4267 * Returns 0 on success and a negative value on error
4268 */
4269static int ice_vsi_start_rx_rings(struct ice_vsi *vsi)
4270{
4271 return ice_vsi_ctrl_rx_rings(vsi, true);
4272}
4273
4274/**
4275 * ice_vsi_stop_rx_rings - stop VSI's rx rings
4276 * @vsi: the VSI
4277 *
4278 * Returns 0 on success and a negative value on error
4279 */
4280static int ice_vsi_stop_rx_rings(struct ice_vsi *vsi)
4281{
4282 return ice_vsi_ctrl_rx_rings(vsi, false);
4283}
4284
4285/**
4286 * ice_vsi_stop_tx_rx_rings - stop VSI's tx and rx rings
4287 * @vsi: the VSI
4288 * Returns 0 on success and a negative value on error
4289 */
4290static int ice_vsi_stop_tx_rx_rings(struct ice_vsi *vsi)
4291{
4292 int err_tx, err_rx;
4293
4294 err_tx = ice_vsi_stop_tx_rings(vsi);
4295 if (err_tx)
4296 dev_dbg(&vsi->back->pdev->dev, "Failed to disable Tx rings\n");
4297
4298 err_rx = ice_vsi_stop_rx_rings(vsi);
4299 if (err_rx)
4300 dev_dbg(&vsi->back->pdev->dev, "Failed to disable Rx rings\n");
4301
4302 if (err_tx || err_rx)
4303 return -EIO;
4304
4305 return 0;
4306}
4307
4308/**
4309 * ice_napi_enable_all - Enable NAPI for all q_vectors in the VSI
4310 * @vsi: the VSI being configured
4311 */
4312static void ice_napi_enable_all(struct ice_vsi *vsi)
4313{
4314 int q_idx;
4315
4316 if (!vsi->netdev)
4317 return;
4318
4319 for (q_idx = 0; q_idx < vsi->num_q_vectors; q_idx++)
4320 napi_enable(&vsi->q_vectors[q_idx]->napi);
4321}
4322
4323/**
4324 * ice_up_complete - Finish the last steps of bringing up a connection
4325 * @vsi: The VSI being configured
4326 *
4327 * Return 0 on success and negative value on error
4328 */
4329static int ice_up_complete(struct ice_vsi *vsi)
4330{
4331 struct ice_pf *pf = vsi->back;
4332 int err;
4333
4334 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags))
4335 ice_vsi_cfg_msix(vsi);
4336 else
4337 return -ENOTSUPP;
4338
4339 /* Enable only Rx rings, Tx rings were enabled by the FW when the
4340 * Tx queue group list was configured and the context bits were
4341 * programmed using ice_vsi_cfg_txqs
4342 */
4343 err = ice_vsi_start_rx_rings(vsi);
4344 if (err)
4345 return err;
4346
4347 clear_bit(__ICE_DOWN, vsi->state);
4348 ice_napi_enable_all(vsi);
4349 ice_vsi_ena_irq(vsi);
4350
4351 if (vsi->port_info &&
4352 (vsi->port_info->phy.link_info.link_info & ICE_AQ_LINK_UP) &&
4353 vsi->netdev) {
4354 ice_print_link_msg(vsi, true);
4355 netif_tx_start_all_queues(vsi->netdev);
4356 netif_carrier_on(vsi->netdev);
4357 }
4358
4359 ice_service_task_schedule(pf);
4360
4361 return err;
4362}
4363
4364/**
4365 * ice_up - Bring the connection back up after being down
4366 * @vsi: VSI being configured
4367 */
4368int ice_up(struct ice_vsi *vsi)
4369{
4370 int err;
4371
4372 err = ice_vsi_cfg(vsi);
4373 if (!err)
4374 err = ice_up_complete(vsi);
4375
4376 return err;
4377}
4378
4379/**
4380 * ice_fetch_u64_stats_per_ring - get packets and bytes stats per ring
4381 * @ring: Tx or Rx ring to read stats from
4382 * @pkts: packets stats counter
4383 * @bytes: bytes stats counter
4384 *
4385 * This function fetches stats from the ring considering the atomic operations
4386 * that needs to be performed to read u64 values in 32 bit machine.
4387 */
4388static void ice_fetch_u64_stats_per_ring(struct ice_ring *ring, u64 *pkts,
4389 u64 *bytes)
4390{
4391 unsigned int start;
4392 *pkts = 0;
4393 *bytes = 0;
4394
4395 if (!ring)
4396 return;
4397 do {
4398 start = u64_stats_fetch_begin_irq(&ring->syncp);
4399 *pkts = ring->stats.pkts;
4400 *bytes = ring->stats.bytes;
4401 } while (u64_stats_fetch_retry_irq(&ring->syncp, start));
4402}
4403
4404/**
4405 * ice_stat_update40 - read 40 bit stat from the chip and update stat values
4406 * @hw: ptr to the hardware info
4407 * @hireg: high 32 bit HW register to read from
4408 * @loreg: low 32 bit HW register to read from
4409 * @prev_stat_loaded: bool to specify if previous stats are loaded
4410 * @prev_stat: ptr to previous loaded stat value
4411 * @cur_stat: ptr to current stat value
4412 */
4413static void ice_stat_update40(struct ice_hw *hw, u32 hireg, u32 loreg,
4414 bool prev_stat_loaded, u64 *prev_stat,
4415 u64 *cur_stat)
4416{
4417 u64 new_data;
4418
4419 new_data = rd32(hw, loreg);
4420 new_data |= ((u64)(rd32(hw, hireg) & 0xFFFF)) << 32;
4421
4422 /* device stats are not reset at PFR, they likely will not be zeroed
4423 * when the driver starts. So save the first values read and use them as
4424 * offsets to be subtracted from the raw values in order to report stats
4425 * that count from zero.
4426 */
4427 if (!prev_stat_loaded)
4428 *prev_stat = new_data;
4429 if (likely(new_data >= *prev_stat))
4430 *cur_stat = new_data - *prev_stat;
4431 else
4432 /* to manage the potential roll-over */
4433 *cur_stat = (new_data + BIT_ULL(40)) - *prev_stat;
4434 *cur_stat &= 0xFFFFFFFFFFULL;
4435}
4436
4437/**
4438 * ice_stat_update32 - read 32 bit stat from the chip and update stat values
4439 * @hw: ptr to the hardware info
4440 * @reg: HW register to read from
4441 * @prev_stat_loaded: bool to specify if previous stats are loaded
4442 * @prev_stat: ptr to previous loaded stat value
4443 * @cur_stat: ptr to current stat value
4444 */
4445static void ice_stat_update32(struct ice_hw *hw, u32 reg, bool prev_stat_loaded,
4446 u64 *prev_stat, u64 *cur_stat)
4447{
4448 u32 new_data;
4449
4450 new_data = rd32(hw, reg);
4451
4452 /* device stats are not reset at PFR, they likely will not be zeroed
4453 * when the driver starts. So save the first values read and use them as
4454 * offsets to be subtracted from the raw values in order to report stats
4455 * that count from zero.
4456 */
4457 if (!prev_stat_loaded)
4458 *prev_stat = new_data;
4459 if (likely(new_data >= *prev_stat))
4460 *cur_stat = new_data - *prev_stat;
4461 else
4462 /* to manage the potential roll-over */
4463 *cur_stat = (new_data + BIT_ULL(32)) - *prev_stat;
4464}
4465
4466/**
4467 * ice_update_eth_stats - Update VSI-specific ethernet statistics counters
4468 * @vsi: the VSI to be updated
4469 */
4470static void ice_update_eth_stats(struct ice_vsi *vsi)
4471{
4472 struct ice_eth_stats *prev_es, *cur_es;
4473 struct ice_hw *hw = &vsi->back->hw;
4474 u16 vsi_num = vsi->vsi_num; /* HW absolute index of a VSI */
4475
4476 prev_es = &vsi->eth_stats_prev;
4477 cur_es = &vsi->eth_stats;
4478
4479 ice_stat_update40(hw, GLV_GORCH(vsi_num), GLV_GORCL(vsi_num),
4480 vsi->stat_offsets_loaded, &prev_es->rx_bytes,
4481 &cur_es->rx_bytes);
4482
4483 ice_stat_update40(hw, GLV_UPRCH(vsi_num), GLV_UPRCL(vsi_num),
4484 vsi->stat_offsets_loaded, &prev_es->rx_unicast,
4485 &cur_es->rx_unicast);
4486
4487 ice_stat_update40(hw, GLV_MPRCH(vsi_num), GLV_MPRCL(vsi_num),
4488 vsi->stat_offsets_loaded, &prev_es->rx_multicast,
4489 &cur_es->rx_multicast);
4490
4491 ice_stat_update40(hw, GLV_BPRCH(vsi_num), GLV_BPRCL(vsi_num),
4492 vsi->stat_offsets_loaded, &prev_es->rx_broadcast,
4493 &cur_es->rx_broadcast);
4494
4495 ice_stat_update32(hw, GLV_RDPC(vsi_num), vsi->stat_offsets_loaded,
4496 &prev_es->rx_discards, &cur_es->rx_discards);
4497
4498 ice_stat_update40(hw, GLV_GOTCH(vsi_num), GLV_GOTCL(vsi_num),
4499 vsi->stat_offsets_loaded, &prev_es->tx_bytes,
4500 &cur_es->tx_bytes);
4501
4502 ice_stat_update40(hw, GLV_UPTCH(vsi_num), GLV_UPTCL(vsi_num),
4503 vsi->stat_offsets_loaded, &prev_es->tx_unicast,
4504 &cur_es->tx_unicast);
4505
4506 ice_stat_update40(hw, GLV_MPTCH(vsi_num), GLV_MPTCL(vsi_num),
4507 vsi->stat_offsets_loaded, &prev_es->tx_multicast,
4508 &cur_es->tx_multicast);
4509
4510 ice_stat_update40(hw, GLV_BPTCH(vsi_num), GLV_BPTCL(vsi_num),
4511 vsi->stat_offsets_loaded, &prev_es->tx_broadcast,
4512 &cur_es->tx_broadcast);
4513
4514 ice_stat_update32(hw, GLV_TEPC(vsi_num), vsi->stat_offsets_loaded,
4515 &prev_es->tx_errors, &cur_es->tx_errors);
4516
4517 vsi->stat_offsets_loaded = true;
4518}
4519
4520/**
4521 * ice_update_vsi_ring_stats - Update VSI stats counters
4522 * @vsi: the VSI to be updated
4523 */
4524static void ice_update_vsi_ring_stats(struct ice_vsi *vsi)
4525{
4526 struct rtnl_link_stats64 *vsi_stats = &vsi->net_stats;
4527 struct ice_ring *ring;
4528 u64 pkts, bytes;
4529 int i;
4530
4531 /* reset netdev stats */
4532 vsi_stats->tx_packets = 0;
4533 vsi_stats->tx_bytes = 0;
4534 vsi_stats->rx_packets = 0;
4535 vsi_stats->rx_bytes = 0;
4536
4537 /* reset non-netdev (extended) stats */
4538 vsi->tx_restart = 0;
4539 vsi->tx_busy = 0;
4540 vsi->tx_linearize = 0;
4541 vsi->rx_buf_failed = 0;
4542 vsi->rx_page_failed = 0;
4543
4544 rcu_read_lock();
4545
4546 /* update Tx rings counters */
4547 ice_for_each_txq(vsi, i) {
4548 ring = READ_ONCE(vsi->tx_rings[i]);
4549 ice_fetch_u64_stats_per_ring(ring, &pkts, &bytes);
4550 vsi_stats->tx_packets += pkts;
4551 vsi_stats->tx_bytes += bytes;
4552 vsi->tx_restart += ring->tx_stats.restart_q;
4553 vsi->tx_busy += ring->tx_stats.tx_busy;
4554 vsi->tx_linearize += ring->tx_stats.tx_linearize;
4555 }
4556
4557 /* update Rx rings counters */
4558 ice_for_each_rxq(vsi, i) {
4559 ring = READ_ONCE(vsi->rx_rings[i]);
4560 ice_fetch_u64_stats_per_ring(ring, &pkts, &bytes);
4561 vsi_stats->rx_packets += pkts;
4562 vsi_stats->rx_bytes += bytes;
4563 vsi->rx_buf_failed += ring->rx_stats.alloc_buf_failed;
4564 vsi->rx_page_failed += ring->rx_stats.alloc_page_failed;
4565 }
4566
4567 rcu_read_unlock();
4568}
4569
4570/**
4571 * ice_update_vsi_stats - Update VSI stats counters
4572 * @vsi: the VSI to be updated
4573 */
4574static void ice_update_vsi_stats(struct ice_vsi *vsi)
4575{
4576 struct rtnl_link_stats64 *cur_ns = &vsi->net_stats;
4577 struct ice_eth_stats *cur_es = &vsi->eth_stats;
4578 struct ice_pf *pf = vsi->back;
4579
4580 if (test_bit(__ICE_DOWN, vsi->state) ||
4581 test_bit(__ICE_CFG_BUSY, pf->state))
4582 return;
4583
4584 /* get stats as recorded by Tx/Rx rings */
4585 ice_update_vsi_ring_stats(vsi);
4586
4587 /* get VSI stats as recorded by the hardware */
4588 ice_update_eth_stats(vsi);
4589
4590 cur_ns->tx_errors = cur_es->tx_errors;
4591 cur_ns->rx_dropped = cur_es->rx_discards;
4592 cur_ns->tx_dropped = cur_es->tx_discards;
4593 cur_ns->multicast = cur_es->rx_multicast;
4594
4595 /* update some more netdev stats if this is main VSI */
4596 if (vsi->type == ICE_VSI_PF) {
4597 cur_ns->rx_crc_errors = pf->stats.crc_errors;
4598 cur_ns->rx_errors = pf->stats.crc_errors +
4599 pf->stats.illegal_bytes;
4600 cur_ns->rx_length_errors = pf->stats.rx_len_errors;
4601 }
4602}
4603
4604/**
4605 * ice_update_pf_stats - Update PF port stats counters
4606 * @pf: PF whose stats needs to be updated
4607 */
4608static void ice_update_pf_stats(struct ice_pf *pf)
4609{
4610 struct ice_hw_port_stats *prev_ps, *cur_ps;
4611 struct ice_hw *hw = &pf->hw;
4612 u8 pf_id;
4613
4614 prev_ps = &pf->stats_prev;
4615 cur_ps = &pf->stats;
4616 pf_id = hw->pf_id;
4617
4618 ice_stat_update40(hw, GLPRT_GORCH(pf_id), GLPRT_GORCL(pf_id),
4619 pf->stat_prev_loaded, &prev_ps->eth.rx_bytes,
4620 &cur_ps->eth.rx_bytes);
4621
4622 ice_stat_update40(hw, GLPRT_UPRCH(pf_id), GLPRT_UPRCL(pf_id),
4623 pf->stat_prev_loaded, &prev_ps->eth.rx_unicast,
4624 &cur_ps->eth.rx_unicast);
4625
4626 ice_stat_update40(hw, GLPRT_MPRCH(pf_id), GLPRT_MPRCL(pf_id),
4627 pf->stat_prev_loaded, &prev_ps->eth.rx_multicast,
4628 &cur_ps->eth.rx_multicast);
4629
4630 ice_stat_update40(hw, GLPRT_BPRCH(pf_id), GLPRT_BPRCL(pf_id),
4631 pf->stat_prev_loaded, &prev_ps->eth.rx_broadcast,
4632 &cur_ps->eth.rx_broadcast);
4633
4634 ice_stat_update40(hw, GLPRT_GOTCH(pf_id), GLPRT_GOTCL(pf_id),
4635 pf->stat_prev_loaded, &prev_ps->eth.tx_bytes,
4636 &cur_ps->eth.tx_bytes);
4637
4638 ice_stat_update40(hw, GLPRT_UPTCH(pf_id), GLPRT_UPTCL(pf_id),
4639 pf->stat_prev_loaded, &prev_ps->eth.tx_unicast,
4640 &cur_ps->eth.tx_unicast);
4641
4642 ice_stat_update40(hw, GLPRT_MPTCH(pf_id), GLPRT_MPTCL(pf_id),
4643 pf->stat_prev_loaded, &prev_ps->eth.tx_multicast,
4644 &cur_ps->eth.tx_multicast);
4645
4646 ice_stat_update40(hw, GLPRT_BPTCH(pf_id), GLPRT_BPTCL(pf_id),
4647 pf->stat_prev_loaded, &prev_ps->eth.tx_broadcast,
4648 &cur_ps->eth.tx_broadcast);
4649
4650 ice_stat_update32(hw, GLPRT_TDOLD(pf_id), pf->stat_prev_loaded,
4651 &prev_ps->tx_dropped_link_down,
4652 &cur_ps->tx_dropped_link_down);
4653
4654 ice_stat_update40(hw, GLPRT_PRC64H(pf_id), GLPRT_PRC64L(pf_id),
4655 pf->stat_prev_loaded, &prev_ps->rx_size_64,
4656 &cur_ps->rx_size_64);
4657
4658 ice_stat_update40(hw, GLPRT_PRC127H(pf_id), GLPRT_PRC127L(pf_id),
4659 pf->stat_prev_loaded, &prev_ps->rx_size_127,
4660 &cur_ps->rx_size_127);
4661
4662 ice_stat_update40(hw, GLPRT_PRC255H(pf_id), GLPRT_PRC255L(pf_id),
4663 pf->stat_prev_loaded, &prev_ps->rx_size_255,
4664 &cur_ps->rx_size_255);
4665
4666 ice_stat_update40(hw, GLPRT_PRC511H(pf_id), GLPRT_PRC511L(pf_id),
4667 pf->stat_prev_loaded, &prev_ps->rx_size_511,
4668 &cur_ps->rx_size_511);
4669
4670 ice_stat_update40(hw, GLPRT_PRC1023H(pf_id),
4671 GLPRT_PRC1023L(pf_id), pf->stat_prev_loaded,
4672 &prev_ps->rx_size_1023, &cur_ps->rx_size_1023);
4673
4674 ice_stat_update40(hw, GLPRT_PRC1522H(pf_id),
4675 GLPRT_PRC1522L(pf_id), pf->stat_prev_loaded,
4676 &prev_ps->rx_size_1522, &cur_ps->rx_size_1522);
4677
4678 ice_stat_update40(hw, GLPRT_PRC9522H(pf_id),
4679 GLPRT_PRC9522L(pf_id), pf->stat_prev_loaded,
4680 &prev_ps->rx_size_big, &cur_ps->rx_size_big);
4681
4682 ice_stat_update40(hw, GLPRT_PTC64H(pf_id), GLPRT_PTC64L(pf_id),
4683 pf->stat_prev_loaded, &prev_ps->tx_size_64,
4684 &cur_ps->tx_size_64);
4685
4686 ice_stat_update40(hw, GLPRT_PTC127H(pf_id), GLPRT_PTC127L(pf_id),
4687 pf->stat_prev_loaded, &prev_ps->tx_size_127,
4688 &cur_ps->tx_size_127);
4689
4690 ice_stat_update40(hw, GLPRT_PTC255H(pf_id), GLPRT_PTC255L(pf_id),
4691 pf->stat_prev_loaded, &prev_ps->tx_size_255,
4692 &cur_ps->tx_size_255);
4693
4694 ice_stat_update40(hw, GLPRT_PTC511H(pf_id), GLPRT_PTC511L(pf_id),
4695 pf->stat_prev_loaded, &prev_ps->tx_size_511,
4696 &cur_ps->tx_size_511);
4697
4698 ice_stat_update40(hw, GLPRT_PTC1023H(pf_id),
4699 GLPRT_PTC1023L(pf_id), pf->stat_prev_loaded,
4700 &prev_ps->tx_size_1023, &cur_ps->tx_size_1023);
4701
4702 ice_stat_update40(hw, GLPRT_PTC1522H(pf_id),
4703 GLPRT_PTC1522L(pf_id), pf->stat_prev_loaded,
4704 &prev_ps->tx_size_1522, &cur_ps->tx_size_1522);
4705
4706 ice_stat_update40(hw, GLPRT_PTC9522H(pf_id),
4707 GLPRT_PTC9522L(pf_id), pf->stat_prev_loaded,
4708 &prev_ps->tx_size_big, &cur_ps->tx_size_big);
4709
4710 ice_stat_update32(hw, GLPRT_LXONRXC(pf_id), pf->stat_prev_loaded,
4711 &prev_ps->link_xon_rx, &cur_ps->link_xon_rx);
4712
4713 ice_stat_update32(hw, GLPRT_LXOFFRXC(pf_id), pf->stat_prev_loaded,
4714 &prev_ps->link_xoff_rx, &cur_ps->link_xoff_rx);
4715
4716 ice_stat_update32(hw, GLPRT_LXONTXC(pf_id), pf->stat_prev_loaded,
4717 &prev_ps->link_xon_tx, &cur_ps->link_xon_tx);
4718
4719 ice_stat_update32(hw, GLPRT_LXOFFTXC(pf_id), pf->stat_prev_loaded,
4720 &prev_ps->link_xoff_tx, &cur_ps->link_xoff_tx);
4721
4722 ice_stat_update32(hw, GLPRT_CRCERRS(pf_id), pf->stat_prev_loaded,
4723 &prev_ps->crc_errors, &cur_ps->crc_errors);
4724
4725 ice_stat_update32(hw, GLPRT_ILLERRC(pf_id), pf->stat_prev_loaded,
4726 &prev_ps->illegal_bytes, &cur_ps->illegal_bytes);
4727
4728 ice_stat_update32(hw, GLPRT_MLFC(pf_id), pf->stat_prev_loaded,
4729 &prev_ps->mac_local_faults,
4730 &cur_ps->mac_local_faults);
4731
4732 ice_stat_update32(hw, GLPRT_MRFC(pf_id), pf->stat_prev_loaded,
4733 &prev_ps->mac_remote_faults,
4734 &cur_ps->mac_remote_faults);
4735
4736 ice_stat_update32(hw, GLPRT_RLEC(pf_id), pf->stat_prev_loaded,
4737 &prev_ps->rx_len_errors, &cur_ps->rx_len_errors);
4738
4739 ice_stat_update32(hw, GLPRT_RUC(pf_id), pf->stat_prev_loaded,
4740 &prev_ps->rx_undersize, &cur_ps->rx_undersize);
4741
4742 ice_stat_update32(hw, GLPRT_RFC(pf_id), pf->stat_prev_loaded,
4743 &prev_ps->rx_fragments, &cur_ps->rx_fragments);
4744
4745 ice_stat_update32(hw, GLPRT_ROC(pf_id), pf->stat_prev_loaded,
4746 &prev_ps->rx_oversize, &cur_ps->rx_oversize);
4747
4748 ice_stat_update32(hw, GLPRT_RJC(pf_id), pf->stat_prev_loaded,
4749 &prev_ps->rx_jabber, &cur_ps->rx_jabber);
4750
4751 pf->stat_prev_loaded = true;
4752}
4753
4754/**
4755 * ice_get_stats64 - get statistics for network device structure
4756 * @netdev: network interface device structure
4757 * @stats: main device statistics structure
4758 */
4759static
4760void ice_get_stats64(struct net_device *netdev, struct rtnl_link_stats64 *stats)
4761{
4762 struct ice_netdev_priv *np = netdev_priv(netdev);
4763 struct rtnl_link_stats64 *vsi_stats;
4764 struct ice_vsi *vsi = np->vsi;
4765
4766 vsi_stats = &vsi->net_stats;
4767
4768 if (test_bit(__ICE_DOWN, vsi->state) || !vsi->num_txq || !vsi->num_rxq)
4769 return;
4770 /* netdev packet/byte stats come from ring counter. These are obtained
4771 * by summing up ring counters (done by ice_update_vsi_ring_stats).
4772 */
4773 ice_update_vsi_ring_stats(vsi);
4774 stats->tx_packets = vsi_stats->tx_packets;
4775 stats->tx_bytes = vsi_stats->tx_bytes;
4776 stats->rx_packets = vsi_stats->rx_packets;
4777 stats->rx_bytes = vsi_stats->rx_bytes;
4778
4779 /* The rest of the stats can be read from the hardware but instead we
4780 * just return values that the watchdog task has already obtained from
4781 * the hardware.
4782 */
4783 stats->multicast = vsi_stats->multicast;
4784 stats->tx_errors = vsi_stats->tx_errors;
4785 stats->tx_dropped = vsi_stats->tx_dropped;
4786 stats->rx_errors = vsi_stats->rx_errors;
4787 stats->rx_dropped = vsi_stats->rx_dropped;
4788 stats->rx_crc_errors = vsi_stats->rx_crc_errors;
4789 stats->rx_length_errors = vsi_stats->rx_length_errors;
4790}
4791
4792#ifdef CONFIG_NET_POLL_CONTROLLER
4793/**
4794 * ice_netpoll - polling "interrupt" handler
4795 * @netdev: network interface device structure
4796 *
4797 * Used by netconsole to send skbs without having to re-enable interrupts.
4798 * This is not called in the normal interrupt path.
4799 */
4800static void ice_netpoll(struct net_device *netdev)
4801{
4802 struct ice_netdev_priv *np = netdev_priv(netdev);
4803 struct ice_vsi *vsi = np->vsi;
4804 struct ice_pf *pf = vsi->back;
4805 int i;
4806
4807 if (test_bit(__ICE_DOWN, vsi->state) ||
4808 !test_bit(ICE_FLAG_MSIX_ENA, pf->flags))
4809 return;
4810
4811 for (i = 0; i < vsi->num_q_vectors; i++)
4812 ice_msix_clean_rings(0, vsi->q_vectors[i]);
4813}
4814#endif /* CONFIG_NET_POLL_CONTROLLER */
4815
4816/**
4817 * ice_napi_disable_all - Disable NAPI for all q_vectors in the VSI
4818 * @vsi: VSI having NAPI disabled
4819 */
4820static void ice_napi_disable_all(struct ice_vsi *vsi)
4821{
4822 int q_idx;
4823
4824 if (!vsi->netdev)
4825 return;
4826
4827 for (q_idx = 0; q_idx < vsi->num_q_vectors; q_idx++)
4828 napi_disable(&vsi->q_vectors[q_idx]->napi);
4829}
4830
4831/**
4832 * ice_down - Shutdown the connection
4833 * @vsi: The VSI being stopped
4834 */
4835int ice_down(struct ice_vsi *vsi)
4836{
4837 int i, err;
4838
4839 /* Caller of this function is expected to set the
4840 * vsi->state __ICE_DOWN bit
4841 */
4842 if (vsi->netdev) {
4843 netif_carrier_off(vsi->netdev);
4844 netif_tx_disable(vsi->netdev);
4845 }
4846
4847 ice_vsi_dis_irq(vsi);
4848 err = ice_vsi_stop_tx_rx_rings(vsi);
4849 ice_napi_disable_all(vsi);
4850
4851 ice_for_each_txq(vsi, i)
4852 ice_clean_tx_ring(vsi->tx_rings[i]);
4853
4854 ice_for_each_rxq(vsi, i)
4855 ice_clean_rx_ring(vsi->rx_rings[i]);
4856
4857 if (err)
4858 netdev_err(vsi->netdev, "Failed to close VSI 0x%04X on switch 0x%04X\n",
4859 vsi->vsi_num, vsi->vsw->sw_id);
4860 return err;
4861}
4862
4863/**
4864 * ice_vsi_setup_tx_rings - Allocate VSI Tx queue resources
4865 * @vsi: VSI having resources allocated
4866 *
4867 * Return 0 on success, negative on failure
4868 */
4869static int ice_vsi_setup_tx_rings(struct ice_vsi *vsi)
4870{
4871 int i, err;
4872
4873 if (!vsi->num_txq) {
4874 dev_err(&vsi->back->pdev->dev, "VSI %d has 0 Tx queues\n",
4875 vsi->vsi_num);
4876 return -EINVAL;
4877 }
4878
4879 ice_for_each_txq(vsi, i) {
4880 err = ice_setup_tx_ring(vsi->tx_rings[i]);
4881 if (err)
4882 break;
4883 }
4884
4885 return err;
4886}
4887
4888/**
4889 * ice_vsi_setup_rx_rings - Allocate VSI Rx queue resources
4890 * @vsi: VSI having resources allocated
4891 *
4892 * Return 0 on success, negative on failure
4893 */
4894static int ice_vsi_setup_rx_rings(struct ice_vsi *vsi)
4895{
4896 int i, err;
4897
4898 if (!vsi->num_rxq) {
4899 dev_err(&vsi->back->pdev->dev, "VSI %d has 0 Rx queues\n",
4900 vsi->vsi_num);
4901 return -EINVAL;
4902 }
4903
4904 ice_for_each_rxq(vsi, i) {
4905 err = ice_setup_rx_ring(vsi->rx_rings[i]);
4906 if (err)
4907 break;
4908 }
4909
4910 return err;
4911}
4912
4913/**
4914 * ice_vsi_req_irq - Request IRQ from the OS
4915 * @vsi: The VSI IRQ is being requested for
4916 * @basename: name for the vector
4917 *
4918 * Return 0 on success and a negative value on error
4919 */
4920static int ice_vsi_req_irq(struct ice_vsi *vsi, char *basename)
4921{
4922 struct ice_pf *pf = vsi->back;
4923 int err = -EINVAL;
4924
4925 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags))
4926 err = ice_vsi_req_irq_msix(vsi, basename);
4927
4928 return err;
4929}
4930
4931/**
4932 * ice_vsi_free_tx_rings - Free Tx resources for VSI queues
4933 * @vsi: the VSI having resources freed
4934 */
4935static void ice_vsi_free_tx_rings(struct ice_vsi *vsi)
4936{
4937 int i;
4938
4939 if (!vsi->tx_rings)
4940 return;
4941
4942 ice_for_each_txq(vsi, i)
4943 if (vsi->tx_rings[i] && vsi->tx_rings[i]->desc)
4944 ice_free_tx_ring(vsi->tx_rings[i]);
4945}
4946
4947/**
4948 * ice_vsi_free_rx_rings - Free Rx resources for VSI queues
4949 * @vsi: the VSI having resources freed
4950 */
4951static void ice_vsi_free_rx_rings(struct ice_vsi *vsi)
4952{
4953 int i;
4954
4955 if (!vsi->rx_rings)
4956 return;
4957
4958 ice_for_each_rxq(vsi, i)
4959 if (vsi->rx_rings[i] && vsi->rx_rings[i]->desc)
4960 ice_free_rx_ring(vsi->rx_rings[i]);
4961}
4962
4963/**
4964 * ice_vsi_open - Called when a network interface is made active
4965 * @vsi: the VSI to open
4966 *
4967 * Initialization of the VSI
4968 *
4969 * Returns 0 on success, negative value on error
4970 */
4971static int ice_vsi_open(struct ice_vsi *vsi)
4972{
4973 char int_name[ICE_INT_NAME_STR_LEN];
4974 struct ice_pf *pf = vsi->back;
4975 int err;
4976
4977 /* allocate descriptors */
4978 err = ice_vsi_setup_tx_rings(vsi);
4979 if (err)
4980 goto err_setup_tx;
4981
4982 err = ice_vsi_setup_rx_rings(vsi);
4983 if (err)
4984 goto err_setup_rx;
4985
4986 err = ice_vsi_cfg(vsi);
4987 if (err)
4988 goto err_setup_rx;
4989
4990 snprintf(int_name, sizeof(int_name) - 1, "%s-%s",
4991 dev_driver_string(&pf->pdev->dev), vsi->netdev->name);
4992 err = ice_vsi_req_irq(vsi, int_name);
4993 if (err)
4994 goto err_setup_rx;
4995
4996 /* Notify the stack of the actual queue counts. */
4997 err = netif_set_real_num_tx_queues(vsi->netdev, vsi->num_txq);
4998 if (err)
4999 goto err_set_qs;
5000
5001 err = netif_set_real_num_rx_queues(vsi->netdev, vsi->num_rxq);
5002 if (err)
5003 goto err_set_qs;
5004
5005 err = ice_up_complete(vsi);
5006 if (err)
5007 goto err_up_complete;
5008
5009 return 0;
5010
5011err_up_complete:
5012 ice_down(vsi);
5013err_set_qs:
5014 ice_vsi_free_irq(vsi);
5015err_setup_rx:
5016 ice_vsi_free_rx_rings(vsi);
5017err_setup_tx:
5018 ice_vsi_free_tx_rings(vsi);
5019
5020 return err;
5021}
5022
5023/**
5024 * ice_vsi_close - Shut down a VSI
5025 * @vsi: the VSI being shut down
5026 */
5027static void ice_vsi_close(struct ice_vsi *vsi)
5028{
5029 if (!test_and_set_bit(__ICE_DOWN, vsi->state))
5030 ice_down(vsi);
5031
5032 ice_vsi_free_irq(vsi);
5033 ice_vsi_free_tx_rings(vsi);
5034 ice_vsi_free_rx_rings(vsi);
5035}
5036
5037/**
5038 * ice_rss_clean - Delete RSS related VSI structures that hold user inputs
5039 * @vsi: the VSI being removed
5040 */
5041static void ice_rss_clean(struct ice_vsi *vsi)
5042{
5043 struct ice_pf *pf;
5044
5045 pf = vsi->back;
5046
5047 if (vsi->rss_hkey_user)
5048 devm_kfree(&pf->pdev->dev, vsi->rss_hkey_user);
5049 if (vsi->rss_lut_user)
5050 devm_kfree(&pf->pdev->dev, vsi->rss_lut_user);
5051}
5052
5053/**
5054 * ice_vsi_release - Delete a VSI and free its resources
5055 * @vsi: the VSI being removed
5056 *
5057 * Returns 0 on success or < 0 on error
5058 */
5059static int ice_vsi_release(struct ice_vsi *vsi)
5060{
5061 struct ice_pf *pf;
5062
5063 if (!vsi->back)
5064 return -ENODEV;
5065 pf = vsi->back;
5066
5067 if (vsi->netdev) {
5068 unregister_netdev(vsi->netdev);
5069 free_netdev(vsi->netdev);
5070 vsi->netdev = NULL;
5071 }
5072
5073 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags))
5074 ice_rss_clean(vsi);
5075
5076 /* Disable VSI and free resources */
5077 ice_vsi_dis_irq(vsi);
5078 ice_vsi_close(vsi);
5079
5080 /* reclaim interrupt vectors back to PF */
5081 ice_free_res(vsi->back->irq_tracker, vsi->base_vector, vsi->idx);
5082 pf->num_avail_msix += vsi->num_q_vectors;
5083
5084 ice_remove_vsi_fltr(&pf->hw, vsi->vsi_num);
5085 ice_vsi_delete(vsi);
5086 ice_vsi_free_q_vectors(vsi);
5087 ice_vsi_clear_rings(vsi);
5088
5089 ice_vsi_put_qs(vsi);
5090 pf->q_left_tx += vsi->alloc_txq;
5091 pf->q_left_rx += vsi->alloc_rxq;
5092
5093 ice_vsi_clear(vsi);
5094
5095 return 0;
5096}
5097
5098/**
5099 * ice_dis_vsi - pause a VSI
5100 * @vsi: the VSI being paused
5101 */
5102static void ice_dis_vsi(struct ice_vsi *vsi)
5103{
5104 if (test_bit(__ICE_DOWN, vsi->state))
5105 return;
5106
5107 set_bit(__ICE_NEEDS_RESTART, vsi->state);
5108
5109 if (vsi->netdev && netif_running(vsi->netdev) &&
5110 vsi->type == ICE_VSI_PF)
5111 vsi->netdev->netdev_ops->ndo_stop(vsi->netdev);
5112
5113 ice_vsi_close(vsi);
5114}
5115
5116/**
5117 * ice_ena_vsi - resume a VSI
5118 * @vsi: the VSI being resume
5119 */
5120static void ice_ena_vsi(struct ice_vsi *vsi)
5121{
5122 if (!test_and_clear_bit(__ICE_NEEDS_RESTART, vsi->state))
5123 return;
5124
5125 if (vsi->netdev && netif_running(vsi->netdev))
5126 vsi->netdev->netdev_ops->ndo_open(vsi->netdev);
5127 else if (ice_vsi_open(vsi))
5128 /* this clears the DOWN bit */
5129 dev_dbg(&vsi->back->pdev->dev, "Failed open VSI 0x%04X on switch 0x%04X\n",
5130 vsi->vsi_num, vsi->vsw->sw_id);
5131}
5132
5133/**
5134 * ice_pf_dis_all_vsi - Pause all VSIs on a PF
5135 * @pf: the PF
5136 */
5137static void ice_pf_dis_all_vsi(struct ice_pf *pf)
5138{
5139 int v;
5140
5141 ice_for_each_vsi(pf, v)
5142 if (pf->vsi[v])
5143 ice_dis_vsi(pf->vsi[v]);
5144}
5145
5146/**
5147 * ice_pf_ena_all_vsi - Resume all VSIs on a PF
5148 * @pf: the PF
5149 */
5150static void ice_pf_ena_all_vsi(struct ice_pf *pf)
5151{
5152 int v;
5153
5154 ice_for_each_vsi(pf, v)
5155 if (pf->vsi[v])
5156 ice_ena_vsi(pf->vsi[v]);
5157}
5158
5159/**
5160 * ice_rebuild - rebuild after reset
5161 * @pf: pf to rebuild
5162 */
5163static void ice_rebuild(struct ice_pf *pf)
5164{
5165 struct device *dev = &pf->pdev->dev;
5166 struct ice_hw *hw = &pf->hw;
5167 enum ice_status ret;
5168 int err;
5169
5170 if (test_bit(__ICE_DOWN, pf->state))
5171 goto clear_recovery;
5172
5173 dev_dbg(dev, "rebuilding pf\n");
5174
5175 ret = ice_init_all_ctrlq(hw);
5176 if (ret) {
5177 dev_err(dev, "control queues init failed %d\n", ret);
5178 goto fail_reset;
5179 }
5180
5181 ret = ice_clear_pf_cfg(hw);
5182 if (ret) {
5183 dev_err(dev, "clear PF configuration failed %d\n", ret);
5184 goto fail_reset;
5185 }
5186
5187 ice_clear_pxe_mode(hw);
5188
5189 ret = ice_get_caps(hw);
5190 if (ret) {
5191 dev_err(dev, "ice_get_caps failed %d\n", ret);
5192 goto fail_reset;
5193 }
5194
5195 /* basic nic switch setup */
5196 err = ice_setup_pf_sw(pf);
5197 if (err) {
5198 dev_err(dev, "ice_setup_pf_sw failed\n");
5199 goto fail_reset;
5200 }
5201
5202 /* start misc vector */
5203 if (test_bit(ICE_FLAG_MSIX_ENA, pf->flags)) {
5204 err = ice_req_irq_msix_misc(pf);
5205 if (err) {
5206 dev_err(dev, "misc vector setup failed: %d\n", err);
5207 goto fail_reset;
5208 }
5209 }
5210
5211 /* restart the VSIs that were rebuilt and running before the reset */
5212 ice_pf_ena_all_vsi(pf);
5213
5214 return;
5215
5216fail_reset:
5217 ice_shutdown_all_ctrlq(hw);
5218 set_bit(__ICE_RESET_FAILED, pf->state);
5219clear_recovery:
5220 set_bit(__ICE_RESET_RECOVERY_PENDING, pf->state);
5221}
5222
5223/**
5224 * ice_change_mtu - NDO callback to change the MTU
5225 * @netdev: network interface device structure
5226 * @new_mtu: new value for maximum frame size
5227 *
5228 * Returns 0 on success, negative on failure
5229 */
5230static int ice_change_mtu(struct net_device *netdev, int new_mtu)
5231{
5232 struct ice_netdev_priv *np = netdev_priv(netdev);
5233 struct ice_vsi *vsi = np->vsi;
5234 struct ice_pf *pf = vsi->back;
5235 u8 count = 0;
5236
5237 if (new_mtu == netdev->mtu) {
5238 netdev_warn(netdev, "mtu is already %d\n", netdev->mtu);
5239 return 0;
5240 }
5241
5242 if (new_mtu < netdev->min_mtu) {
5243 netdev_err(netdev, "new mtu invalid. min_mtu is %d\n",
5244 netdev->min_mtu);
5245 return -EINVAL;
5246 } else if (new_mtu > netdev->max_mtu) {
5247 netdev_err(netdev, "new mtu invalid. max_mtu is %d\n",
5248 netdev->min_mtu);
5249 return -EINVAL;
5250 }
5251 /* if a reset is in progress, wait for some time for it to complete */
5252 do {
5253 if (ice_is_reset_recovery_pending(pf->state)) {
5254 count++;
5255 usleep_range(1000, 2000);
5256 } else {
5257 break;
5258 }
5259
5260 } while (count < 100);
5261
5262 if (count == 100) {
5263 netdev_err(netdev, "can't change mtu. Device is busy\n");
5264 return -EBUSY;
5265 }
5266
5267 netdev->mtu = new_mtu;
5268
5269 /* if VSI is up, bring it down and then back up */
5270 if (!test_and_set_bit(__ICE_DOWN, vsi->state)) {
5271 int err;
5272
5273 err = ice_down(vsi);
5274 if (err) {
5275 netdev_err(netdev, "change mtu if_up err %d\n", err);
5276 return err;
5277 }
5278
5279 err = ice_up(vsi);
5280 if (err) {
5281 netdev_err(netdev, "change mtu if_up err %d\n", err);
5282 return err;
5283 }
5284 }
5285
5286 netdev_dbg(netdev, "changed mtu to %d\n", new_mtu);
5287 return 0;
5288}
5289
5290/**
5291 * ice_set_rss - Set RSS keys and lut
5292 * @vsi: Pointer to VSI structure
5293 * @seed: RSS hash seed
5294 * @lut: Lookup table
5295 * @lut_size: Lookup table size
5296 *
5297 * Returns 0 on success, negative on failure
5298 */
5299int ice_set_rss(struct ice_vsi *vsi, u8 *seed, u8 *lut, u16 lut_size)
5300{
5301 struct ice_pf *pf = vsi->back;
5302 struct ice_hw *hw = &pf->hw;
5303 enum ice_status status;
5304
5305 if (seed) {
5306 struct ice_aqc_get_set_rss_keys *buf =
5307 (struct ice_aqc_get_set_rss_keys *)seed;
5308
5309 status = ice_aq_set_rss_key(hw, vsi->vsi_num, buf);
5310
5311 if (status) {
5312 dev_err(&pf->pdev->dev,
5313 "Cannot set RSS key, err %d aq_err %d\n",
5314 status, hw->adminq.rq_last_status);
5315 return -EIO;
5316 }
5317 }
5318
5319 if (lut) {
5320 status = ice_aq_set_rss_lut(hw, vsi->vsi_num,
5321 vsi->rss_lut_type, lut, lut_size);
5322 if (status) {
5323 dev_err(&pf->pdev->dev,
5324 "Cannot set RSS lut, err %d aq_err %d\n",
5325 status, hw->adminq.rq_last_status);
5326 return -EIO;
5327 }
5328 }
5329
5330 return 0;
5331}
5332
5333/**
5334 * ice_get_rss - Get RSS keys and lut
5335 * @vsi: Pointer to VSI structure
5336 * @seed: Buffer to store the keys
5337 * @lut: Buffer to store the lookup table entries
5338 * @lut_size: Size of buffer to store the lookup table entries
5339 *
5340 * Returns 0 on success, negative on failure
5341 */
5342int ice_get_rss(struct ice_vsi *vsi, u8 *seed, u8 *lut, u16 lut_size)
5343{
5344 struct ice_pf *pf = vsi->back;
5345 struct ice_hw *hw = &pf->hw;
5346 enum ice_status status;
5347
5348 if (seed) {
5349 struct ice_aqc_get_set_rss_keys *buf =
5350 (struct ice_aqc_get_set_rss_keys *)seed;
5351
5352 status = ice_aq_get_rss_key(hw, vsi->vsi_num, buf);
5353 if (status) {
5354 dev_err(&pf->pdev->dev,
5355 "Cannot get RSS key, err %d aq_err %d\n",
5356 status, hw->adminq.rq_last_status);
5357 return -EIO;
5358 }
5359 }
5360
5361 if (lut) {
5362 status = ice_aq_get_rss_lut(hw, vsi->vsi_num,
5363 vsi->rss_lut_type, lut, lut_size);
5364 if (status) {
5365 dev_err(&pf->pdev->dev,
5366 "Cannot get RSS lut, err %d aq_err %d\n",
5367 status, hw->adminq.rq_last_status);
5368 return -EIO;
5369 }
5370 }
5371
5372 return 0;
5373}
5374
5375/**
5376 * ice_open - Called when a network interface becomes active
5377 * @netdev: network interface device structure
5378 *
5379 * The open entry point is called when a network interface is made
5380 * active by the system (IFF_UP). At this point all resources needed
5381 * for transmit and receive operations are allocated, the interrupt
5382 * handler is registered with the OS, the netdev watchdog is enabled,
5383 * and the stack is notified that the interface is ready.
5384 *
5385 * Returns 0 on success, negative value on failure
5386 */
5387static int ice_open(struct net_device *netdev)
5388{
5389 struct ice_netdev_priv *np = netdev_priv(netdev);
5390 struct ice_vsi *vsi = np->vsi;
5391 int err;
5392
5393 netif_carrier_off(netdev);
5394
5395 err = ice_vsi_open(vsi);
5396
5397 if (err)
5398 netdev_err(netdev, "Failed to open VSI 0x%04X on switch 0x%04X\n",
5399 vsi->vsi_num, vsi->vsw->sw_id);
5400 return err;
5401}
5402
5403/**
5404 * ice_stop - Disables a network interface
5405 * @netdev: network interface device structure
5406 *
5407 * The stop entry point is called when an interface is de-activated by the OS,
5408 * and the netdevice enters the DOWN state. The hardware is still under the
5409 * driver's control, but the netdev interface is disabled.
5410 *
5411 * Returns success only - not allowed to fail
5412 */
5413static int ice_stop(struct net_device *netdev)
5414{
5415 struct ice_netdev_priv *np = netdev_priv(netdev);
5416 struct ice_vsi *vsi = np->vsi;
5417
5418 ice_vsi_close(vsi);
5419
5420 return 0;
5421}
5422
5423/**
5424 * ice_features_check - Validate encapsulated packet conforms to limits
5425 * @skb: skb buffer
5426 * @netdev: This port's netdev
5427 * @features: Offload features that the stack believes apply
5428 */
5429static netdev_features_t
5430ice_features_check(struct sk_buff *skb,
5431 struct net_device __always_unused *netdev,
5432 netdev_features_t features)
5433{
5434 size_t len;
5435
5436 /* No point in doing any of this if neither checksum nor GSO are
5437 * being requested for this frame. We can rule out both by just
5438 * checking for CHECKSUM_PARTIAL
5439 */
5440 if (skb->ip_summed != CHECKSUM_PARTIAL)
5441 return features;
5442
5443 /* We cannot support GSO if the MSS is going to be less than
5444 * 64 bytes. If it is then we need to drop support for GSO.
5445 */
5446 if (skb_is_gso(skb) && (skb_shinfo(skb)->gso_size < 64))
5447 features &= ~NETIF_F_GSO_MASK;
5448
5449 len = skb_network_header(skb) - skb->data;
5450 if (len & ~(ICE_TXD_MACLEN_MAX))
5451 goto out_rm_features;
5452
5453 len = skb_transport_header(skb) - skb_network_header(skb);
5454 if (len & ~(ICE_TXD_IPLEN_MAX))
5455 goto out_rm_features;
5456
5457 if (skb->encapsulation) {
5458 len = skb_inner_network_header(skb) - skb_transport_header(skb);
5459 if (len & ~(ICE_TXD_L4LEN_MAX))
5460 goto out_rm_features;
5461
5462 len = skb_inner_transport_header(skb) -
5463 skb_inner_network_header(skb);
5464 if (len & ~(ICE_TXD_IPLEN_MAX))
5465 goto out_rm_features;
5466 }
5467
5468 return features;
5469out_rm_features:
5470 return features & ~(NETIF_F_CSUM_MASK | NETIF_F_GSO_MASK);
5471}
5472
5473static const struct net_device_ops ice_netdev_ops = {
5474 .ndo_open = ice_open,
5475 .ndo_stop = ice_stop,
5476 .ndo_start_xmit = ice_start_xmit,
5477 .ndo_features_check = ice_features_check,
5478 .ndo_set_rx_mode = ice_set_rx_mode,
5479 .ndo_set_mac_address = ice_set_mac_address,
5480 .ndo_validate_addr = eth_validate_addr,
5481 .ndo_change_mtu = ice_change_mtu,
5482 .ndo_get_stats64 = ice_get_stats64,
5483#ifdef CONFIG_NET_POLL_CONTROLLER
5484 .ndo_poll_controller = ice_netpoll,
5485#endif /* CONFIG_NET_POLL_CONTROLLER */
5486 .ndo_vlan_rx_add_vid = ice_vlan_rx_add_vid,
5487 .ndo_vlan_rx_kill_vid = ice_vlan_rx_kill_vid,
5488 .ndo_set_features = ice_set_features,
5489 .ndo_fdb_add = ice_fdb_add,
5490 .ndo_fdb_del = ice_fdb_del,
5491};