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         "LRO aggregated",
1089         "LRO flushed",
1090         "LRO no_desc",
1091         "PAU CreateQPs",
1092         "PAU DestroyQPs",
1093 };
1094 #define NES_ETHTOOL_STAT_COUNT  ARRAY_SIZE(nes_ethtool_stringset)
1095
1096
1097 /**
1098  * nes_netdev_get_sset_count
1099  */
1100 static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
1101 {
1102         if (stringset == ETH_SS_STATS)
1103                 return NES_ETHTOOL_STAT_COUNT;
1104         else
1105                 return -EINVAL;
1106 }
1107
1108
1109 /**
1110  * nes_netdev_get_strings
1111  */
1112 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1113                 u8 *ethtool_strings)
1114 {
1115         if (stringset == ETH_SS_STATS)
1116                 memcpy(ethtool_strings,
1117                                 &nes_ethtool_stringset,
1118                                 sizeof(nes_ethtool_stringset));
1119 }
1120
1121
1122 /**
1123  * nes_netdev_get_ethtool_stats
1124  */
1125
1126 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1127                 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1128 {
1129         u64 u64temp;
1130         struct nes_vnic *nesvnic = netdev_priv(netdev);
1131         struct nes_device *nesdev = nesvnic->nesdev;
1132         struct nes_adapter *nesadapter = nesdev->nesadapter;
1133         u32 nic_count;
1134         u32 u32temp;
1135         u32 index = 0;
1136
1137         target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1138         target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1139         target_stat_values[++index] = nesvnic->linearized_skbs;
1140         target_stat_values[++index] = nesvnic->tso_requests;
1141
1142         u32temp = nes_read_indexed(nesdev,
1143                         NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1144         nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1145         target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
1146
1147         u32temp = nes_read_indexed(nesdev,
1148                         NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1149         nesvnic->nesdev->mac_pause_frames_received += u32temp;
1150
1151         u32temp = nes_read_indexed(nesdev,
1152                         NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1153         nesvnic->nesdev->port_rx_discards += u32temp;
1154         nesvnic->netstats.rx_dropped += u32temp;
1155
1156         u32temp = nes_read_indexed(nesdev,
1157                         NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1158         nesvnic->nesdev->port_tx_discards += u32temp;
1159         nesvnic->netstats.tx_dropped += u32temp;
1160
1161         u32temp = nes_read_indexed(nesdev,
1162                         NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1163         nesvnic->netstats.rx_dropped += u32temp;
1164         nesvnic->nesdev->mac_rx_errors += u32temp;
1165         nesvnic->nesdev->mac_rx_short_frames += u32temp;
1166
1167         u32temp = nes_read_indexed(nesdev,
1168                         NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1169         nesvnic->netstats.rx_dropped += u32temp;
1170         nesvnic->nesdev->mac_rx_errors += u32temp;
1171         nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
1172
1173         u32temp = nes_read_indexed(nesdev,
1174                         NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1175         nesvnic->netstats.rx_dropped += u32temp;
1176         nesvnic->nesdev->mac_rx_errors += u32temp;
1177         nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
1178
1179         u32temp = nes_read_indexed(nesdev,
1180                         NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1181         nesvnic->netstats.rx_dropped += u32temp;
1182         nesvnic->nesdev->mac_rx_errors += u32temp;
1183         nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
1184
1185         u32temp = nes_read_indexed(nesdev,
1186                         NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1187         nesvnic->netstats.rx_length_errors += u32temp;
1188         nesvnic->nesdev->mac_rx_errors += u32temp;
1189
1190         u32temp = nes_read_indexed(nesdev,
1191                         NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1192         nesvnic->nesdev->mac_rx_errors += u32temp;
1193         nesvnic->nesdev->mac_rx_crc_errors += u32temp;
1194         nesvnic->netstats.rx_crc_errors += u32temp;
1195
1196         u32temp = nes_read_indexed(nesdev,
1197                         NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
1198         nesvnic->nesdev->mac_tx_errors += u32temp;
1199         nesvnic->netstats.tx_errors += u32temp;
1200
1201         for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1202                 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1203                         break;
1204
1205                 u32temp = nes_read_indexed(nesdev,
1206                                 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1207                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1208                 nesvnic->netstats.rx_dropped += u32temp;
1209                 nesvnic->endnode_nstat_rx_discard += u32temp;
1210
1211                 u64temp = (u64)nes_read_indexed(nesdev,
1212                                 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1213                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1214                 u64temp += ((u64)nes_read_indexed(nesdev,
1215                                 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1216                                 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1217
1218                 nesvnic->endnode_nstat_rx_octets += u64temp;
1219                 nesvnic->netstats.rx_bytes += u64temp;
1220
1221                 u64temp = (u64)nes_read_indexed(nesdev,
1222                                 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1223                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1224                 u64temp += ((u64)nes_read_indexed(nesdev,
1225                                 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1226                                 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1227
1228                 nesvnic->endnode_nstat_rx_frames += u64temp;
1229                 nesvnic->netstats.rx_packets += u64temp;
1230
1231                 u64temp = (u64)nes_read_indexed(nesdev,
1232                                 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1233                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1234                 u64temp += ((u64)nes_read_indexed(nesdev,
1235                                 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1236                                 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1237
1238                 nesvnic->endnode_nstat_tx_octets += u64temp;
1239                 nesvnic->netstats.tx_bytes += u64temp;
1240
1241                 u64temp = (u64)nes_read_indexed(nesdev,
1242                                 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1243                                 (nesvnic->qp_nic_index[nic_count]*0x200));
1244                 u64temp += ((u64)nes_read_indexed(nesdev,
1245                                 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1246                                 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1247
1248                 nesvnic->endnode_nstat_tx_frames += u64temp;
1249                 nesvnic->netstats.tx_packets += u64temp;
1250
1251                 u32temp = nes_read_indexed(nesdev,
1252                                 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1253                 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1254         }
1255
1256         target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1257         target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1258         target_stat_values[++index] = nesvnic->tx_sw_dropped;
1259         target_stat_values[++index] = nesvnic->sq_full;
1260         target_stat_values[++index] = nesvnic->segmented_tso_requests;
1261         target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1262         target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1263         target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1264         target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
1265         target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
1266         target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
1267         target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
1268         target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1269         target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1270         target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1271         target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1272         target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
1273         target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
1274         target_stat_values[++index] = mh_detected;
1275         target_stat_values[++index] = mh_pauses_sent;
1276         target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1277         target_stat_values[++index] = atomic_read(&cm_connects);
1278         target_stat_values[++index] = atomic_read(&cm_accepts);
1279         target_stat_values[++index] = atomic_read(&cm_disconnects);
1280         target_stat_values[++index] = atomic_read(&cm_connecteds);
1281         target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1282         target_stat_values[++index] = atomic_read(&cm_rejects);
1283         target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1284         target_stat_values[++index] = atomic_read(&qps_created);
1285         target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1286         target_stat_values[++index] = atomic_read(&qps_destroyed);
1287         target_stat_values[++index] = atomic_read(&cm_closes);
1288         target_stat_values[++index] = cm_packets_sent;
1289         target_stat_values[++index] = cm_packets_bounced;
1290         target_stat_values[++index] = cm_packets_created;
1291         target_stat_values[++index] = cm_packets_received;
1292         target_stat_values[++index] = cm_packets_dropped;
1293         target_stat_values[++index] = cm_packets_retrans;
1294         target_stat_values[++index] = atomic_read(&cm_listens_created);
1295         target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
1296         target_stat_values[++index] = cm_backlog_drops;
1297         target_stat_values[++index] = atomic_read(&cm_loopbacks);
1298         target_stat_values[++index] = atomic_read(&cm_nodes_created);
1299         target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1300         target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1301         target_stat_values[++index] = atomic_read(&cm_resets_recvd);
1302         target_stat_values[++index] = nesadapter->free_4kpbl;
1303         target_stat_values[++index] = nesadapter->free_256pbl;
1304         target_stat_values[++index] = int_mod_timer_init;
1305         target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
1306         target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
1307         target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
1308         target_stat_values[++index] = atomic_read(&pau_qps_created);
1309         target_stat_values[++index] = atomic_read(&pau_qps_destroyed);
1310 }
1311
1312 /**
1313  * nes_netdev_get_drvinfo
1314  */
1315 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1316                 struct ethtool_drvinfo *drvinfo)
1317 {
1318         struct nes_vnic *nesvnic = netdev_priv(netdev);
1319         struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
1320
1321         strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
1322         strlcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev),
1323                 sizeof(drvinfo->bus_info));
1324         snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1325                  "%u.%u", nesadapter->firmware_version >> 16,
1326                  nesadapter->firmware_version & 0x000000ff);
1327         strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
1328 }
1329
1330
1331 /**
1332  * nes_netdev_set_coalesce
1333  */
1334 static int nes_netdev_set_coalesce(struct net_device *netdev,
1335                 struct ethtool_coalesce *et_coalesce)
1336 {
1337         struct nes_vnic *nesvnic = netdev_priv(netdev);
1338         struct nes_device *nesdev = nesvnic->nesdev;
1339         struct nes_adapter *nesadapter = nesdev->nesadapter;
1340         struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1341         unsigned long flags;
1342
1343         spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1344         if (et_coalesce->rx_max_coalesced_frames_low) {
1345                 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1346         }
1347         if (et_coalesce->rx_max_coalesced_frames_irq) {
1348                 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1349         }
1350         if (et_coalesce->rx_max_coalesced_frames_high) {
1351                 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1352         }
1353         if (et_coalesce->rx_coalesce_usecs_low) {
1354                 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1355         }
1356         if (et_coalesce->rx_coalesce_usecs_high) {
1357                 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1358         }
1359         spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1360
1361         /* using this to drive total interrupt moderation */
1362         nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1363         if (et_coalesce->use_adaptive_rx_coalesce) {
1364                 nesadapter->et_use_adaptive_rx_coalesce = 1;
1365                 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1366                 nesadapter->et_rx_coalesce_usecs_irq = 0;
1367                 if (et_coalesce->pkt_rate_low) {
1368                         nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1369                 }
1370         } else {
1371                 nesadapter->et_use_adaptive_rx_coalesce = 0;
1372                 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1373                 if (nesadapter->et_rx_coalesce_usecs_irq) {
1374                         nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1375                                         0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1376                 }
1377         }
1378         return 0;
1379 }
1380
1381
1382 /**
1383  * nes_netdev_get_coalesce
1384  */
1385 static int nes_netdev_get_coalesce(struct net_device *netdev,
1386                 struct ethtool_coalesce *et_coalesce)
1387 {
1388         struct nes_vnic *nesvnic = netdev_priv(netdev);
1389         struct nes_device *nesdev = nesvnic->nesdev;
1390         struct nes_adapter *nesadapter = nesdev->nesadapter;
1391         struct ethtool_coalesce temp_et_coalesce;
1392         struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1393         unsigned long flags;
1394
1395         memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1396         temp_et_coalesce.rx_coalesce_usecs_irq    = nesadapter->et_rx_coalesce_usecs_irq;
1397         temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1398         temp_et_coalesce.rate_sample_interval     = nesadapter->et_rate_sample_interval;
1399         temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1400         spin_lock_irqsave(&nesadapter->periodic_timer_lock,     flags);
1401         temp_et_coalesce.rx_max_coalesced_frames_low  = shared_timer->threshold_low;
1402         temp_et_coalesce.rx_max_coalesced_frames_irq  = shared_timer->threshold_target;
1403         temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1404         temp_et_coalesce.rx_coalesce_usecs_low  = shared_timer->timer_in_use_min;
1405         temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1406         if (nesadapter->et_use_adaptive_rx_coalesce) {
1407                 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1408         }
1409         spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1410         memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1411         return 0;
1412 }
1413
1414
1415 /**
1416  * nes_netdev_get_pauseparam
1417  */
1418 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1419                 struct ethtool_pauseparam *et_pauseparam)
1420 {
1421         struct nes_vnic *nesvnic = netdev_priv(netdev);
1422
1423         et_pauseparam->autoneg = 0;
1424         et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1425         et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1426 }
1427
1428
1429 /**
1430  * nes_netdev_set_pauseparam
1431  */
1432 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1433                 struct ethtool_pauseparam *et_pauseparam)
1434 {
1435         struct nes_vnic *nesvnic = netdev_priv(netdev);
1436         struct nes_device *nesdev = nesvnic->nesdev;
1437         u32 u32temp;
1438
1439         if (et_pauseparam->autoneg) {
1440                 /* TODO: should return unsupported */
1441                 return 0;
1442         }
1443         if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1444                 u32temp = nes_read_indexed(nesdev,
1445                                 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1446                 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1447                 nes_write_indexed(nesdev,
1448                                 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
1449                 nesdev->disable_tx_flow_control = 0;
1450         } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1451                 u32temp = nes_read_indexed(nesdev,
1452                                 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1453                 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1454                 nes_write_indexed(nesdev,
1455                                 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
1456                 nesdev->disable_tx_flow_control = 1;
1457         }
1458         if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1459                 u32temp = nes_read_indexed(nesdev,
1460                                 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1461                 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1462                 nes_write_indexed(nesdev,
1463                                 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1464                 nesdev->disable_rx_flow_control = 0;
1465         } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1466                 u32temp = nes_read_indexed(nesdev,
1467                                 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1468                 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1469                 nes_write_indexed(nesdev,
1470                                 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1471                 nesdev->disable_rx_flow_control = 1;
1472         }
1473
1474         return 0;
1475 }
1476
1477
1478 /**
1479  * nes_netdev_get_settings
1480  */
1481 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1482 {
1483         struct nes_vnic *nesvnic = netdev_priv(netdev);
1484         struct nes_device *nesdev = nesvnic->nesdev;
1485         struct nes_adapter *nesadapter = nesdev->nesadapter;
1486         u32 mac_index = nesdev->mac_index;
1487         u8 phy_type = nesadapter->phy_type[mac_index];
1488         u8 phy_index = nesadapter->phy_index[mac_index];
1489         u16 phy_data;
1490
1491         et_cmd->duplex = DUPLEX_FULL;
1492         et_cmd->port   = PORT_MII;
1493         et_cmd->maxtxpkt = 511;
1494         et_cmd->maxrxpkt = 511;
1495
1496         if (nesadapter->OneG_Mode) {
1497                 ethtool_cmd_speed_set(et_cmd, SPEED_1000);
1498                 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
1499                         et_cmd->supported   = SUPPORTED_1000baseT_Full;
1500                         et_cmd->advertising = ADVERTISED_1000baseT_Full;
1501                         et_cmd->autoneg     = AUTONEG_DISABLE;
1502                         et_cmd->transceiver = XCVR_INTERNAL;
1503                         et_cmd->phy_address = mac_index;
1504                 } else {
1505                         unsigned long flags;
1506                         et_cmd->supported   = SUPPORTED_1000baseT_Full
1507                                             | SUPPORTED_Autoneg;
1508                         et_cmd->advertising = ADVERTISED_1000baseT_Full
1509                                             | ADVERTISED_Autoneg;
1510                         spin_lock_irqsave(&nesadapter->phy_lock, flags);
1511                         nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1512                         spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1513                         if (phy_data & 0x1000)
1514                                 et_cmd->autoneg = AUTONEG_ENABLE;
1515                         else
1516                                 et_cmd->autoneg = AUTONEG_DISABLE;
1517                         et_cmd->transceiver = XCVR_EXTERNAL;
1518                         et_cmd->phy_address = phy_index;
1519                 }
1520                 return 0;
1521         }
1522         if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1523             (phy_type == NES_PHY_TYPE_SFP_D) ||
1524             (phy_type == NES_PHY_TYPE_KR)) {
1525                 et_cmd->transceiver = XCVR_EXTERNAL;
1526                 et_cmd->port        = PORT_FIBRE;
1527                 et_cmd->supported   = SUPPORTED_FIBRE;
1528                 et_cmd->advertising = ADVERTISED_FIBRE;
1529                 et_cmd->phy_address = phy_index;
1530         } else {
1531                 et_cmd->transceiver = XCVR_INTERNAL;
1532                 et_cmd->supported   = SUPPORTED_10000baseT_Full;
1533                 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1534                 et_cmd->phy_address = mac_index;
1535         }
1536         ethtool_cmd_speed_set(et_cmd, SPEED_10000);
1537         et_cmd->autoneg = AUTONEG_DISABLE;
1538         return 0;
1539 }
1540
1541
1542 /**
1543  * nes_netdev_set_settings
1544  */
1545 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1546 {
1547         struct nes_vnic *nesvnic = netdev_priv(netdev);
1548         struct nes_device *nesdev = nesvnic->nesdev;
1549         struct nes_adapter *nesadapter = nesdev->nesadapter;
1550
1551         if ((nesadapter->OneG_Mode) &&
1552             (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1553                 unsigned long flags;
1554                 u16 phy_data;
1555                 u8 phy_index = nesadapter->phy_index[nesdev->mac_index];
1556
1557                 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1558                 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1559                 if (et_cmd->autoneg) {
1560                         /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1561                         phy_data |= 0x1300;
1562                 } else {
1563                         /* Turn off autoneg */
1564                         phy_data &= ~0x1000;
1565                 }
1566                 nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data);
1567                 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1568         }
1569
1570         return 0;
1571 }
1572
1573
1574 static const struct ethtool_ops nes_ethtool_ops = {
1575         .get_link = ethtool_op_get_link,
1576         .get_settings = nes_netdev_get_settings,
1577         .set_settings = nes_netdev_set_settings,
1578         .get_strings = nes_netdev_get_strings,
1579         .get_sset_count = nes_netdev_get_sset_count,
1580         .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1581         .get_drvinfo = nes_netdev_get_drvinfo,
1582         .get_coalesce = nes_netdev_get_coalesce,
1583         .set_coalesce = nes_netdev_set_coalesce,
1584         .get_pauseparam = nes_netdev_get_pauseparam,
1585         .set_pauseparam = nes_netdev_set_pauseparam,
1586 };
1587
1588 static void nes_vlan_mode(struct net_device *netdev, struct nes_device *nesdev, netdev_features_t features)
1589 {
1590         struct nes_adapter *nesadapter = nesdev->nesadapter;
1591         u32 u32temp;
1592         unsigned long flags;
1593
1594         spin_lock_irqsave(&nesadapter->phy_lock, flags);
1595
1596         nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1597
1598         /* Enable/Disable VLAN Stripping */
1599         u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1600         if (features & NETIF_F_HW_VLAN_CTAG_RX)
1601                 u32temp &= 0xfdffffff;
1602         else
1603                 u32temp |= 0x02000000;
1604
1605         nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1606         spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1607 }
1608
1609 static netdev_features_t nes_fix_features(struct net_device *netdev, netdev_features_t features)
1610 {
1611         /*
1612          * Since there is no support for separate rx/tx vlan accel
1613          * enable/disable make sure tx flag is always in same state as rx.
1614          */
1615         if (features & NETIF_F_HW_VLAN_CTAG_RX)
1616                 features |= NETIF_F_HW_VLAN_CTAG_TX;
1617         else
1618                 features &= ~NETIF_F_HW_VLAN_CTAG_TX;
1619
1620         return features;
1621 }
1622
1623 static int nes_set_features(struct net_device *netdev, netdev_features_t features)
1624 {
1625         struct nes_vnic *nesvnic = netdev_priv(netdev);
1626         struct nes_device *nesdev = nesvnic->nesdev;
1627         u32 changed = netdev->features ^ features;
1628
1629         if (changed & NETIF_F_HW_VLAN_CTAG_RX)
1630                 nes_vlan_mode(netdev, nesdev, features);
1631
1632         return 0;
1633 }
1634
1635 static const struct net_device_ops nes_netdev_ops = {
1636         .ndo_open               = nes_netdev_open,
1637         .ndo_stop               = nes_netdev_stop,
1638         .ndo_start_xmit         = nes_netdev_start_xmit,
1639         .ndo_get_stats          = nes_netdev_get_stats,
1640         .ndo_tx_timeout         = nes_netdev_tx_timeout,
1641         .ndo_set_mac_address    = nes_netdev_set_mac_address,
1642         .ndo_set_rx_mode        = nes_netdev_set_multicast_list,
1643         .ndo_change_mtu         = nes_netdev_change_mtu,
1644         .ndo_validate_addr      = eth_validate_addr,
1645         .ndo_fix_features       = nes_fix_features,
1646         .ndo_set_features       = nes_set_features,
1647 };
1648
1649 /**
1650  * nes_netdev_init - initialize network device
1651  */
1652 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1653                 void __iomem *mmio_addr)
1654 {
1655         u64 u64temp;
1656         struct nes_vnic *nesvnic;
1657         struct net_device *netdev;
1658         struct nic_qp_map *curr_qp_map;
1659         u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
1660
1661         netdev = alloc_etherdev(sizeof(struct nes_vnic));
1662         if (!netdev) {
1663                 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1664                 return NULL;
1665         }
1666         nesvnic = netdev_priv(netdev);
1667
1668         nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1669
1670         SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1671
1672         netdev->watchdog_timeo = NES_TX_TIMEOUT;
1673         netdev->irq = nesdev->pcidev->irq;
1674         netdev->mtu = ETH_DATA_LEN;
1675         netdev->hard_header_len = ETH_HLEN;
1676         netdev->addr_len = ETH_ALEN;
1677         netdev->type = ARPHRD_ETHER;
1678         netdev->netdev_ops = &nes_netdev_ops;
1679         netdev->ethtool_ops = &nes_ethtool_ops;
1680         netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1681         nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1682
1683         /* Fill in the port structure */
1684         nesvnic->netdev = netdev;
1685         nesvnic->nesdev = nesdev;
1686         nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1687         nesvnic->netdev_index = nesdev->netdev_count;
1688         nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1689         nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1690
1691         curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1692         nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1693         nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1694         nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1695
1696         /* Setup the burned in MAC address */
1697         u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1698         u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1699         u64temp += nesvnic->nic_index;
1700         netdev->dev_addr[0] = (u8)(u64temp>>40);
1701         netdev->dev_addr[1] = (u8)(u64temp>>32);
1702         netdev->dev_addr[2] = (u8)(u64temp>>24);
1703         netdev->dev_addr[3] = (u8)(u64temp>>16);
1704         netdev->dev_addr[4] = (u8)(u64temp>>8);
1705         netdev->dev_addr[5] = (u8)u64temp;
1706
1707         netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM | NETIF_F_HW_VLAN_CTAG_RX;
1708         if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV))
1709                 netdev->hw_features |= NETIF_F_TSO;
1710
1711         netdev->features = netdev->hw_features | NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_CTAG_TX;
1712         netdev->hw_features |= NETIF_F_LRO;
1713
1714         nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1715                         " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1716                         nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1717                         nesvnic->nic_index, nesvnic->logical_port,  nesdev->mac_index);
1718
1719         if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1720                 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1721
1722                 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1723                 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1724                 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1725                         nesvnic->qp_nic_index[2] = 0xf;
1726                         nesvnic->qp_nic_index[3] = 0xf;
1727                 } else {
1728                         nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1729                         nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1730                 }
1731         } else {
1732                 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1733                         (nesvnic->nesdev->nesadapter->port_count == 1 &&
1734                         nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1735                                 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1736                                 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1737                                                                         + 2;
1738                                 nesvnic->qp_nic_index[2] = 0xf;
1739                                 nesvnic->qp_nic_index[3] = 0xf;
1740                 } else {
1741                         nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1742                         nesvnic->qp_nic_index[1] = 0xf;
1743                         nesvnic->qp_nic_index[2] = 0xf;
1744                         nesvnic->qp_nic_index[3] = 0xf;
1745                 }
1746         }
1747         nesvnic->next_qp_nic_index = 0;
1748
1749         if (nesdev->netdev_count == 0) {
1750                 nesvnic->rdma_enabled = 1;
1751         } else {
1752                 nesvnic->rdma_enabled = 0;
1753         }
1754         nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1755         init_timer(&nesvnic->event_timer);
1756         nesvnic->event_timer.function = NULL;
1757         spin_lock_init(&nesvnic->tx_lock);
1758         spin_lock_init(&nesvnic->port_ibevent_lock);
1759         nesdev->netdev[nesdev->netdev_count] = netdev;
1760
1761         nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1762                         nesvnic, nesdev->mac_index);
1763         list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1764
1765         if ((nesdev->netdev_count == 0) &&
1766             ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1767              ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
1768               (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1769                ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1770                 u32 u32temp;
1771                 u32 link_mask = 0;
1772                 u32 link_val = 0;
1773                 u16 temp_phy_data;
1774                 u16 phy_data = 0;
1775                 unsigned long flags;
1776
1777                 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1778                                 (0x200 * (nesdev->mac_index & 1)));
1779                 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
1780                         u32temp |= 0x00200000;
1781                         nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1782                                 (0x200 * (nesdev->mac_index & 1)), u32temp);
1783                 }
1784
1785                 /* Check and set linkup here.  This is for back to back */
1786                 /* configuration where second port won't get link interrupt */
1787                 switch (phy_type) {
1788                 case NES_PHY_TYPE_PUMA_1G:
1789                         if (nesdev->mac_index < 2) {
1790                                 link_mask = 0x01010000;
1791                                 link_val = 0x01010000;
1792                         } else {
1793                                 link_mask = 0x02020000;
1794                                 link_val = 0x02020000;
1795                         }
1796                         break;
1797                 case NES_PHY_TYPE_SFP_D:
1798                         spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
1799                         nes_read_10G_phy_reg(nesdev,
1800                                              nesdev->nesadapter->phy_index[nesdev->mac_index],
1801                                              1, 0x9003);
1802                         temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1803                         nes_read_10G_phy_reg(nesdev,
1804                                              nesdev->nesadapter->phy_index[nesdev->mac_index],
1805                                              3, 0x0021);
1806                         nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1807                         nes_read_10G_phy_reg(nesdev,
1808                                              nesdev->nesadapter->phy_index[nesdev->mac_index],
1809                                              3, 0x0021);
1810                         phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1811                         spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
1812                         phy_data = (!temp_phy_data && (phy_data == 0x8000)) ? 0x4 : 0x0;
1813                         break;
1814                 default:
1815                         link_mask = 0x0f1f0000;
1816                         link_val = 0x0f0f0000;
1817                         break;
1818                 }
1819
1820                 u32temp = nes_read_indexed(nesdev,
1821                                            NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1822                                            (0x200 * (nesdev->mac_index & 1)));
1823
1824                 if (phy_type == NES_PHY_TYPE_SFP_D) {
1825                         if (phy_data & 0x0004)
1826                                 nesvnic->linkup = 1;
1827                 } else {
1828                         if ((u32temp & link_mask) == link_val)
1829                                 nesvnic->linkup = 1;
1830                 }
1831
1832                 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1833                 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1834                 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1835                 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1836
1837                 nes_init_phy(nesdev);
1838         }
1839
1840         nes_vlan_mode(netdev, nesdev, netdev->features);
1841
1842         return netdev;
1843 }
1844
1845
1846 /**
1847  * nes_netdev_destroy - destroy network device structure
1848  */
1849 void nes_netdev_destroy(struct net_device *netdev)
1850 {
1851         struct nes_vnic *nesvnic = netdev_priv(netdev);
1852
1853         /* make sure 'stop' method is called by Linux stack */
1854         /* nes_netdev_stop(netdev); */
1855
1856         list_del(&nesvnic->list);
1857
1858         if (nesvnic->of_device_registered) {
1859                 nes_destroy_ofa_device(nesvnic->nesibdev);
1860         }
1861
1862         free_netdev(netdev);
1863 }
1864
1865
1866 /**
1867  * nes_nic_cm_xmit -- CM calls this to send out pkts
1868  */
1869 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1870 {
1871         int ret;
1872
1873         skb->dev = netdev;
1874         ret = dev_queue_xmit(skb);
1875         if (ret) {
1876                 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1877         }
1878
1879         return ret;
1880 }