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