2 * Copyright (c) 2006 - 2011 Intel Corporation. All rights reserved.
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
39 #include <linux/tcp.h>
40 #include <linux/if_arp.h>
41 #include <linux/if_vlan.h>
42 #include <linux/ethtool.h>
43 #include <linux/slab.h>
46 #include <net/inet_common.h>
47 #include <linux/inet.h>
51 static struct nic_qp_map nic_qp_mapping_0
[] = {
52 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
53 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
54 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
55 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
58 static struct nic_qp_map nic_qp_mapping_1
[] = {
59 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
60 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
63 static struct nic_qp_map nic_qp_mapping_2
[] = {
64 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
67 static struct nic_qp_map nic_qp_mapping_3
[] = {
68 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
71 static struct nic_qp_map nic_qp_mapping_4
[] = {
72 {28,8,0,0},{32,12,0,0}
75 static struct nic_qp_map nic_qp_mapping_5
[] = {
76 {29,9,1,0},{33,13,1,0}
79 static struct nic_qp_map nic_qp_mapping_6
[] = {
80 {30,10,2,0},{34,14,2,0}
83 static struct nic_qp_map nic_qp_mapping_7
[] = {
84 {31,11,3,0},{35,15,3,0}
87 static struct nic_qp_map
*nic_qp_mapping_per_function
[] = {
88 nic_qp_mapping_0
, nic_qp_mapping_1
, nic_qp_mapping_2
, nic_qp_mapping_3
,
89 nic_qp_mapping_4
, nic_qp_mapping_5
, nic_qp_mapping_6
, nic_qp_mapping_7
92 static const u32 default_msg
= NETIF_MSG_DRV
| NETIF_MSG_PROBE
| NETIF_MSG_LINK
93 | NETIF_MSG_IFUP
| NETIF_MSG_IFDOWN
;
94 static int debug
= -1;
95 static int nics_per_function
= 1;
100 static int nes_netdev_poll(struct napi_struct
*napi
, int budget
)
102 struct nes_vnic
*nesvnic
= container_of(napi
, struct nes_vnic
, napi
);
103 struct nes_device
*nesdev
= nesvnic
->nesdev
;
104 struct nes_hw_nic_cq
*nescq
= &nesvnic
->nic_cq
;
106 nesvnic
->budget
= budget
;
107 nescq
->cqes_pending
= 0;
108 nescq
->rx_cqes_completed
= 0;
109 nescq
->cqe_allocs_pending
= 0;
110 nescq
->rx_pkts_indicated
= 0;
112 nes_nic_ce_handler(nesdev
, nescq
);
114 if (nescq
->cqes_pending
== 0) {
116 /* clear out completed cqes and arm */
117 nes_write32(nesdev
->regs
+NES_CQE_ALLOC
, NES_CQE_ALLOC_NOTIFY_NEXT
|
118 nescq
->cq_number
| (nescq
->cqe_allocs_pending
<< 16));
119 nes_read32(nesdev
->regs
+NES_CQE_ALLOC
);
121 /* clear out completed cqes but don't arm */
122 nes_write32(nesdev
->regs
+NES_CQE_ALLOC
,
123 nescq
->cq_number
| (nescq
->cqe_allocs_pending
<< 16));
124 nes_debug(NES_DBG_NETDEV
, "%s: exiting with work pending\n",
125 nesvnic
->netdev
->name
);
127 return nescq
->rx_pkts_indicated
;
132 * nes_netdev_open - Activate the network interface; ifconfig
135 static int nes_netdev_open(struct net_device
*netdev
)
139 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
140 struct nes_device
*nesdev
= nesvnic
->nesdev
;
143 struct nes_vnic
*first_nesvnic
= NULL
;
146 struct list_head
*list_pos
, *list_temp
;
149 assert(nesdev
!= NULL
);
151 if (nesvnic
->netdev_open
== 1)
154 if (netif_msg_ifup(nesvnic
))
155 printk(KERN_INFO PFX
"%s: enabling interface\n", netdev
->name
);
157 ret
= nes_init_nic_qp(nesdev
, netdev
);
162 netif_carrier_off(netdev
);
163 netif_stop_queue(netdev
);
165 if ((!nesvnic
->of_device_registered
) && (nesvnic
->rdma_enabled
)) {
166 nesvnic
->nesibdev
= nes_init_ofa_device(netdev
);
167 if (nesvnic
->nesibdev
== NULL
) {
168 printk(KERN_ERR PFX
"%s: nesvnic->nesibdev alloc failed", netdev
->name
);
170 nesvnic
->nesibdev
->nesvnic
= nesvnic
;
171 ret
= nes_register_ofa_device(nesvnic
->nesibdev
);
173 printk(KERN_ERR PFX
"%s: Unable to register RDMA device, ret = %d\n",
178 /* Set packet filters */
179 nic_active_bit
= 1 << nesvnic
->nic_index
;
180 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_ACTIVE
);
181 nic_active
|= nic_active_bit
;
182 nes_write_indexed(nesdev
, NES_IDX_NIC_ACTIVE
, nic_active
);
183 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ENABLE
);
184 nic_active
|= nic_active_bit
;
185 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ENABLE
, nic_active
);
186 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_BROADCAST_ON
);
187 nic_active
|= nic_active_bit
;
188 nes_write_indexed(nesdev
, NES_IDX_NIC_BROADCAST_ON
, nic_active
);
190 macaddr_high
= ((u16
)netdev
->dev_addr
[0]) << 8;
191 macaddr_high
+= (u16
)netdev
->dev_addr
[1];
193 macaddr_low
= ((u32
)netdev
->dev_addr
[2]) << 24;
194 macaddr_low
+= ((u32
)netdev
->dev_addr
[3]) << 16;
195 macaddr_low
+= ((u32
)netdev
->dev_addr
[4]) << 8;
196 macaddr_low
+= (u32
)netdev
->dev_addr
[5];
198 /* Program the various MAC regs */
199 for (i
= 0; i
< NES_MAX_PORT_COUNT
; i
++) {
200 if (nesvnic
->qp_nic_index
[i
] == 0xf) {
203 nes_debug(NES_DBG_NETDEV
, "i=%d, perfect filter table index= %d, PERF FILTER LOW"
204 " (Addr:%08X) = %08X, HIGH = %08X.\n",
205 i
, nesvnic
->qp_nic_index
[i
],
206 NES_IDX_PERFECT_FILTER_LOW
+
207 (nesvnic
->qp_nic_index
[i
] * 8),
209 (u32
)macaddr_high
| NES_MAC_ADDR_VALID
|
210 ((((u32
)nesvnic
->nic_index
) << 16)));
211 nes_write_indexed(nesdev
,
212 NES_IDX_PERFECT_FILTER_LOW
+ (nesvnic
->qp_nic_index
[i
] * 8),
214 nes_write_indexed(nesdev
,
215 NES_IDX_PERFECT_FILTER_HIGH
+ (nesvnic
->qp_nic_index
[i
] * 8),
216 (u32
)macaddr_high
| NES_MAC_ADDR_VALID
|
217 ((((u32
)nesvnic
->nic_index
) << 16)));
221 nes_write32(nesdev
->regs
+NES_CQE_ALLOC
, NES_CQE_ALLOC_NOTIFY_NEXT
|
222 nesvnic
->nic_cq
.cq_number
);
223 nes_read32(nesdev
->regs
+NES_CQE_ALLOC
);
224 list_for_each_safe(list_pos
, list_temp
, &nesdev
->nesadapter
->nesvnic_list
[nesdev
->mac_index
]) {
225 first_nesvnic
= container_of(list_pos
, struct nes_vnic
, list
);
226 if (first_nesvnic
->netdev_open
== 1)
229 if (first_nesvnic
->netdev_open
== 0) {
230 nes_debug(NES_DBG_INIT
, "Setting up MAC interrupt mask.\n");
231 nes_write_indexed(nesdev
, NES_IDX_MAC_INT_MASK
+ (0x200 * nesdev
->mac_index
),
232 ~(NES_MAC_INT_LINK_STAT_CHG
| NES_MAC_INT_XGMII_EXT
|
233 NES_MAC_INT_TX_UNDERFLOW
| NES_MAC_INT_TX_ERROR
));
234 first_nesvnic
= nesvnic
;
237 if (first_nesvnic
->linkup
) {
238 /* Enable network packets */
240 netif_start_queue(netdev
);
241 netif_carrier_on(netdev
);
244 spin_lock_irqsave(&nesdev
->nesadapter
->phy_lock
, flags
);
245 if (nesdev
->nesadapter
->phy_type
[nesdev
->mac_index
] == NES_PHY_TYPE_SFP_D
) {
246 nesdev
->link_recheck
= 1;
247 mod_delayed_work(system_wq
, &nesdev
->work
,
248 NES_LINK_RECHECK_DELAY
);
250 spin_unlock_irqrestore(&nesdev
->nesadapter
->phy_lock
, flags
);
252 spin_lock_irqsave(&nesvnic
->port_ibevent_lock
, flags
);
253 if (nesvnic
->of_device_registered
) {
254 nesdev
->nesadapter
->send_term_ok
= 1;
255 if (nesvnic
->linkup
== 1) {
256 if (nesdev
->iw_status
== 0) {
257 nesdev
->iw_status
= 1;
258 nes_port_ibevent(nesvnic
);
261 nesdev
->iw_status
= 0;
264 spin_unlock_irqrestore(&nesvnic
->port_ibevent_lock
, flags
);
266 napi_enable(&nesvnic
->napi
);
267 nesvnic
->netdev_open
= 1;
276 static int nes_netdev_stop(struct net_device
*netdev
)
278 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
279 struct nes_device
*nesdev
= nesvnic
->nesdev
;
282 struct nes_vnic
*first_nesvnic
= NULL
;
283 struct list_head
*list_pos
, *list_temp
;
286 nes_debug(NES_DBG_SHUTDOWN
, "nesvnic=%p, nesdev=%p, netdev=%p %s\n",
287 nesvnic
, nesdev
, netdev
, netdev
->name
);
288 if (nesvnic
->netdev_open
== 0)
291 if (netif_msg_ifdown(nesvnic
))
292 printk(KERN_INFO PFX
"%s: disabling interface\n", netdev
->name
);
293 netif_carrier_off(netdev
);
295 /* Disable network packets */
296 napi_disable(&nesvnic
->napi
);
297 netif_stop_queue(netdev
);
298 list_for_each_safe(list_pos
, list_temp
, &nesdev
->nesadapter
->nesvnic_list
[nesdev
->mac_index
]) {
299 first_nesvnic
= container_of(list_pos
, struct nes_vnic
, list
);
300 if ((first_nesvnic
->netdev_open
== 1) && (first_nesvnic
!= nesvnic
))
304 if ((first_nesvnic
->netdev_open
== 1) && (first_nesvnic
!= nesvnic
) &&
305 (PCI_FUNC(first_nesvnic
->nesdev
->pcidev
->devfn
) !=
306 PCI_FUNC(nesvnic
->nesdev
->pcidev
->devfn
))) {
307 nes_write_indexed(nesdev
, NES_IDX_MAC_INT_MASK
+
308 (0x200*nesdev
->mac_index
), 0xffffffff);
309 nes_write_indexed(first_nesvnic
->nesdev
,
310 NES_IDX_MAC_INT_MASK
+
311 (0x200*first_nesvnic
->nesdev
->mac_index
),
312 ~(NES_MAC_INT_LINK_STAT_CHG
| NES_MAC_INT_XGMII_EXT
|
313 NES_MAC_INT_TX_UNDERFLOW
| NES_MAC_INT_TX_ERROR
));
315 nes_write_indexed(nesdev
, NES_IDX_MAC_INT_MASK
+(0x200*nesdev
->mac_index
), 0xffffffff);
318 nic_active_mask
= ~((u32
)(1 << nesvnic
->nic_index
));
319 nes_write_indexed(nesdev
, NES_IDX_PERFECT_FILTER_HIGH
+
320 (nesvnic
->perfect_filter_index
*8), 0);
321 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_ACTIVE
);
322 nic_active
&= nic_active_mask
;
323 nes_write_indexed(nesdev
, NES_IDX_NIC_ACTIVE
, nic_active
);
324 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
);
325 nic_active
&= nic_active_mask
;
326 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
, nic_active
);
327 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ENABLE
);
328 nic_active
&= nic_active_mask
;
329 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ENABLE
, nic_active
);
330 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
331 nic_active
&= nic_active_mask
;
332 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
333 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_BROADCAST_ON
);
334 nic_active
&= nic_active_mask
;
335 nes_write_indexed(nesdev
, NES_IDX_NIC_BROADCAST_ON
, nic_active
);
337 spin_lock_irqsave(&nesvnic
->port_ibevent_lock
, flags
);
338 if (nesvnic
->of_device_registered
) {
339 nesdev
->nesadapter
->send_term_ok
= 0;
340 nesdev
->iw_status
= 0;
341 if (nesvnic
->linkup
== 1)
342 nes_port_ibevent(nesvnic
);
344 del_timer_sync(&nesvnic
->event_timer
);
345 nesvnic
->event_timer
.function
= NULL
;
346 spin_unlock_irqrestore(&nesvnic
->port_ibevent_lock
, flags
);
348 nes_destroy_nic_qp(nesvnic
);
350 nesvnic
->netdev_open
= 0;
359 static bool nes_nic_send(struct sk_buff
*skb
, struct net_device
*netdev
)
361 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
362 struct nes_device
*nesdev
= nesvnic
->nesdev
;
363 struct nes_hw_nic
*nesnic
= &nesvnic
->nic
;
364 struct nes_hw_nic_sq_wqe
*nic_sqe
;
366 __le16
*wqe_fragment_length
;
368 u16 wqe_fragment_index
= 1; /* first fragment (0) is used by copy buffer */
369 u16 skb_fragment_index
;
370 dma_addr_t bus_address
;
372 nic_sqe
= &nesnic
->sq_vbase
[nesnic
->sq_head
];
373 wqe_fragment_length
= (__le16
*)&nic_sqe
->wqe_words
[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX
];
375 /* setup the VLAN tag if present */
376 if (skb_vlan_tag_present(skb
)) {
377 nes_debug(NES_DBG_NIC_TX
, "%s: VLAN packet to send... VLAN = %08X\n",
378 netdev
->name
, skb_vlan_tag_get(skb
));
379 wqe_misc
= NES_NIC_SQ_WQE_TAGVALUE_ENABLE
;
380 wqe_fragment_length
[0] = (__force __le16
) skb_vlan_tag_get(skb
);
384 /* bump past the vlan tag */
385 wqe_fragment_length
++;
386 /* wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
387 wqe_misc
|= NES_NIC_SQ_WQE_COMPLETION
;
389 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
390 if (skb_is_gso(skb
)) {
392 /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... is_gso = %u seg size = %u\n",
393 netdev->name, skb_is_gso(skb), skb_shinfo(skb)->gso_size); */
394 wqe_misc
|= NES_NIC_SQ_WQE_LSO_ENABLE
| (u16
)skb_shinfo(skb
)->gso_size
;
395 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_LSO_INFO_IDX
,
397 (((u32
)(((unsigned char *)tcph
) - skb
->data
)) << 4));
399 } else { /* CHECKSUM_HW */
400 wqe_misc
|= NES_NIC_SQ_WQE_DISABLE_CHKSUM
;
403 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX
,
405 memcpy(&nesnic
->first_frag_vbase
[nesnic
->sq_head
].buffer
,
406 skb
->data
, min(((unsigned int)NES_FIRST_FRAG_SIZE
), skb_headlen(skb
)));
407 wqe_fragment_length
[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE
),
409 wqe_fragment_length
[1] = 0;
410 if (skb_headlen(skb
) > NES_FIRST_FRAG_SIZE
) {
411 if ((skb_shinfo(skb
)->nr_frags
+ 1) > 4) {
412 nes_debug(NES_DBG_NIC_TX
, "%s: Packet with %u fragments not sent, skb_headlen=%u\n",
413 netdev
->name
, skb_shinfo(skb
)->nr_frags
+ 2, skb_headlen(skb
));
415 nesvnic
->tx_sw_dropped
++;
418 set_bit(nesnic
->sq_head
, nesnic
->first_frag_overflow
);
419 bus_address
= pci_map_single(nesdev
->pcidev
, skb
->data
+ NES_FIRST_FRAG_SIZE
,
420 skb_headlen(skb
) - NES_FIRST_FRAG_SIZE
, PCI_DMA_TODEVICE
);
421 wqe_fragment_length
[wqe_fragment_index
++] =
422 cpu_to_le16(skb_headlen(skb
) - NES_FIRST_FRAG_SIZE
);
423 wqe_fragment_length
[wqe_fragment_index
] = 0;
424 set_wqe_64bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_FRAG1_LOW_IDX
,
425 ((u64
)(bus_address
)));
426 nesnic
->tx_skb
[nesnic
->sq_head
] = skb
;
429 if (skb_headlen(skb
) == skb
->len
) {
430 if (skb_headlen(skb
) <= NES_FIRST_FRAG_SIZE
) {
431 nic_sqe
->wqe_words
[NES_NIC_SQ_WQE_LENGTH_2_1_IDX
] = 0;
432 nesnic
->tx_skb
[nesnic
->sq_head
] = skb
;
435 /* Deal with Fragments */
436 nesnic
->tx_skb
[nesnic
->sq_head
] = skb
;
437 for (skb_fragment_index
= 0; skb_fragment_index
< skb_shinfo(skb
)->nr_frags
;
438 skb_fragment_index
++) {
440 &skb_shinfo(skb
)->frags
[skb_fragment_index
];
441 bus_address
= skb_frag_dma_map(&nesdev
->pcidev
->dev
,
442 frag
, 0, skb_frag_size(frag
),
444 wqe_fragment_length
[wqe_fragment_index
] =
445 cpu_to_le16(skb_frag_size(&skb_shinfo(skb
)->frags
[skb_fragment_index
]));
446 set_wqe_64bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_FRAG0_LOW_IDX
+(2*wqe_fragment_index
),
448 wqe_fragment_index
++;
449 if (wqe_fragment_index
< 5)
450 wqe_fragment_length
[wqe_fragment_index
] = 0;
454 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_MISC_IDX
, wqe_misc
);
456 nesnic
->sq_head
&= nesnic
->sq_size
- 1;
462 * nes_netdev_start_xmit
464 static int nes_netdev_start_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
466 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
467 struct nes_device
*nesdev
= nesvnic
->nesdev
;
468 struct nes_hw_nic
*nesnic
= &nesvnic
->nic
;
469 struct nes_hw_nic_sq_wqe
*nic_sqe
;
471 /* struct udphdr *udph; */
472 #define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
473 /* 64K segment plus overflow on each side */
474 dma_addr_t tso_bus_address
[NES_MAX_TSO_FRAGS
];
475 dma_addr_t bus_address
;
482 __le16
*wqe_fragment_length
;
484 u32 original_first_length
;
485 /* u64 *wqe_fragment_address; */
486 /* first fragment (0) is used by copy buffer */
487 u16 wqe_fragment_index
=1;
495 * nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
496 * " (%u frags), tso_size=%u\n",
497 * netdev->name, skb->len, skb_headlen(skb),
498 * skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
501 if (netif_queue_stopped(netdev
))
502 return NETDEV_TX_BUSY
;
504 /* Check if SQ is full */
505 if ((((nesnic
->sq_tail
+(nesnic
->sq_size
*2))-nesnic
->sq_head
) & (nesnic
->sq_size
- 1)) == 1) {
506 if (!netif_queue_stopped(netdev
)) {
507 netif_stop_queue(netdev
);
509 if ((((((volatile u16
)nesnic
->sq_tail
)+(nesnic
->sq_size
*2))-nesnic
->sq_head
) & (nesnic
->sq_size
- 1)) != 1) {
510 netif_start_queue(netdev
);
511 goto sq_no_longer_full
;
515 return NETDEV_TX_BUSY
;
519 nr_frags
= skb_shinfo(skb
)->nr_frags
;
520 if (skb_headlen(skb
) > NES_FIRST_FRAG_SIZE
) {
523 /* Check if too many fragments */
524 if (unlikely((nr_frags
> 4))) {
525 if (skb_is_gso(skb
)) {
526 nesvnic
->segmented_tso_requests
++;
527 nesvnic
->tso_requests
++;
528 /* Basically 4 fragments available per WQE with extended fragments */
529 wqes_needed
= nr_frags
>> 2;
530 wqes_needed
+= (nr_frags
&3)?1:0;
531 wqes_available
= (((nesnic
->sq_tail
+nesnic
->sq_size
)-nesnic
->sq_head
) - 1) &
532 (nesnic
->sq_size
- 1);
534 if (unlikely(wqes_needed
> wqes_available
)) {
535 if (!netif_queue_stopped(netdev
)) {
536 netif_stop_queue(netdev
);
538 wqes_available
= (((((volatile u16
)nesnic
->sq_tail
)+nesnic
->sq_size
)-nesnic
->sq_head
) - 1) &
539 (nesnic
->sq_size
- 1);
540 if (wqes_needed
<= wqes_available
) {
541 netif_start_queue(netdev
);
542 goto tso_sq_no_longer_full
;
546 nes_debug(NES_DBG_NIC_TX
, "%s: HNIC SQ full- TSO request has too many frags!\n",
548 return NETDEV_TX_BUSY
;
550 tso_sq_no_longer_full
:
551 /* Map all the buffers */
552 for (tso_frag_count
=0; tso_frag_count
< skb_shinfo(skb
)->nr_frags
;
555 &skb_shinfo(skb
)->frags
[tso_frag_count
];
556 tso_bus_address
[tso_frag_count
] =
557 skb_frag_dma_map(&nesdev
->pcidev
->dev
,
558 frag
, 0, skb_frag_size(frag
),
563 curr_tcp_seq
= ntohl(tcp_hdr(skb
)->seq
);
564 hoffset
= skb_transport_header(skb
) - skb
->data
;
565 nhoffset
= skb_network_header(skb
) - skb
->data
;
566 original_first_length
= hoffset
+ ((((struct tcphdr
*)skb_transport_header(skb
))->doff
)<<2);
568 for (wqe_count
=0; wqe_count
<((u32
)wqes_needed
); wqe_count
++) {
570 nic_sqe
= &nesnic
->sq_vbase
[nesnic
->sq_head
];
571 wqe_fragment_length
=
572 (__le16
*)&nic_sqe
->wqe_words
[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX
];
573 /* setup the VLAN tag if present */
574 if (skb_vlan_tag_present(skb
)) {
575 nes_debug(NES_DBG_NIC_TX
, "%s: VLAN packet to send... VLAN = %08X\n",
577 skb_vlan_tag_get(skb
));
578 wqe_misc
= NES_NIC_SQ_WQE_TAGVALUE_ENABLE
;
579 wqe_fragment_length
[0] = (__force __le16
) skb_vlan_tag_get(skb
);
583 /* bump past the vlan tag */
584 wqe_fragment_length
++;
586 /* Assumes header totally fits in allocated buffer and is in first fragment */
587 if (original_first_length
> NES_FIRST_FRAG_SIZE
) {
588 nes_debug(NES_DBG_NIC_TX
, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
589 original_first_length
, NES_FIRST_FRAG_SIZE
);
590 nes_debug(NES_DBG_NIC_TX
, "%s Request to tx NIC packet length %u, headlen %u,"
591 " (%u frags), is_gso = %u tso_size=%u\n",
593 skb
->len
, skb_headlen(skb
),
594 skb_shinfo(skb
)->nr_frags
, skb_is_gso(skb
), skb_shinfo(skb
)->gso_size
);
596 memcpy(&nesnic
->first_frag_vbase
[nesnic
->sq_head
].buffer
,
597 skb
->data
, min(((unsigned int)NES_FIRST_FRAG_SIZE
),
598 original_first_length
));
599 iph
= (struct iphdr
*)
600 (&nesnic
->first_frag_vbase
[nesnic
->sq_head
].buffer
[nhoffset
]);
601 tcph
= (struct tcphdr
*)
602 (&nesnic
->first_frag_vbase
[nesnic
->sq_head
].buffer
[hoffset
]);
603 if ((wqe_count
+1)!=(u32
)wqes_needed
) {
612 tcph
->seq
= htonl(curr_tcp_seq
);
613 wqe_fragment_length
[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE
),
614 original_first_length
));
616 wqe_fragment_index
= 1;
617 if ((wqe_count
==0) && (skb_headlen(skb
) > original_first_length
)) {
618 set_bit(nesnic
->sq_head
, nesnic
->first_frag_overflow
);
619 bus_address
= pci_map_single(nesdev
->pcidev
, skb
->data
+ original_first_length
,
620 skb_headlen(skb
) - original_first_length
, PCI_DMA_TODEVICE
);
621 wqe_fragment_length
[wqe_fragment_index
++] =
622 cpu_to_le16(skb_headlen(skb
) - original_first_length
);
623 wqe_fragment_length
[wqe_fragment_index
] = 0;
624 set_wqe_64bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_FRAG1_LOW_IDX
,
626 tso_wqe_length
+= skb_headlen(skb
) -
627 original_first_length
;
629 while (wqe_fragment_index
< 5) {
630 wqe_fragment_length
[wqe_fragment_index
] =
631 cpu_to_le16(skb_frag_size(&skb_shinfo(skb
)->frags
[tso_frag_index
]));
632 set_wqe_64bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_FRAG0_LOW_IDX
+(2*wqe_fragment_index
),
633 (u64
)tso_bus_address
[tso_frag_index
]);
634 wqe_fragment_index
++;
635 tso_wqe_length
+= skb_frag_size(&skb_shinfo(skb
)->frags
[tso_frag_index
++]);
636 if (wqe_fragment_index
< 5)
637 wqe_fragment_length
[wqe_fragment_index
] = 0;
638 if (tso_frag_index
== tso_frag_count
)
641 if ((wqe_count
+1) == (u32
)wqes_needed
) {
642 nesnic
->tx_skb
[nesnic
->sq_head
] = skb
;
644 nesnic
->tx_skb
[nesnic
->sq_head
] = NULL
;
646 wqe_misc
|= NES_NIC_SQ_WQE_COMPLETION
| (u16
)skb_shinfo(skb
)->gso_size
;
647 if ((tso_wqe_length
+ original_first_length
) > skb_shinfo(skb
)->gso_size
) {
648 wqe_misc
|= NES_NIC_SQ_WQE_LSO_ENABLE
;
650 iph
->tot_len
= htons(tso_wqe_length
+ original_first_length
- nhoffset
);
653 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_MISC_IDX
,
655 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_LSO_INFO_IDX
,
656 ((u32
)tcph
->doff
) | (((u32
)hoffset
) << 4));
658 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX
,
659 tso_wqe_length
+ original_first_length
);
660 curr_tcp_seq
+= tso_wqe_length
;
662 nesnic
->sq_head
&= nesnic
->sq_size
-1;
665 hoffset
= skb_transport_header(skb
) - skb
->data
;
666 nhoffset
= skb_network_header(skb
) - skb
->data
;
667 if (skb_linearize(skb
)) {
668 nesvnic
->tx_sw_dropped
++;
672 nesvnic
->linearized_skbs
++;
673 skb_set_transport_header(skb
, hoffset
);
674 skb_set_network_header(skb
, nhoffset
);
675 if (!nes_nic_send(skb
, netdev
))
679 if (!nes_nic_send(skb
, netdev
))
686 nes_write32(nesdev
->regs
+NES_WQE_ALLOC
,
687 (wqe_count
<< 24) | (1 << 23) | nesvnic
->nic
.qp_id
);
689 netif_trans_update(netdev
);
696 * nes_netdev_get_stats
698 static struct net_device_stats
*nes_netdev_get_stats(struct net_device
*netdev
)
700 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
701 struct nes_device
*nesdev
= nesvnic
->nesdev
;
705 u32temp
= nes_read_indexed(nesdev
,
706 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD
+ (nesvnic
->nic_index
*0x200));
707 nesvnic
->netstats
.rx_dropped
+= u32temp
;
708 nesvnic
->endnode_nstat_rx_discard
+= u32temp
;
710 u64temp
= (u64
)nes_read_indexed(nesdev
,
711 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO
+ (nesvnic
->nic_index
*0x200));
712 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
713 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI
+ (nesvnic
->nic_index
*0x200))) << 32;
715 nesvnic
->endnode_nstat_rx_octets
+= u64temp
;
716 nesvnic
->netstats
.rx_bytes
+= u64temp
;
718 u64temp
= (u64
)nes_read_indexed(nesdev
,
719 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO
+ (nesvnic
->nic_index
*0x200));
720 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
721 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI
+ (nesvnic
->nic_index
*0x200))) << 32;
723 nesvnic
->endnode_nstat_rx_frames
+= u64temp
;
724 nesvnic
->netstats
.rx_packets
+= u64temp
;
726 u64temp
= (u64
)nes_read_indexed(nesdev
,
727 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO
+ (nesvnic
->nic_index
*0x200));
728 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
729 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI
+ (nesvnic
->nic_index
*0x200))) << 32;
731 nesvnic
->endnode_nstat_tx_octets
+= u64temp
;
732 nesvnic
->netstats
.tx_bytes
+= u64temp
;
734 u64temp
= (u64
)nes_read_indexed(nesdev
,
735 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO
+ (nesvnic
->nic_index
*0x200));
736 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
737 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI
+ (nesvnic
->nic_index
*0x200))) << 32;
739 nesvnic
->endnode_nstat_tx_frames
+= u64temp
;
740 nesvnic
->netstats
.tx_packets
+= u64temp
;
742 u32temp
= nes_read_indexed(nesdev
,
743 NES_IDX_MAC_RX_SHORT_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
744 nesvnic
->netstats
.rx_dropped
+= u32temp
;
745 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
746 nesvnic
->nesdev
->mac_rx_short_frames
+= u32temp
;
748 u32temp
= nes_read_indexed(nesdev
,
749 NES_IDX_MAC_RX_OVERSIZED_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
750 nesvnic
->netstats
.rx_dropped
+= u32temp
;
751 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
752 nesvnic
->nesdev
->mac_rx_oversized_frames
+= u32temp
;
754 u32temp
= nes_read_indexed(nesdev
,
755 NES_IDX_MAC_RX_JABBER_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
756 nesvnic
->netstats
.rx_dropped
+= u32temp
;
757 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
758 nesvnic
->nesdev
->mac_rx_jabber_frames
+= u32temp
;
760 u32temp
= nes_read_indexed(nesdev
,
761 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
762 nesvnic
->netstats
.rx_dropped
+= u32temp
;
763 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
764 nesvnic
->nesdev
->mac_rx_symbol_err_frames
+= u32temp
;
766 u32temp
= nes_read_indexed(nesdev
,
767 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
768 nesvnic
->netstats
.rx_length_errors
+= u32temp
;
769 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
771 u32temp
= nes_read_indexed(nesdev
,
772 NES_IDX_MAC_RX_CRC_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
773 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
774 nesvnic
->nesdev
->mac_rx_crc_errors
+= u32temp
;
775 nesvnic
->netstats
.rx_crc_errors
+= u32temp
;
777 u32temp
= nes_read_indexed(nesdev
,
778 NES_IDX_MAC_TX_ERRORS
+ (nesvnic
->nesdev
->mac_index
*0x200));
779 nesvnic
->nesdev
->mac_tx_errors
+= u32temp
;
780 nesvnic
->netstats
.tx_errors
+= u32temp
;
782 return &nesvnic
->netstats
;
787 * nes_netdev_tx_timeout
789 static void nes_netdev_tx_timeout(struct net_device
*netdev
)
791 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
793 if (netif_msg_timer(nesvnic
))
794 nes_debug(NES_DBG_NIC_TX
, "%s: tx timeout\n", netdev
->name
);
799 * nes_netdev_set_mac_address
801 static int nes_netdev_set_mac_address(struct net_device
*netdev
, void *p
)
803 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
804 struct nes_device
*nesdev
= nesvnic
->nesdev
;
805 struct sockaddr
*mac_addr
= p
;
810 if (!is_valid_ether_addr(mac_addr
->sa_data
))
811 return -EADDRNOTAVAIL
;
813 memcpy(netdev
->dev_addr
, mac_addr
->sa_data
, netdev
->addr_len
);
814 printk(PFX
"%s: Address length = %d, Address = %pM\n",
815 __func__
, netdev
->addr_len
, mac_addr
->sa_data
);
816 macaddr_high
= ((u16
)netdev
->dev_addr
[0]) << 8;
817 macaddr_high
+= (u16
)netdev
->dev_addr
[1];
818 macaddr_low
= ((u32
)netdev
->dev_addr
[2]) << 24;
819 macaddr_low
+= ((u32
)netdev
->dev_addr
[3]) << 16;
820 macaddr_low
+= ((u32
)netdev
->dev_addr
[4]) << 8;
821 macaddr_low
+= (u32
)netdev
->dev_addr
[5];
823 for (i
= 0; i
< NES_MAX_PORT_COUNT
; i
++) {
824 if (nesvnic
->qp_nic_index
[i
] == 0xf) {
827 nes_write_indexed(nesdev
,
828 NES_IDX_PERFECT_FILTER_LOW
+ (nesvnic
->qp_nic_index
[i
] * 8),
830 nes_write_indexed(nesdev
,
831 NES_IDX_PERFECT_FILTER_HIGH
+ (nesvnic
->qp_nic_index
[i
] * 8),
832 (u32
)macaddr_high
| NES_MAC_ADDR_VALID
|
833 ((((u32
)nesvnic
->nic_index
) << 16)));
839 static void set_allmulti(struct nes_device
*nesdev
, u32 nic_active_bit
)
843 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
);
844 nic_active
|= nic_active_bit
;
845 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
, nic_active
);
846 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
847 nic_active
&= ~nic_active_bit
;
848 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
851 #define get_addr(addrs, index) ((addrs) + (index) * ETH_ALEN)
854 * nes_netdev_set_multicast_list
856 static void nes_netdev_set_multicast_list(struct net_device
*netdev
)
858 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
859 struct nes_device
*nesdev
= nesvnic
->nesdev
;
860 struct nes_adapter
*nesadapter
= nesvnic
->nesdev
->nesadapter
;
863 u32 perfect_filter_register_address
;
868 int mc_nic_index
= -1;
869 u8 pft_entries_preallocated
= max(nesadapter
->adapter_fcn_count
*
870 nics_per_function
, 4);
871 u8 max_pft_entries_avaiable
= NES_PFT_SIZE
- pft_entries_preallocated
;
873 int mc_count
= netdev_mc_count(netdev
);
875 spin_lock_irqsave(&nesadapter
->resource_lock
, flags
);
876 nic_active_bit
= 1 << nesvnic
->nic_index
;
878 if (netdev
->flags
& IFF_PROMISC
) {
879 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
);
880 nic_active
|= nic_active_bit
;
881 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
, nic_active
);
882 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
883 nic_active
|= nic_active_bit
;
884 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
886 } else if ((netdev
->flags
& IFF_ALLMULTI
) ||
887 (nesvnic
->nic_index
> 3)) {
888 set_allmulti(nesdev
, nic_active_bit
);
891 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
);
892 nic_active
&= ~nic_active_bit
;
893 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
, nic_active
);
894 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
895 nic_active
&= ~nic_active_bit
;
896 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
899 nes_debug(NES_DBG_NIC_RX
, "Number of MC entries = %d, Promiscuous = %d, All Multicast = %d.\n",
900 mc_count
, !!(netdev
->flags
& IFF_PROMISC
),
901 !!(netdev
->flags
& IFF_ALLMULTI
));
905 struct netdev_hw_addr
*ha
;
907 addrs
= kmalloc(ETH_ALEN
* mc_count
, GFP_ATOMIC
);
909 set_allmulti(nesdev
, nic_active_bit
);
913 netdev_for_each_mc_addr(ha
, netdev
)
914 memcpy(get_addr(addrs
, i
++), ha
->addr
, ETH_ALEN
);
916 perfect_filter_register_address
= NES_IDX_PERFECT_FILTER_LOW
+
917 pft_entries_preallocated
* 0x8;
918 for (i
= 0, mc_index
= 0; mc_index
< max_pft_entries_avaiable
;
920 while (i
< mc_count
&& nesvnic
->mcrq_mcast_filter
&&
921 ((mc_nic_index
= nesvnic
->mcrq_mcast_filter(nesvnic
,
922 get_addr(addrs
, i
++))) == 0));
923 if (mc_nic_index
< 0)
924 mc_nic_index
= nesvnic
->nic_index
;
925 while (nesadapter
->pft_mcast_map
[mc_index
] < 16 &&
926 nesadapter
->pft_mcast_map
[mc_index
] !=
927 nesvnic
->nic_index
&&
928 mc_index
< max_pft_entries_avaiable
) {
929 nes_debug(NES_DBG_NIC_RX
,
930 "mc_index=%d skipping nic_index=%d, "
931 "used for=%d \n", mc_index
,
933 nesadapter
->pft_mcast_map
[mc_index
]);
936 if (mc_index
>= max_pft_entries_avaiable
)
939 char *addr
= get_addr(addrs
, i
++);
941 nes_debug(NES_DBG_NIC_RX
, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
943 perfect_filter_register_address
+(mc_index
* 8),
945 macaddr_high
= ((u8
) addr
[0]) << 8;
946 macaddr_high
+= (u8
) addr
[1];
947 macaddr_low
= ((u8
) addr
[2]) << 24;
948 macaddr_low
+= ((u8
) addr
[3]) << 16;
949 macaddr_low
+= ((u8
) addr
[4]) << 8;
950 macaddr_low
+= (u8
) addr
[5];
952 nes_write_indexed(nesdev
,
953 perfect_filter_register_address
+(mc_index
* 8),
955 nes_write_indexed(nesdev
,
956 perfect_filter_register_address
+4+(mc_index
* 8),
957 (u32
)macaddr_high
| NES_MAC_ADDR_VALID
|
958 ((((u32
)(1<<mc_nic_index
)) << 16)));
959 nesadapter
->pft_mcast_map
[mc_index
] =
962 nes_debug(NES_DBG_NIC_RX
, "Clearing MC Address at register 0x%04X\n",
963 perfect_filter_register_address
+(mc_index
* 8));
964 nes_write_indexed(nesdev
,
965 perfect_filter_register_address
+4+(mc_index
* 8),
967 nesadapter
->pft_mcast_map
[mc_index
] = 255;
971 /* PFT is not large enough */
973 set_allmulti(nesdev
, nic_active_bit
);
977 spin_unlock_irqrestore(&nesadapter
->resource_lock
, flags
);
982 * nes_netdev_change_mtu
984 static int nes_netdev_change_mtu(struct net_device
*netdev
, int new_mtu
)
986 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
987 struct nes_device
*nesdev
= nesvnic
->nesdev
;
995 if ((new_mtu
< ETH_ZLEN
) || (new_mtu
> max_mtu
))
998 netdev
->mtu
= new_mtu
;
999 nesvnic
->max_frame_size
= new_mtu
+ VLAN_ETH_HLEN
;
1001 if (netdev
->mtu
> 1500) {
1004 nes_nic_init_timer_defaults(nesdev
, jumbomode
);
1006 if (netif_running(netdev
)) {
1007 nic_active_bit
= 1 << nesvnic
->nic_index
;
1008 mc_all_active
= nes_read_indexed(nesdev
,
1009 NES_IDX_NIC_MULTICAST_ALL
) & nic_active_bit
;
1010 uc_all_active
= nes_read_indexed(nesdev
,
1011 NES_IDX_NIC_UNICAST_ALL
) & nic_active_bit
;
1013 nes_netdev_stop(netdev
);
1014 nes_netdev_open(netdev
);
1016 nic_active
= nes_read_indexed(nesdev
,
1017 NES_IDX_NIC_MULTICAST_ALL
);
1018 nic_active
|= mc_all_active
;
1019 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
,
1022 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
1023 nic_active
|= uc_all_active
;
1024 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
1031 static const char nes_ethtool_stringset
[][ETH_GSTRING_LEN
] = {
1032 "Link Change Interrupts",
1035 "Pause Frames Sent",
1036 "Pause Frames Received",
1037 "Internal Routing Errors",
1038 "SQ SW Dropped SKBs",
1040 "Segmented TSO Requests",
1043 "Rx Oversized Frames",
1048 "Endnode Rx Discards",
1049 "Endnode Rx Octets",
1050 "Endnode Rx Frames",
1051 "Endnode Tx Octets",
1052 "Endnode Tx Frames",
1056 "Retransmission Count",
1063 "ModifyQP Timeouts",
1069 "CM Packets Bounced",
1070 "CM Packets Created",
1072 "CM Packets Dropped",
1073 "CM Packets Retrans",
1074 "CM Listens Created",
1075 "CM Listens Destroyed",
1079 "CM Nodes Destroyed",
1081 "CM Resets Received",
1088 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1092 * nes_netdev_get_sset_count
1094 static int nes_netdev_get_sset_count(struct net_device
*netdev
, int stringset
)
1096 if (stringset
== ETH_SS_STATS
)
1097 return NES_ETHTOOL_STAT_COUNT
;
1104 * nes_netdev_get_strings
1106 static void nes_netdev_get_strings(struct net_device
*netdev
, u32 stringset
,
1107 u8
*ethtool_strings
)
1109 if (stringset
== ETH_SS_STATS
)
1110 memcpy(ethtool_strings
,
1111 &nes_ethtool_stringset
,
1112 sizeof(nes_ethtool_stringset
));
1117 * nes_netdev_get_ethtool_stats
1120 static void nes_netdev_get_ethtool_stats(struct net_device
*netdev
,
1121 struct ethtool_stats
*target_ethtool_stats
, u64
*target_stat_values
)
1124 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1125 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1126 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1131 target_ethtool_stats
->n_stats
= NES_ETHTOOL_STAT_COUNT
;
1132 target_stat_values
[index
] = nesvnic
->nesdev
->link_status_interrupts
;
1133 target_stat_values
[++index
] = nesvnic
->linearized_skbs
;
1134 target_stat_values
[++index
] = nesvnic
->tso_requests
;
1136 u32temp
= nes_read_indexed(nesdev
,
1137 NES_IDX_MAC_TX_PAUSE_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1138 nesvnic
->nesdev
->mac_pause_frames_sent
+= u32temp
;
1139 target_stat_values
[++index
] = nesvnic
->nesdev
->mac_pause_frames_sent
;
1141 u32temp
= nes_read_indexed(nesdev
,
1142 NES_IDX_MAC_RX_PAUSE_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1143 nesvnic
->nesdev
->mac_pause_frames_received
+= u32temp
;
1145 u32temp
= nes_read_indexed(nesdev
,
1146 NES_IDX_PORT_RX_DISCARDS
+ (nesvnic
->nesdev
->mac_index
*0x40));
1147 nesvnic
->nesdev
->port_rx_discards
+= u32temp
;
1148 nesvnic
->netstats
.rx_dropped
+= u32temp
;
1150 u32temp
= nes_read_indexed(nesdev
,
1151 NES_IDX_PORT_TX_DISCARDS
+ (nesvnic
->nesdev
->mac_index
*0x40));
1152 nesvnic
->nesdev
->port_tx_discards
+= u32temp
;
1153 nesvnic
->netstats
.tx_dropped
+= u32temp
;
1155 u32temp
= nes_read_indexed(nesdev
,
1156 NES_IDX_MAC_RX_SHORT_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1157 nesvnic
->netstats
.rx_dropped
+= u32temp
;
1158 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
1159 nesvnic
->nesdev
->mac_rx_short_frames
+= u32temp
;
1161 u32temp
= nes_read_indexed(nesdev
,
1162 NES_IDX_MAC_RX_OVERSIZED_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1163 nesvnic
->netstats
.rx_dropped
+= u32temp
;
1164 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
1165 nesvnic
->nesdev
->mac_rx_oversized_frames
+= u32temp
;
1167 u32temp
= nes_read_indexed(nesdev
,
1168 NES_IDX_MAC_RX_JABBER_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1169 nesvnic
->netstats
.rx_dropped
+= u32temp
;
1170 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
1171 nesvnic
->nesdev
->mac_rx_jabber_frames
+= u32temp
;
1173 u32temp
= nes_read_indexed(nesdev
,
1174 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1175 nesvnic
->netstats
.rx_dropped
+= u32temp
;
1176 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
1177 nesvnic
->nesdev
->mac_rx_symbol_err_frames
+= u32temp
;
1179 u32temp
= nes_read_indexed(nesdev
,
1180 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1181 nesvnic
->netstats
.rx_length_errors
+= u32temp
;
1182 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
1184 u32temp
= nes_read_indexed(nesdev
,
1185 NES_IDX_MAC_RX_CRC_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1186 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
1187 nesvnic
->nesdev
->mac_rx_crc_errors
+= u32temp
;
1188 nesvnic
->netstats
.rx_crc_errors
+= u32temp
;
1190 u32temp
= nes_read_indexed(nesdev
,
1191 NES_IDX_MAC_TX_ERRORS
+ (nesvnic
->nesdev
->mac_index
*0x200));
1192 nesvnic
->nesdev
->mac_tx_errors
+= u32temp
;
1193 nesvnic
->netstats
.tx_errors
+= u32temp
;
1195 for (nic_count
= 0; nic_count
< NES_MAX_PORT_COUNT
; nic_count
++) {
1196 if (nesvnic
->qp_nic_index
[nic_count
] == 0xf)
1199 u32temp
= nes_read_indexed(nesdev
,
1200 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD
+
1201 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1202 nesvnic
->netstats
.rx_dropped
+= u32temp
;
1203 nesvnic
->endnode_nstat_rx_discard
+= u32temp
;
1205 u64temp
= (u64
)nes_read_indexed(nesdev
,
1206 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO
+
1207 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1208 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
1209 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI
+
1210 (nesvnic
->qp_nic_index
[nic_count
]*0x200))) << 32;
1212 nesvnic
->endnode_nstat_rx_octets
+= u64temp
;
1213 nesvnic
->netstats
.rx_bytes
+= u64temp
;
1215 u64temp
= (u64
)nes_read_indexed(nesdev
,
1216 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO
+
1217 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1218 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
1219 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI
+
1220 (nesvnic
->qp_nic_index
[nic_count
]*0x200))) << 32;
1222 nesvnic
->endnode_nstat_rx_frames
+= u64temp
;
1223 nesvnic
->netstats
.rx_packets
+= u64temp
;
1225 u64temp
= (u64
)nes_read_indexed(nesdev
,
1226 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO
+
1227 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1228 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
1229 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI
+
1230 (nesvnic
->qp_nic_index
[nic_count
]*0x200))) << 32;
1232 nesvnic
->endnode_nstat_tx_octets
+= u64temp
;
1233 nesvnic
->netstats
.tx_bytes
+= u64temp
;
1235 u64temp
= (u64
)nes_read_indexed(nesdev
,
1236 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO
+
1237 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1238 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
1239 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI
+
1240 (nesvnic
->qp_nic_index
[nic_count
]*0x200))) << 32;
1242 nesvnic
->endnode_nstat_tx_frames
+= u64temp
;
1243 nesvnic
->netstats
.tx_packets
+= u64temp
;
1245 u32temp
= nes_read_indexed(nesdev
,
1246 NES_IDX_IPV4_TCP_REXMITS
+ (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1247 nesvnic
->endnode_ipv4_tcp_retransmits
+= u32temp
;
1250 target_stat_values
[++index
] = nesvnic
->nesdev
->mac_pause_frames_received
;
1251 target_stat_values
[++index
] = nesdev
->nesadapter
->nic_rx_eth_route_err
;
1252 target_stat_values
[++index
] = nesvnic
->tx_sw_dropped
;
1253 target_stat_values
[++index
] = nesvnic
->sq_full
;
1254 target_stat_values
[++index
] = nesvnic
->segmented_tso_requests
;
1255 target_stat_values
[++index
] = nesvnic
->nesdev
->mac_rx_symbol_err_frames
;
1256 target_stat_values
[++index
] = nesvnic
->nesdev
->mac_rx_jabber_frames
;
1257 target_stat_values
[++index
] = nesvnic
->nesdev
->mac_rx_oversized_frames
;
1258 target_stat_values
[++index
] = nesvnic
->nesdev
->mac_rx_short_frames
;
1259 target_stat_values
[++index
] = nesvnic
->netstats
.rx_length_errors
;
1260 target_stat_values
[++index
] = nesvnic
->nesdev
->mac_rx_crc_errors
;
1261 target_stat_values
[++index
] = nesvnic
->nesdev
->port_rx_discards
;
1262 target_stat_values
[++index
] = nesvnic
->endnode_nstat_rx_discard
;
1263 target_stat_values
[++index
] = nesvnic
->endnode_nstat_rx_octets
;
1264 target_stat_values
[++index
] = nesvnic
->endnode_nstat_rx_frames
;
1265 target_stat_values
[++index
] = nesvnic
->endnode_nstat_tx_octets
;
1266 target_stat_values
[++index
] = nesvnic
->endnode_nstat_tx_frames
;
1267 target_stat_values
[++index
] = nesvnic
->nesdev
->mac_tx_errors
;
1268 target_stat_values
[++index
] = mh_detected
;
1269 target_stat_values
[++index
] = mh_pauses_sent
;
1270 target_stat_values
[++index
] = nesvnic
->endnode_ipv4_tcp_retransmits
;
1271 target_stat_values
[++index
] = atomic_read(&cm_connects
);
1272 target_stat_values
[++index
] = atomic_read(&cm_accepts
);
1273 target_stat_values
[++index
] = atomic_read(&cm_disconnects
);
1274 target_stat_values
[++index
] = atomic_read(&cm_connecteds
);
1275 target_stat_values
[++index
] = atomic_read(&cm_connect_reqs
);
1276 target_stat_values
[++index
] = atomic_read(&cm_rejects
);
1277 target_stat_values
[++index
] = atomic_read(&mod_qp_timouts
);
1278 target_stat_values
[++index
] = atomic_read(&qps_created
);
1279 target_stat_values
[++index
] = atomic_read(&sw_qps_destroyed
);
1280 target_stat_values
[++index
] = atomic_read(&qps_destroyed
);
1281 target_stat_values
[++index
] = atomic_read(&cm_closes
);
1282 target_stat_values
[++index
] = cm_packets_sent
;
1283 target_stat_values
[++index
] = cm_packets_bounced
;
1284 target_stat_values
[++index
] = cm_packets_created
;
1285 target_stat_values
[++index
] = cm_packets_received
;
1286 target_stat_values
[++index
] = cm_packets_dropped
;
1287 target_stat_values
[++index
] = cm_packets_retrans
;
1288 target_stat_values
[++index
] = atomic_read(&cm_listens_created
);
1289 target_stat_values
[++index
] = atomic_read(&cm_listens_destroyed
);
1290 target_stat_values
[++index
] = cm_backlog_drops
;
1291 target_stat_values
[++index
] = atomic_read(&cm_loopbacks
);
1292 target_stat_values
[++index
] = atomic_read(&cm_nodes_created
);
1293 target_stat_values
[++index
] = atomic_read(&cm_nodes_destroyed
);
1294 target_stat_values
[++index
] = atomic_read(&cm_accel_dropped_pkts
);
1295 target_stat_values
[++index
] = atomic_read(&cm_resets_recvd
);
1296 target_stat_values
[++index
] = nesadapter
->free_4kpbl
;
1297 target_stat_values
[++index
] = nesadapter
->free_256pbl
;
1298 target_stat_values
[++index
] = int_mod_timer_init
;
1299 target_stat_values
[++index
] = atomic_read(&pau_qps_created
);
1300 target_stat_values
[++index
] = atomic_read(&pau_qps_destroyed
);
1304 * nes_netdev_get_drvinfo
1306 static void nes_netdev_get_drvinfo(struct net_device
*netdev
,
1307 struct ethtool_drvinfo
*drvinfo
)
1309 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1310 struct nes_adapter
*nesadapter
= nesvnic
->nesdev
->nesadapter
;
1312 strlcpy(drvinfo
->driver
, DRV_NAME
, sizeof(drvinfo
->driver
));
1313 strlcpy(drvinfo
->bus_info
, pci_name(nesvnic
->nesdev
->pcidev
),
1314 sizeof(drvinfo
->bus_info
));
1315 snprintf(drvinfo
->fw_version
, sizeof(drvinfo
->fw_version
),
1316 "%u.%u", nesadapter
->firmware_version
>> 16,
1317 nesadapter
->firmware_version
& 0x000000ff);
1318 strlcpy(drvinfo
->version
, DRV_VERSION
, sizeof(drvinfo
->version
));
1323 * nes_netdev_set_coalesce
1325 static int nes_netdev_set_coalesce(struct net_device
*netdev
,
1326 struct ethtool_coalesce
*et_coalesce
)
1328 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1329 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1330 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1331 struct nes_hw_tune_timer
*shared_timer
= &nesadapter
->tune_timer
;
1332 unsigned long flags
;
1334 spin_lock_irqsave(&nesadapter
->periodic_timer_lock
, flags
);
1335 if (et_coalesce
->rx_max_coalesced_frames_low
) {
1336 shared_timer
->threshold_low
= et_coalesce
->rx_max_coalesced_frames_low
;
1338 if (et_coalesce
->rx_max_coalesced_frames_irq
) {
1339 shared_timer
->threshold_target
= et_coalesce
->rx_max_coalesced_frames_irq
;
1341 if (et_coalesce
->rx_max_coalesced_frames_high
) {
1342 shared_timer
->threshold_high
= et_coalesce
->rx_max_coalesced_frames_high
;
1344 if (et_coalesce
->rx_coalesce_usecs_low
) {
1345 shared_timer
->timer_in_use_min
= et_coalesce
->rx_coalesce_usecs_low
;
1347 if (et_coalesce
->rx_coalesce_usecs_high
) {
1348 shared_timer
->timer_in_use_max
= et_coalesce
->rx_coalesce_usecs_high
;
1350 spin_unlock_irqrestore(&nesadapter
->periodic_timer_lock
, flags
);
1352 /* using this to drive total interrupt moderation */
1353 nesadapter
->et_rx_coalesce_usecs_irq
= et_coalesce
->rx_coalesce_usecs_irq
;
1354 if (et_coalesce
->use_adaptive_rx_coalesce
) {
1355 nesadapter
->et_use_adaptive_rx_coalesce
= 1;
1356 nesadapter
->timer_int_limit
= NES_TIMER_INT_LIMIT_DYNAMIC
;
1357 nesadapter
->et_rx_coalesce_usecs_irq
= 0;
1358 if (et_coalesce
->pkt_rate_low
) {
1359 nesadapter
->et_pkt_rate_low
= et_coalesce
->pkt_rate_low
;
1362 nesadapter
->et_use_adaptive_rx_coalesce
= 0;
1363 nesadapter
->timer_int_limit
= NES_TIMER_INT_LIMIT
;
1364 if (nesadapter
->et_rx_coalesce_usecs_irq
) {
1365 nes_write32(nesdev
->regs
+NES_PERIODIC_CONTROL
,
1366 0x80000000 | ((u32
)(nesadapter
->et_rx_coalesce_usecs_irq
*8)));
1374 * nes_netdev_get_coalesce
1376 static int nes_netdev_get_coalesce(struct net_device
*netdev
,
1377 struct ethtool_coalesce
*et_coalesce
)
1379 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1380 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1381 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1382 struct ethtool_coalesce temp_et_coalesce
;
1383 struct nes_hw_tune_timer
*shared_timer
= &nesadapter
->tune_timer
;
1384 unsigned long flags
;
1386 memset(&temp_et_coalesce
, 0, sizeof(temp_et_coalesce
));
1387 temp_et_coalesce
.rx_coalesce_usecs_irq
= nesadapter
->et_rx_coalesce_usecs_irq
;
1388 temp_et_coalesce
.use_adaptive_rx_coalesce
= nesadapter
->et_use_adaptive_rx_coalesce
;
1389 temp_et_coalesce
.rate_sample_interval
= nesadapter
->et_rate_sample_interval
;
1390 temp_et_coalesce
.pkt_rate_low
= nesadapter
->et_pkt_rate_low
;
1391 spin_lock_irqsave(&nesadapter
->periodic_timer_lock
, flags
);
1392 temp_et_coalesce
.rx_max_coalesced_frames_low
= shared_timer
->threshold_low
;
1393 temp_et_coalesce
.rx_max_coalesced_frames_irq
= shared_timer
->threshold_target
;
1394 temp_et_coalesce
.rx_max_coalesced_frames_high
= shared_timer
->threshold_high
;
1395 temp_et_coalesce
.rx_coalesce_usecs_low
= shared_timer
->timer_in_use_min
;
1396 temp_et_coalesce
.rx_coalesce_usecs_high
= shared_timer
->timer_in_use_max
;
1397 if (nesadapter
->et_use_adaptive_rx_coalesce
) {
1398 temp_et_coalesce
.rx_coalesce_usecs_irq
= shared_timer
->timer_in_use
;
1400 spin_unlock_irqrestore(&nesadapter
->periodic_timer_lock
, flags
);
1401 memcpy(et_coalesce
, &temp_et_coalesce
, sizeof(*et_coalesce
));
1407 * nes_netdev_get_pauseparam
1409 static void nes_netdev_get_pauseparam(struct net_device
*netdev
,
1410 struct ethtool_pauseparam
*et_pauseparam
)
1412 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1414 et_pauseparam
->autoneg
= 0;
1415 et_pauseparam
->rx_pause
= (nesvnic
->nesdev
->disable_rx_flow_control
== 0) ? 1:0;
1416 et_pauseparam
->tx_pause
= (nesvnic
->nesdev
->disable_tx_flow_control
== 0) ? 1:0;
1421 * nes_netdev_set_pauseparam
1423 static int nes_netdev_set_pauseparam(struct net_device
*netdev
,
1424 struct ethtool_pauseparam
*et_pauseparam
)
1426 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1427 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1430 if (et_pauseparam
->autoneg
) {
1431 /* TODO: should return unsupported */
1434 if ((et_pauseparam
->tx_pause
== 1) && (nesdev
->disable_tx_flow_control
== 1)) {
1435 u32temp
= nes_read_indexed(nesdev
,
1436 NES_IDX_MAC_TX_CONFIG
+ (nesdev
->mac_index
*0x200));
1437 u32temp
|= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE
;
1438 nes_write_indexed(nesdev
,
1439 NES_IDX_MAC_TX_CONFIG
+ (nesdev
->mac_index
*0x200), u32temp
);
1440 nesdev
->disable_tx_flow_control
= 0;
1441 } else if ((et_pauseparam
->tx_pause
== 0) && (nesdev
->disable_tx_flow_control
== 0)) {
1442 u32temp
= nes_read_indexed(nesdev
,
1443 NES_IDX_MAC_TX_CONFIG
+ (nesdev
->mac_index
*0x200));
1444 u32temp
&= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE
;
1445 nes_write_indexed(nesdev
,
1446 NES_IDX_MAC_TX_CONFIG
+ (nesdev
->mac_index
*0x200), u32temp
);
1447 nesdev
->disable_tx_flow_control
= 1;
1449 if ((et_pauseparam
->rx_pause
== 1) && (nesdev
->disable_rx_flow_control
== 1)) {
1450 u32temp
= nes_read_indexed(nesdev
,
1451 NES_IDX_MPP_DEBUG
+ (nesdev
->mac_index
*0x40));
1452 u32temp
&= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE
;
1453 nes_write_indexed(nesdev
,
1454 NES_IDX_MPP_DEBUG
+ (nesdev
->mac_index
*0x40), u32temp
);
1455 nesdev
->disable_rx_flow_control
= 0;
1456 } else if ((et_pauseparam
->rx_pause
== 0) && (nesdev
->disable_rx_flow_control
== 0)) {
1457 u32temp
= nes_read_indexed(nesdev
,
1458 NES_IDX_MPP_DEBUG
+ (nesdev
->mac_index
*0x40));
1459 u32temp
|= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE
;
1460 nes_write_indexed(nesdev
,
1461 NES_IDX_MPP_DEBUG
+ (nesdev
->mac_index
*0x40), u32temp
);
1462 nesdev
->disable_rx_flow_control
= 1;
1470 * nes_netdev_get_settings
1472 static int nes_netdev_get_link_ksettings(struct net_device
*netdev
,
1473 struct ethtool_link_ksettings
*cmd
)
1475 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1476 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1477 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1478 u32 mac_index
= nesdev
->mac_index
;
1479 u8 phy_type
= nesadapter
->phy_type
[mac_index
];
1480 u8 phy_index
= nesadapter
->phy_index
[mac_index
];
1482 u32 supported
, advertising
;
1484 cmd
->base
.duplex
= DUPLEX_FULL
;
1485 cmd
->base
.port
= PORT_MII
;
1487 if (nesadapter
->OneG_Mode
) {
1488 cmd
->base
.speed
= SPEED_1000
;
1489 if (phy_type
== NES_PHY_TYPE_PUMA_1G
) {
1490 supported
= SUPPORTED_1000baseT_Full
;
1491 advertising
= ADVERTISED_1000baseT_Full
;
1492 cmd
->base
.autoneg
= AUTONEG_DISABLE
;
1493 cmd
->base
.phy_address
= mac_index
;
1495 unsigned long flags
;
1497 supported
= SUPPORTED_1000baseT_Full
1498 | SUPPORTED_Autoneg
;
1499 advertising
= ADVERTISED_1000baseT_Full
1500 | ADVERTISED_Autoneg
;
1501 spin_lock_irqsave(&nesadapter
->phy_lock
, flags
);
1502 nes_read_1G_phy_reg(nesdev
, 0, phy_index
, &phy_data
);
1503 spin_unlock_irqrestore(&nesadapter
->phy_lock
, flags
);
1504 if (phy_data
& 0x1000)
1505 cmd
->base
.autoneg
= AUTONEG_ENABLE
;
1507 cmd
->base
.autoneg
= AUTONEG_DISABLE
;
1508 cmd
->base
.phy_address
= phy_index
;
1510 ethtool_convert_legacy_u32_to_link_mode(
1511 cmd
->link_modes
.supported
, supported
);
1512 ethtool_convert_legacy_u32_to_link_mode(
1513 cmd
->link_modes
.advertising
, advertising
);
1516 if ((phy_type
== NES_PHY_TYPE_ARGUS
) ||
1517 (phy_type
== NES_PHY_TYPE_SFP_D
) ||
1518 (phy_type
== NES_PHY_TYPE_KR
)) {
1519 cmd
->base
.port
= PORT_FIBRE
;
1520 supported
= SUPPORTED_FIBRE
;
1521 advertising
= ADVERTISED_FIBRE
;
1522 cmd
->base
.phy_address
= phy_index
;
1524 supported
= SUPPORTED_10000baseT_Full
;
1525 advertising
= ADVERTISED_10000baseT_Full
;
1526 cmd
->base
.phy_address
= mac_index
;
1528 cmd
->base
.speed
= SPEED_10000
;
1529 cmd
->base
.autoneg
= AUTONEG_DISABLE
;
1530 ethtool_convert_legacy_u32_to_link_mode(cmd
->link_modes
.supported
,
1532 ethtool_convert_legacy_u32_to_link_mode(cmd
->link_modes
.advertising
,
1540 * nes_netdev_set_settings
1543 nes_netdev_set_link_ksettings(struct net_device
*netdev
,
1544 const struct ethtool_link_ksettings
*cmd
)
1546 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1547 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1548 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1550 if ((nesadapter
->OneG_Mode
) &&
1551 (nesadapter
->phy_type
[nesdev
->mac_index
] != NES_PHY_TYPE_PUMA_1G
)) {
1552 unsigned long flags
;
1554 u8 phy_index
= nesadapter
->phy_index
[nesdev
->mac_index
];
1556 spin_lock_irqsave(&nesadapter
->phy_lock
, flags
);
1557 nes_read_1G_phy_reg(nesdev
, 0, phy_index
, &phy_data
);
1558 if (cmd
->base
.autoneg
) {
1559 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1562 /* Turn off autoneg */
1563 phy_data
&= ~0x1000;
1565 nes_write_1G_phy_reg(nesdev
, 0, phy_index
, phy_data
);
1566 spin_unlock_irqrestore(&nesadapter
->phy_lock
, flags
);
1573 static const struct ethtool_ops nes_ethtool_ops
= {
1574 .get_link
= ethtool_op_get_link
,
1575 .get_strings
= nes_netdev_get_strings
,
1576 .get_sset_count
= nes_netdev_get_sset_count
,
1577 .get_ethtool_stats
= nes_netdev_get_ethtool_stats
,
1578 .get_drvinfo
= nes_netdev_get_drvinfo
,
1579 .get_coalesce
= nes_netdev_get_coalesce
,
1580 .set_coalesce
= nes_netdev_set_coalesce
,
1581 .get_pauseparam
= nes_netdev_get_pauseparam
,
1582 .set_pauseparam
= nes_netdev_set_pauseparam
,
1583 .get_link_ksettings
= nes_netdev_get_link_ksettings
,
1584 .set_link_ksettings
= nes_netdev_set_link_ksettings
,
1587 static void nes_vlan_mode(struct net_device
*netdev
, struct nes_device
*nesdev
, netdev_features_t features
)
1589 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1591 unsigned long flags
;
1593 spin_lock_irqsave(&nesadapter
->phy_lock
, flags
);
1595 nes_debug(NES_DBG_NETDEV
, "%s: %s\n", __func__
, netdev
->name
);
1597 /* Enable/Disable VLAN Stripping */
1598 u32temp
= nes_read_indexed(nesdev
, NES_IDX_PCIX_DIAG
);
1599 if (features
& NETIF_F_HW_VLAN_CTAG_RX
)
1600 u32temp
&= 0xfdffffff;
1602 u32temp
|= 0x02000000;
1604 nes_write_indexed(nesdev
, NES_IDX_PCIX_DIAG
, u32temp
);
1605 spin_unlock_irqrestore(&nesadapter
->phy_lock
, flags
);
1608 static netdev_features_t
nes_fix_features(struct net_device
*netdev
, netdev_features_t features
)
1611 * Since there is no support for separate rx/tx vlan accel
1612 * enable/disable make sure tx flag is always in same state as rx.
1614 if (features
& NETIF_F_HW_VLAN_CTAG_RX
)
1615 features
|= NETIF_F_HW_VLAN_CTAG_TX
;
1617 features
&= ~NETIF_F_HW_VLAN_CTAG_TX
;
1622 static int nes_set_features(struct net_device
*netdev
, netdev_features_t features
)
1624 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1625 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1626 u32 changed
= netdev
->features
^ features
;
1628 if (changed
& NETIF_F_HW_VLAN_CTAG_RX
)
1629 nes_vlan_mode(netdev
, nesdev
, features
);
1634 static const struct net_device_ops nes_netdev_ops
= {
1635 .ndo_open
= nes_netdev_open
,
1636 .ndo_stop
= nes_netdev_stop
,
1637 .ndo_start_xmit
= nes_netdev_start_xmit
,
1638 .ndo_get_stats
= nes_netdev_get_stats
,
1639 .ndo_tx_timeout
= nes_netdev_tx_timeout
,
1640 .ndo_set_mac_address
= nes_netdev_set_mac_address
,
1641 .ndo_set_rx_mode
= nes_netdev_set_multicast_list
,
1642 .ndo_change_mtu
= nes_netdev_change_mtu
,
1643 .ndo_validate_addr
= eth_validate_addr
,
1644 .ndo_fix_features
= nes_fix_features
,
1645 .ndo_set_features
= nes_set_features
,
1649 * nes_netdev_init - initialize network device
1651 struct net_device
*nes_netdev_init(struct nes_device
*nesdev
,
1652 void __iomem
*mmio_addr
)
1655 struct nes_vnic
*nesvnic
;
1656 struct net_device
*netdev
;
1657 struct nic_qp_map
*curr_qp_map
;
1658 u8 phy_type
= nesdev
->nesadapter
->phy_type
[nesdev
->mac_index
];
1660 netdev
= alloc_etherdev(sizeof(struct nes_vnic
));
1662 printk(KERN_ERR PFX
"nesvnic etherdev alloc failed");
1665 nesvnic
= netdev_priv(netdev
);
1667 nes_debug(NES_DBG_INIT
, "netdev = %p, %s\n", netdev
, netdev
->name
);
1669 SET_NETDEV_DEV(netdev
, &nesdev
->pcidev
->dev
);
1671 netdev
->watchdog_timeo
= NES_TX_TIMEOUT
;
1672 netdev
->irq
= nesdev
->pcidev
->irq
;
1673 netdev
->mtu
= ETH_DATA_LEN
;
1674 netdev
->hard_header_len
= ETH_HLEN
;
1675 netdev
->addr_len
= ETH_ALEN
;
1676 netdev
->type
= ARPHRD_ETHER
;
1677 netdev
->netdev_ops
= &nes_netdev_ops
;
1678 netdev
->ethtool_ops
= &nes_ethtool_ops
;
1679 netif_napi_add(netdev
, &nesvnic
->napi
, nes_netdev_poll
, 128);
1680 nes_debug(NES_DBG_INIT
, "Enabling VLAN Insert/Delete.\n");
1682 /* Fill in the port structure */
1683 nesvnic
->netdev
= netdev
;
1684 nesvnic
->nesdev
= nesdev
;
1685 nesvnic
->msg_enable
= netif_msg_init(debug
, default_msg
);
1686 nesvnic
->netdev_index
= nesdev
->netdev_count
;
1687 nesvnic
->perfect_filter_index
= nesdev
->nesadapter
->netdev_count
;
1688 nesvnic
->max_frame_size
= netdev
->mtu
+ netdev
->hard_header_len
+ VLAN_HLEN
;
1690 curr_qp_map
= nic_qp_mapping_per_function
[PCI_FUNC(nesdev
->pcidev
->devfn
)];
1691 nesvnic
->nic
.qp_id
= curr_qp_map
[nesdev
->netdev_count
].qpid
;
1692 nesvnic
->nic_index
= curr_qp_map
[nesdev
->netdev_count
].nic_index
;
1693 nesvnic
->logical_port
= curr_qp_map
[nesdev
->netdev_count
].logical_port
;
1695 /* Setup the burned in MAC address */
1696 u64temp
= (u64
)nesdev
->nesadapter
->mac_addr_low
;
1697 u64temp
+= ((u64
)nesdev
->nesadapter
->mac_addr_high
) << 32;
1698 u64temp
+= nesvnic
->nic_index
;
1699 netdev
->dev_addr
[0] = (u8
)(u64temp
>>40);
1700 netdev
->dev_addr
[1] = (u8
)(u64temp
>>32);
1701 netdev
->dev_addr
[2] = (u8
)(u64temp
>>24);
1702 netdev
->dev_addr
[3] = (u8
)(u64temp
>>16);
1703 netdev
->dev_addr
[4] = (u8
)(u64temp
>>8);
1704 netdev
->dev_addr
[5] = (u8
)u64temp
;
1706 netdev
->hw_features
= NETIF_F_SG
| NETIF_F_IP_CSUM
| NETIF_F_RXCSUM
| NETIF_F_HW_VLAN_CTAG_RX
;
1707 if ((nesvnic
->logical_port
< 2) || (nesdev
->nesadapter
->hw_rev
!= NE020_REV
))
1708 netdev
->hw_features
|= NETIF_F_TSO
;
1710 netdev
->features
= netdev
->hw_features
| NETIF_F_HIGHDMA
| NETIF_F_HW_VLAN_CTAG_TX
;
1712 nes_debug(NES_DBG_INIT
, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1713 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1714 nesvnic
, (unsigned long)netdev
->features
, nesvnic
->nic
.qp_id
,
1715 nesvnic
->nic_index
, nesvnic
->logical_port
, nesdev
->mac_index
);
1717 if (nesvnic
->nesdev
->nesadapter
->port_count
== 1 &&
1718 nesvnic
->nesdev
->nesadapter
->adapter_fcn_count
== 1) {
1720 nesvnic
->qp_nic_index
[0] = nesvnic
->nic_index
;
1721 nesvnic
->qp_nic_index
[1] = nesvnic
->nic_index
+ 1;
1722 if (nes_drv_opt
& NES_DRV_OPT_DUAL_LOGICAL_PORT
) {
1723 nesvnic
->qp_nic_index
[2] = 0xf;
1724 nesvnic
->qp_nic_index
[3] = 0xf;
1726 nesvnic
->qp_nic_index
[2] = nesvnic
->nic_index
+ 2;
1727 nesvnic
->qp_nic_index
[3] = nesvnic
->nic_index
+ 3;
1730 if (nesvnic
->nesdev
->nesadapter
->port_count
== 2 ||
1731 (nesvnic
->nesdev
->nesadapter
->port_count
== 1 &&
1732 nesvnic
->nesdev
->nesadapter
->adapter_fcn_count
== 2)) {
1733 nesvnic
->qp_nic_index
[0] = nesvnic
->nic_index
;
1734 nesvnic
->qp_nic_index
[1] = nesvnic
->nic_index
1736 nesvnic
->qp_nic_index
[2] = 0xf;
1737 nesvnic
->qp_nic_index
[3] = 0xf;
1739 nesvnic
->qp_nic_index
[0] = nesvnic
->nic_index
;
1740 nesvnic
->qp_nic_index
[1] = 0xf;
1741 nesvnic
->qp_nic_index
[2] = 0xf;
1742 nesvnic
->qp_nic_index
[3] = 0xf;
1745 nesvnic
->next_qp_nic_index
= 0;
1747 if (nesdev
->netdev_count
== 0) {
1748 nesvnic
->rdma_enabled
= 1;
1750 nesvnic
->rdma_enabled
= 0;
1752 nesvnic
->nic_cq
.cq_number
= nesvnic
->nic
.qp_id
;
1753 init_timer(&nesvnic
->event_timer
);
1754 nesvnic
->event_timer
.function
= NULL
;
1755 spin_lock_init(&nesvnic
->tx_lock
);
1756 spin_lock_init(&nesvnic
->port_ibevent_lock
);
1757 nesdev
->netdev
[nesdev
->netdev_count
] = netdev
;
1759 nes_debug(NES_DBG_INIT
, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1760 nesvnic
, nesdev
->mac_index
);
1761 list_add_tail(&nesvnic
->list
, &nesdev
->nesadapter
->nesvnic_list
[nesdev
->mac_index
]);
1763 if ((nesdev
->netdev_count
== 0) &&
1764 ((PCI_FUNC(nesdev
->pcidev
->devfn
) == nesdev
->mac_index
) ||
1765 ((phy_type
== NES_PHY_TYPE_PUMA_1G
) &&
1766 (((PCI_FUNC(nesdev
->pcidev
->devfn
) == 1) && (nesdev
->mac_index
== 2)) ||
1767 ((PCI_FUNC(nesdev
->pcidev
->devfn
) == 2) && (nesdev
->mac_index
== 1)))))) {
1773 unsigned long flags
;
1775 u32temp
= nes_read_indexed(nesdev
, NES_IDX_PHY_PCS_CONTROL_STATUS0
+
1776 (0x200 * (nesdev
->mac_index
& 1)));
1777 if (phy_type
!= NES_PHY_TYPE_PUMA_1G
) {
1778 u32temp
|= 0x00200000;
1779 nes_write_indexed(nesdev
, NES_IDX_PHY_PCS_CONTROL_STATUS0
+
1780 (0x200 * (nesdev
->mac_index
& 1)), u32temp
);
1783 /* Check and set linkup here. This is for back to back */
1784 /* configuration where second port won't get link interrupt */
1786 case NES_PHY_TYPE_PUMA_1G
:
1787 if (nesdev
->mac_index
< 2) {
1788 link_mask
= 0x01010000;
1789 link_val
= 0x01010000;
1791 link_mask
= 0x02020000;
1792 link_val
= 0x02020000;
1795 case NES_PHY_TYPE_SFP_D
:
1796 spin_lock_irqsave(&nesdev
->nesadapter
->phy_lock
, flags
);
1797 nes_read_10G_phy_reg(nesdev
,
1798 nesdev
->nesadapter
->phy_index
[nesdev
->mac_index
],
1800 temp_phy_data
= (u16
)nes_read_indexed(nesdev
, NES_IDX_MAC_MDIO_CONTROL
);
1801 nes_read_10G_phy_reg(nesdev
,
1802 nesdev
->nesadapter
->phy_index
[nesdev
->mac_index
],
1804 nes_read_indexed(nesdev
, NES_IDX_MAC_MDIO_CONTROL
);
1805 nes_read_10G_phy_reg(nesdev
,
1806 nesdev
->nesadapter
->phy_index
[nesdev
->mac_index
],
1808 phy_data
= (u16
)nes_read_indexed(nesdev
, NES_IDX_MAC_MDIO_CONTROL
);
1809 spin_unlock_irqrestore(&nesdev
->nesadapter
->phy_lock
, flags
);
1810 phy_data
= (!temp_phy_data
&& (phy_data
== 0x8000)) ? 0x4 : 0x0;
1813 link_mask
= 0x0f1f0000;
1814 link_val
= 0x0f0f0000;
1818 u32temp
= nes_read_indexed(nesdev
,
1819 NES_IDX_PHY_PCS_CONTROL_STATUS0
+
1820 (0x200 * (nesdev
->mac_index
& 1)));
1822 if (phy_type
== NES_PHY_TYPE_SFP_D
) {
1823 if (phy_data
& 0x0004)
1824 nesvnic
->linkup
= 1;
1826 if ((u32temp
& link_mask
) == link_val
)
1827 nesvnic
->linkup
= 1;
1830 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1831 u32temp
= nes_read_indexed(nesdev
, NES_IDX_MAC_INT_STATUS
+ (0x200 * nesdev
->mac_index
));
1832 nes_debug(NES_DBG_INIT
, "Phy interrupt status = 0x%X.\n", u32temp
);
1833 nes_write_indexed(nesdev
, NES_IDX_MAC_INT_STATUS
+ (0x200 * nesdev
->mac_index
), u32temp
);
1835 nes_init_phy(nesdev
);
1838 nes_vlan_mode(netdev
, nesdev
, netdev
->features
);
1845 * nes_netdev_destroy - destroy network device structure
1847 void nes_netdev_destroy(struct net_device
*netdev
)
1849 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1851 /* make sure 'stop' method is called by Linux stack */
1852 /* nes_netdev_stop(netdev); */
1854 list_del(&nesvnic
->list
);
1856 if (nesvnic
->of_device_registered
) {
1857 nes_destroy_ofa_device(nesvnic
->nesibdev
);
1860 free_netdev(netdev
);
1865 * nes_nic_cm_xmit -- CM calls this to send out pkts
1867 int nes_nic_cm_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
1872 ret
= dev_queue_xmit(skb
);
1874 nes_debug(NES_DBG_CM
, "Bad return code from dev_queue_xmit %d\n", ret
);