2 * Copyright (c) 2006 - 2008 NetEffect, Inc. All rights reserved.
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:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
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.
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
34 #include <linux/module.h>
35 #include <linux/moduleparam.h>
36 #include <linux/netdevice.h>
37 #include <linux/etherdevice.h>
39 #include <linux/tcp.h>
40 #include <linux/if_arp.h>
41 #include <linux/if_vlan.h>
42 #include <linux/ethtool.h>
45 #include <net/inet_common.h>
46 #include <linux/inet.h>
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}
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}
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}
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}
70 static struct nic_qp_map nic_qp_mapping_4[] = {
71 {28,8,0,0},{32,12,0,0}
74 static struct nic_qp_map nic_qp_mapping_5[] = {
75 {29,9,1,0},{33,13,1,0}
78 static struct nic_qp_map nic_qp_mapping_6[] = {
79 {30,10,2,0},{34,14,2,0}
82 static struct nic_qp_map nic_qp_mapping_7[] = {
83 {31,11,3,0},{35,15,3,0}
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
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;
98 static int nes_netdev_poll(struct napi_struct *napi, int budget)
100 struct nes_vnic *nesvnic = container_of(napi, struct nes_vnic, napi);
101 struct net_device *netdev = nesvnic->netdev;
102 struct nes_device *nesdev = nesvnic->nesdev;
103 struct nes_hw_nic_cq *nescq = &nesvnic->nic_cq;
105 nesvnic->budget = budget;
106 nescq->cqes_pending = 0;
107 nescq->rx_cqes_completed = 0;
108 nescq->cqe_allocs_pending = 0;
109 nescq->rx_pkts_indicated = 0;
111 nes_nic_ce_handler(nesdev, nescq);
113 if (nescq->cqes_pending == 0) {
114 netif_rx_complete(netdev, napi);
115 /* clear out completed cqes and arm */
116 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
117 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
118 nes_read32(nesdev->regs+NES_CQE_ALLOC);
120 /* clear out completed cqes but don't arm */
121 nes_write32(nesdev->regs+NES_CQE_ALLOC,
122 nescq->cq_number | (nescq->cqe_allocs_pending << 16));
123 nes_debug(NES_DBG_NETDEV, "%s: exiting with work pending\n",
124 nesvnic->netdev->name);
126 return nescq->rx_pkts_indicated;
131 * nes_netdev_open - Activate the network interface; ifconfig
134 static int nes_netdev_open(struct net_device *netdev)
138 struct nes_vnic *nesvnic = netdev_priv(netdev);
139 struct nes_device *nesdev = nesvnic->nesdev;
142 struct nes_vnic *first_nesvnic = NULL;
145 struct list_head *list_pos, *list_temp;
147 assert(nesdev != NULL);
149 if (nesvnic->netdev_open == 1)
152 if (netif_msg_ifup(nesvnic))
153 printk(KERN_INFO PFX "%s: enabling interface\n", netdev->name);
155 ret = nes_init_nic_qp(nesdev, netdev);
160 netif_carrier_off(netdev);
161 netif_stop_queue(netdev);
163 if ((!nesvnic->of_device_registered) && (nesvnic->rdma_enabled)) {
164 nesvnic->nesibdev = nes_init_ofa_device(netdev);
165 if (nesvnic->nesibdev == NULL) {
166 printk(KERN_ERR PFX "%s: nesvnic->nesibdev alloc failed", netdev->name);
168 nesvnic->nesibdev->nesvnic = nesvnic;
169 ret = nes_register_ofa_device(nesvnic->nesibdev);
171 printk(KERN_ERR PFX "%s: Unable to register RDMA device, ret = %d\n",
176 /* Set packet filters */
177 nic_active_bit = 1 << nesvnic->nic_index;
178 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
179 nic_active |= nic_active_bit;
180 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
181 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
182 nic_active |= nic_active_bit;
183 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
184 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
185 nic_active |= nic_active_bit;
186 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
188 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
189 macaddr_high += (u16)netdev->dev_addr[1];
190 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
191 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
192 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
193 macaddr_low += (u32)netdev->dev_addr[5];
195 /* Program the various MAC regs */
196 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
197 if (nesvnic->qp_nic_index[i] == 0xf) {
200 nes_debug(NES_DBG_NETDEV, "i=%d, perfect filter table index= %d, PERF FILTER LOW"
201 " (Addr:%08X) = %08X, HIGH = %08X.\n",
202 i, nesvnic->qp_nic_index[i],
203 NES_IDX_PERFECT_FILTER_LOW+((nesvnic->perfect_filter_index + i) * 8),
205 (u32)macaddr_high | NES_MAC_ADDR_VALID |
206 ((((u32)nesvnic->nic_index) << 16)));
207 nes_write_indexed(nesdev,
208 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
210 nes_write_indexed(nesdev,
211 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
212 (u32)macaddr_high | NES_MAC_ADDR_VALID |
213 ((((u32)nesvnic->nic_index) << 16)));
217 nes_write32(nesdev->regs+NES_CQE_ALLOC, NES_CQE_ALLOC_NOTIFY_NEXT |
218 nesvnic->nic_cq.cq_number);
219 nes_read32(nesdev->regs+NES_CQE_ALLOC);
220 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
221 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
222 if (first_nesvnic->netdev_open == 1)
225 if (first_nesvnic->netdev_open == 0) {
226 nes_debug(NES_DBG_INIT, "Setting up MAC interrupt mask.\n");
227 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK + (0x200 * nesdev->mac_index),
228 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
229 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
230 first_nesvnic = nesvnic;
232 if (first_nesvnic->linkup) {
233 /* Enable network packets */
235 netif_start_queue(netdev);
236 netif_carrier_on(netdev);
238 napi_enable(&nesvnic->napi);
239 nesvnic->netdev_open = 1;
248 static int nes_netdev_stop(struct net_device *netdev)
250 struct nes_vnic *nesvnic = netdev_priv(netdev);
251 struct nes_device *nesdev = nesvnic->nesdev;
254 struct nes_vnic *first_nesvnic = NULL;
255 struct list_head *list_pos, *list_temp;
257 nes_debug(NES_DBG_SHUTDOWN, "nesvnic=%p, nesdev=%p, netdev=%p %s\n",
258 nesvnic, nesdev, netdev, netdev->name);
259 if (nesvnic->netdev_open == 0)
262 if (netif_msg_ifdown(nesvnic))
263 printk(KERN_INFO PFX "%s: disabling interface\n", netdev->name);
265 /* Disable network packets */
266 napi_disable(&nesvnic->napi);
267 netif_stop_queue(netdev);
268 list_for_each_safe(list_pos, list_temp, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]) {
269 first_nesvnic = container_of(list_pos, struct nes_vnic, list);
270 if ((first_nesvnic->netdev_open == 1) && (first_nesvnic != nesvnic))
274 if (first_nesvnic->netdev_open == 0)
275 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK+(0x200*nesdev->mac_index), 0xffffffff);
276 else if ((first_nesvnic != nesvnic) &&
277 (PCI_FUNC(first_nesvnic->nesdev->pcidev->devfn) != PCI_FUNC(nesvnic->nesdev->pcidev->devfn))) {
278 nes_write_indexed(nesdev, NES_IDX_MAC_INT_MASK + (0x200 * nesdev->mac_index), 0xffffffff);
279 nes_write_indexed(first_nesvnic->nesdev, NES_IDX_MAC_INT_MASK + (0x200 * first_nesvnic->nesdev->mac_index),
280 ~(NES_MAC_INT_LINK_STAT_CHG | NES_MAC_INT_XGMII_EXT |
281 NES_MAC_INT_TX_UNDERFLOW | NES_MAC_INT_TX_ERROR));
284 nic_active_mask = ~((u32)(1 << nesvnic->nic_index));
285 nes_write_indexed(nesdev, NES_IDX_PERFECT_FILTER_HIGH+
286 (nesvnic->perfect_filter_index*8), 0);
287 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_ACTIVE);
288 nic_active &= nic_active_mask;
289 nes_write_indexed(nesdev, NES_IDX_NIC_ACTIVE, nic_active);
290 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
291 nic_active &= nic_active_mask;
292 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
293 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE);
294 nic_active &= nic_active_mask;
295 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ENABLE, nic_active);
296 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
297 nic_active &= nic_active_mask;
298 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
299 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON);
300 nic_active &= nic_active_mask;
301 nes_write_indexed(nesdev, NES_IDX_NIC_BROADCAST_ON, nic_active);
304 if (nesvnic->of_device_registered) {
305 nes_destroy_ofa_device(nesvnic->nesibdev);
306 nesvnic->nesibdev = NULL;
307 nesvnic->of_device_registered = 0;
309 nes_destroy_nic_qp(nesvnic);
311 nesvnic->netdev_open = 0;
320 static int nes_nic_send(struct sk_buff *skb, struct net_device *netdev)
322 struct nes_vnic *nesvnic = netdev_priv(netdev);
323 struct nes_device *nesdev = nesvnic->nesdev;
324 struct nes_hw_nic *nesnic = &nesvnic->nic;
325 struct nes_hw_nic_sq_wqe *nic_sqe;
327 __le16 *wqe_fragment_length;
329 u16 wqe_fragment_index = 1; /* first fragment (0) is used by copy buffer */
330 u16 skb_fragment_index;
331 dma_addr_t bus_address;
333 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
334 wqe_fragment_length = (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
336 /* setup the VLAN tag if present */
337 if (vlan_tx_tag_present(skb)) {
338 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
339 netdev->name, vlan_tx_tag_get(skb));
340 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
341 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
345 /* bump past the vlan tag */
346 wqe_fragment_length++;
347 /* wqe_fragment_address = (u64 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_FRAG0_LOW_IDX]; */
349 if (skb->ip_summed == CHECKSUM_PARTIAL) {
352 if (skb_is_gso(skb)) {
353 /* nes_debug(NES_DBG_NIC_TX, "%s: TSO request... seg size = %u\n",
354 netdev->name, skb_is_gso(skb)); */
355 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE |
356 NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
357 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
359 (((u32)(((unsigned char *)tcph) - skb->data)) << 4));
361 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION;
364 } else { /* CHECKSUM_HW */
365 wqe_misc |= NES_NIC_SQ_WQE_DISABLE_CHKSUM | NES_NIC_SQ_WQE_COMPLETION;
368 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
370 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
371 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE), skb_headlen(skb)));
372 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
374 wqe_fragment_length[1] = 0;
375 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
376 if ((skb_shinfo(skb)->nr_frags + 1) > 4) {
377 nes_debug(NES_DBG_NIC_TX, "%s: Packet with %u fragments not sent, skb_headlen=%u\n",
378 netdev->name, skb_shinfo(skb)->nr_frags + 2, skb_headlen(skb));
380 nesvnic->tx_sw_dropped++;
381 return NETDEV_TX_LOCKED;
383 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
384 bus_address = pci_map_single(nesdev->pcidev, skb->data + NES_FIRST_FRAG_SIZE,
385 skb_headlen(skb) - NES_FIRST_FRAG_SIZE, PCI_DMA_TODEVICE);
386 wqe_fragment_length[wqe_fragment_index++] =
387 cpu_to_le16(skb_headlen(skb) - NES_FIRST_FRAG_SIZE);
388 wqe_fragment_length[wqe_fragment_index] = 0;
389 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
390 ((u64)(bus_address)));
391 nesnic->tx_skb[nesnic->sq_head] = skb;
394 if (skb_headlen(skb) == skb->len) {
395 if (skb_headlen(skb) <= NES_FIRST_FRAG_SIZE) {
396 nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_2_1_IDX] = 0;
397 nesnic->tx_skb[nesnic->sq_head] = NULL;
401 /* Deal with Fragments */
402 nesnic->tx_skb[nesnic->sq_head] = skb;
403 for (skb_fragment_index = 0; skb_fragment_index < skb_shinfo(skb)->nr_frags;
404 skb_fragment_index++) {
405 bus_address = pci_map_page( nesdev->pcidev,
406 skb_shinfo(skb)->frags[skb_fragment_index].page,
407 skb_shinfo(skb)->frags[skb_fragment_index].page_offset,
408 skb_shinfo(skb)->frags[skb_fragment_index].size,
410 wqe_fragment_length[wqe_fragment_index] =
411 cpu_to_le16(skb_shinfo(skb)->frags[skb_fragment_index].size);
412 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
414 wqe_fragment_index++;
415 if (wqe_fragment_index < 5)
416 wqe_fragment_length[wqe_fragment_index] = 0;
420 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX, wqe_misc);
422 nesnic->sq_head &= nesnic->sq_size - 1;
429 * nes_netdev_start_xmit
431 static int nes_netdev_start_xmit(struct sk_buff *skb, struct net_device *netdev)
433 struct nes_vnic *nesvnic = netdev_priv(netdev);
434 struct nes_device *nesdev = nesvnic->nesdev;
435 struct nes_hw_nic *nesnic = &nesvnic->nic;
436 struct nes_hw_nic_sq_wqe *nic_sqe;
438 /* struct udphdr *udph; */
439 #define NES_MAX_TSO_FRAGS 18
440 /* 64K segment plus overflow on each side */
441 dma_addr_t tso_bus_address[NES_MAX_TSO_FRAGS];
442 dma_addr_t bus_address;
451 __le16 *wqe_fragment_length;
453 u32 original_first_length;
454 // u64 *wqe_fragment_address;
455 /* first fragment (0) is used by copy buffer */
456 u16 wqe_fragment_index=1;
464 /* nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
465 " (%u frags), tso_size=%u\n",
466 netdev->name, skb->len, skb_headlen(skb),
467 skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
470 if (!netif_carrier_ok(netdev))
473 if (netif_queue_stopped(netdev))
474 return NETDEV_TX_BUSY;
476 local_irq_save(flags);
477 if (!spin_trylock(&nesnic->sq_lock)) {
478 local_irq_restore(flags);
479 nesvnic->sq_locked++;
480 return NETDEV_TX_LOCKED;
483 /* Check if SQ is full */
484 if ((((nesnic->sq_tail+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) == 1) {
485 if (!netif_queue_stopped(netdev)) {
486 netif_stop_queue(netdev);
488 if ((((((volatile u16)nesnic->sq_tail)+(nesnic->sq_size*2))-nesnic->sq_head) & (nesnic->sq_size - 1)) != 1) {
489 netif_start_queue(netdev);
490 goto sq_no_longer_full;
494 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
495 return NETDEV_TX_BUSY;
499 nr_frags = skb_shinfo(skb)->nr_frags;
500 if (skb_headlen(skb) > NES_FIRST_FRAG_SIZE) {
503 /* Check if too many fragments */
504 if (unlikely((nr_frags > 4))) {
505 if (skb_is_gso(skb)) {
506 nesvnic->segmented_tso_requests++;
507 nesvnic->tso_requests++;
508 old_head = nesnic->sq_head;
509 /* Basically 4 fragments available per WQE with extended fragments */
510 wqes_needed = nr_frags >> 2;
511 wqes_needed += (nr_frags&3)?1:0;
512 wqes_available = (((nesnic->sq_tail+nesnic->sq_size)-nesnic->sq_head) - 1) &
513 (nesnic->sq_size - 1);
515 if (unlikely(wqes_needed > wqes_available)) {
516 if (!netif_queue_stopped(netdev)) {
517 netif_stop_queue(netdev);
519 wqes_available = (((((volatile u16)nesnic->sq_tail)+nesnic->sq_size)-nesnic->sq_head) - 1) &
520 (nesnic->sq_size - 1);
521 if (wqes_needed <= wqes_available) {
522 netif_start_queue(netdev);
523 goto tso_sq_no_longer_full;
527 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
528 nes_debug(NES_DBG_NIC_TX, "%s: HNIC SQ full- TSO request has too many frags!\n",
530 return NETDEV_TX_BUSY;
532 tso_sq_no_longer_full:
533 /* Map all the buffers */
534 for (tso_frag_count=0; tso_frag_count < skb_shinfo(skb)->nr_frags;
536 tso_bus_address[tso_frag_count] = pci_map_page( nesdev->pcidev,
537 skb_shinfo(skb)->frags[tso_frag_count].page,
538 skb_shinfo(skb)->frags[tso_frag_count].page_offset,
539 skb_shinfo(skb)->frags[tso_frag_count].size,
544 curr_tcp_seq = ntohl(tcp_hdr(skb)->seq);
545 hoffset = skb_transport_header(skb) - skb->data;
546 nhoffset = skb_network_header(skb) - skb->data;
547 original_first_length = hoffset + ((((struct tcphdr *)skb_transport_header(skb))->doff)<<2);
549 for (wqe_count=0; wqe_count<((u32)wqes_needed); wqe_count++) {
551 nic_sqe = &nesnic->sq_vbase[nesnic->sq_head];
552 wqe_fragment_length =
553 (__le16 *)&nic_sqe->wqe_words[NES_NIC_SQ_WQE_LENGTH_0_TAG_IDX];
554 /* setup the VLAN tag if present */
555 if (vlan_tx_tag_present(skb)) {
556 nes_debug(NES_DBG_NIC_TX, "%s: VLAN packet to send... VLAN = %08X\n",
557 netdev->name, vlan_tx_tag_get(skb) );
558 wqe_misc = NES_NIC_SQ_WQE_TAGVALUE_ENABLE;
559 wqe_fragment_length[0] = (__force __le16) vlan_tx_tag_get(skb);
563 /* bump past the vlan tag */
564 wqe_fragment_length++;
566 /* Assumes header totally fits in allocated buffer and is in first fragment */
567 if (original_first_length > NES_FIRST_FRAG_SIZE) {
568 nes_debug(NES_DBG_NIC_TX, "ERROR: SKB header too big, headlen=%u, FIRST_FRAG_SIZE=%u\n",
569 original_first_length, NES_FIRST_FRAG_SIZE);
570 nes_debug(NES_DBG_NIC_TX, "%s Request to tx NIC packet length %u, headlen %u,"
571 " (%u frags), tso_size=%u\n",
573 skb->len, skb_headlen(skb),
574 skb_shinfo(skb)->nr_frags, skb_is_gso(skb));
576 memcpy(&nesnic->first_frag_vbase[nesnic->sq_head].buffer,
577 skb->data, min(((unsigned int)NES_FIRST_FRAG_SIZE),
578 original_first_length));
579 iph = (struct iphdr *)
580 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[nhoffset]);
581 tcph = (struct tcphdr *)
582 (&nesnic->first_frag_vbase[nesnic->sq_head].buffer[hoffset]);
583 if ((wqe_count+1)!=(u32)wqes_needed) {
592 tcph->seq = htonl(curr_tcp_seq);
593 wqe_fragment_length[0] = cpu_to_le16(min(((unsigned int)NES_FIRST_FRAG_SIZE),
594 original_first_length));
596 wqe_fragment_index = 1;
597 if ((wqe_count==0) && (skb_headlen(skb) > original_first_length)) {
598 set_bit(nesnic->sq_head, nesnic->first_frag_overflow);
599 bus_address = pci_map_single(nesdev->pcidev, skb->data + original_first_length,
600 skb_headlen(skb) - original_first_length, PCI_DMA_TODEVICE);
601 wqe_fragment_length[wqe_fragment_index++] =
602 cpu_to_le16(skb_headlen(skb) - original_first_length);
603 wqe_fragment_length[wqe_fragment_index] = 0;
604 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG1_LOW_IDX,
607 while (wqe_fragment_index < 5) {
608 wqe_fragment_length[wqe_fragment_index] =
609 cpu_to_le16(skb_shinfo(skb)->frags[tso_frag_index].size);
610 set_wqe_64bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_FRAG0_LOW_IDX+(2*wqe_fragment_index),
611 (u64)tso_bus_address[tso_frag_index]);
612 wqe_fragment_index++;
613 tso_wqe_length += skb_shinfo(skb)->frags[tso_frag_index++].size;
614 if (wqe_fragment_index < 5)
615 wqe_fragment_length[wqe_fragment_index] = 0;
616 if (tso_frag_index == tso_frag_count)
619 if ((wqe_count+1) == (u32)wqes_needed) {
620 nesnic->tx_skb[nesnic->sq_head] = skb;
622 nesnic->tx_skb[nesnic->sq_head] = NULL;
624 wqe_misc |= NES_NIC_SQ_WQE_COMPLETION | (u16)skb_is_gso(skb);
625 if ((tso_wqe_length + original_first_length) > skb_is_gso(skb)) {
626 wqe_misc |= NES_NIC_SQ_WQE_LSO_ENABLE;
628 iph->tot_len = htons(tso_wqe_length + original_first_length - nhoffset);
631 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_MISC_IDX,
633 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_LSO_INFO_IDX,
634 ((u32)tcph->doff) | (((u32)hoffset) << 4));
636 set_wqe_32bit_value(nic_sqe->wqe_words, NES_NIC_SQ_WQE_TOTAL_LENGTH_IDX,
637 tso_wqe_length + original_first_length);
638 curr_tcp_seq += tso_wqe_length;
640 nesnic->sq_head &= nesnic->sq_size-1;
643 nesvnic->linearized_skbs++;
644 hoffset = skb_transport_header(skb) - skb->data;
645 nhoffset = skb_network_header(skb) - skb->data;
647 skb_set_transport_header(skb, hoffset);
648 skb_set_network_header(skb, nhoffset);
649 send_rc = nes_nic_send(skb, netdev);
650 if (send_rc != NETDEV_TX_OK) {
651 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
656 send_rc = nes_nic_send(skb, netdev);
657 if (send_rc != NETDEV_TX_OK) {
658 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
666 nes_write32(nesdev->regs+NES_WQE_ALLOC,
667 (wqe_count << 24) | (1 << 23) | nesvnic->nic.qp_id);
669 netdev->trans_start = jiffies;
670 spin_unlock_irqrestore(&nesnic->sq_lock, flags);
677 * nes_netdev_get_stats
679 static struct net_device_stats *nes_netdev_get_stats(struct net_device *netdev)
681 struct nes_vnic *nesvnic = netdev_priv(netdev);
682 struct nes_device *nesdev = nesvnic->nesdev;
686 u32temp = nes_read_indexed(nesdev,
687 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD + (nesvnic->nic_index*0x200));
688 nesvnic->netstats.rx_dropped += u32temp;
689 nesvnic->endnode_nstat_rx_discard += u32temp;
691 u64temp = (u64)nes_read_indexed(nesdev,
692 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO + (nesvnic->nic_index*0x200));
693 u64temp += ((u64)nes_read_indexed(nesdev,
694 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
696 nesvnic->endnode_nstat_rx_octets += u64temp;
697 nesvnic->netstats.rx_bytes += u64temp;
699 u64temp = (u64)nes_read_indexed(nesdev,
700 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO + (nesvnic->nic_index*0x200));
701 u64temp += ((u64)nes_read_indexed(nesdev,
702 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
704 nesvnic->endnode_nstat_rx_frames += u64temp;
705 nesvnic->netstats.rx_packets += u64temp;
707 u64temp = (u64)nes_read_indexed(nesdev,
708 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO + (nesvnic->nic_index*0x200));
709 u64temp += ((u64)nes_read_indexed(nesdev,
710 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI + (nesvnic->nic_index*0x200))) << 32;
712 nesvnic->endnode_nstat_tx_octets += u64temp;
713 nesvnic->netstats.tx_bytes += u64temp;
715 u64temp = (u64)nes_read_indexed(nesdev,
716 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO + (nesvnic->nic_index*0x200));
717 u64temp += ((u64)nes_read_indexed(nesdev,
718 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI + (nesvnic->nic_index*0x200))) << 32;
720 nesvnic->endnode_nstat_tx_frames += u64temp;
721 nesvnic->netstats.tx_packets += u64temp;
723 u32temp = nes_read_indexed(nesdev,
724 NES_IDX_MAC_RX_SHORT_FRAMES + (nesvnic->nesdev->mac_index*0x200));
725 nesvnic->netstats.rx_dropped += u32temp;
726 nesvnic->nesdev->mac_rx_errors += u32temp;
727 nesvnic->nesdev->mac_rx_short_frames += u32temp;
729 u32temp = nes_read_indexed(nesdev,
730 NES_IDX_MAC_RX_OVERSIZED_FRAMES + (nesvnic->nesdev->mac_index*0x200));
731 nesvnic->netstats.rx_dropped += u32temp;
732 nesvnic->nesdev->mac_rx_errors += u32temp;
733 nesvnic->nesdev->mac_rx_oversized_frames += u32temp;
735 u32temp = nes_read_indexed(nesdev,
736 NES_IDX_MAC_RX_JABBER_FRAMES + (nesvnic->nesdev->mac_index*0x200));
737 nesvnic->netstats.rx_dropped += u32temp;
738 nesvnic->nesdev->mac_rx_errors += u32temp;
739 nesvnic->nesdev->mac_rx_jabber_frames += u32temp;
741 u32temp = nes_read_indexed(nesdev,
742 NES_IDX_MAC_RX_SYMBOL_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
743 nesvnic->netstats.rx_dropped += u32temp;
744 nesvnic->nesdev->mac_rx_errors += u32temp;
745 nesvnic->nesdev->mac_rx_symbol_err_frames += u32temp;
747 u32temp = nes_read_indexed(nesdev,
748 NES_IDX_MAC_RX_LENGTH_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
749 nesvnic->netstats.rx_length_errors += u32temp;
750 nesvnic->nesdev->mac_rx_errors += u32temp;
752 u32temp = nes_read_indexed(nesdev,
753 NES_IDX_MAC_RX_CRC_ERR_FRAMES + (nesvnic->nesdev->mac_index*0x200));
754 nesvnic->nesdev->mac_rx_errors += u32temp;
755 nesvnic->nesdev->mac_rx_crc_errors += u32temp;
756 nesvnic->netstats.rx_crc_errors += u32temp;
758 u32temp = nes_read_indexed(nesdev,
759 NES_IDX_MAC_TX_ERRORS + (nesvnic->nesdev->mac_index*0x200));
760 nesvnic->nesdev->mac_tx_errors += u32temp;
761 nesvnic->netstats.tx_errors += u32temp;
763 return &nesvnic->netstats;
768 * nes_netdev_tx_timeout
770 static void nes_netdev_tx_timeout(struct net_device *netdev)
772 struct nes_vnic *nesvnic = netdev_priv(netdev);
774 if (netif_msg_timer(nesvnic))
775 nes_debug(NES_DBG_NIC_TX, "%s: tx timeout\n", netdev->name);
780 * nes_netdev_set_mac_address
782 static int nes_netdev_set_mac_address(struct net_device *netdev, void *p)
784 struct nes_vnic *nesvnic = netdev_priv(netdev);
785 struct nes_device *nesdev = nesvnic->nesdev;
786 struct sockaddr *mac_addr = p;
790 DECLARE_MAC_BUF(mac);
792 if (!is_valid_ether_addr(mac_addr->sa_data))
793 return -EADDRNOTAVAIL;
795 memcpy(netdev->dev_addr, mac_addr->sa_data, netdev->addr_len);
796 printk(PFX "%s: Address length = %d, Address = %s\n",
797 __func__, netdev->addr_len, print_mac(mac, mac_addr->sa_data));
798 macaddr_high = ((u16)netdev->dev_addr[0]) << 8;
799 macaddr_high += (u16)netdev->dev_addr[1];
800 macaddr_low = ((u32)netdev->dev_addr[2]) << 24;
801 macaddr_low += ((u32)netdev->dev_addr[3]) << 16;
802 macaddr_low += ((u32)netdev->dev_addr[4]) << 8;
803 macaddr_low += (u32)netdev->dev_addr[5];
805 for (i = 0; i < NES_MAX_PORT_COUNT; i++) {
806 if (nesvnic->qp_nic_index[i] == 0xf) {
809 nes_write_indexed(nesdev,
810 NES_IDX_PERFECT_FILTER_LOW + (nesvnic->qp_nic_index[i] * 8),
812 nes_write_indexed(nesdev,
813 NES_IDX_PERFECT_FILTER_HIGH + (nesvnic->qp_nic_index[i] * 8),
814 (u32)macaddr_high | NES_MAC_ADDR_VALID |
815 ((((u32)nesvnic->nic_index) << 16)));
822 * nes_netdev_set_multicast_list
824 static void nes_netdev_set_multicast_list(struct net_device *netdev)
826 struct nes_vnic *nesvnic = netdev_priv(netdev);
827 struct nes_device *nesdev = nesvnic->nesdev;
828 struct dev_mc_list *multicast_addr;
831 u32 perfect_filter_register_address;
836 int mc_nic_index = -1;
838 nic_active_bit = 1 << nesvnic->nic_index;
840 if (netdev->flags & IFF_PROMISC) {
841 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
842 nic_active |= nic_active_bit;
843 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
844 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
845 nic_active |= nic_active_bit;
846 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
848 } else if ((netdev->flags & IFF_ALLMULTI) || (netdev->mc_count > NES_MULTICAST_PF_MAX) ||
849 (nesvnic->nic_index > 3)) {
850 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
851 nic_active |= nic_active_bit;
852 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
853 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
854 nic_active &= ~nic_active_bit;
855 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
858 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL);
859 nic_active &= ~nic_active_bit;
860 nes_write_indexed(nesdev, NES_IDX_NIC_MULTICAST_ALL, nic_active);
861 nic_active = nes_read_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL);
862 nic_active &= ~nic_active_bit;
863 nes_write_indexed(nesdev, NES_IDX_NIC_UNICAST_ALL, nic_active);
866 nes_debug(NES_DBG_NIC_RX, "Number of MC entries = %d, Promiscous = %d, All Multicast = %d.\n",
867 netdev->mc_count, (netdev->flags & IFF_PROMISC)?1:0,
868 (netdev->flags & IFF_ALLMULTI)?1:0);
870 multicast_addr = netdev->mc_list;
871 perfect_filter_register_address = NES_IDX_PERFECT_FILTER_LOW + 0x80;
872 perfect_filter_register_address += nesvnic->nic_index*0x40;
873 for (mc_index=0; mc_index < NES_MULTICAST_PF_MAX; mc_index++) {
874 while (multicast_addr && nesvnic->mcrq_mcast_filter && ((mc_nic_index = nesvnic->mcrq_mcast_filter(nesvnic, multicast_addr->dmi_addr)) == 0))
875 multicast_addr = multicast_addr->next;
876 if (mc_nic_index < 0)
877 mc_nic_index = nesvnic->nic_index;
878 if (multicast_addr) {
879 DECLARE_MAC_BUF(mac);
880 nes_debug(NES_DBG_NIC_RX, "Assigning MC Address %s to register 0x%04X nic_idx=%d\n",
881 print_mac(mac, multicast_addr->dmi_addr),
882 perfect_filter_register_address+(mc_index * 8),
884 macaddr_high = ((u16)multicast_addr->dmi_addr[0]) << 8;
885 macaddr_high += (u16)multicast_addr->dmi_addr[1];
886 macaddr_low = ((u32)multicast_addr->dmi_addr[2]) << 24;
887 macaddr_low += ((u32)multicast_addr->dmi_addr[3]) << 16;
888 macaddr_low += ((u32)multicast_addr->dmi_addr[4]) << 8;
889 macaddr_low += (u32)multicast_addr->dmi_addr[5];
890 nes_write_indexed(nesdev,
891 perfect_filter_register_address+(mc_index * 8),
893 nes_write_indexed(nesdev,
894 perfect_filter_register_address+4+(mc_index * 8),
895 (u32)macaddr_high | NES_MAC_ADDR_VALID |
896 ((((u32)(1<<mc_nic_index)) << 16)));
897 multicast_addr = multicast_addr->next;
899 nes_debug(NES_DBG_NIC_RX, "Clearing MC Address at register 0x%04X\n",
900 perfect_filter_register_address+(mc_index * 8));
901 nes_write_indexed(nesdev,
902 perfect_filter_register_address+4+(mc_index * 8),
911 * nes_netdev_change_mtu
913 static int nes_netdev_change_mtu(struct net_device *netdev, int new_mtu)
915 struct nes_vnic *nesvnic = netdev_priv(netdev);
916 struct nes_device *nesdev = nesvnic->nesdev;
920 if ((new_mtu < ETH_ZLEN) || (new_mtu > max_mtu))
923 netdev->mtu = new_mtu;
924 nesvnic->max_frame_size = new_mtu + VLAN_ETH_HLEN;
926 if (netdev->mtu > 1500) {
929 nes_nic_init_timer_defaults(nesdev, jumbomode);
931 if (netif_running(netdev)) {
932 nes_netdev_stop(netdev);
933 nes_netdev_open(netdev);
939 static const char nes_ethtool_stringset[][ETH_GSTRING_LEN] = {
940 "Link Change Interrupts",
944 "Pause Frames Received",
945 "Internal Routing Errors",
946 "SQ SW Dropped SKBs",
949 "Segmented TSO Requests",
952 "Rx Oversized Frames",
954 "Endnode Rx Discards",
961 "Retransmission Count",
974 "CM Packets Bounced",
975 "CM Packets Created",
977 "CM Packets Dropped",
978 "CM Packets Retrans",
979 "CM Listens Created",
980 "CM Listens Destroyed",
984 "CM Nodes Destroyed",
986 "CM Resets Received",
1000 #define NES_ETHTOOL_STAT_COUNT ARRAY_SIZE(nes_ethtool_stringset)
1003 * nes_netdev_get_rx_csum
1005 static u32 nes_netdev_get_rx_csum (struct net_device *netdev)
1007 struct nes_vnic *nesvnic = netdev_priv(netdev);
1009 if (nesvnic->rx_checksum_disabled)
1017 * nes_netdev_set_rc_csum
1019 static int nes_netdev_set_rx_csum(struct net_device *netdev, u32 enable)
1021 struct nes_vnic *nesvnic = netdev_priv(netdev);
1024 nesvnic->rx_checksum_disabled = 0;
1026 nesvnic->rx_checksum_disabled = 1;
1032 * nes_netdev_get_stats_count
1034 static int nes_netdev_get_stats_count(struct net_device *netdev)
1036 return NES_ETHTOOL_STAT_COUNT;
1041 * nes_netdev_get_strings
1043 static void nes_netdev_get_strings(struct net_device *netdev, u32 stringset,
1044 u8 *ethtool_strings)
1046 if (stringset == ETH_SS_STATS)
1047 memcpy(ethtool_strings,
1048 &nes_ethtool_stringset,
1049 sizeof(nes_ethtool_stringset));
1054 * nes_netdev_get_ethtool_stats
1056 static void nes_netdev_get_ethtool_stats(struct net_device *netdev,
1057 struct ethtool_stats *target_ethtool_stats, u64 *target_stat_values)
1060 struct nes_vnic *nesvnic = netdev_priv(netdev);
1061 struct nes_device *nesdev = nesvnic->nesdev;
1065 target_ethtool_stats->n_stats = NES_ETHTOOL_STAT_COUNT;
1066 target_stat_values[0] = nesvnic->nesdev->link_status_interrupts;
1067 target_stat_values[1] = nesvnic->linearized_skbs;
1068 target_stat_values[2] = nesvnic->tso_requests;
1070 u32temp = nes_read_indexed(nesdev,
1071 NES_IDX_MAC_TX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1072 nesvnic->nesdev->mac_pause_frames_sent += u32temp;
1073 target_stat_values[3] = nesvnic->nesdev->mac_pause_frames_sent;
1075 u32temp = nes_read_indexed(nesdev,
1076 NES_IDX_MAC_RX_PAUSE_FRAMES + (nesvnic->nesdev->mac_index*0x200));
1077 nesvnic->nesdev->mac_pause_frames_received += u32temp;
1079 u32temp = nes_read_indexed(nesdev,
1080 NES_IDX_PORT_RX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1081 nesvnic->nesdev->port_rx_discards += u32temp;
1082 nesvnic->netstats.rx_dropped += u32temp;
1084 u32temp = nes_read_indexed(nesdev,
1085 NES_IDX_PORT_TX_DISCARDS + (nesvnic->nesdev->mac_index*0x40));
1086 nesvnic->nesdev->port_tx_discards += u32temp;
1087 nesvnic->netstats.tx_dropped += u32temp;
1089 for (nic_count = 0; nic_count < NES_MAX_PORT_COUNT; nic_count++) {
1090 if (nesvnic->qp_nic_index[nic_count] == 0xf)
1093 u32temp = nes_read_indexed(nesdev,
1094 NES_IDX_ENDNODE0_NSTAT_RX_DISCARD +
1095 (nesvnic->qp_nic_index[nic_count]*0x200));
1096 nesvnic->netstats.rx_dropped += u32temp;
1097 nesvnic->endnode_nstat_rx_discard += u32temp;
1099 u64temp = (u64)nes_read_indexed(nesdev,
1100 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_LO +
1101 (nesvnic->qp_nic_index[nic_count]*0x200));
1102 u64temp += ((u64)nes_read_indexed(nesdev,
1103 NES_IDX_ENDNODE0_NSTAT_RX_OCTETS_HI +
1104 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1106 nesvnic->endnode_nstat_rx_octets += u64temp;
1107 nesvnic->netstats.rx_bytes += u64temp;
1109 u64temp = (u64)nes_read_indexed(nesdev,
1110 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_LO +
1111 (nesvnic->qp_nic_index[nic_count]*0x200));
1112 u64temp += ((u64)nes_read_indexed(nesdev,
1113 NES_IDX_ENDNODE0_NSTAT_RX_FRAMES_HI +
1114 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1116 nesvnic->endnode_nstat_rx_frames += u64temp;
1117 nesvnic->netstats.rx_packets += u64temp;
1119 u64temp = (u64)nes_read_indexed(nesdev,
1120 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_LO +
1121 (nesvnic->qp_nic_index[nic_count]*0x200));
1122 u64temp += ((u64)nes_read_indexed(nesdev,
1123 NES_IDX_ENDNODE0_NSTAT_TX_OCTETS_HI +
1124 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1126 nesvnic->endnode_nstat_tx_octets += u64temp;
1127 nesvnic->netstats.tx_bytes += u64temp;
1129 u64temp = (u64)nes_read_indexed(nesdev,
1130 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_LO +
1131 (nesvnic->qp_nic_index[nic_count]*0x200));
1132 u64temp += ((u64)nes_read_indexed(nesdev,
1133 NES_IDX_ENDNODE0_NSTAT_TX_FRAMES_HI +
1134 (nesvnic->qp_nic_index[nic_count]*0x200))) << 32;
1136 nesvnic->endnode_nstat_tx_frames += u64temp;
1137 nesvnic->netstats.tx_packets += u64temp;
1139 u32temp = nes_read_indexed(nesdev,
1140 NES_IDX_IPV4_TCP_REXMITS + (nesvnic->qp_nic_index[nic_count]*0x200));
1141 nesvnic->endnode_ipv4_tcp_retransmits += u32temp;
1144 target_stat_values[4] = nesvnic->nesdev->mac_pause_frames_received;
1145 target_stat_values[5] = nesdev->nesadapter->nic_rx_eth_route_err;
1146 target_stat_values[6] = nesvnic->tx_sw_dropped;
1147 target_stat_values[7] = nesvnic->sq_locked;
1148 target_stat_values[8] = nesvnic->sq_full;
1149 target_stat_values[9] = nesvnic->segmented_tso_requests;
1150 target_stat_values[10] = nesvnic->nesdev->mac_rx_symbol_err_frames;
1151 target_stat_values[11] = nesvnic->nesdev->mac_rx_jabber_frames;
1152 target_stat_values[12] = nesvnic->nesdev->mac_rx_oversized_frames;
1153 target_stat_values[13] = nesvnic->nesdev->mac_rx_short_frames;
1154 target_stat_values[14] = nesvnic->endnode_nstat_rx_discard;
1155 target_stat_values[15] = nesvnic->endnode_nstat_rx_octets;
1156 target_stat_values[16] = nesvnic->endnode_nstat_rx_frames;
1157 target_stat_values[17] = nesvnic->endnode_nstat_tx_octets;
1158 target_stat_values[18] = nesvnic->endnode_nstat_tx_frames;
1159 target_stat_values[19] = mh_detected;
1160 target_stat_values[20] = mh_pauses_sent;
1161 target_stat_values[21] = nesvnic->endnode_ipv4_tcp_retransmits;
1162 target_stat_values[22] = atomic_read(&cm_connects);
1163 target_stat_values[23] = atomic_read(&cm_accepts);
1164 target_stat_values[24] = atomic_read(&cm_disconnects);
1165 target_stat_values[25] = atomic_read(&cm_connecteds);
1166 target_stat_values[26] = atomic_read(&cm_connect_reqs);
1167 target_stat_values[27] = atomic_read(&cm_rejects);
1168 target_stat_values[28] = atomic_read(&mod_qp_timouts);
1169 target_stat_values[29] = atomic_read(&qps_created);
1170 target_stat_values[30] = atomic_read(&sw_qps_destroyed);
1171 target_stat_values[31] = atomic_read(&qps_destroyed);
1172 target_stat_values[32] = atomic_read(&cm_closes);
1173 target_stat_values[33] = cm_packets_sent;
1174 target_stat_values[34] = cm_packets_bounced;
1175 target_stat_values[35] = cm_packets_created;
1176 target_stat_values[36] = cm_packets_received;
1177 target_stat_values[37] = cm_packets_dropped;
1178 target_stat_values[38] = cm_packets_retrans;
1179 target_stat_values[39] = cm_listens_created;
1180 target_stat_values[40] = cm_listens_destroyed;
1181 target_stat_values[41] = cm_backlog_drops;
1182 target_stat_values[42] = atomic_read(&cm_loopbacks);
1183 target_stat_values[43] = atomic_read(&cm_nodes_created);
1184 target_stat_values[44] = atomic_read(&cm_nodes_destroyed);
1185 target_stat_values[45] = atomic_read(&cm_accel_dropped_pkts);
1186 target_stat_values[46] = atomic_read(&cm_resets_recvd);
1187 target_stat_values[47] = int_mod_timer_init;
1188 target_stat_values[48] = int_mod_cq_depth_1;
1189 target_stat_values[49] = int_mod_cq_depth_4;
1190 target_stat_values[50] = int_mod_cq_depth_16;
1191 target_stat_values[51] = int_mod_cq_depth_24;
1192 target_stat_values[52] = int_mod_cq_depth_32;
1193 target_stat_values[53] = int_mod_cq_depth_128;
1194 target_stat_values[54] = int_mod_cq_depth_256;
1195 target_stat_values[55] = nesvnic->lro_mgr.stats.aggregated;
1196 target_stat_values[56] = nesvnic->lro_mgr.stats.flushed;
1197 target_stat_values[57] = nesvnic->lro_mgr.stats.no_desc;
1203 * nes_netdev_get_drvinfo
1205 static void nes_netdev_get_drvinfo(struct net_device *netdev,
1206 struct ethtool_drvinfo *drvinfo)
1208 struct nes_vnic *nesvnic = netdev_priv(netdev);
1210 strcpy(drvinfo->driver, DRV_NAME);
1211 strcpy(drvinfo->bus_info, pci_name(nesvnic->nesdev->pcidev));
1212 strcpy(drvinfo->fw_version, "TBD");
1213 strcpy(drvinfo->version, DRV_VERSION);
1214 drvinfo->n_stats = nes_netdev_get_stats_count(netdev);
1215 drvinfo->testinfo_len = 0;
1216 drvinfo->eedump_len = 0;
1217 drvinfo->regdump_len = 0;
1222 * nes_netdev_set_coalesce
1224 static int nes_netdev_set_coalesce(struct net_device *netdev,
1225 struct ethtool_coalesce *et_coalesce)
1227 struct nes_vnic *nesvnic = netdev_priv(netdev);
1228 struct nes_device *nesdev = nesvnic->nesdev;
1229 struct nes_adapter *nesadapter = nesdev->nesadapter;
1230 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1231 unsigned long flags;
1233 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1234 if (et_coalesce->rx_max_coalesced_frames_low) {
1235 shared_timer->threshold_low = et_coalesce->rx_max_coalesced_frames_low;
1237 if (et_coalesce->rx_max_coalesced_frames_irq) {
1238 shared_timer->threshold_target = et_coalesce->rx_max_coalesced_frames_irq;
1240 if (et_coalesce->rx_max_coalesced_frames_high) {
1241 shared_timer->threshold_high = et_coalesce->rx_max_coalesced_frames_high;
1243 if (et_coalesce->rx_coalesce_usecs_low) {
1244 shared_timer->timer_in_use_min = et_coalesce->rx_coalesce_usecs_low;
1246 if (et_coalesce->rx_coalesce_usecs_high) {
1247 shared_timer->timer_in_use_max = et_coalesce->rx_coalesce_usecs_high;
1249 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1251 /* using this to drive total interrupt moderation */
1252 nesadapter->et_rx_coalesce_usecs_irq = et_coalesce->rx_coalesce_usecs_irq;
1253 if (et_coalesce->use_adaptive_rx_coalesce) {
1254 nesadapter->et_use_adaptive_rx_coalesce = 1;
1255 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT_DYNAMIC;
1256 nesadapter->et_rx_coalesce_usecs_irq = 0;
1257 if (et_coalesce->pkt_rate_low) {
1258 nesadapter->et_pkt_rate_low = et_coalesce->pkt_rate_low;
1261 nesadapter->et_use_adaptive_rx_coalesce = 0;
1262 nesadapter->timer_int_limit = NES_TIMER_INT_LIMIT;
1263 if (nesadapter->et_rx_coalesce_usecs_irq) {
1264 nes_write32(nesdev->regs+NES_PERIODIC_CONTROL,
1265 0x80000000 | ((u32)(nesadapter->et_rx_coalesce_usecs_irq*8)));
1273 * nes_netdev_get_coalesce
1275 static int nes_netdev_get_coalesce(struct net_device *netdev,
1276 struct ethtool_coalesce *et_coalesce)
1278 struct nes_vnic *nesvnic = netdev_priv(netdev);
1279 struct nes_device *nesdev = nesvnic->nesdev;
1280 struct nes_adapter *nesadapter = nesdev->nesadapter;
1281 struct ethtool_coalesce temp_et_coalesce;
1282 struct nes_hw_tune_timer *shared_timer = &nesadapter->tune_timer;
1283 unsigned long flags;
1285 memset(&temp_et_coalesce, 0, sizeof(temp_et_coalesce));
1286 temp_et_coalesce.rx_coalesce_usecs_irq = nesadapter->et_rx_coalesce_usecs_irq;
1287 temp_et_coalesce.use_adaptive_rx_coalesce = nesadapter->et_use_adaptive_rx_coalesce;
1288 temp_et_coalesce.rate_sample_interval = nesadapter->et_rate_sample_interval;
1289 temp_et_coalesce.pkt_rate_low = nesadapter->et_pkt_rate_low;
1290 spin_lock_irqsave(&nesadapter->periodic_timer_lock, flags);
1291 temp_et_coalesce.rx_max_coalesced_frames_low = shared_timer->threshold_low;
1292 temp_et_coalesce.rx_max_coalesced_frames_irq = shared_timer->threshold_target;
1293 temp_et_coalesce.rx_max_coalesced_frames_high = shared_timer->threshold_high;
1294 temp_et_coalesce.rx_coalesce_usecs_low = shared_timer->timer_in_use_min;
1295 temp_et_coalesce.rx_coalesce_usecs_high = shared_timer->timer_in_use_max;
1296 if (nesadapter->et_use_adaptive_rx_coalesce) {
1297 temp_et_coalesce.rx_coalesce_usecs_irq = shared_timer->timer_in_use;
1299 spin_unlock_irqrestore(&nesadapter->periodic_timer_lock, flags);
1300 memcpy(et_coalesce, &temp_et_coalesce, sizeof(*et_coalesce));
1306 * nes_netdev_get_pauseparam
1308 static void nes_netdev_get_pauseparam(struct net_device *netdev,
1309 struct ethtool_pauseparam *et_pauseparam)
1311 struct nes_vnic *nesvnic = netdev_priv(netdev);
1313 et_pauseparam->autoneg = 0;
1314 et_pauseparam->rx_pause = (nesvnic->nesdev->disable_rx_flow_control == 0) ? 1:0;
1315 et_pauseparam->tx_pause = (nesvnic->nesdev->disable_tx_flow_control == 0) ? 1:0;
1320 * nes_netdev_set_pauseparam
1322 static int nes_netdev_set_pauseparam(struct net_device *netdev,
1323 struct ethtool_pauseparam *et_pauseparam)
1325 struct nes_vnic *nesvnic = netdev_priv(netdev);
1326 struct nes_device *nesdev = nesvnic->nesdev;
1329 if (et_pauseparam->autoneg) {
1330 /* TODO: should return unsupported */
1333 if ((et_pauseparam->tx_pause == 1) && (nesdev->disable_tx_flow_control == 1)) {
1334 u32temp = nes_read_indexed(nesdev,
1335 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1336 u32temp |= NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1337 nes_write_indexed(nesdev,
1338 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1339 nesdev->disable_tx_flow_control = 0;
1340 } else if ((et_pauseparam->tx_pause == 0) && (nesdev->disable_tx_flow_control == 0)) {
1341 u32temp = nes_read_indexed(nesdev,
1342 NES_IDX_MAC_TX_CONFIG + (nesdev->mac_index*0x200));
1343 u32temp &= ~NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE;
1344 nes_write_indexed(nesdev,
1345 NES_IDX_MAC_TX_CONFIG_ENABLE_PAUSE + (nesdev->mac_index*0x200), u32temp);
1346 nesdev->disable_tx_flow_control = 1;
1348 if ((et_pauseparam->rx_pause == 1) && (nesdev->disable_rx_flow_control == 1)) {
1349 u32temp = nes_read_indexed(nesdev,
1350 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1351 u32temp &= ~NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1352 nes_write_indexed(nesdev,
1353 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1354 nesdev->disable_rx_flow_control = 0;
1355 } else if ((et_pauseparam->rx_pause == 0) && (nesdev->disable_rx_flow_control == 0)) {
1356 u32temp = nes_read_indexed(nesdev,
1357 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40));
1358 u32temp |= NES_IDX_MPP_DEBUG_PORT_DISABLE_PAUSE;
1359 nes_write_indexed(nesdev,
1360 NES_IDX_MPP_DEBUG + (nesdev->mac_index*0x40), u32temp);
1361 nesdev->disable_rx_flow_control = 1;
1369 * nes_netdev_get_settings
1371 static int nes_netdev_get_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1373 struct nes_vnic *nesvnic = netdev_priv(netdev);
1374 struct nes_device *nesdev = nesvnic->nesdev;
1375 struct nes_adapter *nesadapter = nesdev->nesadapter;
1378 et_cmd->duplex = DUPLEX_FULL;
1379 et_cmd->port = PORT_MII;
1381 if (nesadapter->OneG_Mode) {
1382 et_cmd->speed = SPEED_1000;
1383 if (nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_PUMA_1G) {
1384 et_cmd->supported = SUPPORTED_1000baseT_Full;
1385 et_cmd->advertising = ADVERTISED_1000baseT_Full;
1386 et_cmd->autoneg = AUTONEG_DISABLE;
1387 et_cmd->transceiver = XCVR_INTERNAL;
1388 et_cmd->phy_address = nesdev->mac_index;
1390 et_cmd->supported = SUPPORTED_1000baseT_Full | SUPPORTED_Autoneg;
1391 et_cmd->advertising = ADVERTISED_1000baseT_Full | ADVERTISED_Autoneg;
1392 nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index], &phy_data);
1393 if (phy_data & 0x1000)
1394 et_cmd->autoneg = AUTONEG_ENABLE;
1396 et_cmd->autoneg = AUTONEG_DISABLE;
1397 et_cmd->transceiver = XCVR_EXTERNAL;
1398 et_cmd->phy_address = nesadapter->phy_index[nesdev->mac_index];
1401 if ((nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_IRIS) ||
1402 (nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_ARGUS)) {
1403 et_cmd->transceiver = XCVR_EXTERNAL;
1404 et_cmd->port = PORT_FIBRE;
1405 et_cmd->supported = SUPPORTED_FIBRE;
1406 et_cmd->advertising = ADVERTISED_FIBRE;
1407 et_cmd->phy_address = nesadapter->phy_index[nesdev->mac_index];
1409 et_cmd->transceiver = XCVR_INTERNAL;
1410 et_cmd->supported = SUPPORTED_10000baseT_Full;
1411 et_cmd->advertising = ADVERTISED_10000baseT_Full;
1412 et_cmd->phy_address = nesdev->mac_index;
1414 et_cmd->speed = SPEED_10000;
1415 et_cmd->autoneg = AUTONEG_DISABLE;
1417 et_cmd->maxtxpkt = 511;
1418 et_cmd->maxrxpkt = 511;
1424 * nes_netdev_set_settings
1426 static int nes_netdev_set_settings(struct net_device *netdev, struct ethtool_cmd *et_cmd)
1428 struct nes_vnic *nesvnic = netdev_priv(netdev);
1429 struct nes_device *nesdev = nesvnic->nesdev;
1430 struct nes_adapter *nesadapter = nesdev->nesadapter;
1433 if ((nesadapter->OneG_Mode) &&
1434 (nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G)) {
1435 nes_read_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1437 if (et_cmd->autoneg) {
1438 /* Turn on Full duplex, Autoneg, and restart autonegotiation */
1442 phy_data &= ~0x1000;
1444 nes_write_1G_phy_reg(nesdev, 0, nesadapter->phy_index[nesdev->mac_index],
1452 static struct ethtool_ops nes_ethtool_ops = {
1453 .get_link = ethtool_op_get_link,
1454 .get_settings = nes_netdev_get_settings,
1455 .set_settings = nes_netdev_set_settings,
1456 .get_tx_csum = ethtool_op_get_tx_csum,
1457 .get_rx_csum = nes_netdev_get_rx_csum,
1458 .get_sg = ethtool_op_get_sg,
1459 .get_strings = nes_netdev_get_strings,
1460 .get_stats_count = nes_netdev_get_stats_count,
1461 .get_ethtool_stats = nes_netdev_get_ethtool_stats,
1462 .get_drvinfo = nes_netdev_get_drvinfo,
1463 .get_coalesce = nes_netdev_get_coalesce,
1464 .set_coalesce = nes_netdev_set_coalesce,
1465 .get_pauseparam = nes_netdev_get_pauseparam,
1466 .set_pauseparam = nes_netdev_set_pauseparam,
1467 .set_tx_csum = ethtool_op_set_tx_csum,
1468 .set_rx_csum = nes_netdev_set_rx_csum,
1469 .set_sg = ethtool_op_set_sg,
1470 .get_tso = ethtool_op_get_tso,
1471 .set_tso = ethtool_op_set_tso,
1472 .get_flags = ethtool_op_get_flags,
1473 .set_flags = ethtool_op_set_flags,
1477 static void nes_netdev_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
1479 struct nes_vnic *nesvnic = netdev_priv(netdev);
1480 struct nes_device *nesdev = nesvnic->nesdev;
1481 struct nes_adapter *nesadapter = nesdev->nesadapter;
1483 unsigned long flags;
1485 spin_lock_irqsave(&nesadapter->phy_lock, flags);
1486 nesvnic->vlan_grp = grp;
1488 nes_debug(NES_DBG_NETDEV, "%s: %s\n", __func__, netdev->name);
1490 /* Enable/Disable VLAN Stripping */
1491 u32temp = nes_read_indexed(nesdev, NES_IDX_PCIX_DIAG);
1493 u32temp &= 0xfdffffff;
1495 u32temp |= 0x02000000;
1497 nes_write_indexed(nesdev, NES_IDX_PCIX_DIAG, u32temp);
1498 spin_unlock_irqrestore(&nesadapter->phy_lock, flags);
1503 * nes_netdev_init - initialize network device
1505 struct net_device *nes_netdev_init(struct nes_device *nesdev,
1506 void __iomem *mmio_addr)
1509 struct nes_vnic *nesvnic = NULL;
1510 struct net_device *netdev;
1511 struct nic_qp_map *curr_qp_map;
1516 netdev = alloc_etherdev(sizeof(struct nes_vnic));
1518 printk(KERN_ERR PFX "nesvnic etherdev alloc failed");
1522 nes_debug(NES_DBG_INIT, "netdev = %p, %s\n", netdev, netdev->name);
1524 SET_NETDEV_DEV(netdev, &nesdev->pcidev->dev);
1526 nesvnic = netdev_priv(netdev);
1527 memset(nesvnic, 0, sizeof(*nesvnic));
1529 netdev->open = nes_netdev_open;
1530 netdev->stop = nes_netdev_stop;
1531 netdev->hard_start_xmit = nes_netdev_start_xmit;
1532 netdev->get_stats = nes_netdev_get_stats;
1533 netdev->tx_timeout = nes_netdev_tx_timeout;
1534 netdev->set_mac_address = nes_netdev_set_mac_address;
1535 netdev->set_multicast_list = nes_netdev_set_multicast_list;
1536 netdev->change_mtu = nes_netdev_change_mtu;
1537 netdev->watchdog_timeo = NES_TX_TIMEOUT;
1538 netdev->irq = nesdev->pcidev->irq;
1539 netdev->mtu = ETH_DATA_LEN;
1540 netdev->hard_header_len = ETH_HLEN;
1541 netdev->addr_len = ETH_ALEN;
1542 netdev->type = ARPHRD_ETHER;
1543 netdev->features = NETIF_F_HIGHDMA;
1544 netdev->ethtool_ops = &nes_ethtool_ops;
1545 netif_napi_add(netdev, &nesvnic->napi, nes_netdev_poll, 128);
1546 nes_debug(NES_DBG_INIT, "Enabling VLAN Insert/Delete.\n");
1547 netdev->features |= NETIF_F_HW_VLAN_TX | NETIF_F_HW_VLAN_RX;
1548 netdev->vlan_rx_register = nes_netdev_vlan_rx_register;
1549 netdev->features |= NETIF_F_LLTX;
1551 /* Fill in the port structure */
1552 nesvnic->netdev = netdev;
1553 nesvnic->nesdev = nesdev;
1554 nesvnic->msg_enable = netif_msg_init(debug, default_msg);
1555 nesvnic->netdev_index = nesdev->netdev_count;
1556 nesvnic->perfect_filter_index = nesdev->nesadapter->netdev_count;
1557 nesvnic->max_frame_size = netdev->mtu + netdev->hard_header_len + VLAN_HLEN;
1559 curr_qp_map = nic_qp_mapping_per_function[PCI_FUNC(nesdev->pcidev->devfn)];
1560 nesvnic->nic.qp_id = curr_qp_map[nesdev->netdev_count].qpid;
1561 nesvnic->nic_index = curr_qp_map[nesdev->netdev_count].nic_index;
1562 nesvnic->logical_port = curr_qp_map[nesdev->netdev_count].logical_port;
1564 /* Setup the burned in MAC address */
1565 u64temp = (u64)nesdev->nesadapter->mac_addr_low;
1566 u64temp += ((u64)nesdev->nesadapter->mac_addr_high) << 32;
1567 u64temp += nesvnic->nic_index;
1568 netdev->dev_addr[0] = (u8)(u64temp>>40);
1569 netdev->dev_addr[1] = (u8)(u64temp>>32);
1570 netdev->dev_addr[2] = (u8)(u64temp>>24);
1571 netdev->dev_addr[3] = (u8)(u64temp>>16);
1572 netdev->dev_addr[4] = (u8)(u64temp>>8);
1573 netdev->dev_addr[5] = (u8)u64temp;
1574 memcpy(netdev->perm_addr, netdev->dev_addr, 6);
1576 if ((nesvnic->logical_port < 2) || (nesdev->nesadapter->hw_rev != NE020_REV)) {
1577 netdev->features |= NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1578 netdev->features |= NETIF_F_GSO | NETIF_F_TSO | NETIF_F_SG | NETIF_F_IP_CSUM;
1580 netdev->features |= NETIF_F_SG | NETIF_F_IP_CSUM;
1583 nes_debug(NES_DBG_INIT, "nesvnic = %p, reported features = 0x%lX, QPid = %d,"
1584 " nic_index = %d, logical_port = %d, mac_index = %d.\n",
1585 nesvnic, (unsigned long)netdev->features, nesvnic->nic.qp_id,
1586 nesvnic->nic_index, nesvnic->logical_port, nesdev->mac_index);
1588 if (nesvnic->nesdev->nesadapter->port_count == 1) {
1589 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1590 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 1;
1591 if (nes_drv_opt & NES_DRV_OPT_DUAL_LOGICAL_PORT) {
1592 nesvnic->qp_nic_index[2] = 0xf;
1593 nesvnic->qp_nic_index[3] = 0xf;
1595 nesvnic->qp_nic_index[2] = nesvnic->nic_index + 2;
1596 nesvnic->qp_nic_index[3] = nesvnic->nic_index + 3;
1599 if (nesvnic->nesdev->nesadapter->port_count == 2) {
1600 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1601 nesvnic->qp_nic_index[1] = nesvnic->nic_index + 2;
1602 nesvnic->qp_nic_index[2] = 0xf;
1603 nesvnic->qp_nic_index[3] = 0xf;
1605 nesvnic->qp_nic_index[0] = nesvnic->nic_index;
1606 nesvnic->qp_nic_index[1] = 0xf;
1607 nesvnic->qp_nic_index[2] = 0xf;
1608 nesvnic->qp_nic_index[3] = 0xf;
1611 nesvnic->next_qp_nic_index = 0;
1613 if (nesdev->netdev_count == 0) {
1614 nesvnic->rdma_enabled = 1;
1616 nesvnic->rdma_enabled = 0;
1618 nesvnic->nic_cq.cq_number = nesvnic->nic.qp_id;
1619 spin_lock_init(&nesvnic->tx_lock);
1620 nesdev->netdev[nesdev->netdev_count] = netdev;
1622 nes_debug(NES_DBG_INIT, "Adding nesvnic (%p) to the adapters nesvnic_list for MAC%d.\n",
1623 nesvnic, nesdev->mac_index);
1624 list_add_tail(&nesvnic->list, &nesdev->nesadapter->nesvnic_list[nesdev->mac_index]);
1626 if ((nesdev->netdev_count == 0) &&
1627 ((PCI_FUNC(nesdev->pcidev->devfn) == nesdev->mac_index) ||
1628 ((nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_PUMA_1G) &&
1629 (((PCI_FUNC(nesdev->pcidev->devfn) == 1) && (nesdev->mac_index == 2)) ||
1630 ((PCI_FUNC(nesdev->pcidev->devfn) == 2) && (nesdev->mac_index == 1)))))) {
1632 * nes_debug(NES_DBG_INIT, "Setting up PHY interrupt mask. Using register index 0x%04X\n",
1633 * NES_IDX_PHY_PCS_CONTROL_STATUS0 + (0x200 * (nesvnic->logical_port & 1)));
1635 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1636 (0x200 * (nesdev->mac_index & 1)));
1637 if (nesdev->nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_PUMA_1G) {
1638 u32temp |= 0x00200000;
1639 nes_write_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1640 (0x200 * (nesdev->mac_index & 1)), u32temp);
1643 u32temp = nes_read_indexed(nesdev, NES_IDX_PHY_PCS_CONTROL_STATUS0 +
1644 (0x200 * (nesdev->mac_index & 1)));
1646 if ((u32temp&0x0f1f0000) == 0x0f0f0000) {
1647 if (nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_IRIS) {
1648 nes_init_phy(nesdev);
1649 nes_read_10G_phy_reg(nesdev, nesdev->nesadapter->phy_index[nesdev->mac_index], 1, 1);
1650 temp_phy_data = (u16)nes_read_indexed(nesdev,
1651 NES_IDX_MAC_MDIO_CONTROL);
1654 nes_read_10G_phy_reg(nesdev, nesdev->nesadapter->phy_index[nesdev->mac_index], 1, 1);
1655 phy_data = (u16)nes_read_indexed(nesdev,
1656 NES_IDX_MAC_MDIO_CONTROL);
1657 if ((phy_data == temp_phy_data) || (!(--u32temp)))
1659 temp_phy_data = phy_data;
1662 nes_debug(NES_DBG_INIT, "The Link is UP!!.\n");
1663 nesvnic->linkup = 1;
1665 nes_debug(NES_DBG_INIT, "The Link is DOWN!!.\n");
1668 nes_debug(NES_DBG_INIT, "The Link is UP!!.\n");
1669 nesvnic->linkup = 1;
1671 } else if (nesdev->nesadapter->phy_type[nesdev->mac_index] == NES_PHY_TYPE_PUMA_1G) {
1672 nes_debug(NES_DBG_INIT, "mac_index=%d, logical_port=%d, u32temp=0x%04X, PCI_FUNC=%d\n",
1673 nesdev->mac_index, nesvnic->logical_port, u32temp, PCI_FUNC(nesdev->pcidev->devfn));
1674 if (((nesdev->mac_index < 2) && ((u32temp&0x01010000) == 0x01010000)) ||
1675 ((nesdev->mac_index > 1) && ((u32temp&0x02020000) == 0x02020000))) {
1676 nes_debug(NES_DBG_INIT, "The Link is UP!!.\n");
1677 nesvnic->linkup = 1;
1680 /* clear the MAC interrupt status, assumes direct logical to physical mapping */
1681 u32temp = nes_read_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index));
1682 nes_debug(NES_DBG_INIT, "Phy interrupt status = 0x%X.\n", u32temp);
1683 nes_write_indexed(nesdev, NES_IDX_MAC_INT_STATUS + (0x200 * nesdev->mac_index), u32temp);
1685 if (nesdev->nesadapter->phy_type[nesdev->mac_index] != NES_PHY_TYPE_IRIS)
1686 nes_init_phy(nesdev);
1695 * nes_netdev_destroy - destroy network device structure
1697 void nes_netdev_destroy(struct net_device *netdev)
1699 struct nes_vnic *nesvnic = netdev_priv(netdev);
1701 /* make sure 'stop' method is called by Linux stack */
1702 /* nes_netdev_stop(netdev); */
1704 list_del(&nesvnic->list);
1706 if (nesvnic->of_device_registered) {
1707 nes_destroy_ofa_device(nesvnic->nesibdev);
1710 free_netdev(netdev);
1715 * nes_nic_cm_xmit -- CM calls this to send out pkts
1717 int nes_nic_cm_xmit(struct sk_buff *skb, struct net_device *netdev)
1722 ret = dev_queue_xmit(skb);
1724 nes_debug(NES_DBG_CM, "Bad return code from dev_queue_xmit %d\n", ret);