drivers/infiniband/hw/nes/nes_nic.c

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