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