drivers/infiniband/hw/nes/nes_nic.c

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