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