2 * Copyright (c) 2006 - 2011 Intel Corporation. All rights reserved.
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:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
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.
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
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.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 <linux/slab.h>
46 #include <net/inet_common.h>
47 #include <linux/inet.h>
51 static struct nic_qp_map nic_qp_mapping_0[] = {
52 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
53 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
54 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
55 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
58 static struct nic_qp_map nic_qp_mapping_1[] = {
59 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
60 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
63 static struct nic_qp_map nic_qp_mapping_2[] = {
64 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
67 static struct nic_qp_map nic_qp_mapping_3[] = {
68 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
71 static struct nic_qp_map nic_qp_mapping_4[] = {
72 {28,8,0,0},{32,12,0,0}
75 static struct nic_qp_map nic_qp_mapping_5[] = {
76 {29,9,1,0},{33,13,1,0}
79 static struct nic_qp_map nic_qp_mapping_6[] = {
80 {30,10,2,0},{34,14,2,0}
83 static struct nic_qp_map nic_qp_mapping_7[] = {
84 {31,11,3,0},{35,15,3,0}
87 static struct nic_qp_map *nic_qp_mapping_per_function[] = {
88 nic_qp_mapping_0, nic_qp_mapping_1, nic_qp_mapping_2, nic_qp_mapping_3,
89 nic_qp_mapping_4, nic_qp_mapping_5, nic_qp_mapping_6, nic_qp_mapping_7
92 static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
93 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
94 static int debug = -1;
95 static int nics_per_function = 1;
100 static int nes_netdev_poll(struct napi_struct *napi, int budget)
102 struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi);
103 struct nes_device *nesdev = nesvnic->nesdev;
104 struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq;
106 nesvnic->budget = budget;
107 nescq->cqes_pending = 0;
108 nescq->rx_cqes_completed = 0;
109 nescq->cqe_allocs_pending = 0;
110 nescq->rx_pkts_indicated = 0;
112 nes_nic_ce_handler(nesdev, nescq);
114 if (nescq->cqes_pending == 0) {
116 /* clear out completed cqes and arm */
117 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
118 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
119 nes_read32(nesdev->regs+NES_CQE_ALLOC);
121 /* clear out completed cqes but don't arm */
122 nes_write32(nesdev->regs+NES_CQE_ALLOC,
123 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
124 nes_debug(NES_DBG_NETDEV, "%s: exiting with work pending\n",
125 nesvnic->netdev->name);
127 return nescq->rx_pkts_indicated;
132 * nes_netdev_open - Activate the network interface; ifconfig
135 static int nes_netdev_open(struct net_device *netdev)
139 struct nes_vnic *nesvnic = netdev_priv(netdev);
140 struct nes_device *nesdev = nesvnic->nesdev;
143 struct nes_vnic *first_nesvnic = NULL;
146 struct list_head *list_pos, *list_temp;
149 assert(nesdev != NULL);
151 if (nesvnic->netdev_open == 1)
154 if (netif_msg_ifup(nesvnic))
155 printk(KERN_INFO PFX "%s: enabling interface\n", netdev->name);
157 ret = nes_init_nic_qp(nesdev, netdev);
162 netif_carrier_off(netdev);
163 netif_stop_queue(netdev);
165 if ((!nesvnic->of_device_registered) && (nesvnic->rdma_enabled)) {
166 nesvnic->nesibdev = nes_init_ofa_device(netdev);
167 if (nesvnic->nesibdev == NULL) {
168 printk(KERN_ERR PFX "%s: nesvnic->nesibdev alloc failed", netdev->name);
170 nesvnic->nesibdev->nesvnic = nesvnic;
171 ret = nes_register_ofa_device(nesvnic->nesibdev);
173 printk(KERN_ERR PFX "%s: Unable to register RDMA device, ret = %d\n",
178 /* Set packet filters */
179 nic_active_bit = 1 << nesvnic->nic_index;
180 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
181 nic_active |= nic_active_bit;
182 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
183 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
184 nic_active |= nic_active_bit;
185 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
186 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
187 nic_active |= nic_active_bit;
188 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
190 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
191 macaddr_high += (u16)netdev->dev_addr[1];
193 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
194 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
195 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
196 macaddr_low += (u32)netdev->dev_addr[5];
198 /* Program the various MAC regs */
199 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
200 if (nesvnic->qp_nic_index[i] == 0xf) {
203 nes_debug(NES_DBG_NETDEV, "i=%d, perfect filter table index= %d, PERF FILTER LOW"
204 " (Addr:%08X) = %08X, HIGH = %08X.\n",
205 i, nesvnic->qp_nic_index[i],
206 NES_IDX_PERFECT_FILTER_LOW+
207 (nesvnic->qp_nic_index[i] * 8),
209 (u32)macaddr_high | NES_MAC_ADDR_VALID |
210 ((((u32)nesvnic->nic_index) << 16)));
211 nes_write_indexed(nesdev,
212 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
214 nes_write_indexed(nesdev,
215 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
216 (u32)macaddr_high | NES_MAC_ADDR_VALID |
217 ((((u32)nesvnic->nic_index) << 16)));
221 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
222 nesvnic->nic_cq.cq_number);
223 nes_read32(nesdev->regs+NES_CQE_ALLOC);
224 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
225 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
226 if (first_nesvnic->netdev_open == 1)
229 if (first_nesvnic->netdev_open == 0) {
230 nes_debug(NES_DBG_INIT, "Setting up MAC interrupt mask.\n");
231 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK + (0x200 * nesdev->mac_index),
232 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
233 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
234 first_nesvnic = nesvnic;
237 if (first_nesvnic->linkup) {
238 /* Enable network packets */
240 netif_start_queue(netdev);
241 netif_carrier_on(netdev);
244 spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
245 if (nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_SFP_D) {
246 nesdev->link_recheck = 1;
247 mod_delayed_work(system_wq, &nesdev->work,
248 NES_LINK_RECHECK_DELAY);
250 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
252 spin_lock_irqsave(&nesvnic->port_ibevent_lock, flags);
253 if (nesvnic->of_device_registered) {
254 nesdev->nesadapter->send_term_ok = 1;
255 if (nesvnic->linkup == 1) {
256 if (nesdev->iw_status == 0) {
257 nesdev->iw_status = 1;
258 nes_port_ibevent(nesvnic);
261 nesdev->iw_status = 0;
264 spin_unlock_irqrestore(&nesvnic->port_ibevent_lock, flags);
266 napi_enable(&nesvnic->napi);
267 nesvnic->netdev_open = 1;
276 static int nes_netdev_stop(struct net_device *netdev)
278 struct nes_vnic *nesvnic = netdev_priv(netdev);
279 struct nes_device *nesdev = nesvnic->nesdev;
282 struct nes_vnic *first_nesvnic = NULL;
283 struct list_head *list_pos, *list_temp;
286 nes_debug(NES_DBG_SHUTDOWN, "nesvnic=%p, nesdev=%p, netdev=%p %s\n",
287 nesvnic, nesdev, netdev, netdev->name);
288 if (nesvnic->netdev_open == 0)
291 if (netif_msg_ifdown(nesvnic))
292 printk(KERN_INFO PFX "%s: disabling interface\n", netdev->name);
293 netif_carrier_off(netdev);
295 /* Disable network packets */
296 napi_disable(&nesvnic->napi);
297 netif_stop_queue(netdev);
298 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
299 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
300 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic))
304 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic) &&
305 (PCI_FUNC(first_nesvnic->nesdev->pcidev->devfn) !=
306 PCI_FUNC(nesvnic->nesdev->pcidev->devfn))) {
307 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+
308 (0x200*nesdev->mac_index), 0xffffffff);
309 nes_write_indexed(first_nesvnic->nesdev,
310 NES_IDX_MAC_INT_MASK+
311 (0x200*first_nesvnic->nesdev->mac_index),
312 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
313 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
315 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+(0x200*nesdev->mac_index), 0xffffffff);
318 nic_active_mask = ~((u32)(1 << nesvnic->nic_index));
319 nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_HIGH+
320 (nesvnic->perfect_filter_index*8), 0);
321 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
322 nic_active &= nic_active_mask;
323 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
324 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
325 nic_active &= nic_active_mask;
326 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
327 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
328 nic_active &= nic_active_mask;
329 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
330 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
331 nic_active &= nic_active_mask;
332 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
333 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
334 nic_active &= nic_active_mask;
335 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
337 spin_lock_irqsave(&nesvnic->port_ibevent_lock, flags);
338 if (nesvnic->of_device_registered) {
339 nesdev->nesadapter->send_term_ok = 0;
340 nesdev->iw_status = 0;
341 if (nesvnic->linkup == 1)
342 nes_port_ibevent(nesvnic);
344 del_timer_sync(&nesvnic->event_timer);
345 nesvnic->event_timer.function = NULL;
346 spin_unlock_irqrestore(&nesvnic->port_ibevent_lock, flags);
348 nes_destroy_nic_qp(nesvnic);
350 nesvnic->netdev_open = 0;
359 static int nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
361 struct nes_vnic *nesvnic = netdev_priv(netdev);
362 struct nes_device *nesdev = nesvnic->nesdev;
363 struct nes_hw_nic *nesnic = &nesvnic->nic;
364 struct nes_hw_nic_sq_wqe *nic_sqe;
366 __le16 *wqe_fragment_length;
368 u16 wqe_fragment_index = 1; /* first fragment (0) is used by copy buffer */
369 u16 skb_fragment_index;
370 dma_addr_t bus_address;
372 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
373 wqe_fragment_length = (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
375 /* setup the VLAN tag if present */
376 if (vlan_tx_tag_present(skb)) {
377 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
378 netdev->name, vlan_tx_tag_get(skb));
379 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
380 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
384 /* bump past the vlan tag */
385 wqe_fragment_length++;
386 /* wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
387 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
389 if (skb->ip_summed == CHECKSUM_PARTIAL) {
390 if (skb_is_gso(skb)) {
392 /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... is_gso = %u seg size = %u\n",
393 netdev->name, skb_is_gso(skb), skb_shinfo(skb)->gso_size); */
394 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE | (u16)skb_shinfo(skb)->gso_size;
395 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
397 (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
399 } else { /* CHECKSUM_HW */
400 wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM;
403 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
405 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
406 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE), skb_headlen(skb)));
407 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
409 wqe_fragment_length[1] = 0;
410 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
411 if ((skb_shinfo(skb)->nr_frags + 1) > 4) {
412 nes_debug(NES_DBG_NIC_TX, "%s: Packet with %u fragments not sent, skb_headlen=%u\n",
413 netdev->name, skb_shinfo(skb)->nr_frags + 2, skb_headlen(skb));
415 nesvnic->tx_sw_dropped++;
416 return NETDEV_TX_LOCKED;
418 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
419 bus_address = pci_map_single(nesdev->pcidev, skb->data + NES_FIRST_FRAG_SIZE,
420 skb_headlen(skb) - NES_FIRST_FRAG_SIZE, PCI_DMA_TODEVICE);
421 wqe_fragment_length[wqe_fragment_index++] =
422 cpu_to_le16(skb_headlen(skb) - NES_FIRST_FRAG_SIZE);
423 wqe_fragment_length[wqe_fragment_index] = 0;
424 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
425 ((u64)(bus_address)));
426 nesnic->tx_skb[nesnic->sq_head] = skb;
429 if (skb_headlen(skb) == skb->len) {
430 if (skb_headlen(skb) <= NES_FIRST_FRAG_SIZE) {
431 nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_2_1_IDX] = 0;
432 nesnic->tx_skb[nesnic->sq_head] = skb;
435 /* Deal with Fragments */
436 nesnic->tx_skb[nesnic->sq_head] = skb;
437 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
438 skb_fragment_index++) {
440 &skb_shinfo(skb)->frags[skb_fragment_index];
441 bus_address = skb_frag_dma_map(&nesdev->pcidev->dev,
442 frag, 0, skb_frag_size(frag),
444 wqe_fragment_length[wqe_fragment_index] =
445 cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[skb_fragment_index]));
446 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
448 wqe_fragment_index++;
449 if (wqe_fragment_index < 5)
450 wqe_fragment_length[wqe_fragment_index] = 0;
454 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
456 nesnic->sq_head &= nesnic->sq_size - 1;
463 * nes_netdev_start_xmit
465 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
467 struct nes_vnic *nesvnic = netdev_priv(netdev);
468 struct nes_device *nesdev = nesvnic->nesdev;
469 struct nes_hw_nic *nesnic = &nesvnic->nic;
470 struct nes_hw_nic_sq_wqe *nic_sqe;
472 /* struct udphdr *udph; */
473 #define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
474 /* 64K segment plus overflow on each side */
475 dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
476 dma_addr_t bus_address;
484 __le16 *wqe_fragment_length;
486 u32 original_first_length;
487 /* u64 *wqe_fragment_address; */
488 /* first fragment (0) is used by copy buffer */
489 u16 wqe_fragment_index=1;
497 * nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
498 * " (%u frags), tso_size=%u\n",
499 * netdev->name, skb->len, skb_headlen(skb),
500 * skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
503 if (!netif_carrier_ok(netdev))
506 if (netif_queue_stopped(netdev))
507 return NETDEV_TX_BUSY;
509 /* Check if SQ is full */
510 if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
511 if (!netif_queue_stopped(netdev)) {
512 netif_stop_queue(netdev);
514 if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
515 netif_start_queue(netdev);
516 goto sq_no_longer_full;
520 return NETDEV_TX_BUSY;
524 nr_frags = skb_shinfo(skb)->nr_frags;
525 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
528 /* Check if too many fragments */
529 if (unlikely((nr_frags > 4))) {
530 if (skb_is_gso(skb)) {
531 nesvnic->segmented_tso_requests++;
532 nesvnic->tso_requests++;
533 /* Basically 4 fragments available per WQE with extended fragments */
534 wqes_needed = nr_frags >> 2;
535 wqes_needed += (nr_frags&3)?1:0;
536 wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
537 (nesnic->sq_size - 1);
539 if (unlikely(wqes_needed > wqes_available)) {
540 if (!netif_queue_stopped(netdev)) {
541 netif_stop_queue(netdev);
543 wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
544 (nesnic->sq_size - 1);
545 if (wqes_needed <= wqes_available) {
546 netif_start_queue(netdev);
547 goto tso_sq_no_longer_full;
551 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
553 return NETDEV_TX_BUSY;
555 tso_sq_no_longer_full:
556 /* Map all the buffers */
557 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
560 &skb_shinfo(skb)->frags[tso_frag_count];
561 tso_bus_address[tso_frag_count] =
562 skb_frag_dma_map(&nesdev->pcidev->dev,
563 frag, 0, skb_frag_size(frag),
568 curr_tcp_seq = ntohl(tcp_hdr(skb)->seq);
569 hoffset = skb_transport_header(skb) - skb->data;
570 nhoffset = skb_network_header(skb) - skb->data;
571 original_first_length = hoffset + ((((struct tcphdr *)skb_transport_header(skb))->doff)<<2);
573 for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
575 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
576 wqe_fragment_length =
577 (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
578 /* setup the VLAN tag if present */
579 if (vlan_tx_tag_present(skb)) {
580 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
581 netdev->name, vlan_tx_tag_get(skb) );
582 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
583 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
587 /* bump past the vlan tag */
588 wqe_fragment_length++;
590 /* Assumes header totally fits in allocated buffer and is in first fragment */
591 if (original_first_length > NES_FIRST_FRAG_SIZE) {
592 nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
593 original_first_length, NES_FIRST_FRAG_SIZE);
594 nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
595 " (%u frags), is_gso = %u tso_size=%u\n",
597 skb->len, skb_headlen(skb),
598 skb_shinfo(skb)->nr_frags, skb_is_gso(skb), skb_shinfo(skb)->gso_size);
600 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
601 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
602 original_first_length));
603 iph = (struct iphdr *)
604 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[nhoffset]);
605 tcph = (struct tcphdr *)
606 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[hoffset]);
607 if ((wqe_count+1)!=(u32)wqes_needed) {
616 tcph->seq = htonl(curr_tcp_seq);
617 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
618 original_first_length));
620 wqe_fragment_index = 1;
621 if ((wqe_count==0) && (skb_headlen(skb) > original_first_length)) {
622 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
623 bus_address = pci_map_single(nesdev->pcidev, skb->data + original_first_length,
624 skb_headlen(skb) - original_first_length, PCI_DMA_TODEVICE);
625 wqe_fragment_length[wqe_fragment_index++] =
626 cpu_to_le16(skb_headlen(skb) - original_first_length);
627 wqe_fragment_length[wqe_fragment_index] = 0;
628 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
630 tso_wqe_length += skb_headlen(skb) -
631 original_first_length;
633 while (wqe_fragment_index < 5) {
634 wqe_fragment_length[wqe_fragment_index] =
635 cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index]));
636 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
637 (u64)tso_bus_address[tso_frag_index]);
638 wqe_fragment_index++;
639 tso_wqe_length += skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index++]);
640 if (wqe_fragment_index < 5)
641 wqe_fragment_length[wqe_fragment_index] = 0;
642 if (tso_frag_index == tso_frag_count)
645 if ((wqe_count+1) == (u32)wqes_needed) {
646 nesnic->tx_skb[nesnic->sq_head] = skb;
648 nesnic->tx_skb[nesnic->sq_head] = NULL;
650 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_shinfo(skb)->gso_size;
651 if ((tso_wqe_length + original_first_length) > skb_shinfo(skb)->gso_size) {
652 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
654 iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
657 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
659 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
660 ((u32)tcph->doff) | (((u32)hoffset) << 4));
662 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
663 tso_wqe_length + original_first_length);
664 curr_tcp_seq += tso_wqe_length;
666 nesnic->sq_head &= nesnic->sq_size-1;
669 nesvnic->linearized_skbs++;
670 hoffset = skb_transport_header(skb) - skb->data;
671 nhoffset = skb_network_header(skb) - skb->data;
673 skb_set_transport_header(skb, hoffset);
674 skb_set_network_header(skb, nhoffset);
675 send_rc = nes_nic_send(skb, netdev);
676 if (send_rc != NETDEV_TX_OK)
680 send_rc = nes_nic_send(skb, netdev);
681 if (send_rc != NETDEV_TX_OK)
688 nes_write32(nesdev->regs+NES_WQE_ALLOC,
689 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
691 netdev->trans_start = jiffies;
698 * nes_netdev_get_stats
700 static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
702 struct nes_vnic *nesvnic = netdev_priv(netdev);
703 struct nes_device *nesdev = nesvnic->nesdev;
707 u32temp = nes_read_indexed(nesdev,
708 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD + (nesvnic->nic_index*0x200));
709 nesvnic->netstats.rx_dropped += u32temp;
710 nesvnic->endnode_nstat_rx_discard += u32temp;
712 u64temp = (u64)nes_read_indexed(nesdev,
713 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO + (nesvnic->nic_index*0x200));
714 u64temp += ((u64)nes_read_indexed(nesdev,
715 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
717 nesvnic->endnode_nstat_rx_octets += u64temp;
718 nesvnic->netstats.rx_bytes += u64temp;
720 u64temp = (u64)nes_read_indexed(nesdev,
721 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO + (nesvnic->nic_index*0x200));
722 u64temp += ((u64)nes_read_indexed(nesdev,
723 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
725 nesvnic->endnode_nstat_rx_frames += u64temp;
726 nesvnic->netstats.rx_packets += u64temp;
728 u64temp = (u64)nes_read_indexed(nesdev,
729 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO + (nesvnic->nic_index*0x200));
730 u64temp += ((u64)nes_read_indexed(nesdev,
731 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
733 nesvnic->endnode_nstat_tx_octets += u64temp;
734 nesvnic->netstats.tx_bytes += u64temp;
736 u64temp = (u64)nes_read_indexed(nesdev,
737 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO + (nesvnic->nic_index*0x200));
738 u64temp += ((u64)nes_read_indexed(nesdev,
739 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
741 nesvnic->endnode_nstat_tx_frames += u64temp;
742 nesvnic->netstats.tx_packets += u64temp;
744 u32temp = nes_read_indexed(nesdev,
745 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
746 nesvnic->netstats.rx_dropped += u32temp;
747 nesvnic->nesdev->mac_rx_errors += u32temp;
748 nesvnic->nesdev->mac_rx_short_frames += u32temp;
750 u32temp = nes_read_indexed(nesdev,
751 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
752 nesvnic->netstats.rx_dropped += u32temp;
753 nesvnic->nesdev->mac_rx_errors += u32temp;
754 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
756 u32temp = nes_read_indexed(nesdev,
757 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
758 nesvnic->netstats.rx_dropped += u32temp;
759 nesvnic->nesdev->mac_rx_errors += u32temp;
760 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
762 u32temp = nes_read_indexed(nesdev,
763 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
764 nesvnic->netstats.rx_dropped += u32temp;
765 nesvnic->nesdev->mac_rx_errors += u32temp;
766 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
768 u32temp = nes_read_indexed(nesdev,
769 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
770 nesvnic->netstats.rx_length_errors += u32temp;
771 nesvnic->nesdev->mac_rx_errors += u32temp;
773 u32temp = nes_read_indexed(nesdev,
774 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
775 nesvnic->nesdev->mac_rx_errors += u32temp;
776 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
777 nesvnic->netstats.rx_crc_errors += u32temp;
779 u32temp = nes_read_indexed(nesdev,
780 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
781 nesvnic->nesdev->mac_tx_errors += u32temp;
782 nesvnic->netstats.tx_errors += u32temp;
784 return &nesvnic->netstats;
789 * nes_netdev_tx_timeout
791 static void nes_netdev_tx_timeout(struct net_device *netdev)
793 struct nes_vnic *nesvnic = netdev_priv(netdev);
795 if (netif_msg_timer(nesvnic))
796 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
801 * nes_netdev_set_mac_address
803 static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
805 struct nes_vnic *nesvnic = netdev_priv(netdev);
806 struct nes_device *nesdev = nesvnic->nesdev;
807 struct sockaddr *mac_addr = p;
812 if (!is_valid_ether_addr(mac_addr->sa_data))
813 return -EADDRNOTAVAIL;
815 memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
816 printk(PFX "%s: Address length = %d, Address = %pM\n",
817 __func__, netdev->addr_len, mac_addr->sa_data);
818 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
819 macaddr_high += (u16)netdev->dev_addr[1];
820 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
821 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
822 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
823 macaddr_low += (u32)netdev->dev_addr[5];
825 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
826 if (nesvnic->qp_nic_index[i] == 0xf) {
829 nes_write_indexed(nesdev,
830 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
832 nes_write_indexed(nesdev,
833 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
834 (u32)macaddr_high | NES_MAC_ADDR_VALID |
835 ((((u32)nesvnic->nic_index) << 16)));
841 static void set_allmulti(struct nes_device *nesdev, u32 nic_active_bit)
845 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
846 nic_active |= nic_active_bit;
847 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
848 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
849 nic_active &= ~nic_active_bit;
850 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
853 #define get_addr(addrs, index) ((addrs) + (index) * ETH_ALEN)
856 * nes_netdev_set_multicast_list
858 static void nes_netdev_set_multicast_list(struct net_device *netdev)
860 struct nes_vnic *nesvnic = netdev_priv(netdev);
861 struct nes_device *nesdev = nesvnic->nesdev;
862 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
865 u32 perfect_filter_register_address;
870 int mc_nic_index = -1;
871 u8 pft_entries_preallocated = max(nesadapter->adapter_fcn_count *
872 nics_per_function, 4);
873 u8 max_pft_entries_avaiable = NES_PFT_SIZE - pft_entries_preallocated;
875 int mc_count = netdev_mc_count(netdev);
877 spin_lock_irqsave(&nesadapter->resource_lock, flags);
878 nic_active_bit = 1 << nesvnic->nic_index;
880 if (netdev->flags & IFF_PROMISC) {
881 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
882 nic_active |= nic_active_bit;
883 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
884 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
885 nic_active |= nic_active_bit;
886 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
888 } else if ((netdev->flags & IFF_ALLMULTI) ||
889 (nesvnic->nic_index > 3)) {
890 set_allmulti(nesdev, nic_active_bit);
893 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
894 nic_active &= ~nic_active_bit;
895 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
896 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
897 nic_active &= ~nic_active_bit;
898 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
901 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscuous = %d, All Multicast = %d.\n",
902 mc_count, !!(netdev->flags & IFF_PROMISC),
903 !!(netdev->flags & IFF_ALLMULTI));
907 struct netdev_hw_addr *ha;
909 addrs = kmalloc(ETH_ALEN * mc_count, GFP_ATOMIC);
911 set_allmulti(nesdev, nic_active_bit);
915 netdev_for_each_mc_addr(ha, netdev)
916 memcpy(get_addr(addrs, i++), ha->addr, ETH_ALEN);
918 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW +
919 pft_entries_preallocated * 0x8;
920 for (i = 0, mc_index = 0; mc_index < max_pft_entries_avaiable;
922 while (i < mc_count && nesvnic->mcrq_mcast_filter &&
923 ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
924 get_addr(addrs, i++))) == 0));
925 if (mc_nic_index < 0)
926 mc_nic_index = nesvnic->nic_index;
927 while (nesadapter->pft_mcast_map[mc_index] < 16 &&
928 nesadapter->pft_mcast_map[mc_index] !=
929 nesvnic->nic_index &&
930 mc_index < max_pft_entries_avaiable) {
931 nes_debug(NES_DBG_NIC_RX,
932 "mc_index=%d skipping nic_index=%d, "
933 "used for=%d \n", mc_index,
935 nesadapter->pft_mcast_map[mc_index]);
938 if (mc_index >= max_pft_entries_avaiable)
941 char *addr = get_addr(addrs, i++);
943 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
945 perfect_filter_register_address+(mc_index * 8),
947 macaddr_high = ((u16) addr[0]) << 8;
948 macaddr_high += (u16) addr[1];
949 macaddr_low = ((u32) addr[2]) << 24;
950 macaddr_low += ((u32) addr[3]) << 16;
951 macaddr_low += ((u32) addr[4]) << 8;
952 macaddr_low += (u32) addr[5];
953 nes_write_indexed(nesdev,
954 perfect_filter_register_address+(mc_index * 8),
956 nes_write_indexed(nesdev,
957 perfect_filter_register_address+4+(mc_index * 8),
958 (u32)macaddr_high | NES_MAC_ADDR_VALID |
959 ((((u32)(1<<mc_nic_index)) << 16)));
960 nesadapter->pft_mcast_map[mc_index] =
963 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
964 perfect_filter_register_address+(mc_index * 8));
965 nes_write_indexed(nesdev,
966 perfect_filter_register_address+4+(mc_index * 8),
968 nesadapter->pft_mcast_map[mc_index] = 255;
972 /* PFT is not large enough */
974 set_allmulti(nesdev, nic_active_bit);
978 spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
983 * nes_netdev_change_mtu
985 static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
987 struct nes_vnic *nesvnic = netdev_priv(netdev);
988 struct nes_device *nesdev = nesvnic->nesdev;
996 if ((new_mtu < ETH_ZLEN) || (new_mtu > max_mtu))
999 netdev->mtu = new_mtu;
1000 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
1002 if (netdev->mtu > 1500) {
1005 nes_nic_init_timer_defaults(nesdev, jumbomode);
1007 if (netif_running(netdev)) {
1008 nic_active_bit = 1 << nesvnic->nic_index;
1009 mc_all_active = nes_read_indexed(nesdev,
1010 NES_IDX_NIC_MULTICAST_ALL) & nic_active_bit;
1011 uc_all_active = nes_read_indexed(nesdev,
1012 NES_IDX_NIC_UNICAST_ALL) & nic_active_bit;
1014 nes_netdev_stop(netdev);
1015 nes_netdev_open(netdev);
1017 nic_active = nes_read_indexed(nesdev,
1018 NES_IDX_NIC_MULTICAST_ALL);
1019 nic_active |= mc_all_active;
1020 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL,
1023 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
1024 nic_active |= uc_all_active;
1025 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
1032 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
1033 "Link Change Interrupts",
1036 "Pause Frames Sent",
1037 "Pause Frames Received",
1038 "Internal Routing Errors",
1039 "SQ SW Dropped SKBs",
1041 "Segmented TSO Requests",
1044 "Rx Oversized Frames",
1049 "Endnode Rx Discards",
1050 "Endnode Rx Octets",
1051 "Endnode Rx Frames",
1052 "Endnode Tx Octets",
1053 "Endnode Tx Frames",
1057 "Retransmission Count",
1064 "ModifyQP Timeouts",
1070 "CM Packets Bounced",
1071 "CM Packets Created",
1073 "CM Packets Dropped",
1074 "CM Packets Retrans",
1075 "CM Listens Created",
1076 "CM Listens Destroyed",
1080 "CM Nodes Destroyed",
1082 "CM Resets Received",
1092 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1096 * nes_netdev_get_sset_count
1098 static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
1100 if (stringset == ETH_SS_STATS)
1101 return NES_ETHTOOL_STAT_COUNT;
1108 * nes_netdev_get_strings
1110 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1111 u8 *ethtool_strings)
1113 if (stringset == ETH_SS_STATS)
1114 memcpy(ethtool_strings,
1115 &nes_ethtool_stringset,
1116 sizeof(nes_ethtool_stringset));
1121 * nes_netdev_get_ethtool_stats
1124 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1125 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1128 struct nes_vnic *nesvnic = netdev_priv(netdev);
1129 struct nes_device *nesdev = nesvnic->nesdev;
1130 struct nes_adapter *nesadapter = nesdev->nesadapter;
1135 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1136 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1137 target_stat_values[++index] = nesvnic->linearized_skbs;
1138 target_stat_values[++index] = nesvnic->tso_requests;
1140 u32temp = nes_read_indexed(nesdev,
1141 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1142 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1143 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
1145 u32temp = nes_read_indexed(nesdev,
1146 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1147 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1149 u32temp = nes_read_indexed(nesdev,
1150 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1151 nesvnic->nesdev->port_rx_discards += u32temp;
1152 nesvnic->netstats.rx_dropped += u32temp;
1154 u32temp = nes_read_indexed(nesdev,
1155 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1156 nesvnic->nesdev->port_tx_discards += u32temp;
1157 nesvnic->netstats.tx_dropped += u32temp;
1159 u32temp = nes_read_indexed(nesdev,
1160 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1161 nesvnic->netstats.rx_dropped += u32temp;
1162 nesvnic->nesdev->mac_rx_errors += u32temp;
1163 nesvnic->nesdev->mac_rx_short_frames += u32temp;
1165 u32temp = nes_read_indexed(nesdev,
1166 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1167 nesvnic->netstats.rx_dropped += u32temp;
1168 nesvnic->nesdev->mac_rx_errors += u32temp;
1169 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
1171 u32temp = nes_read_indexed(nesdev,
1172 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1173 nesvnic->netstats.rx_dropped += u32temp;
1174 nesvnic->nesdev->mac_rx_errors += u32temp;
1175 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
1177 u32temp = nes_read_indexed(nesdev,
1178 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1179 nesvnic->netstats.rx_dropped += u32temp;
1180 nesvnic->nesdev->mac_rx_errors += u32temp;
1181 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
1183 u32temp = nes_read_indexed(nesdev,
1184 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1185 nesvnic->netstats.rx_length_errors += u32temp;
1186 nesvnic->nesdev->mac_rx_errors += u32temp;
1188 u32temp = nes_read_indexed(nesdev,
1189 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1190 nesvnic->nesdev->mac_rx_errors += u32temp;
1191 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
1192 nesvnic->netstats.rx_crc_errors += u32temp;
1194 u32temp = nes_read_indexed(nesdev,
1195 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
1196 nesvnic->nesdev->mac_tx_errors += u32temp;
1197 nesvnic->netstats.tx_errors += u32temp;
1199 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1200 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1203 u32temp = nes_read_indexed(nesdev,
1204 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1205 (nesvnic->qp_nic_index[nic_count]*0x200));
1206 nesvnic->netstats.rx_dropped += u32temp;
1207 nesvnic->endnode_nstat_rx_discard += u32temp;
1209 u64temp = (u64)nes_read_indexed(nesdev,
1210 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1211 (nesvnic->qp_nic_index[nic_count]*0x200));
1212 u64temp += ((u64)nes_read_indexed(nesdev,
1213 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1214 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1216 nesvnic->endnode_nstat_rx_octets += u64temp;
1217 nesvnic->netstats.rx_bytes += u64temp;
1219 u64temp = (u64)nes_read_indexed(nesdev,
1220 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1221 (nesvnic->qp_nic_index[nic_count]*0x200));
1222 u64temp += ((u64)nes_read_indexed(nesdev,
1223 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1224 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1226 nesvnic->endnode_nstat_rx_frames += u64temp;
1227 nesvnic->netstats.rx_packets += u64temp;
1229 u64temp = (u64)nes_read_indexed(nesdev,
1230 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1231 (nesvnic->qp_nic_index[nic_count]*0x200));
1232 u64temp += ((u64)nes_read_indexed(nesdev,
1233 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1234 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1236 nesvnic->endnode_nstat_tx_octets += u64temp;
1237 nesvnic->netstats.tx_bytes += u64temp;
1239 u64temp = (u64)nes_read_indexed(nesdev,
1240 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1241 (nesvnic->qp_nic_index[nic_count]*0x200));
1242 u64temp += ((u64)nes_read_indexed(nesdev,
1243 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1244 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1246 nesvnic->endnode_nstat_tx_frames += u64temp;
1247 nesvnic->netstats.tx_packets += u64temp;
1249 u32temp = nes_read_indexed(nesdev,
1250 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1251 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1254 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1255 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1256 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1257 target_stat_values[++index] = nesvnic->sq_full;
1258 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1259 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1260 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1261 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1262 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
1263 target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
1264 target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
1265 target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
1266 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1267 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1268 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1269 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1270 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
1271 target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
1272 target_stat_values[++index] = mh_detected;
1273 target_stat_values[++index] = mh_pauses_sent;
1274 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1275 target_stat_values[++index] = atomic_read(&cm_connects);
1276 target_stat_values[++index] = atomic_read(&cm_accepts);
1277 target_stat_values[++index] = atomic_read(&cm_disconnects);
1278 target_stat_values[++index] = atomic_read(&cm_connecteds);
1279 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1280 target_stat_values[++index] = atomic_read(&cm_rejects);
1281 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1282 target_stat_values[++index] = atomic_read(&qps_created);
1283 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1284 target_stat_values[++index] = atomic_read(&qps_destroyed);
1285 target_stat_values[++index] = atomic_read(&cm_closes);
1286 target_stat_values[++index] = cm_packets_sent;
1287 target_stat_values[++index] = cm_packets_bounced;
1288 target_stat_values[++index] = cm_packets_created;
1289 target_stat_values[++index] = cm_packets_received;
1290 target_stat_values[++index] = cm_packets_dropped;
1291 target_stat_values[++index] = cm_packets_retrans;
1292 target_stat_values[++index] = atomic_read(&cm_listens_created);
1293 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
1294 target_stat_values[++index] = cm_backlog_drops;
1295 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1296 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1297 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1298 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1299 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
1300 target_stat_values[++index] = nesadapter->free_4kpbl;
1301 target_stat_values[++index] = nesadapter->free_256pbl;
1302 target_stat_values[++index] = int_mod_timer_init;
1303 target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
1304 target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
1305 target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
1306 target_stat_values[++index] = atomic_read(&pau_qps_created);
1307 target_stat_values[++index] = atomic_read(&pau_qps_destroyed);
1311 * nes_netdev_get_drvinfo
1313 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1314 struct ethtool_drvinfo *drvinfo)
1316 struct nes_vnic *nesvnic = netdev_priv(netdev);
1317 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
1319 strcpy(drvinfo->driver, DRV_NAME);
1320 strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
1321 sprintf(drvinfo->fw_version, "%u.%u", nesadapter->firmware_version>>16,
1322 nesadapter->firmware_version & 0x000000ff);
1323 strcpy(drvinfo->version, DRV_VERSION);
1324 drvinfo->testinfo_len = 0;
1325 drvinfo->eedump_len = 0;
1326 drvinfo->regdump_len = 0;
1331 * nes_netdev_set_coalesce
1333 static int nes_netdev_set_coalesce(struct net_device *netdev,
1334 struct ethtool_coalesce *et_coalesce)
1336 struct nes_vnic *nesvnic = netdev_priv(netdev);
1337 struct nes_device *nesdev = nesvnic->nesdev;
1338 struct nes_adapter *nesadapter = nesdev->nesadapter;
1339 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1340 unsigned long flags;
1342 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1343 if (et_coalesce->rx_max_coalesced_frames_low) {
1344 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1346 if (et_coalesce->rx_max_coalesced_frames_irq) {
1347 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1349 if (et_coalesce->rx_max_coalesced_frames_high) {
1350 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1352 if (et_coalesce->rx_coalesce_usecs_low) {
1353 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1355 if (et_coalesce->rx_coalesce_usecs_high) {
1356 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1358 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1360 /* using this to drive total interrupt moderation */
1361 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1362 if (et_coalesce->use_adaptive_rx_coalesce) {
1363 nesadapter->et_use_adaptive_rx_coalesce = 1;
1364 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1365 nesadapter->et_rx_coalesce_usecs_irq = 0;
1366 if (et_coalesce->pkt_rate_low) {
1367 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1370 nesadapter->et_use_adaptive_rx_coalesce = 0;
1371 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1372 if (nesadapter->et_rx_coalesce_usecs_irq) {
1373 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1374 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1382 * nes_netdev_get_coalesce
1384 static int nes_netdev_get_coalesce(struct net_device *netdev,
1385 struct ethtool_coalesce *et_coalesce)
1387 struct nes_vnic *nesvnic = netdev_priv(netdev);
1388 struct nes_device *nesdev = nesvnic->nesdev;
1389 struct nes_adapter *nesadapter = nesdev->nesadapter;
1390 struct ethtool_coalesce temp_et_coalesce;
1391 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1392 unsigned long flags;
1394 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1395 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1396 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1397 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1398 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1399 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1400 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1401 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
1402 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1403 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1404 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1405 if (nesadapter->et_use_adaptive_rx_coalesce) {
1406 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1408 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1409 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1415 * nes_netdev_get_pauseparam
1417 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1418 struct ethtool_pauseparam *et_pauseparam)
1420 struct nes_vnic *nesvnic = netdev_priv(netdev);
1422 et_pauseparam->autoneg = 0;
1423 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1424 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1429 * nes_netdev_set_pauseparam
1431 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1432 struct ethtool_pauseparam *et_pauseparam)
1434 struct nes_vnic *nesvnic = netdev_priv(netdev);
1435 struct nes_device *nesdev = nesvnic->nesdev;
1438 if (et_pauseparam->autoneg) {
1439 /* TODO: should return unsupported */
1442 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1443 u32temp = nes_read_indexed(nesdev,
1444 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1445 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1446 nes_write_indexed(nesdev,
1447 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
1448 nesdev->disable_tx_flow_control = 0;
1449 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1450 u32temp = nes_read_indexed(nesdev,
1451 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1452 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1453 nes_write_indexed(nesdev,
1454 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
1455 nesdev->disable_tx_flow_control = 1;
1457 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1458 u32temp = nes_read_indexed(nesdev,
1459 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1460 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1461 nes_write_indexed(nesdev,
1462 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1463 nesdev->disable_rx_flow_control = 0;
1464 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1465 u32temp = nes_read_indexed(nesdev,
1466 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1467 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1468 nes_write_indexed(nesdev,
1469 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1470 nesdev->disable_rx_flow_control = 1;
1478 * nes_netdev_get_settings
1480 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1482 struct nes_vnic *nesvnic = netdev_priv(netdev);
1483 struct nes_device *nesdev = nesvnic->nesdev;
1484 struct nes_adapter *nesadapter = nesdev->nesadapter;
1485 u32 mac_index = nesdev->mac_index;
1486 u8 phy_type = nesadapter->phy_type[mac_index];
1487 u8 phy_index = nesadapter->phy_index[mac_index];
1490 et_cmd->duplex = DUPLEX_FULL;
1491 et_cmd->port = PORT_MII;
1492 et_cmd->maxtxpkt = 511;
1493 et_cmd->maxrxpkt = 511;
1495 if (nesadapter->OneG_Mode) {
1496 ethtool_cmd_speed_set(et_cmd, SPEED_1000);
1497 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
1498 et_cmd->supported = SUPPORTED_1000baseT_Full;
1499 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1500 et_cmd->autoneg = AUTONEG_DISABLE;
1501 et_cmd->transceiver = XCVR_INTERNAL;
1502 et_cmd->phy_address = mac_index;
1504 unsigned long flags;
1505 et_cmd->supported = SUPPORTED_1000baseT_Full
1506 | SUPPORTED_Autoneg;
1507 et_cmd->advertising = ADVERTISED_1000baseT_Full
1508 | ADVERTISED_Autoneg;
1509 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1510 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1511 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1512 if (phy_data & 0x1000)
1513 et_cmd->autoneg = AUTONEG_ENABLE;
1515 et_cmd->autoneg = AUTONEG_DISABLE;
1516 et_cmd->transceiver = XCVR_EXTERNAL;
1517 et_cmd->phy_address = phy_index;
1521 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1522 (phy_type == NES_PHY_TYPE_SFP_D) ||
1523 (phy_type == NES_PHY_TYPE_KR)) {
1524 et_cmd->transceiver = XCVR_EXTERNAL;
1525 et_cmd->port = PORT_FIBRE;
1526 et_cmd->supported = SUPPORTED_FIBRE;
1527 et_cmd->advertising = ADVERTISED_FIBRE;
1528 et_cmd->phy_address = phy_index;
1530 et_cmd->transceiver = XCVR_INTERNAL;
1531 et_cmd->supported = SUPPORTED_10000baseT_Full;
1532 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1533 et_cmd->phy_address = mac_index;
1535 ethtool_cmd_speed_set(et_cmd, SPEED_10000);
1536 et_cmd->autoneg = AUTONEG_DISABLE;
1542 * nes_netdev_set_settings
1544 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1546 struct nes_vnic *nesvnic = netdev_priv(netdev);
1547 struct nes_device *nesdev = nesvnic->nesdev;
1548 struct nes_adapter *nesadapter = nesdev->nesadapter;
1550 if ((nesadapter->OneG_Mode) &&
1551 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1552 unsigned long flags;
1554 u8 phy_index = nesadapter->phy_index[nesdev->mac_index];
1556 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1557 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1558 if (et_cmd->autoneg) {
1559 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1562 /* Turn off autoneg */
1563 phy_data &= ~0x1000;
1565 nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data);
1566 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1573 static const struct ethtool_ops nes_ethtool_ops = {
1574 .get_link = ethtool_op_get_link,
1575 .get_settings = nes_netdev_get_settings,
1576 .set_settings = nes_netdev_set_settings,
1577 .get_strings = nes_netdev_get_strings,
1578 .get_sset_count = nes_netdev_get_sset_count,
1579 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1580 .get_drvinfo = nes_netdev_get_drvinfo,
1581 .get_coalesce = nes_netdev_get_coalesce,
1582 .set_coalesce = nes_netdev_set_coalesce,
1583 .get_pauseparam = nes_netdev_get_pauseparam,
1584 .set_pauseparam = nes_netdev_set_pauseparam,
1587 static void nes_vlan_mode(struct net_device *netdev, struct nes_device *nesdev, netdev_features_t features)
1589 struct nes_adapter *nesadapter = nesdev->nesadapter;
1591 unsigned long flags;
1593 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1595 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1597 /* Enable/Disable VLAN Stripping */
1598 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1599 if (features & NETIF_F_HW_VLAN_RX)
1600 u32temp &= 0xfdffffff;
1602 u32temp |= 0x02000000;
1604 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1605 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1608 static netdev_features_t nes_fix_features(struct net_device *netdev, netdev_features_t features)
1611 * Since there is no support for separate rx/tx vlan accel
1612 * enable/disable make sure tx flag is always in same state as rx.
1614 if (features & NETIF_F_HW_VLAN_RX)
1615 features |= NETIF_F_HW_VLAN_TX;
1617 features &= ~NETIF_F_HW_VLAN_TX;
1622 static int nes_set_features(struct net_device *netdev, netdev_features_t features)
1624 struct nes_vnic *nesvnic = netdev_priv(netdev);
1625 struct nes_device *nesdev = nesvnic->nesdev;
1626 u32 changed = netdev->features ^ features;
1628 if (changed & NETIF_F_HW_VLAN_RX)
1629 nes_vlan_mode(netdev, nesdev, features);
1634 static const struct net_device_ops nes_netdev_ops = {
1635 .ndo_open = nes_netdev_open,
1636 .ndo_stop = nes_netdev_stop,
1637 .ndo_start_xmit = nes_netdev_start_xmit,
1638 .ndo_get_stats = nes_netdev_get_stats,
1639 .ndo_tx_timeout = nes_netdev_tx_timeout,
1640 .ndo_set_mac_address = nes_netdev_set_mac_address,
1641 .ndo_set_rx_mode = nes_netdev_set_multicast_list,
1642 .ndo_change_mtu = nes_netdev_change_mtu,
1643 .ndo_validate_addr = eth_validate_addr,
1644 .ndo_fix_features = nes_fix_features,
1645 .ndo_set_features = nes_set_features,
1649 * nes_netdev_init - initialize network device
1651 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1652 void __iomem *mmio_addr)
1655 struct nes_vnic *nesvnic;
1656 struct net_device *netdev;
1657 struct nic_qp_map *curr_qp_map;
1658 u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
1660 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1662 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1665 nesvnic = netdev_priv(netdev);
1667 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1669 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1671 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1672 netdev->irq = nesdev->pcidev->irq;
1673 netdev->mtu = ETH_DATA_LEN;
1674 netdev->hard_header_len = ETH_HLEN;
1675 netdev->addr_len = ETH_ALEN;
1676 netdev->type = ARPHRD_ETHER;
1677 netdev->netdev_ops = &nes_netdev_ops;
1678 netdev->ethtool_ops = &nes_ethtool_ops;
1679 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1680 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1682 /* Fill in the port structure */
1683 nesvnic->netdev = netdev;
1684 nesvnic->nesdev = nesdev;
1685 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1686 nesvnic->netdev_index = nesdev->netdev_count;
1687 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1688 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1690 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1691 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1692 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1693 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1695 /* Setup the burned in MAC address */
1696 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1697 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1698 u64temp += nesvnic->nic_index;
1699 netdev->dev_addr[0] = (u8)(u64temp>>40);
1700 netdev->dev_addr[1] = (u8)(u64temp>>32);
1701 netdev->dev_addr[2] = (u8)(u64temp>>24);
1702 netdev->dev_addr[3] = (u8)(u64temp>>16);
1703 netdev->dev_addr[4] = (u8)(u64temp>>8);
1704 netdev->dev_addr[5] = (u8)u64temp;
1705 memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1707 netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM | NETIF_F_HW_VLAN_RX;
1708 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV))
1709 netdev->hw_features |= NETIF_F_TSO;
1711 netdev->features = netdev->hw_features | NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_TX;
1712 netdev->hw_features |= NETIF_F_LRO;
1714 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1715 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1716 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1717 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1719 if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1720 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1722 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1723 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1724 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1725 nesvnic->qp_nic_index[2] = 0xf;
1726 nesvnic->qp_nic_index[3] = 0xf;
1728 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1729 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1732 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1733 (nesvnic->nesdev->nesadapter->port_count == 1 &&
1734 nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1735 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1736 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1738 nesvnic->qp_nic_index[2] = 0xf;
1739 nesvnic->qp_nic_index[3] = 0xf;
1741 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1742 nesvnic->qp_nic_index[1] = 0xf;
1743 nesvnic->qp_nic_index[2] = 0xf;
1744 nesvnic->qp_nic_index[3] = 0xf;
1747 nesvnic->next_qp_nic_index = 0;
1749 if (nesdev->netdev_count == 0) {
1750 nesvnic->rdma_enabled = 1;
1752 nesvnic->rdma_enabled = 0;
1754 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1755 init_timer(&nesvnic->event_timer);
1756 nesvnic->event_timer.function = NULL;
1757 spin_lock_init(&nesvnic->tx_lock);
1758 spin_lock_init(&nesvnic->port_ibevent_lock);
1759 nesdev->netdev[nesdev->netdev_count] = netdev;
1761 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1762 nesvnic, nesdev->mac_index);
1763 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1765 if ((nesdev->netdev_count == 0) &&
1766 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1767 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
1768 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1769 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1775 unsigned long flags;
1777 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1778 (0x200 * (nesdev->mac_index & 1)));
1779 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
1780 u32temp |= 0x00200000;
1781 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1782 (0x200 * (nesdev->mac_index & 1)), u32temp);
1785 /* Check and set linkup here. This is for back to back */
1786 /* configuration where second port won't get link interrupt */
1788 case NES_PHY_TYPE_PUMA_1G:
1789 if (nesdev->mac_index < 2) {
1790 link_mask = 0x01010000;
1791 link_val = 0x01010000;
1793 link_mask = 0x02020000;
1794 link_val = 0x02020000;
1797 case NES_PHY_TYPE_SFP_D:
1798 spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
1799 nes_read_10G_phy_reg(nesdev,
1800 nesdev->nesadapter->phy_index[nesdev->mac_index],
1802 temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1803 nes_read_10G_phy_reg(nesdev,
1804 nesdev->nesadapter->phy_index[nesdev->mac_index],
1806 nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1807 nes_read_10G_phy_reg(nesdev,
1808 nesdev->nesadapter->phy_index[nesdev->mac_index],
1810 phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1811 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
1812 phy_data = (!temp_phy_data && (phy_data == 0x8000)) ? 0x4 : 0x0;
1815 link_mask = 0x0f1f0000;
1816 link_val = 0x0f0f0000;
1820 u32temp = nes_read_indexed(nesdev,
1821 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1822 (0x200 * (nesdev->mac_index & 1)));
1824 if (phy_type == NES_PHY_TYPE_SFP_D) {
1825 if (phy_data & 0x0004)
1826 nesvnic->linkup = 1;
1828 if ((u32temp & link_mask) == link_val)
1829 nesvnic->linkup = 1;
1832 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1833 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1834 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1835 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1837 nes_init_phy(nesdev);
1840 nes_vlan_mode(netdev, nesdev, netdev->features);
1847 * nes_netdev_destroy - destroy network device structure
1849 void nes_netdev_destroy(struct net_device *netdev)
1851 struct nes_vnic *nesvnic = netdev_priv(netdev);
1853 /* make sure 'stop' method is called by Linux stack */
1854 /* nes_netdev_stop(netdev); */
1856 list_del(&nesvnic->list);
1858 if (nesvnic->of_device_registered) {
1859 nes_destroy_ofa_device(nesvnic->nesibdev);
1862 free_netdev(netdev);
1867 * nes_nic_cm_xmit -- CM calls this to send out pkts
1869 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1874 ret = dev_queue_xmit(skb);
1876 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);