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