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