2 * linux/drivers/net/ehea/ehea_main.c
4 * eHEA ethernet device driver for IBM eServer System p
6 * (C) Copyright IBM Corp. 2006
9 * Christoph Raisch <raisch@de.ibm.com>
10 * Jan-Bernd Themann <themann@de.ibm.com>
11 * Thomas Klein <tklein@de.ibm.com>
14 * This program is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2, or (at your option)
19 * This program is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
24 * You should have received a copy of the GNU General Public License
25 * along with this program; if not, write to the Free Software
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
31 #include <linux/tcp.h>
32 #include <linux/udp.h>
34 #include <linux/list.h>
35 #include <linux/if_ether.h>
40 #include "ehea_phyp.h"
43 MODULE_LICENSE("GPL");
44 MODULE_AUTHOR("Christoph Raisch <raisch@de.ibm.com>");
45 MODULE_DESCRIPTION("IBM eServer HEA Driver");
46 MODULE_VERSION(DRV_VERSION
);
49 static int msg_level
= -1;
50 static int rq1_entries
= EHEA_DEF_ENTRIES_RQ1
;
51 static int rq2_entries
= EHEA_DEF_ENTRIES_RQ2
;
52 static int rq3_entries
= EHEA_DEF_ENTRIES_RQ3
;
53 static int sq_entries
= EHEA_DEF_ENTRIES_SQ
;
55 module_param(msg_level
, int, 0);
56 module_param(rq1_entries
, int, 0);
57 module_param(rq2_entries
, int, 0);
58 module_param(rq3_entries
, int, 0);
59 module_param(sq_entries
, int, 0);
61 MODULE_PARM_DESC(msg_level
, "msg_level");
62 MODULE_PARM_DESC(rq3_entries
, "Number of entries for Receive Queue 3 "
63 "[2^x - 1], x = [6..14]. Default = "
64 __MODULE_STRING(EHEA_DEF_ENTRIES_RQ3
) ")");
65 MODULE_PARM_DESC(rq2_entries
, "Number of entries for Receive Queue 2 "
66 "[2^x - 1], x = [6..14]. Default = "
67 __MODULE_STRING(EHEA_DEF_ENTRIES_RQ2
) ")");
68 MODULE_PARM_DESC(rq1_entries
, "Number of entries for Receive Queue 1 "
69 "[2^x - 1], x = [6..14]. Default = "
70 __MODULE_STRING(EHEA_DEF_ENTRIES_RQ1
) ")");
71 MODULE_PARM_DESC(sq_entries
, " Number of entries for the Send Queue "
72 "[2^x - 1], x = [6..14]. Default = "
73 __MODULE_STRING(EHEA_DEF_ENTRIES_SQ
) ")");
75 void ehea_dump(void *adr
, int len
, char *msg
) {
77 unsigned char *deb
= adr
;
78 for (x
= 0; x
< len
; x
+= 16) {
79 printk(DRV_NAME
"%s adr=%p ofs=%04x %016lx %016lx\n", msg
,
80 deb
, x
, *((u64
*)&deb
[0]), *((u64
*)&deb
[8]));
85 static struct net_device_stats
*ehea_get_stats(struct net_device
*dev
)
87 struct ehea_port
*port
= netdev_priv(dev
);
88 struct net_device_stats
*stats
= &port
->stats
;
89 struct hcp_ehea_port_cb2
*cb2
;
93 memset(stats
, 0, sizeof(*stats
));
95 cb2
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
97 ehea_error("no mem for cb2");
101 hret
= ehea_h_query_ehea_port(port
->adapter
->handle
,
102 port
->logical_port_id
,
103 H_PORT_CB2
, H_PORT_CB2_ALL
, cb2
);
104 if (hret
!= H_SUCCESS
) {
105 ehea_error("query_ehea_port failed");
109 if (netif_msg_hw(port
))
110 ehea_dump(cb2
, sizeof(*cb2
), "net_device_stats");
113 for (i
= 0; i
< port
->num_def_qps
; i
++)
114 rx_packets
+= port
->port_res
[i
].rx_packets
;
116 stats
->tx_packets
= cb2
->txucp
+ cb2
->txmcp
+ cb2
->txbcp
;
117 stats
->multicast
= cb2
->rxmcp
;
118 stats
->rx_errors
= cb2
->rxuerr
;
119 stats
->rx_bytes
= cb2
->rxo
;
120 stats
->tx_bytes
= cb2
->txo
;
121 stats
->rx_packets
= rx_packets
;
129 static void ehea_refill_rq1(struct ehea_port_res
*pr
, int index
, int nr_of_wqes
)
131 struct sk_buff
**skb_arr_rq1
= pr
->rq1_skba
.arr
;
132 struct net_device
*dev
= pr
->port
->netdev
;
133 int max_index_mask
= pr
->rq1_skba
.len
- 1;
139 for (i
= 0; i
< nr_of_wqes
; i
++) {
140 if (!skb_arr_rq1
[index
]) {
141 skb_arr_rq1
[index
] = netdev_alloc_skb(dev
,
143 if (!skb_arr_rq1
[index
]) {
144 ehea_error("%s: no mem for skb/%d wqes filled",
150 index
&= max_index_mask
;
153 ehea_update_rq1a(pr
->qp
, i
);
156 static int ehea_init_fill_rq1(struct ehea_port_res
*pr
, int nr_rq1a
)
159 struct sk_buff
**skb_arr_rq1
= pr
->rq1_skba
.arr
;
160 struct net_device
*dev
= pr
->port
->netdev
;
163 for (i
= 0; i
< pr
->rq1_skba
.len
; i
++) {
164 skb_arr_rq1
[i
] = netdev_alloc_skb(dev
, EHEA_L_PKT_SIZE
);
165 if (!skb_arr_rq1
[i
]) {
166 ehea_error("%s: no mem for skb/%d wqes filled",
173 ehea_update_rq1a(pr
->qp
, nr_rq1a
);
178 static int ehea_refill_rq_def(struct ehea_port_res
*pr
,
179 struct ehea_q_skb_arr
*q_skba
, int rq_nr
,
180 int num_wqes
, int wqe_type
, int packet_size
)
182 struct net_device
*dev
= pr
->port
->netdev
;
183 struct ehea_qp
*qp
= pr
->qp
;
184 struct sk_buff
**skb_arr
= q_skba
->arr
;
185 struct ehea_rwqe
*rwqe
;
186 int i
, index
, max_index_mask
, fill_wqes
;
189 fill_wqes
= q_skba
->os_skbs
+ num_wqes
;
194 index
= q_skba
->index
;
195 max_index_mask
= q_skba
->len
- 1;
196 for (i
= 0; i
< fill_wqes
; i
++) {
197 struct sk_buff
*skb
= netdev_alloc_skb(dev
, packet_size
);
199 ehea_error("%s: no mem for skb/%d wqes filled",
201 q_skba
->os_skbs
= fill_wqes
- i
;
205 skb_reserve(skb
, NET_IP_ALIGN
);
207 skb_arr
[index
] = skb
;
209 rwqe
= ehea_get_next_rwqe(qp
, rq_nr
);
210 rwqe
->wr_id
= EHEA_BMASK_SET(EHEA_WR_ID_TYPE
, wqe_type
)
211 | EHEA_BMASK_SET(EHEA_WR_ID_INDEX
, index
);
212 rwqe
->sg_list
[0].l_key
= pr
->recv_mr
.lkey
;
213 rwqe
->sg_list
[0].vaddr
= (u64
)skb
->data
;
214 rwqe
->sg_list
[0].len
= packet_size
;
215 rwqe
->data_segments
= 1;
218 index
&= max_index_mask
;
220 q_skba
->index
= index
;
225 ehea_update_rq2a(pr
->qp
, i
);
227 ehea_update_rq3a(pr
->qp
, i
);
233 static int ehea_refill_rq2(struct ehea_port_res
*pr
, int nr_of_wqes
)
235 return ehea_refill_rq_def(pr
, &pr
->rq2_skba
, 2,
236 nr_of_wqes
, EHEA_RWQE2_TYPE
,
237 EHEA_RQ2_PKT_SIZE
+ NET_IP_ALIGN
);
241 static int ehea_refill_rq3(struct ehea_port_res
*pr
, int nr_of_wqes
)
243 return ehea_refill_rq_def(pr
, &pr
->rq3_skba
, 3,
244 nr_of_wqes
, EHEA_RWQE3_TYPE
,
245 EHEA_MAX_PACKET_SIZE
+ NET_IP_ALIGN
);
248 static inline int ehea_check_cqe(struct ehea_cqe
*cqe
, int *rq_num
)
250 *rq_num
= (cqe
->type
& EHEA_CQE_TYPE_RQ
) >> 5;
251 if ((cqe
->status
& EHEA_CQE_STAT_ERR_MASK
) == 0)
253 if (((cqe
->status
& EHEA_CQE_STAT_ERR_TCP
) != 0) &&
254 (cqe
->header_length
== 0))
259 static inline void ehea_fill_skb(struct net_device
*dev
,
260 struct sk_buff
*skb
, struct ehea_cqe
*cqe
)
262 int length
= cqe
->num_bytes_transfered
- 4; /*remove CRC */
264 skb_put(skb
, length
);
265 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
266 skb
->protocol
= eth_type_trans(skb
, dev
);
269 static inline struct sk_buff
*get_skb_by_index(struct sk_buff
**skb_array
,
271 struct ehea_cqe
*cqe
)
273 int skb_index
= EHEA_BMASK_GET(EHEA_WR_ID_INDEX
, cqe
->wr_id
);
283 prefetchw(pref
+ EHEA_CACHE_LINE
);
285 pref
= (skb_array
[x
]->data
);
287 prefetch(pref
+ EHEA_CACHE_LINE
);
288 prefetch(pref
+ EHEA_CACHE_LINE
* 2);
289 prefetch(pref
+ EHEA_CACHE_LINE
* 3);
290 skb
= skb_array
[skb_index
];
291 skb_array
[skb_index
] = NULL
;
295 static inline struct sk_buff
*get_skb_by_index_ll(struct sk_buff
**skb_array
,
296 int arr_len
, int wqe_index
)
307 prefetchw(pref
+ EHEA_CACHE_LINE
);
309 pref
= (skb_array
[x
]->data
);
311 prefetchw(pref
+ EHEA_CACHE_LINE
);
313 skb
= skb_array
[wqe_index
];
314 skb_array
[wqe_index
] = NULL
;
318 static int ehea_treat_poll_error(struct ehea_port_res
*pr
, int rq
,
319 struct ehea_cqe
*cqe
, int *processed_rq2
,
324 if (netif_msg_rx_err(pr
->port
)) {
325 ehea_error("CQE Error for QP %d", pr
->qp
->init_attr
.qp_nr
);
326 ehea_dump(cqe
, sizeof(*cqe
), "CQE");
331 skb
= get_skb_by_index(pr
->rq2_skba
.arr
, pr
->rq2_skba
.len
, cqe
);
333 } else if (rq
== 3) {
335 skb
= get_skb_by_index(pr
->rq3_skba
.arr
, pr
->rq3_skba
.len
, cqe
);
339 if (cqe
->status
& EHEA_CQE_STAT_FAT_ERR_MASK
) {
340 ehea_error("Critical receive error. Resetting port.");
341 queue_work(pr
->port
->adapter
->ehea_wq
, &pr
->port
->reset_task
);
348 static int ehea_poll(struct net_device
*dev
, int *budget
)
350 struct ehea_port
*port
= netdev_priv(dev
);
351 struct ehea_port_res
*pr
= &port
->port_res
[0];
352 struct ehea_qp
*qp
= pr
->qp
;
353 struct ehea_cqe
*cqe
;
355 struct sk_buff
**skb_arr_rq1
= pr
->rq1_skba
.arr
;
356 struct sk_buff
**skb_arr_rq2
= pr
->rq2_skba
.arr
;
357 struct sk_buff
**skb_arr_rq3
= pr
->rq3_skba
.arr
;
358 int skb_arr_rq1_len
= pr
->rq1_skba
.len
;
359 int skb_arr_rq2_len
= pr
->rq2_skba
.len
;
360 int skb_arr_rq3_len
= pr
->rq3_skba
.len
;
361 int processed
, processed_rq1
, processed_rq2
, processed_rq3
;
362 int wqe_index
, last_wqe_index
, rq
, intreq
, my_quota
, port_reset
;
364 processed
= processed_rq1
= processed_rq2
= processed_rq3
= 0;
366 my_quota
= min(*budget
, dev
->quota
);
367 my_quota
= min(my_quota
, EHEA_POLL_MAX_RWQE
);
369 /* rq0 is low latency RQ */
370 cqe
= ehea_poll_rq1(qp
, &wqe_index
);
371 while ((my_quota
> 0) && cqe
) {
376 if (netif_msg_rx_status(port
))
377 ehea_dump(cqe
, sizeof(*cqe
), "CQE");
379 last_wqe_index
= wqe_index
;
381 if (!ehea_check_cqe(cqe
, &rq
)) {
382 if (rq
== 1) { /* LL RQ1 */
383 skb
= get_skb_by_index_ll(skb_arr_rq1
,
386 if (unlikely(!skb
)) {
387 if (netif_msg_rx_err(port
))
388 ehea_error("LL rq1: skb=NULL");
389 skb
= netdev_alloc_skb(dev
,
394 memcpy(skb
->data
, ((char*)cqe
) + 64,
395 cqe
->num_bytes_transfered
- 4);
396 ehea_fill_skb(dev
, skb
, cqe
);
397 } else if (rq
== 2) { /* RQ2 */
398 skb
= get_skb_by_index(skb_arr_rq2
,
399 skb_arr_rq2_len
, cqe
);
400 if (unlikely(!skb
)) {
401 if (netif_msg_rx_err(port
))
402 ehea_error("rq2: skb=NULL");
405 ehea_fill_skb(dev
, skb
, cqe
);
408 skb
= get_skb_by_index(skb_arr_rq3
,
409 skb_arr_rq3_len
, cqe
);
410 if (unlikely(!skb
)) {
411 if (netif_msg_rx_err(port
))
412 ehea_error("rq3: skb=NULL");
415 ehea_fill_skb(dev
, skb
, cqe
);
419 if (cqe
->status
& EHEA_CQE_VLAN_TAG_XTRACT
)
420 vlan_hwaccel_receive_skb(skb
, port
->vgrp
,
423 netif_receive_skb(skb
);
425 } else { /* Error occured */
426 pr
->p_state
.poll_receive_errors
++;
427 port_reset
= ehea_treat_poll_error(pr
, rq
, cqe
,
433 cqe
= ehea_poll_rq1(qp
, &wqe_index
);
436 dev
->quota
-= processed
;
437 *budget
-= processed
;
439 pr
->p_state
.ehea_poll
+= 1;
440 pr
->rx_packets
+= processed
;
442 ehea_refill_rq1(pr
, last_wqe_index
, processed_rq1
);
443 ehea_refill_rq2(pr
, processed_rq2
);
444 ehea_refill_rq3(pr
, processed_rq3
);
446 intreq
= ((pr
->p_state
.ehea_poll
& 0xF) == 0xF);
448 if (!cqe
|| intreq
) {
449 netif_rx_complete(dev
);
450 ehea_reset_cq_ep(pr
->recv_cq
);
451 ehea_reset_cq_n1(pr
->recv_cq
);
452 cqe
= hw_qeit_get_valid(&qp
->hw_rqueue1
);
455 if (!netif_rx_reschedule(dev
, my_quota
))
461 void free_sent_skbs(struct ehea_cqe
*cqe
, struct ehea_port_res
*pr
)
464 int index
, max_index_mask
, i
;
466 index
= EHEA_BMASK_GET(EHEA_WR_ID_INDEX
, cqe
->wr_id
);
467 max_index_mask
= pr
->sq_skba
.len
- 1;
468 for (i
= 0; i
< EHEA_BMASK_GET(EHEA_WR_ID_REFILL
, cqe
->wr_id
); i
++) {
469 skb
= pr
->sq_skba
.arr
[index
];
472 pr
->sq_skba
.arr
[index
] = NULL
;
474 ehea_error("skb=NULL, wr_id=%lX, loop=%d, index=%d",
475 cqe
->wr_id
, i
, index
);
478 index
&= max_index_mask
;
482 #define MAX_SENDCOMP_QUOTA 400
483 void ehea_send_irq_tasklet(unsigned long data
)
485 struct ehea_port_res
*pr
= (struct ehea_port_res
*)data
;
486 struct ehea_cq
*send_cq
= pr
->send_cq
;
487 struct ehea_cqe
*cqe
;
488 int quota
= MAX_SENDCOMP_QUOTA
;
494 cqe
= ehea_poll_cq(send_cq
);
496 ehea_reset_cq_ep(send_cq
);
497 ehea_reset_cq_n1(send_cq
);
498 cqe
= ehea_poll_cq(send_cq
);
504 if (cqe
->status
& EHEA_CQE_STAT_ERR_MASK
) {
505 ehea_error("Send Completion Error: Resetting port");
506 if (netif_msg_tx_err(pr
->port
))
507 ehea_dump(cqe
, sizeof(*cqe
), "Send CQE");
508 queue_work(pr
->port
->adapter
->ehea_wq
,
509 &pr
->port
->reset_task
);
513 if (netif_msg_tx_done(pr
->port
))
514 ehea_dump(cqe
, sizeof(*cqe
), "CQE");
516 if (likely(EHEA_BMASK_GET(EHEA_WR_ID_TYPE
, cqe
->wr_id
)
518 free_sent_skbs(cqe
, pr
);
520 swqe_av
+= EHEA_BMASK_GET(EHEA_WR_ID_REFILL
, cqe
->wr_id
);
524 ehea_update_feca(send_cq
, cqe_counter
);
525 atomic_add(swqe_av
, &pr
->swqe_avail
);
527 spin_lock_irqsave(&pr
->netif_queue
, flags
);
528 if (pr
->queue_stopped
&& (atomic_read(&pr
->swqe_avail
)
529 >= pr
->swqe_refill_th
)) {
530 netif_wake_queue(pr
->port
->netdev
);
531 pr
->queue_stopped
= 0;
533 spin_unlock_irqrestore(&pr
->netif_queue
, flags
);
536 tasklet_hi_schedule(&pr
->send_comp_task
);
539 static irqreturn_t
ehea_send_irq_handler(int irq
, void *param
)
541 struct ehea_port_res
*pr
= param
;
542 tasklet_hi_schedule(&pr
->send_comp_task
);
546 static irqreturn_t
ehea_recv_irq_handler(int irq
, void *param
)
548 struct ehea_port_res
*pr
= param
;
549 struct ehea_port
*port
= pr
->port
;
550 netif_rx_schedule(port
->netdev
);
554 static irqreturn_t
ehea_qp_aff_irq_handler(int irq
, void *param
)
556 struct ehea_port
*port
= param
;
557 struct ehea_eqe
*eqe
;
560 eqe
= ehea_poll_eq(port
->qp_eq
);
561 ehea_debug("eqe=%p", eqe
);
563 ehea_debug("*eqe=%lx", *(u64
*)eqe
);
564 eqe
= ehea_poll_eq(port
->qp_eq
);
565 qp_token
= EHEA_BMASK_GET(EHEA_EQE_QP_TOKEN
, eqe
->entry
);
566 ehea_debug("next eqe=%p", eqe
);
572 static struct ehea_port
*ehea_get_port(struct ehea_adapter
*adapter
,
577 for (i
= 0; i
< adapter
->num_ports
; i
++)
578 if (adapter
->port
[i
]->logical_port_id
== logical_port
)
579 return adapter
->port
[i
];
583 int ehea_sense_port_attr(struct ehea_port
*port
)
587 struct hcp_ehea_port_cb0
*cb0
;
589 cb0
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
591 ehea_error("no mem for cb0");
596 hret
= ehea_h_query_ehea_port(port
->adapter
->handle
,
597 port
->logical_port_id
, H_PORT_CB0
,
598 EHEA_BMASK_SET(H_PORT_CB0_ALL
, 0xFFFF),
600 if (hret
!= H_SUCCESS
) {
606 port
->mac_addr
= cb0
->port_mac_addr
<< 16;
608 if (!is_valid_ether_addr((u8
*)&port
->mac_addr
)) {
609 ret
= -EADDRNOTAVAIL
;
614 switch (cb0
->port_speed
) {
616 port
->port_speed
= EHEA_SPEED_10M
;
617 port
->full_duplex
= 0;
620 port
->port_speed
= EHEA_SPEED_10M
;
621 port
->full_duplex
= 1;
624 port
->port_speed
= EHEA_SPEED_100M
;
625 port
->full_duplex
= 0;
628 port
->port_speed
= EHEA_SPEED_100M
;
629 port
->full_duplex
= 1;
632 port
->port_speed
= EHEA_SPEED_1G
;
633 port
->full_duplex
= 1;
636 port
->port_speed
= EHEA_SPEED_10G
;
637 port
->full_duplex
= 1;
640 port
->port_speed
= 0;
641 port
->full_duplex
= 0;
645 /* Number of default QPs */
646 port
->num_def_qps
= cb0
->num_default_qps
;
648 if (!port
->num_def_qps
) {
653 if (port
->num_def_qps
>= EHEA_NUM_TX_QP
)
654 port
->num_add_tx_qps
= 0;
656 port
->num_add_tx_qps
= EHEA_NUM_TX_QP
- port
->num_def_qps
;
660 if (ret
|| netif_msg_probe(port
))
661 ehea_dump(cb0
, sizeof(*cb0
), "ehea_sense_port_attr");
667 int ehea_set_portspeed(struct ehea_port
*port
, u32 port_speed
)
669 struct hcp_ehea_port_cb4
*cb4
;
673 cb4
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
675 ehea_error("no mem for cb4");
680 cb4
->port_speed
= port_speed
;
682 netif_carrier_off(port
->netdev
);
684 hret
= ehea_h_modify_ehea_port(port
->adapter
->handle
,
685 port
->logical_port_id
,
686 H_PORT_CB4
, H_PORT_CB4_SPEED
, cb4
);
687 if (hret
== H_SUCCESS
) {
688 port
->autoneg
= port_speed
== EHEA_SPEED_AUTONEG
? 1 : 0;
690 hret
= ehea_h_query_ehea_port(port
->adapter
->handle
,
691 port
->logical_port_id
,
692 H_PORT_CB4
, H_PORT_CB4_SPEED
,
694 if (hret
== H_SUCCESS
) {
695 switch (cb4
->port_speed
) {
697 port
->port_speed
= EHEA_SPEED_10M
;
698 port
->full_duplex
= 0;
701 port
->port_speed
= EHEA_SPEED_10M
;
702 port
->full_duplex
= 1;
705 port
->port_speed
= EHEA_SPEED_100M
;
706 port
->full_duplex
= 0;
709 port
->port_speed
= EHEA_SPEED_100M
;
710 port
->full_duplex
= 1;
713 port
->port_speed
= EHEA_SPEED_1G
;
714 port
->full_duplex
= 1;
717 port
->port_speed
= EHEA_SPEED_10G
;
718 port
->full_duplex
= 1;
721 port
->port_speed
= 0;
722 port
->full_duplex
= 0;
726 ehea_error("Failed sensing port speed");
730 if (hret
== H_AUTHORITY
) {
731 ehea_info("Hypervisor denied setting port speed. Either"
732 " this partition is not authorized to set "
733 "port speed or another partition has modified"
734 " port speed first.");
738 ehea_error("Failed setting port speed");
741 netif_carrier_on(port
->netdev
);
747 static void ehea_parse_eqe(struct ehea_adapter
*adapter
, u64 eqe
)
752 struct ehea_port
*port
;
754 ec
= EHEA_BMASK_GET(NEQE_EVENT_CODE
, eqe
);
755 portnum
= EHEA_BMASK_GET(NEQE_PORTNUM
, eqe
);
756 port
= ehea_get_port(adapter
, portnum
);
759 case EHEA_EC_PORTSTATE_CHG
: /* port state change */
762 ehea_error("unknown portnum %x", portnum
);
766 if (EHEA_BMASK_GET(NEQE_PORT_UP
, eqe
)) {
767 if (!netif_carrier_ok(port
->netdev
)) {
768 ret
= ehea_sense_port_attr(
769 adapter
->port
[portnum
]);
771 ehea_error("failed resensing port "
776 if (netif_msg_link(port
))
777 ehea_info("%s: Logical port up: %dMbps "
782 1 ? "Full" : "Half");
784 netif_carrier_on(port
->netdev
);
785 netif_wake_queue(port
->netdev
);
788 if (netif_carrier_ok(port
->netdev
)) {
789 if (netif_msg_link(port
))
790 ehea_info("%s: Logical port down",
792 netif_carrier_off(port
->netdev
);
793 netif_stop_queue(port
->netdev
);
796 if (EHEA_BMASK_GET(NEQE_EXTSWITCH_PORT_UP
, eqe
)) {
797 if (netif_msg_link(port
))
798 ehea_info("%s: Physical port up",
801 if (netif_msg_link(port
))
802 ehea_info("%s: Physical port down",
806 if (EHEA_BMASK_GET(NEQE_EXTSWITCH_PRIMARY
, eqe
))
807 ehea_info("External switch port is primary port");
809 ehea_info("External switch port is backup port");
812 case EHEA_EC_ADAPTER_MALFUNC
:
813 ehea_error("Adapter malfunction");
815 case EHEA_EC_PORT_MALFUNC
:
816 ehea_info("Port malfunction: Device: %s", port
->netdev
->name
);
817 netif_carrier_off(port
->netdev
);
818 netif_stop_queue(port
->netdev
);
821 ehea_error("unknown event code %x", ec
);
826 static void ehea_neq_tasklet(unsigned long data
)
828 struct ehea_adapter
*adapter
= (struct ehea_adapter
*)data
;
829 struct ehea_eqe
*eqe
;
832 eqe
= ehea_poll_eq(adapter
->neq
);
833 ehea_debug("eqe=%p", eqe
);
836 ehea_debug("*eqe=%lx", eqe
->entry
);
837 ehea_parse_eqe(adapter
, eqe
->entry
);
838 eqe
= ehea_poll_eq(adapter
->neq
);
839 ehea_debug("next eqe=%p", eqe
);
842 event_mask
= EHEA_BMASK_SET(NELR_PORTSTATE_CHG
, 1)
843 | EHEA_BMASK_SET(NELR_ADAPTER_MALFUNC
, 1)
844 | EHEA_BMASK_SET(NELR_PORT_MALFUNC
, 1);
846 ehea_h_reset_events(adapter
->handle
,
847 adapter
->neq
->fw_handle
, event_mask
);
850 static irqreturn_t
ehea_interrupt_neq(int irq
, void *param
)
852 struct ehea_adapter
*adapter
= param
;
853 tasklet_hi_schedule(&adapter
->neq_tasklet
);
858 static int ehea_fill_port_res(struct ehea_port_res
*pr
)
861 struct ehea_qp_init_attr
*init_attr
= &pr
->qp
->init_attr
;
863 ret
= ehea_init_fill_rq1(pr
, init_attr
->act_nr_rwqes_rq1
864 - init_attr
->act_nr_rwqes_rq2
865 - init_attr
->act_nr_rwqes_rq3
- 1);
867 ret
|= ehea_refill_rq2(pr
, init_attr
->act_nr_rwqes_rq2
- 1);
869 ret
|= ehea_refill_rq3(pr
, init_attr
->act_nr_rwqes_rq3
- 1);
874 static int ehea_reg_interrupts(struct net_device
*dev
)
876 struct ehea_port
*port
= netdev_priv(dev
);
877 struct ehea_port_res
*pr
;
880 for (i
= 0; i
< port
->num_def_qps
; i
++) {
881 pr
= &port
->port_res
[i
];
882 snprintf(pr
->int_recv_name
, EHEA_IRQ_NAME_SIZE
- 1
883 , "%s-recv%d", dev
->name
, i
);
884 ret
= ibmebus_request_irq(NULL
, pr
->recv_eq
->attr
.ist1
,
885 ehea_recv_irq_handler
,
886 SA_INTERRUPT
, pr
->int_recv_name
, pr
);
888 ehea_error("failed registering irq for ehea_recv_int:"
889 "port_res_nr:%d, ist=%X", i
,
890 pr
->recv_eq
->attr
.ist1
);
893 if (netif_msg_ifup(port
))
894 ehea_info("irq_handle 0x%X for funct ehea_recv_int %d "
895 "registered", pr
->recv_eq
->attr
.ist1
, i
);
898 snprintf(port
->int_aff_name
, EHEA_IRQ_NAME_SIZE
- 1, "%s-aff",
901 ret
= ibmebus_request_irq(NULL
, port
->qp_eq
->attr
.ist1
,
902 ehea_qp_aff_irq_handler
,
903 SA_INTERRUPT
, port
->int_aff_name
, port
);
905 ehea_error("failed registering irq for qp_aff_irq_handler:"
906 "ist=%X", port
->qp_eq
->attr
.ist1
);
910 if (netif_msg_ifup(port
))
911 ehea_info("irq_handle 0x%X for function qp_aff_irq_handler "
912 "registered", port
->qp_eq
->attr
.ist1
);
914 for (i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++) {
915 pr
= &port
->port_res
[i
];
916 snprintf(pr
->int_send_name
, EHEA_IRQ_NAME_SIZE
- 1,
917 "%s-send%d", dev
->name
, i
);
918 ret
= ibmebus_request_irq(NULL
, pr
->send_eq
->attr
.ist1
,
919 ehea_send_irq_handler
,
920 SA_INTERRUPT
, pr
->int_send_name
,
923 ehea_error("failed registering irq for ehea_send "
924 "port_res_nr:%d, ist=%X", i
,
925 pr
->send_eq
->attr
.ist1
);
928 if (netif_msg_ifup(port
))
929 ehea_info("irq_handle 0x%X for function ehea_send_int "
930 "%d registered", pr
->send_eq
->attr
.ist1
, i
);
937 u32 ist
= port
->port_res
[i
].send_eq
->attr
.ist1
;
938 ibmebus_free_irq(NULL
, ist
, &port
->port_res
[i
]);
941 ibmebus_free_irq(NULL
, port
->qp_eq
->attr
.ist1
, port
);
942 i
= port
->num_def_qps
;
945 u32 ist
= port
->port_res
[i
].recv_eq
->attr
.ist1
;
946 ibmebus_free_irq(NULL
, ist
, &port
->port_res
[i
]);
951 static void ehea_free_interrupts(struct net_device
*dev
)
953 struct ehea_port
*port
= netdev_priv(dev
);
954 struct ehea_port_res
*pr
;
958 for (i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++) {
959 pr
= &port
->port_res
[i
];
960 ibmebus_free_irq(NULL
, pr
->send_eq
->attr
.ist1
, pr
);
961 if (netif_msg_intr(port
))
962 ehea_info("free send irq for res %d with handle 0x%X",
963 i
, pr
->send_eq
->attr
.ist1
);
967 for (i
= 0; i
< port
->num_def_qps
; i
++) {
968 pr
= &port
->port_res
[i
];
969 ibmebus_free_irq(NULL
, pr
->recv_eq
->attr
.ist1
, pr
);
970 if (netif_msg_intr(port
))
971 ehea_info("free recv irq for res %d with handle 0x%X",
972 i
, pr
->recv_eq
->attr
.ist1
);
975 /* associated events */
976 ibmebus_free_irq(NULL
, port
->qp_eq
->attr
.ist1
, port
);
977 if (netif_msg_intr(port
))
978 ehea_info("associated event interrupt for handle 0x%X freed",
979 port
->qp_eq
->attr
.ist1
);
982 static int ehea_configure_port(struct ehea_port
*port
)
986 struct hcp_ehea_port_cb0
*cb0
;
989 cb0
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
993 cb0
->port_rc
= EHEA_BMASK_SET(PXLY_RC_VALID
, 1)
994 | EHEA_BMASK_SET(PXLY_RC_IP_CHKSUM
, 1)
995 | EHEA_BMASK_SET(PXLY_RC_TCP_UDP_CHKSUM
, 1)
996 | EHEA_BMASK_SET(PXLY_RC_VLAN_XTRACT
, 1)
997 | EHEA_BMASK_SET(PXLY_RC_VLAN_TAG_FILTER
,
999 | EHEA_BMASK_SET(PXLY_RC_JUMBO_FRAME
, 1);
1001 for (i
= 0; i
< port
->num_def_qps
; i
++)
1002 cb0
->default_qpn_arr
[i
] = port
->port_res
[i
].qp
->init_attr
.qp_nr
;
1004 if (netif_msg_ifup(port
))
1005 ehea_dump(cb0
, sizeof(*cb0
), "ehea_configure_port");
1007 mask
= EHEA_BMASK_SET(H_PORT_CB0_PRC
, 1)
1008 | EHEA_BMASK_SET(H_PORT_CB0_DEFQPNARRAY
, 1);
1010 hret
= ehea_h_modify_ehea_port(port
->adapter
->handle
,
1011 port
->logical_port_id
,
1012 H_PORT_CB0
, mask
, cb0
);
1014 if (hret
!= H_SUCCESS
)
1025 static int ehea_gen_smrs(struct ehea_port_res
*pr
)
1028 struct ehea_adapter
*adapter
= pr
->port
->adapter
;
1030 hret
= ehea_h_register_smr(adapter
->handle
, adapter
->mr
.handle
,
1031 adapter
->mr
.vaddr
, EHEA_MR_ACC_CTRL
,
1032 adapter
->pd
, &pr
->send_mr
);
1033 if (hret
!= H_SUCCESS
)
1036 hret
= ehea_h_register_smr(adapter
->handle
, adapter
->mr
.handle
,
1037 adapter
->mr
.vaddr
, EHEA_MR_ACC_CTRL
,
1038 adapter
->pd
, &pr
->recv_mr
);
1039 if (hret
!= H_SUCCESS
)
1045 hret
= ehea_h_free_resource(adapter
->handle
, pr
->send_mr
.handle
);
1046 if (hret
!= H_SUCCESS
)
1047 ehea_error("failed freeing SMR");
1052 static int ehea_rem_smrs(struct ehea_port_res
*pr
)
1054 struct ehea_adapter
*adapter
= pr
->port
->adapter
;
1058 hret
= ehea_h_free_resource(adapter
->handle
, pr
->send_mr
.handle
);
1059 if (hret
!= H_SUCCESS
) {
1061 ehea_error("failed freeing send SMR for pr=%p", pr
);
1064 hret
= ehea_h_free_resource(adapter
->handle
, pr
->recv_mr
.handle
);
1065 if (hret
!= H_SUCCESS
) {
1067 ehea_error("failed freeing recv SMR for pr=%p", pr
);
1073 static int ehea_init_q_skba(struct ehea_q_skb_arr
*q_skba
, int max_q_entries
)
1075 int arr_size
= sizeof(void*) * max_q_entries
;
1077 q_skba
->arr
= vmalloc(arr_size
);
1081 memset(q_skba
->arr
, 0, arr_size
);
1083 q_skba
->len
= max_q_entries
;
1085 q_skba
->os_skbs
= 0;
1090 static int ehea_init_port_res(struct ehea_port
*port
, struct ehea_port_res
*pr
,
1091 struct port_res_cfg
*pr_cfg
, int queue_token
)
1093 struct ehea_adapter
*adapter
= port
->adapter
;
1094 enum ehea_eq_type eq_type
= EHEA_EQ
;
1095 struct ehea_qp_init_attr
*init_attr
= NULL
;
1098 memset(pr
, 0, sizeof(struct ehea_port_res
));
1101 spin_lock_init(&pr
->send_lock
);
1102 spin_lock_init(&pr
->recv_lock
);
1103 spin_lock_init(&pr
->xmit_lock
);
1104 spin_lock_init(&pr
->netif_queue
);
1106 pr
->recv_eq
= ehea_create_eq(adapter
, eq_type
, EHEA_MAX_ENTRIES_EQ
, 0);
1108 ehea_error("create_eq failed (recv_eq)");
1112 pr
->send_eq
= ehea_create_eq(adapter
, eq_type
, EHEA_MAX_ENTRIES_EQ
, 0);
1114 ehea_error("create_eq failed (send_eq)");
1118 pr
->recv_cq
= ehea_create_cq(adapter
, pr_cfg
->max_entries_rcq
,
1119 pr
->recv_eq
->fw_handle
,
1120 port
->logical_port_id
);
1122 ehea_error("create_cq failed (cq_recv)");
1126 pr
->send_cq
= ehea_create_cq(adapter
, pr_cfg
->max_entries_scq
,
1127 pr
->send_eq
->fw_handle
,
1128 port
->logical_port_id
);
1130 ehea_error("create_cq failed (cq_send)");
1134 if (netif_msg_ifup(port
))
1135 ehea_info("Send CQ: act_nr_cqes=%d, Recv CQ: act_nr_cqes=%d",
1136 pr
->send_cq
->attr
.act_nr_of_cqes
,
1137 pr
->recv_cq
->attr
.act_nr_of_cqes
);
1139 init_attr
= kzalloc(sizeof(*init_attr
), GFP_KERNEL
);
1142 ehea_error("no mem for ehea_qp_init_attr");
1146 init_attr
->low_lat_rq1
= 1;
1147 init_attr
->signalingtype
= 1; /* generate CQE if specified in WQE */
1148 init_attr
->rq_count
= 3;
1149 init_attr
->qp_token
= queue_token
;
1150 init_attr
->max_nr_send_wqes
= pr_cfg
->max_entries_sq
;
1151 init_attr
->max_nr_rwqes_rq1
= pr_cfg
->max_entries_rq1
;
1152 init_attr
->max_nr_rwqes_rq2
= pr_cfg
->max_entries_rq2
;
1153 init_attr
->max_nr_rwqes_rq3
= pr_cfg
->max_entries_rq3
;
1154 init_attr
->wqe_size_enc_sq
= EHEA_SG_SQ
;
1155 init_attr
->wqe_size_enc_rq1
= EHEA_SG_RQ1
;
1156 init_attr
->wqe_size_enc_rq2
= EHEA_SG_RQ2
;
1157 init_attr
->wqe_size_enc_rq3
= EHEA_SG_RQ3
;
1158 init_attr
->rq2_threshold
= EHEA_RQ2_THRESHOLD
;
1159 init_attr
->rq3_threshold
= EHEA_RQ3_THRESHOLD
;
1160 init_attr
->port_nr
= port
->logical_port_id
;
1161 init_attr
->send_cq_handle
= pr
->send_cq
->fw_handle
;
1162 init_attr
->recv_cq_handle
= pr
->recv_cq
->fw_handle
;
1163 init_attr
->aff_eq_handle
= port
->qp_eq
->fw_handle
;
1165 pr
->qp
= ehea_create_qp(adapter
, adapter
->pd
, init_attr
);
1167 ehea_error("create_qp failed");
1172 if (netif_msg_ifup(port
))
1173 ehea_info("QP: qp_nr=%d\n act_nr_snd_wqe=%d\n nr_rwqe_rq1=%d\n "
1174 "nr_rwqe_rq2=%d\n nr_rwqe_rq3=%d", init_attr
->qp_nr
,
1175 init_attr
->act_nr_send_wqes
,
1176 init_attr
->act_nr_rwqes_rq1
,
1177 init_attr
->act_nr_rwqes_rq2
,
1178 init_attr
->act_nr_rwqes_rq3
);
1180 ret
= ehea_init_q_skba(&pr
->sq_skba
, init_attr
->act_nr_send_wqes
+ 1);
1181 ret
|= ehea_init_q_skba(&pr
->rq1_skba
, init_attr
->act_nr_rwqes_rq1
+ 1);
1182 ret
|= ehea_init_q_skba(&pr
->rq2_skba
, init_attr
->act_nr_rwqes_rq2
+ 1);
1183 ret
|= ehea_init_q_skba(&pr
->rq3_skba
, init_attr
->act_nr_rwqes_rq3
+ 1);
1187 pr
->swqe_refill_th
= init_attr
->act_nr_send_wqes
/ 10;
1188 if (ehea_gen_smrs(pr
) != 0) {
1192 tasklet_init(&pr
->send_comp_task
, ehea_send_irq_tasklet
,
1194 atomic_set(&pr
->swqe_avail
, init_attr
->act_nr_send_wqes
- 1);
1202 vfree(pr
->sq_skba
.arr
);
1203 vfree(pr
->rq1_skba
.arr
);
1204 vfree(pr
->rq2_skba
.arr
);
1205 vfree(pr
->rq3_skba
.arr
);
1206 ehea_destroy_qp(pr
->qp
);
1207 ehea_destroy_cq(pr
->send_cq
);
1208 ehea_destroy_cq(pr
->recv_cq
);
1209 ehea_destroy_eq(pr
->send_eq
);
1210 ehea_destroy_eq(pr
->recv_eq
);
1215 static int ehea_clean_portres(struct ehea_port
*port
, struct ehea_port_res
*pr
)
1219 ret
= ehea_destroy_qp(pr
->qp
);
1222 ehea_destroy_cq(pr
->send_cq
);
1223 ehea_destroy_cq(pr
->recv_cq
);
1224 ehea_destroy_eq(pr
->send_eq
);
1225 ehea_destroy_eq(pr
->recv_eq
);
1227 for (i
= 0; i
< pr
->rq1_skba
.len
; i
++)
1228 if (pr
->rq1_skba
.arr
[i
])
1229 dev_kfree_skb(pr
->rq1_skba
.arr
[i
]);
1231 for (i
= 0; i
< pr
->rq2_skba
.len
; i
++)
1232 if (pr
->rq2_skba
.arr
[i
])
1233 dev_kfree_skb(pr
->rq2_skba
.arr
[i
]);
1235 for (i
= 0; i
< pr
->rq3_skba
.len
; i
++)
1236 if (pr
->rq3_skba
.arr
[i
])
1237 dev_kfree_skb(pr
->rq3_skba
.arr
[i
]);
1239 for (i
= 0; i
< pr
->sq_skba
.len
; i
++)
1240 if (pr
->sq_skba
.arr
[i
])
1241 dev_kfree_skb(pr
->sq_skba
.arr
[i
]);
1243 vfree(pr
->rq1_skba
.arr
);
1244 vfree(pr
->rq2_skba
.arr
);
1245 vfree(pr
->rq3_skba
.arr
);
1246 vfree(pr
->sq_skba
.arr
);
1247 ret
= ehea_rem_smrs(pr
);
1253 * The write_* functions store information in swqe which is used by
1254 * the hardware to calculate the ip/tcp/udp checksum
1257 static inline void write_ip_start_end(struct ehea_swqe
*swqe
,
1258 const struct sk_buff
*skb
)
1260 swqe
->ip_start
= (u8
)(((u64
)skb
->nh
.iph
) - ((u64
)skb
->data
));
1261 swqe
->ip_end
= (u8
)(swqe
->ip_start
+ skb
->nh
.iph
->ihl
* 4 - 1);
1264 static inline void write_tcp_offset_end(struct ehea_swqe
*swqe
,
1265 const struct sk_buff
*skb
)
1268 (u8
)(swqe
->ip_end
+ 1 + offsetof(struct tcphdr
, check
));
1270 swqe
->tcp_end
= (u16
)skb
->len
- 1;
1273 static inline void write_udp_offset_end(struct ehea_swqe
*swqe
,
1274 const struct sk_buff
*skb
)
1277 (u8
)(swqe
->ip_end
+ 1 + offsetof(struct udphdr
, check
));
1279 swqe
->tcp_end
= (u16
)skb
->len
- 1;
1283 static void write_swqe2_TSO(struct sk_buff
*skb
,
1284 struct ehea_swqe
*swqe
, u32 lkey
)
1286 struct ehea_vsgentry
*sg1entry
= &swqe
->u
.immdata_desc
.sg_entry
;
1287 u8
*imm_data
= &swqe
->u
.immdata_desc
.immediate_data
[0];
1288 int skb_data_size
= skb
->len
- skb
->data_len
;
1292 /* Packet is TCP with TSO enabled */
1293 swqe
->tx_control
|= EHEA_SWQE_TSO
;
1294 swqe
->mss
= skb_shinfo(skb
)->gso_size
;
1295 /* copy only eth/ip/tcp headers to immediate data and
1296 * the rest of skb->data to sg1entry
1298 headersize
= ETH_HLEN
+ (skb
->nh
.iph
->ihl
* 4) + (skb
->h
.th
->doff
* 4);
1300 skb_data_size
= skb
->len
- skb
->data_len
;
1302 if (skb_data_size
>= headersize
) {
1303 /* copy immediate data */
1304 memcpy(imm_data
, skb
->data
, headersize
);
1305 swqe
->immediate_data_length
= headersize
;
1307 if (skb_data_size
> headersize
) {
1308 /* set sg1entry data */
1309 sg1entry
->l_key
= lkey
;
1310 sg1entry
->len
= skb_data_size
- headersize
;
1312 tmp_addr
= (u64
)(skb
->data
+ headersize
);
1313 sg1entry
->vaddr
= tmp_addr
;
1314 swqe
->descriptors
++;
1317 ehea_error("cannot handle fragmented headers");
1320 static void write_swqe2_nonTSO(struct sk_buff
*skb
,
1321 struct ehea_swqe
*swqe
, u32 lkey
)
1323 int skb_data_size
= skb
->len
- skb
->data_len
;
1324 u8
*imm_data
= &swqe
->u
.immdata_desc
.immediate_data
[0];
1325 struct ehea_vsgentry
*sg1entry
= &swqe
->u
.immdata_desc
.sg_entry
;
1328 /* Packet is any nonTSO type
1330 * Copy as much as possible skb->data to immediate data and
1331 * the rest to sg1entry
1333 if (skb_data_size
>= SWQE2_MAX_IMM
) {
1334 /* copy immediate data */
1335 memcpy(imm_data
, skb
->data
, SWQE2_MAX_IMM
);
1337 swqe
->immediate_data_length
= SWQE2_MAX_IMM
;
1339 if (skb_data_size
> SWQE2_MAX_IMM
) {
1340 /* copy sg1entry data */
1341 sg1entry
->l_key
= lkey
;
1342 sg1entry
->len
= skb_data_size
- SWQE2_MAX_IMM
;
1343 tmp_addr
= (u64
)(skb
->data
+ SWQE2_MAX_IMM
);
1344 sg1entry
->vaddr
= tmp_addr
;
1345 swqe
->descriptors
++;
1348 memcpy(imm_data
, skb
->data
, skb_data_size
);
1349 swqe
->immediate_data_length
= skb_data_size
;
1353 static inline void write_swqe2_data(struct sk_buff
*skb
, struct net_device
*dev
,
1354 struct ehea_swqe
*swqe
, u32 lkey
)
1356 struct ehea_vsgentry
*sg_list
, *sg1entry
, *sgentry
;
1358 int nfrags
, sg1entry_contains_frag_data
, i
;
1361 nfrags
= skb_shinfo(skb
)->nr_frags
;
1362 sg1entry
= &swqe
->u
.immdata_desc
.sg_entry
;
1363 sg_list
= (struct ehea_vsgentry
*)&swqe
->u
.immdata_desc
.sg_list
;
1364 swqe
->descriptors
= 0;
1365 sg1entry_contains_frag_data
= 0;
1367 if ((dev
->features
& NETIF_F_TSO
) && skb_shinfo(skb
)->gso_size
)
1368 write_swqe2_TSO(skb
, swqe
, lkey
);
1370 write_swqe2_nonTSO(skb
, swqe
, lkey
);
1372 /* write descriptors */
1374 if (swqe
->descriptors
== 0) {
1375 /* sg1entry not yet used */
1376 frag
= &skb_shinfo(skb
)->frags
[0];
1378 /* copy sg1entry data */
1379 sg1entry
->l_key
= lkey
;
1380 sg1entry
->len
= frag
->size
;
1381 tmp_addr
= (u64
)(page_address(frag
->page
)
1382 + frag
->page_offset
);
1383 sg1entry
->vaddr
= tmp_addr
;
1384 swqe
->descriptors
++;
1385 sg1entry_contains_frag_data
= 1;
1388 for (i
= sg1entry_contains_frag_data
; i
< nfrags
; i
++) {
1390 frag
= &skb_shinfo(skb
)->frags
[i
];
1391 sgentry
= &sg_list
[i
- sg1entry_contains_frag_data
];
1393 sgentry
->l_key
= lkey
;
1394 sgentry
->len
= frag
->size
;
1396 tmp_addr
= (u64
)(page_address(frag
->page
)
1397 + frag
->page_offset
);
1398 sgentry
->vaddr
= tmp_addr
;
1399 swqe
->descriptors
++;
1404 static int ehea_broadcast_reg_helper(struct ehea_port
*port
, u32 hcallid
)
1410 /* De/Register untagged packets */
1411 reg_type
= EHEA_BCMC_BROADCAST
| EHEA_BCMC_UNTAGGED
;
1412 hret
= ehea_h_reg_dereg_bcmc(port
->adapter
->handle
,
1413 port
->logical_port_id
,
1414 reg_type
, port
->mac_addr
, 0, hcallid
);
1415 if (hret
!= H_SUCCESS
) {
1416 ehea_error("reg_dereg_bcmc failed (tagged)");
1421 /* De/Register VLAN packets */
1422 reg_type
= EHEA_BCMC_BROADCAST
| EHEA_BCMC_VLANID_ALL
;
1423 hret
= ehea_h_reg_dereg_bcmc(port
->adapter
->handle
,
1424 port
->logical_port_id
,
1425 reg_type
, port
->mac_addr
, 0, hcallid
);
1426 if (hret
!= H_SUCCESS
) {
1427 ehea_error("reg_dereg_bcmc failed (vlan)");
1434 static int ehea_set_mac_addr(struct net_device
*dev
, void *sa
)
1436 struct ehea_port
*port
= netdev_priv(dev
);
1437 struct sockaddr
*mac_addr
= sa
;
1438 struct hcp_ehea_port_cb0
*cb0
;
1442 if (!is_valid_ether_addr(mac_addr
->sa_data
)) {
1443 ret
= -EADDRNOTAVAIL
;
1447 cb0
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
1449 ehea_error("no mem for cb0");
1454 memcpy(&(cb0
->port_mac_addr
), &(mac_addr
->sa_data
[0]), ETH_ALEN
);
1456 cb0
->port_mac_addr
= cb0
->port_mac_addr
>> 16;
1458 hret
= ehea_h_modify_ehea_port(port
->adapter
->handle
,
1459 port
->logical_port_id
, H_PORT_CB0
,
1460 EHEA_BMASK_SET(H_PORT_CB0_MAC
, 1), cb0
);
1461 if (hret
!= H_SUCCESS
) {
1466 memcpy(dev
->dev_addr
, mac_addr
->sa_data
, dev
->addr_len
);
1468 /* Deregister old MAC in pHYP */
1469 ret
= ehea_broadcast_reg_helper(port
, H_DEREG_BCMC
);
1473 port
->mac_addr
= cb0
->port_mac_addr
<< 16;
1475 /* Register new MAC in pHYP */
1476 ret
= ehea_broadcast_reg_helper(port
, H_REG_BCMC
);
1487 static void ehea_promiscuous_error(u64 hret
, int enable
)
1489 ehea_info("Hypervisor denied %sabling promiscuous mode.%s",
1490 enable
== 1 ? "en" : "dis",
1491 hret
!= H_AUTHORITY
? "" : " Another partition owning a "
1492 "logical port on the same physical port might have altered "
1493 "promiscuous mode first.");
1496 static void ehea_promiscuous(struct net_device
*dev
, int enable
)
1498 struct ehea_port
*port
= netdev_priv(dev
);
1499 struct hcp_ehea_port_cb7
*cb7
;
1502 if ((enable
&& port
->promisc
) || (!enable
&& !port
->promisc
))
1505 cb7
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
1507 ehea_error("no mem for cb7");
1511 /* Modify Pxs_DUCQPN in CB7 */
1512 cb7
->def_uc_qpn
= enable
== 1 ? port
->port_res
[0].qp
->fw_handle
: 0;
1514 hret
= ehea_h_modify_ehea_port(port
->adapter
->handle
,
1515 port
->logical_port_id
,
1516 H_PORT_CB7
, H_PORT_CB7_DUCQPN
, cb7
);
1518 ehea_promiscuous_error(hret
, enable
);
1522 port
->promisc
= enable
;
1528 static u64
ehea_multicast_reg_helper(struct ehea_port
*port
, u64 mc_mac_addr
,
1534 reg_type
= EHEA_BCMC_SCOPE_ALL
| EHEA_BCMC_MULTICAST
1535 | EHEA_BCMC_UNTAGGED
;
1537 hret
= ehea_h_reg_dereg_bcmc(port
->adapter
->handle
,
1538 port
->logical_port_id
,
1539 reg_type
, mc_mac_addr
, 0, hcallid
);
1543 reg_type
= EHEA_BCMC_SCOPE_ALL
| EHEA_BCMC_MULTICAST
1544 | EHEA_BCMC_VLANID_ALL
;
1546 hret
= ehea_h_reg_dereg_bcmc(port
->adapter
->handle
,
1547 port
->logical_port_id
,
1548 reg_type
, mc_mac_addr
, 0, hcallid
);
1553 static int ehea_drop_multicast_list(struct net_device
*dev
)
1555 struct ehea_port
*port
= netdev_priv(dev
);
1556 struct ehea_mc_list
*mc_entry
= port
->mc_list
;
1557 struct list_head
*pos
;
1558 struct list_head
*temp
;
1562 list_for_each_safe(pos
, temp
, &(port
->mc_list
->list
)) {
1563 mc_entry
= list_entry(pos
, struct ehea_mc_list
, list
);
1565 hret
= ehea_multicast_reg_helper(port
, mc_entry
->macaddr
,
1568 ehea_error("failed deregistering mcast MAC");
1578 static void ehea_allmulti(struct net_device
*dev
, int enable
)
1580 struct ehea_port
*port
= netdev_priv(dev
);
1583 if (!port
->allmulti
) {
1585 /* Enable ALLMULTI */
1586 ehea_drop_multicast_list(dev
);
1587 hret
= ehea_multicast_reg_helper(port
, 0, H_REG_BCMC
);
1591 ehea_error("failed enabling IFF_ALLMULTI");
1595 /* Disable ALLMULTI */
1596 hret
= ehea_multicast_reg_helper(port
, 0, H_DEREG_BCMC
);
1600 ehea_error("failed disabling IFF_ALLMULTI");
1604 static void ehea_add_multicast_entry(struct ehea_port
* port
, u8
* mc_mac_addr
)
1606 struct ehea_mc_list
*ehea_mcl_entry
;
1609 ehea_mcl_entry
= kzalloc(sizeof(*ehea_mcl_entry
), GFP_KERNEL
);
1610 if (!ehea_mcl_entry
) {
1611 ehea_error("no mem for mcl_entry");
1615 INIT_LIST_HEAD(&ehea_mcl_entry
->list
);
1617 memcpy(&ehea_mcl_entry
->macaddr
, mc_mac_addr
, ETH_ALEN
);
1619 hret
= ehea_multicast_reg_helper(port
, ehea_mcl_entry
->macaddr
,
1622 list_add(&ehea_mcl_entry
->list
, &port
->mc_list
->list
);
1624 ehea_error("failed registering mcast MAC");
1625 kfree(ehea_mcl_entry
);
1629 static void ehea_set_multicast_list(struct net_device
*dev
)
1631 struct ehea_port
*port
= netdev_priv(dev
);
1632 struct dev_mc_list
*k_mcl_entry
;
1635 if (dev
->flags
& IFF_PROMISC
) {
1636 ehea_promiscuous(dev
, 1);
1639 ehea_promiscuous(dev
, 0);
1641 if (dev
->flags
& IFF_ALLMULTI
) {
1642 ehea_allmulti(dev
, 1);
1645 ehea_allmulti(dev
, 0);
1647 if (dev
->mc_count
) {
1648 ret
= ehea_drop_multicast_list(dev
);
1650 /* Dropping the current multicast list failed.
1651 * Enabling ALL_MULTI is the best we can do.
1653 ehea_allmulti(dev
, 1);
1656 if (dev
->mc_count
> port
->adapter
->max_mc_mac
) {
1657 ehea_info("Mcast registration limit reached (0x%lx). "
1659 port
->adapter
->max_mc_mac
);
1663 for (i
= 0, k_mcl_entry
= dev
->mc_list
;
1665 i
++, k_mcl_entry
= k_mcl_entry
->next
) {
1666 ehea_add_multicast_entry(port
, k_mcl_entry
->dmi_addr
);
1673 static int ehea_change_mtu(struct net_device
*dev
, int new_mtu
)
1675 if ((new_mtu
< 68) || (new_mtu
> EHEA_MAX_PACKET_SIZE
))
1681 static void ehea_xmit2(struct sk_buff
*skb
, struct net_device
*dev
,
1682 struct ehea_swqe
*swqe
, u32 lkey
)
1684 if (skb
->protocol
== htons(ETH_P_IP
)) {
1686 swqe
->tx_control
|= EHEA_SWQE_CRC
1687 | EHEA_SWQE_IP_CHECKSUM
1688 | EHEA_SWQE_TCP_CHECKSUM
1689 | EHEA_SWQE_IMM_DATA_PRESENT
1690 | EHEA_SWQE_DESCRIPTORS_PRESENT
;
1692 write_ip_start_end(swqe
, skb
);
1694 if (skb
->nh
.iph
->protocol
== IPPROTO_UDP
) {
1695 if ((skb
->nh
.iph
->frag_off
& IP_MF
) ||
1696 (skb
->nh
.iph
->frag_off
& IP_OFFSET
))
1697 /* IP fragment, so don't change cs */
1698 swqe
->tx_control
&= ~EHEA_SWQE_TCP_CHECKSUM
;
1700 write_udp_offset_end(swqe
, skb
);
1702 } else if (skb
->nh
.iph
->protocol
== IPPROTO_TCP
) {
1703 write_tcp_offset_end(swqe
, skb
);
1706 /* icmp (big data) and ip segmentation packets (all other ip
1707 packets) do not require any special handling */
1710 /* Other Ethernet Protocol */
1711 swqe
->tx_control
|= EHEA_SWQE_CRC
1712 | EHEA_SWQE_IMM_DATA_PRESENT
1713 | EHEA_SWQE_DESCRIPTORS_PRESENT
;
1716 write_swqe2_data(skb
, dev
, swqe
, lkey
);
1719 static void ehea_xmit3(struct sk_buff
*skb
, struct net_device
*dev
,
1720 struct ehea_swqe
*swqe
)
1722 int nfrags
= skb_shinfo(skb
)->nr_frags
;
1723 u8
*imm_data
= &swqe
->u
.immdata_nodesc
.immediate_data
[0];
1727 if (skb
->protocol
== htons(ETH_P_IP
)) {
1729 write_ip_start_end(swqe
, skb
);
1731 if (skb
->nh
.iph
->protocol
== IPPROTO_TCP
) {
1732 swqe
->tx_control
|= EHEA_SWQE_CRC
1733 | EHEA_SWQE_IP_CHECKSUM
1734 | EHEA_SWQE_TCP_CHECKSUM
1735 | EHEA_SWQE_IMM_DATA_PRESENT
;
1737 write_tcp_offset_end(swqe
, skb
);
1739 } else if (skb
->nh
.iph
->protocol
== IPPROTO_UDP
) {
1740 if ((skb
->nh
.iph
->frag_off
& IP_MF
) ||
1741 (skb
->nh
.iph
->frag_off
& IP_OFFSET
))
1742 /* IP fragment, so don't change cs */
1743 swqe
->tx_control
|= EHEA_SWQE_CRC
1744 | EHEA_SWQE_IMM_DATA_PRESENT
;
1746 swqe
->tx_control
|= EHEA_SWQE_CRC
1747 | EHEA_SWQE_IP_CHECKSUM
1748 | EHEA_SWQE_TCP_CHECKSUM
1749 | EHEA_SWQE_IMM_DATA_PRESENT
;
1751 write_udp_offset_end(swqe
, skb
);
1754 /* icmp (big data) and
1755 ip segmentation packets (all other ip packets) */
1756 swqe
->tx_control
|= EHEA_SWQE_CRC
1757 | EHEA_SWQE_IP_CHECKSUM
1758 | EHEA_SWQE_IMM_DATA_PRESENT
;
1761 /* Other Ethernet Protocol */
1762 swqe
->tx_control
|= EHEA_SWQE_CRC
| EHEA_SWQE_IMM_DATA_PRESENT
;
1764 /* copy (immediate) data */
1766 /* data is in a single piece */
1767 memcpy(imm_data
, skb
->data
, skb
->len
);
1769 /* first copy data from the skb->data buffer ... */
1770 memcpy(imm_data
, skb
->data
, skb
->len
- skb
->data_len
);
1771 imm_data
+= skb
->len
- skb
->data_len
;
1773 /* ... then copy data from the fragments */
1774 for (i
= 0; i
< nfrags
; i
++) {
1775 frag
= &skb_shinfo(skb
)->frags
[i
];
1777 page_address(frag
->page
) + frag
->page_offset
,
1779 imm_data
+= frag
->size
;
1782 swqe
->immediate_data_length
= skb
->len
;
1786 static int ehea_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1788 struct ehea_port
*port
= netdev_priv(dev
);
1789 struct ehea_swqe
*swqe
;
1790 unsigned long flags
;
1793 struct ehea_port_res
*pr
= &port
->port_res
[0];
1795 spin_lock(&pr
->xmit_lock
);
1797 swqe
= ehea_get_swqe(pr
->qp
, &swqe_index
);
1798 memset(swqe
, 0, SWQE_HEADER_SIZE
);
1799 atomic_dec(&pr
->swqe_avail
);
1801 if (skb
->len
<= SWQE3_MAX_IMM
) {
1802 u32 sig_iv
= port
->sig_comp_iv
;
1803 u32 swqe_num
= pr
->swqe_id_counter
;
1804 ehea_xmit3(skb
, dev
, swqe
);
1805 swqe
->wr_id
= EHEA_BMASK_SET(EHEA_WR_ID_TYPE
, EHEA_SWQE3_TYPE
)
1806 | EHEA_BMASK_SET(EHEA_WR_ID_COUNT
, swqe_num
);
1807 if (pr
->swqe_ll_count
>= (sig_iv
- 1)) {
1808 swqe
->wr_id
|= EHEA_BMASK_SET(EHEA_WR_ID_REFILL
,
1810 swqe
->tx_control
|= EHEA_SWQE_SIGNALLED_COMPLETION
;
1811 pr
->swqe_ll_count
= 0;
1813 pr
->swqe_ll_count
+= 1;
1816 EHEA_BMASK_SET(EHEA_WR_ID_TYPE
, EHEA_SWQE2_TYPE
)
1817 | EHEA_BMASK_SET(EHEA_WR_ID_COUNT
, pr
->swqe_id_counter
)
1818 | EHEA_BMASK_SET(EHEA_WR_ID_INDEX
, pr
->sq_skba
.index
);
1819 pr
->sq_skba
.arr
[pr
->sq_skba
.index
] = skb
;
1821 pr
->sq_skba
.index
++;
1822 pr
->sq_skba
.index
&= (pr
->sq_skba
.len
- 1);
1824 lkey
= pr
->send_mr
.lkey
;
1825 ehea_xmit2(skb
, dev
, swqe
, lkey
);
1827 if (pr
->swqe_count
>= (EHEA_SIG_IV_LONG
- 1)) {
1828 swqe
->wr_id
|= EHEA_BMASK_SET(EHEA_WR_ID_REFILL
,
1830 swqe
->tx_control
|= EHEA_SWQE_SIGNALLED_COMPLETION
;
1833 pr
->swqe_count
+= 1;
1835 pr
->swqe_id_counter
+= 1;
1837 if (port
->vgrp
&& vlan_tx_tag_present(skb
)) {
1838 swqe
->tx_control
|= EHEA_SWQE_VLAN_INSERT
;
1839 swqe
->vlan_tag
= vlan_tx_tag_get(skb
);
1842 if (netif_msg_tx_queued(port
)) {
1843 ehea_info("post swqe on QP %d", pr
->qp
->init_attr
.qp_nr
);
1844 ehea_dump(swqe
, sizeof(*swqe
), "swqe");
1847 ehea_post_swqe(pr
->qp
, swqe
);
1850 if (unlikely(atomic_read(&pr
->swqe_avail
) <= 1)) {
1851 spin_lock_irqsave(&pr
->netif_queue
, flags
);
1852 if (unlikely(atomic_read(&pr
->swqe_avail
) <= 1)) {
1853 netif_stop_queue(dev
);
1854 pr
->queue_stopped
= 1;
1856 spin_unlock_irqrestore(&pr
->netif_queue
, flags
);
1858 dev
->trans_start
= jiffies
;
1859 spin_unlock(&pr
->xmit_lock
);
1861 return NETDEV_TX_OK
;
1864 static void ehea_vlan_rx_register(struct net_device
*dev
,
1865 struct vlan_group
*grp
)
1867 struct ehea_port
*port
= netdev_priv(dev
);
1868 struct ehea_adapter
*adapter
= port
->adapter
;
1869 struct hcp_ehea_port_cb1
*cb1
;
1874 cb1
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
1876 ehea_error("no mem for cb1");
1881 memset(cb1
->vlan_filter
, 0, sizeof(cb1
->vlan_filter
));
1883 memset(cb1
->vlan_filter
, 0xFF, sizeof(cb1
->vlan_filter
));
1885 hret
= ehea_h_modify_ehea_port(adapter
->handle
, port
->logical_port_id
,
1886 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
1887 if (hret
!= H_SUCCESS
)
1888 ehea_error("modify_ehea_port failed");
1895 static void ehea_vlan_rx_add_vid(struct net_device
*dev
, unsigned short vid
)
1897 struct ehea_port
*port
= netdev_priv(dev
);
1898 struct ehea_adapter
*adapter
= port
->adapter
;
1899 struct hcp_ehea_port_cb1
*cb1
;
1903 cb1
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
1905 ehea_error("no mem for cb1");
1909 hret
= ehea_h_query_ehea_port(adapter
->handle
, port
->logical_port_id
,
1910 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
1911 if (hret
!= H_SUCCESS
) {
1912 ehea_error("query_ehea_port failed");
1917 cb1
->vlan_filter
[index
] |= ((u64
)(1 << (vid
& 0x3F)));
1919 hret
= ehea_h_modify_ehea_port(adapter
->handle
, port
->logical_port_id
,
1920 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
1921 if (hret
!= H_SUCCESS
)
1922 ehea_error("modify_ehea_port failed");
1928 static void ehea_vlan_rx_kill_vid(struct net_device
*dev
, unsigned short vid
)
1930 struct ehea_port
*port
= netdev_priv(dev
);
1931 struct ehea_adapter
*adapter
= port
->adapter
;
1932 struct hcp_ehea_port_cb1
*cb1
;
1937 port
->vgrp
->vlan_devices
[vid
] = NULL
;
1939 cb1
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
1941 ehea_error("no mem for cb1");
1945 hret
= ehea_h_query_ehea_port(adapter
->handle
, port
->logical_port_id
,
1946 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
1947 if (hret
!= H_SUCCESS
) {
1948 ehea_error("query_ehea_port failed");
1953 cb1
->vlan_filter
[index
] &= ~((u64
)(1 << (vid
& 0x3F)));
1955 hret
= ehea_h_modify_ehea_port(adapter
->handle
, port
->logical_port_id
,
1956 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
1957 if (hret
!= H_SUCCESS
)
1958 ehea_error("modify_ehea_port failed");
1964 int ehea_activate_qp(struct ehea_adapter
*adapter
, struct ehea_qp
*qp
)
1970 struct hcp_modify_qp_cb0
* cb0
;
1972 cb0
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
1978 hret
= ehea_h_query_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
1979 EHEA_BMASK_SET(H_QPCB0_ALL
, 0xFFFF), cb0
);
1980 if (hret
!= H_SUCCESS
) {
1981 ehea_error("query_ehea_qp failed (1)");
1985 cb0
->qp_ctl_reg
= H_QP_CR_STATE_INITIALIZED
;
1986 hret
= ehea_h_modify_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
1987 EHEA_BMASK_SET(H_QPCB0_QP_CTL_REG
, 1), cb0
,
1988 &dummy64
, &dummy64
, &dummy16
, &dummy16
);
1989 if (hret
!= H_SUCCESS
) {
1990 ehea_error("modify_ehea_qp failed (1)");
1994 hret
= ehea_h_query_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
1995 EHEA_BMASK_SET(H_QPCB0_ALL
, 0xFFFF), cb0
);
1996 if (hret
!= H_SUCCESS
) {
1997 ehea_error("query_ehea_qp failed (2)");
2001 cb0
->qp_ctl_reg
= H_QP_CR_ENABLED
| H_QP_CR_STATE_INITIALIZED
;
2002 hret
= ehea_h_modify_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2003 EHEA_BMASK_SET(H_QPCB0_QP_CTL_REG
, 1), cb0
,
2004 &dummy64
, &dummy64
, &dummy16
, &dummy16
);
2005 if (hret
!= H_SUCCESS
) {
2006 ehea_error("modify_ehea_qp failed (2)");
2010 hret
= ehea_h_query_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2011 EHEA_BMASK_SET(H_QPCB0_ALL
, 0xFFFF), cb0
);
2012 if (hret
!= H_SUCCESS
) {
2013 ehea_error("query_ehea_qp failed (3)");
2017 cb0
->qp_ctl_reg
= H_QP_CR_ENABLED
| H_QP_CR_STATE_RDY2SND
;
2018 hret
= ehea_h_modify_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2019 EHEA_BMASK_SET(H_QPCB0_QP_CTL_REG
, 1), cb0
,
2020 &dummy64
, &dummy64
, &dummy16
, &dummy16
);
2021 if (hret
!= H_SUCCESS
) {
2022 ehea_error("modify_ehea_qp failed (3)");
2026 hret
= ehea_h_query_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2027 EHEA_BMASK_SET(H_QPCB0_ALL
, 0xFFFF), cb0
);
2028 if (hret
!= H_SUCCESS
) {
2029 ehea_error("query_ehea_qp failed (4)");
2039 static int ehea_port_res_setup(struct ehea_port
*port
, int def_qps
,
2043 struct port_res_cfg pr_cfg
, pr_cfg_small_rx
;
2044 enum ehea_eq_type eq_type
= EHEA_EQ
;
2046 port
->qp_eq
= ehea_create_eq(port
->adapter
, eq_type
,
2047 EHEA_MAX_ENTRIES_EQ
, 1);
2050 ehea_error("ehea_create_eq failed (qp_eq)");
2054 pr_cfg
.max_entries_rcq
= rq1_entries
+ rq2_entries
+ rq3_entries
;
2055 pr_cfg
.max_entries_scq
= sq_entries
;
2056 pr_cfg
.max_entries_sq
= sq_entries
;
2057 pr_cfg
.max_entries_rq1
= rq1_entries
;
2058 pr_cfg
.max_entries_rq2
= rq2_entries
;
2059 pr_cfg
.max_entries_rq3
= rq3_entries
;
2061 pr_cfg_small_rx
.max_entries_rcq
= 1;
2062 pr_cfg_small_rx
.max_entries_scq
= sq_entries
;
2063 pr_cfg_small_rx
.max_entries_sq
= sq_entries
;
2064 pr_cfg_small_rx
.max_entries_rq1
= 1;
2065 pr_cfg_small_rx
.max_entries_rq2
= 1;
2066 pr_cfg_small_rx
.max_entries_rq3
= 1;
2068 for (i
= 0; i
< def_qps
; i
++) {
2069 ret
= ehea_init_port_res(port
, &port
->port_res
[i
], &pr_cfg
, i
);
2073 for (i
= def_qps
; i
< def_qps
+ add_tx_qps
; i
++) {
2074 ret
= ehea_init_port_res(port
, &port
->port_res
[i
],
2075 &pr_cfg_small_rx
, i
);
2084 ehea_clean_portres(port
, &port
->port_res
[i
]);
2087 ehea_destroy_eq(port
->qp_eq
);
2091 static int ehea_clean_all_portres(struct ehea_port
*port
)
2096 for(i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++)
2097 ret
|= ehea_clean_portres(port
, &port
->port_res
[i
]);
2099 ret
|= ehea_destroy_eq(port
->qp_eq
);
2104 static int ehea_up(struct net_device
*dev
)
2107 struct ehea_port
*port
= netdev_priv(dev
);
2110 if (port
->state
== EHEA_PORT_UP
)
2113 ret
= ehea_port_res_setup(port
, port
->num_def_qps
,
2114 port
->num_add_tx_qps
);
2116 ehea_error("port_res_failed");
2120 /* Set default QP for this port */
2121 ret
= ehea_configure_port(port
);
2123 ehea_error("ehea_configure_port failed. ret:%d", ret
);
2127 ret
= ehea_broadcast_reg_helper(port
, H_REG_BCMC
);
2130 ehea_error("out_clean_pr");
2133 mac_addr
= (*(u64
*)dev
->dev_addr
) >> 16;
2135 ret
= ehea_reg_interrupts(dev
);
2137 ehea_error("out_dereg_bc");
2141 for(i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++) {
2142 ret
= ehea_activate_qp(port
->adapter
, port
->port_res
[i
].qp
);
2144 ehea_error("activate_qp failed");
2149 for(i
= 0; i
< port
->num_def_qps
; i
++) {
2150 ret
= ehea_fill_port_res(&port
->port_res
[i
]);
2152 ehea_error("out_free_irqs");
2158 port
->state
= EHEA_PORT_UP
;
2162 ehea_free_interrupts(dev
);
2165 ehea_broadcast_reg_helper(port
, H_DEREG_BCMC
);
2168 ehea_clean_all_portres(port
);
2173 static int ehea_open(struct net_device
*dev
)
2176 struct ehea_port
*port
= netdev_priv(dev
);
2178 down(&port
->port_lock
);
2180 if (netif_msg_ifup(port
))
2181 ehea_info("enabling port %s", dev
->name
);
2185 netif_start_queue(dev
);
2187 up(&port
->port_lock
);
2192 static int ehea_down(struct net_device
*dev
)
2195 struct ehea_port
*port
= netdev_priv(dev
);
2197 if (port
->state
== EHEA_PORT_DOWN
)
2200 ehea_drop_multicast_list(dev
);
2201 ehea_free_interrupts(dev
);
2203 for (i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++)
2204 tasklet_kill(&port
->port_res
[i
].send_comp_task
);
2206 ehea_broadcast_reg_helper(port
, H_DEREG_BCMC
);
2207 ret
= ehea_clean_all_portres(port
);
2208 port
->state
= EHEA_PORT_DOWN
;
2212 static int ehea_stop(struct net_device
*dev
)
2215 struct ehea_port
*port
= netdev_priv(dev
);
2217 if (netif_msg_ifdown(port
))
2218 ehea_info("disabling port %s", dev
->name
);
2220 flush_workqueue(port
->adapter
->ehea_wq
);
2221 down(&port
->port_lock
);
2222 netif_stop_queue(dev
);
2223 ret
= ehea_down(dev
);
2224 up(&port
->port_lock
);
2228 static void ehea_reset_port(void *data
)
2231 struct net_device
*dev
= data
;
2232 struct ehea_port
*port
= netdev_priv(dev
);
2235 down(&port
->port_lock
);
2236 netif_stop_queue(dev
);
2237 netif_poll_disable(dev
);
2239 ret
= ehea_down(dev
);
2241 ehea_error("ehea_down failed. not all resources are freed");
2245 ehea_error("Reset device %s failed: ret=%d", dev
->name
, ret
);
2249 if (netif_msg_timer(port
))
2250 ehea_info("Device %s resetted successfully", dev
->name
);
2252 netif_poll_enable(dev
);
2253 netif_wake_queue(dev
);
2255 up(&port
->port_lock
);
2259 static void ehea_tx_watchdog(struct net_device
*dev
)
2261 struct ehea_port
*port
= netdev_priv(dev
);
2263 if (netif_carrier_ok(dev
))
2264 queue_work(port
->adapter
->ehea_wq
, &port
->reset_task
);
2267 int ehea_sense_adapter_attr(struct ehea_adapter
*adapter
)
2269 struct hcp_query_ehea
*cb
;
2273 cb
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
2279 hret
= ehea_h_query_ehea(adapter
->handle
, cb
);
2281 if (hret
!= H_SUCCESS
) {
2286 adapter
->num_ports
= cb
->num_ports
;
2287 adapter
->max_mc_mac
= cb
->max_mc_mac
- 1;
2296 static int ehea_setup_single_port(struct ehea_port
*port
,
2297 struct device_node
*dn
)
2301 struct net_device
*dev
= port
->netdev
;
2302 struct ehea_adapter
*adapter
= port
->adapter
;
2303 struct hcp_ehea_port_cb4
*cb4
;
2304 u32
*dn_log_port_id
;
2306 sema_init(&port
->port_lock
, 1);
2307 port
->state
= EHEA_PORT_DOWN
;
2308 port
->sig_comp_iv
= sq_entries
/ 10;
2311 ehea_error("bad device node: dn=%p", dn
);
2316 port
->of_dev_node
= dn
;
2318 /* Determine logical port id */
2319 dn_log_port_id
= (u32
*)get_property(dn
, "ibm,hea-port-no", NULL
);
2321 if (!dn_log_port_id
) {
2322 ehea_error("bad device node: dn_log_port_id=%p",
2327 port
->logical_port_id
= *dn_log_port_id
;
2329 port
->mc_list
= kzalloc(sizeof(struct ehea_mc_list
), GFP_KERNEL
);
2330 if (!port
->mc_list
) {
2335 INIT_LIST_HEAD(&port
->mc_list
->list
);
2337 ehea_set_portspeed(port
, EHEA_SPEED_AUTONEG
);
2339 ret
= ehea_sense_port_attr(port
);
2343 /* Enable Jumbo frames */
2344 cb4
= kzalloc(H_CB_ALIGNMENT
, GFP_KERNEL
);
2346 ehea_error("no mem for cb4");
2348 cb4
->jumbo_frame
= 1;
2349 hret
= ehea_h_modify_ehea_port(adapter
->handle
,
2350 port
->logical_port_id
,
2351 H_PORT_CB4
, H_PORT_CB4_JUMBO
,
2353 if (hret
!= H_SUCCESS
) {
2354 ehea_info("Jumbo frames not activated");
2359 /* initialize net_device structure */
2360 SET_MODULE_OWNER(dev
);
2362 memcpy(dev
->dev_addr
, &port
->mac_addr
, ETH_ALEN
);
2364 dev
->open
= ehea_open
;
2365 dev
->poll
= ehea_poll
;
2367 dev
->stop
= ehea_stop
;
2368 dev
->hard_start_xmit
= ehea_start_xmit
;
2369 dev
->get_stats
= ehea_get_stats
;
2370 dev
->set_multicast_list
= ehea_set_multicast_list
;
2371 dev
->set_mac_address
= ehea_set_mac_addr
;
2372 dev
->change_mtu
= ehea_change_mtu
;
2373 dev
->vlan_rx_register
= ehea_vlan_rx_register
;
2374 dev
->vlan_rx_add_vid
= ehea_vlan_rx_add_vid
;
2375 dev
->vlan_rx_kill_vid
= ehea_vlan_rx_kill_vid
;
2376 dev
->features
= NETIF_F_SG
| NETIF_F_FRAGLIST
| NETIF_F_TSO
2377 | NETIF_F_HIGHDMA
| NETIF_F_HW_CSUM
| NETIF_F_HW_VLAN_TX
2378 | NETIF_F_HW_VLAN_RX
| NETIF_F_HW_VLAN_FILTER
2380 dev
->tx_timeout
= &ehea_tx_watchdog
;
2381 dev
->watchdog_timeo
= EHEA_WATCH_DOG_TIMEOUT
;
2383 INIT_WORK(&port
->reset_task
, ehea_reset_port
, dev
);
2385 ehea_set_ethtool_ops(dev
);
2387 ret
= register_netdev(dev
);
2389 ehea_error("register_netdev failed. ret=%d", ret
);
2398 kfree(port
->mc_list
);
2403 static int ehea_setup_ports(struct ehea_adapter
*adapter
)
2406 int port_setup_ok
= 0;
2407 struct ehea_port
*port
;
2408 struct device_node
*dn
= NULL
;
2409 struct net_device
*dev
;
2412 /* get port properties for all ports */
2413 for (i
= 0; i
< adapter
->num_ports
; i
++) {
2415 if (adapter
->port
[i
])
2416 continue; /* port already up and running */
2418 /* allocate memory for the port structures */
2419 dev
= alloc_etherdev(sizeof(struct ehea_port
));
2422 ehea_error("no mem for net_device");
2426 port
= netdev_priv(dev
);
2427 port
->adapter
= adapter
;
2429 adapter
->port
[i
] = port
;
2430 port
->msg_enable
= netif_msg_init(msg_level
, EHEA_MSG_DEFAULT
);
2432 dn
= of_find_node_by_name(dn
, "ethernet");
2433 ret
= ehea_setup_single_port(port
, dn
);
2435 /* Free mem for this port struct. The others will be
2436 processed on rollback */
2438 adapter
->port
[i
] = NULL
;
2439 ehea_error("eHEA port %d setup failed, ret=%d", i
, ret
);
2445 /* Check for succesfully set up ports */
2446 for (i
= 0; i
< adapter
->num_ports
; i
++)
2447 if (adapter
->port
[i
])
2451 ret
= 0; /* At least some ports are setup correctly */
2458 static int __devinit
ehea_probe(struct ibmebus_dev
*dev
,
2459 const struct of_device_id
*id
)
2461 struct ehea_adapter
*adapter
;
2462 u64
*adapter_handle
;
2465 adapter
= kzalloc(sizeof(*adapter
), GFP_KERNEL
);
2468 dev_err(&dev
->ofdev
.dev
, "no mem for ehea_adapter\n");
2472 adapter_handle
= (u64
*)get_property(dev
->ofdev
.node
, "ibm,hea-handle",
2474 if (!adapter_handle
) {
2475 dev_err(&dev
->ofdev
.dev
, "failed getting handle for adapter"
2476 " '%s'\n", dev
->ofdev
.node
->full_name
);
2481 adapter
->handle
= *adapter_handle
;
2482 adapter
->pd
= EHEA_PD_ID
;
2484 dev
->ofdev
.dev
.driver_data
= adapter
;
2486 ret
= ehea_reg_mr_adapter(adapter
);
2488 dev_err(&dev
->ofdev
.dev
, "reg_mr_adapter failed\n");
2492 /* initialize adapter and ports */
2493 /* get adapter properties */
2494 ret
= ehea_sense_adapter_attr(adapter
);
2496 dev_err(&dev
->ofdev
.dev
, "sense_adapter_attr failed: %d", ret
);
2499 dev_info(&dev
->ofdev
.dev
, "%d eHEA ports found\n", adapter
->num_ports
);
2501 adapter
->neq
= ehea_create_eq(adapter
,
2502 EHEA_NEQ
, EHEA_MAX_ENTRIES_EQ
, 1);
2503 if (!adapter
->neq
) {
2504 dev_err(&dev
->ofdev
.dev
, "NEQ creation failed");
2508 tasklet_init(&adapter
->neq_tasklet
, ehea_neq_tasklet
,
2509 (unsigned long)adapter
);
2511 ret
= ibmebus_request_irq(NULL
, adapter
->neq
->attr
.ist1
,
2512 ehea_interrupt_neq
, SA_INTERRUPT
,
2513 "ehea_neq", adapter
);
2515 dev_err(&dev
->ofdev
.dev
, "requesting NEQ IRQ failed");
2519 adapter
->ehea_wq
= create_workqueue("ehea_wq");
2520 if (!adapter
->ehea_wq
)
2523 ret
= ehea_setup_ports(adapter
);
2525 dev_err(&dev
->ofdev
.dev
, "setup_ports failed");
2533 destroy_workqueue(adapter
->ehea_wq
);
2536 ibmebus_free_irq(NULL
, adapter
->neq
->attr
.ist1
, adapter
);
2539 ehea_destroy_eq(adapter
->neq
);
2542 ehea_h_free_resource(adapter
->handle
, adapter
->mr
.handle
);
2550 static void ehea_shutdown_single_port(struct ehea_port
*port
)
2552 unregister_netdev(port
->netdev
);
2553 kfree(port
->mc_list
);
2554 free_netdev(port
->netdev
);
2557 static int __devexit
ehea_remove(struct ibmebus_dev
*dev
)
2559 struct ehea_adapter
*adapter
= dev
->ofdev
.dev
.driver_data
;
2563 for (i
= 0; i
< adapter
->num_ports
; i
++)
2564 if (adapter
->port
[i
]) {
2565 ehea_shutdown_single_port(adapter
->port
[i
]);
2566 adapter
->port
[i
] = NULL
;
2568 destroy_workqueue(adapter
->ehea_wq
);
2570 ibmebus_free_irq(NULL
, adapter
->neq
->attr
.ist1
, adapter
);
2572 ehea_destroy_eq(adapter
->neq
);
2574 hret
= ehea_h_free_resource(adapter
->handle
, adapter
->mr
.handle
);
2576 dev_err(&dev
->ofdev
.dev
, "free_resource_mr failed");
2583 static int check_module_parm(void)
2587 if ((rq1_entries
< EHEA_MIN_ENTRIES_QP
) ||
2588 (rq1_entries
> EHEA_MAX_ENTRIES_RQ1
)) {
2589 ehea_info("Bad parameter: rq1_entries");
2592 if ((rq2_entries
< EHEA_MIN_ENTRIES_QP
) ||
2593 (rq2_entries
> EHEA_MAX_ENTRIES_RQ2
)) {
2594 ehea_info("Bad parameter: rq2_entries");
2597 if ((rq3_entries
< EHEA_MIN_ENTRIES_QP
) ||
2598 (rq3_entries
> EHEA_MAX_ENTRIES_RQ3
)) {
2599 ehea_info("Bad parameter: rq3_entries");
2602 if ((sq_entries
< EHEA_MIN_ENTRIES_QP
) ||
2603 (sq_entries
> EHEA_MAX_ENTRIES_SQ
)) {
2604 ehea_info("Bad parameter: sq_entries");
2611 static struct of_device_id ehea_device_table
[] = {
2614 .compatible
= "IBM,lhea",
2619 static struct ibmebus_driver ehea_driver
= {
2621 .id_table
= ehea_device_table
,
2622 .probe
= ehea_probe
,
2623 .remove
= ehea_remove
,
2626 int __init
ehea_module_init(void)
2630 printk(KERN_INFO
"IBM eHEA ethernet device driver (Release %s)\n",
2633 ret
= check_module_parm();
2636 ret
= ibmebus_register_driver(&ehea_driver
);
2638 ehea_error("failed registering eHEA device driver on ebus");
2644 static void __exit
ehea_module_exit(void)
2646 ibmebus_unregister_driver(&ehea_driver
);
2649 module_init(ehea_module_init
);
2650 module_exit(ehea_module_exit
);