drivers/infiniband/hw/nes/nes_nic.c

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