drivers/infiniband/hw/nes/nes_nic.c

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