?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
nes: do vlan cleanup
[linux-2.6/libata-dev.git] / drivers / infiniband / hw / nes / nes_nic.c
blob9d7ffebff213f4f5f705d62bea366979d64a229c
1 /*
2 * Copyright (c) 2006 - 2009 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 if (nesdev->link_recheck)
247 cancel_delayed_work(&nesdev->work);
248 nesdev->link_recheck = 1;
249 schedule_delayed_work(&nesdev->work, NES_LINK_RECHECK_DELAY);
250 }
251 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
252
253 spin_lock_irqsave(&nesvnic->port_ibevent_lock, flags);
254 if (nesvnic->of_device_registered) {
255 nesdev->nesadapter->send_term_ok = 1;
256 if (nesvnic->linkup == 1) {
257 if (nesdev->iw_status == 0) {
258 nesdev->iw_status = 1;
259 nes_port_ibevent(nesvnic);
260 }
261 } else {
262 nesdev->iw_status = 0;
263 }
264 }
265 spin_unlock_irqrestore(&nesvnic->port_ibevent_lock, flags);
266
267 napi_enable(&nesvnic->napi);
268 nesvnic->netdev_open = 1;
269
270 return 0;
271 }
272
273
274 /**
275 * nes_netdev_stop
276 */
277 static int nes_netdev_stop(struct net_device *netdev)
278 {
279 struct nes_vnic *nesvnic = netdev_priv(netdev);
280 struct nes_device *nesdev = nesvnic->nesdev;
281 u32 nic_active_mask;
282 u32 nic_active;
283 struct nes_vnic *first_nesvnic = NULL;
284 struct list_head *list_pos, *list_temp;
285 unsigned long flags;
286
287 nes_debug(NES_DBG_SHUTDOWN, "nesvnic=%p, nesdev=%p, netdev=%p %s\n",
288 nesvnic, nesdev, netdev, netdev->name);
289 if (nesvnic->netdev_open == 0)
290 return 0;
291
292 if (netif_msg_ifdown(nesvnic))
293 printk(KERN_INFO PFX "%s: disabling interface\n", netdev->name);
294 netif_carrier_off(netdev);
295
296 /* Disable network packets */
297 napi_disable(&nesvnic->napi);
298 netif_stop_queue(netdev);
299 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
300 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
301 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic))
302 break;
303 }
304
305 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic) &&
306 (PCI_FUNC(first_nesvnic->nesdev->pcidev->devfn) !=
307 PCI_FUNC(nesvnic->nesdev->pcidev->devfn))) {
308 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+
309 (0x200*nesdev->mac_index), 0xffffffff);
310 nes_write_indexed(first_nesvnic->nesdev,
311 NES_IDX_MAC_INT_MASK+
312 (0x200*first_nesvnic->nesdev->mac_index),
313 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
314 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
315 } else {
316 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+(0x200*nesdev->mac_index), 0xffffffff);
317 }
318
319 nic_active_mask = ~((u32)(1 << nesvnic->nic_index));
320 nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_HIGH+
321 (nesvnic->perfect_filter_index*8), 0);
322 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
323 nic_active &= nic_active_mask;
324 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
325 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
326 nic_active &= nic_active_mask;
327 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
328 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
329 nic_active &= nic_active_mask;
330 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
331 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
332 nic_active &= nic_active_mask;
333 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
334 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
335 nic_active &= nic_active_mask;
336 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
337
338 spin_lock_irqsave(&nesvnic->port_ibevent_lock, flags);
339 if (nesvnic->of_device_registered) {
340 nesdev->nesadapter->send_term_ok = 0;
341 nesdev->iw_status = 0;
342 if (nesvnic->linkup == 1)
343 nes_port_ibevent(nesvnic);
344 }
345 del_timer_sync(&nesvnic->event_timer);
346 nesvnic->event_timer.function = NULL;
347 spin_unlock_irqrestore(&nesvnic->port_ibevent_lock, flags);
348
349 nes_destroy_nic_qp(nesvnic);
350
351 nesvnic->netdev_open = 0;
352
353 return 0;
354 }
355
356
357 /**
358 * nes_nic_send
359 */
360 static int nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
361 {
362 struct nes_vnic *nesvnic = netdev_priv(netdev);
363 struct nes_device *nesdev = nesvnic->nesdev;
364 struct nes_hw_nic *nesnic = &nesvnic->nic;
365 struct nes_hw_nic_sq_wqe *nic_sqe;
366 struct tcphdr *tcph;
367 __le16 *wqe_fragment_length;
368 u32 wqe_misc;
369 u16 wqe_fragment_index = 1; /* first fragment (0) is used by copy buffer */
370 u16 skb_fragment_index;
371 dma_addr_t bus_address;
372
373 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
374 wqe_fragment_length = (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
375
376 /* setup the VLAN tag if present */
377 if (vlan_tx_tag_present(skb)) {
378 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
379 netdev->name, vlan_tx_tag_get(skb));
380 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
381 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
382 } else
383 wqe_misc = 0;
384
385 /* bump past the vlan tag */
386 wqe_fragment_length++;
387 /* wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
388
389 if (skb->ip_summed == CHECKSUM_PARTIAL) {
390 tcph = tcp_hdr(skb);
391 if (1) {
392 if (skb_is_gso(skb)) {
393 /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... seg size = %u\n",
394 netdev->name, skb_is_gso(skb)); */
395 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE |
396 NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
397 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
398 ((u32)tcph->doff) |
399 (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
400 } else {
401 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
402 }
403 }
404 } else { /* CHECKSUM_HW */
405 wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM | NES_NIC_SQ_WQE_COMPLETION;
406 }
407
408 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
409 skb->len);
410 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
411 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE), skb_headlen(skb)));
412 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
413 skb_headlen(skb)));
414 wqe_fragment_length[1] = 0;
415 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
416 if ((skb_shinfo(skb)->nr_frags + 1) > 4) {
417 nes_debug(NES_DBG_NIC_TX, "%s: Packet with %u fragments not sent, skb_headlen=%u\n",
418 netdev->name, skb_shinfo(skb)->nr_frags + 2, skb_headlen(skb));
419 kfree_skb(skb);
420 nesvnic->tx_sw_dropped++;
421 return NETDEV_TX_LOCKED;
422 }
423 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
424 bus_address = pci_map_single(nesdev->pcidev, skb->data + NES_FIRST_FRAG_SIZE,
425 skb_headlen(skb) - NES_FIRST_FRAG_SIZE, PCI_DMA_TODEVICE);
426 wqe_fragment_length[wqe_fragment_index++] =
427 cpu_to_le16(skb_headlen(skb) - NES_FIRST_FRAG_SIZE);
428 wqe_fragment_length[wqe_fragment_index] = 0;
429 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
430 ((u64)(bus_address)));
431 nesnic->tx_skb[nesnic->sq_head] = skb;
432 }
433
434 if (skb_headlen(skb) == skb->len) {
435 if (skb_headlen(skb) <= NES_FIRST_FRAG_SIZE) {
436 nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_2_1_IDX] = 0;
437 nesnic->tx_skb[nesnic->sq_head] = skb;
438 }
439 } else {
440 /* Deal with Fragments */
441 nesnic->tx_skb[nesnic->sq_head] = skb;
442 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
443 skb_fragment_index++) {
444 bus_address = pci_map_page( nesdev->pcidev,
445 skb_shinfo(skb)->frags[skb_fragment_index].page,
446 skb_shinfo(skb)->frags[skb_fragment_index].page_offset,
447 skb_shinfo(skb)->frags[skb_fragment_index].size,
448 PCI_DMA_TODEVICE);
449 wqe_fragment_length[wqe_fragment_index] =
450 cpu_to_le16(skb_shinfo(skb)->frags[skb_fragment_index].size);
451 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
452 bus_address);
453 wqe_fragment_index++;
454 if (wqe_fragment_index < 5)
455 wqe_fragment_length[wqe_fragment_index] = 0;
456 }
457 }
458
459 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
460 nesnic->sq_head++;
461 nesnic->sq_head &= nesnic->sq_size - 1;
462
463 return NETDEV_TX_OK;
464 }
465
466
467 /**
468 * nes_netdev_start_xmit
469 */
470 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
471 {
472 struct nes_vnic *nesvnic = netdev_priv(netdev);
473 struct nes_device *nesdev = nesvnic->nesdev;
474 struct nes_hw_nic *nesnic = &nesvnic->nic;
475 struct nes_hw_nic_sq_wqe *nic_sqe;
476 struct tcphdr *tcph;
477 /* struct udphdr *udph; */
478 #define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
479 /* 64K segment plus overflow on each side */
480 dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
481 dma_addr_t bus_address;
482 u32 tso_frag_index;
483 u32 tso_frag_count;
484 u32 tso_wqe_length;
485 u32 curr_tcp_seq;
486 u32 wqe_count=1;
487 u32 send_rc;
488 struct iphdr *iph;
489 __le16 *wqe_fragment_length;
490 u32 nr_frags;
491 u32 original_first_length;
492 /* u64 *wqe_fragment_address; */
493 /* first fragment (0) is used by copy buffer */
494 u16 wqe_fragment_index=1;
495 u16 hoffset;
496 u16 nhoffset;
497 u16 wqes_needed;
498 u16 wqes_available;
499 u32 wqe_misc;
500
501 /*
502 * nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
503 * " (%u frags), tso_size=%u\n",
504 * netdev->name, skb->len, skb_headlen(skb),
505 * skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
506 */
507
508 if (!netif_carrier_ok(netdev))
509 return NETDEV_TX_OK;
510
511 if (netif_queue_stopped(netdev))
512 return NETDEV_TX_BUSY;
513
514 /* Check if SQ is full */
515 if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
516 if (!netif_queue_stopped(netdev)) {
517 netif_stop_queue(netdev);
518 barrier();
519 if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
520 netif_start_queue(netdev);
521 goto sq_no_longer_full;
522 }
523 }
524 nesvnic->sq_full++;
525 return NETDEV_TX_BUSY;
526 }
527
528 sq_no_longer_full:
529 nr_frags = skb_shinfo(skb)->nr_frags;
530 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
531 nr_frags++;
532 }
533 /* Check if too many fragments */
534 if (unlikely((nr_frags > 4))) {
535 if (skb_is_gso(skb)) {
536 nesvnic->segmented_tso_requests++;
537 nesvnic->tso_requests++;
538 /* Basically 4 fragments available per WQE with extended fragments */
539 wqes_needed = nr_frags >> 2;
540 wqes_needed += (nr_frags&3)?1:0;
541 wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
542 (nesnic->sq_size - 1);
543
544 if (unlikely(wqes_needed > wqes_available)) {
545 if (!netif_queue_stopped(netdev)) {
546 netif_stop_queue(netdev);
547 barrier();
548 wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
549 (nesnic->sq_size - 1);
550 if (wqes_needed <= wqes_available) {
551 netif_start_queue(netdev);
552 goto tso_sq_no_longer_full;
553 }
554 }
555 nesvnic->sq_full++;
556 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
557 netdev->name);
558 return NETDEV_TX_BUSY;
559 }
560 tso_sq_no_longer_full:
561 /* Map all the buffers */
562 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
563 tso_frag_count++) {
564 tso_bus_address[tso_frag_count] = pci_map_page( nesdev->pcidev,
565 skb_shinfo(skb)->frags[tso_frag_count].page,
566 skb_shinfo(skb)->frags[tso_frag_count].page_offset,
567 skb_shinfo(skb)->frags[tso_frag_count].size,
568 PCI_DMA_TODEVICE);
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_shinfo(skb)->frags[tso_frag_index].size);
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_shinfo(skb)->frags[tso_frag_index++].size;
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 };
1094 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1095
1096
1097 /**
1098 * nes_netdev_get_sset_count
1099 */
1100 static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
1101 {
1102 if (stringset == ETH_SS_STATS)
1103 return NES_ETHTOOL_STAT_COUNT;
1104 else
1105 return -EINVAL;
1106 }
1107
1108
1109 /**
1110 * nes_netdev_get_strings
1111 */
1112 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1113 u8 *ethtool_strings)
1114 {
1115 if (stringset == ETH_SS_STATS)
1116 memcpy(ethtool_strings,
1117 &nes_ethtool_stringset,
1118 sizeof(nes_ethtool_stringset));
1119 }
1120
1121
1122 /**
1123 * nes_netdev_get_ethtool_stats
1124 */
1125
1126 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1127 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1128 {
1129 u64 u64temp;
1130 struct nes_vnic *nesvnic = netdev_priv(netdev);
1131 struct nes_device *nesdev = nesvnic->nesdev;
1132 struct nes_adapter *nesadapter = nesdev->nesadapter;
1133 u32 nic_count;
1134 u32 u32temp;
1135 u32 index = 0;
1136
1137 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1138 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1139 target_stat_values[++index] = nesvnic->linearized_skbs;
1140 target_stat_values[++index] = nesvnic->tso_requests;
1141
1142 u32temp = nes_read_indexed(nesdev,
1143 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1144 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1145 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
1146
1147 u32temp = nes_read_indexed(nesdev,
1148 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1149 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1150
1151 u32temp = nes_read_indexed(nesdev,
1152 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1153 nesvnic->nesdev->port_rx_discards += u32temp;
1154 nesvnic->netstats.rx_dropped += u32temp;
1155
1156 u32temp = nes_read_indexed(nesdev,
1157 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1158 nesvnic->nesdev->port_tx_discards += u32temp;
1159 nesvnic->netstats.tx_dropped += u32temp;
1160
1161 u32temp = nes_read_indexed(nesdev,
1162 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1163 nesvnic->netstats.rx_dropped += u32temp;
1164 nesvnic->nesdev->mac_rx_errors += u32temp;
1165 nesvnic->nesdev->mac_rx_short_frames += u32temp;
1166
1167 u32temp = nes_read_indexed(nesdev,
1168 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1169 nesvnic->netstats.rx_dropped += u32temp;
1170 nesvnic->nesdev->mac_rx_errors += u32temp;
1171 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
1172
1173 u32temp = nes_read_indexed(nesdev,
1174 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1175 nesvnic->netstats.rx_dropped += u32temp;
1176 nesvnic->nesdev->mac_rx_errors += u32temp;
1177 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
1178
1179 u32temp = nes_read_indexed(nesdev,
1180 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1181 nesvnic->netstats.rx_dropped += u32temp;
1182 nesvnic->nesdev->mac_rx_errors += u32temp;
1183 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
1184
1185 u32temp = nes_read_indexed(nesdev,
1186 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1187 nesvnic->netstats.rx_length_errors += u32temp;
1188 nesvnic->nesdev->mac_rx_errors += u32temp;
1189
1190 u32temp = nes_read_indexed(nesdev,
1191 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1192 nesvnic->nesdev->mac_rx_errors += u32temp;
1193 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
1194 nesvnic->netstats.rx_crc_errors += u32temp;
1195
1196 u32temp = nes_read_indexed(nesdev,
1197 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
1198 nesvnic->nesdev->mac_tx_errors += u32temp;
1199 nesvnic->netstats.tx_errors += u32temp;
1200
1201 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1202 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1203 break;
1204
1205 u32temp = nes_read_indexed(nesdev,
1206 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1207 (nesvnic->qp_nic_index[nic_count]*0x200));
1208 nesvnic->netstats.rx_dropped += u32temp;
1209 nesvnic->endnode_nstat_rx_discard += u32temp;
1210
1211 u64temp = (u64)nes_read_indexed(nesdev,
1212 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1213 (nesvnic->qp_nic_index[nic_count]*0x200));
1214 u64temp += ((u64)nes_read_indexed(nesdev,
1215 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1216 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1217
1218 nesvnic->endnode_nstat_rx_octets += u64temp;
1219 nesvnic->netstats.rx_bytes += u64temp;
1220
1221 u64temp = (u64)nes_read_indexed(nesdev,
1222 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1223 (nesvnic->qp_nic_index[nic_count]*0x200));
1224 u64temp += ((u64)nes_read_indexed(nesdev,
1225 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1226 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1227
1228 nesvnic->endnode_nstat_rx_frames += u64temp;
1229 nesvnic->netstats.rx_packets += u64temp;
1230
1231 u64temp = (u64)nes_read_indexed(nesdev,
1232 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1233 (nesvnic->qp_nic_index[nic_count]*0x200));
1234 u64temp += ((u64)nes_read_indexed(nesdev,
1235 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1236 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1237
1238 nesvnic->endnode_nstat_tx_octets += u64temp;
1239 nesvnic->netstats.tx_bytes += u64temp;
1240
1241 u64temp = (u64)nes_read_indexed(nesdev,
1242 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1243 (nesvnic->qp_nic_index[nic_count]*0x200));
1244 u64temp += ((u64)nes_read_indexed(nesdev,
1245 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1246 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1247
1248 nesvnic->endnode_nstat_tx_frames += u64temp;
1249 nesvnic->netstats.tx_packets += u64temp;
1250
1251 u32temp = nes_read_indexed(nesdev,
1252 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1253 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1254 }
1255
1256 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1257 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1258 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1259 target_stat_values[++index] = nesvnic->sq_full;
1260 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1261 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1262 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1263 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1264 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
1265 target_stat_values[++index] = nesvnic->netstats.rx_length_errors;
1266 target_stat_values[++index] = nesvnic->nesdev->mac_rx_crc_errors;
1267 target_stat_values[++index] = nesvnic->nesdev->port_rx_discards;
1268 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1269 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1270 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1271 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1272 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
1273 target_stat_values[++index] = nesvnic->nesdev->mac_tx_errors;
1274 target_stat_values[++index] = mh_detected;
1275 target_stat_values[++index] = mh_pauses_sent;
1276 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1277 target_stat_values[++index] = atomic_read(&cm_connects);
1278 target_stat_values[++index] = atomic_read(&cm_accepts);
1279 target_stat_values[++index] = atomic_read(&cm_disconnects);
1280 target_stat_values[++index] = atomic_read(&cm_connecteds);
1281 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1282 target_stat_values[++index] = atomic_read(&cm_rejects);
1283 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1284 target_stat_values[++index] = atomic_read(&qps_created);
1285 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1286 target_stat_values[++index] = atomic_read(&qps_destroyed);
1287 target_stat_values[++index] = atomic_read(&cm_closes);
1288 target_stat_values[++index] = cm_packets_sent;
1289 target_stat_values[++index] = cm_packets_bounced;
1290 target_stat_values[++index] = cm_packets_created;
1291 target_stat_values[++index] = cm_packets_received;
1292 target_stat_values[++index] = cm_packets_dropped;
1293 target_stat_values[++index] = cm_packets_retrans;
1294 target_stat_values[++index] = atomic_read(&cm_listens_created);
1295 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
1296 target_stat_values[++index] = cm_backlog_drops;
1297 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1298 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1299 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1300 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1301 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
1302 target_stat_values[++index] = nesadapter->free_4kpbl;
1303 target_stat_values[++index] = nesadapter->free_256pbl;
1304 target_stat_values[++index] = int_mod_timer_init;
1305 target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
1306 target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
1307 target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
1308 }
1309
1310 /**
1311 * nes_netdev_get_drvinfo
1312 */
1313 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1314 struct ethtool_drvinfo *drvinfo)
1315 {
1316 struct nes_vnic *nesvnic = netdev_priv(netdev);
1317 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
1318
1319 strcpy(drvinfo->driver, DRV_NAME);
1320 strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
1321 sprintf(drvinfo->fw_version, "%u.%u", nesadapter->firmware_version>>16,
1322 nesadapter->firmware_version & 0x000000ff);
1323 strcpy(drvinfo->version, DRV_VERSION);
1324 drvinfo->testinfo_len = 0;
1325 drvinfo->eedump_len = 0;
1326 drvinfo->regdump_len = 0;
1327 }
1328
1329
1330 /**
1331 * nes_netdev_set_coalesce
1332 */
1333 static int nes_netdev_set_coalesce(struct net_device *netdev,
1334 struct ethtool_coalesce *et_coalesce)
1335 {
1336 struct nes_vnic *nesvnic = netdev_priv(netdev);
1337 struct nes_device *nesdev = nesvnic->nesdev;
1338 struct nes_adapter *nesadapter = nesdev->nesadapter;
1339 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1340 unsigned long flags;
1341
1342 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1343 if (et_coalesce->rx_max_coalesced_frames_low) {
1344 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1345 }
1346 if (et_coalesce->rx_max_coalesced_frames_irq) {
1347 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1348 }
1349 if (et_coalesce->rx_max_coalesced_frames_high) {
1350 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1351 }
1352 if (et_coalesce->rx_coalesce_usecs_low) {
1353 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1354 }
1355 if (et_coalesce->rx_coalesce_usecs_high) {
1356 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1357 }
1358 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1359
1360 /* using this to drive total interrupt moderation */
1361 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1362 if (et_coalesce->use_adaptive_rx_coalesce) {
1363 nesadapter->et_use_adaptive_rx_coalesce = 1;
1364 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1365 nesadapter->et_rx_coalesce_usecs_irq = 0;
1366 if (et_coalesce->pkt_rate_low) {
1367 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1368 }
1369 } else {
1370 nesadapter->et_use_adaptive_rx_coalesce = 0;
1371 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1372 if (nesadapter->et_rx_coalesce_usecs_irq) {
1373 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1374 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1375 }
1376 }
1377 return 0;
1378 }
1379
1380
1381 /**
1382 * nes_netdev_get_coalesce
1383 */
1384 static int nes_netdev_get_coalesce(struct net_device *netdev,
1385 struct ethtool_coalesce *et_coalesce)
1386 {
1387 struct nes_vnic *nesvnic = netdev_priv(netdev);
1388 struct nes_device *nesdev = nesvnic->nesdev;
1389 struct nes_adapter *nesadapter = nesdev->nesadapter;
1390 struct ethtool_coalesce temp_et_coalesce;
1391 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1392 unsigned long flags;
1393
1394 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1395 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1396 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1397 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1398 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1399 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1400 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1401 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
1402 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1403 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1404 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1405 if (nesadapter->et_use_adaptive_rx_coalesce) {
1406 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1407 }
1408 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1409 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1410 return 0;
1411 }
1412
1413
1414 /**
1415 * nes_netdev_get_pauseparam
1416 */
1417 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1418 struct ethtool_pauseparam *et_pauseparam)
1419 {
1420 struct nes_vnic *nesvnic = netdev_priv(netdev);
1421
1422 et_pauseparam->autoneg = 0;
1423 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1424 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1425 }
1426
1427
1428 /**
1429 * nes_netdev_set_pauseparam
1430 */
1431 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1432 struct ethtool_pauseparam *et_pauseparam)
1433 {
1434 struct nes_vnic *nesvnic = netdev_priv(netdev);
1435 struct nes_device *nesdev = nesvnic->nesdev;
1436 u32 u32temp;
1437
1438 if (et_pauseparam->autoneg) {
1439 /* TODO: should return unsupported */
1440 return 0;
1441 }
1442 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1443 u32temp = nes_read_indexed(nesdev,
1444 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1445 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1446 nes_write_indexed(nesdev,
1447 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
1448 nesdev->disable_tx_flow_control = 0;
1449 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1450 u32temp = nes_read_indexed(nesdev,
1451 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1452 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1453 nes_write_indexed(nesdev,
1454 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200), u32temp);
1455 nesdev->disable_tx_flow_control = 1;
1456 }
1457 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1458 u32temp = nes_read_indexed(nesdev,
1459 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1460 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1461 nes_write_indexed(nesdev,
1462 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1463 nesdev->disable_rx_flow_control = 0;
1464 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1465 u32temp = nes_read_indexed(nesdev,
1466 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1467 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1468 nes_write_indexed(nesdev,
1469 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1470 nesdev->disable_rx_flow_control = 1;
1471 }
1472
1473 return 0;
1474 }
1475
1476
1477 /**
1478 * nes_netdev_get_settings
1479 */
1480 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1481 {
1482 struct nes_vnic *nesvnic = netdev_priv(netdev);
1483 struct nes_device *nesdev = nesvnic->nesdev;
1484 struct nes_adapter *nesadapter = nesdev->nesadapter;
1485 u32 mac_index = nesdev->mac_index;
1486 u8 phy_type = nesadapter->phy_type[mac_index];
1487 u8 phy_index = nesadapter->phy_index[mac_index];
1488 u16 phy_data;
1489
1490 et_cmd->duplex = DUPLEX_FULL;
1491 et_cmd->port = PORT_MII;
1492 et_cmd->maxtxpkt = 511;
1493 et_cmd->maxrxpkt = 511;
1494
1495 if (nesadapter->OneG_Mode) {
1496 ethtool_cmd_speed_set(et_cmd, SPEED_1000);
1497 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
1498 et_cmd->supported = SUPPORTED_1000baseT_Full;
1499 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1500 et_cmd->autoneg = AUTONEG_DISABLE;
1501 et_cmd->transceiver = XCVR_INTERNAL;
1502 et_cmd->phy_address = mac_index;
1503 } else {
1504 unsigned long flags;
1505 et_cmd->supported = SUPPORTED_1000baseT_Full
1506 | SUPPORTED_Autoneg;
1507 et_cmd->advertising = ADVERTISED_1000baseT_Full
1508 | ADVERTISED_Autoneg;
1509 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1510 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1511 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1512 if (phy_data & 0x1000)
1513 et_cmd->autoneg = AUTONEG_ENABLE;
1514 else
1515 et_cmd->autoneg = AUTONEG_DISABLE;
1516 et_cmd->transceiver = XCVR_EXTERNAL;
1517 et_cmd->phy_address = phy_index;
1518 }
1519 return 0;
1520 }
1521 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1522 (phy_type == NES_PHY_TYPE_SFP_D) ||
1523 (phy_type == NES_PHY_TYPE_KR)) {
1524 et_cmd->transceiver = XCVR_EXTERNAL;
1525 et_cmd->port = PORT_FIBRE;
1526 et_cmd->supported = SUPPORTED_FIBRE;
1527 et_cmd->advertising = ADVERTISED_FIBRE;
1528 et_cmd->phy_address = phy_index;
1529 } else {
1530 et_cmd->transceiver = XCVR_INTERNAL;
1531 et_cmd->supported = SUPPORTED_10000baseT_Full;
1532 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1533 et_cmd->phy_address = mac_index;
1534 }
1535 ethtool_cmd_speed_set(et_cmd, SPEED_10000);
1536 et_cmd->autoneg = AUTONEG_DISABLE;
1537 return 0;
1538 }
1539
1540
1541 /**
1542 * nes_netdev_set_settings
1543 */
1544 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1545 {
1546 struct nes_vnic *nesvnic = netdev_priv(netdev);
1547 struct nes_device *nesdev = nesvnic->nesdev;
1548 struct nes_adapter *nesadapter = nesdev->nesadapter;
1549
1550 if ((nesadapter->OneG_Mode) &&
1551 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1552 unsigned long flags;
1553 u16 phy_data;
1554 u8 phy_index = nesadapter->phy_index[nesdev->mac_index];
1555
1556 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1557 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1558 if (et_cmd->autoneg) {
1559 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1560 phy_data |= 0x1300;
1561 } else {
1562 /* Turn off autoneg */
1563 phy_data &= ~0x1000;
1564 }
1565 nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data);
1566 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1567 }
1568
1569 return 0;
1570 }
1571
1572
1573 static const struct ethtool_ops nes_ethtool_ops = {
1574 .get_link = ethtool_op_get_link,
1575 .get_settings = nes_netdev_get_settings,
1576 .set_settings = nes_netdev_set_settings,
1577 .get_strings = nes_netdev_get_strings,
1578 .get_sset_count = nes_netdev_get_sset_count,
1579 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1580 .get_drvinfo = nes_netdev_get_drvinfo,
1581 .get_coalesce = nes_netdev_get_coalesce,
1582 .set_coalesce = nes_netdev_set_coalesce,
1583 .get_pauseparam = nes_netdev_get_pauseparam,
1584 .set_pauseparam = nes_netdev_set_pauseparam,
1585 };
1586
1587 static void nes_vlan_mode(struct net_device *netdev, struct nes_device *nesdev, u32 features)
1588 {
1589 struct nes_adapter *nesadapter = nesdev->nesadapter;
1590 u32 u32temp;
1591 unsigned long flags;
1592
1593 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1594
1595 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1596
1597 /* Enable/Disable VLAN Stripping */
1598 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1599 if (features & NETIF_F_HW_VLAN_RX)
1600 u32temp &= 0xfdffffff;
1601 else
1602 u32temp |= 0x02000000;
1603
1604 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1605 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1606 }
1607
1608 static u32 nes_fix_features(struct net_device *netdev, u32 features)
1609 {
1610 /*
1611 * Since there is no support for separate rx/tx vlan accel
1612 * enable/disable make sure tx flag is always in same state as rx.
1613 */
1614 if (features & NETIF_F_HW_VLAN_RX)
1615 features |= NETIF_F_HW_VLAN_TX;
1616 else
1617 features &= ~NETIF_F_HW_VLAN_TX;
1618
1619 return features;
1620 }
1621
1622 static int nes_set_features(struct net_device *netdev, u32 features)
1623 {
1624 struct nes_vnic *nesvnic = netdev_priv(netdev);
1625 struct nes_device *nesdev = nesvnic->nesdev;
1626 u32 changed = netdev->features ^ features;
1627
1628 if (changed & NETIF_F_HW_VLAN_RX)
1629 nes_vlan_mode(netdev, nesdev, features);
1630
1631 return 0;
1632 }
1633
1634 static const struct net_device_ops nes_netdev_ops = {
1635 .ndo_open = nes_netdev_open,
1636 .ndo_stop = nes_netdev_stop,
1637 .ndo_start_xmit = nes_netdev_start_xmit,
1638 .ndo_get_stats = nes_netdev_get_stats,
1639 .ndo_tx_timeout = nes_netdev_tx_timeout,
1640 .ndo_set_mac_address = nes_netdev_set_mac_address,
1641 .ndo_set_multicast_list = nes_netdev_set_multicast_list,
1642 .ndo_change_mtu = nes_netdev_change_mtu,
1643 .ndo_validate_addr = eth_validate_addr,
1644 .ndo_fix_features = nes_fix_features,
1645 .ndo_set_features = nes_set_features,
1646 };
1647
1648 /**
1649 * nes_netdev_init - initialize network device
1650 */
1651 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1652 void __iomem *mmio_addr)
1653 {
1654 u64 u64temp;
1655 struct nes_vnic *nesvnic;
1656 struct net_device *netdev;
1657 struct nic_qp_map *curr_qp_map;
1658 u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
1659
1660 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1661 if (!netdev) {
1662 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1663 return NULL;
1664 }
1665 nesvnic = netdev_priv(netdev);
1666
1667 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1668
1669 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1670
1671 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1672 netdev->irq = nesdev->pcidev->irq;
1673 netdev->mtu = ETH_DATA_LEN;
1674 netdev->hard_header_len = ETH_HLEN;
1675 netdev->addr_len = ETH_ALEN;
1676 netdev->type = ARPHRD_ETHER;
1677 netdev->features = NETIF_F_HIGHDMA;
1678 netdev->netdev_ops = &nes_netdev_ops;
1679 netdev->ethtool_ops = &nes_ethtool_ops;
1680 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1681 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1682 netdev->features |= NETIF_F_HW_VLAN_TX;
1683
1684 /* Fill in the port structure */
1685 nesvnic->netdev = netdev;
1686 nesvnic->nesdev = nesdev;
1687 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1688 nesvnic->netdev_index = nesdev->netdev_count;
1689 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1690 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1691
1692 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1693 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1694 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1695 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1696
1697 /* Setup the burned in MAC address */
1698 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1699 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1700 u64temp += nesvnic->nic_index;
1701 netdev->dev_addr[0] = (u8)(u64temp>>40);
1702 netdev->dev_addr[1] = (u8)(u64temp>>32);
1703 netdev->dev_addr[2] = (u8)(u64temp>>24);
1704 netdev->dev_addr[3] = (u8)(u64temp>>16);
1705 netdev->dev_addr[4] = (u8)(u64temp>>8);
1706 netdev->dev_addr[5] = (u8)u64temp;
1707 memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1708
1709 netdev->hw_features = NETIF_F_RXCSUM | NETIF_F_SG | NETIF_F_IP_CSUM |
1710 NETIF_F_HW_VLAN_RX;
1711 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV))
1712 netdev->hw_features |= NETIF_F_TSO;
1713 netdev->features |= netdev->hw_features;
1714 netdev->hw_features |= NETIF_F_LRO;
1715
1716 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1717 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1718 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1719 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1720
1721 if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1722 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1723
1724 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1725 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1726 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1727 nesvnic->qp_nic_index[2] = 0xf;
1728 nesvnic->qp_nic_index[3] = 0xf;
1729 } else {
1730 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1731 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1732 }
1733 } else {
1734 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1735 (nesvnic->nesdev->nesadapter->port_count == 1 &&
1736 nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1737 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1738 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1739 + 2;
1740 nesvnic->qp_nic_index[2] = 0xf;
1741 nesvnic->qp_nic_index[3] = 0xf;
1742 } else {
1743 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1744 nesvnic->qp_nic_index[1] = 0xf;
1745 nesvnic->qp_nic_index[2] = 0xf;
1746 nesvnic->qp_nic_index[3] = 0xf;
1747 }
1748 }
1749 nesvnic->next_qp_nic_index = 0;
1750
1751 if (nesdev->netdev_count == 0) {
1752 nesvnic->rdma_enabled = 1;
1753 } else {
1754 nesvnic->rdma_enabled = 0;
1755 }
1756 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1757 init_timer(&nesvnic->event_timer);
1758 nesvnic->event_timer.function = NULL;
1759 spin_lock_init(&nesvnic->tx_lock);
1760 spin_lock_init(&nesvnic->port_ibevent_lock);
1761 nesdev->netdev[nesdev->netdev_count] = netdev;
1762
1763 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1764 nesvnic, nesdev->mac_index);
1765 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1766
1767 if ((nesdev->netdev_count == 0) &&
1768 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1769 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
1770 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1771 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1772 u32 u32temp;
1773 u32 link_mask = 0;
1774 u32 link_val = 0;
1775 u16 temp_phy_data;
1776 u16 phy_data = 0;
1777 unsigned long flags;
1778
1779 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1780 (0x200 * (nesdev->mac_index & 1)));
1781 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
1782 u32temp |= 0x00200000;
1783 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1784 (0x200 * (nesdev->mac_index & 1)), u32temp);
1785 }
1786
1787 /* Check and set linkup here. This is for back to back */
1788 /* configuration where second port won't get link interrupt */
1789 switch (phy_type) {
1790 case NES_PHY_TYPE_PUMA_1G:
1791 if (nesdev->mac_index < 2) {
1792 link_mask = 0x01010000;
1793 link_val = 0x01010000;
1794 } else {
1795 link_mask = 0x02020000;
1796 link_val = 0x02020000;
1797 }
1798 break;
1799 case NES_PHY_TYPE_SFP_D:
1800 spin_lock_irqsave(&nesdev->nesadapter->phy_lock, flags);
1801 nes_read_10G_phy_reg(nesdev,
1802 nesdev->nesadapter->phy_index[nesdev->mac_index],
1803 1, 0x9003);
1804 temp_phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1805 nes_read_10G_phy_reg(nesdev,
1806 nesdev->nesadapter->phy_index[nesdev->mac_index],
1807 3, 0x0021);
1808 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 phy_data = (u16)nes_read_indexed(nesdev, NES_IDX_MAC_MDIO_CONTROL);
1813 spin_unlock_irqrestore(&nesdev->nesadapter->phy_lock, flags);
1814 phy_data = (!temp_phy_data && (phy_data == 0x8000)) ? 0x4 : 0x0;
1815 break;
1816 default:
1817 link_mask = 0x0f1f0000;
1818 link_val = 0x0f0f0000;
1819 break;
1820 }
1821
1822 u32temp = nes_read_indexed(nesdev,
1823 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1824 (0x200 * (nesdev->mac_index & 1)));
1825
1826 if (phy_type == NES_PHY_TYPE_SFP_D) {
1827 if (phy_data & 0x0004)
1828 nesvnic->linkup = 1;
1829 } else {
1830 if ((u32temp & link_mask) == link_val)
1831 nesvnic->linkup = 1;
1832 }
1833
1834 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1835 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1836 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1837 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1838
1839 nes_init_phy(nesdev);
1840 }
1841
1842 nes_vlan_mode(netdev, nesdev, netdev->features);
1843
1844 return netdev;
1845 }
1846
1847
1848 /**
1849 * nes_netdev_destroy - destroy network device structure
1850 */
1851 void nes_netdev_destroy(struct net_device *netdev)
1852 {
1853 struct nes_vnic *nesvnic = netdev_priv(netdev);
1854
1855 /* make sure 'stop' method is called by Linux stack */
1856 /* nes_netdev_stop(netdev); */
1857
1858 list_del(&nesvnic->list);
1859
1860 if (nesvnic->of_device_registered) {
1861 nes_destroy_ofa_device(nesvnic->nesibdev);
1862 }
1863
1864 free_netdev(netdev);
1865 }
1866
1867
1868 /**
1869 * nes_nic_cm_xmit -- CM calls this to send out pkts
1870 */
1871 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1872 {
1873 int ret;
1874
1875 skb->dev = netdev;
1876 ret = dev_queue_xmit(skb);
1877 if (ret) {
1878 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1879 }
1880
1881 return ret;
1882 }
Linux 2.6 libata-dev (mirror)