projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
treewide: kmalloc() -> kmalloc_array()
[linux-2.6-block.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 */
47975cd1 359static bool nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
3c2d774c
GS		 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++;
47975cd1 416 return false;
3c2d774c
GS		 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;
47975cd1 457 return true;
3c2d774c
GS		 458}
459
460
461/**
462 * nes_netdev_start_xmit
463 */
c192a12c 464static netdev_tx_t nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
3c2d774c
GS		 465{
466 struct nes_vnic *nesvnic = netdev_priv(netdev);
467 struct nes_device *nesdev = nesvnic->nesdev;
468 struct nes_hw_nic *nesnic = &nesvnic->nic;
469 struct nes_hw_nic_sq_wqe *nic_sqe;
470 struct tcphdr *tcph;
471 /* struct udphdr *udph; */
a06fd26d 472#define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
3c2d774c
GS		 473 /* 64K segment plus overflow on each side */
474 dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
475 dma_addr_t bus_address;
476 u32 tso_frag_index;
477 u32 tso_frag_count;
478 u32 tso_wqe_length;
479 u32 curr_tcp_seq;
480 u32 wqe_count=1;
3c2d774c 481 struct iphdr *iph;
3c2d774c
GS		 482 __le16 *wqe_fragment_length;
483 u32 nr_frags;
484 u32 original_first_length;
7495ab68 485 /* u64 *wqe_fragment_address; */
3c2d774c
GS		 486 /* first fragment (0) is used by copy buffer */
487 u16 wqe_fragment_index=1;
488 u16 hoffset;
489 u16 nhoffset;
490 u16 wqes_needed;
491 u16 wqes_available;
3c2d774c
GS		 492 u32 wqe_misc;
493
7495ab68
GS		 494 /*
495 * nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
496 * " (%u frags), tso_size=%u\n",
497 * netdev->name, skb->len, skb_headlen(skb),
498 * skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
499 */
3c2d774c 500
3c2d774c
GS		 501 if (netif_queue_stopped(netdev))
502 return NETDEV_TX_BUSY;
503
3c2d774c
GS		 504 /* Check if SQ is full */
505 if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
506 if (!netif_queue_stopped(netdev)) {
507 netif_stop_queue(netdev);
508 barrier();
509 if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
510 netif_start_queue(netdev);
511 goto sq_no_longer_full;
512 }
513 }
514 nesvnic->sq_full++;
3c2d774c
GS		 515 return NETDEV_TX_BUSY;
516 }
517
518sq_no_longer_full:
519 nr_frags = skb_shinfo(skb)->nr_frags;
520 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
521 nr_frags++;
522 }
523 /* Check if too many fragments */
524 if (unlikely((nr_frags > 4))) {
525 if (skb_is_gso(skb)) {
526 nesvnic->segmented_tso_requests++;
527 nesvnic->tso_requests++;
3c2d774c
GS		 528 /* Basically 4 fragments available per WQE with extended fragments */
529 wqes_needed = nr_frags >> 2;
530 wqes_needed += (nr_frags&3)?1:0;
531 wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
532 (nesnic->sq_size - 1);
533
534 if (unlikely(wqes_needed > wqes_available)) {
535 if (!netif_queue_stopped(netdev)) {
536 netif_stop_queue(netdev);
537 barrier();
538 wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
539 (nesnic->sq_size - 1);
540 if (wqes_needed <= wqes_available) {
541 netif_start_queue(netdev);
542 goto tso_sq_no_longer_full;
543 }
544 }
545 nesvnic->sq_full++;
3c2d774c
GS		 546 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
547 netdev->name);
548 return NETDEV_TX_BUSY;
549 }
550tso_sq_no_longer_full:
551 /* Map all the buffers */
552 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
553 tso_frag_count++) {
cf383ebb
IC		 554 skb_frag_t *frag =
555 &skb_shinfo(skb)->frags[tso_frag_count];
556 tso_bus_address[tso_frag_count] =
557 skb_frag_dma_map(&nesdev->pcidev->dev,
9e903e08 558 frag, 0, skb_frag_size(frag),
5d6bcdfe 559 DMA_TO_DEVICE);
3c2d774c
GS		 560 }
561
562 tso_frag_index = 0;
563 curr_tcp_seq = ntohl(tcp_hdr(skb)->seq);
564 hoffset = skb_transport_header(skb) - skb->data;
565 nhoffset = skb_network_header(skb) - skb->data;
566 original_first_length = hoffset + ((((struct tcphdr *)skb_transport_header(skb))->doff)<<2);
567
568 for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
569 tso_wqe_length = 0;
570 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
571 wqe_fragment_length =
572 (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
573 /* setup the VLAN tag if present */
df8a39de 574 if (skb_vlan_tag_present(skb)) {
3c2d774c 575 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
df8a39de
JP		 576 netdev->name,
577 skb_vlan_tag_get(skb));
3c2d774c 578 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
df8a39de 579 wqe_fragment_length[0] = (__force __le16) skb_vlan_tag_get(skb);
3c2d774c
GS		 580 } else
581 wqe_misc = 0;
582
583 /* bump past the vlan tag */
584 wqe_fragment_length++;
585
586 /* Assumes header totally fits in allocated buffer and is in first fragment */
587 if (original_first_length > NES_FIRST_FRAG_SIZE) {
588 nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
589 original_first_length, NES_FIRST_FRAG_SIZE);
590 nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
6ad1be81 591 " (%u frags), is_gso = %u tso_size=%u\n",
3c2d774c
GS		 592 netdev->name,
593 skb->len, skb_headlen(skb),
6ad1be81 594 skb_shinfo(skb)->nr_frags, skb_is_gso(skb), skb_shinfo(skb)->gso_size);
3c2d774c
GS		 595 }
596 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
597 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
598 original_first_length));
599 iph = (struct iphdr *)
600 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[nhoffset]);
601 tcph = (struct tcphdr *)
602 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[hoffset]);
603 if ((wqe_count+1)!=(u32)wqes_needed) {
604 tcph->fin = 0;
605 tcph->psh = 0;
606 tcph->rst = 0;
607 tcph->urg = 0;
608 }
609 if (wqe_count) {
610 tcph->syn = 0;
611 }
612 tcph->seq = htonl(curr_tcp_seq);
613 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
614 original_first_length));
615
616 wqe_fragment_index = 1;
617 if ((wqe_count==0) && (skb_headlen(skb) > original_first_length)) {
618 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
619 bus_address = pci_map_single(nesdev->pcidev, skb->data + original_first_length,
620 skb_headlen(skb) - original_first_length, PCI_DMA_TODEVICE);
621 wqe_fragment_length[wqe_fragment_index++] =
622 cpu_to_le16(skb_headlen(skb) - original_first_length);
623 wqe_fragment_length[wqe_fragment_index] = 0;
624 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
625 bus_address);
168ac824
CT		 626 tso_wqe_length += skb_headlen(skb) -
627 original_first_length;
3c2d774c
GS		 628 }
629 while (wqe_fragment_index < 5) {
630 wqe_fragment_length[wqe_fragment_index] =
9e903e08 631 cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index]));
3c2d774c
GS		 632 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
633 (u64)tso_bus_address[tso_frag_index]);
634 wqe_fragment_index++;
9e903e08 635 tso_wqe_length += skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index++]);
3c2d774c
GS		 636 if (wqe_fragment_index < 5)
637 wqe_fragment_length[wqe_fragment_index] = 0;
638 if (tso_frag_index == tso_frag_count)
639 break;
640 }
641 if ((wqe_count+1) == (u32)wqes_needed) {
642 nesnic->tx_skb[nesnic->sq_head] = skb;
643 } else {
644 nesnic->tx_skb[nesnic->sq_head] = NULL;
645 }
6ad1be81
TN		 646 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_shinfo(skb)->gso_size;
647 if ((tso_wqe_length + original_first_length) > skb_shinfo(skb)->gso_size) {
3c2d774c
GS		 648 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
649 } else {
650 iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
651 }
652
653 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
654 wqe_misc);
655 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
656 ((u32)tcph->doff) | (((u32)hoffset) << 4));
657
658 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
659 tso_wqe_length + original_first_length);
660 curr_tcp_seq += tso_wqe_length;
661 nesnic->sq_head++;
662 nesnic->sq_head &= nesnic->sq_size-1;
663 }
664 } else {
3c2d774c
GS		 665 hoffset = skb_transport_header(skb) - skb->data;
666 nhoffset = skb_network_header(skb) - skb->data;
6a3a1056
ZZ		 667 if (skb_linearize(skb)) {
668 nesvnic->tx_sw_dropped++;
669 kfree_skb(skb);
670 return NETDEV_TX_OK;
671 }
672 nesvnic->linearized_skbs++;
3c2d774c
GS		 673 skb_set_transport_header(skb, hoffset);
674 skb_set_network_header(skb, nhoffset);
47975cd1 675 if (!nes_nic_send(skb, netdev))
3c2d774c 676 return NETDEV_TX_OK;
3c2d774c
GS		 677 }
678 } else {
47975cd1 679 if (!nes_nic_send(skb, netdev))
3c2d774c 680 return NETDEV_TX_OK;
3c2d774c
GS		 681 }
682
683 barrier();
684
685 if (wqe_count)
686 nes_write32(nesdev->regs+NES_WQE_ALLOC,
687 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
688
860e9538 689 netif_trans_update(netdev);
3c2d774c
GS		 690
691 return NETDEV_TX_OK;
692}
693
694
695/**
696 * nes_netdev_get_stats
697 */
698static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
699{
700 struct nes_vnic *nesvnic = netdev_priv(netdev);
701 struct nes_device *nesdev = nesvnic->nesdev;
702 u64 u64temp;
703 u32 u32temp;
704
705 u32temp = nes_read_indexed(nesdev,
706 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD + (nesvnic->nic_index*0x200));
707 nesvnic->netstats.rx_dropped += u32temp;
708 nesvnic->endnode_nstat_rx_discard += u32temp;
709
710 u64temp = (u64)nes_read_indexed(nesdev,
711 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO + (nesvnic->nic_index*0x200));
712 u64temp += ((u64)nes_read_indexed(nesdev,
713 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
714
715 nesvnic->endnode_nstat_rx_octets += u64temp;
716 nesvnic->netstats.rx_bytes += u64temp;
717
718 u64temp = (u64)nes_read_indexed(nesdev,
719 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO + (nesvnic->nic_index*0x200));
720 u64temp += ((u64)nes_read_indexed(nesdev,
721 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
722
723 nesvnic->endnode_nstat_rx_frames += u64temp;
724 nesvnic->netstats.rx_packets += u64temp;
725
726 u64temp = (u64)nes_read_indexed(nesdev,
727 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO + (nesvnic->nic_index*0x200));
728 u64temp += ((u64)nes_read_indexed(nesdev,
729 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
730
731 nesvnic->endnode_nstat_tx_octets += u64temp;
732 nesvnic->netstats.tx_bytes += u64temp;
733
734 u64temp = (u64)nes_read_indexed(nesdev,
735 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO + (nesvnic->nic_index*0x200));
736 u64temp += ((u64)nes_read_indexed(nesdev,
737 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
738
739 nesvnic->endnode_nstat_tx_frames += u64temp;
740 nesvnic->netstats.tx_packets += u64temp;
741
742 u32temp = nes_read_indexed(nesdev,
743 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
744 nesvnic->netstats.rx_dropped += u32temp;
745 nesvnic->nesdev->mac_rx_errors += u32temp;
746 nesvnic->nesdev->mac_rx_short_frames += u32temp;
747
748 u32temp = nes_read_indexed(nesdev,
749 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
750 nesvnic->netstats.rx_dropped += u32temp;
751 nesvnic->nesdev->mac_rx_errors += u32temp;
752 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
753
754 u32temp = nes_read_indexed(nesdev,
755 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
756 nesvnic->netstats.rx_dropped += u32temp;
757 nesvnic->nesdev->mac_rx_errors += u32temp;
758 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
759
760 u32temp = nes_read_indexed(nesdev,
761 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
762 nesvnic->netstats.rx_dropped += u32temp;
763 nesvnic->nesdev->mac_rx_errors += u32temp;
764 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
765
766 u32temp = nes_read_indexed(nesdev,
767 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
768 nesvnic->netstats.rx_length_errors += u32temp;
769 nesvnic->nesdev->mac_rx_errors += u32temp;
770
771 u32temp = nes_read_indexed(nesdev,
772 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
773 nesvnic->nesdev->mac_rx_errors += u32temp;
774 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
775 nesvnic->netstats.rx_crc_errors += u32temp;
776
777 u32temp = nes_read_indexed(nesdev,
778 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
779 nesvnic->nesdev->mac_tx_errors += u32temp;
780 nesvnic->netstats.tx_errors += u32temp;
781
782 return &nesvnic->netstats;
783}
784
785
786/**
787 * nes_netdev_tx_timeout
788 */
789static void nes_netdev_tx_timeout(struct net_device *netdev)
790{
791 struct nes_vnic *nesvnic = netdev_priv(netdev);
792
793 if (netif_msg_timer(nesvnic))
794 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
795}
796
797
798/**
799 * nes_netdev_set_mac_address
800 */
801static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
802{
803 struct nes_vnic *nesvnic = netdev_priv(netdev);
804 struct nes_device *nesdev = nesvnic->nesdev;
805 struct sockaddr *mac_addr = p;
806 int i;
807 u32 macaddr_low;
808 u16 macaddr_high;
809
810 if (!is_valid_ether_addr(mac_addr->sa_data))
811 return -EADDRNOTAVAIL;
812
813 memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
e174961c
JB		 814 printk(PFX "%s: Address length = %d, Address = %pM\n",
815 __func__, netdev->addr_len, mac_addr->sa_data);
7495ab68 816 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
3c2d774c 817 macaddr_high += (u16)netdev->dev_addr[1];
7495ab68
GS		 818 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
819 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
820 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
821 macaddr_low += (u32)netdev->dev_addr[5];
3c2d774c
GS		 822
823 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
824 if (nesvnic->qp_nic_index[i] == 0xf) {
825 break;
826 }
827 nes_write_indexed(nesdev,
828 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
829 macaddr_low);
830 nes_write_indexed(nesdev,
831 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
832 (u32)macaddr_high | NES_MAC_ADDR_VALID |
833 ((((u32)nesvnic->nic_index) << 16)));
834 }
835 return 0;
836}
837
838
fbf219f1
JP		 839static void set_allmulti(struct nes_device *nesdev, u32 nic_active_bit)
840{
841 u32 nic_active;
842
843 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
844 nic_active |= nic_active_bit;
845 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
846 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
847 nic_active &= ~nic_active_bit;
848 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
849}
850
851#define get_addr(addrs, index) ((addrs) + (index) * ETH_ALEN)
852
3c2d774c
GS		 853/**
854 * nes_netdev_set_multicast_list
855 */
1a855fbf 856static void nes_netdev_set_multicast_list(struct net_device *netdev)
3c2d774c
GS		 857{
858 struct nes_vnic *nesvnic = netdev_priv(netdev);
859 struct nes_device *nesdev = nesvnic->nesdev;
7e36d3d7 860 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
3c2d774c
GS		 861 u32 nic_active_bit;
862 u32 nic_active;
863 u32 perfect_filter_register_address;
864 u32 macaddr_low;
865 u16 macaddr_high;
866 u8 mc_all_on = 0;
867 u8 mc_index;
868 int mc_nic_index = -1;
7e36d3d7
VM		 869 u8 pft_entries_preallocated = max(nesadapter->adapter_fcn_count *
870 nics_per_function, 4);
871 u8 max_pft_entries_avaiable = NES_PFT_SIZE - pft_entries_preallocated;
872 unsigned long flags;
fbf219f1 873 int mc_count = netdev_mc_count(netdev);
3c2d774c 874
7e36d3d7 875 spin_lock_irqsave(&nesadapter->resource_lock, flags);
3c2d774c
GS		 876 nic_active_bit = 1 << nesvnic->nic_index;
877
878 if (netdev->flags & IFF_PROMISC) {
879 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
880 nic_active |= nic_active_bit;
881 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
882 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
883 nic_active |= nic_active_bit;
884 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
885 mc_all_on = 1;
7e36d3d7 886 } else if ((netdev->flags & IFF_ALLMULTI) ||
3c2d774c 887 (nesvnic->nic_index > 3)) {
fbf219f1 888 set_allmulti(nesdev, nic_active_bit);
3c2d774c
GS		 889 mc_all_on = 1;
890 } else {
891 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
892 nic_active &= ~nic_active_bit;
893 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
894 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
895 nic_active &= ~nic_active_bit;
896 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
897 }
898
25985edc 899 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscuous = %d, All Multicast = %d.\n",
fbf219f1 900 mc_count, !!(netdev->flags & IFF_PROMISC),
7e36d3d7 901 !!(netdev->flags & IFF_ALLMULTI));
3c2d774c 902 if (!mc_all_on) {
fbf219f1
JP		 903 char *addrs;
904 int i;
22bedad3 905 struct netdev_hw_addr *ha;
fbf219f1 906
6da2ec56 907 addrs = kmalloc_array(mc_count, ETH_ALEN, GFP_ATOMIC);
fbf219f1
JP		 908 if (!addrs) {
909 set_allmulti(nesdev, nic_active_bit);
910 goto unlock;
911 }
912 i = 0;
22bedad3
JP		 913 netdev_for_each_mc_addr(ha, netdev)
914 memcpy(get_addr(addrs, i++), ha->addr, ETH_ALEN);
fbf219f1 915
7e36d3d7
VM		 916 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW +
917 pft_entries_preallocated * 0x8;
fbf219f1
JP		 918 for (i = 0, mc_index = 0; mc_index < max_pft_entries_avaiable;
919 mc_index++) {
920 while (i < mc_count && nesvnic->mcrq_mcast_filter &&
7e36d3d7 921 ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
fbf219f1 922 get_addr(addrs, i++))) == 0));
3c2d774c
GS		 923 if (mc_nic_index < 0)
924 mc_nic_index = nesvnic->nic_index;
7e36d3d7
VM		 925 while (nesadapter->pft_mcast_map[mc_index] < 16 &&
926 nesadapter->pft_mcast_map[mc_index] !=
927 nesvnic->nic_index &&
928 mc_index < max_pft_entries_avaiable) {
af758a22
BVA		 929 nes_debug(NES_DBG_NIC_RX,
930 "mc_index=%d skipping nic_index=%d, used for=%d\n",
931 mc_index, nesvnic->nic_index,
932 nesadapter->pft_mcast_map[mc_index]);
7e36d3d7
VM		 933 mc_index++;
934 }
935 if (mc_index >= max_pft_entries_avaiable)
936 break;
fbf219f1
JP		 937 if (i < mc_count) {
938 char *addr = get_addr(addrs, i++);
939
e174961c 940 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
fbf219f1 941 addr,
2bd01c5d
RD		 942 perfect_filter_register_address+(mc_index * 8),
943 mc_nic_index);
cecdcd5f
TN		 944 macaddr_high = ((u8) addr[0]) << 8;
945 macaddr_high += (u8) addr[1];
946 macaddr_low = ((u8) addr[2]) << 24;
947 macaddr_low += ((u8) addr[3]) << 16;
948 macaddr_low += ((u8) addr[4]) << 8;
949 macaddr_low += (u8) addr[5];
950
3c2d774c
GS		 951 nes_write_indexed(nesdev,
952 perfect_filter_register_address+(mc_index * 8),
953 macaddr_low);
954 nes_write_indexed(nesdev,
955 perfect_filter_register_address+4+(mc_index * 8),
956 (u32)macaddr_high | NES_MAC_ADDR_VALID |
957 ((((u32)(1<<mc_nic_index)) << 16)));
7e36d3d7
VM		 958 nesadapter->pft_mcast_map[mc_index] =
959 nesvnic->nic_index;
3c2d774c
GS		 960 } else {
961 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
962 perfect_filter_register_address+(mc_index * 8));
963 nes_write_indexed(nesdev,
964 perfect_filter_register_address+4+(mc_index * 8),
965 0);
7e36d3d7 966 nesadapter->pft_mcast_map[mc_index] = 255;
3c2d774c
GS		 967 }
968 }
fbf219f1 969 kfree(addrs);
7e36d3d7 970 /* PFT is not large enough */
fbf219f1
JP		 971 if (i < mc_count)
972 set_allmulti(nesdev, nic_active_bit);
3c2d774c 973 }
7e36d3d7 974
fbf219f1 975unlock:
7e36d3d7 976 spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
3c2d774c
GS		 977}
978
979
980/**
981 * nes_netdev_change_mtu
982 */
7495ab68 983static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
3c2d774c
GS		 984{
985 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68 986 struct nes_device *nesdev = nesvnic->nesdev;
7495ab68 987 u8 jumbomode = 0;
e0e31afb
BS		 988 u32 nic_active;
989 u32 nic_active_bit;
990 u32 uc_all_active;
991 u32 mc_all_active;
3c2d774c 992
7495ab68 993 netdev->mtu = new_mtu;
edd2fd64 994 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
3c2d774c 995
b3e3893e 996 if (netdev->mtu > ETH_DATA_LEN) {
3c2d774c
GS		 997 jumbomode=1;
998 }
7495ab68 999 nes_nic_init_timer_defaults(nesdev, jumbomode);
3c2d774c
GS		 1000
1001 if (netif_running(netdev)) {
e0e31afb
BS		 1002 nic_active_bit = 1 << nesvnic->nic_index;
1003 mc_all_active = nes_read_indexed(nesdev,
1004 NES_IDX_NIC_MULTICAST_ALL) & nic_active_bit;
1005 uc_all_active = nes_read_indexed(nesdev,
1006 NES_IDX_NIC_UNICAST_ALL) & nic_active_bit;
1007
3c2d774c
GS		 1008 nes_netdev_stop(netdev);
1009 nes_netdev_open(netdev);
e0e31afb
BS		 1010
1011 nic_active = nes_read_indexed(nesdev,
1012 NES_IDX_NIC_MULTICAST_ALL);
1013 nic_active |= mc_all_active;
1014 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL,
1015 nic_active);
1016
1017 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
1018 nic_active |= uc_all_active;
1019 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
3c2d774c
GS		 1020 }
1021
b3e3893e 1022 return 0;
3c2d774c
GS		 1023}
1024
39942a02 1025
37dab411 1026static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
3c2d774c
GS		 1027 "Link Change Interrupts",
1028 "Linearized SKBs",
1029 "T/GSO Requests",
1030 "Pause Frames Sent",
1031 "Pause Frames Received",
1032 "Internal Routing Errors",
1033 "SQ SW Dropped SKBs",
3c2d774c
GS		 1034 "SQ Full",
1035 "Segmented TSO Requests",
1036 "Rx Symbol Errors",
1037 "Rx Jabber Errors",
1038 "Rx Oversized Frames",
1039 "Rx Short Frames",
39942a02
FL		 1040 "Rx Length Errors",
1041 "Rx CRC Errors",
1042 "Rx Port Discard",
3c2d774c
GS		 1043 "Endnode Rx Discards",
1044 "Endnode Rx Octets",
1045 "Endnode Rx Frames",
1046 "Endnode Tx Octets",
1047 "Endnode Tx Frames",
39942a02 1048 "Tx Errors",
3c2d774c
GS		 1049 "mh detected",
1050 "mh pauses",
1051 "Retransmission Count",
1052 "CM Connects",
1053 "CM Accepts",
1054 "Disconnects",
1055 "Connected Events",
1056 "Connect Requests",
1057 "CM Rejects",
1058 "ModifyQP Timeouts",
1059 "CreateQPs",
1060 "SW DestroyQPs",
1061 "DestroyQPs",
1062 "CM Closes",
1063 "CM Packets Sent",
1064 "CM Packets Bounced",
1065 "CM Packets Created",
1066 "CM Packets Rcvd",
1067 "CM Packets Dropped",
1068 "CM Packets Retrans",
1069 "CM Listens Created",
1070 "CM Listens Destroyed",
1071 "CM Backlog Drops",
1072 "CM Loopbacks",
1073 "CM Nodes Created",
1074 "CM Nodes Destroyed",
1075 "CM Accel Drops",
1076 "CM Resets Received",
39942a02
FL		 1077 "Free 4Kpbls",
1078 "Free 256pbls",
3c2d774c 1079 "Timer Inits",
0f0bee8b
FL		 1080 "PAU CreateQPs",
1081 "PAU DestroyQPs",
3c2d774c 1082};
37dab411 1083#define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
3c2d774c 1084
3c2d774c
GS		 1085
1086/**
15f0a394 1087 * nes_netdev_get_sset_count
3c2d774c 1088 */
15f0a394 1089static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
3c2d774c 1090{
15f0a394
BH		 1091 if (stringset == ETH_SS_STATS)
1092 return NES_ETHTOOL_STAT_COUNT;
1093 else
1094 return -EINVAL;
3c2d774c
GS		 1095}
1096
1097
1098/**
1099 * nes_netdev_get_strings
1100 */
1101static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1102 u8 *ethtool_strings)
1103{
1104 if (stringset == ETH_SS_STATS)
1105 memcpy(ethtool_strings,
1106 &nes_ethtool_stringset,
1107 sizeof(nes_ethtool_stringset));
1108}
1109
1110
1111/**
1112 * nes_netdev_get_ethtool_stats
1113 */
39942a02 1114
3c2d774c
GS		 1115static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1116 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1117{
1118 u64 u64temp;
1119 struct nes_vnic *nesvnic = netdev_priv(netdev);
1120 struct nes_device *nesdev = nesvnic->nesdev;
39942a02 1121 struct nes_adapter *nesadapter = nesdev->nesadapter;
3c2d774c
GS		 1122 u32 nic_count;
1123 u32 u32temp;
2869975c 1124 u32 index = 0;
3c2d774c
GS		 1125
1126 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
2869975c
FL		 1127 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1128 target_stat_values[++index] = nesvnic->linearized_skbs;
1129 target_stat_values[++index] = nesvnic->tso_requests;
3c2d774c
GS		 1130
1131 u32temp = nes_read_indexed(nesdev,
1132 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1133 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
2869975c 1134 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
3c2d774c
GS		 1135
1136 u32temp = nes_read_indexed(nesdev,
1137 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1138 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1139
1140 u32temp = nes_read_indexed(nesdev,
1141 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1142 nesvnic->nesdev->port_rx_discards += u32temp;
1143 nesvnic->netstats.rx_dropped += u32temp;
1144
1145 u32temp = nes_read_indexed(nesdev,
1146 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1147 nesvnic->nesdev->port_tx_discards += u32temp;
1148 nesvnic->netstats.tx_dropped += u32temp;
1149
39942a02
FL		 1150 u32temp = nes_read_indexed(nesdev,
1151 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1152 nesvnic->netstats.rx_dropped += u32temp;
1153 nesvnic->nesdev->mac_rx_errors += u32temp;
1154 nesvnic->nesdev->mac_rx_short_frames += u32temp;
1155
1156 u32temp = nes_read_indexed(nesdev,
1157 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1158 nesvnic->netstats.rx_dropped += u32temp;
1159 nesvnic->nesdev->mac_rx_errors += u32temp;
1160 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
1161
1162 u32temp = nes_read_indexed(nesdev,
1163 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1164 nesvnic->netstats.rx_dropped += u32temp;
1165 nesvnic->nesdev->mac_rx_errors += u32temp;
1166 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
1167
1168 u32temp = nes_read_indexed(nesdev,
1169 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1170 nesvnic->netstats.rx_dropped += u32temp;
1171 nesvnic->nesdev->mac_rx_errors += u32temp;
1172 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
1173
1174 u32temp = nes_read_indexed(nesdev,
1175 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1176 nesvnic->netstats.rx_length_errors += u32temp;
1177 nesvnic->nesdev->mac_rx_errors += u32temp;
1178
1179 u32temp = nes_read_indexed(nesdev,
1180 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1181 nesvnic->nesdev->mac_rx_errors += u32temp;
1182 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
1183 nesvnic->netstats.rx_crc_errors += u32temp;
1184
1185 u32temp = nes_read_indexed(nesdev,
1186 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
1187 nesvnic->nesdev->mac_tx_errors += u32temp;
1188 nesvnic->netstats.tx_errors += u32temp;
1189
3c2d774c
GS		 1190 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1191 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1192 break;
1193
1194 u32temp = nes_read_indexed(nesdev,
1195 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1196 (nesvnic->qp_nic_index[nic_count]*0x200));
1197 nesvnic->netstats.rx_dropped += u32temp;
1198 nesvnic->endnode_nstat_rx_discard += u32temp;
1199
1200 u64temp = (u64)nes_read_indexed(nesdev,
1201 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1202 (nesvnic->qp_nic_index[nic_count]*0x200));
1203 u64temp += ((u64)nes_read_indexed(nesdev,
1204 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1205 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1206
1207 nesvnic->endnode_nstat_rx_octets += u64temp;
1208 nesvnic->netstats.rx_bytes += u64temp;
1209
1210 u64temp = (u64)nes_read_indexed(nesdev,
1211 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1212 (nesvnic->qp_nic_index[nic_count]*0x200));
1213 u64temp += ((u64)nes_read_indexed(nesdev,
1214 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1215 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1216
1217 nesvnic->endnode_nstat_rx_frames += u64temp;
1218 nesvnic->netstats.rx_packets += u64temp;
1219
1220 u64temp = (u64)nes_read_indexed(nesdev,
1221 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1222 (nesvnic->qp_nic_index[nic_count]*0x200));
1223 u64temp += ((u64)nes_read_indexed(nesdev,
1224 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1225 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1226
1227 nesvnic->endnode_nstat_tx_octets += u64temp;
1228 nesvnic->netstats.tx_bytes += u64temp;
1229
1230 u64temp = (u64)nes_read_indexed(nesdev,
1231 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1232 (nesvnic->qp_nic_index[nic_count]*0x200));
1233 u64temp += ((u64)nes_read_indexed(nesdev,
1234 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1235 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1236
1237 nesvnic->endnode_nstat_tx_frames += u64temp;
1238 nesvnic->netstats.tx_packets += u64temp;
1239
1240 u32temp = nes_read_indexed(nesdev,
1241 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1242 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1243 }
1244
2869975c
FL		 1245 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1246 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1247 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1248 target_stat_values[++index] = nesvnic->sq_full;
1249 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1250 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1251 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1252 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1253 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
39942a02
FL		 1254 target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
1255 target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
1256 target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
2869975c
FL		 1257 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1258 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1259 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1260 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1261 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
39942a02 1262 target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
2869975c
FL		 1263 target_stat_values[++index] = mh_detected;
1264 target_stat_values[++index] = mh_pauses_sent;
1265 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1266 target_stat_values[++index] = atomic_read(&cm_connects);
1267 target_stat_values[++index] = atomic_read(&cm_accepts);
1268 target_stat_values[++index] = atomic_read(&cm_disconnects);
1269 target_stat_values[++index] = atomic_read(&cm_connecteds);
1270 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1271 target_stat_values[++index] = atomic_read(&cm_rejects);
1272 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1273 target_stat_values[++index] = atomic_read(&qps_created);
1274 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1275 target_stat_values[++index] = atomic_read(&qps_destroyed);
1276 target_stat_values[++index] = atomic_read(&cm_closes);
1277 target_stat_values[++index] = cm_packets_sent;
1278 target_stat_values[++index] = cm_packets_bounced;
1279 target_stat_values[++index] = cm_packets_created;
1280 target_stat_values[++index] = cm_packets_received;
1281 target_stat_values[++index] = cm_packets_dropped;
1282 target_stat_values[++index] = cm_packets_retrans;
6e10d2e4
FL		 1283 target_stat_values[++index] = atomic_read(&cm_listens_created);
1284 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
2869975c
FL		 1285 target_stat_values[++index] = cm_backlog_drops;
1286 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1287 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1288 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1289 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1290 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
39942a02
FL		 1291 target_stat_values[++index] = nesadapter->free_4kpbl;
1292 target_stat_values[++index] = nesadapter->free_256pbl;
2869975c 1293 target_stat_values[++index] = int_mod_timer_init;
0f0bee8b
FL		 1294 target_stat_values[++index] = atomic_read(&pau_qps_created);
1295 target_stat_values[++index] = atomic_read(&pau_qps_destroyed);
3c2d774c
GS		 1296}
1297
3c2d774c
GS		 1298/**
1299 * nes_netdev_get_drvinfo
1300 */
1301static void nes_netdev_get_drvinfo(struct net_device *netdev,
1302 struct ethtool_drvinfo *drvinfo)
1303{
1304 struct nes_vnic *nesvnic = netdev_priv(netdev);
0c93ae35 1305 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
3c2d774c 1306
7826d43f
JP		 1307 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
1308 strlcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev),
1309 sizeof(drvinfo->bus_info));
1310 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1311 "%u.%u", nesadapter->firmware_version >> 16,
1312 nesadapter->firmware_version & 0x000000ff);
1313 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
3c2d774c
GS		 1314}
1315
1316
1317/**
1318 * nes_netdev_set_coalesce
1319 */
1320static int nes_netdev_set_coalesce(struct net_device *netdev,
1321 struct ethtool_coalesce *et_coalesce)
1322{
1323 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68 1324 struct nes_device *nesdev = nesvnic->nesdev;
3c2d774c
GS		 1325 struct nes_adapter *nesadapter = nesdev->nesadapter;
1326 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1327 unsigned long flags;
1328
7495ab68 1329 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
3c2d774c 1330 if (et_coalesce->rx_max_coalesced_frames_low) {
7495ab68 1331 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
3c2d774c
GS		 1332 }
1333 if (et_coalesce->rx_max_coalesced_frames_irq) {
1334 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1335 }
1336 if (et_coalesce->rx_max_coalesced_frames_high) {
1337 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1338 }
1339 if (et_coalesce->rx_coalesce_usecs_low) {
1340 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1341 }
1342 if (et_coalesce->rx_coalesce_usecs_high) {
1343 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1344 }
1345 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1346
1347 /* using this to drive total interrupt moderation */
1348 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1349 if (et_coalesce->use_adaptive_rx_coalesce) {
1350 nesadapter->et_use_adaptive_rx_coalesce = 1;
7495ab68 1351 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
3c2d774c
GS		 1352 nesadapter->et_rx_coalesce_usecs_irq = 0;
1353 if (et_coalesce->pkt_rate_low) {
7495ab68 1354 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
3c2d774c
GS		 1355 }
1356 } else {
1357 nesadapter->et_use_adaptive_rx_coalesce = 0;
7495ab68 1358 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
3c2d774c
GS		 1359 if (nesadapter->et_rx_coalesce_usecs_irq) {
1360 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1361 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1362 }
1363 }
1364 return 0;
1365}
1366
1367
1368/**
1369 * nes_netdev_get_coalesce
1370 */
1371static int nes_netdev_get_coalesce(struct net_device *netdev,
1372 struct ethtool_coalesce *et_coalesce)
1373{
1374 struct nes_vnic *nesvnic = netdev_priv(netdev);
7495ab68 1375 struct nes_device *nesdev = nesvnic->nesdev;
3c2d774c
GS		 1376 struct nes_adapter *nesadapter = nesdev->nesadapter;
1377 struct ethtool_coalesce temp_et_coalesce;
1378 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1379 unsigned long flags;
1380
1381 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
7495ab68
GS		 1382 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1383 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1384 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
3c2d774c
GS		 1385 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1386 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
7495ab68
GS		 1387 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1388 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
3c2d774c 1389 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
7495ab68 1390 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
3c2d774c
GS		 1391 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1392 if (nesadapter->et_use_adaptive_rx_coalesce) {
1393 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1394 }
1395 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
7495ab68 1396 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
3c2d774c
GS		 1397 return 0;
1398}
1399
1400
1401/**
1402 * nes_netdev_get_pauseparam
1403 */
1404static void nes_netdev_get_pauseparam(struct net_device *netdev,
1405 struct ethtool_pauseparam *et_pauseparam)
1406{
1407 struct nes_vnic *nesvnic = netdev_priv(netdev);
1408
1409 et_pauseparam->autoneg = 0;
1410 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1411 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1412}
1413
1414
1415/**
1416 * nes_netdev_set_pauseparam
1417 */
1418static int nes_netdev_set_pauseparam(struct net_device *netdev,
1419 struct ethtool_pauseparam *et_pauseparam)
1420{
1421 struct nes_vnic *nesvnic = netdev_priv(netdev);
1422 struct nes_device *nesdev = nesvnic->nesdev;
1423 u32 u32temp;
1424
1425 if (et_pauseparam->autoneg) {
1426 /* TODO: should return unsupported */
1427 return 0;
1428 }
1429 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1430 u32temp = nes_read_indexed(nesdev,
1431 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1432 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1433 nes_write_indexed(nesdev,
70c9db0f 1434 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
3c2d774c
GS		 1435 nesdev->disable_tx_flow_control = 0;
1436 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1437 u32temp = nes_read_indexed(nesdev,
1438 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1439 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1440 nes_write_indexed(nesdev,
70c9db0f 1441 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
3c2d774c
GS		 1442 nesdev->disable_tx_flow_control = 1;
1443 }
1444 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1445 u32temp = nes_read_indexed(nesdev,
1446 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1447 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1448 nes_write_indexed(nesdev,
1449 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1450 nesdev->disable_rx_flow_control = 0;
1451 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1452 u32temp = nes_read_indexed(nesdev,
1453 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1454 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1455 nes_write_indexed(nesdev,
1456 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1457 nesdev->disable_rx_flow_control = 1;
1458 }
1459
1460 return 0;
1461}
1462
1463
1464/**
1465 * nes_netdev_get_settings
1466 */
24dc08c3
PR		 1467static int nes_netdev_get_link_ksettings(struct net_device *netdev,
1468 struct ethtool_link_ksettings *cmd)
3c2d774c
GS		 1469{
1470 struct nes_vnic *nesvnic = netdev_priv(netdev);
1471 struct nes_device *nesdev = nesvnic->nesdev;
1472 struct nes_adapter *nesadapter = nesdev->nesadapter;
4303565d
CT		 1473 u32 mac_index = nesdev->mac_index;
1474 u8 phy_type = nesadapter->phy_type[mac_index];
1475 u8 phy_index = nesadapter->phy_index[mac_index];
3c2d774c 1476 u16 phy_data;
24dc08c3 1477 u32 supported, advertising;
3c2d774c 1478
24dc08c3
PR		 1479 cmd->base.duplex = DUPLEX_FULL;
1480 cmd->base.port = PORT_MII;
0e1de5d6 1481
3c2d774c 1482 if (nesadapter->OneG_Mode) {
24dc08c3 1483 cmd->base.speed = SPEED_1000;
4303565d 1484 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
24dc08c3
PR		 1485 supported = SUPPORTED_1000baseT_Full;
1486 advertising = ADVERTISED_1000baseT_Full;
1487 cmd->base.autoneg = AUTONEG_DISABLE;
1488 cmd->base.phy_address = mac_index;
3c2d774c 1489 } else {
ce6e74f2 1490 unsigned long flags;
24dc08c3
PR		 1491
1492 supported = SUPPORTED_1000baseT_Full
1493 | SUPPORTED_Autoneg;
1494 advertising = ADVERTISED_1000baseT_Full
1495 | ADVERTISED_Autoneg;
ce6e74f2 1496 spin_lock_irqsave(&nesadapter->phy_lock, flags);
4303565d 1497 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
ce6e74f2 1498 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
0e1de5d6 1499 if (phy_data & 0x1000)
24dc08c3 1500 cmd->base.autoneg = AUTONEG_ENABLE;
0e1de5d6 1501 else
24dc08c3
PR		 1502 cmd->base.autoneg = AUTONEG_DISABLE;
1503 cmd->base.phy_address = phy_index;
3c2d774c 1504 }
24dc08c3
PR		 1505 ethtool_convert_legacy_u32_to_link_mode(
1506 cmd->link_modes.supported, supported);
1507 ethtool_convert_legacy_u32_to_link_mode(
1508 cmd->link_modes.advertising, advertising);
4303565d
CT		 1509 return 0;
1510 }
09124e19
CT		 1511 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1512 (phy_type == NES_PHY_TYPE_SFP_D) ||
1513 (phy_type == NES_PHY_TYPE_KR)) {
24dc08c3
PR		 1514 cmd->base.port = PORT_FIBRE;
1515 supported = SUPPORTED_FIBRE;
1516 advertising = ADVERTISED_FIBRE;
1517 cmd->base.phy_address = phy_index;
3c2d774c 1518 } else {
24dc08c3
PR		 1519 supported = SUPPORTED_10000baseT_Full;
1520 advertising = ADVERTISED_10000baseT_Full;
1521 cmd->base.phy_address = mac_index;
3c2d774c 1522 }
24dc08c3
PR		 1523 cmd->base.speed = SPEED_10000;
1524 cmd->base.autoneg = AUTONEG_DISABLE;
1525 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1526 supported);
1527 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
1528 advertising);
1529
3c2d774c
GS		 1530 return 0;
1531}
1532
1533
1534/**
1535 * nes_netdev_set_settings
1536 */
24dc08c3
PR		 1537static int
1538nes_netdev_set_link_ksettings(struct net_device *netdev,
1539 const struct ethtool_link_ksettings *cmd)
3c2d774c
GS		 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);
24dc08c3 1553 if (cmd->base.autoneg) {
3c2d774c
GS		 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 1569 .get_link = ethtool_op_get_link,
3c2d774c 1570 .get_strings = nes_netdev_get_strings,
15f0a394 1571 .get_sset_count = nes_netdev_get_sset_count,
3c2d774c
GS		 1572 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1573 .get_drvinfo = nes_netdev_get_drvinfo,
1574 .get_coalesce = nes_netdev_get_coalesce,
1575 .set_coalesce = nes_netdev_set_coalesce,
1576 .get_pauseparam = nes_netdev_get_pauseparam,
1577 .set_pauseparam = nes_netdev_set_pauseparam,
24dc08c3
PR		 1578 .get_link_ksettings = nes_netdev_get_link_ksettings,
1579 .set_link_ksettings = nes_netdev_set_link_ksettings,
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;
b3e3893e 1668 netdev->max_mtu = NES_MAX_MTU;
3c2d774c
GS		 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;
f0309de9 1748 timer_setup(&nesvnic->event_timer, NULL, 0);
3c2d774c 1749 spin_lock_init(&nesvnic->tx_lock);
ea623455 1750 spin_lock_init(&nesvnic->port_ibevent_lock);
3c2d774c
GS		 1751 nesdev->netdev[nesdev->netdev_count] = netdev;
1752
1753 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1754 nesvnic, nesdev->mac_index);
1755 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1756
1757 if ((nesdev->netdev_count == 0) &&
0e1de5d6 1758 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
09124e19 1759 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
0e1de5d6
ES		 1760 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1761 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
a72042c0 1762 u32 u32temp;
843276ad
MS		 1763 u32 link_mask = 0;
1764 u32 link_val = 0;
1765 u16 temp_phy_data;
1766 u16 phy_data = 0;
1767 unsigned long flags;
a72042c0 1768
3c2d774c 1769 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
0e1de5d6 1770 (0x200 * (nesdev->mac_index & 1)));
09124e19 1771 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
0e1de5d6
ES		 1772 u32temp |= 0x00200000;
1773 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1774 (0x200 * (nesdev->mac_index & 1)), u32temp);
1775 }
1776
a72042c0
CT		 1777 /* Check and set linkup here. This is for back to back */
1778 /* configuration where second port won't get link interrupt */
1779 switch (phy_type) {
1780 case NES_PHY_TYPE_PUMA_1G:
1781 if (nesdev->mac_index < 2) {
1782 link_mask = 0x01010000;
1783 link_val = 0x01010000;
1784 } else {
1785 link_mask = 0x02020000;
1786 link_val = 0x02020000;
1787 }
1788 break;
843276ad
MS		 1789 case NES_PHY_TYPE_SFP_D:
1790 spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
1791 nes_read_10G_phy_reg(nesdev,
1792 nesdev->nesadapter->phy_index[nesdev->mac_index],
1793 1, 0x9003);
1794 temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1795 nes_read_10G_phy_reg(nesdev,
1796 nesdev->nesadapter->phy_index[nesdev->mac_index],
1797 3, 0x0021);
1798 nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1799 nes_read_10G_phy_reg(nesdev,
1800 nesdev->nesadapter->phy_index[nesdev->mac_index],
1801 3, 0x0021);
1802 phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1803 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
1804 phy_data = (!temp_phy_data && (phy_data == 0x8000)) ? 0x4 : 0x0;
1805 break;
a72042c0
CT		 1806 default:
1807 link_mask = 0x0f1f0000;
1808 link_val = 0x0f0f0000;
1809 break;
1810 }
1811
1812 u32temp = nes_read_indexed(nesdev,
1813 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1814 (0x200 * (nesdev->mac_index & 1)));
843276ad
MS		 1815
1816 if (phy_type == NES_PHY_TYPE_SFP_D) {
1817 if (phy_data & 0x0004)
1818 nesvnic->linkup = 1;
1819 } else {
1820 if ((u32temp & link_mask) == link_val)
1821 nesvnic->linkup = 1;
1822 }
a72042c0 1823
3c2d774c 1824 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
11e0704b 1825 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
3c2d774c 1826 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
11e0704b 1827 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
3c2d774c 1828
09124e19 1829 nes_init_phy(nesdev);
3c2d774c
GS		 1830 }
1831
7033c4ad
JP		 1832 nes_vlan_mode(netdev, nesdev, netdev->features);
1833
3c2d774c
GS		 1834 return netdev;
1835}
1836
1837
1838/**
1839 * nes_netdev_destroy - destroy network device structure
1840 */
1841void nes_netdev_destroy(struct net_device *netdev)
1842{
1843 struct nes_vnic *nesvnic = netdev_priv(netdev);
1844
1845 /* make sure 'stop' method is called by Linux stack */
1846 /* nes_netdev_stop(netdev); */
1847
1848 list_del(&nesvnic->list);
1849
1850 if (nesvnic->of_device_registered) {
1851 nes_destroy_ofa_device(nesvnic->nesibdev);
1852 }
1853
1854 free_netdev(netdev);
1855}
1856
1857
1858/**
1859 * nes_nic_cm_xmit -- CM calls this to send out pkts
1860 */
1861int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1862{
1863 int ret;
1864
1865 skb->dev = netdev;
1866 ret = dev_queue_xmit(skb);
1867 if (ret) {
1868 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1869 }
1870
1871 return ret;
1872}
Linux 6.x block layer and io_uring tree(s)