drivers/infiniband/hw/nes/nes_nic.c

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