drivers/infiniband/hw/nes/nes_nic.c

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