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