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