drivers/infiniband/hw/nes/nes_nic.c

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