RDMA/nes: Use LRO
[linux-2.6.git] / drivers / infiniband / hw / nes / nes_nic.c
1 /*
2  * Copyright (c) 2006 - 2008 NetEffect, Inc. All rights reserved.
3  *
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:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
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.
22  *
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
30  * SOFTWARE.
31  *
32  */
33
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/ip.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 <net/tcp.h>
44
45 #include <net/inet_common.h>
46 #include <linux/inet.h>
47
48 #include "nes.h"
49
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}
55 };
56
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}
60 };
61
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}
64 };
65
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}
68 };
69
70 static struct nic_qp_map nic_qp_mapping_4[] = {
71         {28,8,0,0},{32,12,0,0}
72 };
73
74 static struct nic_qp_map nic_qp_mapping_5[] = {
75         {29,9,1,0},{33,13,1,0}
76 };
77
78 static struct nic_qp_map nic_qp_mapping_6[] = {
79         {30,10,2,0},{34,14,2,0}
80 };
81
82 static struct nic_qp_map nic_qp_mapping_7[] = {
83         {31,11,3,0},{35,15,3,0}
84 };
85
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
89 };
90
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
95 /**
96  * nes_netdev_poll
97  */
98 static int nes_netdev_poll(struct napi_struct *napi, int budget)
99 {
100         struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi);
101         struct net_device *netdev = nesvnic->netdev;
102         struct nes_device *nesdev = nesvnic->nesdev;
103         struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq;
104
105         nesvnic->budget = budget;
106         nescq->cqes_pending = 0;
107         nescq->rx_cqes_completed = 0;
108         nescq->cqe_allocs_pending = 0;
109         nescq->rx_pkts_indicated = 0;
110
111         nes_nic_ce_handler(nesdev, nescq);
112
113         if (nescq->cqes_pending == 0) {
114                 netif_rx_complete(netdev, napi);
115                 /* clear out completed cqes and arm */
116                 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
117                                 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
118                 nes_read32(nesdev->regs+NES_CQE_ALLOC);
119         } else {
120                 /* clear out completed cqes but don't arm */
121                 nes_write32(nesdev->regs+NES_CQE_ALLOC,
122                                 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
123                 nes_debug(NES_DBG_NETDEV, "%s: exiting with work pending\n",
124                                 nesvnic->netdev->name);
125         }
126         return nescq->rx_pkts_indicated;
127 }
128
129
130 /**
131  * nes_netdev_open - Activate the network interface; ifconfig
132  * ethx up.
133  */
134 static int nes_netdev_open(struct net_device *netdev)
135 {
136         u32 macaddr_low;
137         u16 macaddr_high;
138         struct nes_vnic *nesvnic = netdev_priv(netdev);
139         struct nes_device *nesdev = nesvnic->nesdev;
140         int ret;
141         int i;
142         struct nes_vnic *first_nesvnic = NULL;
143         u32 nic_active_bit;
144         u32 nic_active;
145         struct list_head *list_pos, *list_temp;
146
147         assert(nesdev != NULL);
148
149         if (nesvnic->netdev_open == 1)
150                 return 0;
151
152         if (netif_msg_ifup(nesvnic))
153                 printk(KERN_INFO PFX "%s: enabling interface\n", netdev->name);
154
155         ret = nes_init_nic_qp(nesdev, netdev);
156         if (ret) {
157                 return ret;
158         }
159
160         netif_carrier_off(netdev);
161         netif_stop_queue(netdev);
162
163         if ((!nesvnic->of_device_registered) && (nesvnic->rdma_enabled)) {
164                 nesvnic->nesibdev = nes_init_ofa_device(netdev);
165                 if (nesvnic->nesibdev == NULL) {
166                         printk(KERN_ERR PFX "%s: nesvnic->nesibdev alloc failed", netdev->name);
167                 } else {
168                         nesvnic->nesibdev->nesvnic = nesvnic;
169                         ret = nes_register_ofa_device(nesvnic->nesibdev);
170                         if (ret) {
171                                 printk(KERN_ERR PFX "%s: Unable to register RDMA device, ret = %d\n",
172                                                 netdev->name, ret);
173                         }
174                 }
175         }
176         /* Set packet filters */
177         nic_active_bit = 1 << nesvnic->nic_index;
178         nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
179         nic_active |= nic_active_bit;
180         nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
181         nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
182         nic_active |= nic_active_bit;
183         nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
184         nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
185         nic_active |= nic_active_bit;
186         nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
187
188         macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
189         macaddr_high += (u16)netdev->dev_addr[1];
190         macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
191         macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
192         macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
193         macaddr_low += (u32)netdev->dev_addr[5];
194
195         /* Program the various MAC regs */
196         for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
197                 if (nesvnic->qp_nic_index[i] == 0xf) {
198                         break;
199                 }
200                 nes_debug(NES_DBG_NETDEV, "i=%d, perfect filter table index= %d, PERF FILTER LOW"
201                                 " (Addr:%08X) = %08X, HIGH = %08X.\n",
202                                 i, nesvnic->qp_nic_index[i],
203                                 NES_IDX_PERFECT_FILTER_LOW+((nesvnic->perfect_filter_index + i) * 8),
204                                 macaddr_low,
205                                 (u32)macaddr_high | NES_MAC_ADDR_VALID |
206                                 ((((u32)nesvnic->nic_index) << 16)));
207                 nes_write_indexed(nesdev,
208                                 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
209                                 macaddr_low);
210                 nes_write_indexed(nesdev,
211                                 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
212                                 (u32)macaddr_high | NES_MAC_ADDR_VALID |
213                                 ((((u32)nesvnic->nic_index) << 16)));
214         }
215
216
217         nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
218                         nesvnic->nic_cq.cq_number);
219         nes_read32(nesdev->regs+NES_CQE_ALLOC);
220         list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
221                 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
222                 if (first_nesvnic->netdev_open == 1)
223                         break;
224         }
225         if (first_nesvnic->netdev_open == 0) {
226                 nes_debug(NES_DBG_INIT, "Setting up MAC interrupt mask.\n");
227                 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK + (0x200 * nesdev->mac_index),
228                                 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
229                                 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
230                 first_nesvnic = nesvnic;
231         }
232         if (first_nesvnic->linkup) {
233                 /* Enable network packets */
234                 nesvnic->linkup = 1;
235                 netif_start_queue(netdev);
236                 netif_carrier_on(netdev);
237         }
238         napi_enable(&nesvnic->napi);
239         nesvnic->netdev_open = 1;
240
241         return 0;
242 }
243
244
245 /**
246  * nes_netdev_stop
247  */
248 static int nes_netdev_stop(struct net_device *netdev)
249 {
250         struct nes_vnic *nesvnic = netdev_priv(netdev);
251         struct nes_device *nesdev = nesvnic->nesdev;
252         u32 nic_active_mask;
253         u32 nic_active;
254         struct nes_vnic *first_nesvnic = NULL;
255         struct list_head *list_pos, *list_temp;
256
257         nes_debug(NES_DBG_SHUTDOWN, "nesvnic=%p, nesdev=%p, netdev=%p %s\n",
258                         nesvnic, nesdev, netdev, netdev->name);
259         if (nesvnic->netdev_open == 0)
260                 return 0;
261
262         if (netif_msg_ifdown(nesvnic))
263                 printk(KERN_INFO PFX "%s: disabling interface\n", netdev->name);
264
265         /* Disable network packets */
266         napi_disable(&nesvnic->napi);
267         netif_stop_queue(netdev);
268         list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
269                 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
270                 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic))
271                         break;
272         }
273
274         if (first_nesvnic->netdev_open == 0)
275                 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+(0x200*nesdev->mac_index), 0xffffffff);
276         else if ((first_nesvnic != nesvnic) &&
277                  (PCI_FUNC(first_nesvnic->nesdev->pcidev->devfn) != PCI_FUNC(nesvnic->nesdev->pcidev->devfn))) {
278                 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK + (0x200 * nesdev->mac_index), 0xffffffff);
279                 nes_write_indexed(first_nesvnic->nesdev, NES_IDX_MAC_INT_MASK + (0x200 * first_nesvnic->nesdev->mac_index),
280                                 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
281                                 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
282         }
283
284         nic_active_mask = ~((u32)(1 << nesvnic->nic_index));
285         nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_HIGH+
286                         (nesvnic->perfect_filter_index*8), 0);
287         nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
288         nic_active &= nic_active_mask;
289         nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
290         nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
291         nic_active &= nic_active_mask;
292         nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
293         nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
294         nic_active &= nic_active_mask;
295         nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
296         nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
297         nic_active &= nic_active_mask;
298         nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
299         nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
300         nic_active &= nic_active_mask;
301         nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
302
303
304         if (nesvnic->of_device_registered) {
305                 nes_destroy_ofa_device(nesvnic->nesibdev);
306                 nesvnic->nesibdev = NULL;
307                 nesvnic->of_device_registered = 0;
308         }
309         nes_destroy_nic_qp(nesvnic);
310
311         nesvnic->netdev_open = 0;
312
313         return 0;
314 }
315
316
317 /**
318  * nes_nic_send
319  */
320 static int nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
321 {
322         struct nes_vnic *nesvnic = netdev_priv(netdev);
323         struct nes_device *nesdev = nesvnic->nesdev;
324         struct nes_hw_nic *nesnic = &nesvnic->nic;
325         struct nes_hw_nic_sq_wqe *nic_sqe;
326         struct tcphdr *tcph;
327         __le16 *wqe_fragment_length;
328         u32 wqe_misc;
329         u16 wqe_fragment_index = 1;     /* first fragment (0) is used by copy buffer */
330         u16 skb_fragment_index;
331         dma_addr_t bus_address;
332
333         nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
334         wqe_fragment_length = (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
335
336         /* setup the VLAN tag if present */
337         if (vlan_tx_tag_present(skb)) {
338                 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
339                                 netdev->name, vlan_tx_tag_get(skb));
340                 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
341                 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
342         } else
343                 wqe_misc = 0;
344
345         /* bump past the vlan tag */
346         wqe_fragment_length++;
347         /*      wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
348
349         if (skb->ip_summed == CHECKSUM_PARTIAL) {
350                 tcph = tcp_hdr(skb);
351                 if (1) {
352                         if (skb_is_gso(skb)) {
353                                 /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... seg size = %u\n",
354                                                 netdev->name, skb_is_gso(skb)); */
355                                 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE |
356                                                 NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
357                                 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
358                                                 ((u32)tcph->doff) |
359                                                 (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
360                         } else {
361                                 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
362                         }
363                 }
364         } else {        /* CHECKSUM_HW */
365                 wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM | NES_NIC_SQ_WQE_COMPLETION;
366         }
367
368         set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
369                                 skb->len);
370         memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
371                         skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE), skb_headlen(skb)));
372         wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
373                         skb_headlen(skb)));
374         wqe_fragment_length[1] = 0;
375         if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
376                 if ((skb_shinfo(skb)->nr_frags + 1) > 4) {
377                         nes_debug(NES_DBG_NIC_TX, "%s: Packet with %u fragments not sent, skb_headlen=%u\n",
378                                         netdev->name, skb_shinfo(skb)->nr_frags + 2, skb_headlen(skb));
379                         kfree_skb(skb);
380                         nesvnic->tx_sw_dropped++;
381                         return NETDEV_TX_LOCKED;
382                 }
383                 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
384                 bus_address = pci_map_single(nesdev->pcidev, skb->data + NES_FIRST_FRAG_SIZE,
385                                 skb_headlen(skb) - NES_FIRST_FRAG_SIZE, PCI_DMA_TODEVICE);
386                 wqe_fragment_length[wqe_fragment_index++] =
387                                 cpu_to_le16(skb_headlen(skb) - NES_FIRST_FRAG_SIZE);
388                 wqe_fragment_length[wqe_fragment_index] = 0;
389                 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
390                                 ((u64)(bus_address)));
391                 nesnic->tx_skb[nesnic->sq_head] = skb;
392         }
393
394         if (skb_headlen(skb) == skb->len) {
395                 if (skb_headlen(skb) <= NES_FIRST_FRAG_SIZE) {
396                         nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_2_1_IDX] = 0;
397                         nesnic->tx_skb[nesnic->sq_head] = NULL;
398                         dev_kfree_skb(skb);
399                 }
400         } else {
401                 /* Deal with Fragments */
402                 nesnic->tx_skb[nesnic->sq_head] = skb;
403                 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
404                                 skb_fragment_index++) {
405                         bus_address = pci_map_page( nesdev->pcidev,
406                                         skb_shinfo(skb)->frags[skb_fragment_index].page,
407                                         skb_shinfo(skb)->frags[skb_fragment_index].page_offset,
408                                         skb_shinfo(skb)->frags[skb_fragment_index].size,
409                                         PCI_DMA_TODEVICE);
410                         wqe_fragment_length[wqe_fragment_index] =
411                                         cpu_to_le16(skb_shinfo(skb)->frags[skb_fragment_index].size);
412                         set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
413                                 bus_address);
414                         wqe_fragment_index++;
415                         if (wqe_fragment_index < 5)
416                                 wqe_fragment_length[wqe_fragment_index] = 0;
417                 }
418         }
419
420         set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
421         nesnic->sq_head++;
422         nesnic->sq_head &= nesnic->sq_size - 1;
423
424         return NETDEV_TX_OK;
425 }
426
427
428 /**
429  * nes_netdev_start_xmit
430  */
431 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
432 {
433         struct nes_vnic *nesvnic = netdev_priv(netdev);
434         struct nes_device *nesdev = nesvnic->nesdev;
435         struct nes_hw_nic *nesnic = &nesvnic->nic;
436         struct nes_hw_nic_sq_wqe *nic_sqe;
437         struct tcphdr *tcph;
438         /* struct udphdr *udph; */
439 #define NES_MAX_TSO_FRAGS 18
440         /* 64K segment plus overflow on each side */
441         dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
442         dma_addr_t bus_address;
443         u32 tso_frag_index;
444         u32 tso_frag_count;
445         u32 tso_wqe_length;
446         u32 curr_tcp_seq;
447         u32 wqe_count=1;
448         u32 send_rc;
449         struct iphdr *iph;
450         unsigned long flags;
451         __le16 *wqe_fragment_length;
452         u32 nr_frags;
453         u32 original_first_length;
454 //      u64 *wqe_fragment_address;
455         /* first fragment (0) is used by copy buffer */
456         u16 wqe_fragment_index=1;
457         u16 hoffset;
458         u16 nhoffset;
459         u16 wqes_needed;
460         u16 wqes_available;
461         u32 old_head;
462         u32 wqe_misc;
463
464         /* nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
465                         " (%u frags), tso_size=%u\n",
466                         netdev->name, skb->len, skb_headlen(skb),
467                         skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
468         */
469
470         if (!netif_carrier_ok(netdev))
471                 return NETDEV_TX_OK;
472
473         if (netif_queue_stopped(netdev))
474                 return NETDEV_TX_BUSY;
475
476         local_irq_save(flags);
477         if (!spin_trylock(&nesnic->sq_lock)) {
478                 local_irq_restore(flags);
479                 nesvnic->sq_locked++;
480                 return NETDEV_TX_LOCKED;
481         }
482
483         /* Check if SQ is full */
484         if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
485                 if (!netif_queue_stopped(netdev)) {
486                         netif_stop_queue(netdev);
487                         barrier();
488                         if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
489                                 netif_start_queue(netdev);
490                                 goto sq_no_longer_full;
491                         }
492                 }
493                 nesvnic->sq_full++;
494                 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
495                 return NETDEV_TX_BUSY;
496         }
497
498 sq_no_longer_full:
499         nr_frags = skb_shinfo(skb)->nr_frags;
500         if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
501                 nr_frags++;
502         }
503         /* Check if too many fragments */
504         if (unlikely((nr_frags > 4))) {
505                 if (skb_is_gso(skb)) {
506                         nesvnic->segmented_tso_requests++;
507                         nesvnic->tso_requests++;
508                         old_head = nesnic->sq_head;
509                         /* Basically 4 fragments available per WQE with extended fragments */
510                         wqes_needed = nr_frags >> 2;
511                         wqes_needed += (nr_frags&3)?1:0;
512                         wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
513                                         (nesnic->sq_size - 1);
514
515                         if (unlikely(wqes_needed > wqes_available)) {
516                                 if (!netif_queue_stopped(netdev)) {
517                                         netif_stop_queue(netdev);
518                                         barrier();
519                                         wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
520                                                 (nesnic->sq_size - 1);
521                                         if (wqes_needed <= wqes_available) {
522                                                 netif_start_queue(netdev);
523                                                 goto tso_sq_no_longer_full;
524                                         }
525                                 }
526                                 nesvnic->sq_full++;
527                                 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
528                                 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
529                                                 netdev->name);
530                                 return NETDEV_TX_BUSY;
531                         }
532 tso_sq_no_longer_full:
533                         /* Map all the buffers */
534                         for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
535                                         tso_frag_count++) {
536                                 tso_bus_address[tso_frag_count] = pci_map_page( nesdev->pcidev,
537                                                 skb_shinfo(skb)->frags[tso_frag_count].page,
538                                                 skb_shinfo(skb)->frags[tso_frag_count].page_offset,
539                                                 skb_shinfo(skb)->frags[tso_frag_count].size,
540                                                 PCI_DMA_TODEVICE);
541                         }
542
543                         tso_frag_index = 0;
544                         curr_tcp_seq = ntohl(tcp_hdr(skb)->seq);
545                         hoffset = skb_transport_header(skb) - skb->data;
546                         nhoffset = skb_network_header(skb) - skb->data;
547                         original_first_length = hoffset + ((((struct tcphdr *)skb_transport_header(skb))->doff)<<2);
548
549                         for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
550                                 tso_wqe_length = 0;
551                                 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
552                                 wqe_fragment_length =
553                                                 (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
554                                 /* setup the VLAN tag if present */
555                                 if (vlan_tx_tag_present(skb)) {
556                                         nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
557                                                         netdev->name, vlan_tx_tag_get(skb) );
558                                         wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
559                                         wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
560                                 } else
561                                         wqe_misc = 0;
562
563                                 /* bump past the vlan tag */
564                                 wqe_fragment_length++;
565
566                                 /* Assumes header totally fits in allocated buffer and is in first fragment */
567                                 if (original_first_length > NES_FIRST_FRAG_SIZE) {
568                                         nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
569                                                         original_first_length, NES_FIRST_FRAG_SIZE);
570                                         nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
571                                                         " (%u frags), tso_size=%u\n",
572                                                         netdev->name,
573                                                         skb->len, skb_headlen(skb),
574                                                         skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
575                                 }
576                                 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
577                                                 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
578                                                 original_first_length));
579                                 iph = (struct iphdr *)
580                                 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[nhoffset]);
581                                 tcph = (struct tcphdr *)
582                                 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[hoffset]);
583                                 if ((wqe_count+1)!=(u32)wqes_needed) {
584                                         tcph->fin = 0;
585                                         tcph->psh = 0;
586                                         tcph->rst = 0;
587                                         tcph->urg = 0;
588                                 }
589                                 if (wqe_count) {
590                                         tcph->syn = 0;
591                                 }
592                                 tcph->seq = htonl(curr_tcp_seq);
593                                 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
594                                                 original_first_length));
595
596                                 wqe_fragment_index = 1;
597                                 if ((wqe_count==0) && (skb_headlen(skb) > original_first_length)) {
598                                         set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
599                                         bus_address = pci_map_single(nesdev->pcidev, skb->data + original_first_length,
600                                                         skb_headlen(skb) - original_first_length, PCI_DMA_TODEVICE);
601                                         wqe_fragment_length[wqe_fragment_index++] =
602                                                 cpu_to_le16(skb_headlen(skb) - original_first_length);
603                                         wqe_fragment_length[wqe_fragment_index] = 0;
604                                         set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
605                                                                         bus_address);
606                                 }
607                                 while (wqe_fragment_index < 5) {
608                                         wqe_fragment_length[wqe_fragment_index] =
609                                                         cpu_to_le16(skb_shinfo(skb)->frags[tso_frag_index].size);
610                                         set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
611                                                 (u64)tso_bus_address[tso_frag_index]);
612                                         wqe_fragment_index++;
613                                         tso_wqe_length += skb_shinfo(skb)->frags[tso_frag_index++].size;
614                                         if (wqe_fragment_index < 5)
615                                                 wqe_fragment_length[wqe_fragment_index] = 0;
616                                         if (tso_frag_index == tso_frag_count)
617                                                 break;
618                                 }
619                                 if ((wqe_count+1) == (u32)wqes_needed) {
620                                         nesnic->tx_skb[nesnic->sq_head] = skb;
621                                 } else {
622                                         nesnic->tx_skb[nesnic->sq_head] = NULL;
623                                 }
624                                 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
625                                 if ((tso_wqe_length + original_first_length) > skb_is_gso(skb)) {
626                                         wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
627                                 } else {
628                                         iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
629                                 }
630
631                                 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
632                                                  wqe_misc);
633                                 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
634                                                 ((u32)tcph->doff) | (((u32)hoffset) << 4));
635
636                                 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
637                                                 tso_wqe_length + original_first_length);
638                                 curr_tcp_seq += tso_wqe_length;
639                                 nesnic->sq_head++;
640                                 nesnic->sq_head &= nesnic->sq_size-1;
641                         }
642                 } else {
643                         nesvnic->linearized_skbs++;
644                         hoffset = skb_transport_header(skb) - skb->data;
645                         nhoffset = skb_network_header(skb) - skb->data;
646                         skb_linearize(skb);
647                         skb_set_transport_header(skb, hoffset);
648                         skb_set_network_header(skb, nhoffset);
649                         send_rc = nes_nic_send(skb, netdev);
650                         if (send_rc != NETDEV_TX_OK) {
651                                 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
652                                 return NETDEV_TX_OK;
653                         }
654                 }
655         } else {
656                 send_rc = nes_nic_send(skb, netdev);
657                 if (send_rc != NETDEV_TX_OK) {
658                         spin_unlock_irqrestore(&nesnic->sq_lock, flags);
659                         return NETDEV_TX_OK;
660                 }
661         }
662
663         barrier();
664
665         if (wqe_count)
666                 nes_write32(nesdev->regs+NES_WQE_ALLOC,
667                                 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
668
669         netdev->trans_start = jiffies;
670         spin_unlock_irqrestore(&nesnic->sq_lock, flags);
671
672         return NETDEV_TX_OK;
673 }
674
675
676 /**
677  * nes_netdev_get_stats
678  */
679 static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
680 {
681         struct nes_vnic *nesvnic = netdev_priv(netdev);
682         struct nes_device *nesdev = nesvnic->nesdev;
683         u64 u64temp;
684         u32 u32temp;
685
686         u32temp = nes_read_indexed(nesdev,
687                         NES_IDX_ENDNODE0_NSTAT_RX_DISCARD + (nesvnic->nic_index*0x200));
688         nesvnic->netstats.rx_dropped += u32temp;
689         nesvnic->endnode_nstat_rx_discard += u32temp;
690
691         u64temp = (u64)nes_read_indexed(nesdev,
692                         NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO + (nesvnic->nic_index*0x200));
693         u64temp += ((u64)nes_read_indexed(nesdev,
694                         NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
695
696         nesvnic->endnode_nstat_rx_octets += u64temp;
697         nesvnic->netstats.rx_bytes += u64temp;
698
699         u64temp = (u64)nes_read_indexed(nesdev,
700                         NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO + (nesvnic->nic_index*0x200));
701         u64temp += ((u64)nes_read_indexed(nesdev,
702                         NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
703
704         nesvnic->endnode_nstat_rx_frames += u64temp;
705         nesvnic->netstats.rx_packets += u64temp;
706
707         u64temp = (u64)nes_read_indexed(nesdev,
708                         NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO + (nesvnic->nic_index*0x200));
709         u64temp += ((u64)nes_read_indexed(nesdev,
710                         NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
711
712         nesvnic->endnode_nstat_tx_octets += u64temp;
713         nesvnic->netstats.tx_bytes += u64temp;
714
715         u64temp = (u64)nes_read_indexed(nesdev,
716                         NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO + (nesvnic->nic_index*0x200));
717         u64temp += ((u64)nes_read_indexed(nesdev,
718                         NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
719
720         nesvnic->endnode_nstat_tx_frames += u64temp;
721         nesvnic->netstats.tx_packets += u64temp;
722
723         u32temp = nes_read_indexed(nesdev,
724                         NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
725         nesvnic->netstats.rx_dropped += u32temp;
726         nesvnic->nesdev->mac_rx_errors += u32temp;
727         nesvnic->nesdev->mac_rx_short_frames += u32temp;
728
729         u32temp = nes_read_indexed(nesdev,
730                         NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
731         nesvnic->netstats.rx_dropped += u32temp;
732         nesvnic->nesdev->mac_rx_errors += u32temp;
733         nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
734
735         u32temp = nes_read_indexed(nesdev,
736                         NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
737         nesvnic->netstats.rx_dropped += u32temp;
738         nesvnic->nesdev->mac_rx_errors += u32temp;
739         nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
740
741         u32temp = nes_read_indexed(nesdev,
742                         NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
743         nesvnic->netstats.rx_dropped += u32temp;
744         nesvnic->nesdev->mac_rx_errors += u32temp;
745         nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
746
747         u32temp = nes_read_indexed(nesdev,
748                         NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
749         nesvnic->netstats.rx_length_errors += u32temp;
750         nesvnic->nesdev->mac_rx_errors += u32temp;
751
752         u32temp = nes_read_indexed(nesdev,
753                         NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
754         nesvnic->nesdev->mac_rx_errors += u32temp;
755         nesvnic->nesdev->mac_rx_crc_errors += u32temp;
756         nesvnic->netstats.rx_crc_errors += u32temp;
757
758         u32temp = nes_read_indexed(nesdev,
759                         NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
760         nesvnic->nesdev->mac_tx_errors += u32temp;
761         nesvnic->netstats.tx_errors += u32temp;
762
763         return &nesvnic->netstats;
764 }
765
766
767 /**
768  * nes_netdev_tx_timeout
769  */
770 static void nes_netdev_tx_timeout(struct net_device *netdev)
771 {
772         struct nes_vnic *nesvnic = netdev_priv(netdev);
773
774         if (netif_msg_timer(nesvnic))
775                 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
776 }
777
778
779 /**
780  * nes_netdev_set_mac_address
781  */
782 static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
783 {
784         struct nes_vnic *nesvnic = netdev_priv(netdev);
785         struct nes_device *nesdev = nesvnic->nesdev;
786         struct sockaddr *mac_addr = p;
787         int i;
788         u32 macaddr_low;
789         u16 macaddr_high;
790         DECLARE_MAC_BUF(mac);
791
792         if (!is_valid_ether_addr(mac_addr->sa_data))
793                 return -EADDRNOTAVAIL;
794
795         memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
796         printk(PFX "%s: Address length = %d, Address = %s\n",
797                __func__, netdev->addr_len, print_mac(mac, mac_addr->sa_data));
798         macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
799         macaddr_high += (u16)netdev->dev_addr[1];
800         macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
801         macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
802         macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
803         macaddr_low += (u32)netdev->dev_addr[5];
804
805         for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
806                 if (nesvnic->qp_nic_index[i] == 0xf) {
807                         break;
808                 }
809                 nes_write_indexed(nesdev,
810                                 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
811                                 macaddr_low);
812                 nes_write_indexed(nesdev,
813                                 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
814                                 (u32)macaddr_high | NES_MAC_ADDR_VALID |
815                                 ((((u32)nesvnic->nic_index) << 16)));
816         }
817         return 0;
818 }
819
820
821 /**
822  * nes_netdev_set_multicast_list
823  */
824 static void nes_netdev_set_multicast_list(struct net_device *netdev)
825 {
826         struct nes_vnic *nesvnic = netdev_priv(netdev);
827         struct nes_device *nesdev = nesvnic->nesdev;
828         struct dev_mc_list *multicast_addr;
829         u32 nic_active_bit;
830         u32 nic_active;
831         u32 perfect_filter_register_address;
832         u32 macaddr_low;
833         u16 macaddr_high;
834         u8 mc_all_on = 0;
835         u8 mc_index;
836         int mc_nic_index = -1;
837
838         nic_active_bit = 1 << nesvnic->nic_index;
839
840         if (netdev->flags & IFF_PROMISC) {
841                 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
842                 nic_active |= nic_active_bit;
843                 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
844                 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
845                 nic_active |= nic_active_bit;
846                 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
847                 mc_all_on = 1;
848         } else if ((netdev->flags & IFF_ALLMULTI) || (netdev->mc_count > NES_MULTICAST_PF_MAX) ||
849                            (nesvnic->nic_index > 3)) {
850                 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
851                 nic_active |= nic_active_bit;
852                 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
853                 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
854                 nic_active &= ~nic_active_bit;
855                 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
856                 mc_all_on = 1;
857         } else {
858                 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
859                 nic_active &= ~nic_active_bit;
860                 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
861                 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
862                 nic_active &= ~nic_active_bit;
863                 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
864         }
865
866         nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscous = %d, All Multicast = %d.\n",
867                           netdev->mc_count, (netdev->flags & IFF_PROMISC)?1:0,
868                           (netdev->flags & IFF_ALLMULTI)?1:0);
869         if (!mc_all_on) {
870                 multicast_addr = netdev->mc_list;
871                 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW + 0x80;
872                 perfect_filter_register_address += nesvnic->nic_index*0x40;
873                 for (mc_index=0; mc_index < NES_MULTICAST_PF_MAX; mc_index++) {
874                         while (multicast_addr && nesvnic->mcrq_mcast_filter && ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic, multicast_addr->dmi_addr)) == 0))
875                                 multicast_addr = multicast_addr->next;
876                         if (mc_nic_index < 0)
877                                 mc_nic_index = nesvnic->nic_index;
878                         if (multicast_addr) {
879                                 DECLARE_MAC_BUF(mac);
880                                 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %s to register 0x%04X nic_idx=%d\n",
881                                           print_mac(mac, multicast_addr->dmi_addr),
882                                           perfect_filter_register_address+(mc_index * 8),
883                                           mc_nic_index);
884                                 macaddr_high = ((u16)multicast_addr->dmi_addr[0]) << 8;
885                                 macaddr_high += (u16)multicast_addr->dmi_addr[1];
886                                 macaddr_low = ((u32)multicast_addr->dmi_addr[2]) << 24;
887                                 macaddr_low += ((u32)multicast_addr->dmi_addr[3]) << 16;
888                                 macaddr_low += ((u32)multicast_addr->dmi_addr[4]) << 8;
889                                 macaddr_low += (u32)multicast_addr->dmi_addr[5];
890                                 nes_write_indexed(nesdev,
891                                                 perfect_filter_register_address+(mc_index * 8),
892                                                 macaddr_low);
893                                 nes_write_indexed(nesdev,
894                                                 perfect_filter_register_address+4+(mc_index * 8),
895                                                 (u32)macaddr_high | NES_MAC_ADDR_VALID |
896                                                 ((((u32)(1<<mc_nic_index)) << 16)));
897                                 multicast_addr = multicast_addr->next;
898                         } else {
899                                 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
900                                                   perfect_filter_register_address+(mc_index * 8));
901                                 nes_write_indexed(nesdev,
902                                                 perfect_filter_register_address+4+(mc_index * 8),
903                                                 0);
904                         }
905                 }
906         }
907 }
908
909
910 /**
911  * nes_netdev_change_mtu
912  */
913 static int nes_netdev_change_mtu(struct net_device *netdev,     int     new_mtu)
914 {
915         struct nes_vnic *nesvnic = netdev_priv(netdev);
916         struct nes_device *nesdev =     nesvnic->nesdev;
917         int     ret     = 0;
918         u8 jumbomode=0;
919
920         if ((new_mtu < ETH_ZLEN) ||     (new_mtu > max_mtu))
921                 return -EINVAL;
922
923         netdev->mtu     = new_mtu;
924         nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
925
926         if (netdev->mtu > 1500) {
927                 jumbomode=1;
928         }
929         nes_nic_init_timer_defaults(nesdev,     jumbomode);
930
931         if (netif_running(netdev)) {
932                 nes_netdev_stop(netdev);
933                 nes_netdev_open(netdev);
934         }
935
936         return ret;
937 }
938
939 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
940         "Link Change Interrupts",
941         "Linearized SKBs",
942         "T/GSO Requests",
943         "Pause Frames Sent",
944         "Pause Frames Received",
945         "Internal Routing Errors",
946         "SQ SW Dropped SKBs",
947         "SQ Locked",
948         "SQ Full",
949         "Segmented TSO Requests",
950         "Rx Symbol Errors",
951         "Rx Jabber Errors",
952         "Rx Oversized Frames",
953         "Rx Short Frames",
954         "Endnode Rx Discards",
955         "Endnode Rx Octets",
956         "Endnode Rx Frames",
957         "Endnode Tx Octets",
958         "Endnode Tx Frames",
959         "mh detected",
960         "mh pauses",
961         "Retransmission Count",
962         "CM Connects",
963         "CM Accepts",
964         "Disconnects",
965         "Connected Events",
966         "Connect Requests",
967         "CM Rejects",
968         "ModifyQP Timeouts",
969         "CreateQPs",
970         "SW DestroyQPs",
971         "DestroyQPs",
972         "CM Closes",
973         "CM Packets Sent",
974         "CM Packets Bounced",
975         "CM Packets Created",
976         "CM Packets Rcvd",
977         "CM Packets Dropped",
978         "CM Packets Retrans",
979         "CM Listens Created",
980         "CM Listens Destroyed",
981         "CM Backlog Drops",
982         "CM Loopbacks",
983         "CM Nodes Created",
984         "CM Nodes Destroyed",
985         "CM Accel Drops",
986         "CM Resets Received",
987         "Timer Inits",
988         "CQ Depth 1",
989         "CQ Depth 4",
990         "CQ Depth 16",
991         "CQ Depth 24",
992         "CQ Depth 32",
993         "CQ Depth 128",
994         "CQ Depth 256",
995         "LRO aggregated",
996         "LRO flushed",
997         "LRO no_desc",
998 };
999
1000 #define NES_ETHTOOL_STAT_COUNT  ARRAY_SIZE(nes_ethtool_stringset)
1001
1002 /**
1003  * nes_netdev_get_rx_csum
1004  */
1005 static u32 nes_netdev_get_rx_csum (struct net_device *netdev)
1006 {
1007         struct nes_vnic *nesvnic = netdev_priv(netdev);
1008
1009         if (nesvnic->rx_checksum_disabled)
1010                 return 0;
1011         else
1012                 return 1;
1013 }
1014
1015
1016 /**
1017  * nes_netdev_set_rc_csum
1018  */
1019 static int nes_netdev_set_rx_csum(struct net_device *netdev, u32 enable)
1020 {
1021         struct nes_vnic *nesvnic = netdev_priv(netdev);
1022
1023         if (enable)
1024                 nesvnic->rx_checksum_disabled = 0;
1025         else
1026                 nesvnic->rx_checksum_disabled = 1;
1027         return 0;
1028 }
1029
1030
1031 /**
1032  * nes_netdev_get_stats_count
1033  */
1034 static int nes_netdev_get_stats_count(struct net_device *netdev)
1035 {
1036         return NES_ETHTOOL_STAT_COUNT;
1037 }
1038
1039
1040 /**
1041  * nes_netdev_get_strings
1042  */
1043 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1044                 u8 *ethtool_strings)
1045 {
1046         if (stringset == ETH_SS_STATS)
1047                 memcpy(ethtool_strings,
1048                                 &nes_ethtool_stringset,
1049                                 sizeof(nes_ethtool_stringset));
1050 }
1051
1052
1053 /**
1054  * nes_netdev_get_ethtool_stats
1055  */
1056 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1057                 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1058 {
1059         u64 u64temp;
1060         struct nes_vnic *nesvnic = netdev_priv(netdev);
1061         struct nes_device *nesdev = nesvnic->nesdev;
1062         u32 nic_count;
1063         u32 u32temp;
1064
1065         target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1066         target_stat_values[0] = nesvnic->nesdev->link_status_interrupts;
1067         target_stat_values[1] = nesvnic->linearized_skbs;
1068         target_stat_values[2] = nesvnic->tso_requests;
1069
1070         u32temp = nes_read_indexed(nesdev,
1071                         NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1072         nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1073         target_stat_values[3] = nesvnic->nesdev->mac_pause_frames_sent;
1074
1075         u32temp = nes_read_indexed(nesdev,
1076                         NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1077         nesvnic->nesdev->mac_pause_frames_received += u32temp;
1078
1079         u32temp = nes_read_indexed(nesdev,
1080                         NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1081         nesvnic->nesdev->port_rx_discards += u32temp;
1082         nesvnic->netstats.rx_dropped += u32temp;
1083
1084         u32temp = nes_read_indexed(nesdev,
1085                         NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1086         nesvnic->nesdev->port_tx_discards += u32temp;
1087         nesvnic->netstats.tx_dropped += u32temp;
1088
1089         for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1090                 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1091                         break;
1092
1093                 u32temp = nes_read_indexed(nesdev,
1094                                 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1095                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1096                 nesvnic->netstats.rx_dropped += u32temp;
1097                 nesvnic->endnode_nstat_rx_discard += u32temp;
1098
1099                 u64temp = (u64)nes_read_indexed(nesdev,
1100                                 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1101                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1102                 u64temp += ((u64)nes_read_indexed(nesdev,
1103                                 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1104                                 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1105
1106                 nesvnic->endnode_nstat_rx_octets += u64temp;
1107                 nesvnic->netstats.rx_bytes += u64temp;
1108
1109                 u64temp = (u64)nes_read_indexed(nesdev,
1110                                 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1111                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1112                 u64temp += ((u64)nes_read_indexed(nesdev,
1113                                 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1114                                 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1115
1116                 nesvnic->endnode_nstat_rx_frames += u64temp;
1117                 nesvnic->netstats.rx_packets += u64temp;
1118
1119                 u64temp = (u64)nes_read_indexed(nesdev,
1120                                 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1121                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1122                 u64temp += ((u64)nes_read_indexed(nesdev,
1123                                 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1124                                 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1125
1126                 nesvnic->endnode_nstat_tx_octets += u64temp;
1127                 nesvnic->netstats.tx_bytes += u64temp;
1128
1129                 u64temp = (u64)nes_read_indexed(nesdev,
1130                                 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1131                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1132                 u64temp += ((u64)nes_read_indexed(nesdev,
1133                                 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1134                                 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1135
1136                 nesvnic->endnode_nstat_tx_frames += u64temp;
1137                 nesvnic->netstats.tx_packets += u64temp;
1138
1139                 u32temp = nes_read_indexed(nesdev,
1140                                 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1141                 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1142         }
1143
1144         target_stat_values[4] = nesvnic->nesdev->mac_pause_frames_received;
1145         target_stat_values[5] = nesdev->nesadapter->nic_rx_eth_route_err;
1146         target_stat_values[6] = nesvnic->tx_sw_dropped;
1147         target_stat_values[7] = nesvnic->sq_locked;
1148         target_stat_values[8] = nesvnic->sq_full;
1149         target_stat_values[9] = nesvnic->segmented_tso_requests;
1150         target_stat_values[10] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1151         target_stat_values[11] = nesvnic->nesdev->mac_rx_jabber_frames;
1152         target_stat_values[12] = nesvnic->nesdev->mac_rx_oversized_frames;
1153         target_stat_values[13] = nesvnic->nesdev->mac_rx_short_frames;
1154         target_stat_values[14] = nesvnic->endnode_nstat_rx_discard;
1155         target_stat_values[15] = nesvnic->endnode_nstat_rx_octets;
1156         target_stat_values[16] = nesvnic->endnode_nstat_rx_frames;
1157         target_stat_values[17] = nesvnic->endnode_nstat_tx_octets;
1158         target_stat_values[18] = nesvnic->endnode_nstat_tx_frames;
1159         target_stat_values[19] = mh_detected;
1160         target_stat_values[20] = mh_pauses_sent;
1161         target_stat_values[21] = nesvnic->endnode_ipv4_tcp_retransmits;
1162         target_stat_values[22] = atomic_read(&cm_connects);
1163         target_stat_values[23] = atomic_read(&cm_accepts);
1164         target_stat_values[24] = atomic_read(&cm_disconnects);
1165         target_stat_values[25] = atomic_read(&cm_connecteds);
1166         target_stat_values[26] = atomic_read(&cm_connect_reqs);
1167         target_stat_values[27] = atomic_read(&cm_rejects);
1168         target_stat_values[28] = atomic_read(&mod_qp_timouts);
1169         target_stat_values[29] = atomic_read(&qps_created);
1170         target_stat_values[30] = atomic_read(&sw_qps_destroyed);
1171         target_stat_values[31] = atomic_read(&qps_destroyed);
1172         target_stat_values[32] = atomic_read(&cm_closes);
1173         target_stat_values[33] = cm_packets_sent;
1174         target_stat_values[34] = cm_packets_bounced;
1175         target_stat_values[35] = cm_packets_created;
1176         target_stat_values[36] = cm_packets_received;
1177         target_stat_values[37] = cm_packets_dropped;
1178         target_stat_values[38] = cm_packets_retrans;
1179         target_stat_values[39] = cm_listens_created;
1180         target_stat_values[40] = cm_listens_destroyed;
1181         target_stat_values[41] = cm_backlog_drops;
1182         target_stat_values[42] = atomic_read(&cm_loopbacks);
1183         target_stat_values[43] = atomic_read(&cm_nodes_created);
1184         target_stat_values[44] = atomic_read(&cm_nodes_destroyed);
1185         target_stat_values[45] = atomic_read(&cm_accel_dropped_pkts);
1186         target_stat_values[46] = atomic_read(&cm_resets_recvd);
1187         target_stat_values[47] = int_mod_timer_init;
1188         target_stat_values[48] = int_mod_cq_depth_1;
1189         target_stat_values[49] = int_mod_cq_depth_4;
1190         target_stat_values[50] = int_mod_cq_depth_16;
1191         target_stat_values[51] = int_mod_cq_depth_24;
1192         target_stat_values[52] = int_mod_cq_depth_32;
1193         target_stat_values[53] = int_mod_cq_depth_128;
1194         target_stat_values[54] = int_mod_cq_depth_256;
1195         target_stat_values[55] = nesvnic->lro_mgr.stats.aggregated;
1196         target_stat_values[56] = nesvnic->lro_mgr.stats.flushed;
1197         target_stat_values[57] = nesvnic->lro_mgr.stats.no_desc;
1198
1199 }
1200
1201
1202 /**
1203  * nes_netdev_get_drvinfo
1204  */
1205 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1206                 struct ethtool_drvinfo *drvinfo)
1207 {
1208         struct nes_vnic *nesvnic = netdev_priv(netdev);
1209
1210         strcpy(drvinfo->driver, DRV_NAME);
1211         strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
1212         strcpy(drvinfo->fw_version, "TBD");
1213         strcpy(drvinfo->version, DRV_VERSION);
1214         drvinfo->n_stats = nes_netdev_get_stats_count(netdev);
1215         drvinfo->testinfo_len = 0;
1216         drvinfo->eedump_len = 0;
1217         drvinfo->regdump_len = 0;
1218 }
1219
1220
1221 /**
1222  * nes_netdev_set_coalesce
1223  */
1224 static int nes_netdev_set_coalesce(struct net_device *netdev,
1225                 struct ethtool_coalesce *et_coalesce)
1226 {
1227         struct nes_vnic *nesvnic = netdev_priv(netdev);
1228         struct nes_device *nesdev =     nesvnic->nesdev;
1229         struct nes_adapter *nesadapter = nesdev->nesadapter;
1230         struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1231         unsigned long flags;
1232
1233         spin_lock_irqsave(&nesadapter->periodic_timer_lock,     flags);
1234         if (et_coalesce->rx_max_coalesced_frames_low) {
1235                 shared_timer->threshold_low      = et_coalesce->rx_max_coalesced_frames_low;
1236         }
1237         if (et_coalesce->rx_max_coalesced_frames_irq) {
1238                 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1239         }
1240         if (et_coalesce->rx_max_coalesced_frames_high) {
1241                 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1242         }
1243         if (et_coalesce->rx_coalesce_usecs_low) {
1244                 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1245         }
1246         if (et_coalesce->rx_coalesce_usecs_high) {
1247                 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1248         }
1249         spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1250
1251         /* using this to drive total interrupt moderation */
1252         nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1253         if (et_coalesce->use_adaptive_rx_coalesce) {
1254                 nesadapter->et_use_adaptive_rx_coalesce = 1;
1255                 nesadapter->timer_int_limit     = NES_TIMER_INT_LIMIT_DYNAMIC;
1256                 nesadapter->et_rx_coalesce_usecs_irq = 0;
1257                 if (et_coalesce->pkt_rate_low) {
1258                         nesadapter->et_pkt_rate_low     = et_coalesce->pkt_rate_low;
1259                 }
1260         } else {
1261                 nesadapter->et_use_adaptive_rx_coalesce = 0;
1262                 nesadapter->timer_int_limit     = NES_TIMER_INT_LIMIT;
1263                 if (nesadapter->et_rx_coalesce_usecs_irq) {
1264                         nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1265                                         0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1266                 }
1267         }
1268         return 0;
1269 }
1270
1271
1272 /**
1273  * nes_netdev_get_coalesce
1274  */
1275 static int nes_netdev_get_coalesce(struct net_device *netdev,
1276                 struct ethtool_coalesce *et_coalesce)
1277 {
1278         struct nes_vnic *nesvnic = netdev_priv(netdev);
1279         struct nes_device *nesdev =     nesvnic->nesdev;
1280         struct nes_adapter *nesadapter = nesdev->nesadapter;
1281         struct ethtool_coalesce temp_et_coalesce;
1282         struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1283         unsigned long flags;
1284
1285         memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1286         temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1287         temp_et_coalesce.use_adaptive_rx_coalesce =     nesadapter->et_use_adaptive_rx_coalesce;
1288         temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1289         temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1290         spin_lock_irqsave(&nesadapter->periodic_timer_lock,     flags);
1291         temp_et_coalesce.rx_max_coalesced_frames_low =  shared_timer->threshold_low;
1292         temp_et_coalesce.rx_max_coalesced_frames_irq =  shared_timer->threshold_target;
1293         temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1294         temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1295         temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1296         if (nesadapter->et_use_adaptive_rx_coalesce) {
1297                 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1298         }
1299         spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1300         memcpy(et_coalesce,     &temp_et_coalesce, sizeof(*et_coalesce));
1301         return 0;
1302 }
1303
1304
1305 /**
1306  * nes_netdev_get_pauseparam
1307  */
1308 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1309                 struct ethtool_pauseparam *et_pauseparam)
1310 {
1311         struct nes_vnic *nesvnic = netdev_priv(netdev);
1312
1313         et_pauseparam->autoneg = 0;
1314         et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1315         et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1316 }
1317
1318
1319 /**
1320  * nes_netdev_set_pauseparam
1321  */
1322 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1323                 struct ethtool_pauseparam *et_pauseparam)
1324 {
1325         struct nes_vnic *nesvnic = netdev_priv(netdev);
1326         struct nes_device *nesdev = nesvnic->nesdev;
1327         u32 u32temp;
1328
1329         if (et_pauseparam->autoneg) {
1330                 /* TODO: should return unsupported */
1331                 return 0;
1332         }
1333         if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1334                 u32temp = nes_read_indexed(nesdev,
1335                                 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1336                 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1337                 nes_write_indexed(nesdev,
1338                                 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1339                 nesdev->disable_tx_flow_control = 0;
1340         } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1341                 u32temp = nes_read_indexed(nesdev,
1342                                 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1343                 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1344                 nes_write_indexed(nesdev,
1345                                 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1346                 nesdev->disable_tx_flow_control = 1;
1347         }
1348         if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1349                 u32temp = nes_read_indexed(nesdev,
1350                                 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1351                 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1352                 nes_write_indexed(nesdev,
1353                                 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1354                 nesdev->disable_rx_flow_control = 0;
1355         } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1356                 u32temp = nes_read_indexed(nesdev,
1357                                 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1358                 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1359                 nes_write_indexed(nesdev,
1360                                 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1361                 nesdev->disable_rx_flow_control = 1;
1362         }
1363
1364         return 0;
1365 }
1366
1367
1368 /**
1369  * nes_netdev_get_settings
1370  */
1371 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1372 {
1373         struct nes_vnic *nesvnic = netdev_priv(netdev);
1374         struct nes_device *nesdev = nesvnic->nesdev;
1375         struct nes_adapter *nesadapter = nesdev->nesadapter;
1376         u16 phy_data;
1377
1378         et_cmd->duplex = DUPLEX_FULL;
1379         et_cmd->port = PORT_MII;
1380         if (nesadapter->OneG_Mode) {
1381                 et_cmd->supported = SUPPORTED_1000baseT_Full|SUPPORTED_Autoneg;
1382                 et_cmd->advertising = ADVERTISED_1000baseT_Full|ADVERTISED_Autoneg;
1383                 et_cmd->speed = SPEED_1000;
1384                 nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1385                                 &phy_data);
1386                 if (phy_data&0x1000) {
1387                         et_cmd->autoneg = AUTONEG_ENABLE;
1388                 } else {
1389                         et_cmd->autoneg = AUTONEG_DISABLE;
1390                 }
1391                 et_cmd->transceiver = XCVR_EXTERNAL;
1392                 et_cmd->phy_address = nesadapter->phy_index[nesdev->mac_index];
1393         } else {
1394                 if (nesadapter->phy_type[nesvnic->logical_port] == NES_PHY_TYPE_IRIS) {
1395                         et_cmd->transceiver = XCVR_EXTERNAL;
1396                         et_cmd->port = PORT_FIBRE;
1397                         et_cmd->supported = SUPPORTED_FIBRE;
1398                         et_cmd->advertising = ADVERTISED_FIBRE;
1399                         et_cmd->phy_address = nesadapter->phy_index[nesdev->mac_index];
1400                 } else {
1401                         et_cmd->transceiver = XCVR_INTERNAL;
1402                         et_cmd->supported = SUPPORTED_10000baseT_Full;
1403                         et_cmd->advertising = ADVERTISED_10000baseT_Full;
1404                         et_cmd->phy_address = nesdev->mac_index;
1405                 }
1406                 et_cmd->speed = SPEED_10000;
1407                 et_cmd->autoneg = AUTONEG_DISABLE;
1408         }
1409         et_cmd->maxtxpkt = 511;
1410         et_cmd->maxrxpkt = 511;
1411         return 0;
1412 }
1413
1414
1415 /**
1416  * nes_netdev_set_settings
1417  */
1418 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1419 {
1420         struct nes_vnic *nesvnic = netdev_priv(netdev);
1421         struct nes_device *nesdev = nesvnic->nesdev;
1422         struct nes_adapter *nesadapter = nesdev->nesadapter;
1423         u16 phy_data;
1424
1425         if (nesadapter->OneG_Mode) {
1426                 nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1427                                 &phy_data);
1428                 if (et_cmd->autoneg) {
1429                         /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1430                         phy_data |= 0x1300;
1431                 } else {
1432                         // Turn off autoneg
1433                         phy_data &= ~0x1000;
1434                 }
1435                 nes_write_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1436                                 phy_data);
1437         }
1438
1439         return 0;
1440 }
1441
1442
1443 static struct ethtool_ops nes_ethtool_ops = {
1444         .get_link = ethtool_op_get_link,
1445         .get_settings = nes_netdev_get_settings,
1446         .set_settings = nes_netdev_set_settings,
1447         .get_tx_csum = ethtool_op_get_tx_csum,
1448         .get_rx_csum = nes_netdev_get_rx_csum,
1449         .get_sg = ethtool_op_get_sg,
1450         .get_strings = nes_netdev_get_strings,
1451         .get_stats_count = nes_netdev_get_stats_count,
1452         .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1453         .get_drvinfo = nes_netdev_get_drvinfo,
1454         .get_coalesce = nes_netdev_get_coalesce,
1455         .set_coalesce = nes_netdev_set_coalesce,
1456         .get_pauseparam = nes_netdev_get_pauseparam,
1457         .set_pauseparam = nes_netdev_set_pauseparam,
1458         .set_tx_csum = ethtool_op_set_tx_csum,
1459         .set_rx_csum = nes_netdev_set_rx_csum,
1460         .set_sg = ethtool_op_set_sg,
1461         .get_tso = ethtool_op_get_tso,
1462         .set_tso = ethtool_op_set_tso,
1463         .get_flags = ethtool_op_get_flags,
1464         .set_flags = ethtool_op_set_flags,
1465 };
1466
1467
1468 static void nes_netdev_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
1469 {
1470         struct nes_vnic *nesvnic = netdev_priv(netdev);
1471         struct nes_device *nesdev = nesvnic->nesdev;
1472         struct nes_adapter *nesadapter = nesdev->nesadapter;
1473         u32 u32temp;
1474         unsigned long flags;
1475
1476         spin_lock_irqsave(&nesadapter->phy_lock, flags);
1477         nesvnic->vlan_grp = grp;
1478
1479         nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1480
1481         /* Enable/Disable VLAN Stripping */
1482         u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1483         if (grp)
1484                 u32temp &= 0xfdffffff;
1485         else
1486                 u32temp |= 0x02000000;
1487
1488         nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1489         spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1490 }
1491
1492
1493 /**
1494  * nes_netdev_init - initialize network device
1495  */
1496 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1497                 void __iomem *mmio_addr)
1498 {
1499         u64 u64temp;
1500         struct nes_vnic *nesvnic = NULL;
1501         struct net_device *netdev;
1502         struct nic_qp_map *curr_qp_map;
1503         u32 u32temp;
1504         u16 phy_data;
1505         u16 temp_phy_data;
1506
1507         netdev = alloc_etherdev(sizeof(struct nes_vnic));
1508         if (!netdev) {
1509                 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1510                 return NULL;
1511         }
1512
1513         nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1514
1515         SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1516
1517         nesvnic = netdev_priv(netdev);
1518         memset(nesvnic, 0, sizeof(*nesvnic));
1519
1520         netdev->open = nes_netdev_open;
1521         netdev->stop = nes_netdev_stop;
1522         netdev->hard_start_xmit = nes_netdev_start_xmit;
1523         netdev->get_stats = nes_netdev_get_stats;
1524         netdev->tx_timeout = nes_netdev_tx_timeout;
1525         netdev->set_mac_address = nes_netdev_set_mac_address;
1526         netdev->set_multicast_list = nes_netdev_set_multicast_list;
1527         netdev->change_mtu = nes_netdev_change_mtu;
1528         netdev->watchdog_timeo = NES_TX_TIMEOUT;
1529         netdev->irq = nesdev->pcidev->irq;
1530         netdev->mtu = ETH_DATA_LEN;
1531         netdev->hard_header_len = ETH_HLEN;
1532         netdev->addr_len = ETH_ALEN;
1533         netdev->type = ARPHRD_ETHER;
1534         netdev->features = NETIF_F_HIGHDMA;
1535         netdev->ethtool_ops = &nes_ethtool_ops;
1536         netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1537         nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1538         netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1539         netdev->vlan_rx_register = nes_netdev_vlan_rx_register;
1540         netdev->features |= NETIF_F_LLTX;
1541
1542         /* Fill in the port structure */
1543         nesvnic->netdev = netdev;
1544         nesvnic->nesdev = nesdev;
1545         nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1546         nesvnic->netdev_index = nesdev->netdev_count;
1547         nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1548         nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1549
1550         curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1551         nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1552         nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1553         nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1554
1555         /* Setup the burned in MAC address */
1556         u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1557         u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1558         u64temp += nesvnic->nic_index;
1559         netdev->dev_addr[0] = (u8)(u64temp>>40);
1560         netdev->dev_addr[1] = (u8)(u64temp>>32);
1561         netdev->dev_addr[2] = (u8)(u64temp>>24);
1562         netdev->dev_addr[3] = (u8)(u64temp>>16);
1563         netdev->dev_addr[4] = (u8)(u64temp>>8);
1564         netdev->dev_addr[5] = (u8)u64temp;
1565         memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1566
1567         if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV)) {
1568                 netdev->features |= NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1569                 netdev->features |= NETIF_F_GSO | NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1570         } else {
1571                 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1572         }
1573
1574         nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1575                         " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1576                         nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1577                         nesvnic->nic_index, nesvnic->logical_port,  nesdev->mac_index);
1578
1579         if (nesvnic->nesdev->nesadapter->port_count == 1) {
1580                 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1581                 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1582                 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1583                         nesvnic->qp_nic_index[2] = 0xf;
1584                         nesvnic->qp_nic_index[3] = 0xf;
1585                 } else {
1586                         nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1587                         nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1588                 }
1589         } else {
1590                 if (nesvnic->nesdev->nesadapter->port_count == 2) {
1591                         nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1592                         nesvnic->qp_nic_index[1] = nesvnic->nic_index + 2;
1593                         nesvnic->qp_nic_index[2] = 0xf;
1594                         nesvnic->qp_nic_index[3] = 0xf;
1595                 } else {
1596                         nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1597                         nesvnic->qp_nic_index[1] = 0xf;
1598                         nesvnic->qp_nic_index[2] = 0xf;
1599                         nesvnic->qp_nic_index[3] = 0xf;
1600                 }
1601         }
1602         nesvnic->next_qp_nic_index = 0;
1603
1604         if (nesdev->netdev_count == 0) {
1605                 nesvnic->rdma_enabled = 1;
1606         } else {
1607                 nesvnic->rdma_enabled = 0;
1608         }
1609         nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1610         spin_lock_init(&nesvnic->tx_lock);
1611         nesdev->netdev[nesdev->netdev_count] = netdev;
1612
1613         nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1614                         nesvnic, nesdev->mac_index);
1615         list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1616
1617         if ((nesdev->netdev_count == 0) &&
1618             (PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index)) {
1619                 nes_debug(NES_DBG_INIT, "Setting up PHY interrupt mask. Using register index 0x%04X\n",
1620                                 NES_IDX_PHY_PCS_CONTROL_STATUS0+(0x200*(nesvnic->logical_port&1)));
1621                 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1622                                 (0x200*(nesvnic->logical_port&1)));
1623                 u32temp |= 0x00200000;
1624                 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1625                                 (0x200*(nesvnic->logical_port&1)), u32temp);
1626                 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1627                                 (0x200*(nesvnic->logical_port&1)) );
1628                 if ((u32temp&0x0f1f0000) == 0x0f0f0000) {
1629                         if (nesdev->nesadapter->phy_type[nesvnic->logical_port] == NES_PHY_TYPE_IRIS) {
1630                                 nes_init_phy(nesdev);
1631                                 nes_read_10G_phy_reg(nesdev, 1,
1632                                                 nesdev->nesadapter->phy_index[nesvnic->logical_port]);
1633                                 temp_phy_data = (u16)nes_read_indexed(nesdev,
1634                                                                         NES_IDX_MAC_MDIO_CONTROL);
1635                                 u32temp = 20;
1636                                 do {
1637                                         nes_read_10G_phy_reg(nesdev, 1,
1638                                                         nesdev->nesadapter->phy_index[nesvnic->logical_port]);
1639                                         phy_data = (u16)nes_read_indexed(nesdev,
1640                                                                         NES_IDX_MAC_MDIO_CONTROL);
1641                                         if ((phy_data == temp_phy_data) || (!(--u32temp)))
1642                                                 break;
1643                                         temp_phy_data = phy_data;
1644                                 } while (1);
1645                                 if (phy_data & 4) {
1646                                         nes_debug(NES_DBG_INIT, "The Link is UP!!.\n");
1647                                         nesvnic->linkup = 1;
1648                                 } else {
1649                                         nes_debug(NES_DBG_INIT, "The Link is DOWN!!.\n");
1650                                 }
1651                         } else {
1652                                 nes_debug(NES_DBG_INIT, "The Link is UP!!.\n");
1653                                 nesvnic->linkup = 1;
1654                         }
1655                 }
1656                 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1657                 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1658                 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1659                 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1660
1661                 if (nesdev->nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_IRIS)
1662                         nes_init_phy(nesdev);
1663
1664         }
1665
1666         return netdev;
1667 }
1668
1669
1670 /**
1671  * nes_netdev_destroy - destroy network device structure
1672  */
1673 void nes_netdev_destroy(struct net_device *netdev)
1674 {
1675         struct nes_vnic *nesvnic = netdev_priv(netdev);
1676
1677         /* make sure 'stop' method is called by Linux stack */
1678         /* nes_netdev_stop(netdev); */
1679
1680         list_del(&nesvnic->list);
1681
1682         if (nesvnic->of_device_registered) {
1683                 nes_destroy_ofa_device(nesvnic->nesibdev);
1684         }
1685
1686         free_netdev(netdev);
1687 }
1688
1689
1690 /**
1691  * nes_nic_cm_xmit -- CM calls this to send out pkts
1692  */
1693 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1694 {
1695         int ret;
1696
1697         skb->dev = netdev;
1698         ret = dev_queue_xmit(skb);
1699         if (ret) {
1700                 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1701         }
1702
1703         return ret;
1704 }