2 * Copyright (c) 2006 - 2008 NetEffect, Inc. 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>
45 #include <net/inet_common.h>
46 #include <linux/inet.h>
50 static struct nic_qp_map nic_qp_mapping_0
[] = {
51 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
52 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
53 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
54 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
57 static struct nic_qp_map nic_qp_mapping_1
[] = {
58 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
59 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
62 static struct nic_qp_map nic_qp_mapping_2
[] = {
63 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
66 static struct nic_qp_map nic_qp_mapping_3
[] = {
67 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
70 static struct nic_qp_map nic_qp_mapping_4
[] = {
71 {28,8,0,0},{32,12,0,0}
74 static struct nic_qp_map nic_qp_mapping_5
[] = {
75 {29,9,1,0},{33,13,1,0}
78 static struct nic_qp_map nic_qp_mapping_6
[] = {
79 {30,10,2,0},{34,14,2,0}
82 static struct nic_qp_map nic_qp_mapping_7
[] = {
83 {31,11,3,0},{35,15,3,0}
86 static struct nic_qp_map
*nic_qp_mapping_per_function
[] = {
87 nic_qp_mapping_0
, nic_qp_mapping_1
, nic_qp_mapping_2
, nic_qp_mapping_3
,
88 nic_qp_mapping_4
, nic_qp_mapping_5
, nic_qp_mapping_6
, nic_qp_mapping_7
91 static const u32 default_msg
= NETIF_MSG_DRV
| NETIF_MSG_PROBE
| NETIF_MSG_LINK
92 | NETIF_MSG_IFUP
| NETIF_MSG_IFDOWN
;
93 static int debug
= -1;
94 static int nics_per_function
= 1;
99 static int nes_netdev_poll(struct napi_struct
*napi
, int budget
)
101 struct nes_vnic
*nesvnic
= container_of(napi
, struct nes_vnic
, napi
);
102 struct net_device
*netdev
= nesvnic
->netdev
;
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) {
115 netif_rx_complete(napi
);
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
;
148 assert(nesdev
!= NULL
);
150 if (nesvnic
->netdev_open
== 1)
153 if (netif_msg_ifup(nesvnic
))
154 printk(KERN_INFO PFX
"%s: enabling interface\n", netdev
->name
);
156 ret
= nes_init_nic_qp(nesdev
, netdev
);
161 netif_carrier_off(netdev
);
162 netif_stop_queue(netdev
);
164 if ((!nesvnic
->of_device_registered
) && (nesvnic
->rdma_enabled
)) {
165 nesvnic
->nesibdev
= nes_init_ofa_device(netdev
);
166 if (nesvnic
->nesibdev
== NULL
) {
167 printk(KERN_ERR PFX
"%s: nesvnic->nesibdev alloc failed", netdev
->name
);
169 nesvnic
->nesibdev
->nesvnic
= nesvnic
;
170 ret
= nes_register_ofa_device(nesvnic
->nesibdev
);
172 printk(KERN_ERR PFX
"%s: Unable to register RDMA device, ret = %d\n",
177 /* Set packet filters */
178 nic_active_bit
= 1 << nesvnic
->nic_index
;
179 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_ACTIVE
);
180 nic_active
|= nic_active_bit
;
181 nes_write_indexed(nesdev
, NES_IDX_NIC_ACTIVE
, nic_active
);
182 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ENABLE
);
183 nic_active
|= nic_active_bit
;
184 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ENABLE
, nic_active
);
185 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_BROADCAST_ON
);
186 nic_active
|= nic_active_bit
;
187 nes_write_indexed(nesdev
, NES_IDX_NIC_BROADCAST_ON
, nic_active
);
189 macaddr_high
= ((u16
)netdev
->dev_addr
[0]) << 8;
190 macaddr_high
+= (u16
)netdev
->dev_addr
[1];
192 macaddr_low
= ((u32
)netdev
->dev_addr
[2]) << 24;
193 macaddr_low
+= ((u32
)netdev
->dev_addr
[3]) << 16;
194 macaddr_low
+= ((u32
)netdev
->dev_addr
[4]) << 8;
195 macaddr_low
+= (u32
)netdev
->dev_addr
[5];
197 /* Program the various MAC regs */
198 for (i
= 0; i
< NES_MAX_PORT_COUNT
; i
++) {
199 if (nesvnic
->qp_nic_index
[i
] == 0xf) {
202 nes_debug(NES_DBG_NETDEV
, "i=%d, perfect filter table index= %d, PERF FILTER LOW"
203 " (Addr:%08X) = %08X, HIGH = %08X.\n",
204 i
, nesvnic
->qp_nic_index
[i
],
205 NES_IDX_PERFECT_FILTER_LOW
+
206 (nesvnic
->qp_nic_index
[i
] * 8),
208 (u32
)macaddr_high
| NES_MAC_ADDR_VALID
|
209 ((((u32
)nesvnic
->nic_index
) << 16)));
210 nes_write_indexed(nesdev
,
211 NES_IDX_PERFECT_FILTER_LOW
+ (nesvnic
->qp_nic_index
[i
] * 8),
213 nes_write_indexed(nesdev
,
214 NES_IDX_PERFECT_FILTER_HIGH
+ (nesvnic
->qp_nic_index
[i
] * 8),
215 (u32
)macaddr_high
| NES_MAC_ADDR_VALID
|
216 ((((u32
)nesvnic
->nic_index
) << 16)));
220 nes_write32(nesdev
->regs
+NES_CQE_ALLOC
, NES_CQE_ALLOC_NOTIFY_NEXT
|
221 nesvnic
->nic_cq
.cq_number
);
222 nes_read32(nesdev
->regs
+NES_CQE_ALLOC
);
223 list_for_each_safe(list_pos
, list_temp
, &nesdev
->nesadapter
->nesvnic_list
[nesdev
->mac_index
]) {
224 first_nesvnic
= container_of(list_pos
, struct nes_vnic
, list
);
225 if (first_nesvnic
->netdev_open
== 1)
228 if (first_nesvnic
->netdev_open
== 0) {
229 nes_debug(NES_DBG_INIT
, "Setting up MAC interrupt mask.\n");
230 nes_write_indexed(nesdev
, NES_IDX_MAC_INT_MASK
+ (0x200 * nesdev
->mac_index
),
231 ~(NES_MAC_INT_LINK_STAT_CHG
| NES_MAC_INT_XGMII_EXT
|
232 NES_MAC_INT_TX_UNDERFLOW
| NES_MAC_INT_TX_ERROR
));
233 first_nesvnic
= nesvnic
;
235 if (first_nesvnic
->linkup
) {
236 /* Enable network packets */
238 netif_start_queue(netdev
);
239 netif_carrier_on(netdev
);
241 napi_enable(&nesvnic
->napi
);
242 nesvnic
->netdev_open
= 1;
251 static int nes_netdev_stop(struct net_device
*netdev
)
253 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
254 struct nes_device
*nesdev
= nesvnic
->nesdev
;
257 struct nes_vnic
*first_nesvnic
= NULL
;
258 struct list_head
*list_pos
, *list_temp
;
260 nes_debug(NES_DBG_SHUTDOWN
, "nesvnic=%p, nesdev=%p, netdev=%p %s\n",
261 nesvnic
, nesdev
, netdev
, netdev
->name
);
262 if (nesvnic
->netdev_open
== 0)
265 if (netif_msg_ifdown(nesvnic
))
266 printk(KERN_INFO PFX
"%s: disabling interface\n", netdev
->name
);
268 /* Disable network packets */
269 napi_disable(&nesvnic
->napi
);
270 netif_stop_queue(netdev
);
271 list_for_each_safe(list_pos
, list_temp
, &nesdev
->nesadapter
->nesvnic_list
[nesdev
->mac_index
]) {
272 first_nesvnic
= container_of(list_pos
, struct nes_vnic
, list
);
273 if ((first_nesvnic
->netdev_open
== 1) && (first_nesvnic
!= nesvnic
))
277 if ((first_nesvnic
->netdev_open
== 1) && (first_nesvnic
!= nesvnic
) &&
278 (PCI_FUNC(first_nesvnic
->nesdev
->pcidev
->devfn
) !=
279 PCI_FUNC(nesvnic
->nesdev
->pcidev
->devfn
))) {
280 nes_write_indexed(nesdev
, NES_IDX_MAC_INT_MASK
+
281 (0x200*nesdev
->mac_index
), 0xffffffff);
282 nes_write_indexed(first_nesvnic
->nesdev
,
283 NES_IDX_MAC_INT_MASK
+
284 (0x200*first_nesvnic
->nesdev
->mac_index
),
285 ~(NES_MAC_INT_LINK_STAT_CHG
| NES_MAC_INT_XGMII_EXT
|
286 NES_MAC_INT_TX_UNDERFLOW
| NES_MAC_INT_TX_ERROR
));
288 nes_write_indexed(nesdev
, NES_IDX_MAC_INT_MASK
+(0x200*nesdev
->mac_index
), 0xffffffff);
291 nic_active_mask
= ~((u32
)(1 << nesvnic
->nic_index
));
292 nes_write_indexed(nesdev
, NES_IDX_PERFECT_FILTER_HIGH
+
293 (nesvnic
->perfect_filter_index
*8), 0);
294 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_ACTIVE
);
295 nic_active
&= nic_active_mask
;
296 nes_write_indexed(nesdev
, NES_IDX_NIC_ACTIVE
, nic_active
);
297 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
);
298 nic_active
&= nic_active_mask
;
299 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
, nic_active
);
300 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ENABLE
);
301 nic_active
&= nic_active_mask
;
302 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ENABLE
, nic_active
);
303 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
304 nic_active
&= nic_active_mask
;
305 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
306 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_BROADCAST_ON
);
307 nic_active
&= nic_active_mask
;
308 nes_write_indexed(nesdev
, NES_IDX_NIC_BROADCAST_ON
, nic_active
);
311 if (nesvnic
->of_device_registered
) {
312 nes_destroy_ofa_device(nesvnic
->nesibdev
);
313 nesvnic
->nesibdev
= NULL
;
314 nesvnic
->of_device_registered
= 0;
316 nes_destroy_nic_qp(nesvnic
);
318 nesvnic
->netdev_open
= 0;
327 static int nes_nic_send(struct sk_buff
*skb
, struct net_device
*netdev
)
329 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
330 struct nes_device
*nesdev
= nesvnic
->nesdev
;
331 struct nes_hw_nic
*nesnic
= &nesvnic
->nic
;
332 struct nes_hw_nic_sq_wqe
*nic_sqe
;
334 __le16
*wqe_fragment_length
;
336 u16 wqe_fragment_index
= 1; /* first fragment (0) is used by copy buffer */
337 u16 skb_fragment_index
;
338 dma_addr_t bus_address
;
340 nic_sqe
= &nesnic
->sq_vbase
[nesnic
->sq_head
];
341 wqe_fragment_length
= (__le16
*)&nic_sqe
->wqe_words
[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX
];
343 /* setup the VLAN tag if present */
344 if (vlan_tx_tag_present(skb
)) {
345 nes_debug(NES_DBG_NIC_TX
, "%s: VLAN packet to send... VLAN = %08X\n",
346 netdev
->name
, vlan_tx_tag_get(skb
));
347 wqe_misc
= NES_NIC_SQ_WQE_TAGVALUE_ENABLE
;
348 wqe_fragment_length
[0] = (__force __le16
) vlan_tx_tag_get(skb
);
352 /* bump past the vlan tag */
353 wqe_fragment_length
++;
354 /* wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
356 if (skb
->ip_summed
== CHECKSUM_PARTIAL
) {
359 if (skb_is_gso(skb
)) {
360 /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... seg size = %u\n",
361 netdev->name, skb_is_gso(skb)); */
362 wqe_misc
|= NES_NIC_SQ_WQE_LSO_ENABLE
|
363 NES_NIC_SQ_WQE_COMPLETION
| (u16
)skb_is_gso(skb
);
364 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_LSO_INFO_IDX
,
366 (((u32
)(((unsigned char *)tcph
) - skb
->data
)) << 4));
368 wqe_misc
|= NES_NIC_SQ_WQE_COMPLETION
;
371 } else { /* CHECKSUM_HW */
372 wqe_misc
|= NES_NIC_SQ_WQE_DISABLE_CHKSUM
| NES_NIC_SQ_WQE_COMPLETION
;
375 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX
,
377 memcpy(&nesnic
->first_frag_vbase
[nesnic
->sq_head
].buffer
,
378 skb
->data
, min(((unsigned int)NES_FIRST_FRAG_SIZE
), skb_headlen(skb
)));
379 wqe_fragment_length
[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE
),
381 wqe_fragment_length
[1] = 0;
382 if (skb_headlen(skb
) > NES_FIRST_FRAG_SIZE
) {
383 if ((skb_shinfo(skb
)->nr_frags
+ 1) > 4) {
384 nes_debug(NES_DBG_NIC_TX
, "%s: Packet with %u fragments not sent, skb_headlen=%u\n",
385 netdev
->name
, skb_shinfo(skb
)->nr_frags
+ 2, skb_headlen(skb
));
387 nesvnic
->tx_sw_dropped
++;
388 return NETDEV_TX_LOCKED
;
390 set_bit(nesnic
->sq_head
, nesnic
->first_frag_overflow
);
391 bus_address
= pci_map_single(nesdev
->pcidev
, skb
->data
+ NES_FIRST_FRAG_SIZE
,
392 skb_headlen(skb
) - NES_FIRST_FRAG_SIZE
, PCI_DMA_TODEVICE
);
393 wqe_fragment_length
[wqe_fragment_index
++] =
394 cpu_to_le16(skb_headlen(skb
) - NES_FIRST_FRAG_SIZE
);
395 wqe_fragment_length
[wqe_fragment_index
] = 0;
396 set_wqe_64bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_FRAG1_LOW_IDX
,
397 ((u64
)(bus_address
)));
398 nesnic
->tx_skb
[nesnic
->sq_head
] = skb
;
401 if (skb_headlen(skb
) == skb
->len
) {
402 if (skb_headlen(skb
) <= NES_FIRST_FRAG_SIZE
) {
403 nic_sqe
->wqe_words
[NES_NIC_SQ_WQE_LENGTH_2_1_IDX
] = 0;
404 nesnic
->tx_skb
[nesnic
->sq_head
] = NULL
;
408 /* Deal with Fragments */
409 nesnic
->tx_skb
[nesnic
->sq_head
] = skb
;
410 for (skb_fragment_index
= 0; skb_fragment_index
< skb_shinfo(skb
)->nr_frags
;
411 skb_fragment_index
++) {
412 bus_address
= pci_map_page( nesdev
->pcidev
,
413 skb_shinfo(skb
)->frags
[skb_fragment_index
].page
,
414 skb_shinfo(skb
)->frags
[skb_fragment_index
].page_offset
,
415 skb_shinfo(skb
)->frags
[skb_fragment_index
].size
,
417 wqe_fragment_length
[wqe_fragment_index
] =
418 cpu_to_le16(skb_shinfo(skb
)->frags
[skb_fragment_index
].size
);
419 set_wqe_64bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_FRAG0_LOW_IDX
+(2*wqe_fragment_index
),
421 wqe_fragment_index
++;
422 if (wqe_fragment_index
< 5)
423 wqe_fragment_length
[wqe_fragment_index
] = 0;
427 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_MISC_IDX
, wqe_misc
);
429 nesnic
->sq_head
&= nesnic
->sq_size
- 1;
436 * nes_netdev_start_xmit
438 static int nes_netdev_start_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
440 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
441 struct nes_device
*nesdev
= nesvnic
->nesdev
;
442 struct nes_hw_nic
*nesnic
= &nesvnic
->nic
;
443 struct nes_hw_nic_sq_wqe
*nic_sqe
;
445 /* struct udphdr *udph; */
446 #define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
447 /* 64K segment plus overflow on each side */
448 dma_addr_t tso_bus_address
[NES_MAX_TSO_FRAGS
];
449 dma_addr_t bus_address
;
458 __le16
*wqe_fragment_length
;
460 u32 original_first_length
;
461 /* u64 *wqe_fragment_address; */
462 /* first fragment (0) is used by copy buffer */
463 u16 wqe_fragment_index
=1;
472 * nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
473 * " (%u frags), tso_size=%u\n",
474 * netdev->name, skb->len, skb_headlen(skb),
475 * skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
478 if (!netif_carrier_ok(netdev
))
481 if (netif_queue_stopped(netdev
))
482 return NETDEV_TX_BUSY
;
484 local_irq_save(flags
);
485 if (!spin_trylock(&nesnic
->sq_lock
)) {
486 local_irq_restore(flags
);
487 nesvnic
->sq_locked
++;
488 return NETDEV_TX_LOCKED
;
491 /* Check if SQ is full */
492 if ((((nesnic
->sq_tail
+(nesnic
->sq_size
*2))-nesnic
->sq_head
) & (nesnic
->sq_size
- 1)) == 1) {
493 if (!netif_queue_stopped(netdev
)) {
494 netif_stop_queue(netdev
);
496 if ((((((volatile u16
)nesnic
->sq_tail
)+(nesnic
->sq_size
*2))-nesnic
->sq_head
) & (nesnic
->sq_size
- 1)) != 1) {
497 netif_start_queue(netdev
);
498 goto sq_no_longer_full
;
502 spin_unlock_irqrestore(&nesnic
->sq_lock
, flags
);
503 return NETDEV_TX_BUSY
;
507 nr_frags
= skb_shinfo(skb
)->nr_frags
;
508 if (skb_headlen(skb
) > NES_FIRST_FRAG_SIZE
) {
511 /* Check if too many fragments */
512 if (unlikely((nr_frags
> 4))) {
513 if (skb_is_gso(skb
)) {
514 nesvnic
->segmented_tso_requests
++;
515 nesvnic
->tso_requests
++;
516 old_head
= nesnic
->sq_head
;
517 /* Basically 4 fragments available per WQE with extended fragments */
518 wqes_needed
= nr_frags
>> 2;
519 wqes_needed
+= (nr_frags
&3)?1:0;
520 wqes_available
= (((nesnic
->sq_tail
+nesnic
->sq_size
)-nesnic
->sq_head
) - 1) &
521 (nesnic
->sq_size
- 1);
523 if (unlikely(wqes_needed
> wqes_available
)) {
524 if (!netif_queue_stopped(netdev
)) {
525 netif_stop_queue(netdev
);
527 wqes_available
= (((((volatile u16
)nesnic
->sq_tail
)+nesnic
->sq_size
)-nesnic
->sq_head
) - 1) &
528 (nesnic
->sq_size
- 1);
529 if (wqes_needed
<= wqes_available
) {
530 netif_start_queue(netdev
);
531 goto tso_sq_no_longer_full
;
535 spin_unlock_irqrestore(&nesnic
->sq_lock
, flags
);
536 nes_debug(NES_DBG_NIC_TX
, "%s: HNIC SQ full- TSO request has too many frags!\n",
538 return NETDEV_TX_BUSY
;
540 tso_sq_no_longer_full
:
541 /* Map all the buffers */
542 for (tso_frag_count
=0; tso_frag_count
< skb_shinfo(skb
)->nr_frags
;
544 tso_bus_address
[tso_frag_count
] = pci_map_page( nesdev
->pcidev
,
545 skb_shinfo(skb
)->frags
[tso_frag_count
].page
,
546 skb_shinfo(skb
)->frags
[tso_frag_count
].page_offset
,
547 skb_shinfo(skb
)->frags
[tso_frag_count
].size
,
552 curr_tcp_seq
= ntohl(tcp_hdr(skb
)->seq
);
553 hoffset
= skb_transport_header(skb
) - skb
->data
;
554 nhoffset
= skb_network_header(skb
) - skb
->data
;
555 original_first_length
= hoffset
+ ((((struct tcphdr
*)skb_transport_header(skb
))->doff
)<<2);
557 for (wqe_count
=0; wqe_count
<((u32
)wqes_needed
); wqe_count
++) {
559 nic_sqe
= &nesnic
->sq_vbase
[nesnic
->sq_head
];
560 wqe_fragment_length
=
561 (__le16
*)&nic_sqe
->wqe_words
[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX
];
562 /* setup the VLAN tag if present */
563 if (vlan_tx_tag_present(skb
)) {
564 nes_debug(NES_DBG_NIC_TX
, "%s: VLAN packet to send... VLAN = %08X\n",
565 netdev
->name
, vlan_tx_tag_get(skb
) );
566 wqe_misc
= NES_NIC_SQ_WQE_TAGVALUE_ENABLE
;
567 wqe_fragment_length
[0] = (__force __le16
) vlan_tx_tag_get(skb
);
571 /* bump past the vlan tag */
572 wqe_fragment_length
++;
574 /* Assumes header totally fits in allocated buffer and is in first fragment */
575 if (original_first_length
> NES_FIRST_FRAG_SIZE
) {
576 nes_debug(NES_DBG_NIC_TX
, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
577 original_first_length
, NES_FIRST_FRAG_SIZE
);
578 nes_debug(NES_DBG_NIC_TX
, "%s Request to tx NIC packet length %u, headlen %u,"
579 " (%u frags), tso_size=%u\n",
581 skb
->len
, skb_headlen(skb
),
582 skb_shinfo(skb
)->nr_frags
, skb_is_gso(skb
));
584 memcpy(&nesnic
->first_frag_vbase
[nesnic
->sq_head
].buffer
,
585 skb
->data
, min(((unsigned int)NES_FIRST_FRAG_SIZE
),
586 original_first_length
));
587 iph
= (struct iphdr
*)
588 (&nesnic
->first_frag_vbase
[nesnic
->sq_head
].buffer
[nhoffset
]);
589 tcph
= (struct tcphdr
*)
590 (&nesnic
->first_frag_vbase
[nesnic
->sq_head
].buffer
[hoffset
]);
591 if ((wqe_count
+1)!=(u32
)wqes_needed
) {
600 tcph
->seq
= htonl(curr_tcp_seq
);
601 wqe_fragment_length
[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE
),
602 original_first_length
));
604 wqe_fragment_index
= 1;
605 if ((wqe_count
==0) && (skb_headlen(skb
) > original_first_length
)) {
606 set_bit(nesnic
->sq_head
, nesnic
->first_frag_overflow
);
607 bus_address
= pci_map_single(nesdev
->pcidev
, skb
->data
+ original_first_length
,
608 skb_headlen(skb
) - original_first_length
, PCI_DMA_TODEVICE
);
609 wqe_fragment_length
[wqe_fragment_index
++] =
610 cpu_to_le16(skb_headlen(skb
) - original_first_length
);
611 wqe_fragment_length
[wqe_fragment_index
] = 0;
612 set_wqe_64bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_FRAG1_LOW_IDX
,
614 tso_wqe_length
+= skb_headlen(skb
) -
615 original_first_length
;
617 while (wqe_fragment_index
< 5) {
618 wqe_fragment_length
[wqe_fragment_index
] =
619 cpu_to_le16(skb_shinfo(skb
)->frags
[tso_frag_index
].size
);
620 set_wqe_64bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_FRAG0_LOW_IDX
+(2*wqe_fragment_index
),
621 (u64
)tso_bus_address
[tso_frag_index
]);
622 wqe_fragment_index
++;
623 tso_wqe_length
+= skb_shinfo(skb
)->frags
[tso_frag_index
++].size
;
624 if (wqe_fragment_index
< 5)
625 wqe_fragment_length
[wqe_fragment_index
] = 0;
626 if (tso_frag_index
== tso_frag_count
)
629 if ((wqe_count
+1) == (u32
)wqes_needed
) {
630 nesnic
->tx_skb
[nesnic
->sq_head
] = skb
;
632 nesnic
->tx_skb
[nesnic
->sq_head
] = NULL
;
634 wqe_misc
|= NES_NIC_SQ_WQE_COMPLETION
| (u16
)skb_is_gso(skb
);
635 if ((tso_wqe_length
+ original_first_length
) > skb_is_gso(skb
)) {
636 wqe_misc
|= NES_NIC_SQ_WQE_LSO_ENABLE
;
638 iph
->tot_len
= htons(tso_wqe_length
+ original_first_length
- nhoffset
);
641 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_MISC_IDX
,
643 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_LSO_INFO_IDX
,
644 ((u32
)tcph
->doff
) | (((u32
)hoffset
) << 4));
646 set_wqe_32bit_value(nic_sqe
->wqe_words
, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX
,
647 tso_wqe_length
+ original_first_length
);
648 curr_tcp_seq
+= tso_wqe_length
;
650 nesnic
->sq_head
&= nesnic
->sq_size
-1;
653 nesvnic
->linearized_skbs
++;
654 hoffset
= skb_transport_header(skb
) - skb
->data
;
655 nhoffset
= skb_network_header(skb
) - skb
->data
;
657 skb_set_transport_header(skb
, hoffset
);
658 skb_set_network_header(skb
, nhoffset
);
659 send_rc
= nes_nic_send(skb
, netdev
);
660 if (send_rc
!= NETDEV_TX_OK
) {
661 spin_unlock_irqrestore(&nesnic
->sq_lock
, flags
);
666 send_rc
= nes_nic_send(skb
, netdev
);
667 if (send_rc
!= NETDEV_TX_OK
) {
668 spin_unlock_irqrestore(&nesnic
->sq_lock
, flags
);
676 nes_write32(nesdev
->regs
+NES_WQE_ALLOC
,
677 (wqe_count
<< 24) | (1 << 23) | nesvnic
->nic
.qp_id
);
679 netdev
->trans_start
= jiffies
;
680 spin_unlock_irqrestore(&nesnic
->sq_lock
, flags
);
687 * nes_netdev_get_stats
689 static struct net_device_stats
*nes_netdev_get_stats(struct net_device
*netdev
)
691 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
692 struct nes_device
*nesdev
= nesvnic
->nesdev
;
696 u32temp
= nes_read_indexed(nesdev
,
697 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD
+ (nesvnic
->nic_index
*0x200));
698 nesvnic
->netstats
.rx_dropped
+= u32temp
;
699 nesvnic
->endnode_nstat_rx_discard
+= u32temp
;
701 u64temp
= (u64
)nes_read_indexed(nesdev
,
702 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO
+ (nesvnic
->nic_index
*0x200));
703 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
704 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI
+ (nesvnic
->nic_index
*0x200))) << 32;
706 nesvnic
->endnode_nstat_rx_octets
+= u64temp
;
707 nesvnic
->netstats
.rx_bytes
+= u64temp
;
709 u64temp
= (u64
)nes_read_indexed(nesdev
,
710 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO
+ (nesvnic
->nic_index
*0x200));
711 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
712 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI
+ (nesvnic
->nic_index
*0x200))) << 32;
714 nesvnic
->endnode_nstat_rx_frames
+= u64temp
;
715 nesvnic
->netstats
.rx_packets
+= u64temp
;
717 u64temp
= (u64
)nes_read_indexed(nesdev
,
718 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO
+ (nesvnic
->nic_index
*0x200));
719 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
720 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI
+ (nesvnic
->nic_index
*0x200))) << 32;
722 nesvnic
->endnode_nstat_tx_octets
+= u64temp
;
723 nesvnic
->netstats
.tx_bytes
+= u64temp
;
725 u64temp
= (u64
)nes_read_indexed(nesdev
,
726 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO
+ (nesvnic
->nic_index
*0x200));
727 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
728 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI
+ (nesvnic
->nic_index
*0x200))) << 32;
730 nesvnic
->endnode_nstat_tx_frames
+= u64temp
;
731 nesvnic
->netstats
.tx_packets
+= u64temp
;
733 u32temp
= nes_read_indexed(nesdev
,
734 NES_IDX_MAC_RX_SHORT_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
735 nesvnic
->netstats
.rx_dropped
+= u32temp
;
736 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
737 nesvnic
->nesdev
->mac_rx_short_frames
+= u32temp
;
739 u32temp
= nes_read_indexed(nesdev
,
740 NES_IDX_MAC_RX_OVERSIZED_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
741 nesvnic
->netstats
.rx_dropped
+= u32temp
;
742 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
743 nesvnic
->nesdev
->mac_rx_oversized_frames
+= u32temp
;
745 u32temp
= nes_read_indexed(nesdev
,
746 NES_IDX_MAC_RX_JABBER_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
747 nesvnic
->netstats
.rx_dropped
+= u32temp
;
748 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
749 nesvnic
->nesdev
->mac_rx_jabber_frames
+= u32temp
;
751 u32temp
= nes_read_indexed(nesdev
,
752 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
753 nesvnic
->netstats
.rx_dropped
+= u32temp
;
754 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
755 nesvnic
->nesdev
->mac_rx_symbol_err_frames
+= u32temp
;
757 u32temp
= nes_read_indexed(nesdev
,
758 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
759 nesvnic
->netstats
.rx_length_errors
+= u32temp
;
760 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
762 u32temp
= nes_read_indexed(nesdev
,
763 NES_IDX_MAC_RX_CRC_ERR_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
764 nesvnic
->nesdev
->mac_rx_errors
+= u32temp
;
765 nesvnic
->nesdev
->mac_rx_crc_errors
+= u32temp
;
766 nesvnic
->netstats
.rx_crc_errors
+= u32temp
;
768 u32temp
= nes_read_indexed(nesdev
,
769 NES_IDX_MAC_TX_ERRORS
+ (nesvnic
->nesdev
->mac_index
*0x200));
770 nesvnic
->nesdev
->mac_tx_errors
+= u32temp
;
771 nesvnic
->netstats
.tx_errors
+= u32temp
;
773 return &nesvnic
->netstats
;
778 * nes_netdev_tx_timeout
780 static void nes_netdev_tx_timeout(struct net_device
*netdev
)
782 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
784 if (netif_msg_timer(nesvnic
))
785 nes_debug(NES_DBG_NIC_TX
, "%s: tx timeout\n", netdev
->name
);
790 * nes_netdev_set_mac_address
792 static int nes_netdev_set_mac_address(struct net_device
*netdev
, void *p
)
794 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
795 struct nes_device
*nesdev
= nesvnic
->nesdev
;
796 struct sockaddr
*mac_addr
= p
;
801 if (!is_valid_ether_addr(mac_addr
->sa_data
))
802 return -EADDRNOTAVAIL
;
804 memcpy(netdev
->dev_addr
, mac_addr
->sa_data
, netdev
->addr_len
);
805 printk(PFX
"%s: Address length = %d, Address = %pM\n",
806 __func__
, netdev
->addr_len
, mac_addr
->sa_data
);
807 macaddr_high
= ((u16
)netdev
->dev_addr
[0]) << 8;
808 macaddr_high
+= (u16
)netdev
->dev_addr
[1];
809 macaddr_low
= ((u32
)netdev
->dev_addr
[2]) << 24;
810 macaddr_low
+= ((u32
)netdev
->dev_addr
[3]) << 16;
811 macaddr_low
+= ((u32
)netdev
->dev_addr
[4]) << 8;
812 macaddr_low
+= (u32
)netdev
->dev_addr
[5];
814 for (i
= 0; i
< NES_MAX_PORT_COUNT
; i
++) {
815 if (nesvnic
->qp_nic_index
[i
] == 0xf) {
818 nes_write_indexed(nesdev
,
819 NES_IDX_PERFECT_FILTER_LOW
+ (nesvnic
->qp_nic_index
[i
] * 8),
821 nes_write_indexed(nesdev
,
822 NES_IDX_PERFECT_FILTER_HIGH
+ (nesvnic
->qp_nic_index
[i
] * 8),
823 (u32
)macaddr_high
| NES_MAC_ADDR_VALID
|
824 ((((u32
)nesvnic
->nic_index
) << 16)));
831 * nes_netdev_set_multicast_list
833 static void nes_netdev_set_multicast_list(struct net_device
*netdev
)
835 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
836 struct nes_device
*nesdev
= nesvnic
->nesdev
;
837 struct nes_adapter
*nesadapter
= nesvnic
->nesdev
->nesadapter
;
838 struct dev_mc_list
*multicast_addr
;
841 u32 perfect_filter_register_address
;
846 int mc_nic_index
= -1;
847 u8 pft_entries_preallocated
= max(nesadapter
->adapter_fcn_count
*
848 nics_per_function
, 4);
849 u8 max_pft_entries_avaiable
= NES_PFT_SIZE
- pft_entries_preallocated
;
852 spin_lock_irqsave(&nesadapter
->resource_lock
, flags
);
853 nic_active_bit
= 1 << nesvnic
->nic_index
;
855 if (netdev
->flags
& IFF_PROMISC
) {
856 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
);
857 nic_active
|= nic_active_bit
;
858 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
, nic_active
);
859 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
860 nic_active
|= nic_active_bit
;
861 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
863 } else if ((netdev
->flags
& IFF_ALLMULTI
) ||
864 (nesvnic
->nic_index
> 3)) {
865 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
);
866 nic_active
|= nic_active_bit
;
867 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
, nic_active
);
868 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
869 nic_active
&= ~nic_active_bit
;
870 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
873 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
);
874 nic_active
&= ~nic_active_bit
;
875 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
, nic_active
);
876 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
877 nic_active
&= ~nic_active_bit
;
878 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
881 nes_debug(NES_DBG_NIC_RX
, "Number of MC entries = %d, Promiscous = %d, All Multicast = %d.\n",
882 netdev
->mc_count
, !!(netdev
->flags
& IFF_PROMISC
),
883 !!(netdev
->flags
& IFF_ALLMULTI
));
885 multicast_addr
= netdev
->mc_list
;
886 perfect_filter_register_address
= NES_IDX_PERFECT_FILTER_LOW
+
887 pft_entries_preallocated
* 0x8;
888 for (mc_index
= 0; mc_index
< max_pft_entries_avaiable
;
890 while (multicast_addr
&& nesvnic
->mcrq_mcast_filter
&&
891 ((mc_nic_index
= nesvnic
->mcrq_mcast_filter(nesvnic
,
892 multicast_addr
->dmi_addr
)) == 0)) {
893 multicast_addr
= multicast_addr
->next
;
895 if (mc_nic_index
< 0)
896 mc_nic_index
= nesvnic
->nic_index
;
897 while (nesadapter
->pft_mcast_map
[mc_index
] < 16 &&
898 nesadapter
->pft_mcast_map
[mc_index
] !=
899 nesvnic
->nic_index
&&
900 mc_index
< max_pft_entries_avaiable
) {
901 nes_debug(NES_DBG_NIC_RX
,
902 "mc_index=%d skipping nic_index=%d,\
903 used for=%d \n", mc_index
,
905 nesadapter
->pft_mcast_map
[mc_index
]);
908 if (mc_index
>= max_pft_entries_avaiable
)
910 if (multicast_addr
) {
911 nes_debug(NES_DBG_NIC_RX
, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
912 multicast_addr
->dmi_addr
,
913 perfect_filter_register_address
+(mc_index
* 8),
915 macaddr_high
= ((u16
)multicast_addr
->dmi_addr
[0]) << 8;
916 macaddr_high
+= (u16
)multicast_addr
->dmi_addr
[1];
917 macaddr_low
= ((u32
)multicast_addr
->dmi_addr
[2]) << 24;
918 macaddr_low
+= ((u32
)multicast_addr
->dmi_addr
[3]) << 16;
919 macaddr_low
+= ((u32
)multicast_addr
->dmi_addr
[4]) << 8;
920 macaddr_low
+= (u32
)multicast_addr
->dmi_addr
[5];
921 nes_write_indexed(nesdev
,
922 perfect_filter_register_address
+(mc_index
* 8),
924 nes_write_indexed(nesdev
,
925 perfect_filter_register_address
+4+(mc_index
* 8),
926 (u32
)macaddr_high
| NES_MAC_ADDR_VALID
|
927 ((((u32
)(1<<mc_nic_index
)) << 16)));
928 multicast_addr
= multicast_addr
->next
;
929 nesadapter
->pft_mcast_map
[mc_index
] =
932 nes_debug(NES_DBG_NIC_RX
, "Clearing MC Address at register 0x%04X\n",
933 perfect_filter_register_address
+(mc_index
* 8));
934 nes_write_indexed(nesdev
,
935 perfect_filter_register_address
+4+(mc_index
* 8),
937 nesadapter
->pft_mcast_map
[mc_index
] = 255;
940 /* PFT is not large enough */
941 if (multicast_addr
&& multicast_addr
->next
) {
942 nic_active
= nes_read_indexed(nesdev
,
943 NES_IDX_NIC_MULTICAST_ALL
);
944 nic_active
|= nic_active_bit
;
945 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
,
947 nic_active
= nes_read_indexed(nesdev
,
948 NES_IDX_NIC_UNICAST_ALL
);
949 nic_active
&= ~nic_active_bit
;
950 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
,
955 spin_unlock_irqrestore(&nesadapter
->resource_lock
, flags
);
960 * nes_netdev_change_mtu
962 static int nes_netdev_change_mtu(struct net_device
*netdev
, int new_mtu
)
964 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
965 struct nes_device
*nesdev
= nesvnic
->nesdev
;
973 if ((new_mtu
< ETH_ZLEN
) || (new_mtu
> max_mtu
))
976 netdev
->mtu
= new_mtu
;
977 nesvnic
->max_frame_size
= new_mtu
+ VLAN_ETH_HLEN
;
979 if (netdev
->mtu
> 1500) {
982 nes_nic_init_timer_defaults(nesdev
, jumbomode
);
984 if (netif_running(netdev
)) {
985 nic_active_bit
= 1 << nesvnic
->nic_index
;
986 mc_all_active
= nes_read_indexed(nesdev
,
987 NES_IDX_NIC_MULTICAST_ALL
) & nic_active_bit
;
988 uc_all_active
= nes_read_indexed(nesdev
,
989 NES_IDX_NIC_UNICAST_ALL
) & nic_active_bit
;
991 nes_netdev_stop(netdev
);
992 nes_netdev_open(netdev
);
994 nic_active
= nes_read_indexed(nesdev
,
995 NES_IDX_NIC_MULTICAST_ALL
);
996 nic_active
|= mc_all_active
;
997 nes_write_indexed(nesdev
, NES_IDX_NIC_MULTICAST_ALL
,
1000 nic_active
= nes_read_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
);
1001 nic_active
|= uc_all_active
;
1002 nes_write_indexed(nesdev
, NES_IDX_NIC_UNICAST_ALL
, nic_active
);
1008 static const char nes_ethtool_stringset
[][ETH_GSTRING_LEN
] = {
1009 "Link Change Interrupts",
1012 "Pause Frames Sent",
1013 "Pause Frames Received",
1014 "Internal Routing Errors",
1015 "SQ SW Dropped SKBs",
1018 "Segmented TSO Requests",
1021 "Rx Oversized Frames",
1023 "Endnode Rx Discards",
1024 "Endnode Rx Octets",
1025 "Endnode Rx Frames",
1026 "Endnode Tx Octets",
1027 "Endnode Tx Frames",
1030 "Retransmission Count",
1037 "ModifyQP Timeouts",
1043 "CM Packets Bounced",
1044 "CM Packets Created",
1046 "CM Packets Dropped",
1047 "CM Packets Retrans",
1048 "CM Listens Created",
1049 "CM Listens Destroyed",
1053 "CM Nodes Destroyed",
1055 "CM Resets Received",
1069 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1072 * nes_netdev_get_rx_csum
1074 static u32
nes_netdev_get_rx_csum (struct net_device
*netdev
)
1076 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1078 if (nesvnic
->rx_checksum_disabled
)
1086 * nes_netdev_set_rc_csum
1088 static int nes_netdev_set_rx_csum(struct net_device
*netdev
, u32 enable
)
1090 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1093 nesvnic
->rx_checksum_disabled
= 0;
1095 nesvnic
->rx_checksum_disabled
= 1;
1101 * nes_netdev_get_stats_count
1103 static int nes_netdev_get_stats_count(struct net_device
*netdev
)
1105 return NES_ETHTOOL_STAT_COUNT
;
1110 * nes_netdev_get_strings
1112 static void nes_netdev_get_strings(struct net_device
*netdev
, u32 stringset
,
1113 u8
*ethtool_strings
)
1115 if (stringset
== ETH_SS_STATS
)
1116 memcpy(ethtool_strings
,
1117 &nes_ethtool_stringset
,
1118 sizeof(nes_ethtool_stringset
));
1123 * nes_netdev_get_ethtool_stats
1125 static void nes_netdev_get_ethtool_stats(struct net_device
*netdev
,
1126 struct ethtool_stats
*target_ethtool_stats
, u64
*target_stat_values
)
1129 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1130 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1134 target_ethtool_stats
->n_stats
= NES_ETHTOOL_STAT_COUNT
;
1135 target_stat_values
[0] = nesvnic
->nesdev
->link_status_interrupts
;
1136 target_stat_values
[1] = nesvnic
->linearized_skbs
;
1137 target_stat_values
[2] = nesvnic
->tso_requests
;
1139 u32temp
= nes_read_indexed(nesdev
,
1140 NES_IDX_MAC_TX_PAUSE_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1141 nesvnic
->nesdev
->mac_pause_frames_sent
+= u32temp
;
1142 target_stat_values
[3] = nesvnic
->nesdev
->mac_pause_frames_sent
;
1144 u32temp
= nes_read_indexed(nesdev
,
1145 NES_IDX_MAC_RX_PAUSE_FRAMES
+ (nesvnic
->nesdev
->mac_index
*0x200));
1146 nesvnic
->nesdev
->mac_pause_frames_received
+= u32temp
;
1148 u32temp
= nes_read_indexed(nesdev
,
1149 NES_IDX_PORT_RX_DISCARDS
+ (nesvnic
->nesdev
->mac_index
*0x40));
1150 nesvnic
->nesdev
->port_rx_discards
+= u32temp
;
1151 nesvnic
->netstats
.rx_dropped
+= u32temp
;
1153 u32temp
= nes_read_indexed(nesdev
,
1154 NES_IDX_PORT_TX_DISCARDS
+ (nesvnic
->nesdev
->mac_index
*0x40));
1155 nesvnic
->nesdev
->port_tx_discards
+= u32temp
;
1156 nesvnic
->netstats
.tx_dropped
+= u32temp
;
1158 for (nic_count
= 0; nic_count
< NES_MAX_PORT_COUNT
; nic_count
++) {
1159 if (nesvnic
->qp_nic_index
[nic_count
] == 0xf)
1162 u32temp
= nes_read_indexed(nesdev
,
1163 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD
+
1164 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1165 nesvnic
->netstats
.rx_dropped
+= u32temp
;
1166 nesvnic
->endnode_nstat_rx_discard
+= u32temp
;
1168 u64temp
= (u64
)nes_read_indexed(nesdev
,
1169 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO
+
1170 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1171 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
1172 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI
+
1173 (nesvnic
->qp_nic_index
[nic_count
]*0x200))) << 32;
1175 nesvnic
->endnode_nstat_rx_octets
+= u64temp
;
1176 nesvnic
->netstats
.rx_bytes
+= u64temp
;
1178 u64temp
= (u64
)nes_read_indexed(nesdev
,
1179 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO
+
1180 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1181 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
1182 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI
+
1183 (nesvnic
->qp_nic_index
[nic_count
]*0x200))) << 32;
1185 nesvnic
->endnode_nstat_rx_frames
+= u64temp
;
1186 nesvnic
->netstats
.rx_packets
+= u64temp
;
1188 u64temp
= (u64
)nes_read_indexed(nesdev
,
1189 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO
+
1190 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1191 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
1192 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI
+
1193 (nesvnic
->qp_nic_index
[nic_count
]*0x200))) << 32;
1195 nesvnic
->endnode_nstat_tx_octets
+= u64temp
;
1196 nesvnic
->netstats
.tx_bytes
+= u64temp
;
1198 u64temp
= (u64
)nes_read_indexed(nesdev
,
1199 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO
+
1200 (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1201 u64temp
+= ((u64
)nes_read_indexed(nesdev
,
1202 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI
+
1203 (nesvnic
->qp_nic_index
[nic_count
]*0x200))) << 32;
1205 nesvnic
->endnode_nstat_tx_frames
+= u64temp
;
1206 nesvnic
->netstats
.tx_packets
+= u64temp
;
1208 u32temp
= nes_read_indexed(nesdev
,
1209 NES_IDX_IPV4_TCP_REXMITS
+ (nesvnic
->qp_nic_index
[nic_count
]*0x200));
1210 nesvnic
->endnode_ipv4_tcp_retransmits
+= u32temp
;
1213 target_stat_values
[4] = nesvnic
->nesdev
->mac_pause_frames_received
;
1214 target_stat_values
[5] = nesdev
->nesadapter
->nic_rx_eth_route_err
;
1215 target_stat_values
[6] = nesvnic
->tx_sw_dropped
;
1216 target_stat_values
[7] = nesvnic
->sq_locked
;
1217 target_stat_values
[8] = nesvnic
->sq_full
;
1218 target_stat_values
[9] = nesvnic
->segmented_tso_requests
;
1219 target_stat_values
[10] = nesvnic
->nesdev
->mac_rx_symbol_err_frames
;
1220 target_stat_values
[11] = nesvnic
->nesdev
->mac_rx_jabber_frames
;
1221 target_stat_values
[12] = nesvnic
->nesdev
->mac_rx_oversized_frames
;
1222 target_stat_values
[13] = nesvnic
->nesdev
->mac_rx_short_frames
;
1223 target_stat_values
[14] = nesvnic
->endnode_nstat_rx_discard
;
1224 target_stat_values
[15] = nesvnic
->endnode_nstat_rx_octets
;
1225 target_stat_values
[16] = nesvnic
->endnode_nstat_rx_frames
;
1226 target_stat_values
[17] = nesvnic
->endnode_nstat_tx_octets
;
1227 target_stat_values
[18] = nesvnic
->endnode_nstat_tx_frames
;
1228 target_stat_values
[19] = mh_detected
;
1229 target_stat_values
[20] = mh_pauses_sent
;
1230 target_stat_values
[21] = nesvnic
->endnode_ipv4_tcp_retransmits
;
1231 target_stat_values
[22] = atomic_read(&cm_connects
);
1232 target_stat_values
[23] = atomic_read(&cm_accepts
);
1233 target_stat_values
[24] = atomic_read(&cm_disconnects
);
1234 target_stat_values
[25] = atomic_read(&cm_connecteds
);
1235 target_stat_values
[26] = atomic_read(&cm_connect_reqs
);
1236 target_stat_values
[27] = atomic_read(&cm_rejects
);
1237 target_stat_values
[28] = atomic_read(&mod_qp_timouts
);
1238 target_stat_values
[29] = atomic_read(&qps_created
);
1239 target_stat_values
[30] = atomic_read(&sw_qps_destroyed
);
1240 target_stat_values
[31] = atomic_read(&qps_destroyed
);
1241 target_stat_values
[32] = atomic_read(&cm_closes
);
1242 target_stat_values
[33] = cm_packets_sent
;
1243 target_stat_values
[34] = cm_packets_bounced
;
1244 target_stat_values
[35] = cm_packets_created
;
1245 target_stat_values
[36] = cm_packets_received
;
1246 target_stat_values
[37] = cm_packets_dropped
;
1247 target_stat_values
[38] = cm_packets_retrans
;
1248 target_stat_values
[39] = cm_listens_created
;
1249 target_stat_values
[40] = cm_listens_destroyed
;
1250 target_stat_values
[41] = cm_backlog_drops
;
1251 target_stat_values
[42] = atomic_read(&cm_loopbacks
);
1252 target_stat_values
[43] = atomic_read(&cm_nodes_created
);
1253 target_stat_values
[44] = atomic_read(&cm_nodes_destroyed
);
1254 target_stat_values
[45] = atomic_read(&cm_accel_dropped_pkts
);
1255 target_stat_values
[46] = atomic_read(&cm_resets_recvd
);
1256 target_stat_values
[47] = int_mod_timer_init
;
1257 target_stat_values
[48] = int_mod_cq_depth_1
;
1258 target_stat_values
[49] = int_mod_cq_depth_4
;
1259 target_stat_values
[50] = int_mod_cq_depth_16
;
1260 target_stat_values
[51] = int_mod_cq_depth_24
;
1261 target_stat_values
[52] = int_mod_cq_depth_32
;
1262 target_stat_values
[53] = int_mod_cq_depth_128
;
1263 target_stat_values
[54] = int_mod_cq_depth_256
;
1264 target_stat_values
[55] = nesvnic
->lro_mgr
.stats
.aggregated
;
1265 target_stat_values
[56] = nesvnic
->lro_mgr
.stats
.flushed
;
1266 target_stat_values
[57] = nesvnic
->lro_mgr
.stats
.no_desc
;
1272 * nes_netdev_get_drvinfo
1274 static void nes_netdev_get_drvinfo(struct net_device
*netdev
,
1275 struct ethtool_drvinfo
*drvinfo
)
1277 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1278 struct nes_adapter
*nesadapter
= nesvnic
->nesdev
->nesadapter
;
1280 strcpy(drvinfo
->driver
, DRV_NAME
);
1281 strcpy(drvinfo
->bus_info
, pci_name(nesvnic
->nesdev
->pcidev
));
1282 sprintf(drvinfo
->fw_version
, "%u.%u", nesadapter
->firmware_version
>>16,
1283 nesadapter
->firmware_version
& 0x000000ff);
1284 strcpy(drvinfo
->version
, DRV_VERSION
);
1285 drvinfo
->n_stats
= nes_netdev_get_stats_count(netdev
);
1286 drvinfo
->testinfo_len
= 0;
1287 drvinfo
->eedump_len
= 0;
1288 drvinfo
->regdump_len
= 0;
1293 * nes_netdev_set_coalesce
1295 static int nes_netdev_set_coalesce(struct net_device
*netdev
,
1296 struct ethtool_coalesce
*et_coalesce
)
1298 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1299 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1300 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1301 struct nes_hw_tune_timer
*shared_timer
= &nesadapter
->tune_timer
;
1302 unsigned long flags
;
1304 spin_lock_irqsave(&nesadapter
->periodic_timer_lock
, flags
);
1305 if (et_coalesce
->rx_max_coalesced_frames_low
) {
1306 shared_timer
->threshold_low
= et_coalesce
->rx_max_coalesced_frames_low
;
1308 if (et_coalesce
->rx_max_coalesced_frames_irq
) {
1309 shared_timer
->threshold_target
= et_coalesce
->rx_max_coalesced_frames_irq
;
1311 if (et_coalesce
->rx_max_coalesced_frames_high
) {
1312 shared_timer
->threshold_high
= et_coalesce
->rx_max_coalesced_frames_high
;
1314 if (et_coalesce
->rx_coalesce_usecs_low
) {
1315 shared_timer
->timer_in_use_min
= et_coalesce
->rx_coalesce_usecs_low
;
1317 if (et_coalesce
->rx_coalesce_usecs_high
) {
1318 shared_timer
->timer_in_use_max
= et_coalesce
->rx_coalesce_usecs_high
;
1320 spin_unlock_irqrestore(&nesadapter
->periodic_timer_lock
, flags
);
1322 /* using this to drive total interrupt moderation */
1323 nesadapter
->et_rx_coalesce_usecs_irq
= et_coalesce
->rx_coalesce_usecs_irq
;
1324 if (et_coalesce
->use_adaptive_rx_coalesce
) {
1325 nesadapter
->et_use_adaptive_rx_coalesce
= 1;
1326 nesadapter
->timer_int_limit
= NES_TIMER_INT_LIMIT_DYNAMIC
;
1327 nesadapter
->et_rx_coalesce_usecs_irq
= 0;
1328 if (et_coalesce
->pkt_rate_low
) {
1329 nesadapter
->et_pkt_rate_low
= et_coalesce
->pkt_rate_low
;
1332 nesadapter
->et_use_adaptive_rx_coalesce
= 0;
1333 nesadapter
->timer_int_limit
= NES_TIMER_INT_LIMIT
;
1334 if (nesadapter
->et_rx_coalesce_usecs_irq
) {
1335 nes_write32(nesdev
->regs
+NES_PERIODIC_CONTROL
,
1336 0x80000000 | ((u32
)(nesadapter
->et_rx_coalesce_usecs_irq
*8)));
1344 * nes_netdev_get_coalesce
1346 static int nes_netdev_get_coalesce(struct net_device
*netdev
,
1347 struct ethtool_coalesce
*et_coalesce
)
1349 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1350 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1351 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1352 struct ethtool_coalesce temp_et_coalesce
;
1353 struct nes_hw_tune_timer
*shared_timer
= &nesadapter
->tune_timer
;
1354 unsigned long flags
;
1356 memset(&temp_et_coalesce
, 0, sizeof(temp_et_coalesce
));
1357 temp_et_coalesce
.rx_coalesce_usecs_irq
= nesadapter
->et_rx_coalesce_usecs_irq
;
1358 temp_et_coalesce
.use_adaptive_rx_coalesce
= nesadapter
->et_use_adaptive_rx_coalesce
;
1359 temp_et_coalesce
.rate_sample_interval
= nesadapter
->et_rate_sample_interval
;
1360 temp_et_coalesce
.pkt_rate_low
= nesadapter
->et_pkt_rate_low
;
1361 spin_lock_irqsave(&nesadapter
->periodic_timer_lock
, flags
);
1362 temp_et_coalesce
.rx_max_coalesced_frames_low
= shared_timer
->threshold_low
;
1363 temp_et_coalesce
.rx_max_coalesced_frames_irq
= shared_timer
->threshold_target
;
1364 temp_et_coalesce
.rx_max_coalesced_frames_high
= shared_timer
->threshold_high
;
1365 temp_et_coalesce
.rx_coalesce_usecs_low
= shared_timer
->timer_in_use_min
;
1366 temp_et_coalesce
.rx_coalesce_usecs_high
= shared_timer
->timer_in_use_max
;
1367 if (nesadapter
->et_use_adaptive_rx_coalesce
) {
1368 temp_et_coalesce
.rx_coalesce_usecs_irq
= shared_timer
->timer_in_use
;
1370 spin_unlock_irqrestore(&nesadapter
->periodic_timer_lock
, flags
);
1371 memcpy(et_coalesce
, &temp_et_coalesce
, sizeof(*et_coalesce
));
1377 * nes_netdev_get_pauseparam
1379 static void nes_netdev_get_pauseparam(struct net_device
*netdev
,
1380 struct ethtool_pauseparam
*et_pauseparam
)
1382 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1384 et_pauseparam
->autoneg
= 0;
1385 et_pauseparam
->rx_pause
= (nesvnic
->nesdev
->disable_rx_flow_control
== 0) ? 1:0;
1386 et_pauseparam
->tx_pause
= (nesvnic
->nesdev
->disable_tx_flow_control
== 0) ? 1:0;
1391 * nes_netdev_set_pauseparam
1393 static int nes_netdev_set_pauseparam(struct net_device
*netdev
,
1394 struct ethtool_pauseparam
*et_pauseparam
)
1396 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1397 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1400 if (et_pauseparam
->autoneg
) {
1401 /* TODO: should return unsupported */
1404 if ((et_pauseparam
->tx_pause
== 1) && (nesdev
->disable_tx_flow_control
== 1)) {
1405 u32temp
= nes_read_indexed(nesdev
,
1406 NES_IDX_MAC_TX_CONFIG
+ (nesdev
->mac_index
*0x200));
1407 u32temp
|= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE
;
1408 nes_write_indexed(nesdev
,
1409 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE
+ (nesdev
->mac_index
*0x200), u32temp
);
1410 nesdev
->disable_tx_flow_control
= 0;
1411 } else if ((et_pauseparam
->tx_pause
== 0) && (nesdev
->disable_tx_flow_control
== 0)) {
1412 u32temp
= nes_read_indexed(nesdev
,
1413 NES_IDX_MAC_TX_CONFIG
+ (nesdev
->mac_index
*0x200));
1414 u32temp
&= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE
;
1415 nes_write_indexed(nesdev
,
1416 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE
+ (nesdev
->mac_index
*0x200), u32temp
);
1417 nesdev
->disable_tx_flow_control
= 1;
1419 if ((et_pauseparam
->rx_pause
== 1) && (nesdev
->disable_rx_flow_control
== 1)) {
1420 u32temp
= nes_read_indexed(nesdev
,
1421 NES_IDX_MPP_DEBUG
+ (nesdev
->mac_index
*0x40));
1422 u32temp
&= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE
;
1423 nes_write_indexed(nesdev
,
1424 NES_IDX_MPP_DEBUG
+ (nesdev
->mac_index
*0x40), u32temp
);
1425 nesdev
->disable_rx_flow_control
= 0;
1426 } else if ((et_pauseparam
->rx_pause
== 0) && (nesdev
->disable_rx_flow_control
== 0)) {
1427 u32temp
= nes_read_indexed(nesdev
,
1428 NES_IDX_MPP_DEBUG
+ (nesdev
->mac_index
*0x40));
1429 u32temp
|= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE
;
1430 nes_write_indexed(nesdev
,
1431 NES_IDX_MPP_DEBUG
+ (nesdev
->mac_index
*0x40), u32temp
);
1432 nesdev
->disable_rx_flow_control
= 1;
1440 * nes_netdev_get_settings
1442 static int nes_netdev_get_settings(struct net_device
*netdev
, struct ethtool_cmd
*et_cmd
)
1444 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1445 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1446 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1449 et_cmd
->duplex
= DUPLEX_FULL
;
1450 et_cmd
->port
= PORT_MII
;
1452 if (nesadapter
->OneG_Mode
) {
1453 et_cmd
->speed
= SPEED_1000
;
1454 if (nesadapter
->phy_type
[nesdev
->mac_index
] == NES_PHY_TYPE_PUMA_1G
) {
1455 et_cmd
->supported
= SUPPORTED_1000baseT_Full
;
1456 et_cmd
->advertising
= ADVERTISED_1000baseT_Full
;
1457 et_cmd
->autoneg
= AUTONEG_DISABLE
;
1458 et_cmd
->transceiver
= XCVR_INTERNAL
;
1459 et_cmd
->phy_address
= nesdev
->mac_index
;
1461 et_cmd
->supported
= SUPPORTED_1000baseT_Full
| SUPPORTED_Autoneg
;
1462 et_cmd
->advertising
= ADVERTISED_1000baseT_Full
| ADVERTISED_Autoneg
;
1463 nes_read_1G_phy_reg(nesdev
, 0, nesadapter
->phy_index
[nesdev
->mac_index
], &phy_data
);
1464 if (phy_data
& 0x1000)
1465 et_cmd
->autoneg
= AUTONEG_ENABLE
;
1467 et_cmd
->autoneg
= AUTONEG_DISABLE
;
1468 et_cmd
->transceiver
= XCVR_EXTERNAL
;
1469 et_cmd
->phy_address
= nesadapter
->phy_index
[nesdev
->mac_index
];
1472 if ((nesadapter
->phy_type
[nesdev
->mac_index
] == NES_PHY_TYPE_IRIS
) ||
1473 (nesadapter
->phy_type
[nesdev
->mac_index
] == NES_PHY_TYPE_ARGUS
)) {
1474 et_cmd
->transceiver
= XCVR_EXTERNAL
;
1475 et_cmd
->port
= PORT_FIBRE
;
1476 et_cmd
->supported
= SUPPORTED_FIBRE
;
1477 et_cmd
->advertising
= ADVERTISED_FIBRE
;
1478 et_cmd
->phy_address
= nesadapter
->phy_index
[nesdev
->mac_index
];
1480 et_cmd
->transceiver
= XCVR_INTERNAL
;
1481 et_cmd
->supported
= SUPPORTED_10000baseT_Full
;
1482 et_cmd
->advertising
= ADVERTISED_10000baseT_Full
;
1483 et_cmd
->phy_address
= nesdev
->mac_index
;
1485 et_cmd
->speed
= SPEED_10000
;
1486 et_cmd
->autoneg
= AUTONEG_DISABLE
;
1488 et_cmd
->maxtxpkt
= 511;
1489 et_cmd
->maxrxpkt
= 511;
1495 * nes_netdev_set_settings
1497 static int nes_netdev_set_settings(struct net_device
*netdev
, struct ethtool_cmd
*et_cmd
)
1499 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1500 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1501 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1504 if ((nesadapter
->OneG_Mode
) &&
1505 (nesadapter
->phy_type
[nesdev
->mac_index
] != NES_PHY_TYPE_PUMA_1G
)) {
1506 nes_read_1G_phy_reg(nesdev
, 0, nesadapter
->phy_index
[nesdev
->mac_index
],
1508 if (et_cmd
->autoneg
) {
1509 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1512 /* Turn off autoneg */
1513 phy_data
&= ~0x1000;
1515 nes_write_1G_phy_reg(nesdev
, 0, nesadapter
->phy_index
[nesdev
->mac_index
],
1523 static struct ethtool_ops nes_ethtool_ops
= {
1524 .get_link
= ethtool_op_get_link
,
1525 .get_settings
= nes_netdev_get_settings
,
1526 .set_settings
= nes_netdev_set_settings
,
1527 .get_tx_csum
= ethtool_op_get_tx_csum
,
1528 .get_rx_csum
= nes_netdev_get_rx_csum
,
1529 .get_sg
= ethtool_op_get_sg
,
1530 .get_strings
= nes_netdev_get_strings
,
1531 .get_stats_count
= nes_netdev_get_stats_count
,
1532 .get_ethtool_stats
= nes_netdev_get_ethtool_stats
,
1533 .get_drvinfo
= nes_netdev_get_drvinfo
,
1534 .get_coalesce
= nes_netdev_get_coalesce
,
1535 .set_coalesce
= nes_netdev_set_coalesce
,
1536 .get_pauseparam
= nes_netdev_get_pauseparam
,
1537 .set_pauseparam
= nes_netdev_set_pauseparam
,
1538 .set_tx_csum
= ethtool_op_set_tx_csum
,
1539 .set_rx_csum
= nes_netdev_set_rx_csum
,
1540 .set_sg
= ethtool_op_set_sg
,
1541 .get_tso
= ethtool_op_get_tso
,
1542 .set_tso
= ethtool_op_set_tso
,
1543 .get_flags
= ethtool_op_get_flags
,
1544 .set_flags
= ethtool_op_set_flags
,
1548 static void nes_netdev_vlan_rx_register(struct net_device
*netdev
, struct vlan_group
*grp
)
1550 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1551 struct nes_device
*nesdev
= nesvnic
->nesdev
;
1552 struct nes_adapter
*nesadapter
= nesdev
->nesadapter
;
1554 unsigned long flags
;
1556 spin_lock_irqsave(&nesadapter
->phy_lock
, flags
);
1557 nesvnic
->vlan_grp
= grp
;
1559 nes_debug(NES_DBG_NETDEV
, "%s: %s\n", __func__
, netdev
->name
);
1561 /* Enable/Disable VLAN Stripping */
1562 u32temp
= nes_read_indexed(nesdev
, NES_IDX_PCIX_DIAG
);
1564 u32temp
&= 0xfdffffff;
1566 u32temp
|= 0x02000000;
1568 nes_write_indexed(nesdev
, NES_IDX_PCIX_DIAG
, u32temp
);
1569 spin_unlock_irqrestore(&nesadapter
->phy_lock
, flags
);
1574 * nes_netdev_init - initialize network device
1576 struct net_device
*nes_netdev_init(struct nes_device
*nesdev
,
1577 void __iomem
*mmio_addr
)
1580 struct nes_vnic
*nesvnic
= NULL
;
1581 struct net_device
*netdev
;
1582 struct nic_qp_map
*curr_qp_map
;
1587 netdev
= alloc_etherdev(sizeof(struct nes_vnic
));
1589 printk(KERN_ERR PFX
"nesvnic etherdev alloc failed");
1593 nes_debug(NES_DBG_INIT
, "netdev = %p, %s\n", netdev
, netdev
->name
);
1595 SET_NETDEV_DEV(netdev
, &nesdev
->pcidev
->dev
);
1597 nesvnic
= netdev_priv(netdev
);
1598 memset(nesvnic
, 0, sizeof(*nesvnic
));
1600 netdev
->open
= nes_netdev_open
;
1601 netdev
->stop
= nes_netdev_stop
;
1602 netdev
->hard_start_xmit
= nes_netdev_start_xmit
;
1603 netdev
->get_stats
= nes_netdev_get_stats
;
1604 netdev
->tx_timeout
= nes_netdev_tx_timeout
;
1605 netdev
->set_mac_address
= nes_netdev_set_mac_address
;
1606 netdev
->set_multicast_list
= nes_netdev_set_multicast_list
;
1607 netdev
->change_mtu
= nes_netdev_change_mtu
;
1608 netdev
->watchdog_timeo
= NES_TX_TIMEOUT
;
1609 netdev
->irq
= nesdev
->pcidev
->irq
;
1610 netdev
->mtu
= ETH_DATA_LEN
;
1611 netdev
->hard_header_len
= ETH_HLEN
;
1612 netdev
->addr_len
= ETH_ALEN
;
1613 netdev
->type
= ARPHRD_ETHER
;
1614 netdev
->features
= NETIF_F_HIGHDMA
;
1615 netdev
->ethtool_ops
= &nes_ethtool_ops
;
1616 netif_napi_add(netdev
, &nesvnic
->napi
, nes_netdev_poll
, 128);
1617 nes_debug(NES_DBG_INIT
, "Enabling VLAN Insert/Delete.\n");
1618 netdev
->features
|= NETIF_F_HW_VLAN_TX
| NETIF_F_HW_VLAN_RX
;
1619 netdev
->vlan_rx_register
= nes_netdev_vlan_rx_register
;
1620 netdev
->features
|= NETIF_F_LLTX
;
1622 /* Fill in the port structure */
1623 nesvnic
->netdev
= netdev
;
1624 nesvnic
->nesdev
= nesdev
;
1625 nesvnic
->msg_enable
= netif_msg_init(debug
, default_msg
);
1626 nesvnic
->netdev_index
= nesdev
->netdev_count
;
1627 nesvnic
->perfect_filter_index
= nesdev
->nesadapter
->netdev_count
;
1628 nesvnic
->max_frame_size
= netdev
->mtu
+ netdev
->hard_header_len
+ VLAN_HLEN
;
1630 curr_qp_map
= nic_qp_mapping_per_function
[PCI_FUNC(nesdev
->pcidev
->devfn
)];
1631 nesvnic
->nic
.qp_id
= curr_qp_map
[nesdev
->netdev_count
].qpid
;
1632 nesvnic
->nic_index
= curr_qp_map
[nesdev
->netdev_count
].nic_index
;
1633 nesvnic
->logical_port
= curr_qp_map
[nesdev
->netdev_count
].logical_port
;
1635 /* Setup the burned in MAC address */
1636 u64temp
= (u64
)nesdev
->nesadapter
->mac_addr_low
;
1637 u64temp
+= ((u64
)nesdev
->nesadapter
->mac_addr_high
) << 32;
1638 u64temp
+= nesvnic
->nic_index
;
1639 netdev
->dev_addr
[0] = (u8
)(u64temp
>>40);
1640 netdev
->dev_addr
[1] = (u8
)(u64temp
>>32);
1641 netdev
->dev_addr
[2] = (u8
)(u64temp
>>24);
1642 netdev
->dev_addr
[3] = (u8
)(u64temp
>>16);
1643 netdev
->dev_addr
[4] = (u8
)(u64temp
>>8);
1644 netdev
->dev_addr
[5] = (u8
)u64temp
;
1645 memcpy(netdev
->perm_addr
, netdev
->dev_addr
, 6);
1647 if ((nesvnic
->logical_port
< 2) || (nesdev
->nesadapter
->hw_rev
!= NE020_REV
)) {
1648 netdev
->features
|= NETIF_F_TSO
| NETIF_F_SG
| NETIF_F_IP_CSUM
;
1649 netdev
->features
|= NETIF_F_GSO
| NETIF_F_TSO
| NETIF_F_SG
| NETIF_F_IP_CSUM
;
1651 netdev
->features
|= NETIF_F_SG
| NETIF_F_IP_CSUM
;
1654 nes_debug(NES_DBG_INIT
, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1655 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1656 nesvnic
, (unsigned long)netdev
->features
, nesvnic
->nic
.qp_id
,
1657 nesvnic
->nic_index
, nesvnic
->logical_port
, nesdev
->mac_index
);
1659 if (nesvnic
->nesdev
->nesadapter
->port_count
== 1 &&
1660 nesvnic
->nesdev
->nesadapter
->adapter_fcn_count
== 1) {
1662 nesvnic
->qp_nic_index
[0] = nesvnic
->nic_index
;
1663 nesvnic
->qp_nic_index
[1] = nesvnic
->nic_index
+ 1;
1664 if (nes_drv_opt
& NES_DRV_OPT_DUAL_LOGICAL_PORT
) {
1665 nesvnic
->qp_nic_index
[2] = 0xf;
1666 nesvnic
->qp_nic_index
[3] = 0xf;
1668 nesvnic
->qp_nic_index
[2] = nesvnic
->nic_index
+ 2;
1669 nesvnic
->qp_nic_index
[3] = nesvnic
->nic_index
+ 3;
1672 if (nesvnic
->nesdev
->nesadapter
->port_count
== 2 ||
1673 (nesvnic
->nesdev
->nesadapter
->port_count
== 1 &&
1674 nesvnic
->nesdev
->nesadapter
->adapter_fcn_count
== 2)) {
1675 nesvnic
->qp_nic_index
[0] = nesvnic
->nic_index
;
1676 nesvnic
->qp_nic_index
[1] = nesvnic
->nic_index
1678 nesvnic
->qp_nic_index
[2] = 0xf;
1679 nesvnic
->qp_nic_index
[3] = 0xf;
1681 nesvnic
->qp_nic_index
[0] = nesvnic
->nic_index
;
1682 nesvnic
->qp_nic_index
[1] = 0xf;
1683 nesvnic
->qp_nic_index
[2] = 0xf;
1684 nesvnic
->qp_nic_index
[3] = 0xf;
1687 nesvnic
->next_qp_nic_index
= 0;
1689 if (nesdev
->netdev_count
== 0) {
1690 nesvnic
->rdma_enabled
= 1;
1692 nesvnic
->rdma_enabled
= 0;
1694 nesvnic
->nic_cq
.cq_number
= nesvnic
->nic
.qp_id
;
1695 spin_lock_init(&nesvnic
->tx_lock
);
1696 nesdev
->netdev
[nesdev
->netdev_count
] = netdev
;
1698 nes_debug(NES_DBG_INIT
, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1699 nesvnic
, nesdev
->mac_index
);
1700 list_add_tail(&nesvnic
->list
, &nesdev
->nesadapter
->nesvnic_list
[nesdev
->mac_index
]);
1702 if ((nesdev
->netdev_count
== 0) &&
1703 ((PCI_FUNC(nesdev
->pcidev
->devfn
) == nesdev
->mac_index
) ||
1704 ((nesdev
->nesadapter
->phy_type
[nesdev
->mac_index
] == NES_PHY_TYPE_PUMA_1G
) &&
1705 (((PCI_FUNC(nesdev
->pcidev
->devfn
) == 1) && (nesdev
->mac_index
== 2)) ||
1706 ((PCI_FUNC(nesdev
->pcidev
->devfn
) == 2) && (nesdev
->mac_index
== 1)))))) {
1708 * nes_debug(NES_DBG_INIT, "Setting up PHY interrupt mask. Using register index 0x%04X\n",
1709 * NES_IDX_PHY_PCS_CONTROL_STATUS0 + (0x200 * (nesvnic->logical_port & 1)));
1711 u32temp
= nes_read_indexed(nesdev
, NES_IDX_PHY_PCS_CONTROL_STATUS0
+
1712 (0x200 * (nesdev
->mac_index
& 1)));
1713 if (nesdev
->nesadapter
->phy_type
[nesdev
->mac_index
] != NES_PHY_TYPE_PUMA_1G
) {
1714 u32temp
|= 0x00200000;
1715 nes_write_indexed(nesdev
, NES_IDX_PHY_PCS_CONTROL_STATUS0
+
1716 (0x200 * (nesdev
->mac_index
& 1)), u32temp
);
1719 u32temp
= nes_read_indexed(nesdev
, NES_IDX_PHY_PCS_CONTROL_STATUS0
+
1720 (0x200 * (nesdev
->mac_index
& 1)));
1722 if ((u32temp
&0x0f1f0000) == 0x0f0f0000) {
1723 if (nesdev
->nesadapter
->phy_type
[nesdev
->mac_index
] == NES_PHY_TYPE_IRIS
) {
1724 nes_init_phy(nesdev
);
1725 nes_read_10G_phy_reg(nesdev
, nesdev
->nesadapter
->phy_index
[nesdev
->mac_index
], 1, 1);
1726 temp_phy_data
= (u16
)nes_read_indexed(nesdev
,
1727 NES_IDX_MAC_MDIO_CONTROL
);
1730 nes_read_10G_phy_reg(nesdev
, nesdev
->nesadapter
->phy_index
[nesdev
->mac_index
], 1, 1);
1731 phy_data
= (u16
)nes_read_indexed(nesdev
,
1732 NES_IDX_MAC_MDIO_CONTROL
);
1733 if ((phy_data
== temp_phy_data
) || (!(--u32temp
)))
1735 temp_phy_data
= phy_data
;
1738 nes_debug(NES_DBG_INIT
, "The Link is UP!!.\n");
1739 nesvnic
->linkup
= 1;
1741 nes_debug(NES_DBG_INIT
, "The Link is DOWN!!.\n");
1744 nes_debug(NES_DBG_INIT
, "The Link is UP!!.\n");
1745 nesvnic
->linkup
= 1;
1747 } else if (nesdev
->nesadapter
->phy_type
[nesdev
->mac_index
] == NES_PHY_TYPE_PUMA_1G
) {
1748 nes_debug(NES_DBG_INIT
, "mac_index=%d, logical_port=%d, u32temp=0x%04X, PCI_FUNC=%d\n",
1749 nesdev
->mac_index
, nesvnic
->logical_port
, u32temp
, PCI_FUNC(nesdev
->pcidev
->devfn
));
1750 if (((nesdev
->mac_index
< 2) && ((u32temp
&0x01010000) == 0x01010000)) ||
1751 ((nesdev
->mac_index
> 1) && ((u32temp
&0x02020000) == 0x02020000))) {
1752 nes_debug(NES_DBG_INIT
, "The Link is UP!!.\n");
1753 nesvnic
->linkup
= 1;
1756 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1757 u32temp
= nes_read_indexed(nesdev
, NES_IDX_MAC_INT_STATUS
+ (0x200 * nesdev
->mac_index
));
1758 nes_debug(NES_DBG_INIT
, "Phy interrupt status = 0x%X.\n", u32temp
);
1759 nes_write_indexed(nesdev
, NES_IDX_MAC_INT_STATUS
+ (0x200 * nesdev
->mac_index
), u32temp
);
1761 if (nesdev
->nesadapter
->phy_type
[nesdev
->mac_index
] != NES_PHY_TYPE_IRIS
)
1762 nes_init_phy(nesdev
);
1771 * nes_netdev_destroy - destroy network device structure
1773 void nes_netdev_destroy(struct net_device
*netdev
)
1775 struct nes_vnic
*nesvnic
= netdev_priv(netdev
);
1777 /* make sure 'stop' method is called by Linux stack */
1778 /* nes_netdev_stop(netdev); */
1780 list_del(&nesvnic
->list
);
1782 if (nesvnic
->of_device_registered
) {
1783 nes_destroy_ofa_device(nesvnic
->nesibdev
);
1786 free_netdev(netdev
);
1791 * nes_nic_cm_xmit -- CM calls this to send out pkts
1793 int nes_nic_cm_xmit(struct sk_buff
*skb
, struct net_device
*netdev
)
1798 ret
= dev_queue_xmit(skb
);
1800 nes_debug(NES_DBG_CM
, "Bad return code from dev_queue_xmit %d\n", ret
);