drivers/infiniband/hw/nes/nes_nic.c

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