1 // SPDX-License-Identifier: GPL-2.0-only
3 * aQuantia Corporation Network Driver
4 * Copyright (C) 2014-2019 aQuantia Corporation. All rights reserved
7 /* File aq_nic.c: Definition of common code for NIC. */
13 #include "aq_pci_func.h"
17 #include "aq_filters.h"
19 #include <linux/moduleparam.h>
20 #include <linux/netdevice.h>
21 #include <linux/etherdevice.h>
22 #include <linux/timer.h>
23 #include <linux/cpu.h>
25 #include <linux/tcp.h>
28 static unsigned int aq_itr = AQ_CFG_INTERRUPT_MODERATION_AUTO;
29 module_param_named(aq_itr, aq_itr, uint, 0644);
30 MODULE_PARM_DESC(aq_itr, "Interrupt throttling mode");
32 static unsigned int aq_itr_tx;
33 module_param_named(aq_itr_tx, aq_itr_tx, uint, 0644);
34 MODULE_PARM_DESC(aq_itr_tx, "TX interrupt throttle rate");
36 static unsigned int aq_itr_rx;
37 module_param_named(aq_itr_rx, aq_itr_rx, uint, 0644);
38 MODULE_PARM_DESC(aq_itr_rx, "RX interrupt throttle rate");
40 static void aq_nic_update_ndev_stats(struct aq_nic_s *self);
42 static void aq_nic_rss_init(struct aq_nic_s *self, unsigned int num_rss_queues)
44 static u8 rss_key[AQ_CFG_RSS_HASHKEY_SIZE] = {
45 0x1e, 0xad, 0x71, 0x87, 0x65, 0xfc, 0x26, 0x7d,
46 0x0d, 0x45, 0x67, 0x74, 0xcd, 0x06, 0x1a, 0x18,
47 0xb6, 0xc1, 0xf0, 0xc7, 0xbb, 0x18, 0xbe, 0xf8,
48 0x19, 0x13, 0x4b, 0xa9, 0xd0, 0x3e, 0xfe, 0x70,
49 0x25, 0x03, 0xab, 0x50, 0x6a, 0x8b, 0x82, 0x0c
51 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg;
52 struct aq_rss_parameters *rss_params;
55 rss_params = &cfg->aq_rss;
57 rss_params->hash_secret_key_size = sizeof(rss_key);
58 memcpy(rss_params->hash_secret_key, rss_key, sizeof(rss_key));
59 rss_params->indirection_table_size = AQ_CFG_RSS_INDIRECTION_TABLE_MAX;
61 for (i = rss_params->indirection_table_size; i--;)
62 rss_params->indirection_table[i] = i & (num_rss_queues - 1);
65 /* Checks hw_caps and 'corrects' aq_nic_cfg in runtime */
66 void aq_nic_cfg_start(struct aq_nic_s *self)
68 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg;
70 cfg->tcs = AQ_CFG_TCS_DEF;
72 cfg->is_polling = AQ_CFG_IS_POLLING_DEF;
75 cfg->tx_itr = aq_itr_tx;
76 cfg->rx_itr = aq_itr_rx;
78 cfg->rxpageorder = AQ_CFG_RX_PAGEORDER;
79 cfg->is_rss = AQ_CFG_IS_RSS_DEF;
80 cfg->num_rss_queues = AQ_CFG_NUM_RSS_QUEUES_DEF;
81 cfg->aq_rss.base_cpu_number = AQ_CFG_RSS_BASE_CPU_NUM_DEF;
82 cfg->fc.req = AQ_CFG_FC_MODE;
83 cfg->wol = AQ_CFG_WOL_MODES;
85 cfg->mtu = AQ_CFG_MTU_DEF;
86 cfg->link_speed_msk = AQ_CFG_SPEED_MSK;
87 cfg->is_autoneg = AQ_CFG_IS_AUTONEG_DEF;
89 cfg->is_lro = AQ_CFG_IS_LRO_DEF;
92 cfg->rxds = min(cfg->aq_hw_caps->rxds_max, AQ_CFG_RXDS_DEF);
93 cfg->txds = min(cfg->aq_hw_caps->txds_max, AQ_CFG_TXDS_DEF);
96 cfg->vecs = min(cfg->aq_hw_caps->vecs, AQ_CFG_VECS_DEF);
97 cfg->vecs = min(cfg->vecs, num_online_cpus());
98 if (self->irqvecs > AQ_HW_SERVICE_IRQS)
99 cfg->vecs = min(cfg->vecs, self->irqvecs - AQ_HW_SERVICE_IRQS);
100 /* cfg->vecs should be power of 2 for RSS */
103 else if (cfg->vecs >= 4U)
105 else if (cfg->vecs >= 2U)
110 cfg->num_rss_queues = min(cfg->vecs, AQ_CFG_NUM_RSS_QUEUES_DEF);
112 aq_nic_rss_init(self, cfg->num_rss_queues);
114 cfg->irq_type = aq_pci_func_get_irq_type(self);
116 if ((cfg->irq_type == AQ_HW_IRQ_LEGACY) ||
117 (cfg->aq_hw_caps->vecs == 1U) ||
123 /* Check if we have enough vectors allocated for
124 * link status IRQ. If no - we'll know link state from
125 * slower service task.
127 if (AQ_HW_SERVICE_IRQS > 0 && cfg->vecs + 1 <= self->irqvecs)
128 cfg->link_irq_vec = cfg->vecs;
130 cfg->link_irq_vec = 0;
132 cfg->link_speed_msk &= cfg->aq_hw_caps->link_speed_msk;
133 cfg->features = cfg->aq_hw_caps->hw_features;
134 cfg->is_vlan_rx_strip = !!(cfg->features & NETIF_F_HW_VLAN_CTAG_RX);
135 cfg->is_vlan_tx_insert = !!(cfg->features & NETIF_F_HW_VLAN_CTAG_TX);
136 cfg->is_vlan_force_promisc = true;
139 static int aq_nic_update_link_status(struct aq_nic_s *self)
141 int err = self->aq_fw_ops->update_link_status(self->aq_hw);
147 if (self->aq_fw_ops->get_flow_control)
148 self->aq_fw_ops->get_flow_control(self->aq_hw, &fc);
149 self->aq_nic_cfg.fc.cur = fc;
151 if (self->link_status.mbps != self->aq_hw->aq_link_status.mbps) {
152 netdev_info(self->ndev, "%s: link change old %d new %d\n",
153 AQ_CFG_DRV_NAME, self->link_status.mbps,
154 self->aq_hw->aq_link_status.mbps);
155 aq_nic_update_interrupt_moderation_settings(self);
158 aq_ptp_clock_init(self);
159 aq_ptp_tm_offset_set(self,
160 self->aq_hw->aq_link_status.mbps);
161 aq_ptp_link_change(self);
164 /* Driver has to update flow control settings on RX block
166 * We should query FW whether it negotiated FC.
168 if (self->aq_hw_ops->hw_set_fc)
169 self->aq_hw_ops->hw_set_fc(self->aq_hw, fc, 0);
172 self->link_status = self->aq_hw->aq_link_status;
173 if (!netif_carrier_ok(self->ndev) && self->link_status.mbps) {
174 aq_utils_obj_set(&self->flags,
175 AQ_NIC_FLAG_STARTED);
176 aq_utils_obj_clear(&self->flags,
178 netif_carrier_on(self->ndev);
179 netif_tx_wake_all_queues(self->ndev);
181 if (netif_carrier_ok(self->ndev) && !self->link_status.mbps) {
182 netif_carrier_off(self->ndev);
183 netif_tx_disable(self->ndev);
184 aq_utils_obj_set(&self->flags, AQ_NIC_LINK_DOWN);
190 static irqreturn_t aq_linkstate_threaded_isr(int irq, void *private)
192 struct aq_nic_s *self = private;
197 aq_nic_update_link_status(self);
199 self->aq_hw_ops->hw_irq_enable(self->aq_hw,
200 BIT(self->aq_nic_cfg.link_irq_vec));
205 static void aq_nic_service_task(struct work_struct *work)
207 struct aq_nic_s *self = container_of(work, struct aq_nic_s,
211 aq_ptp_service_task(self);
213 if (aq_utils_obj_test(&self->flags, AQ_NIC_FLAGS_IS_NOT_READY))
216 err = aq_nic_update_link_status(self);
220 mutex_lock(&self->fwreq_mutex);
221 if (self->aq_fw_ops->update_stats)
222 self->aq_fw_ops->update_stats(self->aq_hw);
223 mutex_unlock(&self->fwreq_mutex);
225 aq_nic_update_ndev_stats(self);
228 static void aq_nic_service_timer_cb(struct timer_list *t)
230 struct aq_nic_s *self = from_timer(self, t, service_timer);
232 mod_timer(&self->service_timer,
233 jiffies + AQ_CFG_SERVICE_TIMER_INTERVAL);
235 aq_ndev_schedule_work(&self->service_task);
238 static void aq_nic_polling_timer_cb(struct timer_list *t)
240 struct aq_nic_s *self = from_timer(self, t, polling_timer);
241 struct aq_vec_s *aq_vec = NULL;
244 for (i = 0U, aq_vec = self->aq_vec[0];
245 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i])
246 aq_vec_isr(i, (void *)aq_vec);
248 mod_timer(&self->polling_timer, jiffies +
249 AQ_CFG_POLLING_TIMER_INTERVAL);
252 int aq_nic_ndev_register(struct aq_nic_s *self)
261 err = hw_atl_utils_initfw(self->aq_hw, &self->aq_fw_ops);
265 mutex_lock(&self->fwreq_mutex);
266 err = self->aq_fw_ops->get_mac_permanent(self->aq_hw,
267 self->ndev->dev_addr);
268 mutex_unlock(&self->fwreq_mutex);
272 #if defined(AQ_CFG_MAC_ADDR_PERMANENT)
274 static u8 mac_addr_permanent[] = AQ_CFG_MAC_ADDR_PERMANENT;
276 ether_addr_copy(self->ndev->dev_addr, mac_addr_permanent);
280 for (self->aq_vecs = 0; self->aq_vecs < aq_nic_get_cfg(self)->vecs;
282 self->aq_vec[self->aq_vecs] =
283 aq_vec_alloc(self, self->aq_vecs, aq_nic_get_cfg(self));
284 if (!self->aq_vec[self->aq_vecs]) {
290 netif_carrier_off(self->ndev);
292 netif_tx_disable(self->ndev);
294 err = register_netdev(self->ndev);
302 void aq_nic_ndev_init(struct aq_nic_s *self)
304 const struct aq_hw_caps_s *aq_hw_caps = self->aq_nic_cfg.aq_hw_caps;
305 struct aq_nic_cfg_s *aq_nic_cfg = &self->aq_nic_cfg;
307 self->ndev->hw_features |= aq_hw_caps->hw_features;
308 self->ndev->features = aq_hw_caps->hw_features;
309 self->ndev->vlan_features |= NETIF_F_HW_CSUM | NETIF_F_RXCSUM |
310 NETIF_F_RXHASH | NETIF_F_SG |
311 NETIF_F_LRO | NETIF_F_TSO;
312 self->ndev->gso_partial_features = NETIF_F_GSO_UDP_L4;
313 self->ndev->priv_flags = aq_hw_caps->hw_priv_flags;
314 self->ndev->priv_flags |= IFF_LIVE_ADDR_CHANGE;
316 self->msg_enable = NETIF_MSG_DRV | NETIF_MSG_LINK;
317 self->ndev->mtu = aq_nic_cfg->mtu - ETH_HLEN;
318 self->ndev->max_mtu = aq_hw_caps->mtu - ETH_FCS_LEN - ETH_HLEN;
322 void aq_nic_set_tx_ring(struct aq_nic_s *self, unsigned int idx,
323 struct aq_ring_s *ring)
325 self->aq_ring_tx[idx] = ring;
328 struct net_device *aq_nic_get_ndev(struct aq_nic_s *self)
333 int aq_nic_init(struct aq_nic_s *self)
335 struct aq_vec_s *aq_vec = NULL;
339 self->power_state = AQ_HW_POWER_STATE_D0;
340 mutex_lock(&self->fwreq_mutex);
341 err = self->aq_hw_ops->hw_reset(self->aq_hw);
342 mutex_unlock(&self->fwreq_mutex);
346 err = self->aq_hw_ops->hw_init(self->aq_hw,
347 aq_nic_get_ndev(self)->dev_addr);
351 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_TP) {
352 self->aq_hw->phy_id = HW_ATL_PHY_ID_MAX;
353 err = aq_phy_init(self->aq_hw);
356 for (i = 0U, aq_vec = self->aq_vec[0];
357 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i])
358 aq_vec_init(aq_vec, self->aq_hw_ops, self->aq_hw);
360 err = aq_ptp_init(self, self->irqvecs - 1);
364 err = aq_ptp_ring_alloc(self);
368 err = aq_ptp_ring_init(self);
372 netif_carrier_off(self->ndev);
378 int aq_nic_start(struct aq_nic_s *self)
380 struct aq_vec_s *aq_vec = NULL;
384 err = self->aq_hw_ops->hw_multicast_list_set(self->aq_hw,
386 self->mc_list.count);
390 err = self->aq_hw_ops->hw_packet_filter_set(self->aq_hw,
391 self->packet_filter);
395 for (i = 0U, aq_vec = self->aq_vec[0];
396 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) {
397 err = aq_vec_start(aq_vec);
402 err = aq_ptp_ring_start(self);
406 aq_nic_set_loopback(self);
408 err = self->aq_hw_ops->hw_start(self->aq_hw);
412 err = aq_nic_update_interrupt_moderation_settings(self);
416 INIT_WORK(&self->service_task, aq_nic_service_task);
418 timer_setup(&self->service_timer, aq_nic_service_timer_cb, 0);
419 aq_nic_service_timer_cb(&self->service_timer);
421 if (self->aq_nic_cfg.is_polling) {
422 timer_setup(&self->polling_timer, aq_nic_polling_timer_cb, 0);
423 mod_timer(&self->polling_timer, jiffies +
424 AQ_CFG_POLLING_TIMER_INTERVAL);
426 for (i = 0U, aq_vec = self->aq_vec[0];
427 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) {
428 err = aq_pci_func_alloc_irq(self, i, self->ndev->name,
430 aq_vec_get_affinity_mask(aq_vec));
435 err = aq_ptp_irq_alloc(self);
439 if (self->aq_nic_cfg.link_irq_vec) {
440 int irqvec = pci_irq_vector(self->pdev,
441 self->aq_nic_cfg.link_irq_vec);
442 err = request_threaded_irq(irqvec, NULL,
443 aq_linkstate_threaded_isr,
444 IRQF_SHARED | IRQF_ONESHOT,
445 self->ndev->name, self);
448 self->msix_entry_mask |= (1 << self->aq_nic_cfg.link_irq_vec);
451 err = self->aq_hw_ops->hw_irq_enable(self->aq_hw,
457 err = netif_set_real_num_tx_queues(self->ndev, self->aq_vecs);
461 err = netif_set_real_num_rx_queues(self->ndev, self->aq_vecs);
465 netif_tx_start_all_queues(self->ndev);
471 unsigned int aq_nic_map_skb(struct aq_nic_s *self, struct sk_buff *skb,
472 struct aq_ring_s *ring)
474 unsigned int nr_frags = skb_shinfo(skb)->nr_frags;
475 struct aq_ring_buff_s *first = NULL;
476 u8 ipver = ip_hdr(skb)->version;
477 struct aq_ring_buff_s *dx_buff;
478 bool need_context_tag = false;
479 unsigned int frag_count = 0U;
480 unsigned int ret = 0U;
485 l4proto = ip_hdr(skb)->protocol;
487 l4proto = ipv6_hdr(skb)->nexthdr;
490 dx_buff = &ring->buff_ring[dx];
493 if (unlikely(skb_is_gso(skb))) {
494 dx_buff->mss = skb_shinfo(skb)->gso_size;
495 if (l4proto == IPPROTO_TCP) {
496 dx_buff->is_gso_tcp = 1U;
497 dx_buff->len_l4 = tcp_hdrlen(skb);
498 } else if (l4proto == IPPROTO_UDP) {
499 dx_buff->is_gso_udp = 1U;
500 dx_buff->len_l4 = sizeof(struct udphdr);
501 /* UDP GSO Hardware does not replace packet length. */
502 udp_hdr(skb)->len = htons(dx_buff->mss +
505 WARN_ONCE(true, "Bad GSO mode");
508 dx_buff->len_pkt = skb->len;
509 dx_buff->len_l2 = ETH_HLEN;
510 dx_buff->len_l3 = skb_network_header_len(skb);
511 dx_buff->eop_index = 0xffffU;
512 dx_buff->is_ipv6 = (ipver == 6);
513 need_context_tag = true;
516 if (self->aq_nic_cfg.is_vlan_tx_insert && skb_vlan_tag_present(skb)) {
517 dx_buff->vlan_tx_tag = skb_vlan_tag_get(skb);
518 dx_buff->len_pkt = skb->len;
519 dx_buff->is_vlan = 1U;
520 need_context_tag = true;
523 if (need_context_tag) {
524 dx = aq_ring_next_dx(ring, dx);
525 dx_buff = &ring->buff_ring[dx];
530 dx_buff->len = skb_headlen(skb);
531 dx_buff->pa = dma_map_single(aq_nic_get_dev(self),
536 if (unlikely(dma_mapping_error(aq_nic_get_dev(self), dx_buff->pa))) {
542 dx_buff->len_pkt = skb->len;
543 dx_buff->is_sop = 1U;
544 dx_buff->is_mapped = 1U;
547 if (skb->ip_summed == CHECKSUM_PARTIAL) {
548 dx_buff->is_ip_cso = (htons(ETH_P_IP) == skb->protocol);
549 dx_buff->is_tcp_cso = (l4proto == IPPROTO_TCP);
550 dx_buff->is_udp_cso = (l4proto == IPPROTO_UDP);
553 for (; nr_frags--; ++frag_count) {
554 unsigned int frag_len = 0U;
555 unsigned int buff_offset = 0U;
556 unsigned int buff_size = 0U;
558 skb_frag_t *frag = &skb_shinfo(skb)->frags[frag_count];
560 frag_len = skb_frag_size(frag);
563 if (frag_len > AQ_CFG_TX_FRAME_MAX)
564 buff_size = AQ_CFG_TX_FRAME_MAX;
566 buff_size = frag_len;
568 frag_pa = skb_frag_dma_map(aq_nic_get_dev(self),
574 if (unlikely(dma_mapping_error(aq_nic_get_dev(self),
578 dx = aq_ring_next_dx(ring, dx);
579 dx_buff = &ring->buff_ring[dx];
582 dx_buff->len = buff_size;
583 dx_buff->pa = frag_pa;
584 dx_buff->is_mapped = 1U;
585 dx_buff->eop_index = 0xffffU;
587 frag_len -= buff_size;
588 buff_offset += buff_size;
594 first->eop_index = dx;
595 dx_buff->is_eop = 1U;
600 for (dx = ring->sw_tail;
602 --ret, dx = aq_ring_next_dx(ring, dx)) {
603 dx_buff = &ring->buff_ring[dx];
605 if (!(dx_buff->is_gso_tcp || dx_buff->is_gso_udp) &&
606 !dx_buff->is_vlan && dx_buff->pa) {
607 if (unlikely(dx_buff->is_sop)) {
608 dma_unmap_single(aq_nic_get_dev(self),
613 dma_unmap_page(aq_nic_get_dev(self),
625 int aq_nic_xmit(struct aq_nic_s *self, struct sk_buff *skb)
627 unsigned int vec = skb->queue_mapping % self->aq_nic_cfg.vecs;
628 struct aq_ring_s *ring = NULL;
629 unsigned int frags = 0U;
630 int err = NETDEV_TX_OK;
631 unsigned int tc = 0U;
633 frags = skb_shinfo(skb)->nr_frags + 1;
635 ring = self->aq_ring_tx[AQ_NIC_TCVEC2RING(self, tc, vec)];
637 if (frags > AQ_CFG_SKB_FRAGS_MAX) {
638 dev_kfree_skb_any(skb);
642 aq_ring_update_queue_state(ring);
644 if (self->aq_nic_cfg.priv_flags & BIT(AQ_HW_LOOPBACK_DMA_NET)) {
645 err = NETDEV_TX_BUSY;
649 /* Above status update may stop the queue. Check this. */
650 if (__netif_subqueue_stopped(self->ndev, ring->idx)) {
651 err = NETDEV_TX_BUSY;
655 frags = aq_nic_map_skb(self, skb, ring);
658 err = self->aq_hw_ops->hw_ring_tx_xmit(self->aq_hw,
661 err = NETDEV_TX_BUSY;
668 int aq_nic_update_interrupt_moderation_settings(struct aq_nic_s *self)
670 return self->aq_hw_ops->hw_interrupt_moderation_set(self->aq_hw);
673 int aq_nic_set_packet_filter(struct aq_nic_s *self, unsigned int flags)
677 err = self->aq_hw_ops->hw_packet_filter_set(self->aq_hw, flags);
681 self->packet_filter = flags;
687 int aq_nic_set_multicast_list(struct aq_nic_s *self, struct net_device *ndev)
689 const struct aq_hw_ops *hw_ops = self->aq_hw_ops;
690 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg;
691 unsigned int packet_filter = ndev->flags;
692 struct netdev_hw_addr *ha = NULL;
696 self->mc_list.count = 0;
697 if (netdev_uc_count(ndev) > AQ_HW_MULTICAST_ADDRESS_MAX) {
698 packet_filter |= IFF_PROMISC;
700 netdev_for_each_uc_addr(ha, ndev) {
701 ether_addr_copy(self->mc_list.ar[i++], ha->addr);
705 cfg->is_mc_list_enabled = !!(packet_filter & IFF_MULTICAST);
706 if (cfg->is_mc_list_enabled) {
707 if (i + netdev_mc_count(ndev) > AQ_HW_MULTICAST_ADDRESS_MAX) {
708 packet_filter |= IFF_ALLMULTI;
710 netdev_for_each_mc_addr(ha, ndev) {
711 ether_addr_copy(self->mc_list.ar[i++],
717 if (i > 0 && i <= AQ_HW_MULTICAST_ADDRESS_MAX) {
718 self->mc_list.count = i;
719 err = hw_ops->hw_multicast_list_set(self->aq_hw,
721 self->mc_list.count);
726 return aq_nic_set_packet_filter(self, packet_filter);
729 int aq_nic_set_mtu(struct aq_nic_s *self, int new_mtu)
731 self->aq_nic_cfg.mtu = new_mtu;
736 int aq_nic_set_mac(struct aq_nic_s *self, struct net_device *ndev)
738 return self->aq_hw_ops->hw_set_mac_address(self->aq_hw, ndev->dev_addr);
741 unsigned int aq_nic_get_link_speed(struct aq_nic_s *self)
743 return self->link_status.mbps;
746 int aq_nic_get_regs(struct aq_nic_s *self, struct ethtool_regs *regs, void *p)
753 err = self->aq_hw_ops->hw_get_regs(self->aq_hw,
754 self->aq_nic_cfg.aq_hw_caps,
763 int aq_nic_get_regs_count(struct aq_nic_s *self)
765 return self->aq_nic_cfg.aq_hw_caps->mac_regs_count;
768 void aq_nic_get_stats(struct aq_nic_s *self, u64 *data)
770 struct aq_vec_s *aq_vec = NULL;
771 struct aq_stats_s *stats;
772 unsigned int count = 0U;
775 if (self->aq_fw_ops->update_stats) {
776 mutex_lock(&self->fwreq_mutex);
777 self->aq_fw_ops->update_stats(self->aq_hw);
778 mutex_unlock(&self->fwreq_mutex);
780 stats = self->aq_hw_ops->hw_get_hw_stats(self->aq_hw);
785 data[i] = stats->uprc + stats->mprc + stats->bprc;
786 data[++i] = stats->uprc;
787 data[++i] = stats->mprc;
788 data[++i] = stats->bprc;
789 data[++i] = stats->erpt;
790 data[++i] = stats->uptc + stats->mptc + stats->bptc;
791 data[++i] = stats->uptc;
792 data[++i] = stats->mptc;
793 data[++i] = stats->bptc;
794 data[++i] = stats->ubrc;
795 data[++i] = stats->ubtc;
796 data[++i] = stats->mbrc;
797 data[++i] = stats->mbtc;
798 data[++i] = stats->bbrc;
799 data[++i] = stats->bbtc;
800 data[++i] = stats->ubrc + stats->mbrc + stats->bbrc;
801 data[++i] = stats->ubtc + stats->mbtc + stats->bbtc;
802 data[++i] = stats->dma_pkt_rc;
803 data[++i] = stats->dma_pkt_tc;
804 data[++i] = stats->dma_oct_rc;
805 data[++i] = stats->dma_oct_tc;
806 data[++i] = stats->dpc;
812 for (i = 0U, aq_vec = self->aq_vec[0];
813 aq_vec && self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i]) {
815 aq_vec_get_sw_stats(aq_vec, data, &count);
821 static void aq_nic_update_ndev_stats(struct aq_nic_s *self)
823 struct aq_stats_s *stats = self->aq_hw_ops->hw_get_hw_stats(self->aq_hw);
824 struct net_device *ndev = self->ndev;
826 ndev->stats.rx_packets = stats->dma_pkt_rc;
827 ndev->stats.rx_bytes = stats->dma_oct_rc;
828 ndev->stats.rx_errors = stats->erpr;
829 ndev->stats.rx_dropped = stats->dpc;
830 ndev->stats.tx_packets = stats->dma_pkt_tc;
831 ndev->stats.tx_bytes = stats->dma_oct_tc;
832 ndev->stats.tx_errors = stats->erpt;
833 ndev->stats.multicast = stats->mprc;
836 void aq_nic_get_link_ksettings(struct aq_nic_s *self,
837 struct ethtool_link_ksettings *cmd)
839 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE)
840 cmd->base.port = PORT_FIBRE;
842 cmd->base.port = PORT_TP;
843 /* This driver supports only 10G capable adapters, so DUPLEX_FULL */
844 cmd->base.duplex = DUPLEX_FULL;
845 cmd->base.autoneg = self->aq_nic_cfg.is_autoneg;
847 ethtool_link_ksettings_zero_link_mode(cmd, supported);
849 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_10G)
850 ethtool_link_ksettings_add_link_mode(cmd, supported,
853 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_5G)
854 ethtool_link_ksettings_add_link_mode(cmd, supported,
857 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_2GS)
858 ethtool_link_ksettings_add_link_mode(cmd, supported,
861 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_1G)
862 ethtool_link_ksettings_add_link_mode(cmd, supported,
865 if (self->aq_nic_cfg.aq_hw_caps->link_speed_msk & AQ_NIC_RATE_100M)
866 ethtool_link_ksettings_add_link_mode(cmd, supported,
869 if (self->aq_nic_cfg.aq_hw_caps->flow_control) {
870 ethtool_link_ksettings_add_link_mode(cmd, supported,
872 ethtool_link_ksettings_add_link_mode(cmd, supported,
876 ethtool_link_ksettings_add_link_mode(cmd, supported, Autoneg);
878 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE)
879 ethtool_link_ksettings_add_link_mode(cmd, supported, FIBRE);
881 ethtool_link_ksettings_add_link_mode(cmd, supported, TP);
883 ethtool_link_ksettings_zero_link_mode(cmd, advertising);
885 if (self->aq_nic_cfg.is_autoneg)
886 ethtool_link_ksettings_add_link_mode(cmd, advertising, Autoneg);
888 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_10G)
889 ethtool_link_ksettings_add_link_mode(cmd, advertising,
892 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_5G)
893 ethtool_link_ksettings_add_link_mode(cmd, advertising,
896 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_2GS)
897 ethtool_link_ksettings_add_link_mode(cmd, advertising,
900 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_1G)
901 ethtool_link_ksettings_add_link_mode(cmd, advertising,
904 if (self->aq_nic_cfg.link_speed_msk & AQ_NIC_RATE_100M)
905 ethtool_link_ksettings_add_link_mode(cmd, advertising,
908 if (self->aq_nic_cfg.fc.cur & AQ_NIC_FC_RX)
909 ethtool_link_ksettings_add_link_mode(cmd, advertising,
912 /* Asym is when either RX or TX, but not both */
913 if (!!(self->aq_nic_cfg.fc.cur & AQ_NIC_FC_TX) ^
914 !!(self->aq_nic_cfg.fc.cur & AQ_NIC_FC_RX))
915 ethtool_link_ksettings_add_link_mode(cmd, advertising,
918 if (self->aq_nic_cfg.aq_hw_caps->media_type == AQ_HW_MEDIA_TYPE_FIBRE)
919 ethtool_link_ksettings_add_link_mode(cmd, advertising, FIBRE);
921 ethtool_link_ksettings_add_link_mode(cmd, advertising, TP);
924 int aq_nic_set_link_ksettings(struct aq_nic_s *self,
925 const struct ethtool_link_ksettings *cmd)
931 if (cmd->base.autoneg == AUTONEG_ENABLE) {
932 rate = self->aq_nic_cfg.aq_hw_caps->link_speed_msk;
933 self->aq_nic_cfg.is_autoneg = true;
935 speed = cmd->base.speed;
939 rate = AQ_NIC_RATE_100M;
943 rate = AQ_NIC_RATE_1G;
947 rate = AQ_NIC_RATE_2GS;
951 rate = AQ_NIC_RATE_5G;
955 rate = AQ_NIC_RATE_10G;
963 if (!(self->aq_nic_cfg.aq_hw_caps->link_speed_msk & rate)) {
968 self->aq_nic_cfg.is_autoneg = false;
971 mutex_lock(&self->fwreq_mutex);
972 err = self->aq_fw_ops->set_link_speed(self->aq_hw, rate);
973 mutex_unlock(&self->fwreq_mutex);
977 self->aq_nic_cfg.link_speed_msk = rate;
983 struct aq_nic_cfg_s *aq_nic_get_cfg(struct aq_nic_s *self)
985 return &self->aq_nic_cfg;
988 u32 aq_nic_get_fw_version(struct aq_nic_s *self)
992 self->aq_hw_ops->hw_get_fw_version(self->aq_hw, &fw_version);
997 int aq_nic_set_loopback(struct aq_nic_s *self)
999 struct aq_nic_cfg_s *cfg = &self->aq_nic_cfg;
1001 if (!self->aq_hw_ops->hw_set_loopback ||
1002 !self->aq_fw_ops->set_phyloopback)
1005 mutex_lock(&self->fwreq_mutex);
1006 self->aq_hw_ops->hw_set_loopback(self->aq_hw,
1007 AQ_HW_LOOPBACK_DMA_SYS,
1008 !!(cfg->priv_flags &
1009 BIT(AQ_HW_LOOPBACK_DMA_SYS)));
1011 self->aq_hw_ops->hw_set_loopback(self->aq_hw,
1012 AQ_HW_LOOPBACK_PKT_SYS,
1013 !!(cfg->priv_flags &
1014 BIT(AQ_HW_LOOPBACK_PKT_SYS)));
1016 self->aq_hw_ops->hw_set_loopback(self->aq_hw,
1017 AQ_HW_LOOPBACK_DMA_NET,
1018 !!(cfg->priv_flags &
1019 BIT(AQ_HW_LOOPBACK_DMA_NET)));
1021 self->aq_fw_ops->set_phyloopback(self->aq_hw,
1022 AQ_HW_LOOPBACK_PHYINT_SYS,
1023 !!(cfg->priv_flags &
1024 BIT(AQ_HW_LOOPBACK_PHYINT_SYS)));
1026 self->aq_fw_ops->set_phyloopback(self->aq_hw,
1027 AQ_HW_LOOPBACK_PHYEXT_SYS,
1028 !!(cfg->priv_flags &
1029 BIT(AQ_HW_LOOPBACK_PHYEXT_SYS)));
1030 mutex_unlock(&self->fwreq_mutex);
1035 int aq_nic_stop(struct aq_nic_s *self)
1037 struct aq_vec_s *aq_vec = NULL;
1038 unsigned int i = 0U;
1040 netif_tx_disable(self->ndev);
1041 netif_carrier_off(self->ndev);
1043 del_timer_sync(&self->service_timer);
1044 cancel_work_sync(&self->service_task);
1046 self->aq_hw_ops->hw_irq_disable(self->aq_hw, AQ_CFG_IRQ_MASK);
1048 if (self->aq_nic_cfg.is_polling)
1049 del_timer_sync(&self->polling_timer);
1051 aq_pci_func_free_irqs(self);
1053 aq_ptp_irq_free(self);
1055 for (i = 0U, aq_vec = self->aq_vec[0];
1056 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i])
1057 aq_vec_stop(aq_vec);
1059 aq_ptp_ring_stop(self);
1061 return self->aq_hw_ops->hw_stop(self->aq_hw);
1064 void aq_nic_set_power(struct aq_nic_s *self)
1066 if (self->power_state != AQ_HW_POWER_STATE_D0 ||
1067 self->aq_hw->aq_nic_cfg->wol)
1068 if (likely(self->aq_fw_ops->set_power)) {
1069 mutex_lock(&self->fwreq_mutex);
1070 self->aq_fw_ops->set_power(self->aq_hw,
1072 self->ndev->dev_addr);
1073 mutex_unlock(&self->fwreq_mutex);
1077 void aq_nic_deinit(struct aq_nic_s *self, bool link_down)
1079 struct aq_vec_s *aq_vec = NULL;
1080 unsigned int i = 0U;
1085 for (i = 0U, aq_vec = self->aq_vec[0];
1086 self->aq_vecs > i; ++i, aq_vec = self->aq_vec[i])
1087 aq_vec_deinit(aq_vec);
1089 aq_ptp_unregister(self);
1090 aq_ptp_ring_deinit(self);
1091 aq_ptp_ring_free(self);
1094 if (likely(self->aq_fw_ops->deinit) && link_down) {
1095 mutex_lock(&self->fwreq_mutex);
1096 self->aq_fw_ops->deinit(self->aq_hw);
1097 mutex_unlock(&self->fwreq_mutex);
1103 void aq_nic_free_vectors(struct aq_nic_s *self)
1105 unsigned int i = 0U;
1110 for (i = ARRAY_SIZE(self->aq_vec); i--;) {
1111 if (self->aq_vec[i]) {
1112 aq_vec_free(self->aq_vec[i]);
1113 self->aq_vec[i] = NULL;
1120 void aq_nic_shutdown(struct aq_nic_s *self)
1129 netif_device_detach(self->ndev);
1131 if (netif_running(self->ndev)) {
1132 err = aq_nic_stop(self);
1136 aq_nic_deinit(self, !self->aq_hw->aq_nic_cfg->wol);
1137 aq_nic_set_power(self);
1143 u8 aq_nic_reserve_filter(struct aq_nic_s *self, enum aq_rx_filter_type type)
1150 case aq_rx_filter_ethertype:
1151 location = AQ_RX_LAST_LOC_FETHERT - AQ_RX_FIRST_LOC_FETHERT -
1152 self->aq_hw_rx_fltrs.fet_reserved_count;
1153 self->aq_hw_rx_fltrs.fet_reserved_count++;
1155 case aq_rx_filter_l3l4:
1156 fltr_cnt = AQ_RX_LAST_LOC_FL3L4 - AQ_RX_FIRST_LOC_FL3L4;
1157 n_bit = fltr_cnt - self->aq_hw_rx_fltrs.fl3l4.reserved_count;
1159 self->aq_hw_rx_fltrs.fl3l4.active_ipv4 |= BIT(n_bit);
1160 self->aq_hw_rx_fltrs.fl3l4.reserved_count++;
1170 void aq_nic_release_filter(struct aq_nic_s *self, enum aq_rx_filter_type type,
1174 case aq_rx_filter_ethertype:
1175 self->aq_hw_rx_fltrs.fet_reserved_count--;
1177 case aq_rx_filter_l3l4:
1178 self->aq_hw_rx_fltrs.fl3l4.reserved_count--;
1179 self->aq_hw_rx_fltrs.fl3l4.active_ipv4 &= ~BIT(location);