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