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