projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
RDMA/nes: Store and print eeprom version
[deliverable/linux.git] / drivers / infiniband / hw / nes / nes_nic.c
CommitLineData
3c2d774c 1/*
fa6c87d5 2 * Copyright (c) 2006 - 2009 Intel Corporation. All rights reserved.
3c2d774c
GS		 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>
5a0e3ad6 43#include <linux/slab.h>
3c2d774c
GS		 44#include <net/tcp.h>
45
46#include <net/inet_common.h>
47#include <linux/inet.h>
48
49#include "nes.h"
50
51static struct nic_qp_map nic_qp_mapping_0[] = {
52 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
53 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
54 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
55 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
56};
57
58static struct nic_qp_map nic_qp_mapping_1[] = {
59 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
60 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
61};
62
63static struct nic_qp_map nic_qp_mapping_2[] = {
64 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
65};
66
67static struct nic_qp_map nic_qp_mapping_3[] = {
68 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
69};
70
71static struct nic_qp_map nic_qp_mapping_4[] = {
72 {28,8,0,0},{32,12,0,0}
73};
74
75static struct nic_qp_map nic_qp_mapping_5[] = {
76 {29,9,1,0},{33,13,1,0}
77};
78
79static struct nic_qp_map nic_qp_mapping_6[] = {
80 {30,10,2,0},{34,14,2,0}
81};
82
83static struct nic_qp_map nic_qp_mapping_7[] = {
84 {31,11,3,0},{35,15,3,0}
85};
86
87static struct nic_qp_map *nic_qp_mapping_per_function[] = {
88 nic_qp_mapping_0, nic_qp_mapping_1, nic_qp_mapping_2, nic_qp_mapping_3,
89 nic_qp_mapping_4, nic_qp_mapping_5, nic_qp_mapping_6, nic_qp_mapping_7
90};
91
92static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
93 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
94static int debug = -1;
7e36d3d7 95static int nics_per_function = 1;
3c2d774c 96
3c2d774c
GS		 97/**
98 * nes_netdev_poll
99 */
100static int nes_netdev_poll(struct napi_struct *napi, int budget)
101{
102 struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi);
3c2d774c
GS		 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) {
288379f0 115 napi_complete(napi);
3c2d774c
GS		 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;
2869975c 404 nesnic->tx_skb[nesnic->sq_head] = skb;
3c2d774c
GS		 405 }
406 } else {
407 /* Deal with Fragments */
408 nesnic->tx_skb[nesnic->sq_head] = skb;
409 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
410 skb_fragment_index++) {
411 bus_address = pci_map_page( nesdev->pcidev,
412 skb_shinfo(skb)->frags[skb_fragment_index].page,
413 skb_shinfo(skb)->frags[skb_fragment_index].page_offset,
414 skb_shinfo(skb)->frags[skb_fragment_index].size,
415 PCI_DMA_TODEVICE);
416 wqe_fragment_length[wqe_fragment_index] =
417 cpu_to_le16(skb_shinfo(skb)->frags[skb_fragment_index].size);
418 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
419 bus_address);
420 wqe_fragment_index++;
421 if (wqe_fragment_index < 5)
422 wqe_fragment_length[wqe_fragment_index] = 0;
423 }
424 }
425
426 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
427 nesnic->sq_head++;
428 nesnic->sq_head &= nesnic->sq_size - 1;
429
430 return NETDEV_TX_OK;
431}
432
433
434/**
435 * nes_netdev_start_xmit
436 */
437static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
438{
439 struct nes_vnic *nesvnic = netdev_priv(netdev);
440 struct nes_device *nesdev = nesvnic->nesdev;
441 struct nes_hw_nic *nesnic = &nesvnic->nic;
442 struct nes_hw_nic_sq_wqe *nic_sqe;
443 struct tcphdr *tcph;
444 /* struct udphdr *udph; */
a06fd26d 445#define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
3c2d774c
GS		 446 /* 64K segment plus overflow on each side */
447 dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
448 dma_addr_t bus_address;
449 u32 tso_frag_index;
450 u32 tso_frag_count;
451 u32 tso_wqe_length;
452 u32 curr_tcp_seq;
453 u32 wqe_count=1;
454 u32 send_rc;
455 struct iphdr *iph;
3c2d774c
GS		 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
3c2d774c
GS		 482 /* Check if SQ is full */
483 if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
484 if (!netif_queue_stopped(netdev)) {
485 netif_stop_queue(netdev);
486 barrier();
487 if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
488 netif_start_queue(netdev);
489 goto sq_no_longer_full;
490 }
491 }
492 nesvnic->sq_full++;
3c2d774c
GS		 493 return NETDEV_TX_BUSY;
494 }
495
496sq_no_longer_full:
497 nr_frags = skb_shinfo(skb)->nr_frags;
498 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
499 nr_frags++;
500 }
501 /* Check if too many fragments */
502 if (unlikely((nr_frags > 4))) {
503 if (skb_is_gso(skb)) {
504 nesvnic->segmented_tso_requests++;
505 nesvnic->tso_requests++;
506 old_head = nesnic->sq_head;
507 /* Basically 4 fragments available per WQE with extended fragments */
508 wqes_needed = nr_frags >> 2;
509 wqes_needed += (nr_frags&3)?1:0;
510 wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
511 (nesnic->sq_size - 1);
512
513 if (unlikely(wqes_needed > wqes_available)) {
514 if (!netif_queue_stopped(netdev)) {
515 netif_stop_queue(netdev);
516 barrier();
517 wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
518 (nesnic->sq_size - 1);
519 if (wqes_needed <= wqes_available) {
520 netif_start_queue(netdev);
521 goto tso_sq_no_longer_full;
522 }
523 }
524 nesvnic->sq_full++;
3c2d774c
GS		 525 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
526 netdev->name);
527 return NETDEV_TX_BUSY;
528 }
529tso_sq_no_longer_full:
530 /* Map all the buffers */
531 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
532 tso_frag_count++) {
533 tso_bus_address[tso_frag_count] = pci_map_page( nesdev->pcidev,
534 skb_shinfo(skb)->frags[tso_frag_count].page,
535 skb_shinfo(skb)->frags[tso_frag_count].page_offset,
536 skb_shinfo(skb)->frags[tso_frag_count].size,
537 PCI_DMA_TODEVICE);
538 }
539
540 tso_frag_index = 0;
541 curr_tcp_seq = ntohl(tcp_hdr(skb)->seq);
542 hoffset = skb_transport_header(skb) - skb->data;
543 nhoffset = skb_network_header(skb) - skb->data;
544 original_first_length = hoffset + ((((struct tcphdr *)skb_transport_header(skb))->doff)<<2);
545
546 for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
547 tso_wqe_length = 0;
548 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
549 wqe_fragment_length =
550 (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
551 /* setup the VLAN tag if present */
552 if (vlan_tx_tag_present(skb)) {
553 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
554 netdev->name, vlan_tx_tag_get(skb) );
555 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
556 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
557 } else
558 wqe_misc = 0;
559
560 /* bump past the vlan tag */
561 wqe_fragment_length++;
562
563 /* Assumes header totally fits in allocated buffer and is in first fragment */
564 if (original_first_length > NES_FIRST_FRAG_SIZE) {
565 nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
566 original_first_length, NES_FIRST_FRAG_SIZE);
567 nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
568 " (%u frags), tso_size=%u\n",
569 netdev->name,
570 skb->len, skb_headlen(skb),
571 skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
572 }
573 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
574 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
575 original_first_length));
576 iph = (struct iphdr *)
577 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[nhoffset]);
578 tcph = (struct tcphdr *)
579 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[hoffset]);
580 if ((wqe_count+1)!=(u32)wqes_needed) {
581 tcph->fin = 0;
582 tcph->psh = 0;
583 tcph->rst = 0;
584 tcph->urg = 0;
585 }
586 if (wqe_count) {
587 tcph->syn = 0;
588 }
589 tcph->seq = htonl(curr_tcp_seq);
590 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
591 original_first_length));
592
593 wqe_fragment_index = 1;
594 if ((wqe_count==0) && (skb_headlen(skb) > original_first_length)) {
595 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
596 bus_address = pci_map_single(nesdev->pcidev, skb->data + original_first_length,
597 skb_headlen(skb) - original_first_length, PCI_DMA_TODEVICE);
598 wqe_fragment_length[wqe_fragment_index++] =
599 cpu_to_le16(skb_headlen(skb) - original_first_length);
600 wqe_fragment_length[wqe_fragment_index] = 0;
601 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
602 bus_address);
168ac824
CT		 603 tso_wqe_length += skb_headlen(skb) -
604 original_first_length;
3c2d774c
GS		 605 }
606 while (wqe_fragment_index < 5) {
607 wqe_fragment_length[wqe_fragment_index] =
608 cpu_to_le16(skb_shinfo(skb)->frags[tso_frag_index].size);
609 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
610 (u64)tso_bus_address[tso_frag_index]);
611 wqe_fragment_index++;
612 tso_wqe_length += skb_shinfo(skb)->frags[tso_frag_index++].size;
613 if (wqe_fragment_index < 5)
614 wqe_fragment_length[wqe_fragment_index] = 0;
615 if (tso_frag_index == tso_frag_count)
616 break;
617 }
618 if ((wqe_count+1) == (u32)wqes_needed) {
619 nesnic->tx_skb[nesnic->sq_head] = skb;
620 } else {
621 nesnic->tx_skb[nesnic->sq_head] = NULL;
622 }
623 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
624 if ((tso_wqe_length + original_first_length) > skb_is_gso(skb)) {
625 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
626 } else {
627 iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
628 }
629
630 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
631 wqe_misc);
632 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
633 ((u32)tcph->doff) | (((u32)hoffset) << 4));
634
635 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
636 tso_wqe_length + original_first_length);
637 curr_tcp_seq += tso_wqe_length;
638 nesnic->sq_head++;
639 nesnic->sq_head &= nesnic->sq_size-1;
640 }
641 } else {
642 nesvnic->linearized_skbs++;
643 hoffset = skb_transport_header(skb) - skb->data;
644 nhoffset = skb_network_header(skb) - skb->data;
645 skb_linearize(skb);
646 skb_set_transport_header(skb, hoffset);
647 skb_set_network_header(skb, nhoffset);
648 send_rc = nes_nic_send(skb, netdev);
2869975c 649 if (send_rc != NETDEV_TX_OK)
3c2d774c 650 return NETDEV_TX_OK;
3c2d774c
GS		 651 }
652 } else {
653 send_rc = nes_nic_send(skb, netdev);
2869975c 654 if (send_rc != NETDEV_TX_OK)
3c2d774c 655 return NETDEV_TX_OK;
3c2d774c
GS		 656 }
657
658 barrier();
659
660 if (wqe_count)
661 nes_write32(nesdev->regs+NES_WQE_ALLOC,
662 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
663
664 netdev->trans_start = jiffies;
3c2d774c
GS		 665
666 return NETDEV_TX_OK;
667}
668
669
670/**
671 * nes_netdev_get_stats
672 */
673static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
674{
675 struct nes_vnic *nesvnic = netdev_priv(netdev);
676 struct nes_device *nesdev = nesvnic->nesdev;
677 u64 u64temp;
678 u32 u32temp;
679
680 u32temp = nes_read_indexed(nesdev,
681 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD + (nesvnic->nic_index*0x200));
682 nesvnic->netstats.rx_dropped += u32temp;
683 nesvnic->endnode_nstat_rx_discard += u32temp;
684
685 u64temp = (u64)nes_read_indexed(nesdev,
686 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO + (nesvnic->nic_index*0x200));
687 u64temp += ((u64)nes_read_indexed(nesdev,
688 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
689
690 nesvnic->endnode_nstat_rx_octets += u64temp;
691 nesvnic->netstats.rx_bytes += u64temp;
692
693 u64temp = (u64)nes_read_indexed(nesdev,
694 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO + (nesvnic->nic_index*0x200));
695 u64temp += ((u64)nes_read_indexed(nesdev,
696 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
697
698 nesvnic->endnode_nstat_rx_frames += u64temp;
699 nesvnic->netstats.rx_packets += u64temp;
700
701 u64temp = (u64)nes_read_indexed(nesdev,
702 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO + (nesvnic->nic_index*0x200));
703 u64temp += ((u64)nes_read_indexed(nesdev,
704 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
705
706 nesvnic->endnode_nstat_tx_octets += u64temp;
707 nesvnic->netstats.tx_bytes += u64temp;
708
709 u64temp = (u64)nes_read_indexed(nesdev,
710 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO + (nesvnic->nic_index*0x200));
711 u64temp += ((u64)nes_read_indexed(nesdev,
712 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
713
714 nesvnic->endnode_nstat_tx_frames += u64temp;
715 nesvnic->netstats.tx_packets += u64temp;
716
717 u32temp = nes_read_indexed(nesdev,
718 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
719 nesvnic->netstats.rx_dropped += u32temp;
720 nesvnic->nesdev->mac_rx_errors += u32temp;
721 nesvnic->nesdev->mac_rx_short_frames += u32temp;
722
723 u32temp = nes_read_indexed(nesdev,
724 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
725 nesvnic->netstats.rx_dropped += u32temp;
726 nesvnic->nesdev->mac_rx_errors += u32temp;
727 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
728
729 u32temp = nes_read_indexed(nesdev,
730 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
731 nesvnic->netstats.rx_dropped += u32temp;
732 nesvnic->nesdev->mac_rx_errors += u32temp;
733 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
734
735 u32temp = nes_read_indexed(nesdev,
736 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
737 nesvnic->netstats.rx_dropped += u32temp;
738 nesvnic->nesdev->mac_rx_errors += u32temp;
739 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
740
741 u32temp = nes_read_indexed(nesdev,
742 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
743 nesvnic->netstats.rx_length_errors += u32temp;
744 nesvnic->nesdev->mac_rx_errors += u32temp;
745
746 u32temp = nes_read_indexed(nesdev,
747 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
748 nesvnic->nesdev->mac_rx_errors += u32temp;
749 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
750 nesvnic->netstats.rx_crc_errors += u32temp;
751
752 u32temp = nes_read_indexed(nesdev,
753 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
754 nesvnic->nesdev->mac_tx_errors += u32temp;
755 nesvnic->netstats.tx_errors += u32temp;
756
757 return &nesvnic->netstats;
758}
759
760
761/**
762 * nes_netdev_tx_timeout
763 */
764static void nes_netdev_tx_timeout(struct net_device *netdev)
765{
766 struct nes_vnic *nesvnic = netdev_priv(netdev);
767
768 if (netif_msg_timer(nesvnic))
769 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
770}
771
772
773/**
774 * nes_netdev_set_mac_address
775 */
776static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
777{
778 struct nes_vnic *nesvnic = netdev_priv(netdev);
779 struct nes_device *nesdev = nesvnic->nesdev;
780 struct sockaddr *mac_addr = p;
781 int i;
782 u32 macaddr_low;
783 u16 macaddr_high;
784
785 if (!is_valid_ether_addr(mac_addr->sa_data))
786 return -EADDRNOTAVAIL;
787
788 memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
e174961c
JB		 789 printk(PFX "%s: Address length = %d, Address = %pM\n",
790 __func__, netdev->addr_len, mac_addr->sa_data);
7495ab68 791 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
3c2d774c 792 macaddr_high += (u16)netdev->dev_addr[1];
7495ab68
GS		 793 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
794 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
795 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
796 macaddr_low += (u32)netdev->dev_addr[5];
3c2d774c
GS		 797
798 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
799 if (nesvnic->qp_nic_index[i] == 0xf) {
800 break;
801 }
802 nes_write_indexed(nesdev,
803 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
804 macaddr_low);
805 nes_write_indexed(nesdev,
806 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
807 (u32)macaddr_high | NES_MAC_ADDR_VALID |
808 ((((u32)nesvnic->nic_index) << 16)));
809 }
810 return 0;
811}
812
813
fbf219f1
JP		 814static void set_allmulti(struct nes_device *nesdev, u32 nic_active_bit)
815{
816 u32 nic_active;
817
818 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
819 nic_active |= nic_active_bit;
820 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
821 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
822 nic_active &= ~nic_active_bit;
823 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
824}
825
826#define get_addr(addrs, index) ((addrs) + (index) * ETH_ALEN)
827
3c2d774c
GS		 828/**
829 * nes_netdev_set_multicast_list
830 */
1a855fbf 831static void nes_netdev_set_multicast_list(struct net_device *netdev)
3c2d774c
GS		 832{
833 struct nes_vnic *nesvnic = netdev_priv(netdev);
834 struct nes_device *nesdev = nesvnic->nesdev;
7e36d3d7 835 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
3c2d774c
GS		 836 u32 nic_active_bit;
837 u32 nic_active;
838 u32 perfect_filter_register_address;
839 u32 macaddr_low;
840 u16 macaddr_high;
841 u8 mc_all_on = 0;
842 u8 mc_index;
843 int mc_nic_index = -1;
7e36d3d7
VM		 844 u8 pft_entries_preallocated = max(nesadapter->adapter_fcn_count *
845 nics_per_function, 4);
846 u8 max_pft_entries_avaiable = NES_PFT_SIZE - pft_entries_preallocated;
847 unsigned long flags;
fbf219f1 848 int mc_count = netdev_mc_count(netdev);
3c2d774c 849
7e36d3d7 850 spin_lock_irqsave(&nesadapter->resource_lock, flags);
3c2d774c
GS		 851 nic_active_bit = 1 << nesvnic->nic_index;
852
853 if (netdev->flags & IFF_PROMISC) {
854 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
855 nic_active |= nic_active_bit;
856 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
857 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
858 nic_active |= nic_active_bit;
859 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
860 mc_all_on = 1;
7e36d3d7 861 } else if ((netdev->flags & IFF_ALLMULTI) ||
3c2d774c 862 (nesvnic->nic_index > 3)) {
fbf219f1 863 set_allmulti(nesdev, nic_active_bit);
3c2d774c
GS		 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",
fbf219f1 875 mc_count, !!(netdev->flags & IFF_PROMISC),
7e36d3d7 876 !!(netdev->flags & IFF_ALLMULTI));
3c2d774c 877 if (!mc_all_on) {
fbf219f1
JP		 878 char *addrs;
879 int i;
22bedad3 880 struct netdev_hw_addr *ha;
fbf219f1
JP		 881
882 addrs = kmalloc(ETH_ALEN * mc_count, GFP_ATOMIC);
883 if (!addrs) {
884 set_allmulti(nesdev, nic_active_bit);
885 goto unlock;
886 }
887 i = 0;
22bedad3
JP		 888 netdev_for_each_mc_addr(ha, netdev)
889 memcpy(get_addr(addrs, i++), ha->addr, ETH_ALEN);
fbf219f1 890
7e36d3d7
VM		 891 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW +
892 pft_entries_preallocated * 0x8;
fbf219f1
JP		 893 for (i = 0, mc_index = 0; mc_index < max_pft_entries_avaiable;
894 mc_index++) {
895 while (i < mc_count && nesvnic->mcrq_mcast_filter &&
7e36d3d7 896 ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
fbf219f1 897 get_addr(addrs, i++))) == 0));
3c2d774c
GS		 898 if (mc_nic_index < 0)
899 mc_nic_index = nesvnic->nic_index;
7e36d3d7
VM		 900 while (nesadapter->pft_mcast_map[mc_index] < 16 &&
901 nesadapter->pft_mcast_map[mc_index] !=
902 nesvnic->nic_index &&
903 mc_index < max_pft_entries_avaiable) {
904 nes_debug(NES_DBG_NIC_RX,
905 "mc_index=%d skipping nic_index=%d,\
906 used for=%d \n", mc_index,
907 nesvnic->nic_index,
908 nesadapter->pft_mcast_map[mc_index]);
909 mc_index++;
910 }
911 if (mc_index >= max_pft_entries_avaiable)
912 break;
fbf219f1
JP		 913 if (i < mc_count) {
914 char *addr = get_addr(addrs, i++);
915
e174961c 916 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
fbf219f1 917 addr,
2bd01c5d
RD		 918 perfect_filter_register_address+(mc_index * 8),
919 mc_nic_index);
fbf219f1
JP		 920 macaddr_high = ((u16) addr[0]) << 8;
921 macaddr_high += (u16) addr[1];
922 macaddr_low = ((u32) addr[2]) << 24;
923 macaddr_low += ((u32) addr[3]) << 16;
924 macaddr_low += ((u32) addr[4]) << 8;
925 macaddr_low += (u32) addr[5];
3c2d774c
GS		 926 nes_write_indexed(nesdev,
927 perfect_filter_register_address+(mc_index * 8),
928 macaddr_low);
929 nes_write_indexed(nesdev,
930 perfect_filter_register_address+4+(mc_index * 8),
931 (u32)macaddr_high | NES_MAC_ADDR_VALID |
932 ((((u32)(1<<mc_nic_index)) << 16)));
7e36d3d7
VM		 933 nesadapter->pft_mcast_map[mc_index] =
934 nesvnic->nic_index;
3c2d774c
GS		 935 } else {
936 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
937 perfect_filter_register_address+(mc_index * 8));
938 nes_write_indexed(nesdev,
939 perfect_filter_register_address+4+(mc_index * 8),
940 0);
7e36d3d7 941 nesadapter->pft_mcast_map[mc_index] = 255;
3c2d774c
GS		 942 }
943 }
fbf219f1 944 kfree(addrs);
7e36d3d7 945 /* PFT is not large enough */
fbf219f1
JP		 946 if (i < mc_count)
947 set_allmulti(nesdev, nic_active_bit);
3c2d774c 948 }
7e36d3d7 949
fbf219f1 950unlock:
7e36d3d7 951 spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
3c2d774c
GS		 952}
953
954
955/**
956 * nes_netdev_change_mtu
957 */
7495ab68 958static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
3c2d774c
GS		 959{
960 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68
GS		 961 struct nes_device *nesdev = nesvnic->nesdev;
962 int ret = 0;
963 u8 jumbomode = 0;
e0e31afb
BS		 964 u32 nic_active;
965 u32 nic_active_bit;
966 u32 uc_all_active;
967 u32 mc_all_active;
3c2d774c 968
7495ab68 969 if ((new_mtu < ETH_ZLEN) || (new_mtu > max_mtu))
3c2d774c
GS		 970 return -EINVAL;
971
7495ab68 972 netdev->mtu = new_mtu;
edd2fd64 973 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
3c2d774c
GS		 974
975 if (netdev->mtu > 1500) {
976 jumbomode=1;
977 }
7495ab68 978 nes_nic_init_timer_defaults(nesdev, jumbomode);
3c2d774c
GS		 979
980 if (netif_running(netdev)) {
e0e31afb
BS		 981 nic_active_bit = 1 << nesvnic->nic_index;
982 mc_all_active = nes_read_indexed(nesdev,
983 NES_IDX_NIC_MULTICAST_ALL) & nic_active_bit;
984 uc_all_active = nes_read_indexed(nesdev,
985 NES_IDX_NIC_UNICAST_ALL) & nic_active_bit;
986
3c2d774c
GS		 987 nes_netdev_stop(netdev);
988 nes_netdev_open(netdev);
e0e31afb
BS		 989
990 nic_active = nes_read_indexed(nesdev,
991 NES_IDX_NIC_MULTICAST_ALL);
992 nic_active |= mc_all_active;
993 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL,
994 nic_active);
995
996 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
997 nic_active |= uc_all_active;
998 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
3c2d774c
GS		 999 }
1000
1001 return ret;
1002}
1003
39942a02 1004
37dab411 1005static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
3c2d774c
GS		 1006 "Link Change Interrupts",
1007 "Linearized SKBs",
1008 "T/GSO Requests",
1009 "Pause Frames Sent",
1010 "Pause Frames Received",
1011 "Internal Routing Errors",
1012 "SQ SW Dropped SKBs",
3c2d774c
GS		 1013 "SQ Full",
1014 "Segmented TSO Requests",
1015 "Rx Symbol Errors",
1016 "Rx Jabber Errors",
1017 "Rx Oversized Frames",
1018 "Rx Short Frames",
39942a02
FL		 1019 "Rx Length Errors",
1020 "Rx CRC Errors",
1021 "Rx Port Discard",
3c2d774c
GS		 1022 "Endnode Rx Discards",
1023 "Endnode Rx Octets",
1024 "Endnode Rx Frames",
1025 "Endnode Tx Octets",
1026 "Endnode Tx Frames",
39942a02 1027 "Tx Errors",
3c2d774c
GS		 1028 "mh detected",
1029 "mh pauses",
1030 "Retransmission Count",
1031 "CM Connects",
1032 "CM Accepts",
1033 "Disconnects",
1034 "Connected Events",
1035 "Connect Requests",
1036 "CM Rejects",
1037 "ModifyQP Timeouts",
1038 "CreateQPs",
1039 "SW DestroyQPs",
1040 "DestroyQPs",
1041 "CM Closes",
1042 "CM Packets Sent",
1043 "CM Packets Bounced",
1044 "CM Packets Created",
1045 "CM Packets Rcvd",
1046 "CM Packets Dropped",
1047 "CM Packets Retrans",
1048 "CM Listens Created",
1049 "CM Listens Destroyed",
1050 "CM Backlog Drops",
1051 "CM Loopbacks",
1052 "CM Nodes Created",
1053 "CM Nodes Destroyed",
1054 "CM Accel Drops",
1055 "CM Resets Received",
39942a02
FL		 1056 "Free 4Kpbls",
1057 "Free 256pbls",
3c2d774c 1058 "Timer Inits",
37dab411
FL		 1059 "LRO aggregated",
1060 "LRO flushed",
1061 "LRO no_desc",
3c2d774c 1062};
37dab411 1063#define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
3c2d774c
GS		 1064
1065/**
1066 * nes_netdev_get_rx_csum
1067 */
1068static u32 nes_netdev_get_rx_csum (struct net_device *netdev)
1069{
1070 struct nes_vnic *nesvnic = netdev_priv(netdev);
1071
1072 if (nesvnic->rx_checksum_disabled)
1073 return 0;
1074 else
1075 return 1;
1076}
1077
1078
1079/**
1080 * nes_netdev_set_rc_csum
1081 */
1082static int nes_netdev_set_rx_csum(struct net_device *netdev, u32 enable)
1083{
1084 struct nes_vnic *nesvnic = netdev_priv(netdev);
1085
1086 if (enable)
1087 nesvnic->rx_checksum_disabled = 0;
1088 else
1089 nesvnic->rx_checksum_disabled = 1;
1090 return 0;
1091}
1092
1093
1094/**
15f0a394 1095 * nes_netdev_get_sset_count
3c2d774c 1096 */
15f0a394 1097static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
3c2d774c 1098{
15f0a394
BH		 1099 if (stringset == ETH_SS_STATS)
1100 return NES_ETHTOOL_STAT_COUNT;
1101 else
1102 return -EINVAL;
3c2d774c
GS		 1103}
1104
1105
1106/**
1107 * nes_netdev_get_strings
1108 */
1109static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1110 u8 *ethtool_strings)
1111{
1112 if (stringset == ETH_SS_STATS)
1113 memcpy(ethtool_strings,
1114 &nes_ethtool_stringset,
1115 sizeof(nes_ethtool_stringset));
1116}
1117
1118
1119/**
1120 * nes_netdev_get_ethtool_stats
1121 */
39942a02 1122
3c2d774c
GS		 1123static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1124 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1125{
1126 u64 u64temp;
1127 struct nes_vnic *nesvnic = netdev_priv(netdev);
1128 struct nes_device *nesdev = nesvnic->nesdev;
39942a02 1129 struct nes_adapter *nesadapter = nesdev->nesadapter;
3c2d774c
GS		 1130 u32 nic_count;
1131 u32 u32temp;
2869975c 1132 u32 index = 0;
3c2d774c
GS		 1133
1134 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
2869975c
FL		 1135 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1136 target_stat_values[++index] = nesvnic->linearized_skbs;
1137 target_stat_values[++index] = nesvnic->tso_requests;
3c2d774c
GS		 1138
1139 u32temp = nes_read_indexed(nesdev,
1140 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1141 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
2869975c 1142 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
3c2d774c
GS		 1143
1144 u32temp = nes_read_indexed(nesdev,
1145 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1146 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1147
1148 u32temp = nes_read_indexed(nesdev,
1149 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1150 nesvnic->nesdev->port_rx_discards += u32temp;
1151 nesvnic->netstats.rx_dropped += u32temp;
1152
1153 u32temp = nes_read_indexed(nesdev,
1154 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1155 nesvnic->nesdev->port_tx_discards += u32temp;
1156 nesvnic->netstats.tx_dropped += u32temp;
1157
39942a02
FL		 1158 u32temp = nes_read_indexed(nesdev,
1159 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1160 nesvnic->netstats.rx_dropped += u32temp;
1161 nesvnic->nesdev->mac_rx_errors += u32temp;
1162 nesvnic->nesdev->mac_rx_short_frames += u32temp;
1163
1164 u32temp = nes_read_indexed(nesdev,
1165 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1166 nesvnic->netstats.rx_dropped += u32temp;
1167 nesvnic->nesdev->mac_rx_errors += u32temp;
1168 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
1169
1170 u32temp = nes_read_indexed(nesdev,
1171 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1172 nesvnic->netstats.rx_dropped += u32temp;
1173 nesvnic->nesdev->mac_rx_errors += u32temp;
1174 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
1175
1176 u32temp = nes_read_indexed(nesdev,
1177 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1178 nesvnic->netstats.rx_dropped += u32temp;
1179 nesvnic->nesdev->mac_rx_errors += u32temp;
1180 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
1181
1182 u32temp = nes_read_indexed(nesdev,
1183 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1184 nesvnic->netstats.rx_length_errors += u32temp;
1185 nesvnic->nesdev->mac_rx_errors += u32temp;
1186
1187 u32temp = nes_read_indexed(nesdev,
1188 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1189 nesvnic->nesdev->mac_rx_errors += u32temp;
1190 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
1191 nesvnic->netstats.rx_crc_errors += u32temp;
1192
1193 u32temp = nes_read_indexed(nesdev,
1194 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
1195 nesvnic->nesdev->mac_tx_errors += u32temp;
1196 nesvnic->netstats.tx_errors += u32temp;
1197
3c2d774c
GS		 1198 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1199 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1200 break;
1201
1202 u32temp = nes_read_indexed(nesdev,
1203 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1204 (nesvnic->qp_nic_index[nic_count]*0x200));
1205 nesvnic->netstats.rx_dropped += u32temp;
1206 nesvnic->endnode_nstat_rx_discard += u32temp;
1207
1208 u64temp = (u64)nes_read_indexed(nesdev,
1209 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1210 (nesvnic->qp_nic_index[nic_count]*0x200));
1211 u64temp += ((u64)nes_read_indexed(nesdev,
1212 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1213 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1214
1215 nesvnic->endnode_nstat_rx_octets += u64temp;
1216 nesvnic->netstats.rx_bytes += u64temp;
1217
1218 u64temp = (u64)nes_read_indexed(nesdev,
1219 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1220 (nesvnic->qp_nic_index[nic_count]*0x200));
1221 u64temp += ((u64)nes_read_indexed(nesdev,
1222 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1223 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1224
1225 nesvnic->endnode_nstat_rx_frames += u64temp;
1226 nesvnic->netstats.rx_packets += u64temp;
1227
1228 u64temp = (u64)nes_read_indexed(nesdev,
1229 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1230 (nesvnic->qp_nic_index[nic_count]*0x200));
1231 u64temp += ((u64)nes_read_indexed(nesdev,
1232 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1233 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1234
1235 nesvnic->endnode_nstat_tx_octets += u64temp;
1236 nesvnic->netstats.tx_bytes += u64temp;
1237
1238 u64temp = (u64)nes_read_indexed(nesdev,
1239 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1240 (nesvnic->qp_nic_index[nic_count]*0x200));
1241 u64temp += ((u64)nes_read_indexed(nesdev,
1242 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1243 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1244
1245 nesvnic->endnode_nstat_tx_frames += u64temp;
1246 nesvnic->netstats.tx_packets += u64temp;
1247
1248 u32temp = nes_read_indexed(nesdev,
1249 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1250 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1251 }
1252
2869975c
FL		 1253 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1254 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1255 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1256 target_stat_values[++index] = nesvnic->sq_full;
1257 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1258 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1259 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1260 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1261 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
39942a02
FL		 1262 target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
1263 target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
1264 target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
2869975c
FL		 1265 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1266 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1267 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1268 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1269 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
39942a02 1270 target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
2869975c
FL		 1271 target_stat_values[++index] = mh_detected;
1272 target_stat_values[++index] = mh_pauses_sent;
1273 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1274 target_stat_values[++index] = atomic_read(&cm_connects);
1275 target_stat_values[++index] = atomic_read(&cm_accepts);
1276 target_stat_values[++index] = atomic_read(&cm_disconnects);
1277 target_stat_values[++index] = atomic_read(&cm_connecteds);
1278 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1279 target_stat_values[++index] = atomic_read(&cm_rejects);
1280 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1281 target_stat_values[++index] = atomic_read(&qps_created);
1282 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1283 target_stat_values[++index] = atomic_read(&qps_destroyed);
1284 target_stat_values[++index] = atomic_read(&cm_closes);
1285 target_stat_values[++index] = cm_packets_sent;
1286 target_stat_values[++index] = cm_packets_bounced;
1287 target_stat_values[++index] = cm_packets_created;
1288 target_stat_values[++index] = cm_packets_received;
1289 target_stat_values[++index] = cm_packets_dropped;
1290 target_stat_values[++index] = cm_packets_retrans;
6e10d2e4
FL		 1291 target_stat_values[++index] = atomic_read(&cm_listens_created);
1292 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
2869975c
FL		 1293 target_stat_values[++index] = cm_backlog_drops;
1294 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1295 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1296 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1297 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1298 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
39942a02
FL		 1299 target_stat_values[++index] = nesadapter->free_4kpbl;
1300 target_stat_values[++index] = nesadapter->free_256pbl;
2869975c 1301 target_stat_values[++index] = int_mod_timer_init;
2869975c
FL		 1302 target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
1303 target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
1304 target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
3c2d774c
GS		 1305}
1306
3c2d774c
GS		 1307/**
1308 * nes_netdev_get_drvinfo
1309 */
1310static void nes_netdev_get_drvinfo(struct net_device *netdev,
1311 struct ethtool_drvinfo *drvinfo)
1312{
1313 struct nes_vnic *nesvnic = netdev_priv(netdev);
0c93ae35 1314 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
3c2d774c
GS		 1315
1316 strcpy(drvinfo->driver, DRV_NAME);
1317 strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
0c93ae35
CT		 1318 sprintf(drvinfo->fw_version, "%u.%u", nesadapter->firmware_version>>16,
1319 nesadapter->firmware_version & 0x000000ff);
3c2d774c 1320 strcpy(drvinfo->version, DRV_VERSION);
3c2d774c
GS		 1321 drvinfo->testinfo_len = 0;
1322 drvinfo->eedump_len = 0;
1323 drvinfo->regdump_len = 0;
1324}
1325
1326
1327/**
1328 * nes_netdev_set_coalesce
1329 */
1330static int nes_netdev_set_coalesce(struct net_device *netdev,
1331 struct ethtool_coalesce *et_coalesce)
1332{
1333 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68 1334 struct nes_device *nesdev = nesvnic->nesdev;
3c2d774c
GS		 1335 struct nes_adapter *nesadapter = nesdev->nesadapter;
1336 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1337 unsigned long flags;
1338
7495ab68 1339 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
3c2d774c 1340 if (et_coalesce->rx_max_coalesced_frames_low) {
7495ab68 1341 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
3c2d774c
GS		 1342 }
1343 if (et_coalesce->rx_max_coalesced_frames_irq) {
1344 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1345 }
1346 if (et_coalesce->rx_max_coalesced_frames_high) {
1347 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1348 }
1349 if (et_coalesce->rx_coalesce_usecs_low) {
1350 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1351 }
1352 if (et_coalesce->rx_coalesce_usecs_high) {
1353 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1354 }
1355 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1356
1357 /* using this to drive total interrupt moderation */
1358 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1359 if (et_coalesce->use_adaptive_rx_coalesce) {
1360 nesadapter->et_use_adaptive_rx_coalesce = 1;
7495ab68 1361 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
3c2d774c
GS		 1362 nesadapter->et_rx_coalesce_usecs_irq = 0;
1363 if (et_coalesce->pkt_rate_low) {
7495ab68 1364 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
3c2d774c
GS		 1365 }
1366 } else {
1367 nesadapter->et_use_adaptive_rx_coalesce = 0;
7495ab68 1368 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
3c2d774c
GS		 1369 if (nesadapter->et_rx_coalesce_usecs_irq) {
1370 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1371 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1372 }
1373 }
1374 return 0;
1375}
1376
1377
1378/**
1379 * nes_netdev_get_coalesce
1380 */
1381static int nes_netdev_get_coalesce(struct net_device *netdev,
1382 struct ethtool_coalesce *et_coalesce)
1383{
1384 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68 1385 struct nes_device *nesdev = nesvnic->nesdev;
3c2d774c
GS		 1386 struct nes_adapter *nesadapter = nesdev->nesadapter;
1387 struct ethtool_coalesce temp_et_coalesce;
1388 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1389 unsigned long flags;
1390
1391 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
7495ab68
GS		 1392 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1393 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1394 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
3c2d774c
GS		 1395 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1396 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
7495ab68
GS		 1397 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1398 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
3c2d774c 1399 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
7495ab68 1400 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
3c2d774c
GS		 1401 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1402 if (nesadapter->et_use_adaptive_rx_coalesce) {
1403 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1404 }
1405 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
7495ab68 1406 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
3c2d774c
GS		 1407 return 0;
1408}
1409
1410
1411/**
1412 * nes_netdev_get_pauseparam
1413 */
1414static void nes_netdev_get_pauseparam(struct net_device *netdev,
1415 struct ethtool_pauseparam *et_pauseparam)
1416{
1417 struct nes_vnic *nesvnic = netdev_priv(netdev);
1418
1419 et_pauseparam->autoneg = 0;
1420 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1421 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1422}
1423
1424
1425/**
1426 * nes_netdev_set_pauseparam
1427 */
1428static int nes_netdev_set_pauseparam(struct net_device *netdev,
1429 struct ethtool_pauseparam *et_pauseparam)
1430{
1431 struct nes_vnic *nesvnic = netdev_priv(netdev);
1432 struct nes_device *nesdev = nesvnic->nesdev;
1433 u32 u32temp;
1434
1435 if (et_pauseparam->autoneg) {
1436 /* TODO: should return unsupported */
1437 return 0;
1438 }
1439 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1440 u32temp = nes_read_indexed(nesdev,
1441 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1442 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1443 nes_write_indexed(nesdev,
1444 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1445 nesdev->disable_tx_flow_control = 0;
1446 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1447 u32temp = nes_read_indexed(nesdev,
1448 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1449 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1450 nes_write_indexed(nesdev,
1451 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1452 nesdev->disable_tx_flow_control = 1;
1453 }
1454 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1455 u32temp = nes_read_indexed(nesdev,
1456 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1457 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1458 nes_write_indexed(nesdev,
1459 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1460 nesdev->disable_rx_flow_control = 0;
1461 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1462 u32temp = nes_read_indexed(nesdev,
1463 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1464 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1465 nes_write_indexed(nesdev,
1466 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1467 nesdev->disable_rx_flow_control = 1;
1468 }
1469
1470 return 0;
1471}
1472
1473
1474/**
1475 * nes_netdev_get_settings
1476 */
1477static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1478{
1479 struct nes_vnic *nesvnic = netdev_priv(netdev);
1480 struct nes_device *nesdev = nesvnic->nesdev;
1481 struct nes_adapter *nesadapter = nesdev->nesadapter;
4303565d
CT		 1482 u32 mac_index = nesdev->mac_index;
1483 u8 phy_type = nesadapter->phy_type[mac_index];
1484 u8 phy_index = nesadapter->phy_index[mac_index];
3c2d774c
GS		 1485 u16 phy_data;
1486
1487 et_cmd->duplex = DUPLEX_FULL;
7495ab68 1488 et_cmd->port = PORT_MII;
4303565d
CT		 1489 et_cmd->maxtxpkt = 511;
1490 et_cmd->maxrxpkt = 511;
0e1de5d6 1491
3c2d774c 1492 if (nesadapter->OneG_Mode) {
3c2d774c 1493 et_cmd->speed = SPEED_1000;
4303565d 1494 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
0e1de5d6
ES		 1495 et_cmd->supported = SUPPORTED_1000baseT_Full;
1496 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1497 et_cmd->autoneg = AUTONEG_DISABLE;
1498 et_cmd->transceiver = XCVR_INTERNAL;
4303565d 1499 et_cmd->phy_address = mac_index;
3c2d774c 1500 } else {
ce6e74f2 1501 unsigned long flags;
4303565d
CT		 1502 et_cmd->supported = SUPPORTED_1000baseT_Full
1503 | SUPPORTED_Autoneg;
1504 et_cmd->advertising = ADVERTISED_1000baseT_Full
1505 | ADVERTISED_Autoneg;
ce6e74f2 1506 spin_lock_irqsave(&nesadapter->phy_lock, flags);
4303565d 1507 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
ce6e74f2 1508 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
0e1de5d6
ES		 1509 if (phy_data & 0x1000)
1510 et_cmd->autoneg = AUTONEG_ENABLE;
1511 else
1512 et_cmd->autoneg = AUTONEG_DISABLE;
1513 et_cmd->transceiver = XCVR_EXTERNAL;
4303565d 1514 et_cmd->phy_address = phy_index;
3c2d774c 1515 }
4303565d
CT		 1516 return 0;
1517 }
09124e19
CT		 1518 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1519 (phy_type == NES_PHY_TYPE_SFP_D) ||
1520 (phy_type == NES_PHY_TYPE_KR)) {
4303565d
CT		 1521 et_cmd->transceiver = XCVR_EXTERNAL;
1522 et_cmd->port = PORT_FIBRE;
1523 et_cmd->supported = SUPPORTED_FIBRE;
1524 et_cmd->advertising = ADVERTISED_FIBRE;
1525 et_cmd->phy_address = phy_index;
3c2d774c 1526 } else {
4303565d
CT		 1527 et_cmd->transceiver = XCVR_INTERNAL;
1528 et_cmd->supported = SUPPORTED_10000baseT_Full;
1529 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1530 et_cmd->phy_address = mac_index;
3c2d774c 1531 }
4303565d
CT		 1532 et_cmd->speed = SPEED_10000;
1533 et_cmd->autoneg = AUTONEG_DISABLE;
3c2d774c
GS		 1534 return 0;
1535}
1536
1537
1538/**
1539 * nes_netdev_set_settings
1540 */
1541static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1542{
1543 struct nes_vnic *nesvnic = netdev_priv(netdev);
1544 struct nes_device *nesdev = nesvnic->nesdev;
1545 struct nes_adapter *nesadapter = nesdev->nesadapter;
3c2d774c 1546
0e1de5d6
ES		 1547 if ((nesadapter->OneG_Mode) &&
1548 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
ce6e74f2
CT		 1549 unsigned long flags;
1550 u16 phy_data;
1551 u8 phy_index = nesadapter->phy_index[nesdev->mac_index];
1552
1553 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1554 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
3c2d774c
GS		 1555 if (et_cmd->autoneg) {
1556 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1557 phy_data |= 0x1300;
1558 } else {
7495ab68 1559 /* Turn off autoneg */
3c2d774c
GS		 1560 phy_data &= ~0x1000;
1561 }
ce6e74f2
CT		 1562 nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data);
1563 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
3c2d774c
GS		 1564 }
1565
1566 return 0;
1567}
1568
1569
0fc0b732 1570static const struct ethtool_ops nes_ethtool_ops = {
3c2d774c
GS		 1571 .get_link = ethtool_op_get_link,
1572 .get_settings = nes_netdev_get_settings,
1573 .set_settings = nes_netdev_set_settings,
1574 .get_tx_csum = ethtool_op_get_tx_csum,
1575 .get_rx_csum = nes_netdev_get_rx_csum,
1576 .get_sg = ethtool_op_get_sg,
1577 .get_strings = nes_netdev_get_strings,
15f0a394 1578 .get_sset_count = nes_netdev_get_sset_count,
3c2d774c
GS		 1579 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1580 .get_drvinfo = nes_netdev_get_drvinfo,
1581 .get_coalesce = nes_netdev_get_coalesce,
1582 .set_coalesce = nes_netdev_set_coalesce,
1583 .get_pauseparam = nes_netdev_get_pauseparam,
1584 .set_pauseparam = nes_netdev_set_pauseparam,
1585 .set_tx_csum = ethtool_op_set_tx_csum,
1586 .set_rx_csum = nes_netdev_set_rx_csum,
1587 .set_sg = ethtool_op_set_sg,
1588 .get_tso = ethtool_op_get_tso,
1589 .set_tso = ethtool_op_set_tso,
37dab411
FL		 1590 .get_flags = ethtool_op_get_flags,
1591 .set_flags = ethtool_op_set_flags,
3c2d774c
GS		 1592};
1593
1594
1595static void nes_netdev_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
1596{
1597 struct nes_vnic *nesvnic = netdev_priv(netdev);
1598 struct nes_device *nesdev = nesvnic->nesdev;
edd2fd64 1599 struct nes_adapter *nesadapter = nesdev->nesadapter;
3c2d774c 1600 u32 u32temp;
edd2fd64 1601 unsigned long flags;
3c2d774c 1602
edd2fd64 1603 spin_lock_irqsave(&nesadapter->phy_lock, flags);
3c2d774c
GS		 1604 nesvnic->vlan_grp = grp;
1605
edd2fd64
CT		 1606 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1607
3c2d774c
GS		 1608 /* Enable/Disable VLAN Stripping */
1609 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1610 if (grp)
1611 u32temp &= 0xfdffffff;
1612 else
1613 u32temp |= 0x02000000;
1614
1615 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
edd2fd64 1616 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
3c2d774c
GS		 1617}
1618
d0929553
SH		 1619static const struct net_device_ops nes_netdev_ops = {
1620 .ndo_open = nes_netdev_open,
1621 .ndo_stop = nes_netdev_stop,
1622 .ndo_start_xmit = nes_netdev_start_xmit,
1623 .ndo_get_stats = nes_netdev_get_stats,
1624 .ndo_tx_timeout = nes_netdev_tx_timeout,
1625 .ndo_set_mac_address = nes_netdev_set_mac_address,
1626 .ndo_set_multicast_list = nes_netdev_set_multicast_list,
1627 .ndo_change_mtu = nes_netdev_change_mtu,
d0929553
SH		 1628 .ndo_validate_addr = eth_validate_addr,
1629 .ndo_vlan_rx_register = nes_netdev_vlan_rx_register,
1630};
3c2d774c
GS		 1631
1632/**
1633 * nes_netdev_init - initialize network device
1634 */
1635struct net_device *nes_netdev_init(struct nes_device *nesdev,
1636 void __iomem *mmio_addr)
1637{
1638 u64 u64temp;
13220a94 1639 struct nes_vnic *nesvnic;
3c2d774c
GS		 1640 struct net_device *netdev;
1641 struct nic_qp_map *curr_qp_map;
09124e19 1642 u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
3c2d774c
GS		 1643
1644 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1645 if (!netdev) {
1646 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1647 return NULL;
1648 }
13220a94 1649 nesvnic = netdev_priv(netdev);
3c2d774c
GS		 1650
1651 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1652
1653 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1654
3c2d774c
GS		 1655 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1656 netdev->irq = nesdev->pcidev->irq;
1657 netdev->mtu = ETH_DATA_LEN;
1658 netdev->hard_header_len = ETH_HLEN;
1659 netdev->addr_len = ETH_ALEN;
1660 netdev->type = ARPHRD_ETHER;
1661 netdev->features = NETIF_F_HIGHDMA;
d0929553 1662 netdev->netdev_ops = &nes_netdev_ops;
3c2d774c
GS		 1663 netdev->ethtool_ops = &nes_ethtool_ops;
1664 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1665 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1666 netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
3c2d774c
GS		 1667
1668 /* Fill in the port structure */
1669 nesvnic->netdev = netdev;
1670 nesvnic->nesdev = nesdev;
1671 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1672 nesvnic->netdev_index = nesdev->netdev_count;
1673 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
edd2fd64 1674 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
3c2d774c
GS		 1675
1676 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1677 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1678 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1679 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1680
1681 /* Setup the burned in MAC address */
1682 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1683 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1684 u64temp += nesvnic->nic_index;
1685 netdev->dev_addr[0] = (u8)(u64temp>>40);
1686 netdev->dev_addr[1] = (u8)(u64temp>>32);
1687 netdev->dev_addr[2] = (u8)(u64temp>>24);
1688 netdev->dev_addr[3] = (u8)(u64temp>>16);
1689 netdev->dev_addr[4] = (u8)(u64temp>>8);
1690 netdev->dev_addr[5] = (u8)u64temp;
1691 memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1692
1693 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV)) {
1694 netdev->features |= NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1695 netdev->features |= NETIF_F_GSO | NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1696 } else {
1697 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1698 }
1699
1700 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1701 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1702 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1703 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1704
7e36d3d7
VM		 1705 if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1706 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1707
3c2d774c
GS		 1708 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1709 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1710 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1711 nesvnic->qp_nic_index[2] = 0xf;
1712 nesvnic->qp_nic_index[3] = 0xf;
1713 } else {
1714 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1715 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1716 }
1717 } else {
7e36d3d7
VM		 1718 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1719 (nesvnic->nesdev->nesadapter->port_count == 1 &&
1720 nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1721 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1722 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1723 + 2;
1724 nesvnic->qp_nic_index[2] = 0xf;
1725 nesvnic->qp_nic_index[3] = 0xf;
3c2d774c
GS		 1726 } else {
1727 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1728 nesvnic->qp_nic_index[1] = 0xf;
1729 nesvnic->qp_nic_index[2] = 0xf;
1730 nesvnic->qp_nic_index[3] = 0xf;
1731 }
1732 }
1733 nesvnic->next_qp_nic_index = 0;
1734
1735 if (nesdev->netdev_count == 0) {
1736 nesvnic->rdma_enabled = 1;
1737 } else {
1738 nesvnic->rdma_enabled = 0;
1739 }
1740 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1741 spin_lock_init(&nesvnic->tx_lock);
1742 nesdev->netdev[nesdev->netdev_count] = netdev;
1743
1744 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1745 nesvnic, nesdev->mac_index);
1746 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1747
1748 if ((nesdev->netdev_count == 0) &&
0e1de5d6 1749 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
09124e19 1750 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
0e1de5d6
ES		 1751 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1752 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
a72042c0
CT		 1753 u32 u32temp;
1754 u32 link_mask;
1755 u32 link_val;
1756
3c2d774c 1757 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
0e1de5d6 1758 (0x200 * (nesdev->mac_index & 1)));
09124e19 1759 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
0e1de5d6
ES		 1760 u32temp |= 0x00200000;
1761 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1762 (0x200 * (nesdev->mac_index & 1)), u32temp);
1763 }
1764
a72042c0
CT		 1765 /* Check and set linkup here. This is for back to back */
1766 /* configuration where second port won't get link interrupt */
1767 switch (phy_type) {
1768 case NES_PHY_TYPE_PUMA_1G:
1769 if (nesdev->mac_index < 2) {
1770 link_mask = 0x01010000;
1771 link_val = 0x01010000;
1772 } else {
1773 link_mask = 0x02020000;
1774 link_val = 0x02020000;
1775 }
1776 break;
1777 default:
1778 link_mask = 0x0f1f0000;
1779 link_val = 0x0f0f0000;
1780 break;
1781 }
1782
1783 u32temp = nes_read_indexed(nesdev,
1784 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1785 (0x200 * (nesdev->mac_index & 1)));
1786 if ((u32temp & link_mask) == link_val)
1787 nesvnic->linkup = 1;
1788
3c2d774c 1789 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
11e0704b 1790 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
3c2d774c 1791 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
11e0704b 1792 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
3c2d774c 1793
09124e19 1794 nes_init_phy(nesdev);
3c2d774c
GS		 1795 }
1796
1797 return netdev;
1798}
1799
1800
1801/**
1802 * nes_netdev_destroy - destroy network device structure
1803 */
1804void nes_netdev_destroy(struct net_device *netdev)
1805{
1806 struct nes_vnic *nesvnic = netdev_priv(netdev);
1807
1808 /* make sure 'stop' method is called by Linux stack */
1809 /* nes_netdev_stop(netdev); */
1810
1811 list_del(&nesvnic->list);
1812
1813 if (nesvnic->of_device_registered) {
1814 nes_destroy_ofa_device(nesvnic->nesibdev);
1815 }
1816
1817 free_netdev(netdev);
1818}
1819
1820
1821/**
1822 * nes_nic_cm_xmit -- CM calls this to send out pkts
1823 */
1824int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1825{
1826 int ret;
1827
1828 skb->dev = netdev;
1829 ret = dev_queue_xmit(skb);
1830 if (ret) {
1831 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1832 }
1833
1834 return ret;
1835}
Linux kernel - Deliverables
This page took 0.360623 seconds and 5 git commands to generate.