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