]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/infiniband/hw/nes/nes_nic.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/dledford/rdma
[mirror_ubuntu-artful-kernel.git] / drivers / infiniband / hw / nes / nes_nic.c
1 /*
2 * Copyright (c) 2006 - 2011 Intel Corporation. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 *
32 */
33
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/ip.h>
39 #include <linux/tcp.h>
40 #include <linux/if_arp.h>
41 #include <linux/if_vlan.h>
42 #include <linux/ethtool.h>
43 #include <linux/slab.h>
44 #include <net/tcp.h>
45
46 #include <net/inet_common.h>
47 #include <linux/inet.h>
48
49 #include "nes.h"
50
51 static struct nic_qp_map nic_qp_mapping_0[] = {
52 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
53 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
54 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
55 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
56 };
57
58 static struct nic_qp_map nic_qp_mapping_1[] = {
59 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
60 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
61 };
62
63 static struct nic_qp_map nic_qp_mapping_2[] = {
64 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
65 };
66
67 static struct nic_qp_map nic_qp_mapping_3[] = {
68 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
69 };
70
71 static struct nic_qp_map nic_qp_mapping_4[] = {
72 {28,8,0,0},{32,12,0,0}
73 };
74
75 static struct nic_qp_map nic_qp_mapping_5[] = {
76 {29,9,1,0},{33,13,1,0}
77 };
78
79 static struct nic_qp_map nic_qp_mapping_6[] = {
80 {30,10,2,0},{34,14,2,0}
81 };
82
83 static struct nic_qp_map nic_qp_mapping_7[] = {
84 {31,11,3,0},{35,15,3,0}
85 };
86
87 static struct nic_qp_map *nic_qp_mapping_per_function[] = {
88 nic_qp_mapping_0, nic_qp_mapping_1, nic_qp_mapping_2, nic_qp_mapping_3,
89 nic_qp_mapping_4, nic_qp_mapping_5, nic_qp_mapping_6, nic_qp_mapping_7
90 };
91
92 static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
93 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
94 static int debug = -1;
95 static int nics_per_function = 1;
96
97 /**
98 * nes_netdev_poll
99 */
100 static int nes_netdev_poll(struct napi_struct *napi, int budget)
101 {
102 struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi);
103 struct nes_device *nesdev = nesvnic->nesdev;
104 struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq;
105
106 nesvnic->budget = budget;
107 nescq->cqes_pending = 0;
108 nescq->rx_cqes_completed = 0;
109 nescq->cqe_allocs_pending = 0;
110 nescq->rx_pkts_indicated = 0;
111
112 nes_nic_ce_handler(nesdev, nescq);
113
114 if (nescq->cqes_pending == 0) {
115 napi_complete(napi);
116 /* clear out completed cqes and arm */
117 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
118 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
119 nes_read32(nesdev->regs+NES_CQE_ALLOC);
120 } else {
121 /* clear out completed cqes but don't arm */
122 nes_write32(nesdev->regs+NES_CQE_ALLOC,
123 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
124 nes_debug(NES_DBG_NETDEV, "%s: exiting with work pending\n",
125 nesvnic->netdev->name);
126 }
127 return nescq->rx_pkts_indicated;
128 }
129
130
131 /**
132 * nes_netdev_open - Activate the network interface; ifconfig
133 * ethx up.
134 */
135 static int nes_netdev_open(struct net_device *netdev)
136 {
137 u32 macaddr_low;
138 u16 macaddr_high;
139 struct nes_vnic *nesvnic = netdev_priv(netdev);
140 struct nes_device *nesdev = nesvnic->nesdev;
141 int ret;
142 int i;
143 struct nes_vnic *first_nesvnic = NULL;
144 u32 nic_active_bit;
145 u32 nic_active;
146 struct list_head *list_pos, *list_temp;
147 unsigned long flags;
148
149 assert(nesdev != NULL);
150
151 if (nesvnic->netdev_open == 1)
152 return 0;
153
154 if (netif_msg_ifup(nesvnic))
155 printk(KERN_INFO PFX "%s: enabling interface\n", netdev->name);
156
157 ret = nes_init_nic_qp(nesdev, netdev);
158 if (ret) {
159 return ret;
160 }
161
162 netif_carrier_off(netdev);
163 netif_stop_queue(netdev);
164
165 if ((!nesvnic->of_device_registered) && (nesvnic->rdma_enabled)) {
166 nesvnic->nesibdev = nes_init_ofa_device(netdev);
167 if (nesvnic->nesibdev == NULL) {
168 printk(KERN_ERR PFX "%s: nesvnic->nesibdev alloc failed", netdev->name);
169 } else {
170 nesvnic->nesibdev->nesvnic = nesvnic;
171 ret = nes_register_ofa_device(nesvnic->nesibdev);
172 if (ret) {
173 printk(KERN_ERR PFX "%s: Unable to register RDMA device, ret = %d\n",
174 netdev->name, ret);
175 }
176 }
177 }
178 /* Set packet filters */
179 nic_active_bit = 1 << nesvnic->nic_index;
180 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
181 nic_active |= nic_active_bit;
182 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
183 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
184 nic_active |= nic_active_bit;
185 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
186 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
187 nic_active |= nic_active_bit;
188 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
189
190 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
191 macaddr_high += (u16)netdev->dev_addr[1];
192
193 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
194 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
195 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
196 macaddr_low += (u32)netdev->dev_addr[5];
197
198 /* Program the various MAC regs */
199 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
200 if (nesvnic->qp_nic_index[i] == 0xf) {
201 break;
202 }
203 nes_debug(NES_DBG_NETDEV, "i=%d, perfect filter table index= %d, PERF FILTER LOW"
204 " (Addr:%08X) = %08X, HIGH = %08X.\n",
205 i, nesvnic->qp_nic_index[i],
206 NES_IDX_PERFECT_FILTER_LOW+
207 (nesvnic->qp_nic_index[i] * 8),
208 macaddr_low,
209 (u32)macaddr_high | NES_MAC_ADDR_VALID |
210 ((((u32)nesvnic->nic_index) << 16)));
211 nes_write_indexed(nesdev,
212 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
213 macaddr_low);
214 nes_write_indexed(nesdev,
215 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
216 (u32)macaddr_high | NES_MAC_ADDR_VALID |
217 ((((u32)nesvnic->nic_index) << 16)));
218 }
219
220
221 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
222 nesvnic->nic_cq.cq_number);
223 nes_read32(nesdev->regs+NES_CQE_ALLOC);
224 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
225 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
226 if (first_nesvnic->netdev_open == 1)
227 break;
228 }
229 if (first_nesvnic->netdev_open == 0) {
230 nes_debug(NES_DBG_INIT, "Setting up MAC interrupt mask.\n");
231 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK + (0x200 * nesdev->mac_index),
232 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
233 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
234 first_nesvnic = nesvnic;
235 }
236
237 if (first_nesvnic->linkup) {
238 /* Enable network packets */
239 nesvnic->linkup = 1;
240 netif_start_queue(netdev);
241 netif_carrier_on(netdev);
242 }
243
244 spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
245 if (nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_SFP_D) {
246 nesdev->link_recheck = 1;
247 mod_delayed_work(system_wq, &nesdev->work,
248 NES_LINK_RECHECK_DELAY);
249 }
250 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
251
252 spin_lock_irqsave(&nesvnic->port_ibevent_lock, flags);
253 if (nesvnic->of_device_registered) {
254 nesdev->nesadapter->send_term_ok = 1;
255 if (nesvnic->linkup == 1) {
256 if (nesdev->iw_status == 0) {
257 nesdev->iw_status = 1;
258 nes_port_ibevent(nesvnic);
259 }
260 } else {
261 nesdev->iw_status = 0;
262 }
263 }
264 spin_unlock_irqrestore(&nesvnic->port_ibevent_lock, flags);
265
266 napi_enable(&nesvnic->napi);
267 nesvnic->netdev_open = 1;
268
269 return 0;
270 }
271
272
273 /**
274 * nes_netdev_stop
275 */
276 static int nes_netdev_stop(struct net_device *netdev)
277 {
278 struct nes_vnic *nesvnic = netdev_priv(netdev);
279 struct nes_device *nesdev = nesvnic->nesdev;
280 u32 nic_active_mask;
281 u32 nic_active;
282 struct nes_vnic *first_nesvnic = NULL;
283 struct list_head *list_pos, *list_temp;
284 unsigned long flags;
285
286 nes_debug(NES_DBG_SHUTDOWN, "nesvnic=%p, nesdev=%p, netdev=%p %s\n",
287 nesvnic, nesdev, netdev, netdev->name);
288 if (nesvnic->netdev_open == 0)
289 return 0;
290
291 if (netif_msg_ifdown(nesvnic))
292 printk(KERN_INFO PFX "%s: disabling interface\n", netdev->name);
293 netif_carrier_off(netdev);
294
295 /* Disable network packets */
296 napi_disable(&nesvnic->napi);
297 netif_stop_queue(netdev);
298 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
299 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
300 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic))
301 break;
302 }
303
304 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic) &&
305 (PCI_FUNC(first_nesvnic->nesdev->pcidev->devfn) !=
306 PCI_FUNC(nesvnic->nesdev->pcidev->devfn))) {
307 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+
308 (0x200*nesdev->mac_index), 0xffffffff);
309 nes_write_indexed(first_nesvnic->nesdev,
310 NES_IDX_MAC_INT_MASK+
311 (0x200*first_nesvnic->nesdev->mac_index),
312 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
313 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
314 } else {
315 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+(0x200*nesdev->mac_index), 0xffffffff);
316 }
317
318 nic_active_mask = ~((u32)(1 << nesvnic->nic_index));
319 nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_HIGH+
320 (nesvnic->perfect_filter_index*8), 0);
321 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
322 nic_active &= nic_active_mask;
323 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
324 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
325 nic_active &= nic_active_mask;
326 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
327 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
328 nic_active &= nic_active_mask;
329 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
330 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
331 nic_active &= nic_active_mask;
332 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
333 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
334 nic_active &= nic_active_mask;
335 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
336
337 spin_lock_irqsave(&nesvnic->port_ibevent_lock, flags);
338 if (nesvnic->of_device_registered) {
339 nesdev->nesadapter->send_term_ok = 0;
340 nesdev->iw_status = 0;
341 if (nesvnic->linkup == 1)
342 nes_port_ibevent(nesvnic);
343 }
344 del_timer_sync(&nesvnic->event_timer);
345 nesvnic->event_timer.function = NULL;
346 spin_unlock_irqrestore(&nesvnic->port_ibevent_lock, flags);
347
348 nes_destroy_nic_qp(nesvnic);
349
350 nesvnic->netdev_open = 0;
351
352 return 0;
353 }
354
355
356 /**
357 * nes_nic_send
358 */
359 static bool nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
360 {
361 struct nes_vnic *nesvnic = netdev_priv(netdev);
362 struct nes_device *nesdev = nesvnic->nesdev;
363 struct nes_hw_nic *nesnic = &nesvnic->nic;
364 struct nes_hw_nic_sq_wqe *nic_sqe;
365 struct tcphdr *tcph;
366 __le16 *wqe_fragment_length;
367 u32 wqe_misc;
368 u16 wqe_fragment_index = 1; /* first fragment (0) is used by copy buffer */
369 u16 skb_fragment_index;
370 dma_addr_t bus_address;
371
372 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
373 wqe_fragment_length = (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
374
375 /* setup the VLAN tag if present */
376 if (skb_vlan_tag_present(skb)) {
377 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
378 netdev->name, skb_vlan_tag_get(skb));
379 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
380 wqe_fragment_length[0] = (__force __le16) skb_vlan_tag_get(skb);
381 } else
382 wqe_misc = 0;
383
384 /* bump past the vlan tag */
385 wqe_fragment_length++;
386 /* wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
387 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
388
389 if (skb->ip_summed == CHECKSUM_PARTIAL) {
390 if (skb_is_gso(skb)) {
391 tcph = tcp_hdr(skb);
392 /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... is_gso = %u seg size = %u\n",
393 netdev->name, skb_is_gso(skb), skb_shinfo(skb)->gso_size); */
394 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE | (u16)skb_shinfo(skb)->gso_size;
395 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
396 ((u32)tcph->doff) |
397 (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
398 }
399 } else { /* CHECKSUM_HW */
400 wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM;
401 }
402
403 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
404 skb->len);
405 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
406 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE), skb_headlen(skb)));
407 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
408 skb_headlen(skb)));
409 wqe_fragment_length[1] = 0;
410 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
411 if ((skb_shinfo(skb)->nr_frags + 1) > 4) {
412 nes_debug(NES_DBG_NIC_TX, "%s: Packet with %u fragments not sent, skb_headlen=%u\n",
413 netdev->name, skb_shinfo(skb)->nr_frags + 2, skb_headlen(skb));
414 kfree_skb(skb);
415 nesvnic->tx_sw_dropped++;
416 return false;
417 }
418 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
419 bus_address = pci_map_single(nesdev->pcidev, skb->data + NES_FIRST_FRAG_SIZE,
420 skb_headlen(skb) - NES_FIRST_FRAG_SIZE, PCI_DMA_TODEVICE);
421 wqe_fragment_length[wqe_fragment_index++] =
422 cpu_to_le16(skb_headlen(skb) - NES_FIRST_FRAG_SIZE);
423 wqe_fragment_length[wqe_fragment_index] = 0;
424 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
425 ((u64)(bus_address)));
426 nesnic->tx_skb[nesnic->sq_head] = skb;
427 }
428
429 if (skb_headlen(skb) == skb->len) {
430 if (skb_headlen(skb) <= NES_FIRST_FRAG_SIZE) {
431 nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_2_1_IDX] = 0;
432 nesnic->tx_skb[nesnic->sq_head] = skb;
433 }
434 } else {
435 /* Deal with Fragments */
436 nesnic->tx_skb[nesnic->sq_head] = skb;
437 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
438 skb_fragment_index++) {
439 skb_frag_t *frag =
440 &skb_shinfo(skb)->frags[skb_fragment_index];
441 bus_address = skb_frag_dma_map(&nesdev->pcidev->dev,
442 frag, 0, skb_frag_size(frag),
443 DMA_TO_DEVICE);
444 wqe_fragment_length[wqe_fragment_index] =
445 cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[skb_fragment_index]));
446 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
447 bus_address);
448 wqe_fragment_index++;
449 if (wqe_fragment_index < 5)
450 wqe_fragment_length[wqe_fragment_index] = 0;
451 }
452 }
453
454 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
455 nesnic->sq_head++;
456 nesnic->sq_head &= nesnic->sq_size - 1;
457 return true;
458 }
459
460
461 /**
462 * nes_netdev_start_xmit
463 */
464 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
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; */
472 #define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
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;
481 struct iphdr *iph;
482 __le16 *wqe_fragment_length;
483 u32 nr_frags;
484 u32 original_first_length;
485 /* u64 *wqe_fragment_address; */
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;
492 u32 wqe_misc;
493
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 */
500
501 if (netif_queue_stopped(netdev))
502 return NETDEV_TX_BUSY;
503
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++;
515 return NETDEV_TX_BUSY;
516 }
517
518 sq_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++;
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++;
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 }
550 tso_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++) {
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,
558 frag, 0, skb_frag_size(frag),
559 DMA_TO_DEVICE);
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 */
574 if (skb_vlan_tag_present(skb)) {
575 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
576 netdev->name,
577 skb_vlan_tag_get(skb));
578 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
579 wqe_fragment_length[0] = (__force __le16) skb_vlan_tag_get(skb);
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,"
591 " (%u frags), is_gso = %u tso_size=%u\n",
592 netdev->name,
593 skb->len, skb_headlen(skb),
594 skb_shinfo(skb)->nr_frags, skb_is_gso(skb), skb_shinfo(skb)->gso_size);
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);
626 tso_wqe_length += skb_headlen(skb) -
627 original_first_length;
628 }
629 while (wqe_fragment_index < 5) {
630 wqe_fragment_length[wqe_fragment_index] =
631 cpu_to_le16(skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index]));
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++;
635 tso_wqe_length += skb_frag_size(&skb_shinfo(skb)->frags[tso_frag_index++]);
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 }
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) {
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 {
665 hoffset = skb_transport_header(skb) - skb->data;
666 nhoffset = skb_network_header(skb) - skb->data;
667 if (skb_linearize(skb)) {
668 nesvnic->tx_sw_dropped++;
669 kfree_skb(skb);
670 return NETDEV_TX_OK;
671 }
672 nesvnic->linearized_skbs++;
673 skb_set_transport_header(skb, hoffset);
674 skb_set_network_header(skb, nhoffset);
675 if (!nes_nic_send(skb, netdev))
676 return NETDEV_TX_OK;
677 }
678 } else {
679 if (!nes_nic_send(skb, netdev))
680 return NETDEV_TX_OK;
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
689 netif_trans_update(netdev);
690
691 return NETDEV_TX_OK;
692 }
693
694
695 /**
696 * nes_netdev_get_stats
697 */
698 static 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 */
789 static 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 */
801 static 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);
814 printk(PFX "%s: Address length = %d, Address = %pM\n",
815 __func__, netdev->addr_len, mac_addr->sa_data);
816 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
817 macaddr_high += (u16)netdev->dev_addr[1];
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];
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
839 static 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
853 /**
854 * nes_netdev_set_multicast_list
855 */
856 static void nes_netdev_set_multicast_list(struct net_device *netdev)
857 {
858 struct nes_vnic *nesvnic = netdev_priv(netdev);
859 struct nes_device *nesdev = nesvnic->nesdev;
860 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
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;
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;
873 int mc_count = netdev_mc_count(netdev);
874
875 spin_lock_irqsave(&nesadapter->resource_lock, flags);
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;
886 } else if ((netdev->flags & IFF_ALLMULTI) ||
887 (nesvnic->nic_index > 3)) {
888 set_allmulti(nesdev, nic_active_bit);
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
899 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscuous = %d, All Multicast = %d.\n",
900 mc_count, !!(netdev->flags & IFF_PROMISC),
901 !!(netdev->flags & IFF_ALLMULTI));
902 if (!mc_all_on) {
903 char *addrs;
904 int i;
905 struct netdev_hw_addr *ha;
906
907 addrs = kmalloc(ETH_ALEN * mc_count, GFP_ATOMIC);
908 if (!addrs) {
909 set_allmulti(nesdev, nic_active_bit);
910 goto unlock;
911 }
912 i = 0;
913 netdev_for_each_mc_addr(ha, netdev)
914 memcpy(get_addr(addrs, i++), ha->addr, ETH_ALEN);
915
916 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW +
917 pft_entries_preallocated * 0x8;
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 &&
921 ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
922 get_addr(addrs, i++))) == 0));
923 if (mc_nic_index < 0)
924 mc_nic_index = nesvnic->nic_index;
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) {
929 nes_debug(NES_DBG_NIC_RX,
930 "mc_index=%d skipping nic_index=%d, "
931 "used for=%d \n", mc_index,
932 nesvnic->nic_index,
933 nesadapter->pft_mcast_map[mc_index]);
934 mc_index++;
935 }
936 if (mc_index >= max_pft_entries_avaiable)
937 break;
938 if (i < mc_count) {
939 char *addr = get_addr(addrs, i++);
940
941 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
942 addr,
943 perfect_filter_register_address+(mc_index * 8),
944 mc_nic_index);
945 macaddr_high = ((u8) addr[0]) << 8;
946 macaddr_high += (u8) addr[1];
947 macaddr_low = ((u8) addr[2]) << 24;
948 macaddr_low += ((u8) addr[3]) << 16;
949 macaddr_low += ((u8) addr[4]) << 8;
950 macaddr_low += (u8) addr[5];
951
952 nes_write_indexed(nesdev,
953 perfect_filter_register_address+(mc_index * 8),
954 macaddr_low);
955 nes_write_indexed(nesdev,
956 perfect_filter_register_address+4+(mc_index * 8),
957 (u32)macaddr_high | NES_MAC_ADDR_VALID |
958 ((((u32)(1<<mc_nic_index)) << 16)));
959 nesadapter->pft_mcast_map[mc_index] =
960 nesvnic->nic_index;
961 } else {
962 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
963 perfect_filter_register_address+(mc_index * 8));
964 nes_write_indexed(nesdev,
965 perfect_filter_register_address+4+(mc_index * 8),
966 0);
967 nesadapter->pft_mcast_map[mc_index] = 255;
968 }
969 }
970 kfree(addrs);
971 /* PFT is not large enough */
972 if (i < mc_count)
973 set_allmulti(nesdev, nic_active_bit);
974 }
975
976 unlock:
977 spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
978 }
979
980
981 /**
982 * nes_netdev_change_mtu
983 */
984 static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
985 {
986 struct nes_vnic *nesvnic = netdev_priv(netdev);
987 struct nes_device *nesdev = nesvnic->nesdev;
988 u8 jumbomode = 0;
989 u32 nic_active;
990 u32 nic_active_bit;
991 u32 uc_all_active;
992 u32 mc_all_active;
993
994 netdev->mtu = new_mtu;
995 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
996
997 if (netdev->mtu > ETH_DATA_LEN) {
998 jumbomode=1;
999 }
1000 nes_nic_init_timer_defaults(nesdev, jumbomode);
1001
1002 if (netif_running(netdev)) {
1003 nic_active_bit = 1 << nesvnic->nic_index;
1004 mc_all_active = nes_read_indexed(nesdev,
1005 NES_IDX_NIC_MULTICAST_ALL) & nic_active_bit;
1006 uc_all_active = nes_read_indexed(nesdev,
1007 NES_IDX_NIC_UNICAST_ALL) & nic_active_bit;
1008
1009 nes_netdev_stop(netdev);
1010 nes_netdev_open(netdev);
1011
1012 nic_active = nes_read_indexed(nesdev,
1013 NES_IDX_NIC_MULTICAST_ALL);
1014 nic_active |= mc_all_active;
1015 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL,
1016 nic_active);
1017
1018 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
1019 nic_active |= uc_all_active;
1020 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
1021 }
1022
1023 return 0;
1024 }
1025
1026
1027 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
1028 "Link Change Interrupts",
1029 "Linearized SKBs",
1030 "T/GSO Requests",
1031 "Pause Frames Sent",
1032 "Pause Frames Received",
1033 "Internal Routing Errors",
1034 "SQ SW Dropped SKBs",
1035 "SQ Full",
1036 "Segmented TSO Requests",
1037 "Rx Symbol Errors",
1038 "Rx Jabber Errors",
1039 "Rx Oversized Frames",
1040 "Rx Short Frames",
1041 "Rx Length Errors",
1042 "Rx CRC Errors",
1043 "Rx Port Discard",
1044 "Endnode Rx Discards",
1045 "Endnode Rx Octets",
1046 "Endnode Rx Frames",
1047 "Endnode Tx Octets",
1048 "Endnode Tx Frames",
1049 "Tx Errors",
1050 "mh detected",
1051 "mh pauses",
1052 "Retransmission Count",
1053 "CM Connects",
1054 "CM Accepts",
1055 "Disconnects",
1056 "Connected Events",
1057 "Connect Requests",
1058 "CM Rejects",
1059 "ModifyQP Timeouts",
1060 "CreateQPs",
1061 "SW DestroyQPs",
1062 "DestroyQPs",
1063 "CM Closes",
1064 "CM Packets Sent",
1065 "CM Packets Bounced",
1066 "CM Packets Created",
1067 "CM Packets Rcvd",
1068 "CM Packets Dropped",
1069 "CM Packets Retrans",
1070 "CM Listens Created",
1071 "CM Listens Destroyed",
1072 "CM Backlog Drops",
1073 "CM Loopbacks",
1074 "CM Nodes Created",
1075 "CM Nodes Destroyed",
1076 "CM Accel Drops",
1077 "CM Resets Received",
1078 "Free 4Kpbls",
1079 "Free 256pbls",
1080 "Timer Inits",
1081 "PAU CreateQPs",
1082 "PAU DestroyQPs",
1083 };
1084 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1085
1086
1087 /**
1088 * nes_netdev_get_sset_count
1089 */
1090 static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
1091 {
1092 if (stringset == ETH_SS_STATS)
1093 return NES_ETHTOOL_STAT_COUNT;
1094 else
1095 return -EINVAL;
1096 }
1097
1098
1099 /**
1100 * nes_netdev_get_strings
1101 */
1102 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1103 u8 *ethtool_strings)
1104 {
1105 if (stringset == ETH_SS_STATS)
1106 memcpy(ethtool_strings,
1107 &nes_ethtool_stringset,
1108 sizeof(nes_ethtool_stringset));
1109 }
1110
1111
1112 /**
1113 * nes_netdev_get_ethtool_stats
1114 */
1115
1116 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1117 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1118 {
1119 u64 u64temp;
1120 struct nes_vnic *nesvnic = netdev_priv(netdev);
1121 struct nes_device *nesdev = nesvnic->nesdev;
1122 struct nes_adapter *nesadapter = nesdev->nesadapter;
1123 u32 nic_count;
1124 u32 u32temp;
1125 u32 index = 0;
1126
1127 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1128 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1129 target_stat_values[++index] = nesvnic->linearized_skbs;
1130 target_stat_values[++index] = nesvnic->tso_requests;
1131
1132 u32temp = nes_read_indexed(nesdev,
1133 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1134 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1135 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
1136
1137 u32temp = nes_read_indexed(nesdev,
1138 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1139 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1140
1141 u32temp = nes_read_indexed(nesdev,
1142 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1143 nesvnic->nesdev->port_rx_discards += u32temp;
1144 nesvnic->netstats.rx_dropped += u32temp;
1145
1146 u32temp = nes_read_indexed(nesdev,
1147 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1148 nesvnic->nesdev->port_tx_discards += u32temp;
1149 nesvnic->netstats.tx_dropped += u32temp;
1150
1151 u32temp = nes_read_indexed(nesdev,
1152 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1153 nesvnic->netstats.rx_dropped += u32temp;
1154 nesvnic->nesdev->mac_rx_errors += u32temp;
1155 nesvnic->nesdev->mac_rx_short_frames += u32temp;
1156
1157 u32temp = nes_read_indexed(nesdev,
1158 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1159 nesvnic->netstats.rx_dropped += u32temp;
1160 nesvnic->nesdev->mac_rx_errors += u32temp;
1161 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
1162
1163 u32temp = nes_read_indexed(nesdev,
1164 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1165 nesvnic->netstats.rx_dropped += u32temp;
1166 nesvnic->nesdev->mac_rx_errors += u32temp;
1167 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
1168
1169 u32temp = nes_read_indexed(nesdev,
1170 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1171 nesvnic->netstats.rx_dropped += u32temp;
1172 nesvnic->nesdev->mac_rx_errors += u32temp;
1173 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
1174
1175 u32temp = nes_read_indexed(nesdev,
1176 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1177 nesvnic->netstats.rx_length_errors += u32temp;
1178 nesvnic->nesdev->mac_rx_errors += u32temp;
1179
1180 u32temp = nes_read_indexed(nesdev,
1181 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1182 nesvnic->nesdev->mac_rx_errors += u32temp;
1183 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
1184 nesvnic->netstats.rx_crc_errors += u32temp;
1185
1186 u32temp = nes_read_indexed(nesdev,
1187 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
1188 nesvnic->nesdev->mac_tx_errors += u32temp;
1189 nesvnic->netstats.tx_errors += u32temp;
1190
1191 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1192 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1193 break;
1194
1195 u32temp = nes_read_indexed(nesdev,
1196 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1197 (nesvnic->qp_nic_index[nic_count]*0x200));
1198 nesvnic->netstats.rx_dropped += u32temp;
1199 nesvnic->endnode_nstat_rx_discard += u32temp;
1200
1201 u64temp = (u64)nes_read_indexed(nesdev,
1202 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1203 (nesvnic->qp_nic_index[nic_count]*0x200));
1204 u64temp += ((u64)nes_read_indexed(nesdev,
1205 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1206 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1207
1208 nesvnic->endnode_nstat_rx_octets += u64temp;
1209 nesvnic->netstats.rx_bytes += u64temp;
1210
1211 u64temp = (u64)nes_read_indexed(nesdev,
1212 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1213 (nesvnic->qp_nic_index[nic_count]*0x200));
1214 u64temp += ((u64)nes_read_indexed(nesdev,
1215 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1216 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1217
1218 nesvnic->endnode_nstat_rx_frames += u64temp;
1219 nesvnic->netstats.rx_packets += u64temp;
1220
1221 u64temp = (u64)nes_read_indexed(nesdev,
1222 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1223 (nesvnic->qp_nic_index[nic_count]*0x200));
1224 u64temp += ((u64)nes_read_indexed(nesdev,
1225 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1226 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1227
1228 nesvnic->endnode_nstat_tx_octets += u64temp;
1229 nesvnic->netstats.tx_bytes += u64temp;
1230
1231 u64temp = (u64)nes_read_indexed(nesdev,
1232 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1233 (nesvnic->qp_nic_index[nic_count]*0x200));
1234 u64temp += ((u64)nes_read_indexed(nesdev,
1235 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1236 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1237
1238 nesvnic->endnode_nstat_tx_frames += u64temp;
1239 nesvnic->netstats.tx_packets += u64temp;
1240
1241 u32temp = nes_read_indexed(nesdev,
1242 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1243 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1244 }
1245
1246 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1247 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1248 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1249 target_stat_values[++index] = nesvnic->sq_full;
1250 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1251 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1252 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1253 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1254 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
1255 target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
1256 target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
1257 target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
1258 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1259 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1260 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1261 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1262 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
1263 target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
1264 target_stat_values[++index] = mh_detected;
1265 target_stat_values[++index] = mh_pauses_sent;
1266 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1267 target_stat_values[++index] = atomic_read(&cm_connects);
1268 target_stat_values[++index] = atomic_read(&cm_accepts);
1269 target_stat_values[++index] = atomic_read(&cm_disconnects);
1270 target_stat_values[++index] = atomic_read(&cm_connecteds);
1271 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1272 target_stat_values[++index] = atomic_read(&cm_rejects);
1273 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1274 target_stat_values[++index] = atomic_read(&qps_created);
1275 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1276 target_stat_values[++index] = atomic_read(&qps_destroyed);
1277 target_stat_values[++index] = atomic_read(&cm_closes);
1278 target_stat_values[++index] = cm_packets_sent;
1279 target_stat_values[++index] = cm_packets_bounced;
1280 target_stat_values[++index] = cm_packets_created;
1281 target_stat_values[++index] = cm_packets_received;
1282 target_stat_values[++index] = cm_packets_dropped;
1283 target_stat_values[++index] = cm_packets_retrans;
1284 target_stat_values[++index] = atomic_read(&cm_listens_created);
1285 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
1286 target_stat_values[++index] = cm_backlog_drops;
1287 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1288 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1289 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1290 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1291 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
1292 target_stat_values[++index] = nesadapter->free_4kpbl;
1293 target_stat_values[++index] = nesadapter->free_256pbl;
1294 target_stat_values[++index] = int_mod_timer_init;
1295 target_stat_values[++index] = atomic_read(&pau_qps_created);
1296 target_stat_values[++index] = atomic_read(&pau_qps_destroyed);
1297 }
1298
1299 /**
1300 * nes_netdev_get_drvinfo
1301 */
1302 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1303 struct ethtool_drvinfo *drvinfo)
1304 {
1305 struct nes_vnic *nesvnic = netdev_priv(netdev);
1306 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
1307
1308 strlcpy(drvinfo->driver, DRV_NAME, sizeof(drvinfo->driver));
1309 strlcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev),
1310 sizeof(drvinfo->bus_info));
1311 snprintf(drvinfo->fw_version, sizeof(drvinfo->fw_version),
1312 "%u.%u", nesadapter->firmware_version >> 16,
1313 nesadapter->firmware_version & 0x000000ff);
1314 strlcpy(drvinfo->version, DRV_VERSION, sizeof(drvinfo->version));
1315 }
1316
1317
1318 /**
1319 * nes_netdev_set_coalesce
1320 */
1321 static int nes_netdev_set_coalesce(struct net_device *netdev,
1322 struct ethtool_coalesce *et_coalesce)
1323 {
1324 struct nes_vnic *nesvnic = netdev_priv(netdev);
1325 struct nes_device *nesdev = nesvnic->nesdev;
1326 struct nes_adapter *nesadapter = nesdev->nesadapter;
1327 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1328 unsigned long flags;
1329
1330 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1331 if (et_coalesce->rx_max_coalesced_frames_low) {
1332 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1333 }
1334 if (et_coalesce->rx_max_coalesced_frames_irq) {
1335 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1336 }
1337 if (et_coalesce->rx_max_coalesced_frames_high) {
1338 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1339 }
1340 if (et_coalesce->rx_coalesce_usecs_low) {
1341 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1342 }
1343 if (et_coalesce->rx_coalesce_usecs_high) {
1344 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1345 }
1346 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1347
1348 /* using this to drive total interrupt moderation */
1349 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1350 if (et_coalesce->use_adaptive_rx_coalesce) {
1351 nesadapter->et_use_adaptive_rx_coalesce = 1;
1352 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1353 nesadapter->et_rx_coalesce_usecs_irq = 0;
1354 if (et_coalesce->pkt_rate_low) {
1355 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1356 }
1357 } else {
1358 nesadapter->et_use_adaptive_rx_coalesce = 0;
1359 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1360 if (nesadapter->et_rx_coalesce_usecs_irq) {
1361 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1362 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1363 }
1364 }
1365 return 0;
1366 }
1367
1368
1369 /**
1370 * nes_netdev_get_coalesce
1371 */
1372 static int nes_netdev_get_coalesce(struct net_device *netdev,
1373 struct ethtool_coalesce *et_coalesce)
1374 {
1375 struct nes_vnic *nesvnic = netdev_priv(netdev);
1376 struct nes_device *nesdev = nesvnic->nesdev;
1377 struct nes_adapter *nesadapter = nesdev->nesadapter;
1378 struct ethtool_coalesce temp_et_coalesce;
1379 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1380 unsigned long flags;
1381
1382 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1383 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1384 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1385 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1386 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1387 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1388 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1389 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
1390 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1391 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1392 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1393 if (nesadapter->et_use_adaptive_rx_coalesce) {
1394 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1395 }
1396 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1397 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1398 return 0;
1399 }
1400
1401
1402 /**
1403 * nes_netdev_get_pauseparam
1404 */
1405 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1406 struct ethtool_pauseparam *et_pauseparam)
1407 {
1408 struct nes_vnic *nesvnic = netdev_priv(netdev);
1409
1410 et_pauseparam->autoneg = 0;
1411 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1412 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1413 }
1414
1415
1416 /**
1417 * nes_netdev_set_pauseparam
1418 */
1419 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1420 struct ethtool_pauseparam *et_pauseparam)
1421 {
1422 struct nes_vnic *nesvnic = netdev_priv(netdev);
1423 struct nes_device *nesdev = nesvnic->nesdev;
1424 u32 u32temp;
1425
1426 if (et_pauseparam->autoneg) {
1427 /* TODO: should return unsupported */
1428 return 0;
1429 }
1430 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1431 u32temp = nes_read_indexed(nesdev,
1432 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1433 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1434 nes_write_indexed(nesdev,
1435 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
1436 nesdev->disable_tx_flow_control = 0;
1437 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
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,
1442 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
1443 nesdev->disable_tx_flow_control = 1;
1444 }
1445 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1446 u32temp = nes_read_indexed(nesdev,
1447 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1448 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1449 nes_write_indexed(nesdev,
1450 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1451 nesdev->disable_rx_flow_control = 0;
1452 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
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 = 1;
1459 }
1460
1461 return 0;
1462 }
1463
1464
1465 /**
1466 * nes_netdev_get_settings
1467 */
1468 static int nes_netdev_get_link_ksettings(struct net_device *netdev,
1469 struct ethtool_link_ksettings *cmd)
1470 {
1471 struct nes_vnic *nesvnic = netdev_priv(netdev);
1472 struct nes_device *nesdev = nesvnic->nesdev;
1473 struct nes_adapter *nesadapter = nesdev->nesadapter;
1474 u32 mac_index = nesdev->mac_index;
1475 u8 phy_type = nesadapter->phy_type[mac_index];
1476 u8 phy_index = nesadapter->phy_index[mac_index];
1477 u16 phy_data;
1478 u32 supported, advertising;
1479
1480 cmd->base.duplex = DUPLEX_FULL;
1481 cmd->base.port = PORT_MII;
1482
1483 if (nesadapter->OneG_Mode) {
1484 cmd->base.speed = SPEED_1000;
1485 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
1486 supported = SUPPORTED_1000baseT_Full;
1487 advertising = ADVERTISED_1000baseT_Full;
1488 cmd->base.autoneg = AUTONEG_DISABLE;
1489 cmd->base.phy_address = mac_index;
1490 } else {
1491 unsigned long flags;
1492
1493 supported = SUPPORTED_1000baseT_Full
1494 | SUPPORTED_Autoneg;
1495 advertising = ADVERTISED_1000baseT_Full
1496 | ADVERTISED_Autoneg;
1497 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1498 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1499 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1500 if (phy_data & 0x1000)
1501 cmd->base.autoneg = AUTONEG_ENABLE;
1502 else
1503 cmd->base.autoneg = AUTONEG_DISABLE;
1504 cmd->base.phy_address = phy_index;
1505 }
1506 ethtool_convert_legacy_u32_to_link_mode(
1507 cmd->link_modes.supported, supported);
1508 ethtool_convert_legacy_u32_to_link_mode(
1509 cmd->link_modes.advertising, advertising);
1510 return 0;
1511 }
1512 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1513 (phy_type == NES_PHY_TYPE_SFP_D) ||
1514 (phy_type == NES_PHY_TYPE_KR)) {
1515 cmd->base.port = PORT_FIBRE;
1516 supported = SUPPORTED_FIBRE;
1517 advertising = ADVERTISED_FIBRE;
1518 cmd->base.phy_address = phy_index;
1519 } else {
1520 supported = SUPPORTED_10000baseT_Full;
1521 advertising = ADVERTISED_10000baseT_Full;
1522 cmd->base.phy_address = mac_index;
1523 }
1524 cmd->base.speed = SPEED_10000;
1525 cmd->base.autoneg = AUTONEG_DISABLE;
1526 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1527 supported);
1528 ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
1529 advertising);
1530
1531 return 0;
1532 }
1533
1534
1535 /**
1536 * nes_netdev_set_settings
1537 */
1538 static int
1539 nes_netdev_set_link_ksettings(struct net_device *netdev,
1540 const struct ethtool_link_ksettings *cmd)
1541 {
1542 struct nes_vnic *nesvnic = netdev_priv(netdev);
1543 struct nes_device *nesdev = nesvnic->nesdev;
1544 struct nes_adapter *nesadapter = nesdev->nesadapter;
1545
1546 if ((nesadapter->OneG_Mode) &&
1547 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1548 unsigned long flags;
1549 u16 phy_data;
1550 u8 phy_index = nesadapter->phy_index[nesdev->mac_index];
1551
1552 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1553 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1554 if (cmd->base.autoneg) {
1555 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1556 phy_data |= 0x1300;
1557 } else {
1558 /* Turn off autoneg */
1559 phy_data &= ~0x1000;
1560 }
1561 nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data);
1562 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1563 }
1564
1565 return 0;
1566 }
1567
1568
1569 static const struct ethtool_ops nes_ethtool_ops = {
1570 .get_link = ethtool_op_get_link,
1571 .get_strings = nes_netdev_get_strings,
1572 .get_sset_count = nes_netdev_get_sset_count,
1573 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1574 .get_drvinfo = nes_netdev_get_drvinfo,
1575 .get_coalesce = nes_netdev_get_coalesce,
1576 .set_coalesce = nes_netdev_set_coalesce,
1577 .get_pauseparam = nes_netdev_get_pauseparam,
1578 .set_pauseparam = nes_netdev_set_pauseparam,
1579 .get_link_ksettings = nes_netdev_get_link_ksettings,
1580 .set_link_ksettings = nes_netdev_set_link_ksettings,
1581 };
1582
1583 static void nes_vlan_mode(struct net_device *netdev, struct nes_device *nesdev, netdev_features_t features)
1584 {
1585 struct nes_adapter *nesadapter = nesdev->nesadapter;
1586 u32 u32temp;
1587 unsigned long flags;
1588
1589 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1590
1591 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1592
1593 /* Enable/Disable VLAN Stripping */
1594 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1595 if (features & NETIF_F_HW_VLAN_CTAG_RX)
1596 u32temp &= 0xfdffffff;
1597 else
1598 u32temp |= 0x02000000;
1599
1600 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1601 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1602 }
1603
1604 static netdev_features_t nes_fix_features(struct net_device *netdev, netdev_features_t features)
1605 {
1606 /*
1607 * Since there is no support for separate rx/tx vlan accel
1608 * enable/disable make sure tx flag is always in same state as rx.
1609 */
1610 if (features & NETIF_F_HW_VLAN_CTAG_RX)
1611 features |= NETIF_F_HW_VLAN_CTAG_TX;
1612 else
1613 features &= ~NETIF_F_HW_VLAN_CTAG_TX;
1614
1615 return features;
1616 }
1617
1618 static int nes_set_features(struct net_device *netdev, netdev_features_t features)
1619 {
1620 struct nes_vnic *nesvnic = netdev_priv(netdev);
1621 struct nes_device *nesdev = nesvnic->nesdev;
1622 u32 changed = netdev->features ^ features;
1623
1624 if (changed & NETIF_F_HW_VLAN_CTAG_RX)
1625 nes_vlan_mode(netdev, nesdev, features);
1626
1627 return 0;
1628 }
1629
1630 static const struct net_device_ops nes_netdev_ops = {
1631 .ndo_open = nes_netdev_open,
1632 .ndo_stop = nes_netdev_stop,
1633 .ndo_start_xmit = nes_netdev_start_xmit,
1634 .ndo_get_stats = nes_netdev_get_stats,
1635 .ndo_tx_timeout = nes_netdev_tx_timeout,
1636 .ndo_set_mac_address = nes_netdev_set_mac_address,
1637 .ndo_set_rx_mode = nes_netdev_set_multicast_list,
1638 .ndo_change_mtu = nes_netdev_change_mtu,
1639 .ndo_validate_addr = eth_validate_addr,
1640 .ndo_fix_features = nes_fix_features,
1641 .ndo_set_features = nes_set_features,
1642 };
1643
1644 /**
1645 * nes_netdev_init - initialize network device
1646 */
1647 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1648 void __iomem *mmio_addr)
1649 {
1650 u64 u64temp;
1651 struct nes_vnic *nesvnic;
1652 struct net_device *netdev;
1653 struct nic_qp_map *curr_qp_map;
1654 u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
1655
1656 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1657 if (!netdev) {
1658 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1659 return NULL;
1660 }
1661 nesvnic = netdev_priv(netdev);
1662
1663 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1664
1665 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1666
1667 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1668 netdev->irq = nesdev->pcidev->irq;
1669 netdev->max_mtu = NES_MAX_MTU;
1670 netdev->hard_header_len = ETH_HLEN;
1671 netdev->addr_len = ETH_ALEN;
1672 netdev->type = ARPHRD_ETHER;
1673 netdev->netdev_ops = &nes_netdev_ops;
1674 netdev->ethtool_ops = &nes_ethtool_ops;
1675 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1676 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1677
1678 /* Fill in the port structure */
1679 nesvnic->netdev = netdev;
1680 nesvnic->nesdev = nesdev;
1681 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1682 nesvnic->netdev_index = nesdev->netdev_count;
1683 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1684 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1685
1686 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1687 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1688 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1689 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1690
1691 /* Setup the burned in MAC address */
1692 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1693 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1694 u64temp += nesvnic->nic_index;
1695 netdev->dev_addr[0] = (u8)(u64temp>>40);
1696 netdev->dev_addr[1] = (u8)(u64temp>>32);
1697 netdev->dev_addr[2] = (u8)(u64temp>>24);
1698 netdev->dev_addr[3] = (u8)(u64temp>>16);
1699 netdev->dev_addr[4] = (u8)(u64temp>>8);
1700 netdev->dev_addr[5] = (u8)u64temp;
1701
1702 netdev->hw_features = NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_RXCSUM | NETIF_F_HW_VLAN_CTAG_RX;
1703 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV))
1704 netdev->hw_features |= NETIF_F_TSO;
1705
1706 netdev->features = netdev->hw_features | NETIF_F_HIGHDMA | NETIF_F_HW_VLAN_CTAG_TX;
1707
1708 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1709 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1710 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1711 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1712
1713 if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1714 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1715
1716 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1717 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1718 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1719 nesvnic->qp_nic_index[2] = 0xf;
1720 nesvnic->qp_nic_index[3] = 0xf;
1721 } else {
1722 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1723 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1724 }
1725 } else {
1726 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1727 (nesvnic->nesdev->nesadapter->port_count == 1 &&
1728 nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1729 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1730 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1731 + 2;
1732 nesvnic->qp_nic_index[2] = 0xf;
1733 nesvnic->qp_nic_index[3] = 0xf;
1734 } else {
1735 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1736 nesvnic->qp_nic_index[1] = 0xf;
1737 nesvnic->qp_nic_index[2] = 0xf;
1738 nesvnic->qp_nic_index[3] = 0xf;
1739 }
1740 }
1741 nesvnic->next_qp_nic_index = 0;
1742
1743 if (nesdev->netdev_count == 0) {
1744 nesvnic->rdma_enabled = 1;
1745 } else {
1746 nesvnic->rdma_enabled = 0;
1747 }
1748 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1749 init_timer(&nesvnic->event_timer);
1750 nesvnic->event_timer.function = NULL;
1751 spin_lock_init(&nesvnic->tx_lock);
1752 spin_lock_init(&nesvnic->port_ibevent_lock);
1753 nesdev->netdev[nesdev->netdev_count] = netdev;
1754
1755 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1756 nesvnic, nesdev->mac_index);
1757 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1758
1759 if ((nesdev->netdev_count == 0) &&
1760 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1761 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
1762 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1763 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1764 u32 u32temp;
1765 u32 link_mask = 0;
1766 u32 link_val = 0;
1767 u16 temp_phy_data;
1768 u16 phy_data = 0;
1769 unsigned long flags;
1770
1771 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1772 (0x200 * (nesdev->mac_index & 1)));
1773 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
1774 u32temp |= 0x00200000;
1775 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1776 (0x200 * (nesdev->mac_index & 1)), u32temp);
1777 }
1778
1779 /* Check and set linkup here. This is for back to back */
1780 /* configuration where second port won't get link interrupt */
1781 switch (phy_type) {
1782 case NES_PHY_TYPE_PUMA_1G:
1783 if (nesdev->mac_index < 2) {
1784 link_mask = 0x01010000;
1785 link_val = 0x01010000;
1786 } else {
1787 link_mask = 0x02020000;
1788 link_val = 0x02020000;
1789 }
1790 break;
1791 case NES_PHY_TYPE_SFP_D:
1792 spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
1793 nes_read_10G_phy_reg(nesdev,
1794 nesdev->nesadapter->phy_index[nesdev->mac_index],
1795 1, 0x9003);
1796 temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1797 nes_read_10G_phy_reg(nesdev,
1798 nesdev->nesadapter->phy_index[nesdev->mac_index],
1799 3, 0x0021);
1800 nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1801 nes_read_10G_phy_reg(nesdev,
1802 nesdev->nesadapter->phy_index[nesdev->mac_index],
1803 3, 0x0021);
1804 phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1805 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
1806 phy_data = (!temp_phy_data && (phy_data == 0x8000)) ? 0x4 : 0x0;
1807 break;
1808 default:
1809 link_mask = 0x0f1f0000;
1810 link_val = 0x0f0f0000;
1811 break;
1812 }
1813
1814 u32temp = nes_read_indexed(nesdev,
1815 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1816 (0x200 * (nesdev->mac_index & 1)));
1817
1818 if (phy_type == NES_PHY_TYPE_SFP_D) {
1819 if (phy_data & 0x0004)
1820 nesvnic->linkup = 1;
1821 } else {
1822 if ((u32temp & link_mask) == link_val)
1823 nesvnic->linkup = 1;
1824 }
1825
1826 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1827 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1828 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1829 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1830
1831 nes_init_phy(nesdev);
1832 }
1833
1834 nes_vlan_mode(netdev, nesdev, netdev->features);
1835
1836 return netdev;
1837 }
1838
1839
1840 /**
1841 * nes_netdev_destroy - destroy network device structure
1842 */
1843 void nes_netdev_destroy(struct net_device *netdev)
1844 {
1845 struct nes_vnic *nesvnic = netdev_priv(netdev);
1846
1847 /* make sure 'stop' method is called by Linux stack */
1848 /* nes_netdev_stop(netdev); */
1849
1850 list_del(&nesvnic->list);
1851
1852 if (nesvnic->of_device_registered) {
1853 nes_destroy_ofa_device(nesvnic->nesibdev);
1854 }
1855
1856 free_netdev(netdev);
1857 }
1858
1859
1860 /**
1861 * nes_nic_cm_xmit -- CM calls this to send out pkts
1862 */
1863 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1864 {
1865 int ret;
1866
1867 skb->dev = netdev;
1868 ret = dev_queue_xmit(skb);
1869 if (ret) {
1870 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1871 }
1872
1873 return ret;
1874 }
Ubuntu Artful kernel mirror