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