drivers/infiniband/hw/nes/nes_nic.c

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