?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-next-2.6
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / infiniband / hw / nes / nes_nic.c
blobe95e8d09ff38ecc2911470cabe9d46e54108c6de
1 /*
2 * Copyright (c) 2006 - 2009 Intel Corporation. All rights reserved.
3 *
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
9 *
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
12 * conditions are met:
13 *
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer.
17 *
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and/or other materials
21 * provided with the distribution.
22 *
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30 * SOFTWARE.
31 *
32 */
33
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
38 #include <linux/ip.h>
39 #include <linux/tcp.h>
40 #include <linux/if_arp.h>
41 #include <linux/if_vlan.h>
42 #include <linux/ethtool.h>
43 #include <linux/slab.h>
44 #include <net/tcp.h>
45
46 #include <net/inet_common.h>
47 #include <linux/inet.h>
48
49 #include "nes.h"
50
51 static struct nic_qp_map nic_qp_mapping_0[] = {
52 {16,0,0,1},{24,4,0,0},{28,8,0,0},{32,12,0,0},
53 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0},
54 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
55 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
56 };
57
58 static struct nic_qp_map nic_qp_mapping_1[] = {
59 {18,1,1,1},{25,5,1,0},{29,9,1,0},{33,13,1,0},
60 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
61 };
62
63 static struct nic_qp_map nic_qp_mapping_2[] = {
64 {20,2,2,1},{26,6,2,0},{30,10,2,0},{34,14,2,0}
65 };
66
67 static struct nic_qp_map nic_qp_mapping_3[] = {
68 {22,3,3,1},{27,7,3,0},{31,11,3,0},{35,15,3,0}
69 };
70
71 static struct nic_qp_map nic_qp_mapping_4[] = {
72 {28,8,0,0},{32,12,0,0}
73 };
74
75 static struct nic_qp_map nic_qp_mapping_5[] = {
76 {29,9,1,0},{33,13,1,0}
77 };
78
79 static struct nic_qp_map nic_qp_mapping_6[] = {
80 {30,10,2,0},{34,14,2,0}
81 };
82
83 static struct nic_qp_map nic_qp_mapping_7[] = {
84 {31,11,3,0},{35,15,3,0}
85 };
86
87 static struct nic_qp_map *nic_qp_mapping_per_function[] = {
88 nic_qp_mapping_0, nic_qp_mapping_1, nic_qp_mapping_2, nic_qp_mapping_3,
89 nic_qp_mapping_4, nic_qp_mapping_5, nic_qp_mapping_6, nic_qp_mapping_7
90 };
91
92 static const u32 default_msg = NETIF_MSG_DRV | NETIF_MSG_PROBE | NETIF_MSG_LINK
93 | NETIF_MSG_IFUP | NETIF_MSG_IFDOWN;
94 static int debug = -1;
95 static int nics_per_function = 1;
96
97 /**
98 * nes_netdev_poll
99 */
100 static int nes_netdev_poll(struct napi_struct *napi, int budget)
101 {
102 struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi);
103 struct nes_device *nesdev = nesvnic->nesdev;
104 struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq;
105
106 nesvnic->budget = budget;
107 nescq->cqes_pending = 0;
108 nescq->rx_cqes_completed = 0;
109 nescq->cqe_allocs_pending = 0;
110 nescq->rx_pkts_indicated = 0;
111
112 nes_nic_ce_handler(nesdev, nescq);
113
114 if (nescq->cqes_pending == 0) {
115 napi_complete(napi);
116 /* clear out completed cqes and arm */
117 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
118 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
119 nes_read32(nesdev->regs+NES_CQE_ALLOC);
120 } else {
121 /* clear out completed cqes but don't arm */
122 nes_write32(nesdev->regs+NES_CQE_ALLOC,
123 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
124 nes_debug(NES_DBG_NETDEV, "%s: exiting with work pending\n",
125 nesvnic->netdev->name);
126 }
127 return nescq->rx_pkts_indicated;
128 }
129
130
131 /**
132 * nes_netdev_open - Activate the network interface; ifconfig
133 * ethx up.
134 */
135 static int nes_netdev_open(struct net_device *netdev)
136 {
137 u32 macaddr_low;
138 u16 macaddr_high;
139 struct nes_vnic *nesvnic = netdev_priv(netdev);
140 struct nes_device *nesdev = nesvnic->nesdev;
141 int ret;
142 int i;
143 struct nes_vnic *first_nesvnic = NULL;
144 u32 nic_active_bit;
145 u32 nic_active;
146 struct list_head *list_pos, *list_temp;
147
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] = skb;
405 }
406 } else {
407 /* Deal with Fragments */
408 nesnic->tx_skb[nesnic->sq_head] = skb;
409 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
410 skb_fragment_index++) {
411 bus_address = pci_map_page( nesdev->pcidev,
412 skb_shinfo(skb)->frags[skb_fragment_index].page,
413 skb_shinfo(skb)->frags[skb_fragment_index].page_offset,
414 skb_shinfo(skb)->frags[skb_fragment_index].size,
415 PCI_DMA_TODEVICE);
416 wqe_fragment_length[wqe_fragment_index] =
417 cpu_to_le16(skb_shinfo(skb)->frags[skb_fragment_index].size);
418 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
419 bus_address);
420 wqe_fragment_index++;
421 if (wqe_fragment_index < 5)
422 wqe_fragment_length[wqe_fragment_index] = 0;
423 }
424 }
425
426 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
427 nesnic->sq_head++;
428 nesnic->sq_head &= nesnic->sq_size - 1;
429
430 return NETDEV_TX_OK;
431 }
432
433
434 /**
435 * nes_netdev_start_xmit
436 */
437 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
438 {
439 struct nes_vnic *nesvnic = netdev_priv(netdev);
440 struct nes_device *nesdev = nesvnic->nesdev;
441 struct nes_hw_nic *nesnic = &nesvnic->nic;
442 struct nes_hw_nic_sq_wqe *nic_sqe;
443 struct tcphdr *tcph;
444 /* struct udphdr *udph; */
445 #define NES_MAX_TSO_FRAGS MAX_SKB_FRAGS
446 /* 64K segment plus overflow on each side */
447 dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
448 dma_addr_t bus_address;
449 u32 tso_frag_index;
450 u32 tso_frag_count;
451 u32 tso_wqe_length;
452 u32 curr_tcp_seq;
453 u32 wqe_count=1;
454 u32 send_rc;
455 struct iphdr *iph;
456 __le16 *wqe_fragment_length;
457 u32 nr_frags;
458 u32 original_first_length;
459 /* u64 *wqe_fragment_address; */
460 /* first fragment (0) is used by copy buffer */
461 u16 wqe_fragment_index=1;
462 u16 hoffset;
463 u16 nhoffset;
464 u16 wqes_needed;
465 u16 wqes_available;
466 u32 old_head;
467 u32 wqe_misc;
468
469 /*
470 * nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
471 * " (%u frags), tso_size=%u\n",
472 * netdev->name, skb->len, skb_headlen(skb),
473 * skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
474 */
475
476 if (!netif_carrier_ok(netdev))
477 return NETDEV_TX_OK;
478
479 if (netif_queue_stopped(netdev))
480 return NETDEV_TX_BUSY;
481
482 /* Check if SQ is full */
483 if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
484 if (!netif_queue_stopped(netdev)) {
485 netif_stop_queue(netdev);
486 barrier();
487 if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
488 netif_start_queue(netdev);
489 goto sq_no_longer_full;
490 }
491 }
492 nesvnic->sq_full++;
493 return NETDEV_TX_BUSY;
494 }
495
496 sq_no_longer_full:
497 nr_frags = skb_shinfo(skb)->nr_frags;
498 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
499 nr_frags++;
500 }
501 /* Check if too many fragments */
502 if (unlikely((nr_frags > 4))) {
503 if (skb_is_gso(skb)) {
504 nesvnic->segmented_tso_requests++;
505 nesvnic->tso_requests++;
506 old_head = nesnic->sq_head;
507 /* Basically 4 fragments available per WQE with extended fragments */
508 wqes_needed = nr_frags >> 2;
509 wqes_needed += (nr_frags&3)?1:0;
510 wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
511 (nesnic->sq_size - 1);
512
513 if (unlikely(wqes_needed > wqes_available)) {
514 if (!netif_queue_stopped(netdev)) {
515 netif_stop_queue(netdev);
516 barrier();
517 wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
518 (nesnic->sq_size - 1);
519 if (wqes_needed <= wqes_available) {
520 netif_start_queue(netdev);
521 goto tso_sq_no_longer_full;
522 }
523 }
524 nesvnic->sq_full++;
525 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
526 netdev->name);
527 return NETDEV_TX_BUSY;
528 }
529 tso_sq_no_longer_full:
530 /* Map all the buffers */
531 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
532 tso_frag_count++) {
533 tso_bus_address[tso_frag_count] = pci_map_page( nesdev->pcidev,
534 skb_shinfo(skb)->frags[tso_frag_count].page,
535 skb_shinfo(skb)->frags[tso_frag_count].page_offset,
536 skb_shinfo(skb)->frags[tso_frag_count].size,
537 PCI_DMA_TODEVICE);
538 }
539
540 tso_frag_index = 0;
541 curr_tcp_seq = ntohl(tcp_hdr(skb)->seq);
542 hoffset = skb_transport_header(skb) - skb->data;
543 nhoffset = skb_network_header(skb) - skb->data;
544 original_first_length = hoffset + ((((struct tcphdr *)skb_transport_header(skb))->doff)<<2);
545
546 for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
547 tso_wqe_length = 0;
548 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
549 wqe_fragment_length =
550 (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
551 /* setup the VLAN tag if present */
552 if (vlan_tx_tag_present(skb)) {
553 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
554 netdev->name, vlan_tx_tag_get(skb) );
555 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
556 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
557 } else
558 wqe_misc = 0;
559
560 /* bump past the vlan tag */
561 wqe_fragment_length++;
562
563 /* Assumes header totally fits in allocated buffer and is in first fragment */
564 if (original_first_length > NES_FIRST_FRAG_SIZE) {
565 nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
566 original_first_length, NES_FIRST_FRAG_SIZE);
567 nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
568 " (%u frags), tso_size=%u\n",
569 netdev->name,
570 skb->len, skb_headlen(skb),
571 skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
572 }
573 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
574 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
575 original_first_length));
576 iph = (struct iphdr *)
577 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[nhoffset]);
578 tcph = (struct tcphdr *)
579 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[hoffset]);
580 if ((wqe_count+1)!=(u32)wqes_needed) {
581 tcph->fin = 0;
582 tcph->psh = 0;
583 tcph->rst = 0;
584 tcph->urg = 0;
585 }
586 if (wqe_count) {
587 tcph->syn = 0;
588 }
589 tcph->seq = htonl(curr_tcp_seq);
590 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
591 original_first_length));
592
593 wqe_fragment_index = 1;
594 if ((wqe_count==0) && (skb_headlen(skb) > original_first_length)) {
595 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
596 bus_address = pci_map_single(nesdev->pcidev, skb->data + original_first_length,
597 skb_headlen(skb) - original_first_length, PCI_DMA_TODEVICE);
598 wqe_fragment_length[wqe_fragment_index++] =
599 cpu_to_le16(skb_headlen(skb) - original_first_length);
600 wqe_fragment_length[wqe_fragment_index] = 0;
601 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
602 bus_address);
603 tso_wqe_length += skb_headlen(skb) -
604 original_first_length;
605 }
606 while (wqe_fragment_index < 5) {
607 wqe_fragment_length[wqe_fragment_index] =
608 cpu_to_le16(skb_shinfo(skb)->frags[tso_frag_index].size);
609 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
610 (u64)tso_bus_address[tso_frag_index]);
611 wqe_fragment_index++;
612 tso_wqe_length += skb_shinfo(skb)->frags[tso_frag_index++].size;
613 if (wqe_fragment_index < 5)
614 wqe_fragment_length[wqe_fragment_index] = 0;
615 if (tso_frag_index == tso_frag_count)
616 break;
617 }
618 if ((wqe_count+1) == (u32)wqes_needed) {
619 nesnic->tx_skb[nesnic->sq_head] = skb;
620 } else {
621 nesnic->tx_skb[nesnic->sq_head] = NULL;
622 }
623 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
624 if ((tso_wqe_length + original_first_length) > skb_is_gso(skb)) {
625 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
626 } else {
627 iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
628 }
629
630 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
631 wqe_misc);
632 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
633 ((u32)tcph->doff) | (((u32)hoffset) << 4));
634
635 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
636 tso_wqe_length + original_first_length);
637 curr_tcp_seq += tso_wqe_length;
638 nesnic->sq_head++;
639 nesnic->sq_head &= nesnic->sq_size-1;
640 }
641 } else {
642 nesvnic->linearized_skbs++;
643 hoffset = skb_transport_header(skb) - skb->data;
644 nhoffset = skb_network_header(skb) - skb->data;
645 skb_linearize(skb);
646 skb_set_transport_header(skb, hoffset);
647 skb_set_network_header(skb, nhoffset);
648 send_rc = nes_nic_send(skb, netdev);
649 if (send_rc != NETDEV_TX_OK)
650 return NETDEV_TX_OK;
651 }
652 } else {
653 send_rc = nes_nic_send(skb, netdev);
654 if (send_rc != NETDEV_TX_OK)
655 return NETDEV_TX_OK;
656 }
657
658 barrier();
659
660 if (wqe_count)
661 nes_write32(nesdev->regs+NES_WQE_ALLOC,
662 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
663
664 netdev->trans_start = jiffies;
665
666 return NETDEV_TX_OK;
667 }
668
669
670 /**
671 * nes_netdev_get_stats
672 */
673 static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
674 {
675 struct nes_vnic *nesvnic = netdev_priv(netdev);
676 struct nes_device *nesdev = nesvnic->nesdev;
677 u64 u64temp;
678 u32 u32temp;
679
680 u32temp = nes_read_indexed(nesdev,
681 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD + (nesvnic->nic_index*0x200));
682 nesvnic->netstats.rx_dropped += u32temp;
683 nesvnic->endnode_nstat_rx_discard += u32temp;
684
685 u64temp = (u64)nes_read_indexed(nesdev,
686 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO + (nesvnic->nic_index*0x200));
687 u64temp += ((u64)nes_read_indexed(nesdev,
688 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
689
690 nesvnic->endnode_nstat_rx_octets += u64temp;
691 nesvnic->netstats.rx_bytes += u64temp;
692
693 u64temp = (u64)nes_read_indexed(nesdev,
694 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO + (nesvnic->nic_index*0x200));
695 u64temp += ((u64)nes_read_indexed(nesdev,
696 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
697
698 nesvnic->endnode_nstat_rx_frames += u64temp;
699 nesvnic->netstats.rx_packets += u64temp;
700
701 u64temp = (u64)nes_read_indexed(nesdev,
702 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO + (nesvnic->nic_index*0x200));
703 u64temp += ((u64)nes_read_indexed(nesdev,
704 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
705
706 nesvnic->endnode_nstat_tx_octets += u64temp;
707 nesvnic->netstats.tx_bytes += u64temp;
708
709 u64temp = (u64)nes_read_indexed(nesdev,
710 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO + (nesvnic->nic_index*0x200));
711 u64temp += ((u64)nes_read_indexed(nesdev,
712 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
713
714 nesvnic->endnode_nstat_tx_frames += u64temp;
715 nesvnic->netstats.tx_packets += u64temp;
716
717 u32temp = nes_read_indexed(nesdev,
718 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
719 nesvnic->netstats.rx_dropped += u32temp;
720 nesvnic->nesdev->mac_rx_errors += u32temp;
721 nesvnic->nesdev->mac_rx_short_frames += u32temp;
722
723 u32temp = nes_read_indexed(nesdev,
724 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
725 nesvnic->netstats.rx_dropped += u32temp;
726 nesvnic->nesdev->mac_rx_errors += u32temp;
727 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
728
729 u32temp = nes_read_indexed(nesdev,
730 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
731 nesvnic->netstats.rx_dropped += u32temp;
732 nesvnic->nesdev->mac_rx_errors += u32temp;
733 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
734
735 u32temp = nes_read_indexed(nesdev,
736 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
737 nesvnic->netstats.rx_dropped += u32temp;
738 nesvnic->nesdev->mac_rx_errors += u32temp;
739 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
740
741 u32temp = nes_read_indexed(nesdev,
742 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
743 nesvnic->netstats.rx_length_errors += u32temp;
744 nesvnic->nesdev->mac_rx_errors += u32temp;
745
746 u32temp = nes_read_indexed(nesdev,
747 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
748 nesvnic->nesdev->mac_rx_errors += u32temp;
749 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
750 nesvnic->netstats.rx_crc_errors += u32temp;
751
752 u32temp = nes_read_indexed(nesdev,
753 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
754 nesvnic->nesdev->mac_tx_errors += u32temp;
755 nesvnic->netstats.tx_errors += u32temp;
756
757 return &nesvnic->netstats;
758 }
759
760
761 /**
762 * nes_netdev_tx_timeout
763 */
764 static void nes_netdev_tx_timeout(struct net_device *netdev)
765 {
766 struct nes_vnic *nesvnic = netdev_priv(netdev);
767
768 if (netif_msg_timer(nesvnic))
769 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
770 }
771
772
773 /**
774 * nes_netdev_set_mac_address
775 */
776 static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
777 {
778 struct nes_vnic *nesvnic = netdev_priv(netdev);
779 struct nes_device *nesdev = nesvnic->nesdev;
780 struct sockaddr *mac_addr = p;
781 int i;
782 u32 macaddr_low;
783 u16 macaddr_high;
784
785 if (!is_valid_ether_addr(mac_addr->sa_data))
786 return -EADDRNOTAVAIL;
787
788 memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
789 printk(PFX "%s: Address length = %d, Address = %pM\n",
790 __func__, netdev->addr_len, mac_addr->sa_data);
791 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
792 macaddr_high += (u16)netdev->dev_addr[1];
793 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
794 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
795 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
796 macaddr_low += (u32)netdev->dev_addr[5];
797
798 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
799 if (nesvnic->qp_nic_index[i] == 0xf) {
800 break;
801 }
802 nes_write_indexed(nesdev,
803 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
804 macaddr_low);
805 nes_write_indexed(nesdev,
806 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
807 (u32)macaddr_high | NES_MAC_ADDR_VALID |
808 ((((u32)nesvnic->nic_index) << 16)));
809 }
810 return 0;
811 }
812
813
814 static void set_allmulti(struct nes_device *nesdev, u32 nic_active_bit)
815 {
816 u32 nic_active;
817
818 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
819 nic_active |= nic_active_bit;
820 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
821 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
822 nic_active &= ~nic_active_bit;
823 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
824 }
825
826 #define get_addr(addrs, index) ((addrs) + (index) * ETH_ALEN)
827
828 /**
829 * nes_netdev_set_multicast_list
830 */
831 static void nes_netdev_set_multicast_list(struct net_device *netdev)
832 {
833 struct nes_vnic *nesvnic = netdev_priv(netdev);
834 struct nes_device *nesdev = nesvnic->nesdev;
835 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
836 u32 nic_active_bit;
837 u32 nic_active;
838 u32 perfect_filter_register_address;
839 u32 macaddr_low;
840 u16 macaddr_high;
841 u8 mc_all_on = 0;
842 u8 mc_index;
843 int mc_nic_index = -1;
844 u8 pft_entries_preallocated = max(nesadapter->adapter_fcn_count *
845 nics_per_function, 4);
846 u8 max_pft_entries_avaiable = NES_PFT_SIZE - pft_entries_preallocated;
847 unsigned long flags;
848 int mc_count = netdev_mc_count(netdev);
849
850 spin_lock_irqsave(&nesadapter->resource_lock, flags);
851 nic_active_bit = 1 << nesvnic->nic_index;
852
853 if (netdev->flags & IFF_PROMISC) {
854 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
855 nic_active |= nic_active_bit;
856 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
857 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
858 nic_active |= nic_active_bit;
859 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
860 mc_all_on = 1;
861 } else if ((netdev->flags & IFF_ALLMULTI) ||
862 (nesvnic->nic_index > 3)) {
863 set_allmulti(nesdev, nic_active_bit);
864 mc_all_on = 1;
865 } else {
866 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
867 nic_active &= ~nic_active_bit;
868 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
869 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
870 nic_active &= ~nic_active_bit;
871 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
872 }
873
874 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscous = %d, All Multicast = %d.\n",
875 mc_count, !!(netdev->flags & IFF_PROMISC),
876 !!(netdev->flags & IFF_ALLMULTI));
877 if (!mc_all_on) {
878 char *addrs;
879 int i;
880 struct netdev_hw_addr *ha;
881
882 addrs = kmalloc(ETH_ALEN * mc_count, GFP_ATOMIC);
883 if (!addrs) {
884 set_allmulti(nesdev, nic_active_bit);
885 goto unlock;
886 }
887 i = 0;
888 netdev_for_each_mc_addr(ha, netdev)
889 memcpy(get_addr(addrs, i++), ha->addr, ETH_ALEN);
890
891 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW +
892 pft_entries_preallocated * 0x8;
893 for (i = 0, mc_index = 0; mc_index < max_pft_entries_avaiable;
894 mc_index++) {
895 while (i < mc_count && nesvnic->mcrq_mcast_filter &&
896 ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic,
897 get_addr(addrs, i++))) == 0));
898 if (mc_nic_index < 0)
899 mc_nic_index = nesvnic->nic_index;
900 while (nesadapter->pft_mcast_map[mc_index] < 16 &&
901 nesadapter->pft_mcast_map[mc_index] !=
902 nesvnic->nic_index &&
903 mc_index < max_pft_entries_avaiable) {
904 nes_debug(NES_DBG_NIC_RX,
905 "mc_index=%d skipping nic_index=%d,\
906 used for=%d \n", mc_index,
907 nesvnic->nic_index,
908 nesadapter->pft_mcast_map[mc_index]);
909 mc_index++;
910 }
911 if (mc_index >= max_pft_entries_avaiable)
912 break;
913 if (i < mc_count) {
914 char *addr = get_addr(addrs, i++);
915
916 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %pM to register 0x%04X nic_idx=%d\n",
917 addr,
918 perfect_filter_register_address+(mc_index * 8),
919 mc_nic_index);
920 macaddr_high = ((u16) addr[0]) << 8;
921 macaddr_high += (u16) addr[1];
922 macaddr_low = ((u32) addr[2]) << 24;
923 macaddr_low += ((u32) addr[3]) << 16;
924 macaddr_low += ((u32) addr[4]) << 8;
925 macaddr_low += (u32) addr[5];
926 nes_write_indexed(nesdev,
927 perfect_filter_register_address+(mc_index * 8),
928 macaddr_low);
929 nes_write_indexed(nesdev,
930 perfect_filter_register_address+4+(mc_index * 8),
931 (u32)macaddr_high | NES_MAC_ADDR_VALID |
932 ((((u32)(1<<mc_nic_index)) << 16)));
933 nesadapter->pft_mcast_map[mc_index] =
934 nesvnic->nic_index;
935 } else {
936 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
937 perfect_filter_register_address+(mc_index * 8));
938 nes_write_indexed(nesdev,
939 perfect_filter_register_address+4+(mc_index * 8),
940 0);
941 nesadapter->pft_mcast_map[mc_index] = 255;
942 }
943 }
944 kfree(addrs);
945 /* PFT is not large enough */
946 if (i < mc_count)
947 set_allmulti(nesdev, nic_active_bit);
948 }
949
950 unlock:
951 spin_unlock_irqrestore(&nesadapter->resource_lock, flags);
952 }
953
954
955 /**
956 * nes_netdev_change_mtu
957 */
958 static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
959 {
960 struct nes_vnic *nesvnic = netdev_priv(netdev);
961 struct nes_device *nesdev = nesvnic->nesdev;
962 int ret = 0;
963 u8 jumbomode = 0;
964 u32 nic_active;
965 u32 nic_active_bit;
966 u32 uc_all_active;
967 u32 mc_all_active;
968
969 if ((new_mtu < ETH_ZLEN) || (new_mtu > max_mtu))
970 return -EINVAL;
971
972 netdev->mtu = new_mtu;
973 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
974
975 if (netdev->mtu > 1500) {
976 jumbomode=1;
977 }
978 nes_nic_init_timer_defaults(nesdev, jumbomode);
979
980 if (netif_running(netdev)) {
981 nic_active_bit = 1 << nesvnic->nic_index;
982 mc_all_active = nes_read_indexed(nesdev,
983 NES_IDX_NIC_MULTICAST_ALL) & nic_active_bit;
984 uc_all_active = nes_read_indexed(nesdev,
985 NES_IDX_NIC_UNICAST_ALL) & nic_active_bit;
986
987 nes_netdev_stop(netdev);
988 nes_netdev_open(netdev);
989
990 nic_active = nes_read_indexed(nesdev,
991 NES_IDX_NIC_MULTICAST_ALL);
992 nic_active |= mc_all_active;
993 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL,
994 nic_active);
995
996 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
997 nic_active |= uc_all_active;
998 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
999 }
1000
1001 return ret;
1002 }
1003
1004 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
1005 "Link Change Interrupts",
1006 "Linearized SKBs",
1007 "T/GSO Requests",
1008 "Pause Frames Sent",
1009 "Pause Frames Received",
1010 "Internal Routing Errors",
1011 "SQ SW Dropped SKBs",
1012 "SQ Full",
1013 "Segmented TSO Requests",
1014 "Rx Symbol Errors",
1015 "Rx Jabber Errors",
1016 "Rx Oversized Frames",
1017 "Rx Short Frames",
1018 "Endnode Rx Discards",
1019 "Endnode Rx Octets",
1020 "Endnode Rx Frames",
1021 "Endnode Tx Octets",
1022 "Endnode Tx Frames",
1023 "mh detected",
1024 "mh pauses",
1025 "Retransmission Count",
1026 "CM Connects",
1027 "CM Accepts",
1028 "Disconnects",
1029 "Connected Events",
1030 "Connect Requests",
1031 "CM Rejects",
1032 "ModifyQP Timeouts",
1033 "CreateQPs",
1034 "SW DestroyQPs",
1035 "DestroyQPs",
1036 "CM Closes",
1037 "CM Packets Sent",
1038 "CM Packets Bounced",
1039 "CM Packets Created",
1040 "CM Packets Rcvd",
1041 "CM Packets Dropped",
1042 "CM Packets Retrans",
1043 "CM Listens Created",
1044 "CM Listens Destroyed",
1045 "CM Backlog Drops",
1046 "CM Loopbacks",
1047 "CM Nodes Created",
1048 "CM Nodes Destroyed",
1049 "CM Accel Drops",
1050 "CM Resets Received",
1051 "Timer Inits",
1052 "CQ Depth 1",
1053 "CQ Depth 4",
1054 "CQ Depth 16",
1055 "CQ Depth 24",
1056 "CQ Depth 32",
1057 "CQ Depth 128",
1058 "CQ Depth 256",
1059 "LRO aggregated",
1060 "LRO flushed",
1061 "LRO no_desc",
1062 };
1063
1064 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1065
1066 /**
1067 * nes_netdev_get_rx_csum
1068 */
1069 static u32 nes_netdev_get_rx_csum (struct net_device *netdev)
1070 {
1071 struct nes_vnic *nesvnic = netdev_priv(netdev);
1072
1073 if (nesvnic->rx_checksum_disabled)
1074 return 0;
1075 else
1076 return 1;
1077 }
1078
1079
1080 /**
1081 * nes_netdev_set_rc_csum
1082 */
1083 static int nes_netdev_set_rx_csum(struct net_device *netdev, u32 enable)
1084 {
1085 struct nes_vnic *nesvnic = netdev_priv(netdev);
1086
1087 if (enable)
1088 nesvnic->rx_checksum_disabled = 0;
1089 else
1090 nesvnic->rx_checksum_disabled = 1;
1091 return 0;
1092 }
1093
1094
1095 /**
1096 * nes_netdev_get_sset_count
1097 */
1098 static int nes_netdev_get_sset_count(struct net_device *netdev, int stringset)
1099 {
1100 if (stringset == ETH_SS_STATS)
1101 return NES_ETHTOOL_STAT_COUNT;
1102 else
1103 return -EINVAL;
1104 }
1105
1106
1107 /**
1108 * nes_netdev_get_strings
1109 */
1110 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1111 u8 *ethtool_strings)
1112 {
1113 if (stringset == ETH_SS_STATS)
1114 memcpy(ethtool_strings,
1115 &nes_ethtool_stringset,
1116 sizeof(nes_ethtool_stringset));
1117 }
1118
1119
1120 /**
1121 * nes_netdev_get_ethtool_stats
1122 */
1123 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1124 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1125 {
1126 u64 u64temp;
1127 struct nes_vnic *nesvnic = netdev_priv(netdev);
1128 struct nes_device *nesdev = nesvnic->nesdev;
1129 u32 nic_count;
1130 u32 u32temp;
1131 u32 index = 0;
1132
1133 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1134 target_stat_values[index] = nesvnic->nesdev->link_status_interrupts;
1135 target_stat_values[++index] = nesvnic->linearized_skbs;
1136 target_stat_values[++index] = nesvnic->tso_requests;
1137
1138 u32temp = nes_read_indexed(nesdev,
1139 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1140 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1141 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_sent;
1142
1143 u32temp = nes_read_indexed(nesdev,
1144 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1145 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1146
1147 u32temp = nes_read_indexed(nesdev,
1148 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1149 nesvnic->nesdev->port_rx_discards += u32temp;
1150 nesvnic->netstats.rx_dropped += u32temp;
1151
1152 u32temp = nes_read_indexed(nesdev,
1153 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1154 nesvnic->nesdev->port_tx_discards += u32temp;
1155 nesvnic->netstats.tx_dropped += u32temp;
1156
1157 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1158 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1159 break;
1160
1161 u32temp = nes_read_indexed(nesdev,
1162 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1163 (nesvnic->qp_nic_index[nic_count]*0x200));
1164 nesvnic->netstats.rx_dropped += u32temp;
1165 nesvnic->endnode_nstat_rx_discard += u32temp;
1166
1167 u64temp = (u64)nes_read_indexed(nesdev,
1168 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1169 (nesvnic->qp_nic_index[nic_count]*0x200));
1170 u64temp += ((u64)nes_read_indexed(nesdev,
1171 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1172 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1173
1174 nesvnic->endnode_nstat_rx_octets += u64temp;
1175 nesvnic->netstats.rx_bytes += u64temp;
1176
1177 u64temp = (u64)nes_read_indexed(nesdev,
1178 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1179 (nesvnic->qp_nic_index[nic_count]*0x200));
1180 u64temp += ((u64)nes_read_indexed(nesdev,
1181 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1182 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1183
1184 nesvnic->endnode_nstat_rx_frames += u64temp;
1185 nesvnic->netstats.rx_packets += u64temp;
1186
1187 u64temp = (u64)nes_read_indexed(nesdev,
1188 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1189 (nesvnic->qp_nic_index[nic_count]*0x200));
1190 u64temp += ((u64)nes_read_indexed(nesdev,
1191 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1192 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1193
1194 nesvnic->endnode_nstat_tx_octets += u64temp;
1195 nesvnic->netstats.tx_bytes += u64temp;
1196
1197 u64temp = (u64)nes_read_indexed(nesdev,
1198 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1199 (nesvnic->qp_nic_index[nic_count]*0x200));
1200 u64temp += ((u64)nes_read_indexed(nesdev,
1201 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1202 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1203
1204 nesvnic->endnode_nstat_tx_frames += u64temp;
1205 nesvnic->netstats.tx_packets += u64temp;
1206
1207 u32temp = nes_read_indexed(nesdev,
1208 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1209 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1210 }
1211
1212 target_stat_values[++index] = nesvnic->nesdev->mac_pause_frames_received;
1213 target_stat_values[++index] = nesdev->nesadapter->nic_rx_eth_route_err;
1214 target_stat_values[++index] = nesvnic->tx_sw_dropped;
1215 target_stat_values[++index] = nesvnic->sq_full;
1216 target_stat_values[++index] = nesvnic->segmented_tso_requests;
1217 target_stat_values[++index] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1218 target_stat_values[++index] = nesvnic->nesdev->mac_rx_jabber_frames;
1219 target_stat_values[++index] = nesvnic->nesdev->mac_rx_oversized_frames;
1220 target_stat_values[++index] = nesvnic->nesdev->mac_rx_short_frames;
1221 target_stat_values[++index] = nesvnic->endnode_nstat_rx_discard;
1222 target_stat_values[++index] = nesvnic->endnode_nstat_rx_octets;
1223 target_stat_values[++index] = nesvnic->endnode_nstat_rx_frames;
1224 target_stat_values[++index] = nesvnic->endnode_nstat_tx_octets;
1225 target_stat_values[++index] = nesvnic->endnode_nstat_tx_frames;
1226 target_stat_values[++index] = mh_detected;
1227 target_stat_values[++index] = mh_pauses_sent;
1228 target_stat_values[++index] = nesvnic->endnode_ipv4_tcp_retransmits;
1229 target_stat_values[++index] = atomic_read(&cm_connects);
1230 target_stat_values[++index] = atomic_read(&cm_accepts);
1231 target_stat_values[++index] = atomic_read(&cm_disconnects);
1232 target_stat_values[++index] = atomic_read(&cm_connecteds);
1233 target_stat_values[++index] = atomic_read(&cm_connect_reqs);
1234 target_stat_values[++index] = atomic_read(&cm_rejects);
1235 target_stat_values[++index] = atomic_read(&mod_qp_timouts);
1236 target_stat_values[++index] = atomic_read(&qps_created);
1237 target_stat_values[++index] = atomic_read(&sw_qps_destroyed);
1238 target_stat_values[++index] = atomic_read(&qps_destroyed);
1239 target_stat_values[++index] = atomic_read(&cm_closes);
1240 target_stat_values[++index] = cm_packets_sent;
1241 target_stat_values[++index] = cm_packets_bounced;
1242 target_stat_values[++index] = cm_packets_created;
1243 target_stat_values[++index] = cm_packets_received;
1244 target_stat_values[++index] = cm_packets_dropped;
1245 target_stat_values[++index] = cm_packets_retrans;
1246 target_stat_values[++index] = atomic_read(&cm_listens_created);
1247 target_stat_values[++index] = atomic_read(&cm_listens_destroyed);
1248 target_stat_values[++index] = cm_backlog_drops;
1249 target_stat_values[++index] = atomic_read(&cm_loopbacks);
1250 target_stat_values[++index] = atomic_read(&cm_nodes_created);
1251 target_stat_values[++index] = atomic_read(&cm_nodes_destroyed);
1252 target_stat_values[++index] = atomic_read(&cm_accel_dropped_pkts);
1253 target_stat_values[++index] = atomic_read(&cm_resets_recvd);
1254 target_stat_values[++index] = int_mod_timer_init;
1255 target_stat_values[++index] = int_mod_cq_depth_1;
1256 target_stat_values[++index] = int_mod_cq_depth_4;
1257 target_stat_values[++index] = int_mod_cq_depth_16;
1258 target_stat_values[++index] = int_mod_cq_depth_24;
1259 target_stat_values[++index] = int_mod_cq_depth_32;
1260 target_stat_values[++index] = int_mod_cq_depth_128;
1261 target_stat_values[++index] = int_mod_cq_depth_256;
1262 target_stat_values[++index] = nesvnic->lro_mgr.stats.aggregated;
1263 target_stat_values[++index] = nesvnic->lro_mgr.stats.flushed;
1264 target_stat_values[++index] = nesvnic->lro_mgr.stats.no_desc;
1265
1266 }
1267
1268
1269 /**
1270 * nes_netdev_get_drvinfo
1271 */
1272 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1273 struct ethtool_drvinfo *drvinfo)
1274 {
1275 struct nes_vnic *nesvnic = netdev_priv(netdev);
1276 struct nes_adapter *nesadapter = nesvnic->nesdev->nesadapter;
1277
1278 strcpy(drvinfo->driver, DRV_NAME);
1279 strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
1280 sprintf(drvinfo->fw_version, "%u.%u", nesadapter->firmware_version>>16,
1281 nesadapter->firmware_version & 0x000000ff);
1282 strcpy(drvinfo->version, DRV_VERSION);
1283 drvinfo->testinfo_len = 0;
1284 drvinfo->eedump_len = 0;
1285 drvinfo->regdump_len = 0;
1286 }
1287
1288
1289 /**
1290 * nes_netdev_set_coalesce
1291 */
1292 static int nes_netdev_set_coalesce(struct net_device *netdev,
1293 struct ethtool_coalesce *et_coalesce)
1294 {
1295 struct nes_vnic *nesvnic = netdev_priv(netdev);
1296 struct nes_device *nesdev = nesvnic->nesdev;
1297 struct nes_adapter *nesadapter = nesdev->nesadapter;
1298 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1299 unsigned long flags;
1300
1301 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1302 if (et_coalesce->rx_max_coalesced_frames_low) {
1303 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1304 }
1305 if (et_coalesce->rx_max_coalesced_frames_irq) {
1306 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1307 }
1308 if (et_coalesce->rx_max_coalesced_frames_high) {
1309 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1310 }
1311 if (et_coalesce->rx_coalesce_usecs_low) {
1312 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1313 }
1314 if (et_coalesce->rx_coalesce_usecs_high) {
1315 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1316 }
1317 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1318
1319 /* using this to drive total interrupt moderation */
1320 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1321 if (et_coalesce->use_adaptive_rx_coalesce) {
1322 nesadapter->et_use_adaptive_rx_coalesce = 1;
1323 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1324 nesadapter->et_rx_coalesce_usecs_irq = 0;
1325 if (et_coalesce->pkt_rate_low) {
1326 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1327 }
1328 } else {
1329 nesadapter->et_use_adaptive_rx_coalesce = 0;
1330 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1331 if (nesadapter->et_rx_coalesce_usecs_irq) {
1332 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1333 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1334 }
1335 }
1336 return 0;
1337 }
1338
1339
1340 /**
1341 * nes_netdev_get_coalesce
1342 */
1343 static int nes_netdev_get_coalesce(struct net_device *netdev,
1344 struct ethtool_coalesce *et_coalesce)
1345 {
1346 struct nes_vnic *nesvnic = netdev_priv(netdev);
1347 struct nes_device *nesdev = nesvnic->nesdev;
1348 struct nes_adapter *nesadapter = nesdev->nesadapter;
1349 struct ethtool_coalesce temp_et_coalesce;
1350 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1351 unsigned long flags;
1352
1353 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1354 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1355 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1356 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1357 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1358 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1359 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1360 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
1361 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1362 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1363 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1364 if (nesadapter->et_use_adaptive_rx_coalesce) {
1365 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1366 }
1367 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1368 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1369 return 0;
1370 }
1371
1372
1373 /**
1374 * nes_netdev_get_pauseparam
1375 */
1376 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1377 struct ethtool_pauseparam *et_pauseparam)
1378 {
1379 struct nes_vnic *nesvnic = netdev_priv(netdev);
1380
1381 et_pauseparam->autoneg = 0;
1382 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1383 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1384 }
1385
1386
1387 /**
1388 * nes_netdev_set_pauseparam
1389 */
1390 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1391 struct ethtool_pauseparam *et_pauseparam)
1392 {
1393 struct nes_vnic *nesvnic = netdev_priv(netdev);
1394 struct nes_device *nesdev = nesvnic->nesdev;
1395 u32 u32temp;
1396
1397 if (et_pauseparam->autoneg) {
1398 /* TODO: should return unsupported */
1399 return 0;
1400 }
1401 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1402 u32temp = nes_read_indexed(nesdev,
1403 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1404 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1405 nes_write_indexed(nesdev,
1406 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1407 nesdev->disable_tx_flow_control = 0;
1408 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1409 u32temp = nes_read_indexed(nesdev,
1410 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1411 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1412 nes_write_indexed(nesdev,
1413 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1414 nesdev->disable_tx_flow_control = 1;
1415 }
1416 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1417 u32temp = nes_read_indexed(nesdev,
1418 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1419 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1420 nes_write_indexed(nesdev,
1421 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1422 nesdev->disable_rx_flow_control = 0;
1423 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1424 u32temp = nes_read_indexed(nesdev,
1425 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1426 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1427 nes_write_indexed(nesdev,
1428 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1429 nesdev->disable_rx_flow_control = 1;
1430 }
1431
1432 return 0;
1433 }
1434
1435
1436 /**
1437 * nes_netdev_get_settings
1438 */
1439 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1440 {
1441 struct nes_vnic *nesvnic = netdev_priv(netdev);
1442 struct nes_device *nesdev = nesvnic->nesdev;
1443 struct nes_adapter *nesadapter = nesdev->nesadapter;
1444 u32 mac_index = nesdev->mac_index;
1445 u8 phy_type = nesadapter->phy_type[mac_index];
1446 u8 phy_index = nesadapter->phy_index[mac_index];
1447 u16 phy_data;
1448
1449 et_cmd->duplex = DUPLEX_FULL;
1450 et_cmd->port = PORT_MII;
1451 et_cmd->maxtxpkt = 511;
1452 et_cmd->maxrxpkt = 511;
1453
1454 if (nesadapter->OneG_Mode) {
1455 et_cmd->speed = SPEED_1000;
1456 if (phy_type == NES_PHY_TYPE_PUMA_1G) {
1457 et_cmd->supported = SUPPORTED_1000baseT_Full;
1458 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1459 et_cmd->autoneg = AUTONEG_DISABLE;
1460 et_cmd->transceiver = XCVR_INTERNAL;
1461 et_cmd->phy_address = mac_index;
1462 } else {
1463 unsigned long flags;
1464 et_cmd->supported = SUPPORTED_1000baseT_Full
1465 | SUPPORTED_Autoneg;
1466 et_cmd->advertising = ADVERTISED_1000baseT_Full
1467 | ADVERTISED_Autoneg;
1468 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1469 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1470 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1471 if (phy_data & 0x1000)
1472 et_cmd->autoneg = AUTONEG_ENABLE;
1473 else
1474 et_cmd->autoneg = AUTONEG_DISABLE;
1475 et_cmd->transceiver = XCVR_EXTERNAL;
1476 et_cmd->phy_address = phy_index;
1477 }
1478 return 0;
1479 }
1480 if ((phy_type == NES_PHY_TYPE_ARGUS) ||
1481 (phy_type == NES_PHY_TYPE_SFP_D) ||
1482 (phy_type == NES_PHY_TYPE_KR)) {
1483 et_cmd->transceiver = XCVR_EXTERNAL;
1484 et_cmd->port = PORT_FIBRE;
1485 et_cmd->supported = SUPPORTED_FIBRE;
1486 et_cmd->advertising = ADVERTISED_FIBRE;
1487 et_cmd->phy_address = phy_index;
1488 } else {
1489 et_cmd->transceiver = XCVR_INTERNAL;
1490 et_cmd->supported = SUPPORTED_10000baseT_Full;
1491 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1492 et_cmd->phy_address = mac_index;
1493 }
1494 et_cmd->speed = SPEED_10000;
1495 et_cmd->autoneg = AUTONEG_DISABLE;
1496 return 0;
1497 }
1498
1499
1500 /**
1501 * nes_netdev_set_settings
1502 */
1503 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1504 {
1505 struct nes_vnic *nesvnic = netdev_priv(netdev);
1506 struct nes_device *nesdev = nesvnic->nesdev;
1507 struct nes_adapter *nesadapter = nesdev->nesadapter;
1508
1509 if ((nesadapter->OneG_Mode) &&
1510 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1511 unsigned long flags;
1512 u16 phy_data;
1513 u8 phy_index = nesadapter->phy_index[nesdev->mac_index];
1514
1515 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1516 nes_read_1G_phy_reg(nesdev, 0, phy_index, &phy_data);
1517 if (et_cmd->autoneg) {
1518 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1519 phy_data |= 0x1300;
1520 } else {
1521 /* Turn off autoneg */
1522 phy_data &= ~0x1000;
1523 }
1524 nes_write_1G_phy_reg(nesdev, 0, phy_index, phy_data);
1525 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1526 }
1527
1528 return 0;
1529 }
1530
1531
1532 static const struct ethtool_ops nes_ethtool_ops = {
1533 .get_link = ethtool_op_get_link,
1534 .get_settings = nes_netdev_get_settings,
1535 .set_settings = nes_netdev_set_settings,
1536 .get_tx_csum = ethtool_op_get_tx_csum,
1537 .get_rx_csum = nes_netdev_get_rx_csum,
1538 .get_sg = ethtool_op_get_sg,
1539 .get_strings = nes_netdev_get_strings,
1540 .get_sset_count = nes_netdev_get_sset_count,
1541 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1542 .get_drvinfo = nes_netdev_get_drvinfo,
1543 .get_coalesce = nes_netdev_get_coalesce,
1544 .set_coalesce = nes_netdev_set_coalesce,
1545 .get_pauseparam = nes_netdev_get_pauseparam,
1546 .set_pauseparam = nes_netdev_set_pauseparam,
1547 .set_tx_csum = ethtool_op_set_tx_csum,
1548 .set_rx_csum = nes_netdev_set_rx_csum,
1549 .set_sg = ethtool_op_set_sg,
1550 .get_tso = ethtool_op_get_tso,
1551 .set_tso = ethtool_op_set_tso,
1552 .get_flags = ethtool_op_get_flags,
1553 .set_flags = ethtool_op_set_flags,
1554 };
1555
1556
1557 static void nes_netdev_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
1558 {
1559 struct nes_vnic *nesvnic = netdev_priv(netdev);
1560 struct nes_device *nesdev = nesvnic->nesdev;
1561 struct nes_adapter *nesadapter = nesdev->nesadapter;
1562 u32 u32temp;
1563 unsigned long flags;
1564
1565 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1566 nesvnic->vlan_grp = grp;
1567
1568 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1569
1570 /* Enable/Disable VLAN Stripping */
1571 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1572 if (grp)
1573 u32temp &= 0xfdffffff;
1574 else
1575 u32temp |= 0x02000000;
1576
1577 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1578 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1579 }
1580
1581 static const struct net_device_ops nes_netdev_ops = {
1582 .ndo_open = nes_netdev_open,
1583 .ndo_stop = nes_netdev_stop,
1584 .ndo_start_xmit = nes_netdev_start_xmit,
1585 .ndo_get_stats = nes_netdev_get_stats,
1586 .ndo_tx_timeout = nes_netdev_tx_timeout,
1587 .ndo_set_mac_address = nes_netdev_set_mac_address,
1588 .ndo_set_multicast_list = nes_netdev_set_multicast_list,
1589 .ndo_change_mtu = nes_netdev_change_mtu,
1590 .ndo_validate_addr = eth_validate_addr,
1591 .ndo_vlan_rx_register = nes_netdev_vlan_rx_register,
1592 };
1593
1594 /**
1595 * nes_netdev_init - initialize network device
1596 */
1597 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1598 void __iomem *mmio_addr)
1599 {
1600 u64 u64temp;
1601 struct nes_vnic *nesvnic;
1602 struct net_device *netdev;
1603 struct nic_qp_map *curr_qp_map;
1604 u8 phy_type = nesdev->nesadapter->phy_type[nesdev->mac_index];
1605
1606 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1607 if (!netdev) {
1608 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1609 return NULL;
1610 }
1611 nesvnic = netdev_priv(netdev);
1612
1613 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1614
1615 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1616
1617 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1618 netdev->irq = nesdev->pcidev->irq;
1619 netdev->mtu = ETH_DATA_LEN;
1620 netdev->hard_header_len = ETH_HLEN;
1621 netdev->addr_len = ETH_ALEN;
1622 netdev->type = ARPHRD_ETHER;
1623 netdev->features = NETIF_F_HIGHDMA;
1624 netdev->netdev_ops = &nes_netdev_ops;
1625 netdev->ethtool_ops = &nes_ethtool_ops;
1626 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1627 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1628 netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1629
1630 /* Fill in the port structure */
1631 nesvnic->netdev = netdev;
1632 nesvnic->nesdev = nesdev;
1633 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1634 nesvnic->netdev_index = nesdev->netdev_count;
1635 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1636 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1637
1638 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1639 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1640 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1641 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1642
1643 /* Setup the burned in MAC address */
1644 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1645 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1646 u64temp += nesvnic->nic_index;
1647 netdev->dev_addr[0] = (u8)(u64temp>>40);
1648 netdev->dev_addr[1] = (u8)(u64temp>>32);
1649 netdev->dev_addr[2] = (u8)(u64temp>>24);
1650 netdev->dev_addr[3] = (u8)(u64temp>>16);
1651 netdev->dev_addr[4] = (u8)(u64temp>>8);
1652 netdev->dev_addr[5] = (u8)u64temp;
1653 memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1654
1655 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV)) {
1656 netdev->features |= NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1657 netdev->features |= NETIF_F_GSO | NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1658 } else {
1659 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1660 }
1661
1662 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1663 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1664 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1665 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1666
1667 if (nesvnic->nesdev->nesadapter->port_count == 1 &&
1668 nesvnic->nesdev->nesadapter->adapter_fcn_count == 1) {
1669
1670 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1671 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1672 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1673 nesvnic->qp_nic_index[2] = 0xf;
1674 nesvnic->qp_nic_index[3] = 0xf;
1675 } else {
1676 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1677 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1678 }
1679 } else {
1680 if (nesvnic->nesdev->nesadapter->port_count == 2 ||
1681 (nesvnic->nesdev->nesadapter->port_count == 1 &&
1682 nesvnic->nesdev->nesadapter->adapter_fcn_count == 2)) {
1683 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1684 nesvnic->qp_nic_index[1] = nesvnic->nic_index
1685 + 2;
1686 nesvnic->qp_nic_index[2] = 0xf;
1687 nesvnic->qp_nic_index[3] = 0xf;
1688 } else {
1689 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1690 nesvnic->qp_nic_index[1] = 0xf;
1691 nesvnic->qp_nic_index[2] = 0xf;
1692 nesvnic->qp_nic_index[3] = 0xf;
1693 }
1694 }
1695 nesvnic->next_qp_nic_index = 0;
1696
1697 if (nesdev->netdev_count == 0) {
1698 nesvnic->rdma_enabled = 1;
1699 } else {
1700 nesvnic->rdma_enabled = 0;
1701 }
1702 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1703 spin_lock_init(&nesvnic->tx_lock);
1704 nesdev->netdev[nesdev->netdev_count] = netdev;
1705
1706 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1707 nesvnic, nesdev->mac_index);
1708 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1709
1710 if ((nesdev->netdev_count == 0) &&
1711 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1712 ((phy_type == NES_PHY_TYPE_PUMA_1G) &&
1713 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1714 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1715 u32 u32temp;
1716 u32 link_mask;
1717 u32 link_val;
1718
1719 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1720 (0x200 * (nesdev->mac_index & 1)));
1721 if (phy_type != NES_PHY_TYPE_PUMA_1G) {
1722 u32temp |= 0x00200000;
1723 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1724 (0x200 * (nesdev->mac_index & 1)), u32temp);
1725 }
1726
1727 /* Check and set linkup here. This is for back to back */
1728 /* configuration where second port won't get link interrupt */
1729 switch (phy_type) {
1730 case NES_PHY_TYPE_PUMA_1G:
1731 if (nesdev->mac_index < 2) {
1732 link_mask = 0x01010000;
1733 link_val = 0x01010000;
1734 } else {
1735 link_mask = 0x02020000;
1736 link_val = 0x02020000;
1737 }
1738 break;
1739 default:
1740 link_mask = 0x0f1f0000;
1741 link_val = 0x0f0f0000;
1742 break;
1743 }
1744
1745 u32temp = nes_read_indexed(nesdev,
1746 NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1747 (0x200 * (nesdev->mac_index & 1)));
1748 if ((u32temp & link_mask) == link_val)
1749 nesvnic->linkup = 1;
1750
1751 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1752 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1753 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1754 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1755
1756 nes_init_phy(nesdev);
1757 }
1758
1759 return netdev;
1760 }
1761
1762
1763 /**
1764 * nes_netdev_destroy - destroy network device structure
1765 */
1766 void nes_netdev_destroy(struct net_device *netdev)
1767 {
1768 struct nes_vnic *nesvnic = netdev_priv(netdev);
1769
1770 /* make sure 'stop' method is called by Linux stack */
1771 /* nes_netdev_stop(netdev); */
1772
1773 list_del(&nesvnic->list);
1774
1775 if (nesvnic->of_device_registered) {
1776 nes_destroy_ofa_device(nesvnic->nesibdev);
1777 }
1778
1779 free_netdev(netdev);
1780 }
1781
1782
1783 /**
1784 * nes_nic_cm_xmit -- CM calls this to send out pkts
1785 */
1786 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1787 {
1788 int ret;
1789
1790 skb->dev = netdev;
1791 ret = dev_queue_xmit(skb);
1792 if (ret) {
1793 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);
1794 }
1795
1796 return ret;
1797 }
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree