projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'fb' into devel
[deliverable/linux.git] / drivers / infiniband / hw / nes / nes_nic.c
1 /*
2 * Copyright (c) 2006 - 2008 NetEffect, Inc. 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 <net/tcp.h>
44
45 #include <net/inet_common.h>
46 #include <linux/inet.h>
47
48 #include "nes.h"
49
50 static struct nic_qp_map nic_qp_mapping_0[] = {
51 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
52 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
53 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
54 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
55 };
56
57 static struct nic_qp_map nic_qp_mapping_1[] = {
58 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
59 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
60 };
61
62 static struct nic_qp_map nic_qp_mapping_2[] = {
63 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
64 };
65
66 static struct nic_qp_map nic_qp_mapping_3[] = {
67 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
68 };
69
70 static struct nic_qp_map nic_qp_mapping_4[] = {
71 {28,8,0,0},{32,12,0,0}
72 };
73
74 static struct nic_qp_map nic_qp_mapping_5[] = {
75 {29,9,1,0},{33,13,1,0}
76 };
77
78 static struct nic_qp_map nic_qp_mapping_6[] = {
79 {30,10,2,0},{34,14,2,0}
80 };
81
82 static struct nic_qp_map nic_qp_mapping_7[] = {
83 {31,11,3,0},{35,15,3,0}
84 };
85
86 static struct nic_qp_map *nic_qp_mapping_per_function[] = {
87 nic_qp_mapping_0, nic_qp_mapping_1, nic_qp_mapping_2, nic_qp_mapping_3,
88 nic_qp_mapping_4, nic_qp_mapping_5, nic_qp_mapping_6, nic_qp_mapping_7
89 };
90
91 static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
92 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
93 static int debug = -1;
94
95 /**
96 * nes_netdev_poll
97 */
98 static int nes_netdev_poll(struct napi_struct *napi, int budget)
99 {
100 struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi);
101 struct net_device *netdev = nesvnic->netdev;
102 struct nes_device *nesdev = nesvnic->nesdev;
103 struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq;
104
105 nesvnic->budget = budget;
106 nescq->cqes_pending = 0;
107 nescq->rx_cqes_completed = 0;
108 nescq->cqe_allocs_pending = 0;
109 nescq->rx_pkts_indicated = 0;
110
111 nes_nic_ce_handler(nesdev, nescq);
112
113 if (nescq->cqes_pending == 0) {
114 netif_rx_complete(netdev, napi);
115 /* clear out completed cqes and arm */
116 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
117 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
118 nes_read32(nesdev->regs+NES_CQE_ALLOC);
119 } else {
120 /* clear out completed cqes but don't arm */
121 nes_write32(nesdev->regs+NES_CQE_ALLOC,
122 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
123 nes_debug(NES_DBG_NETDEV, "%s: exiting with work pending\n",
124 nesvnic->netdev->name);
125 }
126 return nescq->rx_pkts_indicated;
127 }
128
129
130 /**
131 * nes_netdev_open - Activate the network interface; ifconfig
132 * ethx up.
133 */
134 static int nes_netdev_open(struct net_device *netdev)
135 {
136 u32 macaddr_low;
137 u16 macaddr_high;
138 struct nes_vnic *nesvnic = netdev_priv(netdev);
139 struct nes_device *nesdev = nesvnic->nesdev;
140 int ret;
141 int i;
142 struct nes_vnic *first_nesvnic = NULL;
143 u32 nic_active_bit;
144 u32 nic_active;
145 struct list_head *list_pos, *list_temp;
146
147 assert(nesdev != NULL);
148
149 if (nesvnic->netdev_open == 1)
150 return 0;
151
152 if (netif_msg_ifup(nesvnic))
153 printk(KERN_INFO PFX "%s: enabling interface\n", netdev->name);
154
155 ret = nes_init_nic_qp(nesdev, netdev);
156 if (ret) {
157 return ret;
158 }
159
160 netif_carrier_off(netdev);
161 netif_stop_queue(netdev);
162
163 if ((!nesvnic->of_device_registered) && (nesvnic->rdma_enabled)) {
164 nesvnic->nesibdev = nes_init_ofa_device(netdev);
165 if (nesvnic->nesibdev == NULL) {
166 printk(KERN_ERR PFX "%s: nesvnic->nesibdev alloc failed", netdev->name);
167 } else {
168 nesvnic->nesibdev->nesvnic = nesvnic;
169 ret = nes_register_ofa_device(nesvnic->nesibdev);
170 if (ret) {
171 printk(KERN_ERR PFX "%s: Unable to register RDMA device, ret = %d\n",
172 netdev->name, ret);
173 }
174 }
175 }
176 /* Set packet filters */
177 nic_active_bit = 1 << nesvnic->nic_index;
178 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
179 nic_active |= nic_active_bit;
180 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
181 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
182 nic_active |= nic_active_bit;
183 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
184 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
185 nic_active |= nic_active_bit;
186 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
187
188 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
189 macaddr_high += (u16)netdev->dev_addr[1];
190
191 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
192 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
193 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
194 macaddr_low += (u32)netdev->dev_addr[5];
195
196 /* Program the various MAC regs */
197 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
198 if (nesvnic->qp_nic_index[i] == 0xf) {
199 break;
200 }
201 nes_debug(NES_DBG_NETDEV, "i=%d, perfect filter table index= %d, PERF FILTER LOW"
202 " (Addr:%08X) = %08X, HIGH = %08X.\n",
203 i, nesvnic->qp_nic_index[i],
204 NES_IDX_PERFECT_FILTER_LOW+((nesvnic->perfect_filter_index + i) * 8),
205 macaddr_low,
206 (u32)macaddr_high | NES_MAC_ADDR_VALID |
207 ((((u32)nesvnic->nic_index) << 16)));
208 nes_write_indexed(nesdev,
209 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
210 macaddr_low);
211 nes_write_indexed(nesdev,
212 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
213 (u32)macaddr_high | NES_MAC_ADDR_VALID |
214 ((((u32)nesvnic->nic_index) << 16)));
215 }
216
217
218 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
219 nesvnic->nic_cq.cq_number);
220 nes_read32(nesdev->regs+NES_CQE_ALLOC);
221 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
222 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
223 if (first_nesvnic->netdev_open == 1)
224 break;
225 }
226 if (first_nesvnic->netdev_open == 0) {
227 nes_debug(NES_DBG_INIT, "Setting up MAC interrupt mask.\n");
228 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK + (0x200 * nesdev->mac_index),
229 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
230 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
231 first_nesvnic = nesvnic;
232 }
233 if (first_nesvnic->linkup) {
234 /* Enable network packets */
235 nesvnic->linkup = 1;
236 netif_start_queue(netdev);
237 netif_carrier_on(netdev);
238 }
239 napi_enable(&nesvnic->napi);
240 nesvnic->netdev_open = 1;
241
242 return 0;
243 }
244
245
246 /**
247 * nes_netdev_stop
248 */
249 static int nes_netdev_stop(struct net_device *netdev)
250 {
251 struct nes_vnic *nesvnic = netdev_priv(netdev);
252 struct nes_device *nesdev = nesvnic->nesdev;
253 u32 nic_active_mask;
254 u32 nic_active;
255 struct nes_vnic *first_nesvnic = NULL;
256 struct list_head *list_pos, *list_temp;
257
258 nes_debug(NES_DBG_SHUTDOWN, "nesvnic=%p, nesdev=%p, netdev=%p %s\n",
259 nesvnic, nesdev, netdev, netdev->name);
260 if (nesvnic->netdev_open == 0)
261 return 0;
262
263 if (netif_msg_ifdown(nesvnic))
264 printk(KERN_INFO PFX "%s: disabling interface\n", netdev->name);
265
266 /* Disable network packets */
267 napi_disable(&nesvnic->napi);
268 netif_stop_queue(netdev);
269 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
270 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
271 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic))
272 break;
273 }
274
275 if (first_nesvnic->netdev_open == 0)
276 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+(0x200*nesdev->mac_index), 0xffffffff);
277 else if ((first_nesvnic != nesvnic) &&
278 (PCI_FUNC(first_nesvnic->nesdev->pcidev->devfn) != PCI_FUNC(nesvnic->nesdev->pcidev->devfn))) {
279 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK + (0x200 * nesdev->mac_index), 0xffffffff);
280 nes_write_indexed(first_nesvnic->nesdev, NES_IDX_MAC_INT_MASK + (0x200 * first_nesvnic->nesdev->mac_index),
281 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
282 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
283 }
284
285 nic_active_mask = ~((u32)(1 << nesvnic->nic_index));
286 nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_HIGH+
287 (nesvnic->perfect_filter_index*8), 0);
288 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
289 nic_active &= nic_active_mask;
290 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
291 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
292 nic_active &= nic_active_mask;
293 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
294 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
295 nic_active &= nic_active_mask;
296 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
297 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
298 nic_active &= nic_active_mask;
299 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
300 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
301 nic_active &= nic_active_mask;
302 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
303
304
305 if (nesvnic->of_device_registered) {
306 nes_destroy_ofa_device(nesvnic->nesibdev);
307 nesvnic->nesibdev = NULL;
308 nesvnic->of_device_registered = 0;
309 }
310 nes_destroy_nic_qp(nesvnic);
311
312 nesvnic->netdev_open = 0;
313
314 return 0;
315 }
316
317
318 /**
319 * nes_nic_send
320 */
321 static int nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
322 {
323 struct nes_vnic *nesvnic = netdev_priv(netdev);
324 struct nes_device *nesdev = nesvnic->nesdev;
325 struct nes_hw_nic *nesnic = &nesvnic->nic;
326 struct nes_hw_nic_sq_wqe *nic_sqe;
327 struct tcphdr *tcph;
328 __le16 *wqe_fragment_length;
329 u32 wqe_misc;
330 u16 wqe_fragment_index = 1; /* first fragment (0) is used by copy buffer */
331 u16 skb_fragment_index;
332 dma_addr_t bus_address;
333
334 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
335 wqe_fragment_length = (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
336
337 /* setup the VLAN tag if present */
338 if (vlan_tx_tag_present(skb)) {
339 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
340 netdev->name, vlan_tx_tag_get(skb));
341 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
342 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
343 } else
344 wqe_misc = 0;
345
346 /* bump past the vlan tag */
347 wqe_fragment_length++;
348 /* wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
349
350 if (skb->ip_summed == CHECKSUM_PARTIAL) {
351 tcph = tcp_hdr(skb);
352 if (1) {
353 if (skb_is_gso(skb)) {
354 /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... seg size = %u\n",
355 netdev->name, skb_is_gso(skb)); */
356 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE |
357 NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
358 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
359 ((u32)tcph->doff) |
360 (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
361 } else {
362 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
363 }
364 }
365 } else { /* CHECKSUM_HW */
366 wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM | NES_NIC_SQ_WQE_COMPLETION;
367 }
368
369 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
370 skb->len);
371 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
372 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE), skb_headlen(skb)));
373 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
374 skb_headlen(skb)));
375 wqe_fragment_length[1] = 0;
376 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
377 if ((skb_shinfo(skb)->nr_frags + 1) > 4) {
378 nes_debug(NES_DBG_NIC_TX, "%s: Packet with %u fragments not sent, skb_headlen=%u\n",
379 netdev->name, skb_shinfo(skb)->nr_frags + 2, skb_headlen(skb));
380 kfree_skb(skb);
381 nesvnic->tx_sw_dropped++;
382 return NETDEV_TX_LOCKED;
383 }
384 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
385 bus_address = pci_map_single(nesdev->pcidev, skb->data + NES_FIRST_FRAG_SIZE,
386 skb_headlen(skb) - NES_FIRST_FRAG_SIZE, PCI_DMA_TODEVICE);
387 wqe_fragment_length[wqe_fragment_index++] =
388 cpu_to_le16(skb_headlen(skb) - NES_FIRST_FRAG_SIZE);
389 wqe_fragment_length[wqe_fragment_index] = 0;
390 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
391 ((u64)(bus_address)));
392 nesnic->tx_skb[nesnic->sq_head] = skb;
393 }
394
395 if (skb_headlen(skb) == skb->len) {
396 if (skb_headlen(skb) <= NES_FIRST_FRAG_SIZE) {
397 nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_2_1_IDX] = 0;
398 nesnic->tx_skb[nesnic->sq_head] = NULL;
399 dev_kfree_skb(skb);
400 }
401 } else {
402 /* Deal with Fragments */
403 nesnic->tx_skb[nesnic->sq_head] = skb;
404 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
405 skb_fragment_index++) {
406 bus_address = pci_map_page( nesdev->pcidev,
407 skb_shinfo(skb)->frags[skb_fragment_index].page,
408 skb_shinfo(skb)->frags[skb_fragment_index].page_offset,
409 skb_shinfo(skb)->frags[skb_fragment_index].size,
410 PCI_DMA_TODEVICE);
411 wqe_fragment_length[wqe_fragment_index] =
412 cpu_to_le16(skb_shinfo(skb)->frags[skb_fragment_index].size);
413 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
414 bus_address);
415 wqe_fragment_index++;
416 if (wqe_fragment_index < 5)
417 wqe_fragment_length[wqe_fragment_index] = 0;
418 }
419 }
420
421 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
422 nesnic->sq_head++;
423 nesnic->sq_head &= nesnic->sq_size - 1;
424
425 return NETDEV_TX_OK;
426 }
427
428
429 /**
430 * nes_netdev_start_xmit
431 */
432 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
433 {
434 struct nes_vnic *nesvnic = netdev_priv(netdev);
435 struct nes_device *nesdev = nesvnic->nesdev;
436 struct nes_hw_nic *nesnic = &nesvnic->nic;
437 struct nes_hw_nic_sq_wqe *nic_sqe;
438 struct tcphdr *tcph;
439 /* struct udphdr *udph; */
440 #define NES_MAX_TSO_FRAGS 18
441 /* 64K segment plus overflow on each side */
442 dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
443 dma_addr_t bus_address;
444 u32 tso_frag_index;
445 u32 tso_frag_count;
446 u32 tso_wqe_length;
447 u32 curr_tcp_seq;
448 u32 wqe_count=1;
449 u32 send_rc;
450 struct iphdr *iph;
451 unsigned long flags;
452 __le16 *wqe_fragment_length;
453 u32 nr_frags;
454 u32 original_first_length;
455 /* u64 *wqe_fragment_address; */
456 /* first fragment (0) is used by copy buffer */
457 u16 wqe_fragment_index=1;
458 u16 hoffset;
459 u16 nhoffset;
460 u16 wqes_needed;
461 u16 wqes_available;
462 u32 old_head;
463 u32 wqe_misc;
464
465 /*
466 * nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
467 * " (%u frags), tso_size=%u\n",
468 * netdev->name, skb->len, skb_headlen(skb),
469 * skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
470 */
471
472 if (!netif_carrier_ok(netdev))
473 return NETDEV_TX_OK;
474
475 if (netif_queue_stopped(netdev))
476 return NETDEV_TX_BUSY;
477
478 local_irq_save(flags);
479 if (!spin_trylock(&nesnic->sq_lock)) {
480 local_irq_restore(flags);
481 nesvnic->sq_locked++;
482 return NETDEV_TX_LOCKED;
483 }
484
485 /* Check if SQ is full */
486 if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
487 if (!netif_queue_stopped(netdev)) {
488 netif_stop_queue(netdev);
489 barrier();
490 if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
491 netif_start_queue(netdev);
492 goto sq_no_longer_full;
493 }
494 }
495 nesvnic->sq_full++;
496 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
497 return NETDEV_TX_BUSY;
498 }
499
500 sq_no_longer_full:
501 nr_frags = skb_shinfo(skb)->nr_frags;
502 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
503 nr_frags++;
504 }
505 /* Check if too many fragments */
506 if (unlikely((nr_frags > 4))) {
507 if (skb_is_gso(skb)) {
508 nesvnic->segmented_tso_requests++;
509 nesvnic->tso_requests++;
510 old_head = nesnic->sq_head;
511 /* Basically 4 fragments available per WQE with extended fragments */
512 wqes_needed = nr_frags >> 2;
513 wqes_needed += (nr_frags&3)?1:0;
514 wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
515 (nesnic->sq_size - 1);
516
517 if (unlikely(wqes_needed > wqes_available)) {
518 if (!netif_queue_stopped(netdev)) {
519 netif_stop_queue(netdev);
520 barrier();
521 wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
522 (nesnic->sq_size - 1);
523 if (wqes_needed <= wqes_available) {
524 netif_start_queue(netdev);
525 goto tso_sq_no_longer_full;
526 }
527 }
528 nesvnic->sq_full++;
529 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
530 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
531 netdev->name);
532 return NETDEV_TX_BUSY;
533 }
534 tso_sq_no_longer_full:
535 /* Map all the buffers */
536 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
537 tso_frag_count++) {
538 tso_bus_address[tso_frag_count] = pci_map_page( nesdev->pcidev,
539 skb_shinfo(skb)->frags[tso_frag_count].page,
540 skb_shinfo(skb)->frags[tso_frag_count].page_offset,
541 skb_shinfo(skb)->frags[tso_frag_count].size,
542 PCI_DMA_TODEVICE);
543 }
544
545 tso_frag_index = 0;
546 curr_tcp_seq = ntohl(tcp_hdr(skb)->seq);
547 hoffset = skb_transport_header(skb) - skb->data;
548 nhoffset = skb_network_header(skb) - skb->data;
549 original_first_length = hoffset + ((((struct tcphdr *)skb_transport_header(skb))->doff)<<2);
550
551 for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
552 tso_wqe_length = 0;
553 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
554 wqe_fragment_length =
555 (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
556 /* setup the VLAN tag if present */
557 if (vlan_tx_tag_present(skb)) {
558 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
559 netdev->name, vlan_tx_tag_get(skb) );
560 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
561 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
562 } else
563 wqe_misc = 0;
564
565 /* bump past the vlan tag */
566 wqe_fragment_length++;
567
568 /* Assumes header totally fits in allocated buffer and is in first fragment */
569 if (original_first_length > NES_FIRST_FRAG_SIZE) {
570 nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
571 original_first_length, NES_FIRST_FRAG_SIZE);
572 nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
573 " (%u frags), tso_size=%u\n",
574 netdev->name,
575 skb->len, skb_headlen(skb),
576 skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
577 }
578 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
579 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
580 original_first_length));
581 iph = (struct iphdr *)
582 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[nhoffset]);
583 tcph = (struct tcphdr *)
584 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[hoffset]);
585 if ((wqe_count+1)!=(u32)wqes_needed) {
586 tcph->fin = 0;
587 tcph->psh = 0;
588 tcph->rst = 0;
589 tcph->urg = 0;
590 }
591 if (wqe_count) {
592 tcph->syn = 0;
593 }
594 tcph->seq = htonl(curr_tcp_seq);
595 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
596 original_first_length));
597
598 wqe_fragment_index = 1;
599 if ((wqe_count==0) && (skb_headlen(skb) > original_first_length)) {
600 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
601 bus_address = pci_map_single(nesdev->pcidev, skb->data + original_first_length,
602 skb_headlen(skb) - original_first_length, PCI_DMA_TODEVICE);
603 wqe_fragment_length[wqe_fragment_index++] =
604 cpu_to_le16(skb_headlen(skb) - original_first_length);
605 wqe_fragment_length[wqe_fragment_index] = 0;
606 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
607 bus_address);
608 }
609 while (wqe_fragment_index < 5) {
610 wqe_fragment_length[wqe_fragment_index] =
611 cpu_to_le16(skb_shinfo(skb)->frags[tso_frag_index].size);
612 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
613 (u64)tso_bus_address[tso_frag_index]);
614 wqe_fragment_index++;
615 tso_wqe_length += skb_shinfo(skb)->frags[tso_frag_index++].size;
616 if (wqe_fragment_index < 5)
617 wqe_fragment_length[wqe_fragment_index] = 0;
618 if (tso_frag_index == tso_frag_count)
619 break;
620 }
621 if ((wqe_count+1) == (u32)wqes_needed) {
622 nesnic->tx_skb[nesnic->sq_head] = skb;
623 } else {
624 nesnic->tx_skb[nesnic->sq_head] = NULL;
625 }
626 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
627 if ((tso_wqe_length + original_first_length) > skb_is_gso(skb)) {
628 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
629 } else {
630 iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
631 }
632
633 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
634 wqe_misc);
635 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
636 ((u32)tcph->doff) | (((u32)hoffset) << 4));
637
638 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
639 tso_wqe_length + original_first_length);
640 curr_tcp_seq += tso_wqe_length;
641 nesnic->sq_head++;
642 nesnic->sq_head &= nesnic->sq_size-1;
643 }
644 } else {
645 nesvnic->linearized_skbs++;
646 hoffset = skb_transport_header(skb) - skb->data;
647 nhoffset = skb_network_header(skb) - skb->data;
648 skb_linearize(skb);
649 skb_set_transport_header(skb, hoffset);
650 skb_set_network_header(skb, nhoffset);
651 send_rc = nes_nic_send(skb, netdev);
652 if (send_rc != NETDEV_TX_OK) {
653 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
654 return NETDEV_TX_OK;
655 }
656 }
657 } else {
658 send_rc = nes_nic_send(skb, netdev);
659 if (send_rc != NETDEV_TX_OK) {
660 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
661 return NETDEV_TX_OK;
662 }
663 }
664
665 barrier();
666
667 if (wqe_count)
668 nes_write32(nesdev->regs+NES_WQE_ALLOC,
669 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
670
671 netdev->trans_start = jiffies;
672 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
673
674 return NETDEV_TX_OK;
675 }
676
677
678 /**
679 * nes_netdev_get_stats
680 */
681 static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
682 {
683 struct nes_vnic *nesvnic = netdev_priv(netdev);
684 struct nes_device *nesdev = nesvnic->nesdev;
685 u64 u64temp;
686 u32 u32temp;
687
688 u32temp = nes_read_indexed(nesdev,
689 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD + (nesvnic->nic_index*0x200));
690 nesvnic->netstats.rx_dropped += u32temp;
691 nesvnic->endnode_nstat_rx_discard += u32temp;
692
693 u64temp = (u64)nes_read_indexed(nesdev,
694 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO + (nesvnic->nic_index*0x200));
695 u64temp += ((u64)nes_read_indexed(nesdev,
696 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
697
698 nesvnic->endnode_nstat_rx_octets += u64temp;
699 nesvnic->netstats.rx_bytes += u64temp;
700
701 u64temp = (u64)nes_read_indexed(nesdev,
702 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO + (nesvnic->nic_index*0x200));
703 u64temp += ((u64)nes_read_indexed(nesdev,
704 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
705
706 nesvnic->endnode_nstat_rx_frames += u64temp;
707 nesvnic->netstats.rx_packets += u64temp;
708
709 u64temp = (u64)nes_read_indexed(nesdev,
710 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO + (nesvnic->nic_index*0x200));
711 u64temp += ((u64)nes_read_indexed(nesdev,
712 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
713
714 nesvnic->endnode_nstat_tx_octets += u64temp;
715 nesvnic->netstats.tx_bytes += u64temp;
716
717 u64temp = (u64)nes_read_indexed(nesdev,
718 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO + (nesvnic->nic_index*0x200));
719 u64temp += ((u64)nes_read_indexed(nesdev,
720 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
721
722 nesvnic->endnode_nstat_tx_frames += u64temp;
723 nesvnic->netstats.tx_packets += u64temp;
724
725 u32temp = nes_read_indexed(nesdev,
726 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
727 nesvnic->netstats.rx_dropped += u32temp;
728 nesvnic->nesdev->mac_rx_errors += u32temp;
729 nesvnic->nesdev->mac_rx_short_frames += u32temp;
730
731 u32temp = nes_read_indexed(nesdev,
732 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
733 nesvnic->netstats.rx_dropped += u32temp;
734 nesvnic->nesdev->mac_rx_errors += u32temp;
735 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
736
737 u32temp = nes_read_indexed(nesdev,
738 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
739 nesvnic->netstats.rx_dropped += u32temp;
740 nesvnic->nesdev->mac_rx_errors += u32temp;
741 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
742
743 u32temp = nes_read_indexed(nesdev,
744 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
745 nesvnic->netstats.rx_dropped += u32temp;
746 nesvnic->nesdev->mac_rx_errors += u32temp;
747 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
748
749 u32temp = nes_read_indexed(nesdev,
750 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
751 nesvnic->netstats.rx_length_errors += u32temp;
752 nesvnic->nesdev->mac_rx_errors += u32temp;
753
754 u32temp = nes_read_indexed(nesdev,
755 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
756 nesvnic->nesdev->mac_rx_errors += u32temp;
757 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
758 nesvnic->netstats.rx_crc_errors += u32temp;
759
760 u32temp = nes_read_indexed(nesdev,
761 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
762 nesvnic->nesdev->mac_tx_errors += u32temp;
763 nesvnic->netstats.tx_errors += u32temp;
764
765 return &nesvnic->netstats;
766 }
767
768
769 /**
770 * nes_netdev_tx_timeout
771 */
772 static void nes_netdev_tx_timeout(struct net_device *netdev)
773 {
774 struct nes_vnic *nesvnic = netdev_priv(netdev);
775
776 if (netif_msg_timer(nesvnic))
777 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
778 }
779
780
781 /**
782 * nes_netdev_set_mac_address
783 */
784 static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
785 {
786 struct nes_vnic *nesvnic = netdev_priv(netdev);
787 struct nes_device *nesdev = nesvnic->nesdev;
788 struct sockaddr *mac_addr = p;
789 int i;
790 u32 macaddr_low;
791 u16 macaddr_high;
792 DECLARE_MAC_BUF(mac);
793
794 if (!is_valid_ether_addr(mac_addr->sa_data))
795 return -EADDRNOTAVAIL;
796
797 memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
798 printk(PFX "%s: Address length = %d, Address = %s\n",
799 __func__, netdev->addr_len, print_mac(mac, mac_addr->sa_data));
800 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
801 macaddr_high += (u16)netdev->dev_addr[1];
802 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
803 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
804 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
805 macaddr_low += (u32)netdev->dev_addr[5];
806
807 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
808 if (nesvnic->qp_nic_index[i] == 0xf) {
809 break;
810 }
811 nes_write_indexed(nesdev,
812 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
813 macaddr_low);
814 nes_write_indexed(nesdev,
815 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
816 (u32)macaddr_high | NES_MAC_ADDR_VALID |
817 ((((u32)nesvnic->nic_index) << 16)));
818 }
819 return 0;
820 }
821
822
823 /**
824 * nes_netdev_set_multicast_list
825 */
826 static void nes_netdev_set_multicast_list(struct net_device *netdev)
827 {
828 struct nes_vnic *nesvnic = netdev_priv(netdev);
829 struct nes_device *nesdev = nesvnic->nesdev;
830 struct dev_mc_list *multicast_addr;
831 u32 nic_active_bit;
832 u32 nic_active;
833 u32 perfect_filter_register_address;
834 u32 macaddr_low;
835 u16 macaddr_high;
836 u8 mc_all_on = 0;
837 u8 mc_index;
838 int mc_nic_index = -1;
839
840 nic_active_bit = 1 << nesvnic->nic_index;
841
842 if (netdev->flags & IFF_PROMISC) {
843 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
844 nic_active |= nic_active_bit;
845 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
846 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
847 nic_active |= nic_active_bit;
848 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
849 mc_all_on = 1;
850 } else if ((netdev->flags & IFF_ALLMULTI) || (netdev->mc_count > NES_MULTICAST_PF_MAX) ||
851 (nesvnic->nic_index > 3)) {
852 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
853 nic_active |= nic_active_bit;
854 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
855 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
856 nic_active &= ~nic_active_bit;
857 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
858 mc_all_on = 1;
859 } else {
860 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
861 nic_active &= ~nic_active_bit;
862 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
863 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
864 nic_active &= ~nic_active_bit;
865 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
866 }
867
868 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscous = %d, All Multicast = %d.\n",
869 netdev->mc_count, (netdev->flags & IFF_PROMISC)?1:0,
870 (netdev->flags & IFF_ALLMULTI)?1:0);
871 if (!mc_all_on) {
872 multicast_addr = netdev->mc_list;
873 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW + 0x80;
874 perfect_filter_register_address += nesvnic->nic_index*0x40;
875 for (mc_index=0; mc_index < NES_MULTICAST_PF_MAX; mc_index++) {
876 while (multicast_addr && nesvnic->mcrq_mcast_filter && ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic, multicast_addr->dmi_addr)) == 0))
877 multicast_addr = multicast_addr->next;
878 if (mc_nic_index < 0)
879 mc_nic_index = nesvnic->nic_index;
880 if (multicast_addr) {
881 DECLARE_MAC_BUF(mac);
882 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %s to register 0x%04X nic_idx=%d\n",
883 print_mac(mac, multicast_addr->dmi_addr),
884 perfect_filter_register_address+(mc_index * 8),
885 mc_nic_index);
886 macaddr_high = ((u16)multicast_addr->dmi_addr[0]) << 8;
887 macaddr_high += (u16)multicast_addr->dmi_addr[1];
888 macaddr_low = ((u32)multicast_addr->dmi_addr[2]) << 24;
889 macaddr_low += ((u32)multicast_addr->dmi_addr[3]) << 16;
890 macaddr_low += ((u32)multicast_addr->dmi_addr[4]) << 8;
891 macaddr_low += (u32)multicast_addr->dmi_addr[5];
892 nes_write_indexed(nesdev,
893 perfect_filter_register_address+(mc_index * 8),
894 macaddr_low);
895 nes_write_indexed(nesdev,
896 perfect_filter_register_address+4+(mc_index * 8),
897 (u32)macaddr_high | NES_MAC_ADDR_VALID |
898 ((((u32)(1<<mc_nic_index)) << 16)));
899 multicast_addr = multicast_addr->next;
900 } else {
901 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
902 perfect_filter_register_address+(mc_index * 8));
903 nes_write_indexed(nesdev,
904 perfect_filter_register_address+4+(mc_index * 8),
905 0);
906 }
907 }
908 }
909 }
910
911
912 /**
913 * nes_netdev_change_mtu
914 */
915 static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
916 {
917 struct nes_vnic *nesvnic = netdev_priv(netdev);
918 struct nes_device *nesdev = nesvnic->nesdev;
919 int ret = 0;
920 u8 jumbomode = 0;
921
922 if ((new_mtu < ETH_ZLEN) || (new_mtu > max_mtu))
923 return -EINVAL;
924
925 netdev->mtu = new_mtu;
926 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
927
928 if (netdev->mtu > 1500) {
929 jumbomode=1;
930 }
931 nes_nic_init_timer_defaults(nesdev, jumbomode);
932
933 if (netif_running(netdev)) {
934 nes_netdev_stop(netdev);
935 nes_netdev_open(netdev);
936 }
937
938 return ret;
939 }
940
941 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
942 "Link Change Interrupts",
943 "Linearized SKBs",
944 "T/GSO Requests",
945 "Pause Frames Sent",
946 "Pause Frames Received",
947 "Internal Routing Errors",
948 "SQ SW Dropped SKBs",
949 "SQ Locked",
950 "SQ Full",
951 "Segmented TSO Requests",
952 "Rx Symbol Errors",
953 "Rx Jabber Errors",
954 "Rx Oversized Frames",
955 "Rx Short Frames",
956 "Endnode Rx Discards",
957 "Endnode Rx Octets",
958 "Endnode Rx Frames",
959 "Endnode Tx Octets",
960 "Endnode Tx Frames",
961 "mh detected",
962 "mh pauses",
963 "Retransmission Count",
964 "CM Connects",
965 "CM Accepts",
966 "Disconnects",
967 "Connected Events",
968 "Connect Requests",
969 "CM Rejects",
970 "ModifyQP Timeouts",
971 "CreateQPs",
972 "SW DestroyQPs",
973 "DestroyQPs",
974 "CM Closes",
975 "CM Packets Sent",
976 "CM Packets Bounced",
977 "CM Packets Created",
978 "CM Packets Rcvd",
979 "CM Packets Dropped",
980 "CM Packets Retrans",
981 "CM Listens Created",
982 "CM Listens Destroyed",
983 "CM Backlog Drops",
984 "CM Loopbacks",
985 "CM Nodes Created",
986 "CM Nodes Destroyed",
987 "CM Accel Drops",
988 "CM Resets Received",
989 "Timer Inits",
990 "CQ Depth 1",
991 "CQ Depth 4",
992 "CQ Depth 16",
993 "CQ Depth 24",
994 "CQ Depth 32",
995 "CQ Depth 128",
996 "CQ Depth 256",
997 "LRO aggregated",
998 "LRO flushed",
999 "LRO no_desc",
1000 };
1001
1002 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1003
1004 /**
1005 * nes_netdev_get_rx_csum
1006 */
1007 static u32 nes_netdev_get_rx_csum (struct net_device *netdev)
1008 {
1009 struct nes_vnic *nesvnic = netdev_priv(netdev);
1010
1011 if (nesvnic->rx_checksum_disabled)
1012 return 0;
1013 else
1014 return 1;
1015 }
1016
1017
1018 /**
1019 * nes_netdev_set_rc_csum
1020 */
1021 static int nes_netdev_set_rx_csum(struct net_device *netdev, u32 enable)
1022 {
1023 struct nes_vnic *nesvnic = netdev_priv(netdev);
1024
1025 if (enable)
1026 nesvnic->rx_checksum_disabled = 0;
1027 else
1028 nesvnic->rx_checksum_disabled = 1;
1029 return 0;
1030 }
1031
1032
1033 /**
1034 * nes_netdev_get_stats_count
1035 */
1036 static int nes_netdev_get_stats_count(struct net_device *netdev)
1037 {
1038 return NES_ETHTOOL_STAT_COUNT;
1039 }
1040
1041
1042 /**
1043 * nes_netdev_get_strings
1044 */
1045 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1046 u8 *ethtool_strings)
1047 {
1048 if (stringset == ETH_SS_STATS)
1049 memcpy(ethtool_strings,
1050 &nes_ethtool_stringset,
1051 sizeof(nes_ethtool_stringset));
1052 }
1053
1054
1055 /**
1056 * nes_netdev_get_ethtool_stats
1057 */
1058 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1059 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1060 {
1061 u64 u64temp;
1062 struct nes_vnic *nesvnic = netdev_priv(netdev);
1063 struct nes_device *nesdev = nesvnic->nesdev;
1064 u32 nic_count;
1065 u32 u32temp;
1066
1067 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1068 target_stat_values[0] = nesvnic->nesdev->link_status_interrupts;
1069 target_stat_values[1] = nesvnic->linearized_skbs;
1070 target_stat_values[2] = nesvnic->tso_requests;
1071
1072 u32temp = nes_read_indexed(nesdev,
1073 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1074 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1075 target_stat_values[3] = nesvnic->nesdev->mac_pause_frames_sent;
1076
1077 u32temp = nes_read_indexed(nesdev,
1078 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1079 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1080
1081 u32temp = nes_read_indexed(nesdev,
1082 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1083 nesvnic->nesdev->port_rx_discards += u32temp;
1084 nesvnic->netstats.rx_dropped += u32temp;
1085
1086 u32temp = nes_read_indexed(nesdev,
1087 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1088 nesvnic->nesdev->port_tx_discards += u32temp;
1089 nesvnic->netstats.tx_dropped += u32temp;
1090
1091 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1092 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1093 break;
1094
1095 u32temp = nes_read_indexed(nesdev,
1096 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1097 (nesvnic->qp_nic_index[nic_count]*0x200));
1098 nesvnic->netstats.rx_dropped += u32temp;
1099 nesvnic->endnode_nstat_rx_discard += u32temp;
1100
1101 u64temp = (u64)nes_read_indexed(nesdev,
1102 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1103 (nesvnic->qp_nic_index[nic_count]*0x200));
1104 u64temp += ((u64)nes_read_indexed(nesdev,
1105 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1106 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1107
1108 nesvnic->endnode_nstat_rx_octets += u64temp;
1109 nesvnic->netstats.rx_bytes += u64temp;
1110
1111 u64temp = (u64)nes_read_indexed(nesdev,
1112 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1113 (nesvnic->qp_nic_index[nic_count]*0x200));
1114 u64temp += ((u64)nes_read_indexed(nesdev,
1115 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1116 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1117
1118 nesvnic->endnode_nstat_rx_frames += u64temp;
1119 nesvnic->netstats.rx_packets += u64temp;
1120
1121 u64temp = (u64)nes_read_indexed(nesdev,
1122 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1123 (nesvnic->qp_nic_index[nic_count]*0x200));
1124 u64temp += ((u64)nes_read_indexed(nesdev,
1125 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1126 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1127
1128 nesvnic->endnode_nstat_tx_octets += u64temp;
1129 nesvnic->netstats.tx_bytes += u64temp;
1130
1131 u64temp = (u64)nes_read_indexed(nesdev,
1132 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1133 (nesvnic->qp_nic_index[nic_count]*0x200));
1134 u64temp += ((u64)nes_read_indexed(nesdev,
1135 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1136 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1137
1138 nesvnic->endnode_nstat_tx_frames += u64temp;
1139 nesvnic->netstats.tx_packets += u64temp;
1140
1141 u32temp = nes_read_indexed(nesdev,
1142 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1143 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1144 }
1145
1146 target_stat_values[4] = nesvnic->nesdev->mac_pause_frames_received;
1147 target_stat_values[5] = nesdev->nesadapter->nic_rx_eth_route_err;
1148 target_stat_values[6] = nesvnic->tx_sw_dropped;
1149 target_stat_values[7] = nesvnic->sq_locked;
1150 target_stat_values[8] = nesvnic->sq_full;
1151 target_stat_values[9] = nesvnic->segmented_tso_requests;
1152 target_stat_values[10] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1153 target_stat_values[11] = nesvnic->nesdev->mac_rx_jabber_frames;
1154 target_stat_values[12] = nesvnic->nesdev->mac_rx_oversized_frames;
1155 target_stat_values[13] = nesvnic->nesdev->mac_rx_short_frames;
1156 target_stat_values[14] = nesvnic->endnode_nstat_rx_discard;
1157 target_stat_values[15] = nesvnic->endnode_nstat_rx_octets;
1158 target_stat_values[16] = nesvnic->endnode_nstat_rx_frames;
1159 target_stat_values[17] = nesvnic->endnode_nstat_tx_octets;
1160 target_stat_values[18] = nesvnic->endnode_nstat_tx_frames;
1161 target_stat_values[19] = mh_detected;
1162 target_stat_values[20] = mh_pauses_sent;
1163 target_stat_values[21] = nesvnic->endnode_ipv4_tcp_retransmits;
1164 target_stat_values[22] = atomic_read(&cm_connects);
1165 target_stat_values[23] = atomic_read(&cm_accepts);
1166 target_stat_values[24] = atomic_read(&cm_disconnects);
1167 target_stat_values[25] = atomic_read(&cm_connecteds);
1168 target_stat_values[26] = atomic_read(&cm_connect_reqs);
1169 target_stat_values[27] = atomic_read(&cm_rejects);
1170 target_stat_values[28] = atomic_read(&mod_qp_timouts);
1171 target_stat_values[29] = atomic_read(&qps_created);
1172 target_stat_values[30] = atomic_read(&sw_qps_destroyed);
1173 target_stat_values[31] = atomic_read(&qps_destroyed);
1174 target_stat_values[32] = atomic_read(&cm_closes);
1175 target_stat_values[33] = cm_packets_sent;
1176 target_stat_values[34] = cm_packets_bounced;
1177 target_stat_values[35] = cm_packets_created;
1178 target_stat_values[36] = cm_packets_received;
1179 target_stat_values[37] = cm_packets_dropped;
1180 target_stat_values[38] = cm_packets_retrans;
1181 target_stat_values[39] = cm_listens_created;
1182 target_stat_values[40] = cm_listens_destroyed;
1183 target_stat_values[41] = cm_backlog_drops;
1184 target_stat_values[42] = atomic_read(&cm_loopbacks);
1185 target_stat_values[43] = atomic_read(&cm_nodes_created);
1186 target_stat_values[44] = atomic_read(&cm_nodes_destroyed);
1187 target_stat_values[45] = atomic_read(&cm_accel_dropped_pkts);
1188 target_stat_values[46] = atomic_read(&cm_resets_recvd);
1189 target_stat_values[47] = int_mod_timer_init;
1190 target_stat_values[48] = int_mod_cq_depth_1;
1191 target_stat_values[49] = int_mod_cq_depth_4;
1192 target_stat_values[50] = int_mod_cq_depth_16;
1193 target_stat_values[51] = int_mod_cq_depth_24;
1194 target_stat_values[52] = int_mod_cq_depth_32;
1195 target_stat_values[53] = int_mod_cq_depth_128;
1196 target_stat_values[54] = int_mod_cq_depth_256;
1197 target_stat_values[55] = nesvnic->lro_mgr.stats.aggregated;
1198 target_stat_values[56] = nesvnic->lro_mgr.stats.flushed;
1199 target_stat_values[57] = nesvnic->lro_mgr.stats.no_desc;
1200
1201 }
1202
1203
1204 /**
1205 * nes_netdev_get_drvinfo
1206 */
1207 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1208 struct ethtool_drvinfo *drvinfo)
1209 {
1210 struct nes_vnic *nesvnic = netdev_priv(netdev);
1211
1212 strcpy(drvinfo->driver, DRV_NAME);
1213 strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
1214 strcpy(drvinfo->fw_version, "TBD");
1215 strcpy(drvinfo->version, DRV_VERSION);
1216 drvinfo->n_stats = nes_netdev_get_stats_count(netdev);
1217 drvinfo->testinfo_len = 0;
1218 drvinfo->eedump_len = 0;
1219 drvinfo->regdump_len = 0;
1220 }
1221
1222
1223 /**
1224 * nes_netdev_set_coalesce
1225 */
1226 static int nes_netdev_set_coalesce(struct net_device *netdev,
1227 struct ethtool_coalesce *et_coalesce)
1228 {
1229 struct nes_vnic *nesvnic = netdev_priv(netdev);
1230 struct nes_device *nesdev = nesvnic->nesdev;
1231 struct nes_adapter *nesadapter = nesdev->nesadapter;
1232 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1233 unsigned long flags;
1234
1235 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1236 if (et_coalesce->rx_max_coalesced_frames_low) {
1237 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1238 }
1239 if (et_coalesce->rx_max_coalesced_frames_irq) {
1240 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1241 }
1242 if (et_coalesce->rx_max_coalesced_frames_high) {
1243 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1244 }
1245 if (et_coalesce->rx_coalesce_usecs_low) {
1246 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1247 }
1248 if (et_coalesce->rx_coalesce_usecs_high) {
1249 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1250 }
1251 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1252
1253 /* using this to drive total interrupt moderation */
1254 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1255 if (et_coalesce->use_adaptive_rx_coalesce) {
1256 nesadapter->et_use_adaptive_rx_coalesce = 1;
1257 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1258 nesadapter->et_rx_coalesce_usecs_irq = 0;
1259 if (et_coalesce->pkt_rate_low) {
1260 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1261 }
1262 } else {
1263 nesadapter->et_use_adaptive_rx_coalesce = 0;
1264 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1265 if (nesadapter->et_rx_coalesce_usecs_irq) {
1266 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1267 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1268 }
1269 }
1270 return 0;
1271 }
1272
1273
1274 /**
1275 * nes_netdev_get_coalesce
1276 */
1277 static int nes_netdev_get_coalesce(struct net_device *netdev,
1278 struct ethtool_coalesce *et_coalesce)
1279 {
1280 struct nes_vnic *nesvnic = netdev_priv(netdev);
1281 struct nes_device *nesdev = nesvnic->nesdev;
1282 struct nes_adapter *nesadapter = nesdev->nesadapter;
1283 struct ethtool_coalesce temp_et_coalesce;
1284 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1285 unsigned long flags;
1286
1287 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1288 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1289 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1290 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1291 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1292 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1293 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1294 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
1295 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1296 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1297 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1298 if (nesadapter->et_use_adaptive_rx_coalesce) {
1299 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1300 }
1301 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1302 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1303 return 0;
1304 }
1305
1306
1307 /**
1308 * nes_netdev_get_pauseparam
1309 */
1310 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1311 struct ethtool_pauseparam *et_pauseparam)
1312 {
1313 struct nes_vnic *nesvnic = netdev_priv(netdev);
1314
1315 et_pauseparam->autoneg = 0;
1316 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1317 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1318 }
1319
1320
1321 /**
1322 * nes_netdev_set_pauseparam
1323 */
1324 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1325 struct ethtool_pauseparam *et_pauseparam)
1326 {
1327 struct nes_vnic *nesvnic = netdev_priv(netdev);
1328 struct nes_device *nesdev = nesvnic->nesdev;
1329 u32 u32temp;
1330
1331 if (et_pauseparam->autoneg) {
1332 /* TODO: should return unsupported */
1333 return 0;
1334 }
1335 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1336 u32temp = nes_read_indexed(nesdev,
1337 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1338 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1339 nes_write_indexed(nesdev,
1340 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1341 nesdev->disable_tx_flow_control = 0;
1342 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1343 u32temp = nes_read_indexed(nesdev,
1344 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1345 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1346 nes_write_indexed(nesdev,
1347 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1348 nesdev->disable_tx_flow_control = 1;
1349 }
1350 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1351 u32temp = nes_read_indexed(nesdev,
1352 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1353 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1354 nes_write_indexed(nesdev,
1355 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1356 nesdev->disable_rx_flow_control = 0;
1357 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1358 u32temp = nes_read_indexed(nesdev,
1359 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1360 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1361 nes_write_indexed(nesdev,
1362 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1363 nesdev->disable_rx_flow_control = 1;
1364 }
1365
1366 return 0;
1367 }
1368
1369
1370 /**
1371 * nes_netdev_get_settings
1372 */
1373 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1374 {
1375 struct nes_vnic *nesvnic = netdev_priv(netdev);
1376 struct nes_device *nesdev = nesvnic->nesdev;
1377 struct nes_adapter *nesadapter = nesdev->nesadapter;
1378 u16 phy_data;
1379
1380 et_cmd->duplex = DUPLEX_FULL;
1381 et_cmd->port = PORT_MII;
1382
1383 if (nesadapter->OneG_Mode) {
1384 et_cmd->speed = SPEED_1000;
1385 if (nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_PUMA_1G) {
1386 et_cmd->supported = SUPPORTED_1000baseT_Full;
1387 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1388 et_cmd->autoneg = AUTONEG_DISABLE;
1389 et_cmd->transceiver = XCVR_INTERNAL;
1390 et_cmd->phy_address = nesdev->mac_index;
1391 } else {
1392 et_cmd->supported = SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg;
1393 et_cmd->advertising = ADVERTISED_1000baseT_Full | ADVERTISED_Autoneg;
1394 nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index], &phy_data);
1395 if (phy_data & 0x1000)
1396 et_cmd->autoneg = AUTONEG_ENABLE;
1397 else
1398 et_cmd->autoneg = AUTONEG_DISABLE;
1399 et_cmd->transceiver = XCVR_EXTERNAL;
1400 et_cmd->phy_address = nesadapter->phy_index[nesdev->mac_index];
1401 }
1402 } else {
1403 if ((nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_IRIS) ||
1404 (nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_ARGUS)) {
1405 et_cmd->transceiver = XCVR_EXTERNAL;
1406 et_cmd->port = PORT_FIBRE;
1407 et_cmd->supported = SUPPORTED_FIBRE;
1408 et_cmd->advertising = ADVERTISED_FIBRE;
1409 et_cmd->phy_address = nesadapter->phy_index[nesdev->mac_index];
1410 } else {
1411 et_cmd->transceiver = XCVR_INTERNAL;
1412 et_cmd->supported = SUPPORTED_10000baseT_Full;
1413 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1414 et_cmd->phy_address = nesdev->mac_index;
1415 }
1416 et_cmd->speed = SPEED_10000;
1417 et_cmd->autoneg = AUTONEG_DISABLE;
1418 }
1419 et_cmd->maxtxpkt = 511;
1420 et_cmd->maxrxpkt = 511;
1421 return 0;
1422 }
1423
1424
1425 /**
1426 * nes_netdev_set_settings
1427 */
1428 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1429 {
1430 struct nes_vnic *nesvnic = netdev_priv(netdev);
1431 struct nes_device *nesdev = nesvnic->nesdev;
1432 struct nes_adapter *nesadapter = nesdev->nesadapter;
1433 u16 phy_data;
1434
1435 if ((nesadapter->OneG_Mode) &&
1436 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1437 nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1438 &phy_data);
1439 if (et_cmd->autoneg) {
1440 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1441 phy_data |= 0x1300;
1442 } else {
1443 /* Turn off autoneg */
1444 phy_data &= ~0x1000;
1445 }
1446 nes_write_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1447 phy_data);
1448 }
1449
1450 return 0;
1451 }
1452
1453
1454 static struct ethtool_ops nes_ethtool_ops = {
1455 .get_link = ethtool_op_get_link,
1456 .get_settings = nes_netdev_get_settings,
1457 .set_settings = nes_netdev_set_settings,
1458 .get_tx_csum = ethtool_op_get_tx_csum,
1459 .get_rx_csum = nes_netdev_get_rx_csum,
1460 .get_sg = ethtool_op_get_sg,
1461 .get_strings = nes_netdev_get_strings,
1462 .get_stats_count = nes_netdev_get_stats_count,
1463 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1464 .get_drvinfo = nes_netdev_get_drvinfo,
1465 .get_coalesce = nes_netdev_get_coalesce,
1466 .set_coalesce = nes_netdev_set_coalesce,
1467 .get_pauseparam = nes_netdev_get_pauseparam,
1468 .set_pauseparam = nes_netdev_set_pauseparam,
1469 .set_tx_csum = ethtool_op_set_tx_csum,
1470 .set_rx_csum = nes_netdev_set_rx_csum,
1471 .set_sg = ethtool_op_set_sg,
1472 .get_tso = ethtool_op_get_tso,
1473 .set_tso = ethtool_op_set_tso,
1474 .get_flags = ethtool_op_get_flags,
1475 .set_flags = ethtool_op_set_flags,
1476 };
1477
1478
1479 static void nes_netdev_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
1480 {
1481 struct nes_vnic *nesvnic = netdev_priv(netdev);
1482 struct nes_device *nesdev = nesvnic->nesdev;
1483 struct nes_adapter *nesadapter = nesdev->nesadapter;
1484 u32 u32temp;
1485 unsigned long flags;
1486
1487 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1488 nesvnic->vlan_grp = grp;
1489
1490 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1491
1492 /* Enable/Disable VLAN Stripping */
1493 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1494 if (grp)
1495 u32temp &= 0xfdffffff;
1496 else
1497 u32temp |= 0x02000000;
1498
1499 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1500 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1501 }
1502
1503
1504 /**
1505 * nes_netdev_init - initialize network device
1506 */
1507 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1508 void __iomem *mmio_addr)
1509 {
1510 u64 u64temp;
1511 struct nes_vnic *nesvnic = NULL;
1512 struct net_device *netdev;
1513 struct nic_qp_map *curr_qp_map;
1514 u32 u32temp;
1515 u16 phy_data;
1516 u16 temp_phy_data;
1517
1518 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1519 if (!netdev) {
1520 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1521 return NULL;
1522 }
1523
1524 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1525
1526 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1527
1528 nesvnic = netdev_priv(netdev);
1529 memset(nesvnic, 0, sizeof(*nesvnic));
1530
1531 netdev->open = nes_netdev_open;
1532 netdev->stop = nes_netdev_stop;
1533 netdev->hard_start_xmit = nes_netdev_start_xmit;
1534 netdev->get_stats = nes_netdev_get_stats;
1535 netdev->tx_timeout = nes_netdev_tx_timeout;
1536 netdev->set_mac_address = nes_netdev_set_mac_address;
1537 netdev->set_multicast_list = nes_netdev_set_multicast_list;
1538 netdev->change_mtu = nes_netdev_change_mtu;
1539 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1540 netdev->irq = nesdev->pcidev->irq;
1541 netdev->mtu = ETH_DATA_LEN;
1542 netdev->hard_header_len = ETH_HLEN;
1543 netdev->addr_len = ETH_ALEN;
1544 netdev->type = ARPHRD_ETHER;
1545 netdev->features = NETIF_F_HIGHDMA;
1546 netdev->ethtool_ops = &nes_ethtool_ops;
1547 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1548 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1549 netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1550 netdev->vlan_rx_register = nes_netdev_vlan_rx_register;
1551 netdev->features |= NETIF_F_LLTX;
1552
1553 /* Fill in the port structure */
1554 nesvnic->netdev = netdev;
1555 nesvnic->nesdev = nesdev;
1556 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1557 nesvnic->netdev_index = nesdev->netdev_count;
1558 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1559 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1560
1561 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1562 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1563 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1564 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1565
1566 /* Setup the burned in MAC address */
1567 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1568 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1569 u64temp += nesvnic->nic_index;
1570 netdev->dev_addr[0] = (u8)(u64temp>>40);
1571 netdev->dev_addr[1] = (u8)(u64temp>>32);
1572 netdev->dev_addr[2] = (u8)(u64temp>>24);
1573 netdev->dev_addr[3] = (u8)(u64temp>>16);
1574 netdev->dev_addr[4] = (u8)(u64temp>>8);
1575 netdev->dev_addr[5] = (u8)u64temp;
1576 memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1577
1578 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV)) {
1579 netdev->features |= NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1580 netdev->features |= NETIF_F_GSO | NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1581 } else {
1582 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1583 }
1584
1585 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1586 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1587 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1588 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1589
1590 if (nesvnic->nesdev->nesadapter->port_count == 1) {
1591 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1592 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1593 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1594 nesvnic->qp_nic_index[2] = 0xf;
1595 nesvnic->qp_nic_index[3] = 0xf;
1596 } else {
1597 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1598 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1599 }
1600 } else {
1601 if (nesvnic->nesdev->nesadapter->port_count == 2) {
1602 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1603 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 2;
1604 nesvnic->qp_nic_index[2] = 0xf;
1605 nesvnic->qp_nic_index[3] = 0xf;
1606 } else {
1607 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1608 nesvnic->qp_nic_index[1] = 0xf;
1609 nesvnic->qp_nic_index[2] = 0xf;
1610 nesvnic->qp_nic_index[3] = 0xf;
1611 }
1612 }
1613 nesvnic->next_qp_nic_index = 0;
1614
1615 if (nesdev->netdev_count == 0) {
1616 nesvnic->rdma_enabled = 1;
1617 } else {
1618 nesvnic->rdma_enabled = 0;
1619 }
1620 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1621 spin_lock_init(&nesvnic->tx_lock);
1622 nesdev->netdev[nesdev->netdev_count] = netdev;
1623
1624 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1625 nesvnic, nesdev->mac_index);
1626 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1627
1628 if ((nesdev->netdev_count == 0) &&
1629 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1630 ((nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_PUMA_1G) &&
1631 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1632 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1633 /*
1634 * nes_debug(NES_DBG_INIT, "Setting up PHY interrupt mask. Using register index 0x%04X\n",
1635 * NES_IDX_PHY_PCS_CONTROL_STATUS0 + (0x200 * (nesvnic->logical_port & 1)));
1636 */
1637 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1638 (0x200 * (nesdev->mac_index & 1)));
1639 if (nesdev->nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G) {
1640 u32temp |= 0x00200000;
1641 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1642 (0x200 * (nesdev->mac_index & 1)), u32temp);
1643 }
1644
1645 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1646 (0x200 * (nesdev->mac_index & 1)));
1647
1648 if ((u32temp&0x0f1f0000) == 0x0f0f0000) {
1649 if (nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_IRIS) {
1650 nes_init_phy(nesdev);
1651 nes_read_10G_phy_reg(nesdev, nesdev->nesadapter->phy_index[nesdev->mac_index], 1, 1);
1652 temp_phy_data = (u16)nes_read_indexed(nesdev,
1653 NES_IDX_MAC_MDIO_CONTROL);
1654 u32temp = 20;
1655 do {
1656 nes_read_10G_phy_reg(nesdev, nesdev->nesadapter->phy_index[nesdev->mac_index], 1, 1);
1657 phy_data = (u16)nes_read_indexed(nesdev,
1658 NES_IDX_MAC_MDIO_CONTROL);
1659 if ((phy_data == temp_phy_data) || (!(--u32temp)))
1660 break;
1661 temp_phy_data = phy_data;
1662 } while (1);
1663 if (phy_data & 4) {
1664 nes_debug(NES_DBG_INIT, "The Link is UP!!.\n");
1665 nesvnic->linkup = 1;
1666 } else {
1667 nes_debug(NES_DBG_INIT, "The Link is DOWN!!.\n");
1668 }
1669 } else {
1670 nes_debug(NES_DBG_INIT, "The Link is UP!!.\n");
1671 nesvnic->linkup = 1;
1672 }
1673 } else if (nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_PUMA_1G) {
1674 nes_debug(NES_DBG_INIT, "mac_index=%d, logical_port=%d, u32temp=0x%04X, PCI_FUNC=%d\n",
1675 nesdev->mac_index, nesvnic->logical_port, u32temp, PCI_FUNC(nesdev->pcidev->devfn));
1676 if (((nesdev->mac_index < 2) && ((u32temp&0x01010000) == 0x01010000)) ||
1677 ((nesdev->mac_index > 1) && ((u32temp&0x02020000) == 0x02020000))) {
1678 nes_debug(NES_DBG_INIT, "The Link is UP!!.\n");
1679 nesvnic->linkup = 1;
1680 }
1681 }
1682 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1683 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1684 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1685 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1686
1687 if (nesdev->nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_IRIS)
1688 nes_init_phy(nesdev);
1689
1690 }
1691
1692 return netdev;
1693 }
1694
1695
1696 /**
1697 * nes_netdev_destroy - destroy network device structure
1698 */
1699 void nes_netdev_destroy(struct net_device *netdev)
1700 {
1701 struct nes_vnic *nesvnic = netdev_priv(netdev);
1702
1703 /* make sure 'stop' method is called by Linux stack */
1704 /* nes_netdev_stop(netdev); */
1705
1706 list_del(&nesvnic->list);
1707
1708 if (nesvnic->of_device_registered) {
1709 nes_destroy_ofa_device(nesvnic->nesibdev);
1710 }
1711
1712 free_netdev(netdev);
1713 }
1714
1715
1716 /**
1717 * nes_nic_cm_xmit -- CM calls this to send out pkts
1718 */
1719 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1720 {
1721 int ret;
1722
1723 skb->dev = netdev;
1724 ret = dev_queue_xmit(skb);
1725 if (ret) {
1726 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1727 }
1728
1729 return ret;
1730 }
Linux kernel - Deliverables
This page took 0.068779 seconds and 6 git commands to generate.