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