]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blame - drivers/infiniband/hw/nes/nes_nic.c
projects / mirror_ubuntu-bionic-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
RDMA/nes: Replace LRO with GRO
[mirror_ubuntu-bionic-kernel.git] / drivers / infiniband / hw / nes / nes_nic.c
CommitLineData
3c2d774c 1/*
c5488c57 2 * Copyright (c) 2006 - 2011 Intel Corporation. All rights reserved.
3c2d774c
GS		 3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 *
32 */
33
34#include <linux/module.h>
35#include <linux/moduleparam.h>
36#include <linux/netdevice.h>
37#include <linux/etherdevice.h>
38#include <linux/ip.h>
39#include <linux/tcp.h>
40#include <linux/if_arp.h>
41#include <linux/if_vlan.h>
42#include <linux/ethtool.h>
5a0e3ad6 43#include <linux/slab.h>
3c2d774c
GS		 44#include <net/tcp.h>
45
46#include <net/inet_common.h>
47#include <linux/inet.h>
48
49#include "nes.h"
50
51static struct nic_qp_map nic_qp_mapping_0[] = {
52 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
53 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
54 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
55 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
56};
57
58static struct nic_qp_map nic_qp_mapping_1[] = {
59 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
60 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
61};
62
63static struct nic_qp_map nic_qp_mapping_2[] = {
64 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
65};
66
67static struct nic_qp_map nic_qp_mapping_3[] = {
68 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
69};
70
71static struct nic_qp_map nic_qp_mapping_4[] = {
72 {28,8,0,0},{32,12,0,0}
73};
74
75static struct nic_qp_map nic_qp_mapping_5[] = {
76 {29,9,1,0},{33,13,1,0}
77};
78
79static struct nic_qp_map nic_qp_mapping_6[] = {
80 {30,10,2,0},{34,14,2,0}
81};
82
83static struct nic_qp_map nic_qp_mapping_7[] = {
84 {31,11,3,0},{35,15,3,0}
85};
86
87static struct nic_qp_map *nic_qp_mapping_per_function[] = {
88 nic_qp_mapping_0, nic_qp_mapping_1, nic_qp_mapping_2, nic_qp_mapping_3,
89 nic_qp_mapping_4, nic_qp_mapping_5, nic_qp_mapping_6, nic_qp_mapping_7
90};
91
92static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
93 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
94static int debug = -1;
7e36d3d7 95static int nics_per_function = 1;
3c2d774c 96
3c2d774c
GS		 97/**
98 * nes_netdev_poll
99 */
100static int nes_netdev_poll(struct napi_struct *napi, int budget)
101{
102 struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi);
3c2d774c
GS		 103 struct nes_device *nesdev = nesvnic->nesdev;
104 struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq;
105
106 nesvnic->budget = budget;
107 nescq->cqes_pending = 0;
108 nescq->rx_cqes_completed = 0;
109 nescq->cqe_allocs_pending = 0;
110 nescq->rx_pkts_indicated = 0;
111
112 nes_nic_ce_handler(nesdev, nescq);
113
114 if (nescq->cqes_pending == 0) {
288379f0 115 napi_complete(napi);
3c2d774c
GS		 116 /* clear out completed cqes and arm */
117 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
118 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
119 nes_read32(nesdev->regs+NES_CQE_ALLOC);
120 } else {
121 /* clear out completed cqes but don't arm */
122 nes_write32(nesdev->regs+NES_CQE_ALLOC,
123 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
124 nes_debug(NES_DBG_NETDEV, "%s: exiting with work pending\n",
125 nesvnic->netdev->name);
126 }
127 return nescq->rx_pkts_indicated;
128}
129
130
131/**
132 * nes_netdev_open - Activate the network interface; ifconfig
133 * ethx up.
134 */
135static int nes_netdev_open(struct net_device *netdev)
136{
137 u32 macaddr_low;
138 u16 macaddr_high;
139 struct nes_vnic *nesvnic = netdev_priv(netdev);
140 struct nes_device *nesdev = nesvnic->nesdev;
141 int ret;
142 int i;
11e0704b 143 struct nes_vnic *first_nesvnic = NULL;
3c2d774c
GS		 144 u32 nic_active_bit;
145 u32 nic_active;
11e0704b 146 struct list_head *list_pos, *list_temp;
ea623455 147 unsigned long flags;
3c2d774c
GS		 148
149 assert(nesdev != NULL);
150
11e0704b
GS		 151 if (nesvnic->netdev_open == 1)
152 return 0;
3c2d774c
GS		 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
7495ab68 190 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
3c2d774c 191 macaddr_high += (u16)netdev->dev_addr[1];
7495ab68
GS		 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];
3c2d774c
GS		 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],
7e36d3d7
VM		 206 NES_IDX_PERFECT_FILTER_LOW+
207 (nesvnic->qp_nic_index[i] * 8),
3c2d774c
GS		 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);
11e0704b
GS		 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 }
cd6860eb 236
3c2d774c
GS		 237 if (first_nesvnic->linkup) {
238 /* Enable network packets */
239 nesvnic->linkup = 1;
240 netif_start_queue(netdev);
241 netif_carrier_on(netdev);
242 }
ea623455 243
843276ad
MS		 244 spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
245 if (nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_SFP_D) {
843276ad 246 nesdev->link_recheck = 1;
41f63c53
TH		 247 mod_delayed_work(system_wq, &nesdev->work,
248 NES_LINK_RECHECK_DELAY);
843276ad
MS		 249 }
250 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
251
ea623455
MS		 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
3c2d774c
GS		 266 napi_enable(&nesvnic->napi);
267 nesvnic->netdev_open = 1;
268
269 return 0;
270}
271
272
273/**
274 * nes_netdev_stop
275 */
276static 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;
11e0704b
GS		 282 struct nes_vnic *first_nesvnic = NULL;
283 struct list_head *list_pos, *list_temp;
ea623455 284 unsigned long flags;
3c2d774c
GS		 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);
52106bd2 293 netif_carrier_off(netdev);
3c2d774c
GS		 294
295 /* Disable network packets */
296 napi_disable(&nesvnic->napi);
297 netif_stop_queue(netdev);
11e0704b
GS		 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
068e80de
CT		 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 {
11e0704b 315 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+(0x200*nesdev->mac_index), 0xffffffff);
3c2d774c
GS		 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
ea623455 337 spin_lock_irqsave(&nesvnic->port_ibevent_lock, flags);
3c2d774c 338 if (nesvnic->of_device_registered) {
cd6860eb
FL		 339 nesdev->nesadapter->send_term_ok = 0;
340 nesdev->iw_status = 0;
ea623455
MS		 341 if (nesvnic->linkup == 1)
342 nes_port_ibevent(nesvnic);
3c2d774c 343 }
ea623455
MS		 344 del_timer_sync(&nesvnic->event_timer);
345 nesvnic->event_timer.function = NULL;
346 spin_unlock_irqrestore(&nesvnic->port_ibevent_lock, flags);
347
3c2d774c
GS		 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 */
359static 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 */
df8a39de 376 if (skb_vlan_tag_present(skb)) {
3c2d774c 377 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
df8a39de 378 netdev->name, skb_vlan_tag_get(skb));
3c2d774c 379 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
df8a39de 380 wqe_fragment_length[0] = (__force __le16) skb_vlan_tag_get(skb);
3c2d774c
GS		 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]; */
48a99563 387 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
3c2d774c
GS		 388
389 if (skb->ip_summed == CHECKSUM_PARTIAL) {
48a99563
TN		 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));
3c2d774c
GS		 398 }
399 } else { /* CHECKSUM_HW */
48a99563 400 wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM;
3c2d774c
GS		 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;
2869975c 432 nesnic->tx_skb[nesnic->sq_head] = skb;
3c2d774c
GS		 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++) {
cf383ebb
IC		 439 skb_frag_t *frag =
440 &skb_shinfo(skb)->frags[skb_fragment_index];
441 bus_address = skb_frag_dma_map(&nesdev->pcidev->dev,
9e903e08 442 frag, 0, skb_frag_size(frag),
5d6bcdfe 443 DMA_TO_DEVICE);
3c2d774c 444 wqe_fragment_length[wqe_fragment_index] =
9e903e08 445 cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[skb_fragment_index]));
3c2d774c
GS		 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 */
465static 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; */
a06fd26d 473#define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
3c2d774c
GS		 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;
3c2d774c
GS		 484 __le16 *wqe_fragment_length;
485 u32 nr_frags;
486 u32 original_first_length;
7495ab68 487 /* u64 *wqe_fragment_address; */
3c2d774c
GS		 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;
3c2d774c
GS		 494 u32 wqe_misc;
495
7495ab68
GS		 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 */
3c2d774c
GS		 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
3c2d774c
GS		 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++;
3c2d774c
GS		 520 return NETDEV_TX_BUSY;
521 }
522
523sq_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++;
3c2d774c
GS		 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++;
3c2d774c
GS		 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 }
555tso_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++) {
cf383ebb
IC		 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,
9e903e08 563 frag, 0, skb_frag_size(frag),
5d6bcdfe 564 DMA_TO_DEVICE);
3c2d774c
GS		 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 */
df8a39de 579 if (skb_vlan_tag_present(skb)) {
3c2d774c 580 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
df8a39de
JP		 581 netdev->name,
582 skb_vlan_tag_get(skb));
3c2d774c 583 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
df8a39de 584 wqe_fragment_length[0] = (__force __le16) skb_vlan_tag_get(skb);
3c2d774c
GS		 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,"
6ad1be81 596 " (%u frags), is_gso = %u tso_size=%u\n",
3c2d774c
GS		 597 netdev->name,
598 skb->len, skb_headlen(skb),
6ad1be81 599 skb_shinfo(skb)->nr_frags, skb_is_gso(skb), skb_shinfo(skb)->gso_size);
3c2d774c
GS		 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);
168ac824
CT		 631 tso_wqe_length += skb_headlen(skb) -
632 original_first_length;
3c2d774c
GS		 633 }
634 while (wqe_fragment_index < 5) {
635 wqe_fragment_length[wqe_fragment_index] =
9e903e08 636 cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index]));
3c2d774c
GS		 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++;
9e903e08 640 tso_wqe_length += skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index++]);
3c2d774c
GS		 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 }
6ad1be81
TN		 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) {
3c2d774c
GS		 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);
2869975c 677 if (send_rc != NETDEV_TX_OK)
3c2d774c 678 return NETDEV_TX_OK;
3c2d774c
GS		 679 }
680 } else {
681 send_rc = nes_nic_send(skb, netdev);
2869975c 682 if (send_rc != NETDEV_TX_OK)
3c2d774c 683 return NETDEV_TX_OK;
3c2d774c
GS		 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;
3c2d774c
GS		 693
694 return NETDEV_TX_OK;
695}
696
697
698/**
699 * nes_netdev_get_stats
700 */
701static 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 */
792static 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 */
804static 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);
e174961c
JB		 817 printk(PFX "%s: Address length = %d, Address = %pM\n",
818 __func__, netdev->addr_len, mac_addr->sa_data);
7495ab68 819 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
3c2d774c 820 macaddr_high += (u16)netdev->dev_addr[1];
7495ab68
GS		 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];
3c2d774c
GS		 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
fbf219f1
JP		 842static 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
3c2d774c
GS		 856/**
857 * nes_netdev_set_multicast_list
858 */
1a855fbf 859static void nes_netdev_set_multicast_list(struct net_device *netdev)
3c2d774c
GS		 860{
861 struct nes_vnic *nesvnic = netdev_priv(netdev);
862 struct nes_device *nesdev = nesvnic->nesdev;
7e36d3d7 863 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
3c2d774c
GS		 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;
7e36d3d7
VM		 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;
fbf219f1 876 int mc_count = netdev_mc_count(netdev);
3c2d774c 877
7e36d3d7 878 spin_lock_irqsave(&nesadapter->resource_lock, flags);
3c2d774c
GS		 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;
7e36d3d7 889 } else if ((netdev->flags & IFF_ALLMULTI) ||
3c2d774c 890 (nesvnic->nic_index > 3)) {
fbf219f1 891 set_allmulti(nesdev, nic_active_bit);
3c2d774c
GS		 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
25985edc 902 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscuous = %d, All Multicast = %d.\n",
fbf219f1 903 mc_count, !!(netdev->flags & IFF_PROMISC),
7e36d3d7 904 !!(netdev->flags & IFF_ALLMULTI));
3c2d774c 905 if (!mc_all_on) {
fbf219f1
JP		 906 char *addrs;
907 int i;
22bedad3 908 struct netdev_hw_addr *ha;
fbf219f1
JP		 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;
22bedad3
JP		 916 netdev_for_each_mc_addr(ha, netdev)
917 memcpy(get_addr(addrs, i++), ha->addr, ETH_ALEN);
fbf219f1 918
7e36d3d7
VM		 919 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW +
920 pft_entries_preallocated * 0x8;
fbf219f1
JP		 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 &&
7e36d3d7 924 ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
fbf219f1 925 get_addr(addrs, i++))) == 0));
3c2d774c
GS		 926 if (mc_nic_index < 0)
927 mc_nic_index = nesvnic->nic_index;
7e36d3d7
VM		 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,
601d87b0
JP		 933 "mc_index=%d skipping nic_index=%d, "
934 "used for=%d \n", mc_index,
7e36d3d7
VM		 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;
fbf219f1
JP		 941 if (i < mc_count) {
942 char *addr = get_addr(addrs, i++);
943
e174961c 944 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
fbf219f1 945 addr,
2bd01c5d
RD		 946 perfect_filter_register_address+(mc_index * 8),
947 mc_nic_index);
cecdcd5f
TN		 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
3c2d774c
GS		 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)));
7e36d3d7
VM		 962 nesadapter->pft_mcast_map[mc_index] =
963 nesvnic->nic_index;
3c2d774c
GS		 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);
7e36d3d7 970 nesadapter->pft_mcast_map[mc_index] = 255;
3c2d774c
GS		 971 }
972 }
fbf219f1 973 kfree(addrs);
7e36d3d7 974 /* PFT is not large enough */
fbf219f1
JP		 975 if (i < mc_count)
976 set_allmulti(nesdev, nic_active_bit);
3c2d774c 977 }
7e36d3d7 978
fbf219f1 979unlock:
7e36d3d7 980 spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
3c2d774c
GS		 981}
982
983
984/**
985 * nes_netdev_change_mtu
986 */
7495ab68 987static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
3c2d774c
GS		 988{
989 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68
GS		 990 struct nes_device *nesdev = nesvnic->nesdev;
991 int ret = 0;
992 u8 jumbomode = 0;
e0e31afb
BS		 993 u32 nic_active;
994 u32 nic_active_bit;
995 u32 uc_all_active;
996 u32 mc_all_active;
3c2d774c 997
7495ab68 998 if ((new_mtu < ETH_ZLEN) || (new_mtu > max_mtu))
3c2d774c
GS		 999 return -EINVAL;
1000
7495ab68 1001 netdev->mtu = new_mtu;
edd2fd64 1002 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
3c2d774c
GS		 1003
1004 if (netdev->mtu > 1500) {
1005 jumbomode=1;
1006 }
7495ab68 1007 nes_nic_init_timer_defaults(nesdev, jumbomode);
3c2d774c
GS		 1008
1009 if (netif_running(netdev)) {
e0e31afb
BS		 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
3c2d774c
GS		 1016 nes_netdev_stop(netdev);
1017 nes_netdev_open(netdev);
e0e31afb
BS		 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);
3c2d774c
GS		 1028 }
1029
1030 return ret;
1031}
1032
39942a02 1033
37dab411 1034static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
3c2d774c
GS		 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",
3c2d774c
GS		 1042 "SQ Full",
1043 "Segmented TSO Requests",
1044 "Rx Symbol Errors",
1045 "Rx Jabber Errors",
1046 "Rx Oversized Frames",
1047 "Rx Short Frames",
39942a02
FL		 1048 "Rx Length Errors",
1049 "Rx CRC Errors",
1050 "Rx Port Discard",
3c2d774c
GS		 1051 "Endnode Rx Discards",
1052 "Endnode Rx Octets",
1053 "Endnode Rx Frames",
1054 "Endnode Tx Octets",
1055 "Endnode Tx Frames",
39942a02 1056 "Tx Errors",
3c2d774c
GS		 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",
39942a02
FL		 1085 "Free 4Kpbls",
1086 "Free 256pbls",
3c2d774c 1087 "Timer Inits",
0f0bee8b
FL		 1088 "PAU CreateQPs",
1089 "PAU DestroyQPs",
3c2d774c 1090};
37dab411 1091#define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
3c2d774c 1092
3c2d774c
GS		 1093
1094/**
15f0a394 1095 * nes_netdev_get_sset_count
3c2d774c 1096 */
15f0a394 1097static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
3c2d774c 1098{
15f0a394
BH		 1099 if (stringset == ETH_SS_STATS)
1100 return NES_ETHTOOL_STAT_COUNT;
1101 else
1102 return -EINVAL;
3c2d774c
GS		 1103}
1104
1105
1106/**
1107 * nes_netdev_get_strings
1108 */
1109static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1110 u8 *ethtool_strings)
1111{
1112 if (stringset == ETH_SS_STATS)
1113 memcpy(ethtool_strings,
1114 &nes_ethtool_stringset,
1115 sizeof(nes_ethtool_stringset));
1116}
1117
1118
1119/**
1120 * nes_netdev_get_ethtool_stats
1121 */
39942a02 1122
3c2d774c
GS		 1123static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1124 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1125{
1126 u64 u64temp;
1127 struct nes_vnic *nesvnic = netdev_priv(netdev);
1128 struct nes_device *nesdev = nesvnic->nesdev;
39942a02 1129 struct nes_adapter *nesadapter = nesdev->nesadapter;
3c2d774c
GS		 1130 u32 nic_count;
1131 u32 u32temp;
2869975c 1132 u32 index = 0;
3c2d774c
GS		 1133
1134 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
2869975c
FL		 1135 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1136 target_stat_values[++index] = nesvnic->linearized_skbs;
1137 target_stat_values[++index] = nesvnic->tso_requests;
3c2d774c
GS		 1138
1139 u32temp = nes_read_indexed(nesdev,
1140 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1141 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
2869975c 1142 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
3c2d774c
GS		 1143
1144 u32temp = nes_read_indexed(nesdev,
1145 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1146 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1147
1148 u32temp = nes_read_indexed(nesdev,
1149 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1150 nesvnic->nesdev->port_rx_discards += u32temp;
1151 nesvnic->netstats.rx_dropped += u32temp;
1152
1153 u32temp = nes_read_indexed(nesdev,
1154 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1155 nesvnic->nesdev->port_tx_discards += u32temp;
1156 nesvnic->netstats.tx_dropped += u32temp;
1157
39942a02
FL		 1158 u32temp = nes_read_indexed(nesdev,
1159 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1160 nesvnic->netstats.rx_dropped += u32temp;
1161 nesvnic->nesdev->mac_rx_errors += u32temp;
1162 nesvnic->nesdev->mac_rx_short_frames += u32temp;
1163
1164 u32temp = nes_read_indexed(nesdev,
1165 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1166 nesvnic->netstats.rx_dropped += u32temp;
1167 nesvnic->nesdev->mac_rx_errors += u32temp;
1168 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
1169
1170 u32temp = nes_read_indexed(nesdev,
1171 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1172 nesvnic->netstats.rx_dropped += u32temp;
1173 nesvnic->nesdev->mac_rx_errors += u32temp;
1174 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
1175
1176 u32temp = nes_read_indexed(nesdev,
1177 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1178 nesvnic->netstats.rx_dropped += u32temp;
1179 nesvnic->nesdev->mac_rx_errors += u32temp;
1180 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
1181
1182 u32temp = nes_read_indexed(nesdev,
1183 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1184 nesvnic->netstats.rx_length_errors += u32temp;
1185 nesvnic->nesdev->mac_rx_errors += u32temp;
1186
1187 u32temp = nes_read_indexed(nesdev,
1188 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1189 nesvnic->nesdev->mac_rx_errors += u32temp;
1190 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
1191 nesvnic->netstats.rx_crc_errors += u32temp;
1192
1193 u32temp = nes_read_indexed(nesdev,
1194 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
1195 nesvnic->nesdev->mac_tx_errors += u32temp;
1196 nesvnic->netstats.tx_errors += u32temp;
1197
3c2d774c
GS		 1198 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1199 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1200 break;
1201
1202 u32temp = nes_read_indexed(nesdev,
1203 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1204 (nesvnic->qp_nic_index[nic_count]*0x200));
1205 nesvnic->netstats.rx_dropped += u32temp;
1206 nesvnic->endnode_nstat_rx_discard += u32temp;
1207
1208 u64temp = (u64)nes_read_indexed(nesdev,
1209 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1210 (nesvnic->qp_nic_index[nic_count]*0x200));
1211 u64temp += ((u64)nes_read_indexed(nesdev,
1212 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1213 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1214
1215 nesvnic->endnode_nstat_rx_octets += u64temp;
1216 nesvnic->netstats.rx_bytes += u64temp;
1217
1218 u64temp = (u64)nes_read_indexed(nesdev,
1219 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1220 (nesvnic->qp_nic_index[nic_count]*0x200));
1221 u64temp += ((u64)nes_read_indexed(nesdev,
1222 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1223 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1224
1225 nesvnic->endnode_nstat_rx_frames += u64temp;
1226 nesvnic->netstats.rx_packets += u64temp;
1227
1228 u64temp = (u64)nes_read_indexed(nesdev,
1229 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1230 (nesvnic->qp_nic_index[nic_count]*0x200));
1231 u64temp += ((u64)nes_read_indexed(nesdev,
1232 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1233 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1234
1235 nesvnic->endnode_nstat_tx_octets += u64temp;
1236 nesvnic->netstats.tx_bytes += u64temp;
1237
1238 u64temp = (u64)nes_read_indexed(nesdev,
1239 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1240 (nesvnic->qp_nic_index[nic_count]*0x200));
1241 u64temp += ((u64)nes_read_indexed(nesdev,
1242 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1243 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1244
1245 nesvnic->endnode_nstat_tx_frames += u64temp;
1246 nesvnic->netstats.tx_packets += u64temp;
1247
1248 u32temp = nes_read_indexed(nesdev,
1249 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1250 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1251 }
1252
2869975c
FL		 1253 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1254 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1255 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1256 target_stat_values[++index] = nesvnic->sq_full;
1257 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1258 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1259 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1260 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1261 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
39942a02
FL		 1262 target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
1263 target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
1264 target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
2869975c
FL		 1265 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1266 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1267 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1268 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1269 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
39942a02 1270 target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
2869975c
FL		 1271 target_stat_values[++index] = mh_detected;
1272 target_stat_values[++index] = mh_pauses_sent;
1273 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1274 target_stat_values[++index] = atomic_read(&cm_connects);
1275 target_stat_values[++index] = atomic_read(&cm_accepts);
1276 target_stat_values[++index] = atomic_read(&cm_disconnects);
1277 target_stat_values[++index] = atomic_read(&cm_connecteds);
1278 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1279 target_stat_values[++index] = atomic_read(&cm_rejects);
1280 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1281 target_stat_values[++index] = atomic_read(&qps_created);
1282 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1283 target_stat_values[++index] = atomic_read(&qps_destroyed);
1284 target_stat_values[++index] = atomic_read(&cm_closes);
1285 target_stat_values[++index] = cm_packets_sent;
1286 target_stat_values[++index] = cm_packets_bounced;
1287 target_stat_values[++index] = cm_packets_created;
1288 target_stat_values[++index] = cm_packets_received;
1289 target_stat_values[++index] = cm_packets_dropped;
1290 target_stat_values[++index] = cm_packets_retrans;
6e10d2e4
FL		 1291 target_stat_values[++index] = atomic_read(&cm_listens_created);
1292 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
2869975c
FL		 1293 target_stat_values[++index] = cm_backlog_drops;
1294 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1295 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1296 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1297 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1298 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
39942a02
FL		 1299 target_stat_values[++index] = nesadapter->free_4kpbl;
1300 target_stat_values[++index] = nesadapter->free_256pbl;
2869975c 1301 target_stat_values[++index] = int_mod_timer_init;
0f0bee8b
FL		 1302 target_stat_values[++index] = atomic_read(&pau_qps_created);
1303 target_stat_values[++index] = atomic_read(&pau_qps_destroyed);
3c2d774c
GS		 1304}
1305
3c2d774c
GS		 1306/**
1307 * nes_netdev_get_drvinfo
1308 */
1309static void nes_netdev_get_drvinfo(struct net_device *netdev,
1310 struct ethtool_drvinfo *drvinfo)
1311{
1312 struct nes_vnic *nesvnic = netdev_priv(netdev);
0c93ae35 1313 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
3c2d774c 1314
7826d43f
JP		 1315 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
1316 strlcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev),
1317 sizeof(drvinfo->bus_info));
1318 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1319 "%u.%u", nesadapter->firmware_version >> 16,
1320 nesadapter->firmware_version & 0x000000ff);
1321 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
3c2d774c
GS		 1322}
1323
1324
1325/**
1326 * nes_netdev_set_coalesce
1327 */
1328static int nes_netdev_set_coalesce(struct net_device *netdev,
1329 struct ethtool_coalesce *et_coalesce)
1330{
1331 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68 1332 struct nes_device *nesdev = nesvnic->nesdev;
3c2d774c
GS		 1333 struct nes_adapter *nesadapter = nesdev->nesadapter;
1334 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1335 unsigned long flags;
1336
7495ab68 1337 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
3c2d774c 1338 if (et_coalesce->rx_max_coalesced_frames_low) {
7495ab68 1339 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
3c2d774c
GS		 1340 }
1341 if (et_coalesce->rx_max_coalesced_frames_irq) {
1342 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1343 }
1344 if (et_coalesce->rx_max_coalesced_frames_high) {
1345 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1346 }
1347 if (et_coalesce->rx_coalesce_usecs_low) {
1348 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1349 }
1350 if (et_coalesce->rx_coalesce_usecs_high) {
1351 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1352 }
1353 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1354
1355 /* using this to drive total interrupt moderation */
1356 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1357 if (et_coalesce->use_adaptive_rx_coalesce) {
1358 nesadapter->et_use_adaptive_rx_coalesce = 1;
7495ab68 1359 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
3c2d774c
GS		 1360 nesadapter->et_rx_coalesce_usecs_irq = 0;
1361 if (et_coalesce->pkt_rate_low) {
7495ab68 1362 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
3c2d774c
GS		 1363 }
1364 } else {
1365 nesadapter->et_use_adaptive_rx_coalesce = 0;
7495ab68 1366 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
3c2d774c
GS		 1367 if (nesadapter->et_rx_coalesce_usecs_irq) {
1368 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1369 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1370 }
1371 }
1372 return 0;
1373}
1374
1375
1376/**
1377 * nes_netdev_get_coalesce
1378 */
1379static int nes_netdev_get_coalesce(struct net_device *netdev,
1380 struct ethtool_coalesce *et_coalesce)
1381{
1382 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68 1383 struct nes_device *nesdev = nesvnic->nesdev;
3c2d774c
GS		 1384 struct nes_adapter *nesadapter = nesdev->nesadapter;
1385 struct ethtool_coalesce temp_et_coalesce;
1386 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1387 unsigned long flags;
1388
1389 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
7495ab68
GS		 1390 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1391 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1392 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
3c2d774c
GS		 1393 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1394 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
7495ab68
GS		 1395 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1396 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
3c2d774c 1397 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
7495ab68 1398 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
3c2d774c
GS		 1399 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1400 if (nesadapter->et_use_adaptive_rx_coalesce) {
1401 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1402 }
1403 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
7495ab68 1404 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
3c2d774c
GS		 1405 return 0;
1406}
1407
1408
1409/**
1410 * nes_netdev_get_pauseparam
1411 */
1412static void nes_netdev_get_pauseparam(struct net_device *netdev,
1413 struct ethtool_pauseparam *et_pauseparam)
1414{
1415 struct nes_vnic *nesvnic = netdev_priv(netdev);
1416
1417 et_pauseparam->autoneg = 0;
1418 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1419 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1420}
1421
1422
1423/**
1424 * nes_netdev_set_pauseparam
1425 */
1426static int nes_netdev_set_pauseparam(struct net_device *netdev,
1427 struct ethtool_pauseparam *et_pauseparam)
1428{
1429 struct nes_vnic *nesvnic = netdev_priv(netdev);
1430 struct nes_device *nesdev = nesvnic->nesdev;
1431 u32 u32temp;
1432
1433 if (et_pauseparam->autoneg) {
1434 /* TODO: should return unsupported */
1435 return 0;
1436 }
1437 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1438 u32temp = nes_read_indexed(nesdev,
1439 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1440 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1441 nes_write_indexed(nesdev,
70c9db0f 1442 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
3c2d774c
GS		 1443 nesdev->disable_tx_flow_control = 0;
1444 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1445 u32temp = nes_read_indexed(nesdev,
1446 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1447 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1448 nes_write_indexed(nesdev,
70c9db0f 1449 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
3c2d774c
GS		 1450 nesdev->disable_tx_flow_control = 1;
1451 }
1452 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1453 u32temp = nes_read_indexed(nesdev,
1454 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1455 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1456 nes_write_indexed(nesdev,
1457 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1458 nesdev->disable_rx_flow_control = 0;
1459 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1460 u32temp = nes_read_indexed(nesdev,
1461 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1462 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1463 nes_write_indexed(nesdev,
1464 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1465 nesdev->disable_rx_flow_control = 1;
1466 }
1467
1468 return 0;
1469}
1470
1471
1472/**
1473 * nes_netdev_get_settings
1474 */
1475static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1476{
1477 struct nes_vnic *nesvnic = netdev_priv(netdev);
1478 struct nes_device *nesdev = nesvnic->nesdev;
1479 struct nes_adapter *nesadapter = nesdev->nesadapter;
4303565d
CT		 1480 u32 mac_index = nesdev->mac_index;
1481 u8 phy_type = nesadapter->phy_type[mac_index];
1482 u8 phy_index = nesadapter->phy_index[mac_index];
3c2d774c
GS		 1483 u16 phy_data;
1484
1485 et_cmd->duplex = DUPLEX_FULL;
7495ab68 1486 et_cmd->port = PORT_MII;
4303565d
CT		 1487 et_cmd->maxtxpkt = 511;
1488 et_cmd->maxrxpkt = 511;
0e1de5d6 1489
3c2d774c 1490 if (nesadapter->OneG_Mode) {
70739497 1491 ethtool_cmd_speed_set(et_cmd, SPEED_1000);
4303565d 1492 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
0e1de5d6
ES		 1493 et_cmd->supported = SUPPORTED_1000baseT_Full;
1494 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1495 et_cmd->autoneg = AUTONEG_DISABLE;
1496 et_cmd->transceiver = XCVR_INTERNAL;
4303565d 1497 et_cmd->phy_address = mac_index;
3c2d774c 1498 } else {
ce6e74f2 1499 unsigned long flags;
4303565d
CT		 1500 et_cmd->supported = SUPPORTED_1000baseT_Full
1501 | SUPPORTED_Autoneg;
1502 et_cmd->advertising = ADVERTISED_1000baseT_Full
1503 | ADVERTISED_Autoneg;
ce6e74f2 1504 spin_lock_irqsave(&nesadapter->phy_lock, flags);
4303565d 1505 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
ce6e74f2 1506 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
0e1de5d6
ES		 1507 if (phy_data & 0x1000)
1508 et_cmd->autoneg = AUTONEG_ENABLE;
1509 else
1510 et_cmd->autoneg = AUTONEG_DISABLE;
1511 et_cmd->transceiver = XCVR_EXTERNAL;
4303565d 1512 et_cmd->phy_address = phy_index;
3c2d774c 1513 }
4303565d
CT		 1514 return 0;
1515 }
09124e19
CT		 1516 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1517 (phy_type == NES_PHY_TYPE_SFP_D) ||
1518 (phy_type == NES_PHY_TYPE_KR)) {
4303565d
CT		 1519 et_cmd->transceiver = XCVR_EXTERNAL;
1520 et_cmd->port = PORT_FIBRE;
1521 et_cmd->supported = SUPPORTED_FIBRE;
1522 et_cmd->advertising = ADVERTISED_FIBRE;
1523 et_cmd->phy_address = phy_index;
3c2d774c 1524 } else {
4303565d
CT		 1525 et_cmd->transceiver = XCVR_INTERNAL;
1526 et_cmd->supported = SUPPORTED_10000baseT_Full;
1527 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1528 et_cmd->phy_address = mac_index;
3c2d774c 1529 }
70739497 1530 ethtool_cmd_speed_set(et_cmd, SPEED_10000);
4303565d 1531 et_cmd->autoneg = AUTONEG_DISABLE;
3c2d774c
GS		 1532 return 0;
1533}
1534
1535
1536/**
1537 * nes_netdev_set_settings
1538 */
1539static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1540{
1541 struct nes_vnic *nesvnic = netdev_priv(netdev);
1542 struct nes_device *nesdev = nesvnic->nesdev;
1543 struct nes_adapter *nesadapter = nesdev->nesadapter;
3c2d774c 1544
0e1de5d6
ES		 1545 if ((nesadapter->OneG_Mode) &&
1546 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
ce6e74f2
CT		 1547 unsigned long flags;
1548 u16 phy_data;
1549 u8 phy_index = nesadapter->phy_index[nesdev->mac_index];
1550
1551 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1552 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
3c2d774c
GS		 1553 if (et_cmd->autoneg) {
1554 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1555 phy_data |= 0x1300;
1556 } else {
7495ab68 1557 /* Turn off autoneg */
3c2d774c
GS		 1558 phy_data &= ~0x1000;
1559 }
ce6e74f2
CT		 1560 nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data);
1561 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
3c2d774c
GS		 1562 }
1563
1564 return 0;
1565}
1566
1567
0fc0b732 1568static const struct ethtool_ops nes_ethtool_ops = {
3c2d774c
GS		 1569 .get_link = ethtool_op_get_link,
1570 .get_settings = nes_netdev_get_settings,
1571 .set_settings = nes_netdev_set_settings,
3c2d774c 1572 .get_strings = nes_netdev_get_strings,
15f0a394 1573 .get_sset_count = nes_netdev_get_sset_count,
3c2d774c
GS		 1574 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1575 .get_drvinfo = nes_netdev_get_drvinfo,
1576 .get_coalesce = nes_netdev_get_coalesce,
1577 .set_coalesce = nes_netdev_set_coalesce,
1578 .get_pauseparam = nes_netdev_get_pauseparam,
1579 .set_pauseparam = nes_netdev_set_pauseparam,
3c2d774c
GS		 1580};
1581
9ca36f7d 1582static void nes_vlan_mode(struct net_device *netdev, struct nes_device *nesdev, netdev_features_t features)
3c2d774c 1583{
edd2fd64 1584 struct nes_adapter *nesadapter = nesdev->nesadapter;
3c2d774c 1585 u32 u32temp;
edd2fd64 1586 unsigned long flags;
3c2d774c 1587
edd2fd64 1588 spin_lock_irqsave(&nesadapter->phy_lock, flags);
3c2d774c 1589
edd2fd64
CT		 1590 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1591
3c2d774c
GS		 1592 /* Enable/Disable VLAN Stripping */
1593 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
f646968f 1594 if (features & NETIF_F_HW_VLAN_CTAG_RX)
3c2d774c
GS		 1595 u32temp &= 0xfdffffff;
1596 else
1597 u32temp |= 0x02000000;
1598
1599 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
edd2fd64 1600 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
3c2d774c
GS		 1601}
1602
9ca36f7d 1603static netdev_features_t nes_fix_features(struct net_device *netdev, netdev_features_t features)
7033c4ad
JP		 1604{
1605 /*
1606 * Since there is no support for separate rx/tx vlan accel
1607 * enable/disable make sure tx flag is always in same state as rx.
1608 */
f646968f
PM		 1609 if (features & NETIF_F_HW_VLAN_CTAG_RX)
1610 features |= NETIF_F_HW_VLAN_CTAG_TX;
7033c4ad 1611 else
f646968f 1612 features &= ~NETIF_F_HW_VLAN_CTAG_TX;
7033c4ad
JP		 1613
1614 return features;
1615}
1616
9ca36f7d 1617static int nes_set_features(struct net_device *netdev, netdev_features_t features)
7033c4ad
JP		 1618{
1619 struct nes_vnic *nesvnic = netdev_priv(netdev);
1620 struct nes_device *nesdev = nesvnic->nesdev;
1621 u32 changed = netdev->features ^ features;
1622
f646968f 1623 if (changed & NETIF_F_HW_VLAN_CTAG_RX)
7033c4ad
JP		 1624 nes_vlan_mode(netdev, nesdev, features);
1625
1626 return 0;
1627}
1628
d0929553 1629static const struct net_device_ops nes_netdev_ops = {
7033c4ad 1630 .ndo_open = nes_netdev_open,
d0929553 1631 .ndo_stop = nes_netdev_stop,
7033c4ad 1632 .ndo_start_xmit = nes_netdev_start_xmit,
d0929553 1633 .ndo_get_stats = nes_netdev_get_stats,
7033c4ad 1634 .ndo_tx_timeout = nes_netdev_tx_timeout,
d0929553 1635 .ndo_set_mac_address = nes_netdev_set_mac_address,
afc4b13d 1636 .ndo_set_rx_mode = nes_netdev_set_multicast_list,
d0929553 1637 .ndo_change_mtu = nes_netdev_change_mtu,
d0929553 1638 .ndo_validate_addr = eth_validate_addr,
7033c4ad
JP		 1639 .ndo_fix_features = nes_fix_features,
1640 .ndo_set_features = nes_set_features,
d0929553 1641};
3c2d774c
GS		 1642
1643/**
1644 * nes_netdev_init - initialize network device
1645 */
1646struct net_device *nes_netdev_init(struct nes_device *nesdev,
1647 void __iomem *mmio_addr)
1648{
1649 u64 u64temp;
13220a94 1650 struct nes_vnic *nesvnic;
3c2d774c
GS		 1651 struct net_device *netdev;
1652 struct nic_qp_map *curr_qp_map;
09124e19 1653 u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
3c2d774c
GS		 1654
1655 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1656 if (!netdev) {
1657 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1658 return NULL;
1659 }
13220a94 1660 nesvnic = netdev_priv(netdev);
3c2d774c
GS		 1661
1662 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1663
1664 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1665
3c2d774c
GS		 1666 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1667 netdev->irq = nesdev->pcidev->irq;
1668 netdev->mtu = ETH_DATA_LEN;
1669 netdev->hard_header_len = ETH_HLEN;
1670 netdev->addr_len = ETH_ALEN;
1671 netdev->type = ARPHRD_ETHER;
d0929553 1672 netdev->netdev_ops = &nes_netdev_ops;
3c2d774c
GS		 1673 netdev->ethtool_ops = &nes_ethtool_ops;
1674 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1675 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
3c2d774c
GS		 1676
1677 /* Fill in the port structure */
1678 nesvnic->netdev = netdev;
1679 nesvnic->nesdev = nesdev;
1680 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1681 nesvnic->netdev_index = nesdev->netdev_count;
1682 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
edd2fd64 1683 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
3c2d774c
GS		 1684
1685 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1686 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1687 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1688 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1689
1690 /* Setup the burned in MAC address */
1691 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1692 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1693 u64temp += nesvnic->nic_index;
1694 netdev->dev_addr[0] = (u8)(u64temp>>40);
1695 netdev->dev_addr[1] = (u8)(u64temp>>32);
1696 netdev->dev_addr[2] = (u8)(u64temp>>24);
1697 netdev->dev_addr[3] = (u8)(u64temp>>16);
1698 netdev->dev_addr[4] = (u8)(u64temp>>8);
1699 netdev->dev_addr[5] = (u8)u64temp;
3c2d774c 1700
f646968f 1701 netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM | NETIF_F_HW_VLAN_CTAG_RX;
dd6f6d02
MM		 1702 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV))
1703 netdev->hw_features |= NETIF_F_TSO;
48a99563 1704
f646968f 1705 netdev->features = netdev->hw_features | NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_CTAG_TX;
3c2d774c
GS		 1706
1707 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1708 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1709 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1710 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1711
7e36d3d7
VM		 1712 if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1713 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1714
3c2d774c
GS		 1715 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1716 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1717 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1718 nesvnic->qp_nic_index[2] = 0xf;
1719 nesvnic->qp_nic_index[3] = 0xf;
1720 } else {
1721 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1722 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1723 }
1724 } else {
7e36d3d7
VM		 1725 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1726 (nesvnic->nesdev->nesadapter->port_count == 1 &&
1727 nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1728 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1729 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1730 + 2;
1731 nesvnic->qp_nic_index[2] = 0xf;
1732 nesvnic->qp_nic_index[3] = 0xf;
3c2d774c
GS		 1733 } else {
1734 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1735 nesvnic->qp_nic_index[1] = 0xf;
1736 nesvnic->qp_nic_index[2] = 0xf;
1737 nesvnic->qp_nic_index[3] = 0xf;
1738 }
1739 }
1740 nesvnic->next_qp_nic_index = 0;
1741
1742 if (nesdev->netdev_count == 0) {
1743 nesvnic->rdma_enabled = 1;
1744 } else {
1745 nesvnic->rdma_enabled = 0;
1746 }
1747 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
ea623455
MS		 1748 init_timer(&nesvnic->event_timer);
1749 nesvnic->event_timer.function = NULL;
3c2d774c 1750 spin_lock_init(&nesvnic->tx_lock);
ea623455 1751 spin_lock_init(&nesvnic->port_ibevent_lock);
3c2d774c
GS		 1752 nesdev->netdev[nesdev->netdev_count] = netdev;
1753
1754 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1755 nesvnic, nesdev->mac_index);
1756 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1757
1758 if ((nesdev->netdev_count == 0) &&
0e1de5d6 1759 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
09124e19 1760 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
0e1de5d6
ES		 1761 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1762 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
a72042c0 1763 u32 u32temp;
843276ad
MS		 1764 u32 link_mask = 0;
1765 u32 link_val = 0;
1766 u16 temp_phy_data;
1767 u16 phy_data = 0;
1768 unsigned long flags;
a72042c0 1769
3c2d774c 1770 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
0e1de5d6 1771 (0x200 * (nesdev->mac_index & 1)));
09124e19 1772 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
0e1de5d6
ES		 1773 u32temp |= 0x00200000;
1774 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1775 (0x200 * (nesdev->mac_index & 1)), u32temp);
1776 }
1777
a72042c0
CT		 1778 /* Check and set linkup here. This is for back to back */
1779 /* configuration where second port won't get link interrupt */
1780 switch (phy_type) {
1781 case NES_PHY_TYPE_PUMA_1G:
1782 if (nesdev->mac_index < 2) {
1783 link_mask = 0x01010000;
1784 link_val = 0x01010000;
1785 } else {
1786 link_mask = 0x02020000;
1787 link_val = 0x02020000;
1788 }
1789 break;
843276ad
MS		 1790 case NES_PHY_TYPE_SFP_D:
1791 spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
1792 nes_read_10G_phy_reg(nesdev,
1793 nesdev->nesadapter->phy_index[nesdev->mac_index],
1794 1, 0x9003);
1795 temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1796 nes_read_10G_phy_reg(nesdev,
1797 nesdev->nesadapter->phy_index[nesdev->mac_index],
1798 3, 0x0021);
1799 nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1800 nes_read_10G_phy_reg(nesdev,
1801 nesdev->nesadapter->phy_index[nesdev->mac_index],
1802 3, 0x0021);
1803 phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1804 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
1805 phy_data = (!temp_phy_data && (phy_data == 0x8000)) ? 0x4 : 0x0;
1806 break;
a72042c0
CT		 1807 default:
1808 link_mask = 0x0f1f0000;
1809 link_val = 0x0f0f0000;
1810 break;
1811 }
1812
1813 u32temp = nes_read_indexed(nesdev,
1814 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1815 (0x200 * (nesdev->mac_index & 1)));
843276ad
MS		 1816
1817 if (phy_type == NES_PHY_TYPE_SFP_D) {
1818 if (phy_data & 0x0004)
1819 nesvnic->linkup = 1;
1820 } else {
1821 if ((u32temp & link_mask) == link_val)
1822 nesvnic->linkup = 1;
1823 }
a72042c0 1824
3c2d774c 1825 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
11e0704b 1826 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
3c2d774c 1827 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
11e0704b 1828 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
3c2d774c 1829
09124e19 1830 nes_init_phy(nesdev);
3c2d774c
GS		 1831 }
1832
7033c4ad
JP		 1833 nes_vlan_mode(netdev, nesdev, netdev->features);
1834
3c2d774c
GS		 1835 return netdev;
1836}
1837
1838
1839/**
1840 * nes_netdev_destroy - destroy network device structure
1841 */
1842void nes_netdev_destroy(struct net_device *netdev)
1843{
1844 struct nes_vnic *nesvnic = netdev_priv(netdev);
1845
1846 /* make sure 'stop' method is called by Linux stack */
1847 /* nes_netdev_stop(netdev); */
1848
1849 list_del(&nesvnic->list);
1850
1851 if (nesvnic->of_device_registered) {
1852 nes_destroy_ofa_device(nesvnic->nesibdev);
1853 }
1854
1855 free_netdev(netdev);
1856}
1857
1858
1859/**
1860 * nes_nic_cm_xmit -- CM calls this to send out pkts
1861 */
1862int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1863{
1864 int ret;
1865
1866 skb->dev = netdev;
1867 ret = dev_queue_xmit(skb);
1868 if (ret) {
1869 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1870 }
1871
1872 return ret;
1873}
ubuntu-bionic-kernel mirror