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(struct timer_list
*t
)
168 struct aq_nic_s
*self
= from_timer(self
, t
, service_timer
);
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(struct timer_list
*t
)
206 struct aq_nic_s
*self
= from_timer(self
, t
, polling_timer
);
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
,
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
, 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
);
261 aq_nic_cfg_init_defaults(self
);
265 aq_nic_free_hot_resources(self
);
271 int aq_nic_ndev_register(struct aq_nic_s
*self
)
279 err
= self
->aq_hw_ops
.hw_get_mac_permanent(self
->aq_hw
,
280 self
->aq_nic_cfg
.aq_hw_caps
,
281 self
->ndev
->dev_addr
);
285 #if defined(AQ_CFG_MAC_ADDR_PERMANENT)
287 static u8 mac_addr_permanent
[] = AQ_CFG_MAC_ADDR_PERMANENT
;
289 ether_addr_copy(self
->ndev
->dev_addr
, mac_addr_permanent
);
293 netif_carrier_off(self
->ndev
);
295 netif_tx_disable(self
->ndev
);
297 err
= register_netdev(self
->ndev
);
305 int aq_nic_ndev_init(struct aq_nic_s
*self
)
307 struct aq_hw_caps_s
*aq_hw_caps
= self
->aq_nic_cfg
.aq_hw_caps
;
308 struct aq_nic_cfg_s
*aq_nic_cfg
= &self
->aq_nic_cfg
;
310 self
->ndev
->hw_features
|= aq_hw_caps
->hw_features
;
311 self
->ndev
->features
= aq_hw_caps
->hw_features
;
312 self
->ndev
->priv_flags
= aq_hw_caps
->hw_priv_flags
;
313 self
->ndev
->mtu
= aq_nic_cfg
->mtu
- ETH_HLEN
;
314 self
->ndev
->max_mtu
= self
->aq_hw_caps
.mtu
- ETH_FCS_LEN
- ETH_HLEN
;
319 void aq_nic_ndev_free(struct aq_nic_s
*self
)
324 if (self
->ndev
->reg_state
== NETREG_REGISTERED
)
325 unregister_netdev(self
->ndev
);
328 self
->aq_hw_ops
.destroy(self
->aq_hw
);
330 free_netdev(self
->ndev
);
335 struct aq_nic_s
*aq_nic_alloc_hot(struct net_device
*ndev
)
337 struct aq_nic_s
*self
= NULL
;
344 self
= netdev_priv(ndev
);
350 if (netif_running(ndev
))
351 netif_tx_disable(ndev
);
352 netif_carrier_off(self
->ndev
);
354 for (self
->aq_vecs
= 0; self
->aq_vecs
< self
->aq_nic_cfg
.vecs
;
356 self
->aq_vec
[self
->aq_vecs
] =
357 aq_vec_alloc(self
, self
->aq_vecs
, &self
->aq_nic_cfg
);
358 if (!self
->aq_vec
[self
->aq_vecs
]) {
366 aq_nic_free_hot_resources(self
);
372 void aq_nic_set_tx_ring(struct aq_nic_s
*self
, unsigned int idx
,
373 struct aq_ring_s
*ring
)
375 self
->aq_ring_tx
[idx
] = ring
;
378 struct device
*aq_nic_get_dev(struct aq_nic_s
*self
)
380 return self
->ndev
->dev
.parent
;
383 struct net_device
*aq_nic_get_ndev(struct aq_nic_s
*self
)
388 int aq_nic_init(struct aq_nic_s
*self
)
390 struct aq_vec_s
*aq_vec
= NULL
;
394 self
->power_state
= AQ_HW_POWER_STATE_D0
;
395 err
= self
->aq_hw_ops
.hw_reset(self
->aq_hw
);
399 err
= self
->aq_hw_ops
.hw_init(self
->aq_hw
, &self
->aq_nic_cfg
,
400 aq_nic_get_ndev(self
)->dev_addr
);
404 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
405 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
])
406 aq_vec_init(aq_vec
, &self
->aq_hw_ops
, self
->aq_hw
);
412 int aq_nic_start(struct aq_nic_s
*self
)
414 struct aq_vec_s
*aq_vec
= NULL
;
418 err
= self
->aq_hw_ops
.hw_multicast_list_set(self
->aq_hw
,
420 self
->mc_list
.count
);
424 err
= self
->aq_hw_ops
.hw_packet_filter_set(self
->aq_hw
,
425 self
->packet_filter
);
429 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
430 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
]) {
431 err
= aq_vec_start(aq_vec
);
436 err
= self
->aq_hw_ops
.hw_start(self
->aq_hw
);
440 err
= aq_nic_update_interrupt_moderation_settings(self
);
443 timer_setup(&self
->service_timer
, aq_nic_service_timer_cb
, 0);
444 mod_timer(&self
->service_timer
, jiffies
+
445 AQ_CFG_SERVICE_TIMER_INTERVAL
);
447 if (self
->aq_nic_cfg
.is_polling
) {
448 timer_setup(&self
->polling_timer
, aq_nic_polling_timer_cb
, 0);
449 mod_timer(&self
->polling_timer
, jiffies
+
450 AQ_CFG_POLLING_TIMER_INTERVAL
);
452 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
453 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
]) {
454 err
= aq_pci_func_alloc_irq(self
->aq_pci_func
, i
,
455 self
->ndev
->name
, aq_vec
,
456 aq_vec_get_affinity_mask(aq_vec
));
461 err
= self
->aq_hw_ops
.hw_irq_enable(self
->aq_hw
,
467 err
= netif_set_real_num_tx_queues(self
->ndev
, self
->aq_vecs
);
471 err
= netif_set_real_num_rx_queues(self
->ndev
, self
->aq_vecs
);
475 netif_tx_start_all_queues(self
->ndev
);
481 static unsigned int aq_nic_map_skb(struct aq_nic_s
*self
,
483 struct aq_ring_s
*ring
)
485 unsigned int ret
= 0U;
486 unsigned int nr_frags
= skb_shinfo(skb
)->nr_frags
;
487 unsigned int frag_count
= 0U;
488 unsigned int dx
= ring
->sw_tail
;
489 struct aq_ring_buff_s
*first
= NULL
;
490 struct aq_ring_buff_s
*dx_buff
= &ring
->buff_ring
[dx
];
492 if (unlikely(skb_is_gso(skb
))) {
494 dx_buff
->len_pkt
= skb
->len
;
495 dx_buff
->len_l2
= ETH_HLEN
;
496 dx_buff
->len_l3
= ip_hdrlen(skb
);
497 dx_buff
->len_l4
= tcp_hdrlen(skb
);
498 dx_buff
->mss
= skb_shinfo(skb
)->gso_size
;
499 dx_buff
->is_txc
= 1U;
500 dx_buff
->eop_index
= 0xffffU
;
503 (ip_hdr(skb
)->version
== 6) ? 1U : 0U;
505 dx
= aq_ring_next_dx(ring
, dx
);
506 dx_buff
= &ring
->buff_ring
[dx
];
511 dx_buff
->len
= skb_headlen(skb
);
512 dx_buff
->pa
= dma_map_single(aq_nic_get_dev(self
),
517 if (unlikely(dma_mapping_error(aq_nic_get_dev(self
), dx_buff
->pa
)))
521 dx_buff
->len_pkt
= skb
->len
;
522 dx_buff
->is_sop
= 1U;
523 dx_buff
->is_mapped
= 1U;
526 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
527 dx_buff
->is_ip_cso
= (htons(ETH_P_IP
) == skb
->protocol
) ?
530 if (ip_hdr(skb
)->version
== 4) {
531 dx_buff
->is_tcp_cso
=
532 (ip_hdr(skb
)->protocol
== IPPROTO_TCP
) ?
534 dx_buff
->is_udp_cso
=
535 (ip_hdr(skb
)->protocol
== IPPROTO_UDP
) ?
537 } else if (ip_hdr(skb
)->version
== 6) {
538 dx_buff
->is_tcp_cso
=
539 (ipv6_hdr(skb
)->nexthdr
== NEXTHDR_TCP
) ?
541 dx_buff
->is_udp_cso
=
542 (ipv6_hdr(skb
)->nexthdr
== NEXTHDR_UDP
) ?
547 for (; nr_frags
--; ++frag_count
) {
548 unsigned int frag_len
= 0U;
549 unsigned int buff_offset
= 0U;
550 unsigned int buff_size
= 0U;
552 skb_frag_t
*frag
= &skb_shinfo(skb
)->frags
[frag_count
];
554 frag_len
= skb_frag_size(frag
);
557 if (frag_len
> AQ_CFG_TX_FRAME_MAX
)
558 buff_size
= AQ_CFG_TX_FRAME_MAX
;
560 buff_size
= frag_len
;
562 frag_pa
= skb_frag_dma_map(aq_nic_get_dev(self
),
568 if (unlikely(dma_mapping_error(aq_nic_get_dev(self
),
572 dx
= aq_ring_next_dx(ring
, dx
);
573 dx_buff
= &ring
->buff_ring
[dx
];
576 dx_buff
->len
= buff_size
;
577 dx_buff
->pa
= frag_pa
;
578 dx_buff
->is_mapped
= 1U;
579 dx_buff
->eop_index
= 0xffffU
;
581 frag_len
-= buff_size
;
582 buff_offset
+= buff_size
;
588 first
->eop_index
= dx
;
589 dx_buff
->is_eop
= 1U;
594 for (dx
= ring
->sw_tail
;
596 --ret
, dx
= aq_ring_next_dx(ring
, dx
)) {
597 dx_buff
= &ring
->buff_ring
[dx
];
599 if (!dx_buff
->is_txc
&& dx_buff
->pa
) {
600 if (unlikely(dx_buff
->is_sop
)) {
601 dma_unmap_single(aq_nic_get_dev(self
),
606 dma_unmap_page(aq_nic_get_dev(self
),
618 int aq_nic_xmit(struct aq_nic_s
*self
, struct sk_buff
*skb
)
620 struct aq_ring_s
*ring
= NULL
;
621 unsigned int frags
= 0U;
622 unsigned int vec
= skb
->queue_mapping
% self
->aq_nic_cfg
.vecs
;
623 unsigned int tc
= 0U;
624 int err
= NETDEV_TX_OK
;
626 frags
= skb_shinfo(skb
)->nr_frags
+ 1;
628 ring
= self
->aq_ring_tx
[AQ_NIC_TCVEC2RING(self
, tc
, vec
)];
630 if (frags
> AQ_CFG_SKB_FRAGS_MAX
) {
631 dev_kfree_skb_any(skb
);
635 aq_ring_update_queue_state(ring
);
637 /* Above status update may stop the queue. Check this. */
638 if (__netif_subqueue_stopped(self
->ndev
, ring
->idx
)) {
639 err
= NETDEV_TX_BUSY
;
643 frags
= aq_nic_map_skb(self
, skb
, ring
);
646 err
= self
->aq_hw_ops
.hw_ring_tx_xmit(self
->aq_hw
,
650 ++ring
->stats
.tx
.packets
;
651 ring
->stats
.tx
.bytes
+= skb
->len
;
654 err
= NETDEV_TX_BUSY
;
661 int aq_nic_update_interrupt_moderation_settings(struct aq_nic_s
*self
)
663 return self
->aq_hw_ops
.hw_interrupt_moderation_set(self
->aq_hw
);
666 int aq_nic_set_packet_filter(struct aq_nic_s
*self
, unsigned int flags
)
670 err
= self
->aq_hw_ops
.hw_packet_filter_set(self
->aq_hw
, flags
);
674 self
->packet_filter
= flags
;
680 int aq_nic_set_multicast_list(struct aq_nic_s
*self
, struct net_device
*ndev
)
682 struct netdev_hw_addr
*ha
= NULL
;
685 self
->mc_list
.count
= 0U;
687 netdev_for_each_mc_addr(ha
, ndev
) {
688 ether_addr_copy(self
->mc_list
.ar
[i
++], ha
->addr
);
689 ++self
->mc_list
.count
;
691 if (i
>= AQ_CFG_MULTICAST_ADDRESS_MAX
)
695 if (i
>= AQ_CFG_MULTICAST_ADDRESS_MAX
) {
696 /* Number of filters is too big: atlantic does not support this.
697 * Force all multi filter to support this.
698 * With this we disable all UC filters and setup "all pass"
701 self
->packet_filter
|= IFF_ALLMULTI
;
702 self
->aq_hw
->aq_nic_cfg
->mc_list_count
= 0;
703 return self
->aq_hw_ops
.hw_packet_filter_set(self
->aq_hw
,
704 self
->packet_filter
);
706 return self
->aq_hw_ops
.hw_multicast_list_set(self
->aq_hw
,
708 self
->mc_list
.count
);
712 int aq_nic_set_mtu(struct aq_nic_s
*self
, int new_mtu
)
714 self
->aq_nic_cfg
.mtu
= new_mtu
;
719 int aq_nic_set_mac(struct aq_nic_s
*self
, struct net_device
*ndev
)
721 return self
->aq_hw_ops
.hw_set_mac_address(self
->aq_hw
, ndev
->dev_addr
);
724 unsigned int aq_nic_get_link_speed(struct aq_nic_s
*self
)
726 return self
->link_status
.mbps
;
729 int aq_nic_get_regs(struct aq_nic_s
*self
, struct ethtool_regs
*regs
, void *p
)
736 err
= self
->aq_hw_ops
.hw_get_regs(self
->aq_hw
,
737 &self
->aq_hw_caps
, regs_buff
);
745 int aq_nic_get_regs_count(struct aq_nic_s
*self
)
747 return self
->aq_hw_caps
.mac_regs_count
;
750 void aq_nic_get_stats(struct aq_nic_s
*self
, u64
*data
)
752 struct aq_vec_s
*aq_vec
= NULL
;
754 unsigned int count
= 0U;
757 err
= self
->aq_hw_ops
.hw_get_hw_stats(self
->aq_hw
, data
, &count
);
764 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
765 aq_vec
&& self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
]) {
767 aq_vec_get_sw_stats(aq_vec
, data
, &count
);
774 void aq_nic_get_link_ksettings(struct aq_nic_s
*self
,
775 struct ethtool_link_ksettings
*cmd
)
777 cmd
->base
.port
= PORT_TP
;
778 /* This driver supports only 10G capable adapters, so DUPLEX_FULL */
779 cmd
->base
.duplex
= DUPLEX_FULL
;
780 cmd
->base
.autoneg
= self
->aq_nic_cfg
.is_autoneg
;
782 ethtool_link_ksettings_zero_link_mode(cmd
, supported
);
784 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_10G
)
785 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
788 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_5G
)
789 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
792 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_2GS
)
793 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
796 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_1G
)
797 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
800 if (self
->aq_hw_caps
.link_speed_msk
& AQ_NIC_RATE_100M
)
801 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
804 if (self
->aq_hw_caps
.flow_control
)
805 ethtool_link_ksettings_add_link_mode(cmd
, supported
,
808 ethtool_link_ksettings_add_link_mode(cmd
, supported
, Autoneg
);
809 ethtool_link_ksettings_add_link_mode(cmd
, supported
, TP
);
811 ethtool_link_ksettings_zero_link_mode(cmd
, advertising
);
813 if (self
->aq_nic_cfg
.is_autoneg
)
814 ethtool_link_ksettings_add_link_mode(cmd
, advertising
, Autoneg
);
816 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_10G
)
817 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
820 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_5G
)
821 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
824 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_2GS
)
825 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
828 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_1G
)
829 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
832 if (self
->aq_nic_cfg
.link_speed_msk
& AQ_NIC_RATE_100M
)
833 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
836 if (self
->aq_nic_cfg
.flow_control
)
837 ethtool_link_ksettings_add_link_mode(cmd
, advertising
,
840 ethtool_link_ksettings_add_link_mode(cmd
, advertising
, TP
);
843 int aq_nic_set_link_ksettings(struct aq_nic_s
*self
,
844 const struct ethtool_link_ksettings
*cmd
)
850 if (cmd
->base
.autoneg
== AUTONEG_ENABLE
) {
851 rate
= self
->aq_hw_caps
.link_speed_msk
;
852 self
->aq_nic_cfg
.is_autoneg
= true;
854 speed
= cmd
->base
.speed
;
858 rate
= AQ_NIC_RATE_100M
;
862 rate
= AQ_NIC_RATE_1G
;
866 rate
= AQ_NIC_RATE_2GS
;
870 rate
= AQ_NIC_RATE_5G
;
874 rate
= AQ_NIC_RATE_10G
;
882 if (!(self
->aq_hw_caps
.link_speed_msk
& rate
)) {
887 self
->aq_nic_cfg
.is_autoneg
= false;
890 err
= self
->aq_hw_ops
.hw_set_link_speed(self
->aq_hw
, rate
);
894 self
->aq_nic_cfg
.link_speed_msk
= rate
;
900 struct aq_nic_cfg_s
*aq_nic_get_cfg(struct aq_nic_s
*self
)
902 return &self
->aq_nic_cfg
;
905 u32
aq_nic_get_fw_version(struct aq_nic_s
*self
)
909 self
->aq_hw_ops
.hw_get_fw_version(self
->aq_hw
, &fw_version
);
914 int aq_nic_stop(struct aq_nic_s
*self
)
916 struct aq_vec_s
*aq_vec
= NULL
;
919 netif_tx_disable(self
->ndev
);
920 netif_carrier_off(self
->ndev
);
922 del_timer_sync(&self
->service_timer
);
924 self
->aq_hw_ops
.hw_irq_disable(self
->aq_hw
, AQ_CFG_IRQ_MASK
);
926 if (self
->aq_nic_cfg
.is_polling
)
927 del_timer_sync(&self
->polling_timer
);
929 aq_pci_func_free_irqs(self
->aq_pci_func
);
931 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
932 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
])
935 return self
->aq_hw_ops
.hw_stop(self
->aq_hw
);
938 void aq_nic_deinit(struct aq_nic_s
*self
)
940 struct aq_vec_s
*aq_vec
= NULL
;
946 for (i
= 0U, aq_vec
= self
->aq_vec
[0];
947 self
->aq_vecs
> i
; ++i
, aq_vec
= self
->aq_vec
[i
])
948 aq_vec_deinit(aq_vec
);
950 if (self
->power_state
== AQ_HW_POWER_STATE_D0
) {
951 (void)self
->aq_hw_ops
.hw_deinit(self
->aq_hw
);
953 (void)self
->aq_hw_ops
.hw_set_power(self
->aq_hw
,
960 void aq_nic_free_hot_resources(struct aq_nic_s
*self
)
967 for (i
= AQ_DIMOF(self
->aq_vec
); i
--;) {
968 if (self
->aq_vec
[i
]) {
969 aq_vec_free(self
->aq_vec
[i
]);
970 self
->aq_vec
[i
] = NULL
;
977 int aq_nic_change_pm_state(struct aq_nic_s
*self
, pm_message_t
*pm_msg
)
981 if (!netif_running(self
->ndev
)) {
986 if (pm_msg
->event
& PM_EVENT_SLEEP
|| pm_msg
->event
& PM_EVENT_FREEZE
) {
987 self
->power_state
= AQ_HW_POWER_STATE_D3
;
988 netif_device_detach(self
->ndev
);
989 netif_tx_stop_all_queues(self
->ndev
);
991 err
= aq_nic_stop(self
);
997 err
= aq_nic_init(self
);
1001 err
= aq_nic_start(self
);
1005 netif_device_attach(self
->ndev
);
1006 netif_tx_start_all_queues(self
->ndev
);