drivers/infiniband/hw/nes/nes_nic.c

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