2 * Copyright (c) 2006 - 2009 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>
45 #include <net/inet_common.h>
46 #include <linux/inet.h>
50 static struct nic_qp_map nic_qp_mapping_0[] = {
51 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
52 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
53 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
54 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
57 static struct nic_qp_map nic_qp_mapping_1[] = {
58 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
59 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
62 static struct nic_qp_map nic_qp_mapping_2[] = {
63 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
66 static struct nic_qp_map nic_qp_mapping_3[] = {
67 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
70 static struct nic_qp_map nic_qp_mapping_4[] = {
71 {28,8,0,0},{32,12,0,0}
74 static struct nic_qp_map nic_qp_mapping_5[] = {
75 {29,9,1,0},{33,13,1,0}
78 static struct nic_qp_map nic_qp_mapping_6[] = {
79 {30,10,2,0},{34,14,2,0}
82 static struct nic_qp_map nic_qp_mapping_7[] = {
83 {31,11,3,0},{35,15,3,0}
86 static struct nic_qp_map *nic_qp_mapping_per_function[] = {
87 nic_qp_mapping_0, nic_qp_mapping_1, nic_qp_mapping_2, nic_qp_mapping_3,
88 nic_qp_mapping_4, nic_qp_mapping_5, nic_qp_mapping_6, nic_qp_mapping_7
91 static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
92 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
93 static int debug = -1;
94 static int nics_per_function = 1;
99 static int nes_netdev_poll(struct napi_struct *napi, int budget)
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;
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;
111 nes_nic_ce_handler(nesdev, nescq);
113 if (nescq->cqes_pending == 0) {
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);
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);
126 return nescq->rx_pkts_indicated;
131 * nes_netdev_open - Activate the network interface; ifconfig
134 static int nes_netdev_open(struct net_device *netdev)
138 struct nes_vnic *nesvnic = netdev_priv(netdev);
139 struct nes_device *nesdev = nesvnic->nesdev;
142 struct nes_vnic *first_nesvnic = NULL;
145 struct list_head *list_pos, *list_temp;
147 assert(nesdev != NULL);
149 if (nesvnic->netdev_open == 1)
152 if (netif_msg_ifup(nesvnic))
153 printk(KERN_INFO PFX "%s: enabling interface\n", netdev->name);
155 ret = nes_init_nic_qp(nesdev, netdev);
160 netif_carrier_off(netdev);
161 netif_stop_queue(netdev);
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);
168 nesvnic->nesibdev->nesvnic = nesvnic;
169 ret = nes_register_ofa_device(nesvnic->nesibdev);
171 printk(KERN_ERR PFX "%s: Unable to register RDMA device, ret = %d\n",
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);
188 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
189 macaddr_high += (u16)netdev->dev_addr[1];
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];
196 /* Program the various MAC regs */
197 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
198 if (nesvnic->qp_nic_index[i] == 0xf) {
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),
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),
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)));
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)
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;
234 if (first_nesvnic->linkup) {
235 /* Enable network packets */
237 netif_start_queue(netdev);
238 netif_carrier_on(netdev);
240 napi_enable(&nesvnic->napi);
241 nesvnic->netdev_open = 1;
250 static int nes_netdev_stop(struct net_device *netdev)
252 struct nes_vnic *nesvnic = netdev_priv(netdev);
253 struct nes_device *nesdev = nesvnic->nesdev;
256 struct nes_vnic *first_nesvnic = NULL;
257 struct list_head *list_pos, *list_temp;
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)
264 if (netif_msg_ifdown(nesvnic))
265 printk(KERN_INFO PFX "%s: disabling interface\n", netdev->name);
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))
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));
287 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+(0x200*nesdev->mac_index), 0xffffffff);
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);
310 if (nesvnic->of_device_registered) {
311 nes_destroy_ofa_device(nesvnic->nesibdev);
312 nesvnic->nesibdev = NULL;
313 nesvnic->of_device_registered = 0;
315 nes_destroy_nic_qp(nesvnic);
317 nesvnic->netdev_open = 0;
326 static int nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
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;
333 __le16 *wqe_fragment_length;
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;
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];
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);
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]; */
355 if (skb->ip_summed == CHECKSUM_PARTIAL) {
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,
365 (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
367 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
370 } else { /* CHECKSUM_HW */
371 wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM | NES_NIC_SQ_WQE_COMPLETION;
374 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
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),
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));
386 nesvnic->tx_sw_dropped++;
387 return NETDEV_TX_LOCKED;
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;
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;
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,
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),
419 wqe_fragment_index++;
420 if (wqe_fragment_index < 5)
421 wqe_fragment_length[wqe_fragment_index] = 0;
425 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
427 nesnic->sq_head &= nesnic->sq_size - 1;
434 * nes_netdev_start_xmit
436 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
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;
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;
455 __le16 *wqe_fragment_length;
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;
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));
475 if (!netif_carrier_ok(netdev))
478 if (netif_queue_stopped(netdev))
479 return NETDEV_TX_BUSY;
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);
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;
492 return NETDEV_TX_BUSY;
496 nr_frags = skb_shinfo(skb)->nr_frags;
497 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
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);
512 if (unlikely(wqes_needed > wqes_available)) {
513 if (!netif_queue_stopped(netdev)) {
514 netif_stop_queue(netdev);
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;
524 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
526 return NETDEV_TX_BUSY;
528 tso_sq_no_longer_full:
529 /* Map all the buffers */
530 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
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,
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);
545 for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
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);
559 /* bump past the vlan tag */
560 wqe_fragment_length++;
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",
569 skb->len, skb_headlen(skb),
570 skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
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) {
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));
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,
602 tso_wqe_length += skb_headlen(skb) -
603 original_first_length;
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)
617 if ((wqe_count+1) == (u32)wqes_needed) {
618 nesnic->tx_skb[nesnic->sq_head] = skb;
620 nesnic->tx_skb[nesnic->sq_head] = NULL;
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;
626 iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
629 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
631 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
632 ((u32)tcph->doff) | (((u32)hoffset) << 4));
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;
638 nesnic->sq_head &= nesnic->sq_size-1;
641 nesvnic->linearized_skbs++;
642 hoffset = skb_transport_header(skb) - skb->data;
643 nhoffset = skb_network_header(skb) - skb->data;
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)
652 send_rc = nes_nic_send(skb, netdev);
653 if (send_rc != NETDEV_TX_OK)
660 nes_write32(nesdev->regs+NES_WQE_ALLOC,
661 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
663 netdev->trans_start = jiffies;
670 * nes_netdev_get_stats
672 static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
674 struct nes_vnic *nesvnic = netdev_priv(netdev);
675 struct nes_device *nesdev = nesvnic->nesdev;
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;
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;
689 nesvnic->endnode_nstat_rx_octets += u64temp;
690 nesvnic->netstats.rx_bytes += u64temp;
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;
697 nesvnic->endnode_nstat_rx_frames += u64temp;
698 nesvnic->netstats.rx_packets += u64temp;
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;
705 nesvnic->endnode_nstat_tx_octets += u64temp;
706 nesvnic->netstats.tx_bytes += u64temp;
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;
713 nesvnic->endnode_nstat_tx_frames += u64temp;
714 nesvnic->netstats.tx_packets += u64temp;
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;
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;
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;
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;
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;
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;
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;
756 return &nesvnic->netstats;
761 * nes_netdev_tx_timeout
763 static void nes_netdev_tx_timeout(struct net_device *netdev)
765 struct nes_vnic *nesvnic = netdev_priv(netdev);
767 if (netif_msg_timer(nesvnic))
768 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
773 * nes_netdev_set_mac_address
775 static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
777 struct nes_vnic *nesvnic = netdev_priv(netdev);
778 struct nes_device *nesdev = nesvnic->nesdev;
779 struct sockaddr *mac_addr = p;
784 if (!is_valid_ether_addr(mac_addr->sa_data))
785 return -EADDRNOTAVAIL;
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];
797 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
798 if (nesvnic->qp_nic_index[i] == 0xf) {
801 nes_write_indexed(nesdev,
802 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
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)));
813 static void set_allmulti(struct nes_device *nesdev, u32 nic_active_bit)
817 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
818 nic_active |= nic_active_bit;
819 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
820 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
821 nic_active &= ~nic_active_bit;
822 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
825 #define get_addr(addrs, index) ((addrs) + (index) * ETH_ALEN)
828 * nes_netdev_set_multicast_list
830 static void nes_netdev_set_multicast_list(struct net_device *netdev)
832 struct nes_vnic *nesvnic = netdev_priv(netdev);
833 struct nes_device *nesdev = nesvnic->nesdev;
834 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
837 u32 perfect_filter_register_address;
842 int mc_nic_index = -1;
843 u8 pft_entries_preallocated = max(nesadapter->adapter_fcn_count *
844 nics_per_function, 4);
845 u8 max_pft_entries_avaiable = NES_PFT_SIZE - pft_entries_preallocated;
847 int mc_count = netdev_mc_count(netdev);
849 spin_lock_irqsave(&nesadapter->resource_lock, flags);
850 nic_active_bit = 1 << nesvnic->nic_index;
852 if (netdev->flags & IFF_PROMISC) {
853 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
854 nic_active |= nic_active_bit;
855 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
856 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
857 nic_active |= nic_active_bit;
858 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
860 } else if ((netdev->flags & IFF_ALLMULTI) ||
861 (nesvnic->nic_index > 3)) {
862 set_allmulti(nesdev, nic_active_bit);
865 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
866 nic_active &= ~nic_active_bit;
867 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
868 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
869 nic_active &= ~nic_active_bit;
870 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
873 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscous = %d, All Multicast = %d.\n",
874 mc_count, !!(netdev->flags & IFF_PROMISC),
875 !!(netdev->flags & IFF_ALLMULTI));
879 struct dev_mc_list *mcaddr;
881 addrs = kmalloc(ETH_ALEN * mc_count, GFP_ATOMIC);
883 set_allmulti(nesdev, nic_active_bit);
887 netdev_for_each_mc_addr(mcaddr, netdev)
888 memcpy(get_addr(addrs, i++),
889 mcaddr->dmi_addr, ETH_ALEN);
891 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW +
892 pft_entries_preallocated * 0x8;
893 for (i = 0, mc_index = 0; mc_index < max_pft_entries_avaiable;
895 while (i < mc_count && nesvnic->mcrq_mcast_filter &&
896 ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
897 get_addr(addrs, i++))) == 0));
898 if (mc_nic_index < 0)
899 mc_nic_index = nesvnic->nic_index;
900 while (nesadapter->pft_mcast_map[mc_index] < 16 &&
901 nesadapter->pft_mcast_map[mc_index] !=
902 nesvnic->nic_index &&
903 mc_index < max_pft_entries_avaiable) {
904 nes_debug(NES_DBG_NIC_RX,
905 "mc_index=%d skipping nic_index=%d,\
906 used for=%d \n", mc_index,
908 nesadapter->pft_mcast_map[mc_index]);
911 if (mc_index >= max_pft_entries_avaiable)
914 char *addr = get_addr(addrs, i++);
916 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
918 perfect_filter_register_address+(mc_index * 8),
920 macaddr_high = ((u16) addr[0]) << 8;
921 macaddr_high += (u16) addr[1];
922 macaddr_low = ((u32) addr[2]) << 24;
923 macaddr_low += ((u32) addr[3]) << 16;
924 macaddr_low += ((u32) addr[4]) << 8;
925 macaddr_low += (u32) addr[5];
926 nes_write_indexed(nesdev,
927 perfect_filter_register_address+(mc_index * 8),
929 nes_write_indexed(nesdev,
930 perfect_filter_register_address+4+(mc_index * 8),
931 (u32)macaddr_high | NES_MAC_ADDR_VALID |
932 ((((u32)(1<<mc_nic_index)) << 16)));
933 nesadapter->pft_mcast_map[mc_index] =
936 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
937 perfect_filter_register_address+(mc_index * 8));
938 nes_write_indexed(nesdev,
939 perfect_filter_register_address+4+(mc_index * 8),
941 nesadapter->pft_mcast_map[mc_index] = 255;
945 /* PFT is not large enough */
947 set_allmulti(nesdev, nic_active_bit);
951 spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
956 * nes_netdev_change_mtu
958 static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
960 struct nes_vnic *nesvnic = netdev_priv(netdev);
961 struct nes_device *nesdev = nesvnic->nesdev;
969 if ((new_mtu < ETH_ZLEN) || (new_mtu > max_mtu))
972 netdev->mtu = new_mtu;
973 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
975 if (netdev->mtu > 1500) {
978 nes_nic_init_timer_defaults(nesdev, jumbomode);
980 if (netif_running(netdev)) {
981 nic_active_bit = 1 << nesvnic->nic_index;
982 mc_all_active = nes_read_indexed(nesdev,
983 NES_IDX_NIC_MULTICAST_ALL) & nic_active_bit;
984 uc_all_active = nes_read_indexed(nesdev,
985 NES_IDX_NIC_UNICAST_ALL) & nic_active_bit;
987 nes_netdev_stop(netdev);
988 nes_netdev_open(netdev);
990 nic_active = nes_read_indexed(nesdev,
991 NES_IDX_NIC_MULTICAST_ALL);
992 nic_active |= mc_all_active;
993 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL,
996 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
997 nic_active |= uc_all_active;
998 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
1004 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
1005 "Link Change Interrupts",
1008 "Pause Frames Sent",
1009 "Pause Frames Received",
1010 "Internal Routing Errors",
1011 "SQ SW Dropped SKBs",
1013 "Segmented TSO Requests",
1016 "Rx Oversized Frames",
1018 "Endnode Rx Discards",
1019 "Endnode Rx Octets",
1020 "Endnode Rx Frames",
1021 "Endnode Tx Octets",
1022 "Endnode Tx Frames",
1025 "Retransmission Count",
1032 "ModifyQP Timeouts",
1038 "CM Packets Bounced",
1039 "CM Packets Created",
1041 "CM Packets Dropped",
1042 "CM Packets Retrans",
1043 "CM Listens Created",
1044 "CM Listens Destroyed",
1048 "CM Nodes Destroyed",
1050 "CM Resets Received",
1064 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1067 * nes_netdev_get_rx_csum
1069 static u32 nes_netdev_get_rx_csum (struct net_device *netdev)
1071 struct nes_vnic *nesvnic = netdev_priv(netdev);
1073 if (nesvnic->rx_checksum_disabled)
1081 * nes_netdev_set_rc_csum
1083 static int nes_netdev_set_rx_csum(struct net_device *netdev, u32 enable)
1085 struct nes_vnic *nesvnic = netdev_priv(netdev);
1088 nesvnic->rx_checksum_disabled = 0;
1090 nesvnic->rx_checksum_disabled = 1;
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
1123 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1124 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1127 struct nes_vnic *nesvnic = netdev_priv(netdev);
1128 struct nes_device *nesdev = nesvnic->nesdev;
1133 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1134 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1135 target_stat_values[++index] = nesvnic->linearized_skbs;
1136 target_stat_values[++index] = nesvnic->tso_requests;
1138 u32temp = nes_read_indexed(nesdev,
1139 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1140 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1141 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
1143 u32temp = nes_read_indexed(nesdev,
1144 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1145 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1147 u32temp = nes_read_indexed(nesdev,
1148 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1149 nesvnic->nesdev->port_rx_discards += u32temp;
1150 nesvnic->netstats.rx_dropped += u32temp;
1152 u32temp = nes_read_indexed(nesdev,
1153 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1154 nesvnic->nesdev->port_tx_discards += u32temp;
1155 nesvnic->netstats.tx_dropped += u32temp;
1157 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1158 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1161 u32temp = nes_read_indexed(nesdev,
1162 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1163 (nesvnic->qp_nic_index[nic_count]*0x200));
1164 nesvnic->netstats.rx_dropped += u32temp;
1165 nesvnic->endnode_nstat_rx_discard += u32temp;
1167 u64temp = (u64)nes_read_indexed(nesdev,
1168 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1169 (nesvnic->qp_nic_index[nic_count]*0x200));
1170 u64temp += ((u64)nes_read_indexed(nesdev,
1171 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1172 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1174 nesvnic->endnode_nstat_rx_octets += u64temp;
1175 nesvnic->netstats.rx_bytes += u64temp;
1177 u64temp = (u64)nes_read_indexed(nesdev,
1178 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1179 (nesvnic->qp_nic_index[nic_count]*0x200));
1180 u64temp += ((u64)nes_read_indexed(nesdev,
1181 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1182 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1184 nesvnic->endnode_nstat_rx_frames += u64temp;
1185 nesvnic->netstats.rx_packets += u64temp;
1187 u64temp = (u64)nes_read_indexed(nesdev,
1188 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1189 (nesvnic->qp_nic_index[nic_count]*0x200));
1190 u64temp += ((u64)nes_read_indexed(nesdev,
1191 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1192 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1194 nesvnic->endnode_nstat_tx_octets += u64temp;
1195 nesvnic->netstats.tx_bytes += u64temp;
1197 u64temp = (u64)nes_read_indexed(nesdev,
1198 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1199 (nesvnic->qp_nic_index[nic_count]*0x200));
1200 u64temp += ((u64)nes_read_indexed(nesdev,
1201 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1202 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1204 nesvnic->endnode_nstat_tx_frames += u64temp;
1205 nesvnic->netstats.tx_packets += u64temp;
1207 u32temp = nes_read_indexed(nesdev,
1208 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1209 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1212 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1213 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1214 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1215 target_stat_values[++index] = nesvnic->sq_full;
1216 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1217 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1218 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1219 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1220 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
1221 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1222 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1223 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1224 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1225 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
1226 target_stat_values[++index] = mh_detected;
1227 target_stat_values[++index] = mh_pauses_sent;
1228 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1229 target_stat_values[++index] = atomic_read(&cm_connects);
1230 target_stat_values[++index] = atomic_read(&cm_accepts);
1231 target_stat_values[++index] = atomic_read(&cm_disconnects);
1232 target_stat_values[++index] = atomic_read(&cm_connecteds);
1233 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1234 target_stat_values[++index] = atomic_read(&cm_rejects);
1235 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1236 target_stat_values[++index] = atomic_read(&qps_created);
1237 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1238 target_stat_values[++index] = atomic_read(&qps_destroyed);
1239 target_stat_values[++index] = atomic_read(&cm_closes);
1240 target_stat_values[++index] = cm_packets_sent;
1241 target_stat_values[++index] = cm_packets_bounced;
1242 target_stat_values[++index] = cm_packets_created;
1243 target_stat_values[++index] = cm_packets_received;
1244 target_stat_values[++index] = cm_packets_dropped;
1245 target_stat_values[++index] = cm_packets_retrans;
1246 target_stat_values[++index] = atomic_read(&cm_listens_created);
1247 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
1248 target_stat_values[++index] = cm_backlog_drops;
1249 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1250 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1251 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1252 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1253 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
1254 target_stat_values[++index] = int_mod_timer_init;
1255 target_stat_values[++index] = int_mod_cq_depth_1;
1256 target_stat_values[++index] = int_mod_cq_depth_4;
1257 target_stat_values[++index] = int_mod_cq_depth_16;
1258 target_stat_values[++index] = int_mod_cq_depth_24;
1259 target_stat_values[++index] = int_mod_cq_depth_32;
1260 target_stat_values[++index] = int_mod_cq_depth_128;
1261 target_stat_values[++index] = int_mod_cq_depth_256;
1262 target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
1263 target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
1264 target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
1270 * nes_netdev_get_drvinfo
1272 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1273 struct ethtool_drvinfo *drvinfo)
1275 struct nes_vnic *nesvnic = netdev_priv(netdev);
1276 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
1278 strcpy(drvinfo->driver, DRV_NAME);
1279 strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
1280 sprintf(drvinfo->fw_version, "%u.%u", nesadapter->firmware_version>>16,
1281 nesadapter->firmware_version & 0x000000ff);
1282 strcpy(drvinfo->version, DRV_VERSION);
1283 drvinfo->testinfo_len = 0;
1284 drvinfo->eedump_len = 0;
1285 drvinfo->regdump_len = 0;
1290 * nes_netdev_set_coalesce
1292 static int nes_netdev_set_coalesce(struct net_device *netdev,
1293 struct ethtool_coalesce *et_coalesce)
1295 struct nes_vnic *nesvnic = netdev_priv(netdev);
1296 struct nes_device *nesdev = nesvnic->nesdev;
1297 struct nes_adapter *nesadapter = nesdev->nesadapter;
1298 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1299 unsigned long flags;
1301 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1302 if (et_coalesce->rx_max_coalesced_frames_low) {
1303 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1305 if (et_coalesce->rx_max_coalesced_frames_irq) {
1306 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1308 if (et_coalesce->rx_max_coalesced_frames_high) {
1309 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1311 if (et_coalesce->rx_coalesce_usecs_low) {
1312 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1314 if (et_coalesce->rx_coalesce_usecs_high) {
1315 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1317 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1319 /* using this to drive total interrupt moderation */
1320 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1321 if (et_coalesce->use_adaptive_rx_coalesce) {
1322 nesadapter->et_use_adaptive_rx_coalesce = 1;
1323 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1324 nesadapter->et_rx_coalesce_usecs_irq = 0;
1325 if (et_coalesce->pkt_rate_low) {
1326 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1329 nesadapter->et_use_adaptive_rx_coalesce = 0;
1330 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1331 if (nesadapter->et_rx_coalesce_usecs_irq) {
1332 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1333 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1341 * nes_netdev_get_coalesce
1343 static int nes_netdev_get_coalesce(struct net_device *netdev,
1344 struct ethtool_coalesce *et_coalesce)
1346 struct nes_vnic *nesvnic = netdev_priv(netdev);
1347 struct nes_device *nesdev = nesvnic->nesdev;
1348 struct nes_adapter *nesadapter = nesdev->nesadapter;
1349 struct ethtool_coalesce temp_et_coalesce;
1350 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1351 unsigned long flags;
1353 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1354 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1355 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1356 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1357 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1358 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1359 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1360 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
1361 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1362 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1363 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1364 if (nesadapter->et_use_adaptive_rx_coalesce) {
1365 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1367 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1368 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1374 * nes_netdev_get_pauseparam
1376 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1377 struct ethtool_pauseparam *et_pauseparam)
1379 struct nes_vnic *nesvnic = netdev_priv(netdev);
1381 et_pauseparam->autoneg = 0;
1382 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1383 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1388 * nes_netdev_set_pauseparam
1390 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1391 struct ethtool_pauseparam *et_pauseparam)
1393 struct nes_vnic *nesvnic = netdev_priv(netdev);
1394 struct nes_device *nesdev = nesvnic->nesdev;
1397 if (et_pauseparam->autoneg) {
1398 /* TODO: should return unsupported */
1401 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1402 u32temp = nes_read_indexed(nesdev,
1403 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1404 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1405 nes_write_indexed(nesdev,
1406 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1407 nesdev->disable_tx_flow_control = 0;
1408 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1409 u32temp = nes_read_indexed(nesdev,
1410 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1411 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1412 nes_write_indexed(nesdev,
1413 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1414 nesdev->disable_tx_flow_control = 1;
1416 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1417 u32temp = nes_read_indexed(nesdev,
1418 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1419 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1420 nes_write_indexed(nesdev,
1421 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1422 nesdev->disable_rx_flow_control = 0;
1423 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1424 u32temp = nes_read_indexed(nesdev,
1425 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1426 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1427 nes_write_indexed(nesdev,
1428 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1429 nesdev->disable_rx_flow_control = 1;
1437 * nes_netdev_get_settings
1439 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1441 struct nes_vnic *nesvnic = netdev_priv(netdev);
1442 struct nes_device *nesdev = nesvnic->nesdev;
1443 struct nes_adapter *nesadapter = nesdev->nesadapter;
1444 u32 mac_index = nesdev->mac_index;
1445 u8 phy_type = nesadapter->phy_type[mac_index];
1446 u8 phy_index = nesadapter->phy_index[mac_index];
1449 et_cmd->duplex = DUPLEX_FULL;
1450 et_cmd->port = PORT_MII;
1451 et_cmd->maxtxpkt = 511;
1452 et_cmd->maxrxpkt = 511;
1454 if (nesadapter->OneG_Mode) {
1455 et_cmd->speed = SPEED_1000;
1456 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
1457 et_cmd->supported = SUPPORTED_1000baseT_Full;
1458 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1459 et_cmd->autoneg = AUTONEG_DISABLE;
1460 et_cmd->transceiver = XCVR_INTERNAL;
1461 et_cmd->phy_address = mac_index;
1463 et_cmd->supported = SUPPORTED_1000baseT_Full
1464 | SUPPORTED_Autoneg;
1465 et_cmd->advertising = ADVERTISED_1000baseT_Full
1466 | ADVERTISED_Autoneg;
1467 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1468 if (phy_data & 0x1000)
1469 et_cmd->autoneg = AUTONEG_ENABLE;
1471 et_cmd->autoneg = AUTONEG_DISABLE;
1472 et_cmd->transceiver = XCVR_EXTERNAL;
1473 et_cmd->phy_address = phy_index;
1477 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1478 (phy_type == NES_PHY_TYPE_SFP_D) ||
1479 (phy_type == NES_PHY_TYPE_KR)) {
1480 et_cmd->transceiver = XCVR_EXTERNAL;
1481 et_cmd->port = PORT_FIBRE;
1482 et_cmd->supported = SUPPORTED_FIBRE;
1483 et_cmd->advertising = ADVERTISED_FIBRE;
1484 et_cmd->phy_address = phy_index;
1486 et_cmd->transceiver = XCVR_INTERNAL;
1487 et_cmd->supported = SUPPORTED_10000baseT_Full;
1488 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1489 et_cmd->phy_address = mac_index;
1491 et_cmd->speed = SPEED_10000;
1492 et_cmd->autoneg = AUTONEG_DISABLE;
1498 * nes_netdev_set_settings
1500 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1502 struct nes_vnic *nesvnic = netdev_priv(netdev);
1503 struct nes_device *nesdev = nesvnic->nesdev;
1504 struct nes_adapter *nesadapter = nesdev->nesadapter;
1507 if ((nesadapter->OneG_Mode) &&
1508 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1509 nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1511 if (et_cmd->autoneg) {
1512 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1515 /* Turn off autoneg */
1516 phy_data &= ~0x1000;
1518 nes_write_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1526 static const struct ethtool_ops nes_ethtool_ops = {
1527 .get_link = ethtool_op_get_link,
1528 .get_settings = nes_netdev_get_settings,
1529 .set_settings = nes_netdev_set_settings,
1530 .get_tx_csum = ethtool_op_get_tx_csum,
1531 .get_rx_csum = nes_netdev_get_rx_csum,
1532 .get_sg = ethtool_op_get_sg,
1533 .get_strings = nes_netdev_get_strings,
1534 .get_sset_count = nes_netdev_get_sset_count,
1535 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1536 .get_drvinfo = nes_netdev_get_drvinfo,
1537 .get_coalesce = nes_netdev_get_coalesce,
1538 .set_coalesce = nes_netdev_set_coalesce,
1539 .get_pauseparam = nes_netdev_get_pauseparam,
1540 .set_pauseparam = nes_netdev_set_pauseparam,
1541 .set_tx_csum = ethtool_op_set_tx_csum,
1542 .set_rx_csum = nes_netdev_set_rx_csum,
1543 .set_sg = ethtool_op_set_sg,
1544 .get_tso = ethtool_op_get_tso,
1545 .set_tso = ethtool_op_set_tso,
1546 .get_flags = ethtool_op_get_flags,
1547 .set_flags = ethtool_op_set_flags,
1551 static void nes_netdev_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
1553 struct nes_vnic *nesvnic = netdev_priv(netdev);
1554 struct nes_device *nesdev = nesvnic->nesdev;
1555 struct nes_adapter *nesadapter = nesdev->nesadapter;
1557 unsigned long flags;
1559 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1560 nesvnic->vlan_grp = grp;
1562 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1564 /* Enable/Disable VLAN Stripping */
1565 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1567 u32temp &= 0xfdffffff;
1569 u32temp |= 0x02000000;
1571 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1572 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1575 static const struct net_device_ops nes_netdev_ops = {
1576 .ndo_open = nes_netdev_open,
1577 .ndo_stop = nes_netdev_stop,
1578 .ndo_start_xmit = nes_netdev_start_xmit,
1579 .ndo_get_stats = nes_netdev_get_stats,
1580 .ndo_tx_timeout = nes_netdev_tx_timeout,
1581 .ndo_set_mac_address = nes_netdev_set_mac_address,
1582 .ndo_set_multicast_list = nes_netdev_set_multicast_list,
1583 .ndo_change_mtu = nes_netdev_change_mtu,
1584 .ndo_validate_addr = eth_validate_addr,
1585 .ndo_vlan_rx_register = nes_netdev_vlan_rx_register,
1589 * nes_netdev_init - initialize network device
1591 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1592 void __iomem *mmio_addr)
1595 struct nes_vnic *nesvnic;
1596 struct net_device *netdev;
1597 struct nic_qp_map *curr_qp_map;
1598 u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
1600 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1602 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1605 nesvnic = netdev_priv(netdev);
1607 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1609 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1611 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1612 netdev->irq = nesdev->pcidev->irq;
1613 netdev->mtu = ETH_DATA_LEN;
1614 netdev->hard_header_len = ETH_HLEN;
1615 netdev->addr_len = ETH_ALEN;
1616 netdev->type = ARPHRD_ETHER;
1617 netdev->features = NETIF_F_HIGHDMA;
1618 netdev->netdev_ops = &nes_netdev_ops;
1619 netdev->ethtool_ops = &nes_ethtool_ops;
1620 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1621 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1622 netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1624 /* Fill in the port structure */
1625 nesvnic->netdev = netdev;
1626 nesvnic->nesdev = nesdev;
1627 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1628 nesvnic->netdev_index = nesdev->netdev_count;
1629 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1630 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1632 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1633 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1634 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1635 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1637 /* Setup the burned in MAC address */
1638 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1639 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1640 u64temp += nesvnic->nic_index;
1641 netdev->dev_addr[0] = (u8)(u64temp>>40);
1642 netdev->dev_addr[1] = (u8)(u64temp>>32);
1643 netdev->dev_addr[2] = (u8)(u64temp>>24);
1644 netdev->dev_addr[3] = (u8)(u64temp>>16);
1645 netdev->dev_addr[4] = (u8)(u64temp>>8);
1646 netdev->dev_addr[5] = (u8)u64temp;
1647 memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1649 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV)) {
1650 netdev->features |= NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1651 netdev->features |= NETIF_F_GSO | NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1653 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1656 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1657 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1658 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1659 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1661 if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1662 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1664 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1665 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1666 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1667 nesvnic->qp_nic_index[2] = 0xf;
1668 nesvnic->qp_nic_index[3] = 0xf;
1670 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1671 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1674 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1675 (nesvnic->nesdev->nesadapter->port_count == 1 &&
1676 nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1677 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1678 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1680 nesvnic->qp_nic_index[2] = 0xf;
1681 nesvnic->qp_nic_index[3] = 0xf;
1683 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1684 nesvnic->qp_nic_index[1] = 0xf;
1685 nesvnic->qp_nic_index[2] = 0xf;
1686 nesvnic->qp_nic_index[3] = 0xf;
1689 nesvnic->next_qp_nic_index = 0;
1691 if (nesdev->netdev_count == 0) {
1692 nesvnic->rdma_enabled = 1;
1694 nesvnic->rdma_enabled = 0;
1696 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1697 spin_lock_init(&nesvnic->tx_lock);
1698 nesdev->netdev[nesdev->netdev_count] = netdev;
1700 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1701 nesvnic, nesdev->mac_index);
1702 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1704 if ((nesdev->netdev_count == 0) &&
1705 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1706 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
1707 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1708 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1713 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1714 (0x200 * (nesdev->mac_index & 1)));
1715 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
1716 u32temp |= 0x00200000;
1717 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1718 (0x200 * (nesdev->mac_index & 1)), u32temp);
1721 /* Check and set linkup here. This is for back to back */
1722 /* configuration where second port won't get link interrupt */
1724 case NES_PHY_TYPE_PUMA_1G:
1725 if (nesdev->mac_index < 2) {
1726 link_mask = 0x01010000;
1727 link_val = 0x01010000;
1729 link_mask = 0x02020000;
1730 link_val = 0x02020000;
1734 link_mask = 0x0f1f0000;
1735 link_val = 0x0f0f0000;
1739 u32temp = nes_read_indexed(nesdev,
1740 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1741 (0x200 * (nesdev->mac_index & 1)));
1742 if ((u32temp & link_mask) == link_val)
1743 nesvnic->linkup = 1;
1745 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1746 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1747 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1748 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1750 nes_init_phy(nesdev);
1758 * nes_netdev_destroy - destroy network device structure
1760 void nes_netdev_destroy(struct net_device *netdev)
1762 struct nes_vnic *nesvnic = netdev_priv(netdev);
1764 /* make sure 'stop' method is called by Linux stack */
1765 /* nes_netdev_stop(netdev); */
1767 list_del(&nesvnic->list);
1769 if (nesvnic->of_device_registered) {
1770 nes_destroy_ofa_device(nesvnic->nesibdev);
1773 free_netdev(netdev);
1778 * nes_nic_cm_xmit -- CM calls this to send out pkts
1780 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1785 ret = dev_queue_xmit(skb);
1787 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);