2 * Copyright (c) 2006 - 2009 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;
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] = skb;
407 /* Deal with Fragments */
408 nesnic->tx_skb[nesnic->sq_head] = skb;
409 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
410 skb_fragment_index++) {
411 bus_address = pci_map_page( nesdev->pcidev,
412 skb_shinfo(skb)->frags[skb_fragment_index].page,
413 skb_shinfo(skb)->frags[skb_fragment_index].page_offset,
414 skb_shinfo(skb)->frags[skb_fragment_index].size,
416 wqe_fragment_length[wqe_fragment_index] =
417 cpu_to_le16(skb_shinfo(skb)->frags[skb_fragment_index].size);
418 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
420 wqe_fragment_index++;
421 if (wqe_fragment_index < 5)
422 wqe_fragment_length[wqe_fragment_index] = 0;
426 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
428 nesnic->sq_head &= nesnic->sq_size - 1;
435 * nes_netdev_start_xmit
437 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
439 struct nes_vnic *nesvnic = netdev_priv(netdev);
440 struct nes_device *nesdev = nesvnic->nesdev;
441 struct nes_hw_nic *nesnic = &nesvnic->nic;
442 struct nes_hw_nic_sq_wqe *nic_sqe;
444 /* struct udphdr *udph; */
445 #define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
446 /* 64K segment plus overflow on each side */
447 dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
448 dma_addr_t bus_address;
456 __le16 *wqe_fragment_length;
458 u32 original_first_length;
459 /* u64 *wqe_fragment_address; */
460 /* first fragment (0) is used by copy buffer */
461 u16 wqe_fragment_index=1;
470 * nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
471 * " (%u frags), tso_size=%u\n",
472 * netdev->name, skb->len, skb_headlen(skb),
473 * skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
476 if (!netif_carrier_ok(netdev))
479 if (netif_queue_stopped(netdev))
480 return NETDEV_TX_BUSY;
482 /* Check if SQ is full */
483 if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
484 if (!netif_queue_stopped(netdev)) {
485 netif_stop_queue(netdev);
487 if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
488 netif_start_queue(netdev);
489 goto sq_no_longer_full;
493 return NETDEV_TX_BUSY;
497 nr_frags = skb_shinfo(skb)->nr_frags;
498 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
501 /* Check if too many fragments */
502 if (unlikely((nr_frags > 4))) {
503 if (skb_is_gso(skb)) {
504 nesvnic->segmented_tso_requests++;
505 nesvnic->tso_requests++;
506 old_head = nesnic->sq_head;
507 /* Basically 4 fragments available per WQE with extended fragments */
508 wqes_needed = nr_frags >> 2;
509 wqes_needed += (nr_frags&3)?1:0;
510 wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
511 (nesnic->sq_size - 1);
513 if (unlikely(wqes_needed > wqes_available)) {
514 if (!netif_queue_stopped(netdev)) {
515 netif_stop_queue(netdev);
517 wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
518 (nesnic->sq_size - 1);
519 if (wqes_needed <= wqes_available) {
520 netif_start_queue(netdev);
521 goto tso_sq_no_longer_full;
525 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
527 return NETDEV_TX_BUSY;
529 tso_sq_no_longer_full:
530 /* Map all the buffers */
531 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
533 tso_bus_address[tso_frag_count] = pci_map_page( nesdev->pcidev,
534 skb_shinfo(skb)->frags[tso_frag_count].page,
535 skb_shinfo(skb)->frags[tso_frag_count].page_offset,
536 skb_shinfo(skb)->frags[tso_frag_count].size,
541 curr_tcp_seq = ntohl(tcp_hdr(skb)->seq);
542 hoffset = skb_transport_header(skb) - skb->data;
543 nhoffset = skb_network_header(skb) - skb->data;
544 original_first_length = hoffset + ((((struct tcphdr *)skb_transport_header(skb))->doff)<<2);
546 for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
548 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
549 wqe_fragment_length =
550 (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
551 /* setup the VLAN tag if present */
552 if (vlan_tx_tag_present(skb)) {
553 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
554 netdev->name, vlan_tx_tag_get(skb) );
555 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
556 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
560 /* bump past the vlan tag */
561 wqe_fragment_length++;
563 /* Assumes header totally fits in allocated buffer and is in first fragment */
564 if (original_first_length > NES_FIRST_FRAG_SIZE) {
565 nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
566 original_first_length, NES_FIRST_FRAG_SIZE);
567 nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
568 " (%u frags), tso_size=%u\n",
570 skb->len, skb_headlen(skb),
571 skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
573 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
574 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
575 original_first_length));
576 iph = (struct iphdr *)
577 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[nhoffset]);
578 tcph = (struct tcphdr *)
579 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[hoffset]);
580 if ((wqe_count+1)!=(u32)wqes_needed) {
589 tcph->seq = htonl(curr_tcp_seq);
590 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
591 original_first_length));
593 wqe_fragment_index = 1;
594 if ((wqe_count==0) && (skb_headlen(skb) > original_first_length)) {
595 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
596 bus_address = pci_map_single(nesdev->pcidev, skb->data + original_first_length,
597 skb_headlen(skb) - original_first_length, PCI_DMA_TODEVICE);
598 wqe_fragment_length[wqe_fragment_index++] =
599 cpu_to_le16(skb_headlen(skb) - original_first_length);
600 wqe_fragment_length[wqe_fragment_index] = 0;
601 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
603 tso_wqe_length += skb_headlen(skb) -
604 original_first_length;
606 while (wqe_fragment_index < 5) {
607 wqe_fragment_length[wqe_fragment_index] =
608 cpu_to_le16(skb_shinfo(skb)->frags[tso_frag_index].size);
609 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
610 (u64)tso_bus_address[tso_frag_index]);
611 wqe_fragment_index++;
612 tso_wqe_length += skb_shinfo(skb)->frags[tso_frag_index++].size;
613 if (wqe_fragment_index < 5)
614 wqe_fragment_length[wqe_fragment_index] = 0;
615 if (tso_frag_index == tso_frag_count)
618 if ((wqe_count+1) == (u32)wqes_needed) {
619 nesnic->tx_skb[nesnic->sq_head] = skb;
621 nesnic->tx_skb[nesnic->sq_head] = NULL;
623 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
624 if ((tso_wqe_length + original_first_length) > skb_is_gso(skb)) {
625 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
627 iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
630 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
632 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
633 ((u32)tcph->doff) | (((u32)hoffset) << 4));
635 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
636 tso_wqe_length + original_first_length);
637 curr_tcp_seq += tso_wqe_length;
639 nesnic->sq_head &= nesnic->sq_size-1;
642 nesvnic->linearized_skbs++;
643 hoffset = skb_transport_header(skb) - skb->data;
644 nhoffset = skb_network_header(skb) - skb->data;
646 skb_set_transport_header(skb, hoffset);
647 skb_set_network_header(skb, nhoffset);
648 send_rc = nes_nic_send(skb, netdev);
649 if (send_rc != NETDEV_TX_OK)
653 send_rc = nes_nic_send(skb, netdev);
654 if (send_rc != NETDEV_TX_OK)
661 nes_write32(nesdev->regs+NES_WQE_ALLOC,
662 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
664 netdev->trans_start = jiffies;
671 * nes_netdev_get_stats
673 static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
675 struct nes_vnic *nesvnic = netdev_priv(netdev);
676 struct nes_device *nesdev = nesvnic->nesdev;
680 u32temp = nes_read_indexed(nesdev,
681 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD + (nesvnic->nic_index*0x200));
682 nesvnic->netstats.rx_dropped += u32temp;
683 nesvnic->endnode_nstat_rx_discard += u32temp;
685 u64temp = (u64)nes_read_indexed(nesdev,
686 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO + (nesvnic->nic_index*0x200));
687 u64temp += ((u64)nes_read_indexed(nesdev,
688 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
690 nesvnic->endnode_nstat_rx_octets += u64temp;
691 nesvnic->netstats.rx_bytes += u64temp;
693 u64temp = (u64)nes_read_indexed(nesdev,
694 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO + (nesvnic->nic_index*0x200));
695 u64temp += ((u64)nes_read_indexed(nesdev,
696 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
698 nesvnic->endnode_nstat_rx_frames += u64temp;
699 nesvnic->netstats.rx_packets += u64temp;
701 u64temp = (u64)nes_read_indexed(nesdev,
702 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO + (nesvnic->nic_index*0x200));
703 u64temp += ((u64)nes_read_indexed(nesdev,
704 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
706 nesvnic->endnode_nstat_tx_octets += u64temp;
707 nesvnic->netstats.tx_bytes += u64temp;
709 u64temp = (u64)nes_read_indexed(nesdev,
710 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO + (nesvnic->nic_index*0x200));
711 u64temp += ((u64)nes_read_indexed(nesdev,
712 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
714 nesvnic->endnode_nstat_tx_frames += u64temp;
715 nesvnic->netstats.tx_packets += u64temp;
717 u32temp = nes_read_indexed(nesdev,
718 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
719 nesvnic->netstats.rx_dropped += u32temp;
720 nesvnic->nesdev->mac_rx_errors += u32temp;
721 nesvnic->nesdev->mac_rx_short_frames += u32temp;
723 u32temp = nes_read_indexed(nesdev,
724 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
725 nesvnic->netstats.rx_dropped += u32temp;
726 nesvnic->nesdev->mac_rx_errors += u32temp;
727 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
729 u32temp = nes_read_indexed(nesdev,
730 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
731 nesvnic->netstats.rx_dropped += u32temp;
732 nesvnic->nesdev->mac_rx_errors += u32temp;
733 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
735 u32temp = nes_read_indexed(nesdev,
736 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
737 nesvnic->netstats.rx_dropped += u32temp;
738 nesvnic->nesdev->mac_rx_errors += u32temp;
739 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
741 u32temp = nes_read_indexed(nesdev,
742 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
743 nesvnic->netstats.rx_length_errors += u32temp;
744 nesvnic->nesdev->mac_rx_errors += u32temp;
746 u32temp = nes_read_indexed(nesdev,
747 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
748 nesvnic->nesdev->mac_rx_errors += u32temp;
749 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
750 nesvnic->netstats.rx_crc_errors += u32temp;
752 u32temp = nes_read_indexed(nesdev,
753 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
754 nesvnic->nesdev->mac_tx_errors += u32temp;
755 nesvnic->netstats.tx_errors += u32temp;
757 return &nesvnic->netstats;
762 * nes_netdev_tx_timeout
764 static void nes_netdev_tx_timeout(struct net_device *netdev)
766 struct nes_vnic *nesvnic = netdev_priv(netdev);
768 if (netif_msg_timer(nesvnic))
769 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
774 * nes_netdev_set_mac_address
776 static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
778 struct nes_vnic *nesvnic = netdev_priv(netdev);
779 struct nes_device *nesdev = nesvnic->nesdev;
780 struct sockaddr *mac_addr = p;
785 if (!is_valid_ether_addr(mac_addr->sa_data))
786 return -EADDRNOTAVAIL;
788 memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
789 printk(PFX "%s: Address length = %d, Address = %pM\n",
790 __func__, netdev->addr_len, mac_addr->sa_data);
791 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
792 macaddr_high += (u16)netdev->dev_addr[1];
793 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
794 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
795 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
796 macaddr_low += (u32)netdev->dev_addr[5];
798 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
799 if (nesvnic->qp_nic_index[i] == 0xf) {
802 nes_write_indexed(nesdev,
803 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
805 nes_write_indexed(nesdev,
806 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
807 (u32)macaddr_high | NES_MAC_ADDR_VALID |
808 ((((u32)nesvnic->nic_index) << 16)));
814 static void set_allmulti(struct nes_device *nesdev, u32 nic_active_bit)
818 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
819 nic_active |= nic_active_bit;
820 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
821 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
822 nic_active &= ~nic_active_bit;
823 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
826 #define get_addr(addrs, index) ((addrs) + (index) * ETH_ALEN)
829 * nes_netdev_set_multicast_list
831 static void nes_netdev_set_multicast_list(struct net_device *netdev)
833 struct nes_vnic *nesvnic = netdev_priv(netdev);
834 struct nes_device *nesdev = nesvnic->nesdev;
835 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
838 u32 perfect_filter_register_address;
843 int mc_nic_index = -1;
844 u8 pft_entries_preallocated = max(nesadapter->adapter_fcn_count *
845 nics_per_function, 4);
846 u8 max_pft_entries_avaiable = NES_PFT_SIZE - pft_entries_preallocated;
848 int mc_count = netdev_mc_count(netdev);
850 spin_lock_irqsave(&nesadapter->resource_lock, flags);
851 nic_active_bit = 1 << nesvnic->nic_index;
853 if (netdev->flags & IFF_PROMISC) {
854 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
855 nic_active |= nic_active_bit;
856 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
857 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
858 nic_active |= nic_active_bit;
859 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
861 } else if ((netdev->flags & IFF_ALLMULTI) ||
862 (nesvnic->nic_index > 3)) {
863 set_allmulti(nesdev, nic_active_bit);
866 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
867 nic_active &= ~nic_active_bit;
868 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
869 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
870 nic_active &= ~nic_active_bit;
871 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
874 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscous = %d, All Multicast = %d.\n",
875 mc_count, !!(netdev->flags & IFF_PROMISC),
876 !!(netdev->flags & IFF_ALLMULTI));
880 struct netdev_hw_addr *ha;
882 addrs = kmalloc(ETH_ALEN * mc_count, GFP_ATOMIC);
884 set_allmulti(nesdev, nic_active_bit);
888 netdev_for_each_mc_addr(ha, netdev)
889 memcpy(get_addr(addrs, i++), ha->addr, ETH_ALEN);
891 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW +
892 pft_entries_preallocated * 0x8;
893 for (i = 0, mc_index = 0; mc_index < max_pft_entries_avaiable;
895 while (i < mc_count && nesvnic->mcrq_mcast_filter &&
896 ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
897 get_addr(addrs, i++))) == 0));
898 if (mc_nic_index < 0)
899 mc_nic_index = nesvnic->nic_index;
900 while (nesadapter->pft_mcast_map[mc_index] < 16 &&
901 nesadapter->pft_mcast_map[mc_index] !=
902 nesvnic->nic_index &&
903 mc_index < max_pft_entries_avaiable) {
904 nes_debug(NES_DBG_NIC_RX,
905 "mc_index=%d skipping nic_index=%d,\
906 used for=%d \n", mc_index,
908 nesadapter->pft_mcast_map[mc_index]);
911 if (mc_index >= max_pft_entries_avaiable)
914 char *addr = get_addr(addrs, i++);
916 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
918 perfect_filter_register_address+(mc_index * 8),
920 macaddr_high = ((u16) addr[0]) << 8;
921 macaddr_high += (u16) addr[1];
922 macaddr_low = ((u32) addr[2]) << 24;
923 macaddr_low += ((u32) addr[3]) << 16;
924 macaddr_low += ((u32) addr[4]) << 8;
925 macaddr_low += (u32) addr[5];
926 nes_write_indexed(nesdev,
927 perfect_filter_register_address+(mc_index * 8),
929 nes_write_indexed(nesdev,
930 perfect_filter_register_address+4+(mc_index * 8),
931 (u32)macaddr_high | NES_MAC_ADDR_VALID |
932 ((((u32)(1<<mc_nic_index)) << 16)));
933 nesadapter->pft_mcast_map[mc_index] =
936 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
937 perfect_filter_register_address+(mc_index * 8));
938 nes_write_indexed(nesdev,
939 perfect_filter_register_address+4+(mc_index * 8),
941 nesadapter->pft_mcast_map[mc_index] = 255;
945 /* PFT is not large enough */
947 set_allmulti(nesdev, nic_active_bit);
951 spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
956 * nes_netdev_change_mtu
958 static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
960 struct nes_vnic *nesvnic = netdev_priv(netdev);
961 struct nes_device *nesdev = nesvnic->nesdev;
969 if ((new_mtu < ETH_ZLEN) || (new_mtu > max_mtu))
972 netdev->mtu = new_mtu;
973 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
975 if (netdev->mtu > 1500) {
978 nes_nic_init_timer_defaults(nesdev, jumbomode);
980 if (netif_running(netdev)) {
981 nic_active_bit = 1 << nesvnic->nic_index;
982 mc_all_active = nes_read_indexed(nesdev,
983 NES_IDX_NIC_MULTICAST_ALL) & nic_active_bit;
984 uc_all_active = nes_read_indexed(nesdev,
985 NES_IDX_NIC_UNICAST_ALL) & nic_active_bit;
987 nes_netdev_stop(netdev);
988 nes_netdev_open(netdev);
990 nic_active = nes_read_indexed(nesdev,
991 NES_IDX_NIC_MULTICAST_ALL);
992 nic_active |= mc_all_active;
993 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL,
996 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
997 nic_active |= uc_all_active;
998 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
1005 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
1006 "Link Change Interrupts",
1009 "Pause Frames Sent",
1010 "Pause Frames Received",
1011 "Internal Routing Errors",
1012 "SQ SW Dropped SKBs",
1014 "Segmented TSO Requests",
1017 "Rx Oversized Frames",
1022 "Endnode Rx Discards",
1023 "Endnode Rx Octets",
1024 "Endnode Rx Frames",
1025 "Endnode Tx Octets",
1026 "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",
1063 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1066 * nes_netdev_get_rx_csum
1068 static u32 nes_netdev_get_rx_csum (struct net_device *netdev)
1070 struct nes_vnic *nesvnic = netdev_priv(netdev);
1072 if (nesvnic->rx_checksum_disabled)
1080 * nes_netdev_set_rc_csum
1082 static int nes_netdev_set_rx_csum(struct net_device *netdev, u32 enable)
1084 struct nes_vnic *nesvnic = netdev_priv(netdev);
1087 nesvnic->rx_checksum_disabled = 0;
1089 nesvnic->rx_checksum_disabled = 1;
1095 * nes_netdev_get_sset_count
1097 static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
1099 if (stringset == ETH_SS_STATS)
1100 return NES_ETHTOOL_STAT_COUNT;
1107 * nes_netdev_get_strings
1109 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1110 u8 *ethtool_strings)
1112 if (stringset == ETH_SS_STATS)
1113 memcpy(ethtool_strings,
1114 &nes_ethtool_stringset,
1115 sizeof(nes_ethtool_stringset));
1120 * nes_netdev_get_ethtool_stats
1123 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1124 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1127 struct nes_vnic *nesvnic = netdev_priv(netdev);
1128 struct nes_device *nesdev = nesvnic->nesdev;
1129 struct nes_adapter *nesadapter = nesdev->nesadapter;
1134 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1135 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1136 target_stat_values[++index] = nesvnic->linearized_skbs;
1137 target_stat_values[++index] = 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[++index] = 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 u32temp = nes_read_indexed(nesdev,
1159 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1160 nesvnic->netstats.rx_dropped += u32temp;
1161 nesvnic->nesdev->mac_rx_errors += u32temp;
1162 nesvnic->nesdev->mac_rx_short_frames += u32temp;
1164 u32temp = nes_read_indexed(nesdev,
1165 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1166 nesvnic->netstats.rx_dropped += u32temp;
1167 nesvnic->nesdev->mac_rx_errors += u32temp;
1168 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
1170 u32temp = nes_read_indexed(nesdev,
1171 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1172 nesvnic->netstats.rx_dropped += u32temp;
1173 nesvnic->nesdev->mac_rx_errors += u32temp;
1174 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
1176 u32temp = nes_read_indexed(nesdev,
1177 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1178 nesvnic->netstats.rx_dropped += u32temp;
1179 nesvnic->nesdev->mac_rx_errors += u32temp;
1180 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
1182 u32temp = nes_read_indexed(nesdev,
1183 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1184 nesvnic->netstats.rx_length_errors += u32temp;
1185 nesvnic->nesdev->mac_rx_errors += u32temp;
1187 u32temp = nes_read_indexed(nesdev,
1188 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1189 nesvnic->nesdev->mac_rx_errors += u32temp;
1190 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
1191 nesvnic->netstats.rx_crc_errors += u32temp;
1193 u32temp = nes_read_indexed(nesdev,
1194 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
1195 nesvnic->nesdev->mac_tx_errors += u32temp;
1196 nesvnic->netstats.tx_errors += u32temp;
1198 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1199 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1202 u32temp = nes_read_indexed(nesdev,
1203 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1204 (nesvnic->qp_nic_index[nic_count]*0x200));
1205 nesvnic->netstats.rx_dropped += u32temp;
1206 nesvnic->endnode_nstat_rx_discard += u32temp;
1208 u64temp = (u64)nes_read_indexed(nesdev,
1209 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1210 (nesvnic->qp_nic_index[nic_count]*0x200));
1211 u64temp += ((u64)nes_read_indexed(nesdev,
1212 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1213 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1215 nesvnic->endnode_nstat_rx_octets += u64temp;
1216 nesvnic->netstats.rx_bytes += u64temp;
1218 u64temp = (u64)nes_read_indexed(nesdev,
1219 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1220 (nesvnic->qp_nic_index[nic_count]*0x200));
1221 u64temp += ((u64)nes_read_indexed(nesdev,
1222 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1223 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1225 nesvnic->endnode_nstat_rx_frames += u64temp;
1226 nesvnic->netstats.rx_packets += u64temp;
1228 u64temp = (u64)nes_read_indexed(nesdev,
1229 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1230 (nesvnic->qp_nic_index[nic_count]*0x200));
1231 u64temp += ((u64)nes_read_indexed(nesdev,
1232 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1233 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1235 nesvnic->endnode_nstat_tx_octets += u64temp;
1236 nesvnic->netstats.tx_bytes += u64temp;
1238 u64temp = (u64)nes_read_indexed(nesdev,
1239 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1240 (nesvnic->qp_nic_index[nic_count]*0x200));
1241 u64temp += ((u64)nes_read_indexed(nesdev,
1242 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1243 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1245 nesvnic->endnode_nstat_tx_frames += u64temp;
1246 nesvnic->netstats.tx_packets += u64temp;
1248 u32temp = nes_read_indexed(nesdev,
1249 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1250 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1253 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1254 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1255 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1256 target_stat_values[++index] = nesvnic->sq_full;
1257 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1258 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1259 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1260 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1261 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
1262 target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
1263 target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
1264 target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
1265 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1266 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1267 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1268 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1269 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
1270 target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
1271 target_stat_values[++index] = mh_detected;
1272 target_stat_values[++index] = mh_pauses_sent;
1273 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1274 target_stat_values[++index] = atomic_read(&cm_connects);
1275 target_stat_values[++index] = atomic_read(&cm_accepts);
1276 target_stat_values[++index] = atomic_read(&cm_disconnects);
1277 target_stat_values[++index] = atomic_read(&cm_connecteds);
1278 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1279 target_stat_values[++index] = atomic_read(&cm_rejects);
1280 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1281 target_stat_values[++index] = atomic_read(&qps_created);
1282 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1283 target_stat_values[++index] = atomic_read(&qps_destroyed);
1284 target_stat_values[++index] = atomic_read(&cm_closes);
1285 target_stat_values[++index] = cm_packets_sent;
1286 target_stat_values[++index] = cm_packets_bounced;
1287 target_stat_values[++index] = cm_packets_created;
1288 target_stat_values[++index] = cm_packets_received;
1289 target_stat_values[++index] = cm_packets_dropped;
1290 target_stat_values[++index] = cm_packets_retrans;
1291 target_stat_values[++index] = atomic_read(&cm_listens_created);
1292 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
1293 target_stat_values[++index] = cm_backlog_drops;
1294 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1295 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1296 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1297 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1298 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
1299 target_stat_values[++index] = nesadapter->free_4kpbl;
1300 target_stat_values[++index] = nesadapter->free_256pbl;
1301 target_stat_values[++index] = int_mod_timer_init;
1302 target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
1303 target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
1304 target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
1308 * nes_netdev_get_drvinfo
1310 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1311 struct ethtool_drvinfo *drvinfo)
1313 struct nes_vnic *nesvnic = netdev_priv(netdev);
1314 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
1316 strcpy(drvinfo->driver, DRV_NAME);
1317 strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
1318 sprintf(drvinfo->fw_version, "%u.%u", nesadapter->firmware_version>>16,
1319 nesadapter->firmware_version & 0x000000ff);
1320 strcpy(drvinfo->version, DRV_VERSION);
1321 drvinfo->testinfo_len = 0;
1322 drvinfo->eedump_len = 0;
1323 drvinfo->regdump_len = 0;
1328 * nes_netdev_set_coalesce
1330 static int nes_netdev_set_coalesce(struct net_device *netdev,
1331 struct ethtool_coalesce *et_coalesce)
1333 struct nes_vnic *nesvnic = netdev_priv(netdev);
1334 struct nes_device *nesdev = nesvnic->nesdev;
1335 struct nes_adapter *nesadapter = nesdev->nesadapter;
1336 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1337 unsigned long flags;
1339 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1340 if (et_coalesce->rx_max_coalesced_frames_low) {
1341 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1343 if (et_coalesce->rx_max_coalesced_frames_irq) {
1344 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1346 if (et_coalesce->rx_max_coalesced_frames_high) {
1347 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1349 if (et_coalesce->rx_coalesce_usecs_low) {
1350 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1352 if (et_coalesce->rx_coalesce_usecs_high) {
1353 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1355 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1357 /* using this to drive total interrupt moderation */
1358 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1359 if (et_coalesce->use_adaptive_rx_coalesce) {
1360 nesadapter->et_use_adaptive_rx_coalesce = 1;
1361 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1362 nesadapter->et_rx_coalesce_usecs_irq = 0;
1363 if (et_coalesce->pkt_rate_low) {
1364 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1367 nesadapter->et_use_adaptive_rx_coalesce = 0;
1368 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1369 if (nesadapter->et_rx_coalesce_usecs_irq) {
1370 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1371 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1379 * nes_netdev_get_coalesce
1381 static int nes_netdev_get_coalesce(struct net_device *netdev,
1382 struct ethtool_coalesce *et_coalesce)
1384 struct nes_vnic *nesvnic = netdev_priv(netdev);
1385 struct nes_device *nesdev = nesvnic->nesdev;
1386 struct nes_adapter *nesadapter = nesdev->nesadapter;
1387 struct ethtool_coalesce temp_et_coalesce;
1388 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1389 unsigned long flags;
1391 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1392 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1393 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1394 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1395 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1396 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1397 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1398 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
1399 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1400 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1401 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1402 if (nesadapter->et_use_adaptive_rx_coalesce) {
1403 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1405 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1406 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1412 * nes_netdev_get_pauseparam
1414 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1415 struct ethtool_pauseparam *et_pauseparam)
1417 struct nes_vnic *nesvnic = netdev_priv(netdev);
1419 et_pauseparam->autoneg = 0;
1420 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1421 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1426 * nes_netdev_set_pauseparam
1428 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1429 struct ethtool_pauseparam *et_pauseparam)
1431 struct nes_vnic *nesvnic = netdev_priv(netdev);
1432 struct nes_device *nesdev = nesvnic->nesdev;
1435 if (et_pauseparam->autoneg) {
1436 /* TODO: should return unsupported */
1439 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1440 u32temp = nes_read_indexed(nesdev,
1441 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1442 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1443 nes_write_indexed(nesdev,
1444 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1445 nesdev->disable_tx_flow_control = 0;
1446 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1447 u32temp = nes_read_indexed(nesdev,
1448 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1449 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1450 nes_write_indexed(nesdev,
1451 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1452 nesdev->disable_tx_flow_control = 1;
1454 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1455 u32temp = nes_read_indexed(nesdev,
1456 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1457 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1458 nes_write_indexed(nesdev,
1459 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1460 nesdev->disable_rx_flow_control = 0;
1461 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1462 u32temp = nes_read_indexed(nesdev,
1463 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1464 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1465 nes_write_indexed(nesdev,
1466 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1467 nesdev->disable_rx_flow_control = 1;
1475 * nes_netdev_get_settings
1477 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1479 struct nes_vnic *nesvnic = netdev_priv(netdev);
1480 struct nes_device *nesdev = nesvnic->nesdev;
1481 struct nes_adapter *nesadapter = nesdev->nesadapter;
1482 u32 mac_index = nesdev->mac_index;
1483 u8 phy_type = nesadapter->phy_type[mac_index];
1484 u8 phy_index = nesadapter->phy_index[mac_index];
1487 et_cmd->duplex = DUPLEX_FULL;
1488 et_cmd->port = PORT_MII;
1489 et_cmd->maxtxpkt = 511;
1490 et_cmd->maxrxpkt = 511;
1492 if (nesadapter->OneG_Mode) {
1493 et_cmd->speed = SPEED_1000;
1494 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
1495 et_cmd->supported = SUPPORTED_1000baseT_Full;
1496 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1497 et_cmd->autoneg = AUTONEG_DISABLE;
1498 et_cmd->transceiver = XCVR_INTERNAL;
1499 et_cmd->phy_address = mac_index;
1501 unsigned long flags;
1502 et_cmd->supported = SUPPORTED_1000baseT_Full
1503 | SUPPORTED_Autoneg;
1504 et_cmd->advertising = ADVERTISED_1000baseT_Full
1505 | ADVERTISED_Autoneg;
1506 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1507 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1508 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1509 if (phy_data & 0x1000)
1510 et_cmd->autoneg = AUTONEG_ENABLE;
1512 et_cmd->autoneg = AUTONEG_DISABLE;
1513 et_cmd->transceiver = XCVR_EXTERNAL;
1514 et_cmd->phy_address = phy_index;
1518 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1519 (phy_type == NES_PHY_TYPE_SFP_D) ||
1520 (phy_type == NES_PHY_TYPE_KR)) {
1521 et_cmd->transceiver = XCVR_EXTERNAL;
1522 et_cmd->port = PORT_FIBRE;
1523 et_cmd->supported = SUPPORTED_FIBRE;
1524 et_cmd->advertising = ADVERTISED_FIBRE;
1525 et_cmd->phy_address = phy_index;
1527 et_cmd->transceiver = XCVR_INTERNAL;
1528 et_cmd->supported = SUPPORTED_10000baseT_Full;
1529 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1530 et_cmd->phy_address = mac_index;
1532 et_cmd->speed = SPEED_10000;
1533 et_cmd->autoneg = AUTONEG_DISABLE;
1539 * nes_netdev_set_settings
1541 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1543 struct nes_vnic *nesvnic = netdev_priv(netdev);
1544 struct nes_device *nesdev = nesvnic->nesdev;
1545 struct nes_adapter *nesadapter = nesdev->nesadapter;
1547 if ((nesadapter->OneG_Mode) &&
1548 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1549 unsigned long flags;
1551 u8 phy_index = nesadapter->phy_index[nesdev->mac_index];
1553 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1554 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1555 if (et_cmd->autoneg) {
1556 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1559 /* Turn off autoneg */
1560 phy_data &= ~0x1000;
1562 nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data);
1563 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1570 static const struct ethtool_ops nes_ethtool_ops = {
1571 .get_link = ethtool_op_get_link,
1572 .get_settings = nes_netdev_get_settings,
1573 .set_settings = nes_netdev_set_settings,
1574 .get_tx_csum = ethtool_op_get_tx_csum,
1575 .get_rx_csum = nes_netdev_get_rx_csum,
1576 .get_sg = ethtool_op_get_sg,
1577 .get_strings = nes_netdev_get_strings,
1578 .get_sset_count = nes_netdev_get_sset_count,
1579 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1580 .get_drvinfo = nes_netdev_get_drvinfo,
1581 .get_coalesce = nes_netdev_get_coalesce,
1582 .set_coalesce = nes_netdev_set_coalesce,
1583 .get_pauseparam = nes_netdev_get_pauseparam,
1584 .set_pauseparam = nes_netdev_set_pauseparam,
1585 .set_tx_csum = ethtool_op_set_tx_csum,
1586 .set_rx_csum = nes_netdev_set_rx_csum,
1587 .set_sg = ethtool_op_set_sg,
1588 .get_tso = ethtool_op_get_tso,
1589 .set_tso = ethtool_op_set_tso,
1590 .get_flags = ethtool_op_get_flags,
1591 .set_flags = ethtool_op_set_flags,
1595 static void nes_netdev_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
1597 struct nes_vnic *nesvnic = netdev_priv(netdev);
1598 struct nes_device *nesdev = nesvnic->nesdev;
1599 struct nes_adapter *nesadapter = nesdev->nesadapter;
1601 unsigned long flags;
1603 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1604 nesvnic->vlan_grp = grp;
1606 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1608 /* Enable/Disable VLAN Stripping */
1609 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1611 u32temp &= 0xfdffffff;
1613 u32temp |= 0x02000000;
1615 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1616 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1619 static const struct net_device_ops nes_netdev_ops = {
1620 .ndo_open = nes_netdev_open,
1621 .ndo_stop = nes_netdev_stop,
1622 .ndo_start_xmit = nes_netdev_start_xmit,
1623 .ndo_get_stats = nes_netdev_get_stats,
1624 .ndo_tx_timeout = nes_netdev_tx_timeout,
1625 .ndo_set_mac_address = nes_netdev_set_mac_address,
1626 .ndo_set_multicast_list = nes_netdev_set_multicast_list,
1627 .ndo_change_mtu = nes_netdev_change_mtu,
1628 .ndo_validate_addr = eth_validate_addr,
1629 .ndo_vlan_rx_register = nes_netdev_vlan_rx_register,
1633 * nes_netdev_init - initialize network device
1635 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1636 void __iomem *mmio_addr)
1639 struct nes_vnic *nesvnic;
1640 struct net_device *netdev;
1641 struct nic_qp_map *curr_qp_map;
1642 u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
1644 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1646 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1649 nesvnic = netdev_priv(netdev);
1651 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1653 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1655 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1656 netdev->irq = nesdev->pcidev->irq;
1657 netdev->mtu = ETH_DATA_LEN;
1658 netdev->hard_header_len = ETH_HLEN;
1659 netdev->addr_len = ETH_ALEN;
1660 netdev->type = ARPHRD_ETHER;
1661 netdev->features = NETIF_F_HIGHDMA;
1662 netdev->netdev_ops = &nes_netdev_ops;
1663 netdev->ethtool_ops = &nes_ethtool_ops;
1664 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1665 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1666 netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1668 /* Fill in the port structure */
1669 nesvnic->netdev = netdev;
1670 nesvnic->nesdev = nesdev;
1671 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1672 nesvnic->netdev_index = nesdev->netdev_count;
1673 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1674 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1676 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1677 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1678 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1679 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1681 /* Setup the burned in MAC address */
1682 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1683 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1684 u64temp += nesvnic->nic_index;
1685 netdev->dev_addr[0] = (u8)(u64temp>>40);
1686 netdev->dev_addr[1] = (u8)(u64temp>>32);
1687 netdev->dev_addr[2] = (u8)(u64temp>>24);
1688 netdev->dev_addr[3] = (u8)(u64temp>>16);
1689 netdev->dev_addr[4] = (u8)(u64temp>>8);
1690 netdev->dev_addr[5] = (u8)u64temp;
1691 memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1693 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV)) {
1694 netdev->features |= NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1695 netdev->features |= NETIF_F_GSO | NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1697 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1700 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1701 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1702 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1703 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1705 if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1706 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1708 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1709 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1710 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1711 nesvnic->qp_nic_index[2] = 0xf;
1712 nesvnic->qp_nic_index[3] = 0xf;
1714 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1715 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1718 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1719 (nesvnic->nesdev->nesadapter->port_count == 1 &&
1720 nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1721 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1722 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1724 nesvnic->qp_nic_index[2] = 0xf;
1725 nesvnic->qp_nic_index[3] = 0xf;
1727 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1728 nesvnic->qp_nic_index[1] = 0xf;
1729 nesvnic->qp_nic_index[2] = 0xf;
1730 nesvnic->qp_nic_index[3] = 0xf;
1733 nesvnic->next_qp_nic_index = 0;
1735 if (nesdev->netdev_count == 0) {
1736 nesvnic->rdma_enabled = 1;
1738 nesvnic->rdma_enabled = 0;
1740 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1741 spin_lock_init(&nesvnic->tx_lock);
1742 nesdev->netdev[nesdev->netdev_count] = netdev;
1744 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1745 nesvnic, nesdev->mac_index);
1746 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1748 if ((nesdev->netdev_count == 0) &&
1749 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1750 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
1751 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1752 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1757 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1758 (0x200 * (nesdev->mac_index & 1)));
1759 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
1760 u32temp |= 0x00200000;
1761 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1762 (0x200 * (nesdev->mac_index & 1)), u32temp);
1765 /* Check and set linkup here. This is for back to back */
1766 /* configuration where second port won't get link interrupt */
1768 case NES_PHY_TYPE_PUMA_1G:
1769 if (nesdev->mac_index < 2) {
1770 link_mask = 0x01010000;
1771 link_val = 0x01010000;
1773 link_mask = 0x02020000;
1774 link_val = 0x02020000;
1778 link_mask = 0x0f1f0000;
1779 link_val = 0x0f0f0000;
1783 u32temp = nes_read_indexed(nesdev,
1784 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1785 (0x200 * (nesdev->mac_index & 1)));
1786 if ((u32temp & link_mask) == link_val)
1787 nesvnic->linkup = 1;
1789 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1790 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1791 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1792 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1794 nes_init_phy(nesdev);
1802 * nes_netdev_destroy - destroy network device structure
1804 void nes_netdev_destroy(struct net_device *netdev)
1806 struct nes_vnic *nesvnic = netdev_priv(netdev);
1808 /* make sure 'stop' method is called by Linux stack */
1809 /* nes_netdev_stop(netdev); */
1811 list_del(&nesvnic->list);
1813 if (nesvnic->of_device_registered) {
1814 nes_destroy_ofa_device(nesvnic->nesibdev);
1817 free_netdev(netdev);
1822 * nes_nic_cm_xmit -- CM calls this to send out pkts
1824 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1829 ret = dev_queue_xmit(skb);
1831 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);