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
;
54 static int use_mcs
= 0;
55 static int num_tx_qps
= EHEA_NUM_TX_QP
;
57 module_param(msg_level
, int, 0);
58 module_param(rq1_entries
, int, 0);
59 module_param(rq2_entries
, int, 0);
60 module_param(rq3_entries
, int, 0);
61 module_param(sq_entries
, int, 0);
62 module_param(use_mcs
, int, 0);
63 module_param(num_tx_qps
, int, 0);
65 MODULE_PARM_DESC(num_tx_qps
, "Number of TX-QPS");
66 MODULE_PARM_DESC(msg_level
, "msg_level");
67 MODULE_PARM_DESC(rq3_entries
, "Number of entries for Receive Queue 3 "
68 "[2^x - 1], x = [6..14]. Default = "
69 __MODULE_STRING(EHEA_DEF_ENTRIES_RQ3
) ")");
70 MODULE_PARM_DESC(rq2_entries
, "Number of entries for Receive Queue 2 "
71 "[2^x - 1], x = [6..14]. Default = "
72 __MODULE_STRING(EHEA_DEF_ENTRIES_RQ2
) ")");
73 MODULE_PARM_DESC(rq1_entries
, "Number of entries for Receive Queue 1 "
74 "[2^x - 1], x = [6..14]. Default = "
75 __MODULE_STRING(EHEA_DEF_ENTRIES_RQ1
) ")");
76 MODULE_PARM_DESC(sq_entries
, " Number of entries for the Send Queue "
77 "[2^x - 1], x = [6..14]. Default = "
78 __MODULE_STRING(EHEA_DEF_ENTRIES_SQ
) ")");
79 MODULE_PARM_DESC(use_mcs
, " 0:NAPI, 1:Multiple receive queues, Default = 0 ");
81 static int port_name_cnt
= 0;
82 static LIST_HEAD(adapter_list
);
83 u64 ehea_driver_flags
= 0;
84 struct workqueue_struct
*ehea_driver_wq
;
85 struct work_struct ehea_rereg_mr_task
;
88 static int __devinit
ehea_probe_adapter(struct ibmebus_dev
*dev
,
89 const struct of_device_id
*id
);
91 static int __devexit
ehea_remove(struct ibmebus_dev
*dev
);
93 static struct of_device_id ehea_device_table
[] = {
96 .compatible
= "IBM,lhea",
101 static struct ibmebus_driver ehea_driver
= {
103 .id_table
= ehea_device_table
,
104 .probe
= ehea_probe_adapter
,
105 .remove
= ehea_remove
,
108 void ehea_dump(void *adr
, int len
, char *msg
) {
110 unsigned char *deb
= adr
;
111 for (x
= 0; x
< len
; x
+= 16) {
112 printk(DRV_NAME
" %s adr=%p ofs=%04x %016lx %016lx\n", msg
,
113 deb
, x
, *((u64
*)&deb
[0]), *((u64
*)&deb
[8]));
118 static struct net_device_stats
*ehea_get_stats(struct net_device
*dev
)
120 struct ehea_port
*port
= netdev_priv(dev
);
121 struct net_device_stats
*stats
= &port
->stats
;
122 struct hcp_ehea_port_cb2
*cb2
;
123 u64 hret
, rx_packets
;
126 memset(stats
, 0, sizeof(*stats
));
128 cb2
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
130 ehea_error("no mem for cb2");
134 hret
= ehea_h_query_ehea_port(port
->adapter
->handle
,
135 port
->logical_port_id
,
136 H_PORT_CB2
, H_PORT_CB2_ALL
, cb2
);
137 if (hret
!= H_SUCCESS
) {
138 ehea_error("query_ehea_port failed");
142 if (netif_msg_hw(port
))
143 ehea_dump(cb2
, sizeof(*cb2
), "net_device_stats");
146 for (i
= 0; i
< port
->num_def_qps
; i
++)
147 rx_packets
+= port
->port_res
[i
].rx_packets
;
149 stats
->tx_packets
= cb2
->txucp
+ cb2
->txmcp
+ cb2
->txbcp
;
150 stats
->multicast
= cb2
->rxmcp
;
151 stats
->rx_errors
= cb2
->rxuerr
;
152 stats
->rx_bytes
= cb2
->rxo
;
153 stats
->tx_bytes
= cb2
->txo
;
154 stats
->rx_packets
= rx_packets
;
162 static void ehea_refill_rq1(struct ehea_port_res
*pr
, int index
, int nr_of_wqes
)
164 struct sk_buff
**skb_arr_rq1
= pr
->rq1_skba
.arr
;
165 struct net_device
*dev
= pr
->port
->netdev
;
166 int max_index_mask
= pr
->rq1_skba
.len
- 1;
172 for (i
= 0; i
< nr_of_wqes
; i
++) {
173 if (!skb_arr_rq1
[index
]) {
174 skb_arr_rq1
[index
] = netdev_alloc_skb(dev
,
176 if (!skb_arr_rq1
[index
]) {
177 ehea_error("%s: no mem for skb/%d wqes filled",
183 index
&= max_index_mask
;
186 ehea_update_rq1a(pr
->qp
, i
);
189 static int ehea_init_fill_rq1(struct ehea_port_res
*pr
, int nr_rq1a
)
192 struct sk_buff
**skb_arr_rq1
= pr
->rq1_skba
.arr
;
193 struct net_device
*dev
= pr
->port
->netdev
;
196 for (i
= 0; i
< pr
->rq1_skba
.len
; i
++) {
197 skb_arr_rq1
[i
] = netdev_alloc_skb(dev
, EHEA_L_PKT_SIZE
);
198 if (!skb_arr_rq1
[i
]) {
199 ehea_error("%s: no mem for skb/%d wqes filled",
206 ehea_update_rq1a(pr
->qp
, nr_rq1a
);
211 static int ehea_refill_rq_def(struct ehea_port_res
*pr
,
212 struct ehea_q_skb_arr
*q_skba
, int rq_nr
,
213 int num_wqes
, int wqe_type
, int packet_size
)
215 struct net_device
*dev
= pr
->port
->netdev
;
216 struct ehea_qp
*qp
= pr
->qp
;
217 struct sk_buff
**skb_arr
= q_skba
->arr
;
218 struct ehea_rwqe
*rwqe
;
219 int i
, index
, max_index_mask
, fill_wqes
;
222 fill_wqes
= q_skba
->os_skbs
+ num_wqes
;
227 index
= q_skba
->index
;
228 max_index_mask
= q_skba
->len
- 1;
229 for (i
= 0; i
< fill_wqes
; i
++) {
230 struct sk_buff
*skb
= netdev_alloc_skb(dev
, packet_size
);
232 ehea_error("%s: no mem for skb/%d wqes filled",
233 pr
->port
->netdev
->name
, i
);
234 q_skba
->os_skbs
= fill_wqes
- i
;
238 skb_reserve(skb
, NET_IP_ALIGN
);
240 skb_arr
[index
] = skb
;
242 rwqe
= ehea_get_next_rwqe(qp
, rq_nr
);
243 rwqe
->wr_id
= EHEA_BMASK_SET(EHEA_WR_ID_TYPE
, wqe_type
)
244 | EHEA_BMASK_SET(EHEA_WR_ID_INDEX
, index
);
245 rwqe
->sg_list
[0].l_key
= pr
->recv_mr
.lkey
;
246 rwqe
->sg_list
[0].vaddr
= ehea_map_vaddr(skb
->data
);
247 rwqe
->sg_list
[0].len
= packet_size
;
248 rwqe
->data_segments
= 1;
251 index
&= max_index_mask
;
253 if (unlikely(test_bit(__EHEA_STOP_XFER
, &ehea_driver_flags
)))
257 q_skba
->index
= index
;
262 ehea_update_rq2a(pr
->qp
, i
);
264 ehea_update_rq3a(pr
->qp
, i
);
270 static int ehea_refill_rq2(struct ehea_port_res
*pr
, int nr_of_wqes
)
272 return ehea_refill_rq_def(pr
, &pr
->rq2_skba
, 2,
273 nr_of_wqes
, EHEA_RWQE2_TYPE
,
274 EHEA_RQ2_PKT_SIZE
+ NET_IP_ALIGN
);
278 static int ehea_refill_rq3(struct ehea_port_res
*pr
, int nr_of_wqes
)
280 return ehea_refill_rq_def(pr
, &pr
->rq3_skba
, 3,
281 nr_of_wqes
, EHEA_RWQE3_TYPE
,
282 EHEA_MAX_PACKET_SIZE
+ NET_IP_ALIGN
);
285 static inline int ehea_check_cqe(struct ehea_cqe
*cqe
, int *rq_num
)
287 *rq_num
= (cqe
->type
& EHEA_CQE_TYPE_RQ
) >> 5;
288 if ((cqe
->status
& EHEA_CQE_STAT_ERR_MASK
) == 0)
290 if (((cqe
->status
& EHEA_CQE_STAT_ERR_TCP
) != 0) &&
291 (cqe
->header_length
== 0))
296 static inline void ehea_fill_skb(struct net_device
*dev
,
297 struct sk_buff
*skb
, struct ehea_cqe
*cqe
)
299 int length
= cqe
->num_bytes_transfered
- 4; /*remove CRC */
301 skb_put(skb
, length
);
302 skb
->ip_summed
= CHECKSUM_UNNECESSARY
;
303 skb
->protocol
= eth_type_trans(skb
, dev
);
306 static inline struct sk_buff
*get_skb_by_index(struct sk_buff
**skb_array
,
308 struct ehea_cqe
*cqe
)
310 int skb_index
= EHEA_BMASK_GET(EHEA_WR_ID_INDEX
, cqe
->wr_id
);
320 prefetchw(pref
+ EHEA_CACHE_LINE
);
322 pref
= (skb_array
[x
]->data
);
324 prefetch(pref
+ EHEA_CACHE_LINE
);
325 prefetch(pref
+ EHEA_CACHE_LINE
* 2);
326 prefetch(pref
+ EHEA_CACHE_LINE
* 3);
327 skb
= skb_array
[skb_index
];
328 skb_array
[skb_index
] = NULL
;
332 static inline struct sk_buff
*get_skb_by_index_ll(struct sk_buff
**skb_array
,
333 int arr_len
, int wqe_index
)
344 prefetchw(pref
+ EHEA_CACHE_LINE
);
346 pref
= (skb_array
[x
]->data
);
348 prefetchw(pref
+ EHEA_CACHE_LINE
);
350 skb
= skb_array
[wqe_index
];
351 skb_array
[wqe_index
] = NULL
;
355 static int ehea_treat_poll_error(struct ehea_port_res
*pr
, int rq
,
356 struct ehea_cqe
*cqe
, int *processed_rq2
,
361 if (cqe
->status
& EHEA_CQE_STAT_ERR_TCP
)
362 pr
->p_stats
.err_tcp_cksum
++;
363 if (cqe
->status
& EHEA_CQE_STAT_ERR_IP
)
364 pr
->p_stats
.err_ip_cksum
++;
365 if (cqe
->status
& EHEA_CQE_STAT_ERR_CRC
)
366 pr
->p_stats
.err_frame_crc
++;
368 if (netif_msg_rx_err(pr
->port
)) {
369 ehea_error("CQE Error for QP %d", pr
->qp
->init_attr
.qp_nr
);
370 ehea_dump(cqe
, sizeof(*cqe
), "CQE");
375 skb
= get_skb_by_index(pr
->rq2_skba
.arr
, pr
->rq2_skba
.len
, cqe
);
377 } else if (rq
== 3) {
379 skb
= get_skb_by_index(pr
->rq3_skba
.arr
, pr
->rq3_skba
.len
, cqe
);
383 if (cqe
->status
& EHEA_CQE_STAT_FAT_ERR_MASK
) {
384 ehea_error("Critical receive error. Resetting port.");
385 queue_work(pr
->port
->adapter
->ehea_wq
, &pr
->port
->reset_task
);
392 static struct ehea_cqe
*ehea_proc_rwqes(struct net_device
*dev
,
393 struct ehea_port_res
*pr
,
396 struct ehea_port
*port
= pr
->port
;
397 struct ehea_qp
*qp
= pr
->qp
;
398 struct ehea_cqe
*cqe
;
400 struct sk_buff
**skb_arr_rq1
= pr
->rq1_skba
.arr
;
401 struct sk_buff
**skb_arr_rq2
= pr
->rq2_skba
.arr
;
402 struct sk_buff
**skb_arr_rq3
= pr
->rq3_skba
.arr
;
403 int skb_arr_rq1_len
= pr
->rq1_skba
.len
;
404 int skb_arr_rq2_len
= pr
->rq2_skba
.len
;
405 int skb_arr_rq3_len
= pr
->rq3_skba
.len
;
406 int processed
, processed_rq1
, processed_rq2
, processed_rq3
;
407 int wqe_index
, last_wqe_index
, rq
, my_quota
, port_reset
;
409 processed
= processed_rq1
= processed_rq2
= processed_rq3
= 0;
411 my_quota
= min(*budget
, dev
->quota
);
413 cqe
= ehea_poll_rq1(qp
, &wqe_index
);
414 while ((my_quota
> 0) && cqe
) {
419 if (netif_msg_rx_status(port
))
420 ehea_dump(cqe
, sizeof(*cqe
), "CQE");
422 last_wqe_index
= wqe_index
;
424 if (!ehea_check_cqe(cqe
, &rq
)) {
425 if (rq
== 1) { /* LL RQ1 */
426 skb
= get_skb_by_index_ll(skb_arr_rq1
,
429 if (unlikely(!skb
)) {
430 if (netif_msg_rx_err(port
))
431 ehea_error("LL rq1: skb=NULL");
433 skb
= netdev_alloc_skb(port
->netdev
,
438 skb_copy_to_linear_data(skb
, ((char*)cqe
) + 64,
439 cqe
->num_bytes_transfered
- 4);
440 ehea_fill_skb(port
->netdev
, skb
, cqe
);
441 } else if (rq
== 2) { /* RQ2 */
442 skb
= get_skb_by_index(skb_arr_rq2
,
443 skb_arr_rq2_len
, cqe
);
444 if (unlikely(!skb
)) {
445 if (netif_msg_rx_err(port
))
446 ehea_error("rq2: skb=NULL");
449 ehea_fill_skb(port
->netdev
, skb
, cqe
);
452 skb
= get_skb_by_index(skb_arr_rq3
,
453 skb_arr_rq3_len
, cqe
);
454 if (unlikely(!skb
)) {
455 if (netif_msg_rx_err(port
))
456 ehea_error("rq3: skb=NULL");
459 ehea_fill_skb(port
->netdev
, skb
, cqe
);
463 if ((cqe
->status
& EHEA_CQE_VLAN_TAG_XTRACT
)
465 vlan_hwaccel_receive_skb(skb
, port
->vgrp
,
468 netif_receive_skb(skb
);
470 dev
->last_rx
= jiffies
;
472 pr
->p_stats
.poll_receive_errors
++;
473 port_reset
= ehea_treat_poll_error(pr
, rq
, cqe
,
479 cqe
= ehea_poll_rq1(qp
, &wqe_index
);
482 pr
->rx_packets
+= processed
;
483 *budget
-= processed
;
485 ehea_refill_rq1(pr
, last_wqe_index
, processed_rq1
);
486 ehea_refill_rq2(pr
, processed_rq2
);
487 ehea_refill_rq3(pr
, processed_rq3
);
489 cqe
= ehea_poll_rq1(qp
, &wqe_index
);
493 static struct ehea_cqe
*ehea_proc_cqes(struct ehea_port_res
*pr
, int my_quota
)
496 struct ehea_cq
*send_cq
= pr
->send_cq
;
497 struct ehea_cqe
*cqe
;
498 int quota
= my_quota
;
504 cqe
= ehea_poll_cq(send_cq
);
505 while(cqe
&& (quota
> 0)) {
506 ehea_inc_cq(send_cq
);
510 if (cqe
->status
& EHEA_CQE_STAT_ERR_MASK
) {
511 ehea_error("Send Completion Error: Resetting port");
512 if (netif_msg_tx_err(pr
->port
))
513 ehea_dump(cqe
, sizeof(*cqe
), "Send CQE");
514 queue_work(pr
->port
->adapter
->ehea_wq
,
515 &pr
->port
->reset_task
);
519 if (netif_msg_tx_done(pr
->port
))
520 ehea_dump(cqe
, sizeof(*cqe
), "CQE");
522 if (likely(EHEA_BMASK_GET(EHEA_WR_ID_TYPE
, cqe
->wr_id
)
523 == EHEA_SWQE2_TYPE
)) {
525 index
= EHEA_BMASK_GET(EHEA_WR_ID_INDEX
, cqe
->wr_id
);
526 skb
= pr
->sq_skba
.arr
[index
];
528 pr
->sq_skba
.arr
[index
] = NULL
;
531 swqe_av
+= EHEA_BMASK_GET(EHEA_WR_ID_REFILL
, cqe
->wr_id
);
534 cqe
= ehea_poll_cq(send_cq
);
537 ehea_update_feca(send_cq
, cqe_counter
);
538 atomic_add(swqe_av
, &pr
->swqe_avail
);
540 spin_lock_irqsave(&pr
->netif_queue
, flags
);
542 if (pr
->queue_stopped
&& (atomic_read(&pr
->swqe_avail
)
543 >= pr
->swqe_refill_th
)) {
544 netif_wake_queue(pr
->port
->netdev
);
545 pr
->queue_stopped
= 0;
547 spin_unlock_irqrestore(&pr
->netif_queue
, flags
);
552 #define EHEA_NAPI_POLL_NUM_BEFORE_IRQ 16
554 static int ehea_poll(struct net_device
*dev
, int *budget
)
556 struct ehea_port_res
*pr
= dev
->priv
;
557 struct ehea_cqe
*cqe
;
558 struct ehea_cqe
*cqe_skb
= NULL
;
559 int force_irq
, wqe_index
;
561 cqe
= ehea_poll_rq1(pr
->qp
, &wqe_index
);
562 cqe_skb
= ehea_poll_cq(pr
->send_cq
);
564 force_irq
= (pr
->poll_counter
> EHEA_NAPI_POLL_NUM_BEFORE_IRQ
);
566 if ((!cqe
&& !cqe_skb
) || force_irq
) {
567 pr
->poll_counter
= 0;
568 netif_rx_complete(dev
);
569 ehea_reset_cq_ep(pr
->recv_cq
);
570 ehea_reset_cq_ep(pr
->send_cq
);
571 ehea_reset_cq_n1(pr
->recv_cq
);
572 ehea_reset_cq_n1(pr
->send_cq
);
573 cqe
= ehea_poll_rq1(pr
->qp
, &wqe_index
);
574 cqe_skb
= ehea_poll_cq(pr
->send_cq
);
576 if (!cqe
&& !cqe_skb
)
579 if (!netif_rx_reschedule(dev
, dev
->quota
))
583 cqe
= ehea_proc_rwqes(dev
, pr
, budget
);
584 cqe_skb
= ehea_proc_cqes(pr
, 300);
592 #ifdef CONFIG_NET_POLL_CONTROLLER
593 static void ehea_netpoll(struct net_device
*dev
)
595 struct ehea_port
*port
= netdev_priv(dev
);
597 netif_rx_schedule(port
->port_res
[0].d_netdev
);
601 static int ehea_poll_firstqueue(struct net_device
*dev
, int *budget
)
603 struct ehea_port
*port
= netdev_priv(dev
);
604 struct net_device
*d_dev
= port
->port_res
[0].d_netdev
;
606 return ehea_poll(d_dev
, budget
);
609 static irqreturn_t
ehea_recv_irq_handler(int irq
, void *param
)
611 struct ehea_port_res
*pr
= param
;
613 netif_rx_schedule(pr
->d_netdev
);
618 static irqreturn_t
ehea_qp_aff_irq_handler(int irq
, void *param
)
620 struct ehea_port
*port
= param
;
621 struct ehea_eqe
*eqe
;
625 eqe
= ehea_poll_eq(port
->qp_eq
);
628 qp_token
= EHEA_BMASK_GET(EHEA_EQE_QP_TOKEN
, eqe
->entry
);
629 ehea_error("QP aff_err: entry=0x%lx, token=0x%x",
630 eqe
->entry
, qp_token
);
632 qp
= port
->port_res
[qp_token
].qp
;
633 ehea_error_data(port
->adapter
, qp
->fw_handle
);
634 eqe
= ehea_poll_eq(port
->qp_eq
);
637 queue_work(port
->adapter
->ehea_wq
, &port
->reset_task
);
642 static struct ehea_port
*ehea_get_port(struct ehea_adapter
*adapter
,
647 for (i
= 0; i
< EHEA_MAX_PORTS
; i
++)
648 if (adapter
->port
[i
])
649 if (adapter
->port
[i
]->logical_port_id
== logical_port
)
650 return adapter
->port
[i
];
654 int ehea_sense_port_attr(struct ehea_port
*port
)
658 struct hcp_ehea_port_cb0
*cb0
;
660 cb0
= kzalloc(PAGE_SIZE
, GFP_ATOMIC
); /* May be called via */
661 if (!cb0
) { /* ehea_neq_tasklet() */
662 ehea_error("no mem for cb0");
667 hret
= ehea_h_query_ehea_port(port
->adapter
->handle
,
668 port
->logical_port_id
, H_PORT_CB0
,
669 EHEA_BMASK_SET(H_PORT_CB0_ALL
, 0xFFFF),
671 if (hret
!= H_SUCCESS
) {
677 port
->mac_addr
= cb0
->port_mac_addr
<< 16;
679 if (!is_valid_ether_addr((u8
*)&port
->mac_addr
)) {
680 ret
= -EADDRNOTAVAIL
;
685 switch (cb0
->port_speed
) {
687 port
->port_speed
= EHEA_SPEED_10M
;
688 port
->full_duplex
= 0;
691 port
->port_speed
= EHEA_SPEED_10M
;
692 port
->full_duplex
= 1;
695 port
->port_speed
= EHEA_SPEED_100M
;
696 port
->full_duplex
= 0;
699 port
->port_speed
= EHEA_SPEED_100M
;
700 port
->full_duplex
= 1;
703 port
->port_speed
= EHEA_SPEED_1G
;
704 port
->full_duplex
= 1;
707 port
->port_speed
= EHEA_SPEED_10G
;
708 port
->full_duplex
= 1;
711 port
->port_speed
= 0;
712 port
->full_duplex
= 0;
717 port
->num_mcs
= cb0
->num_default_qps
;
719 /* Number of default QPs */
721 port
->num_def_qps
= cb0
->num_default_qps
;
723 port
->num_def_qps
= 1;
725 if (!port
->num_def_qps
) {
730 port
->num_tx_qps
= num_tx_qps
;
732 if (port
->num_def_qps
>= port
->num_tx_qps
)
733 port
->num_add_tx_qps
= 0;
735 port
->num_add_tx_qps
= port
->num_tx_qps
- port
->num_def_qps
;
739 if (ret
|| netif_msg_probe(port
))
740 ehea_dump(cb0
, sizeof(*cb0
), "ehea_sense_port_attr");
746 int ehea_set_portspeed(struct ehea_port
*port
, u32 port_speed
)
748 struct hcp_ehea_port_cb4
*cb4
;
752 cb4
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
754 ehea_error("no mem for cb4");
759 cb4
->port_speed
= port_speed
;
761 netif_carrier_off(port
->netdev
);
763 hret
= ehea_h_modify_ehea_port(port
->adapter
->handle
,
764 port
->logical_port_id
,
765 H_PORT_CB4
, H_PORT_CB4_SPEED
, cb4
);
766 if (hret
== H_SUCCESS
) {
767 port
->autoneg
= port_speed
== EHEA_SPEED_AUTONEG
? 1 : 0;
769 hret
= ehea_h_query_ehea_port(port
->adapter
->handle
,
770 port
->logical_port_id
,
771 H_PORT_CB4
, H_PORT_CB4_SPEED
,
773 if (hret
== H_SUCCESS
) {
774 switch (cb4
->port_speed
) {
776 port
->port_speed
= EHEA_SPEED_10M
;
777 port
->full_duplex
= 0;
780 port
->port_speed
= EHEA_SPEED_10M
;
781 port
->full_duplex
= 1;
784 port
->port_speed
= EHEA_SPEED_100M
;
785 port
->full_duplex
= 0;
788 port
->port_speed
= EHEA_SPEED_100M
;
789 port
->full_duplex
= 1;
792 port
->port_speed
= EHEA_SPEED_1G
;
793 port
->full_duplex
= 1;
796 port
->port_speed
= EHEA_SPEED_10G
;
797 port
->full_duplex
= 1;
800 port
->port_speed
= 0;
801 port
->full_duplex
= 0;
805 ehea_error("Failed sensing port speed");
809 if (hret
== H_AUTHORITY
) {
810 ehea_info("Hypervisor denied setting port speed");
814 ehea_error("Failed setting port speed");
817 netif_carrier_on(port
->netdev
);
823 static void ehea_parse_eqe(struct ehea_adapter
*adapter
, u64 eqe
)
828 struct ehea_port
*port
;
830 ec
= EHEA_BMASK_GET(NEQE_EVENT_CODE
, eqe
);
831 portnum
= EHEA_BMASK_GET(NEQE_PORTNUM
, eqe
);
832 port
= ehea_get_port(adapter
, portnum
);
835 case EHEA_EC_PORTSTATE_CHG
: /* port state change */
838 ehea_error("unknown portnum %x", portnum
);
842 if (EHEA_BMASK_GET(NEQE_PORT_UP
, eqe
)) {
843 if (!netif_carrier_ok(port
->netdev
)) {
844 ret
= ehea_sense_port_attr(port
);
846 ehea_error("failed resensing port "
851 if (netif_msg_link(port
))
852 ehea_info("%s: Logical port up: %dMbps "
857 1 ? "Full" : "Half");
859 netif_carrier_on(port
->netdev
);
860 netif_wake_queue(port
->netdev
);
863 if (netif_carrier_ok(port
->netdev
)) {
864 if (netif_msg_link(port
))
865 ehea_info("%s: Logical port down",
867 netif_carrier_off(port
->netdev
);
868 netif_stop_queue(port
->netdev
);
871 if (EHEA_BMASK_GET(NEQE_EXTSWITCH_PORT_UP
, eqe
)) {
872 if (netif_msg_link(port
))
873 ehea_info("%s: Physical port up",
876 if (netif_msg_link(port
))
877 ehea_info("%s: Physical port down",
881 if (EHEA_BMASK_GET(NEQE_EXTSWITCH_PRIMARY
, eqe
))
882 ehea_info("External switch port is primary port");
884 ehea_info("External switch port is backup port");
887 case EHEA_EC_ADAPTER_MALFUNC
:
888 ehea_error("Adapter malfunction");
890 case EHEA_EC_PORT_MALFUNC
:
891 ehea_info("Port malfunction: Device: %s", port
->netdev
->name
);
892 netif_carrier_off(port
->netdev
);
893 netif_stop_queue(port
->netdev
);
896 ehea_error("unknown event code %x, eqe=0x%lX", ec
, eqe
);
901 static void ehea_neq_tasklet(unsigned long data
)
903 struct ehea_adapter
*adapter
= (struct ehea_adapter
*)data
;
904 struct ehea_eqe
*eqe
;
907 eqe
= ehea_poll_eq(adapter
->neq
);
908 ehea_debug("eqe=%p", eqe
);
911 ehea_debug("*eqe=%lx", eqe
->entry
);
912 ehea_parse_eqe(adapter
, eqe
->entry
);
913 eqe
= ehea_poll_eq(adapter
->neq
);
914 ehea_debug("next eqe=%p", eqe
);
917 event_mask
= EHEA_BMASK_SET(NELR_PORTSTATE_CHG
, 1)
918 | EHEA_BMASK_SET(NELR_ADAPTER_MALFUNC
, 1)
919 | EHEA_BMASK_SET(NELR_PORT_MALFUNC
, 1);
921 ehea_h_reset_events(adapter
->handle
,
922 adapter
->neq
->fw_handle
, event_mask
);
925 static irqreturn_t
ehea_interrupt_neq(int irq
, void *param
)
927 struct ehea_adapter
*adapter
= param
;
928 tasklet_hi_schedule(&adapter
->neq_tasklet
);
933 static int ehea_fill_port_res(struct ehea_port_res
*pr
)
936 struct ehea_qp_init_attr
*init_attr
= &pr
->qp
->init_attr
;
938 ret
= ehea_init_fill_rq1(pr
, init_attr
->act_nr_rwqes_rq1
939 - init_attr
->act_nr_rwqes_rq2
940 - init_attr
->act_nr_rwqes_rq3
- 1);
942 ret
|= ehea_refill_rq2(pr
, init_attr
->act_nr_rwqes_rq2
- 1);
944 ret
|= ehea_refill_rq3(pr
, init_attr
->act_nr_rwqes_rq3
- 1);
949 static int ehea_reg_interrupts(struct net_device
*dev
)
951 struct ehea_port
*port
= netdev_priv(dev
);
952 struct ehea_port_res
*pr
;
956 snprintf(port
->int_aff_name
, EHEA_IRQ_NAME_SIZE
- 1, "%s-aff",
959 ret
= ibmebus_request_irq(NULL
, port
->qp_eq
->attr
.ist1
,
960 ehea_qp_aff_irq_handler
,
961 IRQF_DISABLED
, port
->int_aff_name
, port
);
963 ehea_error("failed registering irq for qp_aff_irq_handler:"
964 "ist=%X", port
->qp_eq
->attr
.ist1
);
968 if (netif_msg_ifup(port
))
969 ehea_info("irq_handle 0x%X for function qp_aff_irq_handler "
970 "registered", port
->qp_eq
->attr
.ist1
);
973 for (i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++) {
974 pr
= &port
->port_res
[i
];
975 snprintf(pr
->int_send_name
, EHEA_IRQ_NAME_SIZE
- 1,
976 "%s-queue%d", dev
->name
, i
);
977 ret
= ibmebus_request_irq(NULL
, pr
->eq
->attr
.ist1
,
978 ehea_recv_irq_handler
,
979 IRQF_DISABLED
, pr
->int_send_name
,
982 ehea_error("failed registering irq for ehea_queue "
983 "port_res_nr:%d, ist=%X", i
,
987 if (netif_msg_ifup(port
))
988 ehea_info("irq_handle 0x%X for function ehea_queue_int "
989 "%d registered", pr
->eq
->attr
.ist1
, i
);
997 u32 ist
= port
->port_res
[i
].eq
->attr
.ist1
;
998 ibmebus_free_irq(NULL
, ist
, &port
->port_res
[i
]);
1002 ibmebus_free_irq(NULL
, port
->qp_eq
->attr
.ist1
, port
);
1003 i
= port
->num_def_qps
;
1009 static void ehea_free_interrupts(struct net_device
*dev
)
1011 struct ehea_port
*port
= netdev_priv(dev
);
1012 struct ehea_port_res
*pr
;
1017 for (i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++) {
1018 pr
= &port
->port_res
[i
];
1019 ibmebus_free_irq(NULL
, pr
->eq
->attr
.ist1
, pr
);
1020 if (netif_msg_intr(port
))
1021 ehea_info("free send irq for res %d with handle 0x%X",
1022 i
, pr
->eq
->attr
.ist1
);
1025 /* associated events */
1026 ibmebus_free_irq(NULL
, port
->qp_eq
->attr
.ist1
, port
);
1027 if (netif_msg_intr(port
))
1028 ehea_info("associated event interrupt for handle 0x%X freed",
1029 port
->qp_eq
->attr
.ist1
);
1032 static int ehea_configure_port(struct ehea_port
*port
)
1036 struct hcp_ehea_port_cb0
*cb0
;
1039 cb0
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
1043 cb0
->port_rc
= EHEA_BMASK_SET(PXLY_RC_VALID
, 1)
1044 | EHEA_BMASK_SET(PXLY_RC_IP_CHKSUM
, 1)
1045 | EHEA_BMASK_SET(PXLY_RC_TCP_UDP_CHKSUM
, 1)
1046 | EHEA_BMASK_SET(PXLY_RC_VLAN_XTRACT
, 1)
1047 | EHEA_BMASK_SET(PXLY_RC_VLAN_TAG_FILTER
,
1048 PXLY_RC_VLAN_FILTER
)
1049 | EHEA_BMASK_SET(PXLY_RC_JUMBO_FRAME
, 1);
1051 for (i
= 0; i
< port
->num_mcs
; i
++)
1053 cb0
->default_qpn_arr
[i
] =
1054 port
->port_res
[i
].qp
->init_attr
.qp_nr
;
1056 cb0
->default_qpn_arr
[i
] =
1057 port
->port_res
[0].qp
->init_attr
.qp_nr
;
1059 if (netif_msg_ifup(port
))
1060 ehea_dump(cb0
, sizeof(*cb0
), "ehea_configure_port");
1062 mask
= EHEA_BMASK_SET(H_PORT_CB0_PRC
, 1)
1063 | EHEA_BMASK_SET(H_PORT_CB0_DEFQPNARRAY
, 1);
1065 hret
= ehea_h_modify_ehea_port(port
->adapter
->handle
,
1066 port
->logical_port_id
,
1067 H_PORT_CB0
, mask
, cb0
);
1069 if (hret
!= H_SUCCESS
)
1080 int ehea_gen_smrs(struct ehea_port_res
*pr
)
1083 struct ehea_adapter
*adapter
= pr
->port
->adapter
;
1085 ret
= ehea_gen_smr(adapter
, &adapter
->mr
, &pr
->send_mr
);
1089 ret
= ehea_gen_smr(adapter
, &adapter
->mr
, &pr
->recv_mr
);
1096 ehea_rem_mr(&pr
->send_mr
);
1098 ehea_error("Generating SMRS failed\n");
1102 int ehea_rem_smrs(struct ehea_port_res
*pr
)
1104 if ((ehea_rem_mr(&pr
->send_mr
))
1105 || (ehea_rem_mr(&pr
->recv_mr
)))
1111 static int ehea_init_q_skba(struct ehea_q_skb_arr
*q_skba
, int max_q_entries
)
1113 int arr_size
= sizeof(void*) * max_q_entries
;
1115 q_skba
->arr
= vmalloc(arr_size
);
1119 memset(q_skba
->arr
, 0, arr_size
);
1121 q_skba
->len
= max_q_entries
;
1123 q_skba
->os_skbs
= 0;
1128 static int ehea_init_port_res(struct ehea_port
*port
, struct ehea_port_res
*pr
,
1129 struct port_res_cfg
*pr_cfg
, int queue_token
)
1131 struct ehea_adapter
*adapter
= port
->adapter
;
1132 enum ehea_eq_type eq_type
= EHEA_EQ
;
1133 struct ehea_qp_init_attr
*init_attr
= NULL
;
1136 memset(pr
, 0, sizeof(struct ehea_port_res
));
1139 spin_lock_init(&pr
->xmit_lock
);
1140 spin_lock_init(&pr
->netif_queue
);
1142 pr
->eq
= ehea_create_eq(adapter
, eq_type
, EHEA_MAX_ENTRIES_EQ
, 0);
1144 ehea_error("create_eq failed (eq)");
1148 pr
->recv_cq
= ehea_create_cq(adapter
, pr_cfg
->max_entries_rcq
,
1150 port
->logical_port_id
);
1152 ehea_error("create_cq failed (cq_recv)");
1156 pr
->send_cq
= ehea_create_cq(adapter
, pr_cfg
->max_entries_scq
,
1158 port
->logical_port_id
);
1160 ehea_error("create_cq failed (cq_send)");
1164 if (netif_msg_ifup(port
))
1165 ehea_info("Send CQ: act_nr_cqes=%d, Recv CQ: act_nr_cqes=%d",
1166 pr
->send_cq
->attr
.act_nr_of_cqes
,
1167 pr
->recv_cq
->attr
.act_nr_of_cqes
);
1169 init_attr
= kzalloc(sizeof(*init_attr
), GFP_KERNEL
);
1172 ehea_error("no mem for ehea_qp_init_attr");
1176 init_attr
->low_lat_rq1
= 1;
1177 init_attr
->signalingtype
= 1; /* generate CQE if specified in WQE */
1178 init_attr
->rq_count
= 3;
1179 init_attr
->qp_token
= queue_token
;
1180 init_attr
->max_nr_send_wqes
= pr_cfg
->max_entries_sq
;
1181 init_attr
->max_nr_rwqes_rq1
= pr_cfg
->max_entries_rq1
;
1182 init_attr
->max_nr_rwqes_rq2
= pr_cfg
->max_entries_rq2
;
1183 init_attr
->max_nr_rwqes_rq3
= pr_cfg
->max_entries_rq3
;
1184 init_attr
->wqe_size_enc_sq
= EHEA_SG_SQ
;
1185 init_attr
->wqe_size_enc_rq1
= EHEA_SG_RQ1
;
1186 init_attr
->wqe_size_enc_rq2
= EHEA_SG_RQ2
;
1187 init_attr
->wqe_size_enc_rq3
= EHEA_SG_RQ3
;
1188 init_attr
->rq2_threshold
= EHEA_RQ2_THRESHOLD
;
1189 init_attr
->rq3_threshold
= EHEA_RQ3_THRESHOLD
;
1190 init_attr
->port_nr
= port
->logical_port_id
;
1191 init_attr
->send_cq_handle
= pr
->send_cq
->fw_handle
;
1192 init_attr
->recv_cq_handle
= pr
->recv_cq
->fw_handle
;
1193 init_attr
->aff_eq_handle
= port
->qp_eq
->fw_handle
;
1195 pr
->qp
= ehea_create_qp(adapter
, adapter
->pd
, init_attr
);
1197 ehea_error("create_qp failed");
1202 if (netif_msg_ifup(port
))
1203 ehea_info("QP: qp_nr=%d\n act_nr_snd_wqe=%d\n nr_rwqe_rq1=%d\n "
1204 "nr_rwqe_rq2=%d\n nr_rwqe_rq3=%d", init_attr
->qp_nr
,
1205 init_attr
->act_nr_send_wqes
,
1206 init_attr
->act_nr_rwqes_rq1
,
1207 init_attr
->act_nr_rwqes_rq2
,
1208 init_attr
->act_nr_rwqes_rq3
);
1210 ret
= ehea_init_q_skba(&pr
->sq_skba
, init_attr
->act_nr_send_wqes
+ 1);
1211 ret
|= ehea_init_q_skba(&pr
->rq1_skba
, init_attr
->act_nr_rwqes_rq1
+ 1);
1212 ret
|= ehea_init_q_skba(&pr
->rq2_skba
, init_attr
->act_nr_rwqes_rq2
+ 1);
1213 ret
|= ehea_init_q_skba(&pr
->rq3_skba
, init_attr
->act_nr_rwqes_rq3
+ 1);
1217 pr
->swqe_refill_th
= init_attr
->act_nr_send_wqes
/ 10;
1218 if (ehea_gen_smrs(pr
) != 0) {
1223 atomic_set(&pr
->swqe_avail
, init_attr
->act_nr_send_wqes
- 1);
1227 pr
->d_netdev
= alloc_netdev(0, "", ether_setup
);
1230 pr
->d_netdev
->priv
= pr
;
1231 pr
->d_netdev
->weight
= 64;
1232 pr
->d_netdev
->poll
= ehea_poll
;
1233 set_bit(__LINK_STATE_START
, &pr
->d_netdev
->state
);
1234 strcpy(pr
->d_netdev
->name
, port
->netdev
->name
);
1241 vfree(pr
->sq_skba
.arr
);
1242 vfree(pr
->rq1_skba
.arr
);
1243 vfree(pr
->rq2_skba
.arr
);
1244 vfree(pr
->rq3_skba
.arr
);
1245 ehea_destroy_qp(pr
->qp
);
1246 ehea_destroy_cq(pr
->send_cq
);
1247 ehea_destroy_cq(pr
->recv_cq
);
1248 ehea_destroy_eq(pr
->eq
);
1253 static int ehea_clean_portres(struct ehea_port
*port
, struct ehea_port_res
*pr
)
1257 free_netdev(pr
->d_netdev
);
1259 ret
= ehea_destroy_qp(pr
->qp
);
1262 ehea_destroy_cq(pr
->send_cq
);
1263 ehea_destroy_cq(pr
->recv_cq
);
1264 ehea_destroy_eq(pr
->eq
);
1266 for (i
= 0; i
< pr
->rq1_skba
.len
; i
++)
1267 if (pr
->rq1_skba
.arr
[i
])
1268 dev_kfree_skb(pr
->rq1_skba
.arr
[i
]);
1270 for (i
= 0; i
< pr
->rq2_skba
.len
; i
++)
1271 if (pr
->rq2_skba
.arr
[i
])
1272 dev_kfree_skb(pr
->rq2_skba
.arr
[i
]);
1274 for (i
= 0; i
< pr
->rq3_skba
.len
; i
++)
1275 if (pr
->rq3_skba
.arr
[i
])
1276 dev_kfree_skb(pr
->rq3_skba
.arr
[i
]);
1278 for (i
= 0; i
< pr
->sq_skba
.len
; i
++)
1279 if (pr
->sq_skba
.arr
[i
])
1280 dev_kfree_skb(pr
->sq_skba
.arr
[i
]);
1282 vfree(pr
->rq1_skba
.arr
);
1283 vfree(pr
->rq2_skba
.arr
);
1284 vfree(pr
->rq3_skba
.arr
);
1285 vfree(pr
->sq_skba
.arr
);
1286 ret
= ehea_rem_smrs(pr
);
1292 * The write_* functions store information in swqe which is used by
1293 * the hardware to calculate the ip/tcp/udp checksum
1296 static inline void write_ip_start_end(struct ehea_swqe
*swqe
,
1297 const struct sk_buff
*skb
)
1299 swqe
->ip_start
= skb_network_offset(skb
);
1300 swqe
->ip_end
= (u8
)(swqe
->ip_start
+ ip_hdrlen(skb
) - 1);
1303 static inline void write_tcp_offset_end(struct ehea_swqe
*swqe
,
1304 const struct sk_buff
*skb
)
1307 (u8
)(swqe
->ip_end
+ 1 + offsetof(struct tcphdr
, check
));
1309 swqe
->tcp_end
= (u16
)skb
->len
- 1;
1312 static inline void write_udp_offset_end(struct ehea_swqe
*swqe
,
1313 const struct sk_buff
*skb
)
1316 (u8
)(swqe
->ip_end
+ 1 + offsetof(struct udphdr
, check
));
1318 swqe
->tcp_end
= (u16
)skb
->len
- 1;
1322 static void write_swqe2_TSO(struct sk_buff
*skb
,
1323 struct ehea_swqe
*swqe
, u32 lkey
)
1325 struct ehea_vsgentry
*sg1entry
= &swqe
->u
.immdata_desc
.sg_entry
;
1326 u8
*imm_data
= &swqe
->u
.immdata_desc
.immediate_data
[0];
1327 int skb_data_size
= skb
->len
- skb
->data_len
;
1330 /* Packet is TCP with TSO enabled */
1331 swqe
->tx_control
|= EHEA_SWQE_TSO
;
1332 swqe
->mss
= skb_shinfo(skb
)->gso_size
;
1333 /* copy only eth/ip/tcp headers to immediate data and
1334 * the rest of skb->data to sg1entry
1336 headersize
= ETH_HLEN
+ ip_hdrlen(skb
) + tcp_hdrlen(skb
);
1338 skb_data_size
= skb
->len
- skb
->data_len
;
1340 if (skb_data_size
>= headersize
) {
1341 /* copy immediate data */
1342 skb_copy_from_linear_data(skb
, imm_data
, headersize
);
1343 swqe
->immediate_data_length
= headersize
;
1345 if (skb_data_size
> headersize
) {
1346 /* set sg1entry data */
1347 sg1entry
->l_key
= lkey
;
1348 sg1entry
->len
= skb_data_size
- headersize
;
1350 ehea_map_vaddr(skb
->data
+ headersize
);
1351 swqe
->descriptors
++;
1354 ehea_error("cannot handle fragmented headers");
1357 static void write_swqe2_nonTSO(struct sk_buff
*skb
,
1358 struct ehea_swqe
*swqe
, u32 lkey
)
1360 int skb_data_size
= skb
->len
- skb
->data_len
;
1361 u8
*imm_data
= &swqe
->u
.immdata_desc
.immediate_data
[0];
1362 struct ehea_vsgentry
*sg1entry
= &swqe
->u
.immdata_desc
.sg_entry
;
1364 /* Packet is any nonTSO type
1366 * Copy as much as possible skb->data to immediate data and
1367 * the rest to sg1entry
1369 if (skb_data_size
>= SWQE2_MAX_IMM
) {
1370 /* copy immediate data */
1371 skb_copy_from_linear_data(skb
, imm_data
, SWQE2_MAX_IMM
);
1373 swqe
->immediate_data_length
= SWQE2_MAX_IMM
;
1375 if (skb_data_size
> SWQE2_MAX_IMM
) {
1376 /* copy sg1entry data */
1377 sg1entry
->l_key
= lkey
;
1378 sg1entry
->len
= skb_data_size
- SWQE2_MAX_IMM
;
1380 ehea_map_vaddr(skb
->data
+ SWQE2_MAX_IMM
);
1381 swqe
->descriptors
++;
1384 skb_copy_from_linear_data(skb
, imm_data
, skb_data_size
);
1385 swqe
->immediate_data_length
= skb_data_size
;
1389 static inline void write_swqe2_data(struct sk_buff
*skb
, struct net_device
*dev
,
1390 struct ehea_swqe
*swqe
, u32 lkey
)
1392 struct ehea_vsgentry
*sg_list
, *sg1entry
, *sgentry
;
1394 int nfrags
, sg1entry_contains_frag_data
, i
;
1396 nfrags
= skb_shinfo(skb
)->nr_frags
;
1397 sg1entry
= &swqe
->u
.immdata_desc
.sg_entry
;
1398 sg_list
= (struct ehea_vsgentry
*)&swqe
->u
.immdata_desc
.sg_list
;
1399 swqe
->descriptors
= 0;
1400 sg1entry_contains_frag_data
= 0;
1402 if ((dev
->features
& NETIF_F_TSO
) && skb_shinfo(skb
)->gso_size
)
1403 write_swqe2_TSO(skb
, swqe
, lkey
);
1405 write_swqe2_nonTSO(skb
, swqe
, lkey
);
1407 /* write descriptors */
1409 if (swqe
->descriptors
== 0) {
1410 /* sg1entry not yet used */
1411 frag
= &skb_shinfo(skb
)->frags
[0];
1413 /* copy sg1entry data */
1414 sg1entry
->l_key
= lkey
;
1415 sg1entry
->len
= frag
->size
;
1417 ehea_map_vaddr(page_address(frag
->page
)
1418 + frag
->page_offset
);
1419 swqe
->descriptors
++;
1420 sg1entry_contains_frag_data
= 1;
1423 for (i
= sg1entry_contains_frag_data
; i
< nfrags
; i
++) {
1425 frag
= &skb_shinfo(skb
)->frags
[i
];
1426 sgentry
= &sg_list
[i
- sg1entry_contains_frag_data
];
1428 sgentry
->l_key
= lkey
;
1429 sgentry
->len
= frag
->size
;
1431 ehea_map_vaddr(page_address(frag
->page
)
1432 + frag
->page_offset
);
1433 swqe
->descriptors
++;
1438 static int ehea_broadcast_reg_helper(struct ehea_port
*port
, u32 hcallid
)
1444 /* De/Register untagged packets */
1445 reg_type
= EHEA_BCMC_BROADCAST
| EHEA_BCMC_UNTAGGED
;
1446 hret
= ehea_h_reg_dereg_bcmc(port
->adapter
->handle
,
1447 port
->logical_port_id
,
1448 reg_type
, port
->mac_addr
, 0, hcallid
);
1449 if (hret
!= H_SUCCESS
) {
1450 ehea_error("%sregistering bc address failed (tagged)",
1451 hcallid
== H_REG_BCMC
? "" : "de");
1456 /* De/Register VLAN packets */
1457 reg_type
= EHEA_BCMC_BROADCAST
| EHEA_BCMC_VLANID_ALL
;
1458 hret
= ehea_h_reg_dereg_bcmc(port
->adapter
->handle
,
1459 port
->logical_port_id
,
1460 reg_type
, port
->mac_addr
, 0, hcallid
);
1461 if (hret
!= H_SUCCESS
) {
1462 ehea_error("%sregistering bc address failed (vlan)",
1463 hcallid
== H_REG_BCMC
? "" : "de");
1470 static int ehea_set_mac_addr(struct net_device
*dev
, void *sa
)
1472 struct ehea_port
*port
= netdev_priv(dev
);
1473 struct sockaddr
*mac_addr
= sa
;
1474 struct hcp_ehea_port_cb0
*cb0
;
1478 if (!is_valid_ether_addr(mac_addr
->sa_data
)) {
1479 ret
= -EADDRNOTAVAIL
;
1483 cb0
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
1485 ehea_error("no mem for cb0");
1490 memcpy(&(cb0
->port_mac_addr
), &(mac_addr
->sa_data
[0]), ETH_ALEN
);
1492 cb0
->port_mac_addr
= cb0
->port_mac_addr
>> 16;
1494 hret
= ehea_h_modify_ehea_port(port
->adapter
->handle
,
1495 port
->logical_port_id
, H_PORT_CB0
,
1496 EHEA_BMASK_SET(H_PORT_CB0_MAC
, 1), cb0
);
1497 if (hret
!= H_SUCCESS
) {
1502 memcpy(dev
->dev_addr
, mac_addr
->sa_data
, dev
->addr_len
);
1504 /* Deregister old MAC in pHYP */
1505 ret
= ehea_broadcast_reg_helper(port
, H_DEREG_BCMC
);
1509 port
->mac_addr
= cb0
->port_mac_addr
<< 16;
1511 /* Register new MAC in pHYP */
1512 ret
= ehea_broadcast_reg_helper(port
, H_REG_BCMC
);
1523 static void ehea_promiscuous_error(u64 hret
, int enable
)
1525 if (hret
== H_AUTHORITY
)
1526 ehea_info("Hypervisor denied %sabling promiscuous mode",
1527 enable
== 1 ? "en" : "dis");
1529 ehea_error("failed %sabling promiscuous mode",
1530 enable
== 1 ? "en" : "dis");
1533 static void ehea_promiscuous(struct net_device
*dev
, int enable
)
1535 struct ehea_port
*port
= netdev_priv(dev
);
1536 struct hcp_ehea_port_cb7
*cb7
;
1539 if ((enable
&& port
->promisc
) || (!enable
&& !port
->promisc
))
1542 cb7
= kzalloc(PAGE_SIZE
, GFP_ATOMIC
);
1544 ehea_error("no mem for cb7");
1548 /* Modify Pxs_DUCQPN in CB7 */
1549 cb7
->def_uc_qpn
= enable
== 1 ? port
->port_res
[0].qp
->fw_handle
: 0;
1551 hret
= ehea_h_modify_ehea_port(port
->adapter
->handle
,
1552 port
->logical_port_id
,
1553 H_PORT_CB7
, H_PORT_CB7_DUCQPN
, cb7
);
1555 ehea_promiscuous_error(hret
, enable
);
1559 port
->promisc
= enable
;
1565 static u64
ehea_multicast_reg_helper(struct ehea_port
*port
, u64 mc_mac_addr
,
1571 reg_type
= EHEA_BCMC_SCOPE_ALL
| EHEA_BCMC_MULTICAST
1572 | EHEA_BCMC_UNTAGGED
;
1574 hret
= ehea_h_reg_dereg_bcmc(port
->adapter
->handle
,
1575 port
->logical_port_id
,
1576 reg_type
, mc_mac_addr
, 0, hcallid
);
1580 reg_type
= EHEA_BCMC_SCOPE_ALL
| EHEA_BCMC_MULTICAST
1581 | EHEA_BCMC_VLANID_ALL
;
1583 hret
= ehea_h_reg_dereg_bcmc(port
->adapter
->handle
,
1584 port
->logical_port_id
,
1585 reg_type
, mc_mac_addr
, 0, hcallid
);
1590 static int ehea_drop_multicast_list(struct net_device
*dev
)
1592 struct ehea_port
*port
= netdev_priv(dev
);
1593 struct ehea_mc_list
*mc_entry
= port
->mc_list
;
1594 struct list_head
*pos
;
1595 struct list_head
*temp
;
1599 list_for_each_safe(pos
, temp
, &(port
->mc_list
->list
)) {
1600 mc_entry
= list_entry(pos
, struct ehea_mc_list
, list
);
1602 hret
= ehea_multicast_reg_helper(port
, mc_entry
->macaddr
,
1605 ehea_error("failed deregistering mcast MAC");
1615 static void ehea_allmulti(struct net_device
*dev
, int enable
)
1617 struct ehea_port
*port
= netdev_priv(dev
);
1620 if (!port
->allmulti
) {
1622 /* Enable ALLMULTI */
1623 ehea_drop_multicast_list(dev
);
1624 hret
= ehea_multicast_reg_helper(port
, 0, H_REG_BCMC
);
1628 ehea_error("failed enabling IFF_ALLMULTI");
1632 /* Disable ALLMULTI */
1633 hret
= ehea_multicast_reg_helper(port
, 0, H_DEREG_BCMC
);
1637 ehea_error("failed disabling IFF_ALLMULTI");
1641 static void ehea_add_multicast_entry(struct ehea_port
* port
, u8
* mc_mac_addr
)
1643 struct ehea_mc_list
*ehea_mcl_entry
;
1646 ehea_mcl_entry
= kzalloc(sizeof(*ehea_mcl_entry
), GFP_ATOMIC
);
1647 if (!ehea_mcl_entry
) {
1648 ehea_error("no mem for mcl_entry");
1652 INIT_LIST_HEAD(&ehea_mcl_entry
->list
);
1654 memcpy(&ehea_mcl_entry
->macaddr
, mc_mac_addr
, ETH_ALEN
);
1656 hret
= ehea_multicast_reg_helper(port
, ehea_mcl_entry
->macaddr
,
1659 list_add(&ehea_mcl_entry
->list
, &port
->mc_list
->list
);
1661 ehea_error("failed registering mcast MAC");
1662 kfree(ehea_mcl_entry
);
1666 static void ehea_set_multicast_list(struct net_device
*dev
)
1668 struct ehea_port
*port
= netdev_priv(dev
);
1669 struct dev_mc_list
*k_mcl_entry
;
1672 if (dev
->flags
& IFF_PROMISC
) {
1673 ehea_promiscuous(dev
, 1);
1676 ehea_promiscuous(dev
, 0);
1678 if (dev
->flags
& IFF_ALLMULTI
) {
1679 ehea_allmulti(dev
, 1);
1682 ehea_allmulti(dev
, 0);
1684 if (dev
->mc_count
) {
1685 ret
= ehea_drop_multicast_list(dev
);
1687 /* Dropping the current multicast list failed.
1688 * Enabling ALL_MULTI is the best we can do.
1690 ehea_allmulti(dev
, 1);
1693 if (dev
->mc_count
> port
->adapter
->max_mc_mac
) {
1694 ehea_info("Mcast registration limit reached (0x%lx). "
1696 port
->adapter
->max_mc_mac
);
1700 for (i
= 0, k_mcl_entry
= dev
->mc_list
;
1702 i
++, k_mcl_entry
= k_mcl_entry
->next
) {
1703 ehea_add_multicast_entry(port
, k_mcl_entry
->dmi_addr
);
1710 static int ehea_change_mtu(struct net_device
*dev
, int new_mtu
)
1712 if ((new_mtu
< 68) || (new_mtu
> EHEA_MAX_PACKET_SIZE
))
1718 static void ehea_xmit2(struct sk_buff
*skb
, struct net_device
*dev
,
1719 struct ehea_swqe
*swqe
, u32 lkey
)
1721 if (skb
->protocol
== htons(ETH_P_IP
)) {
1722 const struct iphdr
*iph
= ip_hdr(skb
);
1725 swqe
->tx_control
|= EHEA_SWQE_CRC
1726 | EHEA_SWQE_IP_CHECKSUM
1727 | EHEA_SWQE_TCP_CHECKSUM
1728 | EHEA_SWQE_IMM_DATA_PRESENT
1729 | EHEA_SWQE_DESCRIPTORS_PRESENT
;
1731 write_ip_start_end(swqe
, skb
);
1733 if (iph
->protocol
== IPPROTO_UDP
) {
1734 if ((iph
->frag_off
& IP_MF
)
1735 || (iph
->frag_off
& IP_OFFSET
))
1736 /* IP fragment, so don't change cs */
1737 swqe
->tx_control
&= ~EHEA_SWQE_TCP_CHECKSUM
;
1739 write_udp_offset_end(swqe
, skb
);
1740 } else if (iph
->protocol
== IPPROTO_TCP
) {
1741 write_tcp_offset_end(swqe
, skb
);
1744 /* icmp (big data) and ip segmentation packets (all other ip
1745 packets) do not require any special handling */
1748 /* Other Ethernet Protocol */
1749 swqe
->tx_control
|= EHEA_SWQE_CRC
1750 | EHEA_SWQE_IMM_DATA_PRESENT
1751 | EHEA_SWQE_DESCRIPTORS_PRESENT
;
1754 write_swqe2_data(skb
, dev
, swqe
, lkey
);
1757 static void ehea_xmit3(struct sk_buff
*skb
, struct net_device
*dev
,
1758 struct ehea_swqe
*swqe
)
1760 int nfrags
= skb_shinfo(skb
)->nr_frags
;
1761 u8
*imm_data
= &swqe
->u
.immdata_nodesc
.immediate_data
[0];
1765 if (skb
->protocol
== htons(ETH_P_IP
)) {
1766 const struct iphdr
*iph
= ip_hdr(skb
);
1769 write_ip_start_end(swqe
, skb
);
1771 if (iph
->protocol
== IPPROTO_TCP
) {
1772 swqe
->tx_control
|= EHEA_SWQE_CRC
1773 | EHEA_SWQE_IP_CHECKSUM
1774 | EHEA_SWQE_TCP_CHECKSUM
1775 | EHEA_SWQE_IMM_DATA_PRESENT
;
1777 write_tcp_offset_end(swqe
, skb
);
1779 } else if (iph
->protocol
== IPPROTO_UDP
) {
1780 if ((iph
->frag_off
& IP_MF
)
1781 || (iph
->frag_off
& IP_OFFSET
))
1782 /* IP fragment, so don't change cs */
1783 swqe
->tx_control
|= EHEA_SWQE_CRC
1784 | EHEA_SWQE_IMM_DATA_PRESENT
;
1786 swqe
->tx_control
|= EHEA_SWQE_CRC
1787 | EHEA_SWQE_IP_CHECKSUM
1788 | EHEA_SWQE_TCP_CHECKSUM
1789 | EHEA_SWQE_IMM_DATA_PRESENT
;
1791 write_udp_offset_end(swqe
, skb
);
1794 /* icmp (big data) and
1795 ip segmentation packets (all other ip packets) */
1796 swqe
->tx_control
|= EHEA_SWQE_CRC
1797 | EHEA_SWQE_IP_CHECKSUM
1798 | EHEA_SWQE_IMM_DATA_PRESENT
;
1801 /* Other Ethernet Protocol */
1802 swqe
->tx_control
|= EHEA_SWQE_CRC
| EHEA_SWQE_IMM_DATA_PRESENT
;
1804 /* copy (immediate) data */
1806 /* data is in a single piece */
1807 skb_copy_from_linear_data(skb
, imm_data
, skb
->len
);
1809 /* first copy data from the skb->data buffer ... */
1810 skb_copy_from_linear_data(skb
, imm_data
,
1811 skb
->len
- skb
->data_len
);
1812 imm_data
+= skb
->len
- skb
->data_len
;
1814 /* ... then copy data from the fragments */
1815 for (i
= 0; i
< nfrags
; i
++) {
1816 frag
= &skb_shinfo(skb
)->frags
[i
];
1818 page_address(frag
->page
) + frag
->page_offset
,
1820 imm_data
+= frag
->size
;
1823 swqe
->immediate_data_length
= skb
->len
;
1827 static inline int ehea_hash_skb(struct sk_buff
*skb
, int num_qps
)
1832 if ((skb
->protocol
== htons(ETH_P_IP
)) &&
1833 (ip_hdr(skb
)->protocol
== IPPROTO_TCP
)) {
1834 tcp
= (struct tcphdr
*)(skb_network_header(skb
) + (ip_hdr(skb
)->ihl
* 4));
1835 tmp
= (tcp
->source
+ (tcp
->dest
<< 16)) % 31;
1836 tmp
+= ip_hdr(skb
)->daddr
% 31;
1837 return tmp
% num_qps
;
1843 static int ehea_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
1845 struct ehea_port
*port
= netdev_priv(dev
);
1846 struct ehea_swqe
*swqe
;
1847 unsigned long flags
;
1850 struct ehea_port_res
*pr
;
1852 pr
= &port
->port_res
[ehea_hash_skb(skb
, port
->num_tx_qps
)];
1854 if (!spin_trylock(&pr
->xmit_lock
))
1855 return NETDEV_TX_BUSY
;
1857 if (pr
->queue_stopped
) {
1858 spin_unlock(&pr
->xmit_lock
);
1859 return NETDEV_TX_BUSY
;
1862 swqe
= ehea_get_swqe(pr
->qp
, &swqe_index
);
1863 memset(swqe
, 0, SWQE_HEADER_SIZE
);
1864 atomic_dec(&pr
->swqe_avail
);
1866 if (skb
->len
<= SWQE3_MAX_IMM
) {
1867 u32 sig_iv
= port
->sig_comp_iv
;
1868 u32 swqe_num
= pr
->swqe_id_counter
;
1869 ehea_xmit3(skb
, dev
, swqe
);
1870 swqe
->wr_id
= EHEA_BMASK_SET(EHEA_WR_ID_TYPE
, EHEA_SWQE3_TYPE
)
1871 | EHEA_BMASK_SET(EHEA_WR_ID_COUNT
, swqe_num
);
1872 if (pr
->swqe_ll_count
>= (sig_iv
- 1)) {
1873 swqe
->wr_id
|= EHEA_BMASK_SET(EHEA_WR_ID_REFILL
,
1875 swqe
->tx_control
|= EHEA_SWQE_SIGNALLED_COMPLETION
;
1876 pr
->swqe_ll_count
= 0;
1878 pr
->swqe_ll_count
+= 1;
1881 EHEA_BMASK_SET(EHEA_WR_ID_TYPE
, EHEA_SWQE2_TYPE
)
1882 | EHEA_BMASK_SET(EHEA_WR_ID_COUNT
, pr
->swqe_id_counter
)
1883 | EHEA_BMASK_SET(EHEA_WR_ID_REFILL
, 1)
1884 | EHEA_BMASK_SET(EHEA_WR_ID_INDEX
, pr
->sq_skba
.index
);
1885 pr
->sq_skba
.arr
[pr
->sq_skba
.index
] = skb
;
1887 pr
->sq_skba
.index
++;
1888 pr
->sq_skba
.index
&= (pr
->sq_skba
.len
- 1);
1890 lkey
= pr
->send_mr
.lkey
;
1891 ehea_xmit2(skb
, dev
, swqe
, lkey
);
1892 swqe
->tx_control
|= EHEA_SWQE_SIGNALLED_COMPLETION
;
1894 pr
->swqe_id_counter
+= 1;
1896 if (port
->vgrp
&& vlan_tx_tag_present(skb
)) {
1897 swqe
->tx_control
|= EHEA_SWQE_VLAN_INSERT
;
1898 swqe
->vlan_tag
= vlan_tx_tag_get(skb
);
1901 if (netif_msg_tx_queued(port
)) {
1902 ehea_info("post swqe on QP %d", pr
->qp
->init_attr
.qp_nr
);
1903 ehea_dump(swqe
, 512, "swqe");
1906 if (unlikely(test_bit(__EHEA_STOP_XFER
, &ehea_driver_flags
)))
1909 ehea_post_swqe(pr
->qp
, swqe
);
1912 if (unlikely(atomic_read(&pr
->swqe_avail
) <= 1)) {
1913 spin_lock_irqsave(&pr
->netif_queue
, flags
);
1914 if (unlikely(atomic_read(&pr
->swqe_avail
) <= 1)) {
1915 pr
->p_stats
.queue_stopped
++;
1916 netif_stop_queue(dev
);
1917 pr
->queue_stopped
= 1;
1919 spin_unlock_irqrestore(&pr
->netif_queue
, flags
);
1921 dev
->trans_start
= jiffies
;
1922 spin_unlock(&pr
->xmit_lock
);
1924 return NETDEV_TX_OK
;
1927 static void ehea_vlan_rx_register(struct net_device
*dev
,
1928 struct vlan_group
*grp
)
1930 struct ehea_port
*port
= netdev_priv(dev
);
1931 struct ehea_adapter
*adapter
= port
->adapter
;
1932 struct hcp_ehea_port_cb1
*cb1
;
1937 cb1
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
1939 ehea_error("no mem for cb1");
1943 memset(cb1
->vlan_filter
, 0, sizeof(cb1
->vlan_filter
));
1945 hret
= ehea_h_modify_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("modify_ehea_port failed");
1955 static void ehea_vlan_rx_add_vid(struct net_device
*dev
, unsigned short vid
)
1957 struct ehea_port
*port
= netdev_priv(dev
);
1958 struct ehea_adapter
*adapter
= port
->adapter
;
1959 struct hcp_ehea_port_cb1
*cb1
;
1963 cb1
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
1965 ehea_error("no mem for cb1");
1969 hret
= ehea_h_query_ehea_port(adapter
->handle
, port
->logical_port_id
,
1970 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
1971 if (hret
!= H_SUCCESS
) {
1972 ehea_error("query_ehea_port failed");
1977 cb1
->vlan_filter
[index
] |= ((u64
)(0x8000000000000000 >> (vid
& 0x3F)));
1979 hret
= ehea_h_modify_ehea_port(adapter
->handle
, port
->logical_port_id
,
1980 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
1981 if (hret
!= H_SUCCESS
)
1982 ehea_error("modify_ehea_port failed");
1988 static void ehea_vlan_rx_kill_vid(struct net_device
*dev
, unsigned short vid
)
1990 struct ehea_port
*port
= netdev_priv(dev
);
1991 struct ehea_adapter
*adapter
= port
->adapter
;
1992 struct hcp_ehea_port_cb1
*cb1
;
1996 vlan_group_set_device(port
->vgrp
, vid
, NULL
);
1998 cb1
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
2000 ehea_error("no mem for cb1");
2004 hret
= ehea_h_query_ehea_port(adapter
->handle
, port
->logical_port_id
,
2005 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
2006 if (hret
!= H_SUCCESS
) {
2007 ehea_error("query_ehea_port failed");
2012 cb1
->vlan_filter
[index
] &= ~((u64
)(0x8000000000000000 >> (vid
& 0x3F)));
2014 hret
= ehea_h_modify_ehea_port(adapter
->handle
, port
->logical_port_id
,
2015 H_PORT_CB1
, H_PORT_CB1_ALL
, cb1
);
2016 if (hret
!= H_SUCCESS
)
2017 ehea_error("modify_ehea_port failed");
2023 int ehea_activate_qp(struct ehea_adapter
*adapter
, struct ehea_qp
*qp
)
2029 struct hcp_modify_qp_cb0
* cb0
;
2031 cb0
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
2037 hret
= ehea_h_query_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2038 EHEA_BMASK_SET(H_QPCB0_ALL
, 0xFFFF), cb0
);
2039 if (hret
!= H_SUCCESS
) {
2040 ehea_error("query_ehea_qp failed (1)");
2044 cb0
->qp_ctl_reg
= H_QP_CR_STATE_INITIALIZED
;
2045 hret
= ehea_h_modify_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2046 EHEA_BMASK_SET(H_QPCB0_QP_CTL_REG
, 1), cb0
,
2047 &dummy64
, &dummy64
, &dummy16
, &dummy16
);
2048 if (hret
!= H_SUCCESS
) {
2049 ehea_error("modify_ehea_qp failed (1)");
2053 hret
= ehea_h_query_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2054 EHEA_BMASK_SET(H_QPCB0_ALL
, 0xFFFF), cb0
);
2055 if (hret
!= H_SUCCESS
) {
2056 ehea_error("query_ehea_qp failed (2)");
2060 cb0
->qp_ctl_reg
= H_QP_CR_ENABLED
| H_QP_CR_STATE_INITIALIZED
;
2061 hret
= ehea_h_modify_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2062 EHEA_BMASK_SET(H_QPCB0_QP_CTL_REG
, 1), cb0
,
2063 &dummy64
, &dummy64
, &dummy16
, &dummy16
);
2064 if (hret
!= H_SUCCESS
) {
2065 ehea_error("modify_ehea_qp failed (2)");
2069 hret
= ehea_h_query_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2070 EHEA_BMASK_SET(H_QPCB0_ALL
, 0xFFFF), cb0
);
2071 if (hret
!= H_SUCCESS
) {
2072 ehea_error("query_ehea_qp failed (3)");
2076 cb0
->qp_ctl_reg
= H_QP_CR_ENABLED
| H_QP_CR_STATE_RDY2SND
;
2077 hret
= ehea_h_modify_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2078 EHEA_BMASK_SET(H_QPCB0_QP_CTL_REG
, 1), cb0
,
2079 &dummy64
, &dummy64
, &dummy16
, &dummy16
);
2080 if (hret
!= H_SUCCESS
) {
2081 ehea_error("modify_ehea_qp failed (3)");
2085 hret
= ehea_h_query_ehea_qp(adapter
->handle
, 0, qp
->fw_handle
,
2086 EHEA_BMASK_SET(H_QPCB0_ALL
, 0xFFFF), cb0
);
2087 if (hret
!= H_SUCCESS
) {
2088 ehea_error("query_ehea_qp failed (4)");
2098 static int ehea_port_res_setup(struct ehea_port
*port
, int def_qps
,
2102 struct port_res_cfg pr_cfg
, pr_cfg_small_rx
;
2103 enum ehea_eq_type eq_type
= EHEA_EQ
;
2105 port
->qp_eq
= ehea_create_eq(port
->adapter
, eq_type
,
2106 EHEA_MAX_ENTRIES_EQ
, 1);
2109 ehea_error("ehea_create_eq failed (qp_eq)");
2113 pr_cfg
.max_entries_rcq
= rq1_entries
+ rq2_entries
+ rq3_entries
;
2114 pr_cfg
.max_entries_scq
= sq_entries
* 2;
2115 pr_cfg
.max_entries_sq
= sq_entries
;
2116 pr_cfg
.max_entries_rq1
= rq1_entries
;
2117 pr_cfg
.max_entries_rq2
= rq2_entries
;
2118 pr_cfg
.max_entries_rq3
= rq3_entries
;
2120 pr_cfg_small_rx
.max_entries_rcq
= 1;
2121 pr_cfg_small_rx
.max_entries_scq
= sq_entries
;
2122 pr_cfg_small_rx
.max_entries_sq
= sq_entries
;
2123 pr_cfg_small_rx
.max_entries_rq1
= 1;
2124 pr_cfg_small_rx
.max_entries_rq2
= 1;
2125 pr_cfg_small_rx
.max_entries_rq3
= 1;
2127 for (i
= 0; i
< def_qps
; i
++) {
2128 ret
= ehea_init_port_res(port
, &port
->port_res
[i
], &pr_cfg
, i
);
2132 for (i
= def_qps
; i
< def_qps
+ add_tx_qps
; i
++) {
2133 ret
= ehea_init_port_res(port
, &port
->port_res
[i
],
2134 &pr_cfg_small_rx
, i
);
2143 ehea_clean_portres(port
, &port
->port_res
[i
]);
2146 ehea_destroy_eq(port
->qp_eq
);
2150 static int ehea_clean_all_portres(struct ehea_port
*port
)
2155 for(i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++)
2156 ret
|= ehea_clean_portres(port
, &port
->port_res
[i
]);
2158 ret
|= ehea_destroy_eq(port
->qp_eq
);
2163 static void ehea_remove_adapter_mr(struct ehea_adapter
*adapter
)
2165 if (adapter
->active_ports
)
2168 ehea_rem_mr(&adapter
->mr
);
2171 static int ehea_add_adapter_mr(struct ehea_adapter
*adapter
)
2173 if (adapter
->active_ports
)
2176 return ehea_reg_kernel_mr(adapter
, &adapter
->mr
);
2179 static int ehea_up(struct net_device
*dev
)
2182 struct ehea_port
*port
= netdev_priv(dev
);
2184 if (port
->state
== EHEA_PORT_UP
)
2187 ret
= ehea_port_res_setup(port
, port
->num_def_qps
,
2188 port
->num_add_tx_qps
);
2190 ehea_error("port_res_failed");
2194 /* Set default QP for this port */
2195 ret
= ehea_configure_port(port
);
2197 ehea_error("ehea_configure_port failed. ret:%d", ret
);
2201 ret
= ehea_reg_interrupts(dev
);
2203 ehea_error("reg_interrupts failed. ret:%d", ret
);
2207 for(i
= 0; i
< port
->num_def_qps
+ port
->num_add_tx_qps
; i
++) {
2208 ret
= ehea_activate_qp(port
->adapter
, port
->port_res
[i
].qp
);
2210 ehea_error("activate_qp failed");
2215 for(i
= 0; i
< port
->num_def_qps
; i
++) {
2216 ret
= ehea_fill_port_res(&port
->port_res
[i
]);
2218 ehea_error("out_free_irqs");
2224 port
->state
= EHEA_PORT_UP
;
2228 ehea_free_interrupts(dev
);
2231 ehea_clean_all_portres(port
);
2234 ehea_info("Failed starting %s. ret=%i", dev
->name
, ret
);
2239 static int ehea_open(struct net_device
*dev
)
2242 struct ehea_port
*port
= netdev_priv(dev
);
2244 down(&port
->port_lock
);
2246 if (netif_msg_ifup(port
))
2247 ehea_info("enabling port %s", dev
->name
);
2251 netif_start_queue(dev
);
2253 up(&port
->port_lock
);
2258 static int ehea_down(struct net_device
*dev
)
2261 struct ehea_port
*port
= netdev_priv(dev
);
2263 if (port
->state
== EHEA_PORT_DOWN
)
2266 ehea_drop_multicast_list(dev
);
2267 ehea_free_interrupts(dev
);
2269 for (i
= 0; i
< port
->num_def_qps
; i
++)
2270 while (test_bit(__LINK_STATE_RX_SCHED
,
2271 &port
->port_res
[i
].d_netdev
->state
))
2274 port
->state
= EHEA_PORT_DOWN
;
2276 ret
= ehea_clean_all_portres(port
);
2278 ehea_info("Failed freeing resources for %s. ret=%i",
2284 static int ehea_stop(struct net_device
*dev
)
2287 struct ehea_port
*port
= netdev_priv(dev
);
2289 if (netif_msg_ifdown(port
))
2290 ehea_info("disabling port %s", dev
->name
);
2292 flush_workqueue(port
->adapter
->ehea_wq
);
2293 down(&port
->port_lock
);
2294 netif_stop_queue(dev
);
2295 ret
= ehea_down(dev
);
2296 up(&port
->port_lock
);
2300 static void ehea_reset_port(struct work_struct
*work
)
2303 struct ehea_port
*port
=
2304 container_of(work
, struct ehea_port
, reset_task
);
2305 struct net_device
*dev
= port
->netdev
;
2308 down(&port
->port_lock
);
2309 netif_stop_queue(dev
);
2310 netif_poll_disable(dev
);
2318 if (netif_msg_timer(port
))
2319 ehea_info("Device %s resetted successfully", dev
->name
);
2321 netif_poll_enable(dev
);
2322 netif_wake_queue(dev
);
2324 up(&port
->port_lock
);
2328 static void ehea_rereg_mrs(struct work_struct
*work
)
2331 struct ehea_adapter
*adapter
;
2333 ehea_info("LPAR memory enlarged - re-initializing driver");
2335 list_for_each_entry(adapter
, &adapter_list
, list
)
2336 if (adapter
->active_ports
) {
2337 /* Shutdown all ports */
2338 for (i
= 0; i
< EHEA_MAX_PORTS
; i
++) {
2339 struct ehea_port
*port
= adapter
->port
[i
];
2342 struct net_device
*dev
= port
->netdev
;
2344 if (dev
->flags
& IFF_UP
) {
2345 ehea_info("stopping %s",
2347 down(&port
->port_lock
);
2348 netif_stop_queue(dev
);
2349 netif_poll_disable(dev
);
2351 up(&port
->port_lock
);
2356 /* Unregister old memory region */
2357 ret
= ehea_rem_mr(&adapter
->mr
);
2359 ehea_error("unregister MR failed - driver"
2365 ehea_destroy_busmap();
2367 ret
= ehea_create_busmap();
2371 clear_bit(__EHEA_STOP_XFER
, &ehea_driver_flags
);
2373 list_for_each_entry(adapter
, &adapter_list
, list
)
2374 if (adapter
->active_ports
) {
2375 /* Register new memory region */
2376 ret
= ehea_reg_kernel_mr(adapter
, &adapter
->mr
);
2378 ehea_error("register MR failed - driver"
2383 /* Restart all ports */
2384 for (i
= 0; i
< EHEA_MAX_PORTS
; i
++) {
2385 struct ehea_port
*port
= adapter
->port
[i
];
2388 struct net_device
*dev
= port
->netdev
;
2390 if (dev
->flags
& IFF_UP
) {
2391 ehea_info("restarting %s",
2393 down(&port
->port_lock
);
2397 netif_poll_enable(dev
);
2398 netif_wake_queue(dev
);
2401 up(&port
->port_lock
);
2410 static void ehea_tx_watchdog(struct net_device
*dev
)
2412 struct ehea_port
*port
= netdev_priv(dev
);
2414 if (netif_carrier_ok(dev
))
2415 queue_work(port
->adapter
->ehea_wq
, &port
->reset_task
);
2418 int ehea_sense_adapter_attr(struct ehea_adapter
*adapter
)
2420 struct hcp_query_ehea
*cb
;
2424 cb
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
2430 hret
= ehea_h_query_ehea(adapter
->handle
, cb
);
2432 if (hret
!= H_SUCCESS
) {
2437 adapter
->max_mc_mac
= cb
->max_mc_mac
- 1;
2446 int ehea_get_jumboframe_status(struct ehea_port
*port
, int *jumbo
)
2448 struct hcp_ehea_port_cb4
*cb4
;
2454 /* (Try to) enable *jumbo frames */
2455 cb4
= kzalloc(PAGE_SIZE
, GFP_KERNEL
);
2457 ehea_error("no mem for cb4");
2461 hret
= ehea_h_query_ehea_port(port
->adapter
->handle
,
2462 port
->logical_port_id
,
2464 H_PORT_CB4_JUMBO
, cb4
);
2465 if (hret
== H_SUCCESS
) {
2466 if (cb4
->jumbo_frame
)
2469 cb4
->jumbo_frame
= 1;
2470 hret
= ehea_h_modify_ehea_port(port
->adapter
->
2477 if (hret
== H_SUCCESS
)
2489 static ssize_t
ehea_show_port_id(struct device
*dev
,
2490 struct device_attribute
*attr
, char *buf
)
2492 struct ehea_port
*port
= container_of(dev
, struct ehea_port
, ofdev
.dev
);
2493 return sprintf(buf
, "%d", port
->logical_port_id
);
2496 static DEVICE_ATTR(log_port_id
, S_IRUSR
| S_IRGRP
| S_IROTH
, ehea_show_port_id
,
2499 static void __devinit
logical_port_release(struct device
*dev
)
2501 struct ehea_port
*port
= container_of(dev
, struct ehea_port
, ofdev
.dev
);
2502 of_node_put(port
->ofdev
.node
);
2505 static int ehea_driver_sysfs_add(struct device
*dev
,
2506 struct device_driver
*driver
)
2510 ret
= sysfs_create_link(&driver
->kobj
, &dev
->kobj
,
2511 kobject_name(&dev
->kobj
));
2513 ret
= sysfs_create_link(&dev
->kobj
, &driver
->kobj
,
2516 sysfs_remove_link(&driver
->kobj
,
2517 kobject_name(&dev
->kobj
));
2522 static void ehea_driver_sysfs_remove(struct device
*dev
,
2523 struct device_driver
*driver
)
2525 struct device_driver
*drv
= driver
;
2528 sysfs_remove_link(&drv
->kobj
, kobject_name(&dev
->kobj
));
2529 sysfs_remove_link(&dev
->kobj
, "driver");
2533 static struct device
*ehea_register_port(struct ehea_port
*port
,
2534 struct device_node
*dn
)
2538 port
->ofdev
.node
= of_node_get(dn
);
2539 port
->ofdev
.dev
.parent
= &port
->adapter
->ebus_dev
->ofdev
.dev
;
2540 port
->ofdev
.dev
.bus
= &ibmebus_bus_type
;
2542 sprintf(port
->ofdev
.dev
.bus_id
, "port%d", port_name_cnt
++);
2543 port
->ofdev
.dev
.release
= logical_port_release
;
2545 ret
= of_device_register(&port
->ofdev
);
2547 ehea_error("failed to register device. ret=%d", ret
);
2551 ret
= device_create_file(&port
->ofdev
.dev
, &dev_attr_log_port_id
);
2553 ehea_error("failed to register attributes, ret=%d", ret
);
2554 goto out_unreg_of_dev
;
2557 ret
= ehea_driver_sysfs_add(&port
->ofdev
.dev
, &ehea_driver
.driver
);
2559 ehea_error("failed to register sysfs driver link");
2560 goto out_rem_dev_file
;
2563 return &port
->ofdev
.dev
;
2566 device_remove_file(&port
->ofdev
.dev
, &dev_attr_log_port_id
);
2568 of_device_unregister(&port
->ofdev
);
2573 static void ehea_unregister_port(struct ehea_port
*port
)
2575 ehea_driver_sysfs_remove(&port
->ofdev
.dev
, &ehea_driver
.driver
);
2576 device_remove_file(&port
->ofdev
.dev
, &dev_attr_log_port_id
);
2577 of_device_unregister(&port
->ofdev
);
2580 struct ehea_port
*ehea_setup_single_port(struct ehea_adapter
*adapter
,
2581 u32 logical_port_id
,
2582 struct device_node
*dn
)
2585 struct net_device
*dev
;
2586 struct ehea_port
*port
;
2587 struct device
*port_dev
;
2590 /* allocate memory for the port structures */
2591 dev
= alloc_etherdev(sizeof(struct ehea_port
));
2594 ehea_error("no mem for net_device");
2599 port
= netdev_priv(dev
);
2601 sema_init(&port
->port_lock
, 1);
2602 port
->state
= EHEA_PORT_DOWN
;
2603 port
->sig_comp_iv
= sq_entries
/ 10;
2605 port
->adapter
= adapter
;
2607 port
->logical_port_id
= logical_port_id
;
2609 port
->msg_enable
= netif_msg_init(msg_level
, EHEA_MSG_DEFAULT
);
2611 port
->mc_list
= kzalloc(sizeof(struct ehea_mc_list
), GFP_KERNEL
);
2612 if (!port
->mc_list
) {
2614 goto out_free_ethdev
;
2617 INIT_LIST_HEAD(&port
->mc_list
->list
);
2619 ret
= ehea_sense_port_attr(port
);
2621 goto out_free_mc_list
;
2623 port_dev
= ehea_register_port(port
, dn
);
2625 goto out_free_mc_list
;
2627 SET_NETDEV_DEV(dev
, port_dev
);
2629 /* initialize net_device structure */
2630 SET_MODULE_OWNER(dev
);
2632 memcpy(dev
->dev_addr
, &port
->mac_addr
, ETH_ALEN
);
2634 dev
->open
= ehea_open
;
2635 dev
->poll
= ehea_poll_firstqueue
;
2636 #ifdef CONFIG_NET_POLL_CONTROLLER
2637 dev
->poll_controller
= ehea_netpoll
;
2640 dev
->stop
= ehea_stop
;
2641 dev
->hard_start_xmit
= ehea_start_xmit
;
2642 dev
->get_stats
= ehea_get_stats
;
2643 dev
->set_multicast_list
= ehea_set_multicast_list
;
2644 dev
->set_mac_address
= ehea_set_mac_addr
;
2645 dev
->change_mtu
= ehea_change_mtu
;
2646 dev
->vlan_rx_register
= ehea_vlan_rx_register
;
2647 dev
->vlan_rx_add_vid
= ehea_vlan_rx_add_vid
;
2648 dev
->vlan_rx_kill_vid
= ehea_vlan_rx_kill_vid
;
2649 dev
->features
= NETIF_F_SG
| NETIF_F_FRAGLIST
| NETIF_F_TSO
2650 | NETIF_F_HIGHDMA
| NETIF_F_HW_CSUM
| NETIF_F_HW_VLAN_TX
2651 | NETIF_F_HW_VLAN_RX
| NETIF_F_HW_VLAN_FILTER
2653 dev
->tx_timeout
= &ehea_tx_watchdog
;
2654 dev
->watchdog_timeo
= EHEA_WATCH_DOG_TIMEOUT
;
2656 INIT_WORK(&port
->reset_task
, ehea_reset_port
);
2658 ret
= ehea_broadcast_reg_helper(port
, H_REG_BCMC
);
2661 goto out_unreg_port
;
2664 ehea_set_ethtool_ops(dev
);
2666 ret
= register_netdev(dev
);
2668 ehea_error("register_netdev failed. ret=%d", ret
);
2672 ret
= ehea_get_jumboframe_status(port
, &jumbo
);
2674 ehea_error("failed determining jumbo frame status for %s",
2675 port
->netdev
->name
);
2677 ehea_info("%s: Jumbo frames are %sabled", dev
->name
,
2678 jumbo
== 1 ? "en" : "dis");
2680 adapter
->active_ports
++;
2685 ehea_broadcast_reg_helper(port
, H_DEREG_BCMC
);
2688 ehea_unregister_port(port
);
2691 kfree(port
->mc_list
);
2697 ehea_error("setting up logical port with id=%d failed, ret=%d",
2698 logical_port_id
, ret
);
2702 static void ehea_shutdown_single_port(struct ehea_port
*port
)
2704 unregister_netdev(port
->netdev
);
2705 ehea_unregister_port(port
);
2706 ehea_broadcast_reg_helper(port
, H_DEREG_BCMC
);
2707 kfree(port
->mc_list
);
2708 free_netdev(port
->netdev
);
2709 port
->adapter
->active_ports
--;
2712 static int ehea_setup_ports(struct ehea_adapter
*adapter
)
2714 struct device_node
*lhea_dn
;
2715 struct device_node
*eth_dn
= NULL
;
2717 const u32
*dn_log_port_id
;
2720 lhea_dn
= adapter
->ebus_dev
->ofdev
.node
;
2721 while ((eth_dn
= of_get_next_child(lhea_dn
, eth_dn
))) {
2723 dn_log_port_id
= of_get_property(eth_dn
, "ibm,hea-port-no",
2725 if (!dn_log_port_id
) {
2726 ehea_error("bad device node: eth_dn name=%s",
2731 if (ehea_add_adapter_mr(adapter
)) {
2732 ehea_error("creating MR failed");
2733 of_node_put(eth_dn
);
2737 adapter
->port
[i
] = ehea_setup_single_port(adapter
,
2740 if (adapter
->port
[i
])
2741 ehea_info("%s -> logical port id #%d",
2742 adapter
->port
[i
]->netdev
->name
,
2745 ehea_remove_adapter_mr(adapter
);
2753 static struct device_node
*ehea_get_eth_dn(struct ehea_adapter
*adapter
,
2754 u32 logical_port_id
)
2756 struct device_node
*lhea_dn
;
2757 struct device_node
*eth_dn
= NULL
;
2758 const u32
*dn_log_port_id
;
2760 lhea_dn
= adapter
->ebus_dev
->ofdev
.node
;
2761 while ((eth_dn
= of_get_next_child(lhea_dn
, eth_dn
))) {
2763 dn_log_port_id
= of_get_property(eth_dn
, "ibm,hea-port-no",
2766 if (*dn_log_port_id
== logical_port_id
)
2773 static ssize_t
ehea_probe_port(struct device
*dev
,
2774 struct device_attribute
*attr
,
2775 const char *buf
, size_t count
)
2777 struct ehea_adapter
*adapter
= dev
->driver_data
;
2778 struct ehea_port
*port
;
2779 struct device_node
*eth_dn
= NULL
;
2782 u32 logical_port_id
;
2784 sscanf(buf
, "%d", &logical_port_id
);
2786 port
= ehea_get_port(adapter
, logical_port_id
);
2789 ehea_info("adding port with logical port id=%d failed. port "
2790 "already configured as %s.", logical_port_id
,
2791 port
->netdev
->name
);
2795 eth_dn
= ehea_get_eth_dn(adapter
, logical_port_id
);
2798 ehea_info("no logical port with id %d found", logical_port_id
);
2802 if (ehea_add_adapter_mr(adapter
)) {
2803 ehea_error("creating MR failed");
2807 port
= ehea_setup_single_port(adapter
, logical_port_id
, eth_dn
);
2809 of_node_put(eth_dn
);
2812 for (i
=0; i
< EHEA_MAX_PORTS
; i
++)
2813 if (!adapter
->port
[i
]) {
2814 adapter
->port
[i
] = port
;
2818 ehea_info("added %s (logical port id=%d)", port
->netdev
->name
,
2821 ehea_remove_adapter_mr(adapter
);
2825 return (ssize_t
) count
;
2828 static ssize_t
ehea_remove_port(struct device
*dev
,
2829 struct device_attribute
*attr
,
2830 const char *buf
, size_t count
)
2832 struct ehea_adapter
*adapter
= dev
->driver_data
;
2833 struct ehea_port
*port
;
2835 u32 logical_port_id
;
2837 sscanf(buf
, "%d", &logical_port_id
);
2839 port
= ehea_get_port(adapter
, logical_port_id
);
2842 ehea_info("removed %s (logical port id=%d)", port
->netdev
->name
,
2845 ehea_shutdown_single_port(port
);
2847 for (i
=0; i
< EHEA_MAX_PORTS
; i
++)
2848 if (adapter
->port
[i
] == port
) {
2849 adapter
->port
[i
] = NULL
;
2853 ehea_error("removing port with logical port id=%d failed. port "
2854 "not configured.", logical_port_id
);
2858 ehea_remove_adapter_mr(adapter
);
2860 return (ssize_t
) count
;
2863 static DEVICE_ATTR(probe_port
, S_IWUSR
, NULL
, ehea_probe_port
);
2864 static DEVICE_ATTR(remove_port
, S_IWUSR
, NULL
, ehea_remove_port
);
2866 int ehea_create_device_sysfs(struct ibmebus_dev
*dev
)
2868 int ret
= device_create_file(&dev
->ofdev
.dev
, &dev_attr_probe_port
);
2872 ret
= device_create_file(&dev
->ofdev
.dev
, &dev_attr_remove_port
);
2877 void ehea_remove_device_sysfs(struct ibmebus_dev
*dev
)
2879 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_probe_port
);
2880 device_remove_file(&dev
->ofdev
.dev
, &dev_attr_remove_port
);
2883 static int __devinit
ehea_probe_adapter(struct ibmebus_dev
*dev
,
2884 const struct of_device_id
*id
)
2886 struct ehea_adapter
*adapter
;
2887 const u64
*adapter_handle
;
2890 if (!dev
|| !dev
->ofdev
.node
) {
2891 ehea_error("Invalid ibmebus device probed");
2895 adapter
= kzalloc(sizeof(*adapter
), GFP_KERNEL
);
2898 dev_err(&dev
->ofdev
.dev
, "no mem for ehea_adapter\n");
2902 list_add(&adapter
->list
, &adapter_list
);
2904 adapter
->ebus_dev
= dev
;
2906 adapter_handle
= of_get_property(dev
->ofdev
.node
, "ibm,hea-handle",
2909 adapter
->handle
= *adapter_handle
;
2911 if (!adapter
->handle
) {
2912 dev_err(&dev
->ofdev
.dev
, "failed getting handle for adapter"
2913 " '%s'\n", dev
->ofdev
.node
->full_name
);
2918 adapter
->pd
= EHEA_PD_ID
;
2920 dev
->ofdev
.dev
.driver_data
= adapter
;
2923 /* initialize adapter and ports */
2924 /* get adapter properties */
2925 ret
= ehea_sense_adapter_attr(adapter
);
2927 dev_err(&dev
->ofdev
.dev
, "sense_adapter_attr failed: %d", ret
);
2931 adapter
->neq
= ehea_create_eq(adapter
,
2932 EHEA_NEQ
, EHEA_MAX_ENTRIES_EQ
, 1);
2933 if (!adapter
->neq
) {
2935 dev_err(&dev
->ofdev
.dev
, "NEQ creation failed");
2939 tasklet_init(&adapter
->neq_tasklet
, ehea_neq_tasklet
,
2940 (unsigned long)adapter
);
2942 ret
= ibmebus_request_irq(NULL
, adapter
->neq
->attr
.ist1
,
2943 ehea_interrupt_neq
, IRQF_DISABLED
,
2944 "ehea_neq", adapter
);
2946 dev_err(&dev
->ofdev
.dev
, "requesting NEQ IRQ failed");
2950 adapter
->ehea_wq
= create_workqueue("ehea_wq");
2951 if (!adapter
->ehea_wq
) {
2956 ret
= ehea_create_device_sysfs(dev
);
2960 ret
= ehea_setup_ports(adapter
);
2962 dev_err(&dev
->ofdev
.dev
, "setup_ports failed");
2963 goto out_rem_dev_sysfs
;
2970 ehea_remove_device_sysfs(dev
);
2973 destroy_workqueue(adapter
->ehea_wq
);
2976 ibmebus_free_irq(NULL
, adapter
->neq
->attr
.ist1
, adapter
);
2979 ehea_destroy_eq(adapter
->neq
);
2987 static int __devexit
ehea_remove(struct ibmebus_dev
*dev
)
2989 struct ehea_adapter
*adapter
= dev
->ofdev
.dev
.driver_data
;
2992 for (i
= 0; i
< EHEA_MAX_PORTS
; i
++)
2993 if (adapter
->port
[i
]) {
2994 ehea_shutdown_single_port(adapter
->port
[i
]);
2995 adapter
->port
[i
] = NULL
;
2998 ehea_remove_device_sysfs(dev
);
3000 destroy_workqueue(adapter
->ehea_wq
);
3002 ibmebus_free_irq(NULL
, adapter
->neq
->attr
.ist1
, adapter
);
3003 tasklet_kill(&adapter
->neq_tasklet
);
3005 ehea_destroy_eq(adapter
->neq
);
3006 ehea_remove_adapter_mr(adapter
);
3007 list_del(&adapter
->list
);
3014 static int check_module_parm(void)
3018 if ((rq1_entries
< EHEA_MIN_ENTRIES_QP
) ||
3019 (rq1_entries
> EHEA_MAX_ENTRIES_RQ1
)) {
3020 ehea_info("Bad parameter: rq1_entries");
3023 if ((rq2_entries
< EHEA_MIN_ENTRIES_QP
) ||
3024 (rq2_entries
> EHEA_MAX_ENTRIES_RQ2
)) {
3025 ehea_info("Bad parameter: rq2_entries");
3028 if ((rq3_entries
< EHEA_MIN_ENTRIES_QP
) ||
3029 (rq3_entries
> EHEA_MAX_ENTRIES_RQ3
)) {
3030 ehea_info("Bad parameter: rq3_entries");
3033 if ((sq_entries
< EHEA_MIN_ENTRIES_QP
) ||
3034 (sq_entries
> EHEA_MAX_ENTRIES_SQ
)) {
3035 ehea_info("Bad parameter: sq_entries");
3042 static ssize_t
ehea_show_capabilities(struct device_driver
*drv
,
3045 return sprintf(buf
, "%d", EHEA_CAPABILITIES
);
3048 static DRIVER_ATTR(capabilities
, S_IRUSR
| S_IRGRP
| S_IROTH
,
3049 ehea_show_capabilities
, NULL
);
3051 int __init
ehea_module_init(void)
3055 printk(KERN_INFO
"IBM eHEA ethernet device driver (Release %s)\n",
3058 ehea_driver_wq
= create_workqueue("ehea_driver_wq");
3060 INIT_WORK(&ehea_rereg_mr_task
, ehea_rereg_mrs
);
3062 ret
= check_module_parm();
3066 ret
= ehea_create_busmap();
3070 ret
= ibmebus_register_driver(&ehea_driver
);
3072 ehea_error("failed registering eHEA device driver on ebus");
3076 ret
= driver_create_file(&ehea_driver
.driver
,
3077 &driver_attr_capabilities
);
3079 ehea_error("failed to register capabilities attribute, ret=%d",
3081 ibmebus_unregister_driver(&ehea_driver
);
3089 static void __exit
ehea_module_exit(void)
3091 destroy_workqueue(ehea_driver_wq
);
3092 driver_remove_file(&ehea_driver
.driver
, &driver_attr_capabilities
);
3093 ibmebus_unregister_driver(&ehea_driver
);
3094 ehea_destroy_busmap();
3097 module_init(ehea_module_init
);
3098 module_exit(ehea_module_exit
);