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