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