2 * aQuantia Corporation Network Driver
3 * Copyright (C) 2014-2017 aQuantia Corporation. All rights reserved
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms and conditions of the GNU General Public License,
7 * version 2, as published by the Free Software Foundation.
10 /* File aq_nic.c: Definition of common code for NIC. */
16 #include "aq_pci_func.h"
17 #include "aq_nic_internal.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_rss_init(struct aq_nic_s
*self
, unsigned int num_rss_queues
)
42 struct aq_nic_cfg_s
*cfg
= &self
->aq_nic_cfg
;
43 struct aq_rss_parameters
*rss_params
= &cfg
->aq_rss
;
46 static u8 rss_key
[40] = {
47 0x1e, 0xad, 0x71, 0x87, 0x65, 0xfc, 0x26, 0x7d,
48 0x0d, 0x45, 0x67, 0x74, 0xcd, 0x06, 0x1a, 0x18,
49 0xb6, 0xc1, 0xf0, 0xc7, 0xbb, 0x18, 0xbe, 0xf8,
50 0x19, 0x13, 0x4b, 0xa9, 0xd0, 0x3e, 0xfe, 0x70,
51 0x25, 0x03, 0xab, 0x50, 0x6a, 0x8b, 0x82, 0x0c
54 rss_params
->hash_secret_key_size
= sizeof(rss_key
);
55 memcpy(rss_params
->hash_secret_key
, rss_key
, sizeof(rss_key
));
56 rss_params
->indirection_table_size
= AQ_CFG_RSS_INDIRECTION_TABLE_MAX
;
58 for (i
= rss_params
->indirection_table_size
; i
--;)
59 rss_params
->indirection_table
[i
] = i
& (num_rss_queues
- 1);
62 /* Fills aq_nic_cfg with valid defaults */
63 static void aq_nic_cfg_init_defaults(struct aq_nic_s
*self
)
65 struct aq_nic_cfg_s
*cfg
= &self
->aq_nic_cfg
;
67 cfg
->aq_hw_caps
= &self
->aq_hw_caps
;
69 cfg
->vecs
= AQ_CFG_VECS_DEF
;
70 cfg
->tcs
= AQ_CFG_TCS_DEF
;
72 cfg
->rxds
= AQ_CFG_RXDS_DEF
;
73 cfg
->txds
= AQ_CFG_TXDS_DEF
;
75 cfg
->is_polling
= AQ_CFG_IS_POLLING_DEF
;
78 cfg
->tx_itr
= aq_itr_tx
;
79 cfg
->rx_itr
= aq_itr_rx
;
81 cfg
->is_rss
= AQ_CFG_IS_RSS_DEF
;
82 cfg
->num_rss_queues
= AQ_CFG_NUM_RSS_QUEUES_DEF
;
83 cfg
->aq_rss
.base_cpu_number
= AQ_CFG_RSS_BASE_CPU_NUM_DEF
;
84 cfg
->flow_control
= AQ_CFG_FC_MODE
;
86 cfg
->mtu
= AQ_CFG_MTU_DEF
;
87 cfg
->link_speed_msk
= AQ_CFG_SPEED_MSK
;
88 cfg
->is_autoneg
= AQ_CFG_IS_AUTONEG_DEF
;
90 cfg
->is_lro
= AQ_CFG_IS_LRO_DEF
;
94 aq_nic_rss_init(self
, cfg
->num_rss_queues
);
97 /* Checks hw_caps and 'corrects' aq_nic_cfg in runtime */
98 int aq_nic_cfg_start(struct aq_nic_s
*self
)
100 struct aq_nic_cfg_s
*cfg
= &self
->aq_nic_cfg
;
103 cfg
->rxds
= min(cfg
->rxds
, cfg
->aq_hw_caps
->rxds
);
104 cfg
->txds
= min(cfg
->txds
, cfg
->aq_hw_caps
->txds
);
107 cfg
->vecs
= min(cfg
->vecs
, cfg
->aq_hw_caps
->vecs
);
108 cfg
->vecs
= min(cfg
->vecs
, num_online_cpus());
109 /* cfg->vecs should be power of 2 for RSS */
112 else if (cfg
->vecs
>= 4U)
114 else if (cfg
->vecs
>= 2U)
119 cfg
->num_rss_queues
= min(cfg
->vecs
, AQ_CFG_NUM_RSS_QUEUES_DEF
);
121 cfg
->irq_type
= aq_pci_func_get_irq_type(self
->aq_pci_func
);
123 if ((cfg
->irq_type
== AQ_HW_IRQ_LEGACY
) ||
124 (self
->aq_hw_caps
.vecs
== 1U) ||
130 cfg
->link_speed_msk
&= self
->aq_hw_caps
.link_speed_msk
;
131 cfg
->hw_features
= self
->aq_hw_caps
.hw_features
;
135 static int aq_nic_update_link_status(struct aq_nic_s
*self
)
137 int err
= self
->aq_hw_ops
.hw_get_link_status(self
->aq_hw
);
142 if (self
->link_status
.mbps
!= self
->aq_hw
->aq_link_status
.mbps
) {
143 pr_info("%s: link change old %d new %d\n",
144 AQ_CFG_DRV_NAME
, self
->link_status
.mbps
,
145 self
->aq_hw
->aq_link_status
.mbps
);
146 aq_nic_update_interrupt_moderation_settings(self
);
149 self
->link_status
= self
->aq_hw
->aq_link_status
;
150 if (!netif_carrier_ok(self
->ndev
) && self
->link_status
.mbps
) {
151 aq_utils_obj_set(&self
->header
.flags
,
152 AQ_NIC_FLAG_STARTED
);
153 aq_utils_obj_clear(&self
->header
.flags
,
155 netif_carrier_on(self
->ndev
);
156 netif_tx_wake_all_queues(self
->ndev
);
158 if (netif_carrier_ok(self
->ndev
) && !self
->link_status
.mbps
) {
159 netif_carrier_off(self
->ndev
);
160 netif_tx_disable(self
->ndev
);
161 aq_utils_obj_set(&self
->header
.flags
, AQ_NIC_LINK_DOWN
);
166 static void aq_nic_service_timer_cb(unsigned long param
)
168 struct aq_nic_s
*self
= (struct aq_nic_s
*)param
;
169 struct net_device
*ndev
= aq_nic_get_ndev(self
);
172 struct aq_ring_stats_rx_s stats_rx
;
173 struct aq_ring_stats_tx_s stats_tx
;
175 if (aq_utils_obj_test(&self
->header
.flags
, AQ_NIC_FLAGS_IS_NOT_READY
))
178 err
= aq_nic_update_link_status(self
);
182 if (self
->aq_hw_ops
.hw_update_stats
)
183 self
->aq_hw_ops
.hw_update_stats(self
->aq_hw
);
185 memset(&stats_rx
, 0U, sizeof(struct aq_ring_stats_rx_s
));
186 memset(&stats_tx
, 0U, sizeof(struct aq_ring_stats_tx_s
));
187 for (i
= AQ_DIMOF(self
->aq_vec
); i
--;) {
189 aq_vec_add_stats(self
->aq_vec
[i
], &stats_rx
, &stats_tx
);
192 ndev
->stats
.rx_packets
= stats_rx
.packets
;
193 ndev
->stats
.rx_bytes
= stats_rx
.bytes
;
194 ndev
->stats
.rx_errors
= stats_rx
.errors
;
195 ndev
->stats
.tx_packets
= stats_tx
.packets
;
196 ndev
->stats
.tx_bytes
= stats_tx
.bytes
;
197 ndev
->stats
.tx_errors
= stats_tx
.errors
;
200 mod_timer(&self
->service_timer
,
201 jiffies
+ AQ_CFG_SERVICE_TIMER_INTERVAL
);
204 static void aq_nic_polling_timer_cb(unsigned long param
)
206 struct aq_nic_s
*self
= (struct aq_nic_s
*)param
;
207 struct aq_vec_s
*aq_vec
= NULL
;
210 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
211 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
])
212 aq_vec_isr(i
, (void *)aq_vec
);
214 mod_timer(&self
->polling_timer
, jiffies
+
215 AQ_CFG_POLLING_TIMER_INTERVAL
);
218 static struct net_device
*aq_nic_ndev_alloc(void)
220 return alloc_etherdev_mq(sizeof(struct aq_nic_s
), AQ_CFG_VECS_MAX
);
223 struct aq_nic_s
*aq_nic_alloc_cold(const struct net_device_ops
*ndev_ops
,
224 const struct ethtool_ops
*et_ops
,
225 struct pci_dev
*pdev
,
226 struct aq_pci_func_s
*aq_pci_func
,
228 const struct aq_hw_ops
*aq_hw_ops
)
230 struct net_device
*ndev
= NULL
;
231 struct aq_nic_s
*self
= NULL
;
234 ndev
= aq_nic_ndev_alloc();
240 self
= netdev_priv(ndev
);
242 ndev
->netdev_ops
= ndev_ops
;
243 ndev
->ethtool_ops
= et_ops
;
245 SET_NETDEV_DEV(ndev
, &pdev
->dev
);
247 ndev
->if_port
= port
;
250 self
->aq_pci_func
= aq_pci_func
;
252 self
->aq_hw_ops
= *aq_hw_ops
;
253 self
->port
= (u8
)port
;
255 self
->aq_hw
= self
->aq_hw_ops
.create(aq_pci_func
, self
->port
,
257 err
= self
->aq_hw_ops
.get_hw_caps(self
->aq_hw
, &self
->aq_hw_caps
,
258 pdev
->device
, pdev
->subsystem_device
);
262 aq_nic_cfg_init_defaults(self
);
266 aq_nic_free_hot_resources(self
);
272 int aq_nic_ndev_register(struct aq_nic_s
*self
)
280 err
= self
->aq_hw_ops
.hw_get_mac_permanent(self
->aq_hw
,
281 self
->aq_nic_cfg
.aq_hw_caps
,
282 self
->ndev
->dev_addr
);
286 #if defined(AQ_CFG_MAC_ADDR_PERMANENT)
288 static u8 mac_addr_permanent
[] = AQ_CFG_MAC_ADDR_PERMANENT
;
290 ether_addr_copy(self
->ndev
->dev_addr
, mac_addr_permanent
);
294 netif_carrier_off(self
->ndev
);
296 netif_tx_disable(self
->ndev
);
298 err
= register_netdev(self
->ndev
);
306 int aq_nic_ndev_init(struct aq_nic_s
*self
)
308 struct aq_hw_caps_s
*aq_hw_caps
= self
->aq_nic_cfg
.aq_hw_caps
;
309 struct aq_nic_cfg_s
*aq_nic_cfg
= &self
->aq_nic_cfg
;
311 self
->ndev
->hw_features
|= aq_hw_caps
->hw_features
;
312 self
->ndev
->features
= aq_hw_caps
->hw_features
;
313 self
->ndev
->priv_flags
= aq_hw_caps
->hw_priv_flags
;
314 self
->ndev
->mtu
= aq_nic_cfg
->mtu
- ETH_HLEN
;
315 self
->ndev
->max_mtu
= self
->aq_hw_caps
.mtu
- ETH_FCS_LEN
- ETH_HLEN
;
320 void aq_nic_ndev_free(struct aq_nic_s
*self
)
325 if (self
->ndev
->reg_state
== NETREG_REGISTERED
)
326 unregister_netdev(self
->ndev
);
329 self
->aq_hw_ops
.destroy(self
->aq_hw
);
331 free_netdev(self
->ndev
);
336 struct aq_nic_s
*aq_nic_alloc_hot(struct net_device
*ndev
)
338 struct aq_nic_s
*self
= NULL
;
345 self
= netdev_priv(ndev
);
351 if (netif_running(ndev
))
352 netif_tx_disable(ndev
);
353 netif_carrier_off(self
->ndev
);
355 for (self
->aq_vecs
= 0; self
->aq_vecs
< self
->aq_nic_cfg
.vecs
;
357 self
->aq_vec
[self
->aq_vecs
] =
358 aq_vec_alloc(self
, self
->aq_vecs
, &self
->aq_nic_cfg
);
359 if (!self
->aq_vec
[self
->aq_vecs
]) {
367 aq_nic_free_hot_resources(self
);
373 void aq_nic_set_tx_ring(struct aq_nic_s
*self
, unsigned int idx
,
374 struct aq_ring_s
*ring
)
376 self
->aq_ring_tx
[idx
] = ring
;
379 struct device
*aq_nic_get_dev(struct aq_nic_s
*self
)
381 return self
->ndev
->dev
.parent
;
384 struct net_device
*aq_nic_get_ndev(struct aq_nic_s
*self
)
389 int aq_nic_init(struct aq_nic_s
*self
)
391 struct aq_vec_s
*aq_vec
= NULL
;
395 self
->power_state
= AQ_HW_POWER_STATE_D0
;
396 err
= self
->aq_hw_ops
.hw_reset(self
->aq_hw
);
400 err
= self
->aq_hw_ops
.hw_init(self
->aq_hw
, &self
->aq_nic_cfg
,
401 aq_nic_get_ndev(self
)->dev_addr
);
405 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
406 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
])
407 aq_vec_init(aq_vec
, &self
->aq_hw_ops
, self
->aq_hw
);
413 int aq_nic_start(struct aq_nic_s
*self
)
415 struct aq_vec_s
*aq_vec
= NULL
;
419 err
= self
->aq_hw_ops
.hw_multicast_list_set(self
->aq_hw
,
421 self
->mc_list
.count
);
425 err
= self
->aq_hw_ops
.hw_packet_filter_set(self
->aq_hw
,
426 self
->packet_filter
);
430 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
431 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
]) {
432 err
= aq_vec_start(aq_vec
);
437 err
= self
->aq_hw_ops
.hw_start(self
->aq_hw
);
441 err
= aq_nic_update_interrupt_moderation_settings(self
);
444 setup_timer(&self
->service_timer
, &aq_nic_service_timer_cb
,
445 (unsigned long)self
);
446 mod_timer(&self
->service_timer
, jiffies
+
447 AQ_CFG_SERVICE_TIMER_INTERVAL
);
449 if (self
->aq_nic_cfg
.is_polling
) {
450 setup_timer(&self
->polling_timer
, &aq_nic_polling_timer_cb
,
451 (unsigned long)self
);
452 mod_timer(&self
->polling_timer
, jiffies
+
453 AQ_CFG_POLLING_TIMER_INTERVAL
);
455 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
456 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
]) {
457 err
= aq_pci_func_alloc_irq(self
->aq_pci_func
, i
,
458 self
->ndev
->name
, aq_vec
,
459 aq_vec_get_affinity_mask(aq_vec
));
464 err
= self
->aq_hw_ops
.hw_irq_enable(self
->aq_hw
,
470 err
= netif_set_real_num_tx_queues(self
->ndev
, self
->aq_vecs
);
474 err
= netif_set_real_num_rx_queues(self
->ndev
, self
->aq_vecs
);
478 netif_tx_start_all_queues(self
->ndev
);
484 static unsigned int aq_nic_map_skb(struct aq_nic_s
*self
,
486 struct aq_ring_s
*ring
)
488 unsigned int ret
= 0U;
489 unsigned int nr_frags
= skb_shinfo(skb
)->nr_frags
;
490 unsigned int frag_count
= 0U;
491 unsigned int dx
= ring
->sw_tail
;
492 struct aq_ring_buff_s
*first
= NULL
;
493 struct aq_ring_buff_s
*dx_buff
= &ring
->buff_ring
[dx
];
495 if (unlikely(skb_is_gso(skb
))) {
497 dx_buff
->len_pkt
= skb
->len
;
498 dx_buff
->len_l2
= ETH_HLEN
;
499 dx_buff
->len_l3
= ip_hdrlen(skb
);
500 dx_buff
->len_l4
= tcp_hdrlen(skb
);
501 dx_buff
->mss
= skb_shinfo(skb
)->gso_size
;
502 dx_buff
->is_txc
= 1U;
503 dx_buff
->eop_index
= 0xffffU
;
506 (ip_hdr(skb
)->version
== 6) ? 1U : 0U;
508 dx
= aq_ring_next_dx(ring
, dx
);
509 dx_buff
= &ring
->buff_ring
[dx
];
514 dx_buff
->len
= skb_headlen(skb
);
515 dx_buff
->pa
= dma_map_single(aq_nic_get_dev(self
),
520 if (unlikely(dma_mapping_error(aq_nic_get_dev(self
), dx_buff
->pa
)))
524 dx_buff
->len_pkt
= skb
->len
;
525 dx_buff
->is_sop
= 1U;
526 dx_buff
->is_mapped
= 1U;
529 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
530 dx_buff
->is_ip_cso
= (htons(ETH_P_IP
) == skb
->protocol
) ?
533 if (ip_hdr(skb
)->version
== 4) {
534 dx_buff
->is_tcp_cso
=
535 (ip_hdr(skb
)->protocol
== IPPROTO_TCP
) ?
537 dx_buff
->is_udp_cso
=
538 (ip_hdr(skb
)->protocol
== IPPROTO_UDP
) ?
540 } else if (ip_hdr(skb
)->version
== 6) {
541 dx_buff
->is_tcp_cso
=
542 (ipv6_hdr(skb
)->nexthdr
== NEXTHDR_TCP
) ?
544 dx_buff
->is_udp_cso
=
545 (ipv6_hdr(skb
)->nexthdr
== NEXTHDR_UDP
) ?
550 for (; nr_frags
--; ++frag_count
) {
551 unsigned int frag_len
= 0U;
552 unsigned int buff_offset
= 0U;
553 unsigned int buff_size
= 0U;
555 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[frag_count
];
557 frag_len
= skb_frag_size(frag
);
560 if (frag_len
> AQ_CFG_TX_FRAME_MAX
)
561 buff_size
= AQ_CFG_TX_FRAME_MAX
;
563 buff_size
= frag_len
;
565 frag_pa
= skb_frag_dma_map(aq_nic_get_dev(self
),
571 if (unlikely(dma_mapping_error(aq_nic_get_dev(self
),
575 dx
= aq_ring_next_dx(ring
, dx
);
576 dx_buff
= &ring
->buff_ring
[dx
];
579 dx_buff
->len
= buff_size
;
580 dx_buff
->pa
= frag_pa
;
581 dx_buff
->is_mapped
= 1U;
582 dx_buff
->eop_index
= 0xffffU
;
584 frag_len
-= buff_size
;
585 buff_offset
+= buff_size
;
591 first
->eop_index
= dx
;
592 dx_buff
->is_eop
= 1U;
597 for (dx
= ring
->sw_tail
;
599 --ret
, dx
= aq_ring_next_dx(ring
, dx
)) {
600 dx_buff
= &ring
->buff_ring
[dx
];
602 if (!dx_buff
->is_txc
&& dx_buff
->pa
) {
603 if (unlikely(dx_buff
->is_sop
)) {
604 dma_unmap_single(aq_nic_get_dev(self
),
609 dma_unmap_page(aq_nic_get_dev(self
),
621 int aq_nic_xmit(struct aq_nic_s
*self
, struct sk_buff
*skb
)
623 struct aq_ring_s
*ring
= NULL
;
624 unsigned int frags
= 0U;
625 unsigned int vec
= skb
->queue_mapping
% self
->aq_nic_cfg
.vecs
;
626 unsigned int tc
= 0U;
627 int err
= NETDEV_TX_OK
;
629 frags
= skb_shinfo(skb
)->nr_frags
+ 1;
631 ring
= self
->aq_ring_tx
[AQ_NIC_TCVEC2RING(self
, tc
, vec
)];
633 if (frags
> AQ_CFG_SKB_FRAGS_MAX
) {
634 dev_kfree_skb_any(skb
);
638 aq_ring_update_queue_state(ring
);
640 /* Above status update may stop the queue. Check this. */
641 if (__netif_subqueue_stopped(self
->ndev
, ring
->idx
)) {
642 err
= NETDEV_TX_BUSY
;
646 frags
= aq_nic_map_skb(self
, skb
, ring
);
649 err
= self
->aq_hw_ops
.hw_ring_tx_xmit(self
->aq_hw
,
653 ++ring
->stats
.tx
.packets
;
654 ring
->stats
.tx
.bytes
+= skb
->len
;
657 err
= NETDEV_TX_BUSY
;
664 int aq_nic_update_interrupt_moderation_settings(struct aq_nic_s
*self
)
666 return self
->aq_hw_ops
.hw_interrupt_moderation_set(self
->aq_hw
);
669 int aq_nic_set_packet_filter(struct aq_nic_s
*self
, unsigned int flags
)
673 err
= self
->aq_hw_ops
.hw_packet_filter_set(self
->aq_hw
, flags
);
677 self
->packet_filter
= flags
;
683 int aq_nic_set_multicast_list(struct aq_nic_s
*self
, struct net_device
*ndev
)
685 struct netdev_hw_addr
*ha
= NULL
;
688 self
->mc_list
.count
= 0U;
690 netdev_for_each_mc_addr(ha
, ndev
) {
691 ether_addr_copy(self
->mc_list
.ar
[i
++], ha
->addr
);
692 ++self
->mc_list
.count
;
694 if (i
>= AQ_CFG_MULTICAST_ADDRESS_MAX
)
698 if (i
>= AQ_CFG_MULTICAST_ADDRESS_MAX
) {
699 /* Number of filters is too big: atlantic does not support this.
700 * Force all multi filter to support this.
701 * With this we disable all UC filters and setup "all pass"
704 self
->packet_filter
|= IFF_ALLMULTI
;
705 self
->aq_hw
->aq_nic_cfg
->mc_list_count
= 0;
706 return self
->aq_hw_ops
.hw_packet_filter_set(self
->aq_hw
,
707 self
->packet_filter
);
709 return self
->aq_hw_ops
.hw_multicast_list_set(self
->aq_hw
,
711 self
->mc_list
.count
);
715 int aq_nic_set_mtu(struct aq_nic_s
*self
, int new_mtu
)
717 self
->aq_nic_cfg
.mtu
= new_mtu
;
722 int aq_nic_set_mac(struct aq_nic_s
*self
, struct net_device
*ndev
)
724 return self
->aq_hw_ops
.hw_set_mac_address(self
->aq_hw
, ndev
->dev_addr
);
727 unsigned int aq_nic_get_link_speed(struct aq_nic_s
*self
)
729 return self
->link_status
.mbps
;
732 int aq_nic_get_regs(struct aq_nic_s
*self
, struct ethtool_regs
*regs
, void *p
)
739 err
= self
->aq_hw_ops
.hw_get_regs(self
->aq_hw
,
740 &self
->aq_hw_caps
, regs_buff
);
748 int aq_nic_get_regs_count(struct aq_nic_s
*self
)
750 return self
->aq_hw_caps
.mac_regs_count
;
753 void aq_nic_get_stats(struct aq_nic_s
*self
, u64
*data
)
755 struct aq_vec_s
*aq_vec
= NULL
;
757 unsigned int count
= 0U;
760 err
= self
->aq_hw_ops
.hw_get_hw_stats(self
->aq_hw
, data
, &count
);
767 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
768 aq_vec
&& self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
]) {
770 aq_vec_get_sw_stats(aq_vec
, data
, &count
);
777 void aq_nic_get_link_ksettings(struct aq_nic_s
*self
,
778 struct ethtool_link_ksettings
*cmd
)
780 cmd
->base
.port
= PORT_TP
;
781 /* This driver supports only 10G capable adapters, so DUPLEX_FULL */
782 cmd
->base
.duplex
= DUPLEX_FULL
;
783 cmd
->base
.autoneg
= self
->aq_nic_cfg
.is_autoneg
;
785 ethtool_link_ksettings_zero_link_mode(cmd
, supported
);
787 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_10G
)
788 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
791 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_5G
)
792 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
795 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_2GS
)
796 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
799 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_1G
)
800 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
803 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_100M
)
804 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
807 if (self
->aq_hw_caps
.flow_control
)
808 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
811 ethtool_link_ksettings_add_link_mode(cmd
, supported
, Autoneg
);
812 ethtool_link_ksettings_add_link_mode(cmd
, supported
, TP
);
814 ethtool_link_ksettings_zero_link_mode(cmd
, advertising
);
816 if (self
->aq_nic_cfg
.is_autoneg
)
817 ethtool_link_ksettings_add_link_mode(cmd
, advertising
, Autoneg
);
819 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_10G
)
820 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
823 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_5G
)
824 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
827 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_2GS
)
828 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
831 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_1G
)
832 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
835 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_100M
)
836 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
839 if (self
->aq_nic_cfg
.flow_control
)
840 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
843 ethtool_link_ksettings_add_link_mode(cmd
, advertising
, TP
);
846 int aq_nic_set_link_ksettings(struct aq_nic_s
*self
,
847 const struct ethtool_link_ksettings
*cmd
)
853 if (cmd
->base
.autoneg
== AUTONEG_ENABLE
) {
854 rate
= self
->aq_hw_caps
.link_speed_msk
;
855 self
->aq_nic_cfg
.is_autoneg
= true;
857 speed
= cmd
->base
.speed
;
861 rate
= AQ_NIC_RATE_100M
;
865 rate
= AQ_NIC_RATE_1G
;
869 rate
= AQ_NIC_RATE_2GS
;
873 rate
= AQ_NIC_RATE_5G
;
877 rate
= AQ_NIC_RATE_10G
;
885 if (!(self
->aq_hw_caps
.link_speed_msk
& rate
)) {
890 self
->aq_nic_cfg
.is_autoneg
= false;
893 err
= self
->aq_hw_ops
.hw_set_link_speed(self
->aq_hw
, rate
);
897 self
->aq_nic_cfg
.link_speed_msk
= rate
;
903 struct aq_nic_cfg_s
*aq_nic_get_cfg(struct aq_nic_s
*self
)
905 return &self
->aq_nic_cfg
;
908 u32
aq_nic_get_fw_version(struct aq_nic_s
*self
)
912 self
->aq_hw_ops
.hw_get_fw_version(self
->aq_hw
, &fw_version
);
917 int aq_nic_stop(struct aq_nic_s
*self
)
919 struct aq_vec_s
*aq_vec
= NULL
;
922 netif_tx_disable(self
->ndev
);
923 netif_carrier_off(self
->ndev
);
925 del_timer_sync(&self
->service_timer
);
927 self
->aq_hw_ops
.hw_irq_disable(self
->aq_hw
, AQ_CFG_IRQ_MASK
);
929 if (self
->aq_nic_cfg
.is_polling
)
930 del_timer_sync(&self
->polling_timer
);
932 aq_pci_func_free_irqs(self
->aq_pci_func
);
934 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
935 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
])
938 return self
->aq_hw_ops
.hw_stop(self
->aq_hw
);
941 void aq_nic_deinit(struct aq_nic_s
*self
)
943 struct aq_vec_s
*aq_vec
= NULL
;
949 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
950 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
])
951 aq_vec_deinit(aq_vec
);
953 if (self
->power_state
== AQ_HW_POWER_STATE_D0
) {
954 (void)self
->aq_hw_ops
.hw_deinit(self
->aq_hw
);
956 (void)self
->aq_hw_ops
.hw_set_power(self
->aq_hw
,
963 void aq_nic_free_hot_resources(struct aq_nic_s
*self
)
970 for (i
= AQ_DIMOF(self
->aq_vec
); i
--;) {
971 if (self
->aq_vec
[i
]) {
972 aq_vec_free(self
->aq_vec
[i
]);
973 self
->aq_vec
[i
] = NULL
;
980 int aq_nic_change_pm_state(struct aq_nic_s
*self
, pm_message_t
*pm_msg
)
984 if (!netif_running(self
->ndev
)) {
989 if (pm_msg
->event
& PM_EVENT_SLEEP
|| pm_msg
->event
& PM_EVENT_FREEZE
) {
990 self
->power_state
= AQ_HW_POWER_STATE_D3
;
991 netif_device_detach(self
->ndev
);
992 netif_tx_stop_all_queues(self
->ndev
);
994 err
= aq_nic_stop(self
);
1000 err
= aq_nic_init(self
);
1004 err
= aq_nic_start(self
);
1008 netif_device_attach(self
->ndev
);
1009 netif_tx_start_all_queues(self
->ndev
);