1 /* QLogic qed NIC Driver
2 * Copyright (c) 2015-2017 QLogic Corporation
4 * This software is available to you under a choice of one of two
5 * licenses. You may choose to be licensed under the terms of the GNU
6 * General Public License (GPL) Version 2, available from the file
7 * COPYING in the main directory of this source tree, or the
8 * OpenIB.org BSD license below:
10 * Redistribution and use in source and binary forms, with or
11 * without modification, are permitted provided that the following
14 * - Redistributions of source code must retain the above
15 * copyright notice, this list of conditions and the following
18 * - Redistributions in binary form must reproduce the above
19 * copyright notice, this list of conditions and the following
20 * disclaimer in the documentation and /or other materials
21 * provided with the distribution.
23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
33 #include <linux/types.h>
34 #include <asm/byteorder.h>
35 #include <linux/dma-mapping.h>
36 #include <linux/if_vlan.h>
37 #include <linux/kernel.h>
38 #include <linux/pci.h>
39 #include <linux/slab.h>
40 #include <linux/stddef.h>
41 #include <linux/workqueue.h>
43 #include <linux/bitops.h>
44 #include <linux/delay.h>
45 #include <linux/errno.h>
46 #include <linux/etherdevice.h>
48 #include <linux/list.h>
49 #include <linux/mutex.h>
50 #include <linux/spinlock.h>
51 #include <linux/string.h>
52 #include <linux/qed/qed_ll2_if.h>
55 #include "qed_dev_api.h"
62 #include "qed_reg_addr.h"
66 #define QED_LL2_RX_REGISTERED(ll2) ((ll2)->rx_queue.b_cb_registred)
67 #define QED_LL2_TX_REGISTERED(ll2) ((ll2)->tx_queue.b_cb_registred)
69 #define QED_LL2_TX_SIZE (256)
70 #define QED_LL2_RX_SIZE (4096)
72 struct qed_cb_ll2_info
{
77 /* Lock protecting LL2 buffer lists in sleepless context */
79 struct list_head list
;
81 const struct qed_ll2_cb_ops
*cbs
;
85 struct qed_ll2_buffer
{
86 struct list_head list
;
91 static void qed_ll2b_complete_tx_packet(void *cxt
,
94 dma_addr_t first_frag_addr
,
98 struct qed_hwfn
*p_hwfn
= cxt
;
99 struct qed_dev
*cdev
= p_hwfn
->cdev
;
100 struct sk_buff
*skb
= cookie
;
102 /* All we need to do is release the mapping */
103 dma_unmap_single(&p_hwfn
->cdev
->pdev
->dev
, first_frag_addr
,
104 skb_headlen(skb
), DMA_TO_DEVICE
);
106 if (cdev
->ll2
->cbs
&& cdev
->ll2
->cbs
->tx_cb
)
107 cdev
->ll2
->cbs
->tx_cb(cdev
->ll2
->cb_cookie
, skb
,
110 dev_kfree_skb_any(skb
);
113 static int qed_ll2_alloc_buffer(struct qed_dev
*cdev
,
114 u8
**data
, dma_addr_t
*phys_addr
)
116 *data
= kmalloc(cdev
->ll2
->rx_size
, GFP_ATOMIC
);
118 DP_INFO(cdev
, "Failed to allocate LL2 buffer data\n");
122 *phys_addr
= dma_map_single(&cdev
->pdev
->dev
,
123 ((*data
) + NET_SKB_PAD
),
124 cdev
->ll2
->rx_size
, DMA_FROM_DEVICE
);
125 if (dma_mapping_error(&cdev
->pdev
->dev
, *phys_addr
)) {
126 DP_INFO(cdev
, "Failed to map LL2 buffer data\n");
134 static int qed_ll2_dealloc_buffer(struct qed_dev
*cdev
,
135 struct qed_ll2_buffer
*buffer
)
137 spin_lock_bh(&cdev
->ll2
->lock
);
139 dma_unmap_single(&cdev
->pdev
->dev
, buffer
->phys_addr
,
140 cdev
->ll2
->rx_size
, DMA_FROM_DEVICE
);
142 list_del(&buffer
->list
);
145 if (!cdev
->ll2
->rx_cnt
)
146 DP_INFO(cdev
, "All LL2 entries were removed\n");
148 spin_unlock_bh(&cdev
->ll2
->lock
);
153 static void qed_ll2_kill_buffers(struct qed_dev
*cdev
)
155 struct qed_ll2_buffer
*buffer
, *tmp_buffer
;
157 list_for_each_entry_safe(buffer
, tmp_buffer
, &cdev
->ll2
->list
, list
)
158 qed_ll2_dealloc_buffer(cdev
, buffer
);
161 void qed_ll2b_complete_rx_packet(void *cxt
, struct qed_ll2_comp_rx_data
*data
)
163 struct qed_hwfn
*p_hwfn
= cxt
;
164 struct qed_ll2_buffer
*buffer
= data
->cookie
;
165 struct qed_dev
*cdev
= p_hwfn
->cdev
;
166 dma_addr_t new_phys_addr
;
173 (NETIF_MSG_RX_STATUS
| QED_MSG_STORAGE
| NETIF_MSG_PKTDATA
),
174 "Got an LL2 Rx completion: [Buffer at phys 0x%llx, offset 0x%02x] Length 0x%04x Parse_flags 0x%04x vlan 0x%04x Opaque data [0x%08x:0x%08x]\n",
175 (u64
)data
->rx_buf_addr
,
176 data
->u
.placement_offset
,
177 data
->length
.packet_length
,
179 data
->vlan
, data
->opaque_data_0
, data
->opaque_data_1
);
181 if ((cdev
->dp_module
& NETIF_MSG_PKTDATA
) && buffer
->data
) {
182 print_hex_dump(KERN_INFO
, "",
183 DUMP_PREFIX_OFFSET
, 16, 1,
184 buffer
->data
, data
->length
.packet_length
, false);
187 /* Determine if data is valid */
188 if (data
->length
.packet_length
< ETH_HLEN
)
191 /* Allocate a replacement for buffer; Reuse upon failure */
193 rc
= qed_ll2_alloc_buffer(p_hwfn
->cdev
, &new_data
,
196 /* If need to reuse or there's no replacement buffer, repost this */
199 dma_unmap_single(&cdev
->pdev
->dev
, buffer
->phys_addr
,
200 cdev
->ll2
->rx_size
, DMA_FROM_DEVICE
);
202 skb
= build_skb(buffer
->data
, 0);
208 data
->u
.placement_offset
+= NET_SKB_PAD
;
209 skb_reserve(skb
, data
->u
.placement_offset
);
210 skb_put(skb
, data
->length
.packet_length
);
211 skb_checksum_none_assert(skb
);
213 /* Get parital ethernet information instead of eth_type_trans(),
214 * Since we don't have an associated net_device.
216 skb_reset_mac_header(skb
);
217 skb
->protocol
= eth_hdr(skb
)->h_proto
;
219 /* Pass SKB onward */
220 if (cdev
->ll2
->cbs
&& cdev
->ll2
->cbs
->rx_cb
) {
222 __vlan_hwaccel_put_tag(skb
, htons(ETH_P_8021Q
),
224 cdev
->ll2
->cbs
->rx_cb(cdev
->ll2
->cb_cookie
, skb
,
226 data
->opaque_data_1
);
229 /* Update Buffer information and update FW producer */
230 buffer
->data
= new_data
;
231 buffer
->phys_addr
= new_phys_addr
;
234 rc
= qed_ll2_post_rx_buffer(QED_LEADING_HWFN(cdev
), cdev
->ll2
->handle
,
235 buffer
->phys_addr
, 0, buffer
, 1);
238 qed_ll2_dealloc_buffer(cdev
, buffer
);
241 static struct qed_ll2_info
*__qed_ll2_handle_sanity(struct qed_hwfn
*p_hwfn
,
242 u8 connection_handle
,
246 struct qed_ll2_info
*p_ll2_conn
, *p_ret
= NULL
;
248 if (connection_handle
>= QED_MAX_NUM_OF_LL2_CONNECTIONS
)
251 if (!p_hwfn
->p_ll2_info
)
254 p_ll2_conn
= &p_hwfn
->p_ll2_info
[connection_handle
];
258 mutex_lock(&p_ll2_conn
->mutex
);
259 if (p_ll2_conn
->b_active
)
262 mutex_unlock(&p_ll2_conn
->mutex
);
270 static struct qed_ll2_info
*qed_ll2_handle_sanity(struct qed_hwfn
*p_hwfn
,
271 u8 connection_handle
)
273 return __qed_ll2_handle_sanity(p_hwfn
, connection_handle
, false, true);
276 static struct qed_ll2_info
*qed_ll2_handle_sanity_lock(struct qed_hwfn
*p_hwfn
,
277 u8 connection_handle
)
279 return __qed_ll2_handle_sanity(p_hwfn
, connection_handle
, true, true);
282 static struct qed_ll2_info
*qed_ll2_handle_sanity_inactive(struct qed_hwfn
284 u8 connection_handle
)
286 return __qed_ll2_handle_sanity(p_hwfn
, connection_handle
, false, false);
289 static void qed_ll2_txq_flush(struct qed_hwfn
*p_hwfn
, u8 connection_handle
)
291 bool b_last_packet
= false, b_last_frag
= false;
292 struct qed_ll2_tx_packet
*p_pkt
= NULL
;
293 struct qed_ll2_info
*p_ll2_conn
;
294 struct qed_ll2_tx_queue
*p_tx
;
297 p_ll2_conn
= qed_ll2_handle_sanity_inactive(p_hwfn
, connection_handle
);
301 p_tx
= &p_ll2_conn
->tx_queue
;
303 while (!list_empty(&p_tx
->active_descq
)) {
304 p_pkt
= list_first_entry(&p_tx
->active_descq
,
305 struct qed_ll2_tx_packet
, list_entry
);
309 list_del(&p_pkt
->list_entry
);
310 b_last_packet
= list_empty(&p_tx
->active_descq
);
311 list_add_tail(&p_pkt
->list_entry
, &p_tx
->free_descq
);
312 if (p_ll2_conn
->input
.conn_type
== QED_LL2_TYPE_OOO
) {
313 struct qed_ooo_buffer
*p_buffer
;
315 p_buffer
= (struct qed_ooo_buffer
*)p_pkt
->cookie
;
316 qed_ooo_put_free_buffer(p_hwfn
, p_hwfn
->p_ooo_info
,
319 p_tx
->cur_completing_packet
= *p_pkt
;
320 p_tx
->cur_completing_bd_idx
= 1;
322 p_tx
->cur_completing_bd_idx
== p_pkt
->bd_used
;
323 tx_frag
= p_pkt
->bds_set
[0].tx_frag
;
324 p_ll2_conn
->cbs
.tx_release_cb(p_ll2_conn
->cbs
.cookie
,
334 static int qed_ll2_txq_completion(struct qed_hwfn
*p_hwfn
, void *p_cookie
)
336 struct qed_ll2_info
*p_ll2_conn
= p_cookie
;
337 struct qed_ll2_tx_queue
*p_tx
= &p_ll2_conn
->tx_queue
;
338 u16 new_idx
= 0, num_bds
= 0, num_bds_in_packet
= 0;
339 struct qed_ll2_tx_packet
*p_pkt
;
340 bool b_last_frag
= false;
344 spin_lock_irqsave(&p_tx
->lock
, flags
);
345 if (p_tx
->b_completing_packet
) {
350 new_idx
= le16_to_cpu(*p_tx
->p_fw_cons
);
351 num_bds
= ((s16
)new_idx
- (s16
)p_tx
->bds_idx
);
353 if (list_empty(&p_tx
->active_descq
))
356 p_pkt
= list_first_entry(&p_tx
->active_descq
,
357 struct qed_ll2_tx_packet
, list_entry
);
361 p_tx
->b_completing_packet
= true;
362 p_tx
->cur_completing_packet
= *p_pkt
;
363 num_bds_in_packet
= p_pkt
->bd_used
;
364 list_del(&p_pkt
->list_entry
);
366 if (num_bds
< num_bds_in_packet
) {
368 "Rest of BDs does not cover whole packet\n");
372 num_bds
-= num_bds_in_packet
;
373 p_tx
->bds_idx
+= num_bds_in_packet
;
374 while (num_bds_in_packet
--)
375 qed_chain_consume(&p_tx
->txq_chain
);
377 p_tx
->cur_completing_bd_idx
= 1;
378 b_last_frag
= p_tx
->cur_completing_bd_idx
== p_pkt
->bd_used
;
379 list_add_tail(&p_pkt
->list_entry
, &p_tx
->free_descq
);
381 spin_unlock_irqrestore(&p_tx
->lock
, flags
);
383 p_ll2_conn
->cbs
.tx_comp_cb(p_ll2_conn
->cbs
.cookie
,
386 p_pkt
->bds_set
[0].tx_frag
,
387 b_last_frag
, !num_bds
);
389 spin_lock_irqsave(&p_tx
->lock
, flags
);
392 p_tx
->b_completing_packet
= false;
395 spin_unlock_irqrestore(&p_tx
->lock
, flags
);
399 static void qed_ll2_rxq_parse_gsi(struct qed_hwfn
*p_hwfn
,
400 union core_rx_cqe_union
*p_cqe
,
401 struct qed_ll2_comp_rx_data
*data
)
403 data
->parse_flags
= le16_to_cpu(p_cqe
->rx_cqe_gsi
.parse_flags
.flags
);
404 data
->length
.data_length
= le16_to_cpu(p_cqe
->rx_cqe_gsi
.data_length
);
405 data
->vlan
= le16_to_cpu(p_cqe
->rx_cqe_gsi
.vlan
);
406 data
->opaque_data_0
= le32_to_cpu(p_cqe
->rx_cqe_gsi
.src_mac_addrhi
);
407 data
->opaque_data_1
= le16_to_cpu(p_cqe
->rx_cqe_gsi
.src_mac_addrlo
);
408 data
->u
.data_length_error
= p_cqe
->rx_cqe_gsi
.data_length_error
;
411 static void qed_ll2_rxq_parse_reg(struct qed_hwfn
*p_hwfn
,
412 union core_rx_cqe_union
*p_cqe
,
413 struct qed_ll2_comp_rx_data
*data
)
415 data
->parse_flags
= le16_to_cpu(p_cqe
->rx_cqe_fp
.parse_flags
.flags
);
416 data
->err_flags
= le16_to_cpu(p_cqe
->rx_cqe_fp
.err_flags
.flags
);
417 data
->length
.packet_length
=
418 le16_to_cpu(p_cqe
->rx_cqe_fp
.packet_length
);
419 data
->vlan
= le16_to_cpu(p_cqe
->rx_cqe_fp
.vlan
);
420 data
->opaque_data_0
= le32_to_cpu(p_cqe
->rx_cqe_fp
.opaque_data
.data
[0]);
421 data
->opaque_data_1
= le32_to_cpu(p_cqe
->rx_cqe_fp
.opaque_data
.data
[1]);
422 data
->u
.placement_offset
= p_cqe
->rx_cqe_fp
.placement_offset
;
426 qed_ll2_rxq_handle_completion(struct qed_hwfn
*p_hwfn
,
427 struct qed_ll2_info
*p_ll2_conn
,
428 union core_rx_cqe_union
*p_cqe
,
429 unsigned long *p_lock_flags
, bool b_last_cqe
)
431 struct qed_ll2_rx_queue
*p_rx
= &p_ll2_conn
->rx_queue
;
432 struct qed_ll2_rx_packet
*p_pkt
= NULL
;
433 struct qed_ll2_comp_rx_data data
;
435 if (!list_empty(&p_rx
->active_descq
))
436 p_pkt
= list_first_entry(&p_rx
->active_descq
,
437 struct qed_ll2_rx_packet
, list_entry
);
440 "[%d] LL2 Rx completion but active_descq is empty\n",
441 p_ll2_conn
->input
.conn_type
);
445 list_del(&p_pkt
->list_entry
);
447 if (p_cqe
->rx_cqe_sp
.type
== CORE_RX_CQE_TYPE_REGULAR
)
448 qed_ll2_rxq_parse_reg(p_hwfn
, p_cqe
, &data
);
450 qed_ll2_rxq_parse_gsi(p_hwfn
, p_cqe
, &data
);
451 if (qed_chain_consume(&p_rx
->rxq_chain
) != p_pkt
->rxq_bd
)
453 "Mismatch between active_descq and the LL2 Rx chain\n");
455 list_add_tail(&p_pkt
->list_entry
, &p_rx
->free_descq
);
457 data
.connection_handle
= p_ll2_conn
->my_id
;
458 data
.cookie
= p_pkt
->cookie
;
459 data
.rx_buf_addr
= p_pkt
->rx_buf_addr
;
460 data
.b_last_packet
= b_last_cqe
;
462 spin_unlock_irqrestore(&p_rx
->lock
, *p_lock_flags
);
463 p_ll2_conn
->cbs
.rx_comp_cb(p_ll2_conn
->cbs
.cookie
, &data
);
465 spin_lock_irqsave(&p_rx
->lock
, *p_lock_flags
);
470 static int qed_ll2_rxq_completion(struct qed_hwfn
*p_hwfn
, void *cookie
)
472 struct qed_ll2_info
*p_ll2_conn
= (struct qed_ll2_info
*)cookie
;
473 struct qed_ll2_rx_queue
*p_rx
= &p_ll2_conn
->rx_queue
;
474 union core_rx_cqe_union
*cqe
= NULL
;
475 u16 cq_new_idx
= 0, cq_old_idx
= 0;
476 unsigned long flags
= 0;
479 spin_lock_irqsave(&p_rx
->lock
, flags
);
480 cq_new_idx
= le16_to_cpu(*p_rx
->p_fw_cons
);
481 cq_old_idx
= qed_chain_get_cons_idx(&p_rx
->rcq_chain
);
483 while (cq_new_idx
!= cq_old_idx
) {
484 bool b_last_cqe
= (cq_new_idx
== cq_old_idx
);
487 (union core_rx_cqe_union
*)
488 qed_chain_consume(&p_rx
->rcq_chain
);
489 cq_old_idx
= qed_chain_get_cons_idx(&p_rx
->rcq_chain
);
493 "LL2 [sw. cons %04x, fw. at %04x] - Got Packet of type %02x\n",
494 cq_old_idx
, cq_new_idx
, cqe
->rx_cqe_sp
.type
);
496 switch (cqe
->rx_cqe_sp
.type
) {
497 case CORE_RX_CQE_TYPE_SLOW_PATH
:
498 DP_NOTICE(p_hwfn
, "LL2 - unexpected Rx CQE slowpath\n");
501 case CORE_RX_CQE_TYPE_GSI_OFFLOAD
:
502 case CORE_RX_CQE_TYPE_REGULAR
:
503 rc
= qed_ll2_rxq_handle_completion(p_hwfn
, p_ll2_conn
,
512 spin_unlock_irqrestore(&p_rx
->lock
, flags
);
516 static void qed_ll2_rxq_flush(struct qed_hwfn
*p_hwfn
, u8 connection_handle
)
518 struct qed_ll2_info
*p_ll2_conn
= NULL
;
519 struct qed_ll2_rx_packet
*p_pkt
= NULL
;
520 struct qed_ll2_rx_queue
*p_rx
;
522 p_ll2_conn
= qed_ll2_handle_sanity_inactive(p_hwfn
, connection_handle
);
526 p_rx
= &p_ll2_conn
->rx_queue
;
528 while (!list_empty(&p_rx
->active_descq
)) {
529 p_pkt
= list_first_entry(&p_rx
->active_descq
,
530 struct qed_ll2_rx_packet
, list_entry
);
534 list_move_tail(&p_pkt
->list_entry
, &p_rx
->free_descq
);
536 if (p_ll2_conn
->input
.conn_type
== QED_LL2_TYPE_OOO
) {
537 struct qed_ooo_buffer
*p_buffer
;
539 p_buffer
= (struct qed_ooo_buffer
*)p_pkt
->cookie
;
540 qed_ooo_put_free_buffer(p_hwfn
, p_hwfn
->p_ooo_info
,
543 dma_addr_t rx_buf_addr
= p_pkt
->rx_buf_addr
;
544 void *cookie
= p_pkt
->cookie
;
547 b_last
= list_empty(&p_rx
->active_descq
);
548 p_ll2_conn
->cbs
.rx_release_cb(p_ll2_conn
->cbs
.cookie
,
551 rx_buf_addr
, b_last
);
556 static u8
qed_ll2_convert_rx_parse_to_tx_flags(u16 parse_flags
)
560 if (GET_FIELD(parse_flags
, PARSING_AND_ERR_FLAGS_TAG8021QEXIST
))
561 SET_FIELD(bd_flags
, CORE_TX_BD_DATA_VLAN_INSERTION
, 1);
566 static int qed_ll2_lb_rxq_handler(struct qed_hwfn
*p_hwfn
,
567 struct qed_ll2_info
*p_ll2_conn
)
569 struct qed_ll2_rx_queue
*p_rx
= &p_ll2_conn
->rx_queue
;
570 u16 packet_length
= 0, parse_flags
= 0, vlan
= 0;
571 struct qed_ll2_rx_packet
*p_pkt
= NULL
;
572 u32 num_ooo_add_to_peninsula
= 0, cid
;
573 union core_rx_cqe_union
*cqe
= NULL
;
574 u16 cq_new_idx
= 0, cq_old_idx
= 0;
575 struct qed_ooo_buffer
*p_buffer
;
576 struct ooo_opaque
*iscsi_ooo
;
577 u8 placement_offset
= 0;
580 cq_new_idx
= le16_to_cpu(*p_rx
->p_fw_cons
);
581 cq_old_idx
= qed_chain_get_cons_idx(&p_rx
->rcq_chain
);
582 if (cq_new_idx
== cq_old_idx
)
585 while (cq_new_idx
!= cq_old_idx
) {
586 struct core_rx_fast_path_cqe
*p_cqe_fp
;
588 cqe
= qed_chain_consume(&p_rx
->rcq_chain
);
589 cq_old_idx
= qed_chain_get_cons_idx(&p_rx
->rcq_chain
);
590 cqe_type
= cqe
->rx_cqe_sp
.type
;
592 if (cqe_type
!= CORE_RX_CQE_TYPE_REGULAR
) {
594 "Got a non-regular LB LL2 completion [type 0x%02x]\n",
598 p_cqe_fp
= &cqe
->rx_cqe_fp
;
600 placement_offset
= p_cqe_fp
->placement_offset
;
601 parse_flags
= le16_to_cpu(p_cqe_fp
->parse_flags
.flags
);
602 packet_length
= le16_to_cpu(p_cqe_fp
->packet_length
);
603 vlan
= le16_to_cpu(p_cqe_fp
->vlan
);
604 iscsi_ooo
= (struct ooo_opaque
*)&p_cqe_fp
->opaque_data
;
605 qed_ooo_save_history_entry(p_hwfn
, p_hwfn
->p_ooo_info
,
607 cid
= le32_to_cpu(iscsi_ooo
->cid
);
609 /* Process delete isle first */
610 if (iscsi_ooo
->drop_size
)
611 qed_ooo_delete_isles(p_hwfn
, p_hwfn
->p_ooo_info
, cid
,
612 iscsi_ooo
->drop_isle
,
613 iscsi_ooo
->drop_size
);
615 if (iscsi_ooo
->ooo_opcode
== TCP_EVENT_NOP
)
618 /* Now process create/add/join isles */
619 if (list_empty(&p_rx
->active_descq
)) {
621 "LL2 OOO RX chain has no submitted buffers\n"
626 p_pkt
= list_first_entry(&p_rx
->active_descq
,
627 struct qed_ll2_rx_packet
, list_entry
);
629 if ((iscsi_ooo
->ooo_opcode
== TCP_EVENT_ADD_NEW_ISLE
) ||
630 (iscsi_ooo
->ooo_opcode
== TCP_EVENT_ADD_ISLE_RIGHT
) ||
631 (iscsi_ooo
->ooo_opcode
== TCP_EVENT_ADD_ISLE_LEFT
) ||
632 (iscsi_ooo
->ooo_opcode
== TCP_EVENT_ADD_PEN
) ||
633 (iscsi_ooo
->ooo_opcode
== TCP_EVENT_JOIN
)) {
636 "LL2 OOO RX packet is not valid\n");
639 list_del(&p_pkt
->list_entry
);
640 p_buffer
= (struct qed_ooo_buffer
*)p_pkt
->cookie
;
641 p_buffer
->packet_length
= packet_length
;
642 p_buffer
->parse_flags
= parse_flags
;
643 p_buffer
->vlan
= vlan
;
644 p_buffer
->placement_offset
= placement_offset
;
645 qed_chain_consume(&p_rx
->rxq_chain
);
646 list_add_tail(&p_pkt
->list_entry
, &p_rx
->free_descq
);
648 switch (iscsi_ooo
->ooo_opcode
) {
649 case TCP_EVENT_ADD_NEW_ISLE
:
650 qed_ooo_add_new_isle(p_hwfn
,
656 case TCP_EVENT_ADD_ISLE_RIGHT
:
657 qed_ooo_add_new_buffer(p_hwfn
,
664 case TCP_EVENT_ADD_ISLE_LEFT
:
665 qed_ooo_add_new_buffer(p_hwfn
,
673 qed_ooo_add_new_buffer(p_hwfn
,
676 iscsi_ooo
->ooo_isle
+
680 qed_ooo_join_isles(p_hwfn
,
682 cid
, iscsi_ooo
->ooo_isle
);
684 case TCP_EVENT_ADD_PEN
:
685 num_ooo_add_to_peninsula
++;
686 qed_ooo_put_ready_buffer(p_hwfn
,
693 "Unexpected event (%d) TX OOO completion\n",
694 iscsi_ooo
->ooo_opcode
);
702 qed_ooo_submit_tx_buffers(struct qed_hwfn
*p_hwfn
,
703 struct qed_ll2_info
*p_ll2_conn
)
705 struct qed_ll2_tx_pkt_info tx_pkt
;
706 struct qed_ooo_buffer
*p_buffer
;
708 dma_addr_t first_frag
;
713 /* Submit Tx buffers here */
714 while ((p_buffer
= qed_ooo_get_ready_buffer(p_hwfn
,
715 p_hwfn
->p_ooo_info
))) {
719 first_frag
= p_buffer
->rx_buffer_phys_addr
+
720 p_buffer
->placement_offset
;
721 parse_flags
= p_buffer
->parse_flags
;
722 bd_flags
= qed_ll2_convert_rx_parse_to_tx_flags(parse_flags
);
723 SET_FIELD(bd_flags
, CORE_TX_BD_DATA_FORCE_VLAN_MODE
, 1);
724 SET_FIELD(bd_flags
, CORE_TX_BD_DATA_L4_PROTOCOL
, 1);
726 memset(&tx_pkt
, 0, sizeof(tx_pkt
));
727 tx_pkt
.num_of_bds
= 1;
728 tx_pkt
.vlan
= p_buffer
->vlan
;
729 tx_pkt
.bd_flags
= bd_flags
;
730 tx_pkt
.l4_hdr_offset_w
= l4_hdr_offset_w
;
731 tx_pkt
.tx_dest
= p_ll2_conn
->tx_dest
;
732 tx_pkt
.first_frag
= first_frag
;
733 tx_pkt
.first_frag_len
= p_buffer
->packet_length
;
734 tx_pkt
.cookie
= p_buffer
;
736 rc
= qed_ll2_prepare_tx_packet(p_hwfn
, p_ll2_conn
->my_id
,
739 qed_ooo_put_ready_buffer(p_hwfn
, p_hwfn
->p_ooo_info
,
747 qed_ooo_submit_rx_buffers(struct qed_hwfn
*p_hwfn
,
748 struct qed_ll2_info
*p_ll2_conn
)
750 struct qed_ooo_buffer
*p_buffer
;
753 while ((p_buffer
= qed_ooo_get_free_buffer(p_hwfn
,
754 p_hwfn
->p_ooo_info
))) {
755 rc
= qed_ll2_post_rx_buffer(p_hwfn
,
757 p_buffer
->rx_buffer_phys_addr
,
760 qed_ooo_put_free_buffer(p_hwfn
,
761 p_hwfn
->p_ooo_info
, p_buffer
);
767 static int qed_ll2_lb_rxq_completion(struct qed_hwfn
*p_hwfn
, void *p_cookie
)
769 struct qed_ll2_info
*p_ll2_conn
= (struct qed_ll2_info
*)p_cookie
;
772 rc
= qed_ll2_lb_rxq_handler(p_hwfn
, p_ll2_conn
);
776 qed_ooo_submit_rx_buffers(p_hwfn
, p_ll2_conn
);
777 qed_ooo_submit_tx_buffers(p_hwfn
, p_ll2_conn
);
782 static int qed_ll2_lb_txq_completion(struct qed_hwfn
*p_hwfn
, void *p_cookie
)
784 struct qed_ll2_info
*p_ll2_conn
= (struct qed_ll2_info
*)p_cookie
;
785 struct qed_ll2_tx_queue
*p_tx
= &p_ll2_conn
->tx_queue
;
786 struct qed_ll2_tx_packet
*p_pkt
= NULL
;
787 struct qed_ooo_buffer
*p_buffer
;
788 bool b_dont_submit_rx
= false;
789 u16 new_idx
= 0, num_bds
= 0;
792 new_idx
= le16_to_cpu(*p_tx
->p_fw_cons
);
793 num_bds
= ((s16
)new_idx
- (s16
)p_tx
->bds_idx
);
799 if (list_empty(&p_tx
->active_descq
))
802 p_pkt
= list_first_entry(&p_tx
->active_descq
,
803 struct qed_ll2_tx_packet
, list_entry
);
807 if (p_pkt
->bd_used
!= 1) {
809 "Unexpectedly many BDs(%d) in TX OOO completion\n",
814 list_del(&p_pkt
->list_entry
);
818 qed_chain_consume(&p_tx
->txq_chain
);
820 p_buffer
= (struct qed_ooo_buffer
*)p_pkt
->cookie
;
821 list_add_tail(&p_pkt
->list_entry
, &p_tx
->free_descq
);
823 if (b_dont_submit_rx
) {
824 qed_ooo_put_free_buffer(p_hwfn
, p_hwfn
->p_ooo_info
,
829 rc
= qed_ll2_post_rx_buffer(p_hwfn
, p_ll2_conn
->my_id
,
830 p_buffer
->rx_buffer_phys_addr
, 0,
833 qed_ooo_put_free_buffer(p_hwfn
,
834 p_hwfn
->p_ooo_info
, p_buffer
);
835 b_dont_submit_rx
= true;
839 qed_ooo_submit_tx_buffers(p_hwfn
, p_ll2_conn
);
844 static void qed_ll2_stop_ooo(struct qed_dev
*cdev
)
846 struct qed_hwfn
*hwfn
= QED_LEADING_HWFN(cdev
);
847 u8
*handle
= &hwfn
->pf_params
.iscsi_pf_params
.ll2_ooo_queue_id
;
849 DP_VERBOSE(cdev
, QED_MSG_STORAGE
, "Stopping LL2 OOO queue [%02x]\n",
852 qed_ll2_terminate_connection(hwfn
, *handle
);
853 qed_ll2_release_connection(hwfn
, *handle
);
854 *handle
= QED_LL2_UNUSED_HANDLE
;
857 static int qed_sp_ll2_rx_queue_start(struct qed_hwfn
*p_hwfn
,
858 struct qed_ll2_info
*p_ll2_conn
,
861 enum qed_ll2_conn_type conn_type
= p_ll2_conn
->input
.conn_type
;
862 struct qed_ll2_rx_queue
*p_rx
= &p_ll2_conn
->rx_queue
;
863 struct core_rx_start_ramrod_data
*p_ramrod
= NULL
;
864 struct qed_spq_entry
*p_ent
= NULL
;
865 struct qed_sp_init_data init_data
;
870 memset(&init_data
, 0, sizeof(init_data
));
871 init_data
.cid
= p_ll2_conn
->cid
;
872 init_data
.opaque_fid
= p_hwfn
->hw_info
.opaque_fid
;
873 init_data
.comp_mode
= QED_SPQ_MODE_EBLOCK
;
875 rc
= qed_sp_init_request(p_hwfn
, &p_ent
,
876 CORE_RAMROD_RX_QUEUE_START
,
877 PROTOCOLID_CORE
, &init_data
);
881 p_ramrod
= &p_ent
->ramrod
.core_rx_queue_start
;
883 p_ramrod
->sb_id
= cpu_to_le16(qed_int_get_sp_sb_id(p_hwfn
));
884 p_ramrod
->sb_index
= p_rx
->rx_sb_index
;
885 p_ramrod
->complete_event_flg
= 1;
887 p_ramrod
->mtu
= cpu_to_le16(p_ll2_conn
->input
.mtu
);
888 DMA_REGPAIR_LE(p_ramrod
->bd_base
, p_rx
->rxq_chain
.p_phys_addr
);
889 cqe_pbl_size
= (u16
)qed_chain_get_page_cnt(&p_rx
->rcq_chain
);
890 p_ramrod
->num_of_pbl_pages
= cpu_to_le16(cqe_pbl_size
);
891 DMA_REGPAIR_LE(p_ramrod
->cqe_pbl_addr
,
892 qed_chain_get_pbl_phys(&p_rx
->rcq_chain
));
894 p_ramrod
->drop_ttl0_flg
= p_ll2_conn
->input
.rx_drop_ttl0_flg
;
895 p_ramrod
->inner_vlan_removal_en
= p_ll2_conn
->input
.rx_vlan_removal_en
;
896 p_ramrod
->queue_id
= p_ll2_conn
->queue_id
;
897 p_ramrod
->main_func_queue
= p_ll2_conn
->main_func_queue
? 1 : 0;
899 if ((IS_MF_DEFAULT(p_hwfn
) || IS_MF_SI(p_hwfn
)) &&
900 p_ramrod
->main_func_queue
&& (conn_type
!= QED_LL2_TYPE_ROCE
) &&
901 (conn_type
!= QED_LL2_TYPE_IWARP
)) {
902 p_ramrod
->mf_si_bcast_accept_all
= 1;
903 p_ramrod
->mf_si_mcast_accept_all
= 1;
905 p_ramrod
->mf_si_bcast_accept_all
= 0;
906 p_ramrod
->mf_si_mcast_accept_all
= 0;
909 p_ramrod
->action_on_error
.error_type
= action_on_error
;
910 p_ramrod
->gsi_offload_flag
= p_ll2_conn
->input
.gsi_enable
;
911 return qed_spq_post(p_hwfn
, p_ent
, NULL
);
914 static int qed_sp_ll2_tx_queue_start(struct qed_hwfn
*p_hwfn
,
915 struct qed_ll2_info
*p_ll2_conn
)
917 enum qed_ll2_conn_type conn_type
= p_ll2_conn
->input
.conn_type
;
918 struct qed_ll2_tx_queue
*p_tx
= &p_ll2_conn
->tx_queue
;
919 struct core_tx_start_ramrod_data
*p_ramrod
= NULL
;
920 struct qed_spq_entry
*p_ent
= NULL
;
921 struct qed_sp_init_data init_data
;
922 u16 pq_id
= 0, pbl_size
;
925 if (!QED_LL2_TX_REGISTERED(p_ll2_conn
))
928 if (p_ll2_conn
->input
.conn_type
== QED_LL2_TYPE_OOO
)
929 p_ll2_conn
->tx_stats_en
= 0;
931 p_ll2_conn
->tx_stats_en
= 1;
934 memset(&init_data
, 0, sizeof(init_data
));
935 init_data
.cid
= p_ll2_conn
->cid
;
936 init_data
.opaque_fid
= p_hwfn
->hw_info
.opaque_fid
;
937 init_data
.comp_mode
= QED_SPQ_MODE_EBLOCK
;
939 rc
= qed_sp_init_request(p_hwfn
, &p_ent
,
940 CORE_RAMROD_TX_QUEUE_START
,
941 PROTOCOLID_CORE
, &init_data
);
945 p_ramrod
= &p_ent
->ramrod
.core_tx_queue_start
;
947 p_ramrod
->sb_id
= cpu_to_le16(qed_int_get_sp_sb_id(p_hwfn
));
948 p_ramrod
->sb_index
= p_tx
->tx_sb_index
;
949 p_ramrod
->mtu
= cpu_to_le16(p_ll2_conn
->input
.mtu
);
950 p_ramrod
->stats_en
= p_ll2_conn
->tx_stats_en
;
951 p_ramrod
->stats_id
= p_ll2_conn
->tx_stats_id
;
953 DMA_REGPAIR_LE(p_ramrod
->pbl_base_addr
,
954 qed_chain_get_pbl_phys(&p_tx
->txq_chain
));
955 pbl_size
= qed_chain_get_page_cnt(&p_tx
->txq_chain
);
956 p_ramrod
->pbl_size
= cpu_to_le16(pbl_size
);
958 switch (p_ll2_conn
->input
.tx_tc
) {
960 pq_id
= qed_get_cm_pq_idx(p_hwfn
, PQ_FLAGS_LB
);
963 pq_id
= qed_get_cm_pq_idx(p_hwfn
, PQ_FLAGS_OOO
);
966 pq_id
= qed_get_cm_pq_idx(p_hwfn
, PQ_FLAGS_OFLD
);
970 p_ramrod
->qm_pq_id
= cpu_to_le16(pq_id
);
973 case QED_LL2_TYPE_FCOE
:
974 p_ramrod
->conn_type
= PROTOCOLID_FCOE
;
976 case QED_LL2_TYPE_ISCSI
:
977 p_ramrod
->conn_type
= PROTOCOLID_ISCSI
;
979 case QED_LL2_TYPE_ROCE
:
980 p_ramrod
->conn_type
= PROTOCOLID_ROCE
;
982 case QED_LL2_TYPE_IWARP
:
983 p_ramrod
->conn_type
= PROTOCOLID_IWARP
;
985 case QED_LL2_TYPE_OOO
:
986 if (p_hwfn
->hw_info
.personality
== QED_PCI_ISCSI
)
987 p_ramrod
->conn_type
= PROTOCOLID_ISCSI
;
989 p_ramrod
->conn_type
= PROTOCOLID_IWARP
;
992 p_ramrod
->conn_type
= PROTOCOLID_ETH
;
993 DP_NOTICE(p_hwfn
, "Unknown connection type: %d\n", conn_type
);
996 p_ramrod
->gsi_offload_flag
= p_ll2_conn
->input
.gsi_enable
;
998 return qed_spq_post(p_hwfn
, p_ent
, NULL
);
1001 static int qed_sp_ll2_rx_queue_stop(struct qed_hwfn
*p_hwfn
,
1002 struct qed_ll2_info
*p_ll2_conn
)
1004 struct core_rx_stop_ramrod_data
*p_ramrod
= NULL
;
1005 struct qed_spq_entry
*p_ent
= NULL
;
1006 struct qed_sp_init_data init_data
;
1010 memset(&init_data
, 0, sizeof(init_data
));
1011 init_data
.cid
= p_ll2_conn
->cid
;
1012 init_data
.opaque_fid
= p_hwfn
->hw_info
.opaque_fid
;
1013 init_data
.comp_mode
= QED_SPQ_MODE_EBLOCK
;
1015 rc
= qed_sp_init_request(p_hwfn
, &p_ent
,
1016 CORE_RAMROD_RX_QUEUE_STOP
,
1017 PROTOCOLID_CORE
, &init_data
);
1021 p_ramrod
= &p_ent
->ramrod
.core_rx_queue_stop
;
1023 p_ramrod
->complete_event_flg
= 1;
1024 p_ramrod
->queue_id
= p_ll2_conn
->queue_id
;
1026 return qed_spq_post(p_hwfn
, p_ent
, NULL
);
1029 static int qed_sp_ll2_tx_queue_stop(struct qed_hwfn
*p_hwfn
,
1030 struct qed_ll2_info
*p_ll2_conn
)
1032 struct qed_spq_entry
*p_ent
= NULL
;
1033 struct qed_sp_init_data init_data
;
1037 memset(&init_data
, 0, sizeof(init_data
));
1038 init_data
.cid
= p_ll2_conn
->cid
;
1039 init_data
.opaque_fid
= p_hwfn
->hw_info
.opaque_fid
;
1040 init_data
.comp_mode
= QED_SPQ_MODE_EBLOCK
;
1042 rc
= qed_sp_init_request(p_hwfn
, &p_ent
,
1043 CORE_RAMROD_TX_QUEUE_STOP
,
1044 PROTOCOLID_CORE
, &init_data
);
1048 return qed_spq_post(p_hwfn
, p_ent
, NULL
);
1052 qed_ll2_acquire_connection_rx(struct qed_hwfn
*p_hwfn
,
1053 struct qed_ll2_info
*p_ll2_info
)
1055 struct qed_ll2_rx_packet
*p_descq
;
1059 if (!p_ll2_info
->input
.rx_num_desc
)
1062 rc
= qed_chain_alloc(p_hwfn
->cdev
,
1063 QED_CHAIN_USE_TO_CONSUME_PRODUCE
,
1064 QED_CHAIN_MODE_NEXT_PTR
,
1065 QED_CHAIN_CNT_TYPE_U16
,
1066 p_ll2_info
->input
.rx_num_desc
,
1067 sizeof(struct core_rx_bd
),
1068 &p_ll2_info
->rx_queue
.rxq_chain
, NULL
);
1070 DP_NOTICE(p_hwfn
, "Failed to allocate ll2 rxq chain\n");
1074 capacity
= qed_chain_get_capacity(&p_ll2_info
->rx_queue
.rxq_chain
);
1075 p_descq
= kcalloc(capacity
, sizeof(struct qed_ll2_rx_packet
),
1079 DP_NOTICE(p_hwfn
, "Failed to allocate ll2 Rx desc\n");
1082 p_ll2_info
->rx_queue
.descq_array
= p_descq
;
1084 rc
= qed_chain_alloc(p_hwfn
->cdev
,
1085 QED_CHAIN_USE_TO_CONSUME_PRODUCE
,
1087 QED_CHAIN_CNT_TYPE_U16
,
1088 p_ll2_info
->input
.rx_num_desc
,
1089 sizeof(struct core_rx_fast_path_cqe
),
1090 &p_ll2_info
->rx_queue
.rcq_chain
, NULL
);
1092 DP_NOTICE(p_hwfn
, "Failed to allocate ll2 rcq chain\n");
1096 DP_VERBOSE(p_hwfn
, QED_MSG_LL2
,
1097 "Allocated LL2 Rxq [Type %08x] with 0x%08x buffers\n",
1098 p_ll2_info
->input
.conn_type
, p_ll2_info
->input
.rx_num_desc
);
1104 static int qed_ll2_acquire_connection_tx(struct qed_hwfn
*p_hwfn
,
1105 struct qed_ll2_info
*p_ll2_info
)
1107 struct qed_ll2_tx_packet
*p_descq
;
1112 if (!p_ll2_info
->input
.tx_num_desc
)
1115 rc
= qed_chain_alloc(p_hwfn
->cdev
,
1116 QED_CHAIN_USE_TO_CONSUME_PRODUCE
,
1118 QED_CHAIN_CNT_TYPE_U16
,
1119 p_ll2_info
->input
.tx_num_desc
,
1120 sizeof(struct core_tx_bd
),
1121 &p_ll2_info
->tx_queue
.txq_chain
, NULL
);
1125 capacity
= qed_chain_get_capacity(&p_ll2_info
->tx_queue
.txq_chain
);
1126 /* First element is part of the packet, rest are flexibly added */
1127 desc_size
= (sizeof(*p_descq
) +
1128 (p_ll2_info
->input
.tx_max_bds_per_packet
- 1) *
1129 sizeof(p_descq
->bds_set
));
1131 p_descq
= kcalloc(capacity
, desc_size
, GFP_KERNEL
);
1136 p_ll2_info
->tx_queue
.descq_mem
= p_descq
;
1138 DP_VERBOSE(p_hwfn
, QED_MSG_LL2
,
1139 "Allocated LL2 Txq [Type %08x] with 0x%08x buffers\n",
1140 p_ll2_info
->input
.conn_type
, p_ll2_info
->input
.tx_num_desc
);
1145 "Can't allocate memory for Tx LL2 with 0x%08x buffers\n",
1146 p_ll2_info
->input
.tx_num_desc
);
1151 qed_ll2_acquire_connection_ooo(struct qed_hwfn
*p_hwfn
,
1152 struct qed_ll2_info
*p_ll2_info
, u16 mtu
)
1154 struct qed_ooo_buffer
*p_buf
= NULL
;
1159 if (p_ll2_info
->input
.conn_type
!= QED_LL2_TYPE_OOO
)
1162 /* Correct number of requested OOO buffers if needed */
1163 if (!p_ll2_info
->input
.rx_num_ooo_buffers
) {
1164 u16 num_desc
= p_ll2_info
->input
.rx_num_desc
;
1168 p_ll2_info
->input
.rx_num_ooo_buffers
= num_desc
* 2;
1171 for (buf_idx
= 0; buf_idx
< p_ll2_info
->input
.rx_num_ooo_buffers
;
1173 p_buf
= kzalloc(sizeof(*p_buf
), GFP_KERNEL
);
1179 p_buf
->rx_buffer_size
= mtu
+ 26 + ETH_CACHE_LINE_SIZE
;
1180 p_buf
->rx_buffer_size
= (p_buf
->rx_buffer_size
+
1181 ETH_CACHE_LINE_SIZE
- 1) &
1182 ~(ETH_CACHE_LINE_SIZE
- 1);
1183 p_virt
= dma_alloc_coherent(&p_hwfn
->cdev
->pdev
->dev
,
1184 p_buf
->rx_buffer_size
,
1185 &p_buf
->rx_buffer_phys_addr
,
1193 p_buf
->rx_buffer_virt_addr
= p_virt
;
1194 qed_ooo_put_free_buffer(p_hwfn
, p_hwfn
->p_ooo_info
, p_buf
);
1197 DP_VERBOSE(p_hwfn
, QED_MSG_LL2
,
1198 "Allocated [%04x] LL2 OOO buffers [each of size 0x%08x]\n",
1199 p_ll2_info
->input
.rx_num_ooo_buffers
, p_buf
->rx_buffer_size
);
1206 qed_ll2_set_cbs(struct qed_ll2_info
*p_ll2_info
, const struct qed_ll2_cbs
*cbs
)
1208 if (!cbs
|| (!cbs
->rx_comp_cb
||
1209 !cbs
->rx_release_cb
||
1210 !cbs
->tx_comp_cb
|| !cbs
->tx_release_cb
|| !cbs
->cookie
))
1213 p_ll2_info
->cbs
.rx_comp_cb
= cbs
->rx_comp_cb
;
1214 p_ll2_info
->cbs
.rx_release_cb
= cbs
->rx_release_cb
;
1215 p_ll2_info
->cbs
.tx_comp_cb
= cbs
->tx_comp_cb
;
1216 p_ll2_info
->cbs
.tx_release_cb
= cbs
->tx_release_cb
;
1217 p_ll2_info
->cbs
.cookie
= cbs
->cookie
;
1222 static enum core_error_handle
1223 qed_ll2_get_error_choice(enum qed_ll2_error_handle err
)
1226 case QED_LL2_DROP_PACKET
:
1227 return LL2_DROP_PACKET
;
1228 case QED_LL2_DO_NOTHING
:
1229 return LL2_DO_NOTHING
;
1230 case QED_LL2_ASSERT
:
1233 return LL2_DO_NOTHING
;
1237 int qed_ll2_acquire_connection(void *cxt
, struct qed_ll2_acquire_data
*data
)
1239 struct qed_hwfn
*p_hwfn
= cxt
;
1240 qed_int_comp_cb_t comp_rx_cb
, comp_tx_cb
;
1241 struct qed_ll2_info
*p_ll2_info
= NULL
;
1245 if (!data
->p_connection_handle
|| !p_hwfn
->p_ll2_info
)
1248 /* Find a free connection to be used */
1249 for (i
= 0; (i
< QED_MAX_NUM_OF_LL2_CONNECTIONS
); i
++) {
1250 mutex_lock(&p_hwfn
->p_ll2_info
[i
].mutex
);
1251 if (p_hwfn
->p_ll2_info
[i
].b_active
) {
1252 mutex_unlock(&p_hwfn
->p_ll2_info
[i
].mutex
);
1256 p_hwfn
->p_ll2_info
[i
].b_active
= true;
1257 p_ll2_info
= &p_hwfn
->p_ll2_info
[i
];
1258 mutex_unlock(&p_hwfn
->p_ll2_info
[i
].mutex
);
1264 memcpy(&p_ll2_info
->input
, &data
->input
, sizeof(p_ll2_info
->input
));
1266 p_ll2_info
->tx_dest
= (data
->input
.tx_dest
== QED_LL2_TX_DEST_NW
) ?
1267 CORE_TX_DEST_NW
: CORE_TX_DEST_LB
;
1268 if (data
->input
.conn_type
== QED_LL2_TYPE_OOO
||
1269 data
->input
.secondary_queue
)
1270 p_ll2_info
->main_func_queue
= false;
1272 p_ll2_info
->main_func_queue
= true;
1274 /* Correct maximum number of Tx BDs */
1275 p_tx_max
= &p_ll2_info
->input
.tx_max_bds_per_packet
;
1277 *p_tx_max
= CORE_LL2_TX_MAX_BDS_PER_PACKET
;
1279 *p_tx_max
= min_t(u8
, *p_tx_max
,
1280 CORE_LL2_TX_MAX_BDS_PER_PACKET
);
1282 rc
= qed_ll2_set_cbs(p_ll2_info
, data
->cbs
);
1284 DP_NOTICE(p_hwfn
, "Invalid callback functions\n");
1285 goto q_allocate_fail
;
1288 rc
= qed_ll2_acquire_connection_rx(p_hwfn
, p_ll2_info
);
1290 goto q_allocate_fail
;
1292 rc
= qed_ll2_acquire_connection_tx(p_hwfn
, p_ll2_info
);
1294 goto q_allocate_fail
;
1296 rc
= qed_ll2_acquire_connection_ooo(p_hwfn
, p_ll2_info
,
1299 goto q_allocate_fail
;
1301 /* Register callbacks for the Rx/Tx queues */
1302 if (data
->input
.conn_type
== QED_LL2_TYPE_OOO
) {
1303 comp_rx_cb
= qed_ll2_lb_rxq_completion
;
1304 comp_tx_cb
= qed_ll2_lb_txq_completion
;
1306 comp_rx_cb
= qed_ll2_rxq_completion
;
1307 comp_tx_cb
= qed_ll2_txq_completion
;
1310 if (data
->input
.rx_num_desc
) {
1311 qed_int_register_cb(p_hwfn
, comp_rx_cb
,
1312 &p_hwfn
->p_ll2_info
[i
],
1313 &p_ll2_info
->rx_queue
.rx_sb_index
,
1314 &p_ll2_info
->rx_queue
.p_fw_cons
);
1315 p_ll2_info
->rx_queue
.b_cb_registred
= true;
1318 if (data
->input
.tx_num_desc
) {
1319 qed_int_register_cb(p_hwfn
,
1321 &p_hwfn
->p_ll2_info
[i
],
1322 &p_ll2_info
->tx_queue
.tx_sb_index
,
1323 &p_ll2_info
->tx_queue
.p_fw_cons
);
1324 p_ll2_info
->tx_queue
.b_cb_registred
= true;
1327 *data
->p_connection_handle
= i
;
1331 qed_ll2_release_connection(p_hwfn
, i
);
1335 static int qed_ll2_establish_connection_rx(struct qed_hwfn
*p_hwfn
,
1336 struct qed_ll2_info
*p_ll2_conn
)
1338 enum qed_ll2_error_handle error_input
;
1339 enum core_error_handle error_mode
;
1340 u8 action_on_error
= 0;
1342 if (!QED_LL2_RX_REGISTERED(p_ll2_conn
))
1345 DIRECT_REG_WR(p_ll2_conn
->rx_queue
.set_prod_addr
, 0x0);
1346 error_input
= p_ll2_conn
->input
.ai_err_packet_too_big
;
1347 error_mode
= qed_ll2_get_error_choice(error_input
);
1348 SET_FIELD(action_on_error
,
1349 CORE_RX_ACTION_ON_ERROR_PACKET_TOO_BIG
, error_mode
);
1350 error_input
= p_ll2_conn
->input
.ai_err_no_buf
;
1351 error_mode
= qed_ll2_get_error_choice(error_input
);
1352 SET_FIELD(action_on_error
, CORE_RX_ACTION_ON_ERROR_NO_BUFF
, error_mode
);
1354 return qed_sp_ll2_rx_queue_start(p_hwfn
, p_ll2_conn
, action_on_error
);
1358 qed_ll2_establish_connection_ooo(struct qed_hwfn
*p_hwfn
,
1359 struct qed_ll2_info
*p_ll2_conn
)
1361 if (p_ll2_conn
->input
.conn_type
!= QED_LL2_TYPE_OOO
)
1364 qed_ooo_release_all_isles(p_hwfn
, p_hwfn
->p_ooo_info
);
1365 qed_ooo_submit_rx_buffers(p_hwfn
, p_ll2_conn
);
1368 int qed_ll2_establish_connection(void *cxt
, u8 connection_handle
)
1370 struct qed_hwfn
*p_hwfn
= cxt
;
1371 struct qed_ll2_info
*p_ll2_conn
;
1372 struct qed_ll2_tx_packet
*p_pkt
;
1373 struct qed_ll2_rx_queue
*p_rx
;
1374 struct qed_ll2_tx_queue
*p_tx
;
1375 struct qed_ptt
*p_ptt
;
1381 p_ptt
= qed_ptt_acquire(p_hwfn
);
1385 p_ll2_conn
= qed_ll2_handle_sanity_lock(p_hwfn
, connection_handle
);
1391 p_rx
= &p_ll2_conn
->rx_queue
;
1392 p_tx
= &p_ll2_conn
->tx_queue
;
1394 qed_chain_reset(&p_rx
->rxq_chain
);
1395 qed_chain_reset(&p_rx
->rcq_chain
);
1396 INIT_LIST_HEAD(&p_rx
->active_descq
);
1397 INIT_LIST_HEAD(&p_rx
->free_descq
);
1398 INIT_LIST_HEAD(&p_rx
->posting_descq
);
1399 spin_lock_init(&p_rx
->lock
);
1400 capacity
= qed_chain_get_capacity(&p_rx
->rxq_chain
);
1401 for (i
= 0; i
< capacity
; i
++)
1402 list_add_tail(&p_rx
->descq_array
[i
].list_entry
,
1404 *p_rx
->p_fw_cons
= 0;
1406 qed_chain_reset(&p_tx
->txq_chain
);
1407 INIT_LIST_HEAD(&p_tx
->active_descq
);
1408 INIT_LIST_HEAD(&p_tx
->free_descq
);
1409 INIT_LIST_HEAD(&p_tx
->sending_descq
);
1410 spin_lock_init(&p_tx
->lock
);
1411 capacity
= qed_chain_get_capacity(&p_tx
->txq_chain
);
1412 /* First element is part of the packet, rest are flexibly added */
1413 desc_size
= (sizeof(*p_pkt
) +
1414 (p_ll2_conn
->input
.tx_max_bds_per_packet
- 1) *
1415 sizeof(p_pkt
->bds_set
));
1417 for (i
= 0; i
< capacity
; i
++) {
1418 p_pkt
= p_tx
->descq_mem
+ desc_size
* i
;
1419 list_add_tail(&p_pkt
->list_entry
, &p_tx
->free_descq
);
1421 p_tx
->cur_completing_bd_idx
= 0;
1423 p_tx
->b_completing_packet
= false;
1424 p_tx
->cur_send_packet
= NULL
;
1425 p_tx
->cur_send_frag_num
= 0;
1426 p_tx
->cur_completing_frag_num
= 0;
1427 *p_tx
->p_fw_cons
= 0;
1429 rc
= qed_cxt_acquire_cid(p_hwfn
, PROTOCOLID_CORE
, &p_ll2_conn
->cid
);
1433 qid
= p_hwfn
->hw_info
.resc_start
[QED_LL2_QUEUE
] + connection_handle
;
1434 p_ll2_conn
->queue_id
= qid
;
1435 p_ll2_conn
->tx_stats_id
= qid
;
1436 p_rx
->set_prod_addr
= (u8 __iomem
*)p_hwfn
->regview
+
1437 GTT_BAR0_MAP_REG_TSDM_RAM
+
1438 TSTORM_LL2_RX_PRODS_OFFSET(qid
);
1439 p_tx
->doorbell_addr
= (u8 __iomem
*)p_hwfn
->doorbells
+
1440 qed_db_addr(p_ll2_conn
->cid
,
1443 rc
= qed_ll2_establish_connection_rx(p_hwfn
, p_ll2_conn
);
1447 rc
= qed_sp_ll2_tx_queue_start(p_hwfn
, p_ll2_conn
);
1451 if (!QED_IS_RDMA_PERSONALITY(p_hwfn
))
1452 qed_wr(p_hwfn
, p_ptt
, PRS_REG_USE_LIGHT_L2
, 1);
1454 qed_ll2_establish_connection_ooo(p_hwfn
, p_ll2_conn
);
1456 if (p_ll2_conn
->input
.conn_type
== QED_LL2_TYPE_FCOE
) {
1457 qed_llh_add_protocol_filter(p_hwfn
, p_ptt
,
1459 QED_LLH_FILTER_ETHERTYPE
);
1460 qed_llh_add_protocol_filter(p_hwfn
, p_ptt
,
1462 QED_LLH_FILTER_ETHERTYPE
);
1466 qed_ptt_release(p_hwfn
, p_ptt
);
1470 static void qed_ll2_post_rx_buffer_notify_fw(struct qed_hwfn
*p_hwfn
,
1471 struct qed_ll2_rx_queue
*p_rx
,
1472 struct qed_ll2_rx_packet
*p_curp
)
1474 struct qed_ll2_rx_packet
*p_posting_packet
= NULL
;
1475 struct core_ll2_rx_prod rx_prod
= { 0, 0, 0 };
1476 bool b_notify_fw
= false;
1477 u16 bd_prod
, cq_prod
;
1479 /* This handles the flushing of already posted buffers */
1480 while (!list_empty(&p_rx
->posting_descq
)) {
1481 p_posting_packet
= list_first_entry(&p_rx
->posting_descq
,
1482 struct qed_ll2_rx_packet
,
1484 list_move_tail(&p_posting_packet
->list_entry
,
1485 &p_rx
->active_descq
);
1489 /* This handles the supplied packet [if there is one] */
1491 list_add_tail(&p_curp
->list_entry
, &p_rx
->active_descq
);
1498 bd_prod
= qed_chain_get_prod_idx(&p_rx
->rxq_chain
);
1499 cq_prod
= qed_chain_get_prod_idx(&p_rx
->rcq_chain
);
1500 rx_prod
.bd_prod
= cpu_to_le16(bd_prod
);
1501 rx_prod
.cqe_prod
= cpu_to_le16(cq_prod
);
1502 DIRECT_REG_WR(p_rx
->set_prod_addr
, *((u32
*)&rx_prod
));
1505 int qed_ll2_post_rx_buffer(void *cxt
,
1506 u8 connection_handle
,
1508 u16 buf_len
, void *cookie
, u8 notify_fw
)
1510 struct qed_hwfn
*p_hwfn
= cxt
;
1511 struct core_rx_bd_with_buff_len
*p_curb
= NULL
;
1512 struct qed_ll2_rx_packet
*p_curp
= NULL
;
1513 struct qed_ll2_info
*p_ll2_conn
;
1514 struct qed_ll2_rx_queue
*p_rx
;
1515 unsigned long flags
;
1519 p_ll2_conn
= qed_ll2_handle_sanity(p_hwfn
, connection_handle
);
1522 p_rx
= &p_ll2_conn
->rx_queue
;
1524 spin_lock_irqsave(&p_rx
->lock
, flags
);
1525 if (!list_empty(&p_rx
->free_descq
))
1526 p_curp
= list_first_entry(&p_rx
->free_descq
,
1527 struct qed_ll2_rx_packet
, list_entry
);
1529 if (qed_chain_get_elem_left(&p_rx
->rxq_chain
) &&
1530 qed_chain_get_elem_left(&p_rx
->rcq_chain
)) {
1531 p_data
= qed_chain_produce(&p_rx
->rxq_chain
);
1532 p_curb
= (struct core_rx_bd_with_buff_len
*)p_data
;
1533 qed_chain_produce(&p_rx
->rcq_chain
);
1537 /* If we're lacking entires, let's try to flush buffers to FW */
1538 if (!p_curp
|| !p_curb
) {
1544 /* We have an Rx packet we can fill */
1545 DMA_REGPAIR_LE(p_curb
->addr
, addr
);
1546 p_curb
->buff_length
= cpu_to_le16(buf_len
);
1547 p_curp
->rx_buf_addr
= addr
;
1548 p_curp
->cookie
= cookie
;
1549 p_curp
->rxq_bd
= p_curb
;
1550 p_curp
->buf_length
= buf_len
;
1551 list_del(&p_curp
->list_entry
);
1553 /* Check if we only want to enqueue this packet without informing FW */
1555 list_add_tail(&p_curp
->list_entry
, &p_rx
->posting_descq
);
1560 qed_ll2_post_rx_buffer_notify_fw(p_hwfn
, p_rx
, p_curp
);
1562 spin_unlock_irqrestore(&p_rx
->lock
, flags
);
1566 static void qed_ll2_prepare_tx_packet_set(struct qed_hwfn
*p_hwfn
,
1567 struct qed_ll2_tx_queue
*p_tx
,
1568 struct qed_ll2_tx_packet
*p_curp
,
1569 struct qed_ll2_tx_pkt_info
*pkt
,
1572 list_del(&p_curp
->list_entry
);
1573 p_curp
->cookie
= pkt
->cookie
;
1574 p_curp
->bd_used
= pkt
->num_of_bds
;
1575 p_curp
->notify_fw
= notify_fw
;
1576 p_tx
->cur_send_packet
= p_curp
;
1577 p_tx
->cur_send_frag_num
= 0;
1579 p_curp
->bds_set
[p_tx
->cur_send_frag_num
].tx_frag
= pkt
->first_frag
;
1580 p_curp
->bds_set
[p_tx
->cur_send_frag_num
].frag_len
= pkt
->first_frag_len
;
1581 p_tx
->cur_send_frag_num
++;
1585 qed_ll2_prepare_tx_packet_set_bd(struct qed_hwfn
*p_hwfn
,
1586 struct qed_ll2_info
*p_ll2
,
1587 struct qed_ll2_tx_packet
*p_curp
,
1588 struct qed_ll2_tx_pkt_info
*pkt
)
1590 struct qed_chain
*p_tx_chain
= &p_ll2
->tx_queue
.txq_chain
;
1591 u16 prod_idx
= qed_chain_get_prod_idx(p_tx_chain
);
1592 struct core_tx_bd
*start_bd
= NULL
;
1593 enum core_roce_flavor_type roce_flavor
;
1594 enum core_tx_dest tx_dest
;
1595 u16 bd_data
= 0, frag_idx
;
1597 roce_flavor
= (pkt
->qed_roce_flavor
== QED_LL2_ROCE
) ? CORE_ROCE
1600 switch (pkt
->tx_dest
) {
1601 case QED_LL2_TX_DEST_NW
:
1602 tx_dest
= CORE_TX_DEST_NW
;
1604 case QED_LL2_TX_DEST_LB
:
1605 tx_dest
= CORE_TX_DEST_LB
;
1607 case QED_LL2_TX_DEST_DROP
:
1608 tx_dest
= CORE_TX_DEST_DROP
;
1611 tx_dest
= CORE_TX_DEST_LB
;
1615 start_bd
= (struct core_tx_bd
*)qed_chain_produce(p_tx_chain
);
1616 start_bd
->nw_vlan_or_lb_echo
= cpu_to_le16(pkt
->vlan
);
1617 SET_FIELD(start_bd
->bitfield1
, CORE_TX_BD_L4_HDR_OFFSET_W
,
1618 cpu_to_le16(pkt
->l4_hdr_offset_w
));
1619 SET_FIELD(start_bd
->bitfield1
, CORE_TX_BD_TX_DST
, tx_dest
);
1620 bd_data
|= pkt
->bd_flags
;
1621 SET_FIELD(bd_data
, CORE_TX_BD_DATA_START_BD
, 0x1);
1622 SET_FIELD(bd_data
, CORE_TX_BD_DATA_NBDS
, pkt
->num_of_bds
);
1623 SET_FIELD(bd_data
, CORE_TX_BD_DATA_ROCE_FLAV
, roce_flavor
);
1624 SET_FIELD(bd_data
, CORE_TX_BD_DATA_IP_CSUM
, !!(pkt
->enable_ip_cksum
));
1625 SET_FIELD(bd_data
, CORE_TX_BD_DATA_L4_CSUM
, !!(pkt
->enable_l4_cksum
));
1626 SET_FIELD(bd_data
, CORE_TX_BD_DATA_IP_LEN
, !!(pkt
->calc_ip_len
));
1627 start_bd
->bd_data
.as_bitfield
= cpu_to_le16(bd_data
);
1628 DMA_REGPAIR_LE(start_bd
->addr
, pkt
->first_frag
);
1629 start_bd
->nbytes
= cpu_to_le16(pkt
->first_frag_len
);
1632 (NETIF_MSG_TX_QUEUED
| QED_MSG_LL2
),
1633 "LL2 [q 0x%02x cid 0x%08x type 0x%08x] Tx Producer at [0x%04x] - set with a %04x bytes %02x BDs buffer at %08x:%08x\n",
1636 p_ll2
->input
.conn_type
,
1638 pkt
->first_frag_len
,
1640 le32_to_cpu(start_bd
->addr
.hi
),
1641 le32_to_cpu(start_bd
->addr
.lo
));
1643 if (p_ll2
->tx_queue
.cur_send_frag_num
== pkt
->num_of_bds
)
1646 /* Need to provide the packet with additional BDs for frags */
1647 for (frag_idx
= p_ll2
->tx_queue
.cur_send_frag_num
;
1648 frag_idx
< pkt
->num_of_bds
; frag_idx
++) {
1649 struct core_tx_bd
**p_bd
= &p_curp
->bds_set
[frag_idx
].txq_bd
;
1651 *p_bd
= (struct core_tx_bd
*)qed_chain_produce(p_tx_chain
);
1652 (*p_bd
)->bd_data
.as_bitfield
= 0;
1653 (*p_bd
)->bitfield1
= 0;
1654 p_curp
->bds_set
[frag_idx
].tx_frag
= 0;
1655 p_curp
->bds_set
[frag_idx
].frag_len
= 0;
1659 /* This should be called while the Txq spinlock is being held */
1660 static void qed_ll2_tx_packet_notify(struct qed_hwfn
*p_hwfn
,
1661 struct qed_ll2_info
*p_ll2_conn
)
1663 bool b_notify
= p_ll2_conn
->tx_queue
.cur_send_packet
->notify_fw
;
1664 struct qed_ll2_tx_queue
*p_tx
= &p_ll2_conn
->tx_queue
;
1665 struct qed_ll2_tx_packet
*p_pkt
= NULL
;
1666 struct core_db_data db_msg
= { 0, 0, 0 };
1669 /* If there are missing BDs, don't do anything now */
1670 if (p_ll2_conn
->tx_queue
.cur_send_frag_num
!=
1671 p_ll2_conn
->tx_queue
.cur_send_packet
->bd_used
)
1674 /* Push the current packet to the list and clean after it */
1675 list_add_tail(&p_ll2_conn
->tx_queue
.cur_send_packet
->list_entry
,
1676 &p_ll2_conn
->tx_queue
.sending_descq
);
1677 p_ll2_conn
->tx_queue
.cur_send_packet
= NULL
;
1678 p_ll2_conn
->tx_queue
.cur_send_frag_num
= 0;
1680 /* Notify FW of packet only if requested to */
1684 bd_prod
= qed_chain_get_prod_idx(&p_ll2_conn
->tx_queue
.txq_chain
);
1686 while (!list_empty(&p_tx
->sending_descq
)) {
1687 p_pkt
= list_first_entry(&p_tx
->sending_descq
,
1688 struct qed_ll2_tx_packet
, list_entry
);
1692 list_move_tail(&p_pkt
->list_entry
, &p_tx
->active_descq
);
1695 SET_FIELD(db_msg
.params
, CORE_DB_DATA_DEST
, DB_DEST_XCM
);
1696 SET_FIELD(db_msg
.params
, CORE_DB_DATA_AGG_CMD
, DB_AGG_CMD_SET
);
1697 SET_FIELD(db_msg
.params
, CORE_DB_DATA_AGG_VAL_SEL
,
1698 DQ_XCM_CORE_TX_BD_PROD_CMD
);
1699 db_msg
.agg_flags
= DQ_XCM_CORE_DQ_CF_CMD
;
1700 db_msg
.spq_prod
= cpu_to_le16(bd_prod
);
1702 /* Make sure the BDs data is updated before ringing the doorbell */
1705 DIRECT_REG_WR(p_tx
->doorbell_addr
, *((u32
*)&db_msg
));
1708 (NETIF_MSG_TX_QUEUED
| QED_MSG_LL2
),
1709 "LL2 [q 0x%02x cid 0x%08x type 0x%08x] Doorbelled [producer 0x%04x]\n",
1710 p_ll2_conn
->queue_id
,
1712 p_ll2_conn
->input
.conn_type
, db_msg
.spq_prod
);
1715 int qed_ll2_prepare_tx_packet(void *cxt
,
1716 u8 connection_handle
,
1717 struct qed_ll2_tx_pkt_info
*pkt
,
1720 struct qed_hwfn
*p_hwfn
= cxt
;
1721 struct qed_ll2_tx_packet
*p_curp
= NULL
;
1722 struct qed_ll2_info
*p_ll2_conn
= NULL
;
1723 struct qed_ll2_tx_queue
*p_tx
;
1724 struct qed_chain
*p_tx_chain
;
1725 unsigned long flags
;
1728 p_ll2_conn
= qed_ll2_handle_sanity(p_hwfn
, connection_handle
);
1731 p_tx
= &p_ll2_conn
->tx_queue
;
1732 p_tx_chain
= &p_tx
->txq_chain
;
1734 if (pkt
->num_of_bds
> p_ll2_conn
->input
.tx_max_bds_per_packet
)
1737 spin_lock_irqsave(&p_tx
->lock
, flags
);
1738 if (p_tx
->cur_send_packet
) {
1743 /* Get entry, but only if we have tx elements for it */
1744 if (!list_empty(&p_tx
->free_descq
))
1745 p_curp
= list_first_entry(&p_tx
->free_descq
,
1746 struct qed_ll2_tx_packet
, list_entry
);
1747 if (p_curp
&& qed_chain_get_elem_left(p_tx_chain
) < pkt
->num_of_bds
)
1755 /* Prepare packet and BD, and perhaps send a doorbell to FW */
1756 qed_ll2_prepare_tx_packet_set(p_hwfn
, p_tx
, p_curp
, pkt
, notify_fw
);
1758 qed_ll2_prepare_tx_packet_set_bd(p_hwfn
, p_ll2_conn
, p_curp
, pkt
);
1760 qed_ll2_tx_packet_notify(p_hwfn
, p_ll2_conn
);
1763 spin_unlock_irqrestore(&p_tx
->lock
, flags
);
1767 int qed_ll2_set_fragment_of_tx_packet(void *cxt
,
1768 u8 connection_handle
,
1769 dma_addr_t addr
, u16 nbytes
)
1771 struct qed_ll2_tx_packet
*p_cur_send_packet
= NULL
;
1772 struct qed_hwfn
*p_hwfn
= cxt
;
1773 struct qed_ll2_info
*p_ll2_conn
= NULL
;
1774 u16 cur_send_frag_num
= 0;
1775 struct core_tx_bd
*p_bd
;
1776 unsigned long flags
;
1778 p_ll2_conn
= qed_ll2_handle_sanity(p_hwfn
, connection_handle
);
1782 if (!p_ll2_conn
->tx_queue
.cur_send_packet
)
1785 p_cur_send_packet
= p_ll2_conn
->tx_queue
.cur_send_packet
;
1786 cur_send_frag_num
= p_ll2_conn
->tx_queue
.cur_send_frag_num
;
1788 if (cur_send_frag_num
>= p_cur_send_packet
->bd_used
)
1791 /* Fill the BD information, and possibly notify FW */
1792 p_bd
= p_cur_send_packet
->bds_set
[cur_send_frag_num
].txq_bd
;
1793 DMA_REGPAIR_LE(p_bd
->addr
, addr
);
1794 p_bd
->nbytes
= cpu_to_le16(nbytes
);
1795 p_cur_send_packet
->bds_set
[cur_send_frag_num
].tx_frag
= addr
;
1796 p_cur_send_packet
->bds_set
[cur_send_frag_num
].frag_len
= nbytes
;
1798 p_ll2_conn
->tx_queue
.cur_send_frag_num
++;
1800 spin_lock_irqsave(&p_ll2_conn
->tx_queue
.lock
, flags
);
1801 qed_ll2_tx_packet_notify(p_hwfn
, p_ll2_conn
);
1802 spin_unlock_irqrestore(&p_ll2_conn
->tx_queue
.lock
, flags
);
1807 int qed_ll2_terminate_connection(void *cxt
, u8 connection_handle
)
1809 struct qed_hwfn
*p_hwfn
= cxt
;
1810 struct qed_ll2_info
*p_ll2_conn
= NULL
;
1812 struct qed_ptt
*p_ptt
;
1814 p_ptt
= qed_ptt_acquire(p_hwfn
);
1818 p_ll2_conn
= qed_ll2_handle_sanity_lock(p_hwfn
, connection_handle
);
1824 /* Stop Tx & Rx of connection, if needed */
1825 if (QED_LL2_TX_REGISTERED(p_ll2_conn
)) {
1826 rc
= qed_sp_ll2_tx_queue_stop(p_hwfn
, p_ll2_conn
);
1829 qed_ll2_txq_flush(p_hwfn
, connection_handle
);
1832 if (QED_LL2_RX_REGISTERED(p_ll2_conn
)) {
1833 rc
= qed_sp_ll2_rx_queue_stop(p_hwfn
, p_ll2_conn
);
1836 qed_ll2_rxq_flush(p_hwfn
, connection_handle
);
1839 if (p_ll2_conn
->input
.conn_type
== QED_LL2_TYPE_OOO
)
1840 qed_ooo_release_all_isles(p_hwfn
, p_hwfn
->p_ooo_info
);
1842 if (p_ll2_conn
->input
.conn_type
== QED_LL2_TYPE_FCOE
) {
1843 qed_llh_remove_protocol_filter(p_hwfn
, p_ptt
,
1845 QED_LLH_FILTER_ETHERTYPE
);
1846 qed_llh_remove_protocol_filter(p_hwfn
, p_ptt
,
1848 QED_LLH_FILTER_ETHERTYPE
);
1852 qed_ptt_release(p_hwfn
, p_ptt
);
1856 static void qed_ll2_release_connection_ooo(struct qed_hwfn
*p_hwfn
,
1857 struct qed_ll2_info
*p_ll2_conn
)
1859 struct qed_ooo_buffer
*p_buffer
;
1861 if (p_ll2_conn
->input
.conn_type
!= QED_LL2_TYPE_OOO
)
1864 qed_ooo_release_all_isles(p_hwfn
, p_hwfn
->p_ooo_info
);
1865 while ((p_buffer
= qed_ooo_get_free_buffer(p_hwfn
,
1866 p_hwfn
->p_ooo_info
))) {
1867 dma_free_coherent(&p_hwfn
->cdev
->pdev
->dev
,
1868 p_buffer
->rx_buffer_size
,
1869 p_buffer
->rx_buffer_virt_addr
,
1870 p_buffer
->rx_buffer_phys_addr
);
1875 void qed_ll2_release_connection(void *cxt
, u8 connection_handle
)
1877 struct qed_hwfn
*p_hwfn
= cxt
;
1878 struct qed_ll2_info
*p_ll2_conn
= NULL
;
1880 p_ll2_conn
= qed_ll2_handle_sanity(p_hwfn
, connection_handle
);
1884 if (QED_LL2_RX_REGISTERED(p_ll2_conn
)) {
1885 p_ll2_conn
->rx_queue
.b_cb_registred
= false;
1886 qed_int_unregister_cb(p_hwfn
, p_ll2_conn
->rx_queue
.rx_sb_index
);
1889 if (QED_LL2_TX_REGISTERED(p_ll2_conn
)) {
1890 p_ll2_conn
->tx_queue
.b_cb_registred
= false;
1891 qed_int_unregister_cb(p_hwfn
, p_ll2_conn
->tx_queue
.tx_sb_index
);
1894 kfree(p_ll2_conn
->tx_queue
.descq_mem
);
1895 qed_chain_free(p_hwfn
->cdev
, &p_ll2_conn
->tx_queue
.txq_chain
);
1897 kfree(p_ll2_conn
->rx_queue
.descq_array
);
1898 qed_chain_free(p_hwfn
->cdev
, &p_ll2_conn
->rx_queue
.rxq_chain
);
1899 qed_chain_free(p_hwfn
->cdev
, &p_ll2_conn
->rx_queue
.rcq_chain
);
1901 qed_cxt_release_cid(p_hwfn
, p_ll2_conn
->cid
);
1903 qed_ll2_release_connection_ooo(p_hwfn
, p_ll2_conn
);
1905 mutex_lock(&p_ll2_conn
->mutex
);
1906 p_ll2_conn
->b_active
= false;
1907 mutex_unlock(&p_ll2_conn
->mutex
);
1910 int qed_ll2_alloc(struct qed_hwfn
*p_hwfn
)
1912 struct qed_ll2_info
*p_ll2_connections
;
1915 /* Allocate LL2's set struct */
1916 p_ll2_connections
= kcalloc(QED_MAX_NUM_OF_LL2_CONNECTIONS
,
1917 sizeof(struct qed_ll2_info
), GFP_KERNEL
);
1918 if (!p_ll2_connections
) {
1919 DP_NOTICE(p_hwfn
, "Failed to allocate `struct qed_ll2'\n");
1923 for (i
= 0; i
< QED_MAX_NUM_OF_LL2_CONNECTIONS
; i
++)
1924 p_ll2_connections
[i
].my_id
= i
;
1926 p_hwfn
->p_ll2_info
= p_ll2_connections
;
1930 void qed_ll2_setup(struct qed_hwfn
*p_hwfn
)
1934 for (i
= 0; i
< QED_MAX_NUM_OF_LL2_CONNECTIONS
; i
++)
1935 mutex_init(&p_hwfn
->p_ll2_info
[i
].mutex
);
1938 void qed_ll2_free(struct qed_hwfn
*p_hwfn
)
1940 if (!p_hwfn
->p_ll2_info
)
1943 kfree(p_hwfn
->p_ll2_info
);
1944 p_hwfn
->p_ll2_info
= NULL
;
1947 static void _qed_ll2_get_port_stats(struct qed_hwfn
*p_hwfn
,
1948 struct qed_ptt
*p_ptt
,
1949 struct qed_ll2_stats
*p_stats
)
1951 struct core_ll2_port_stats port_stats
;
1953 memset(&port_stats
, 0, sizeof(port_stats
));
1954 qed_memcpy_from(p_hwfn
, p_ptt
, &port_stats
,
1955 BAR0_MAP_REG_TSDM_RAM
+
1956 TSTORM_LL2_PORT_STAT_OFFSET(MFW_PORT(p_hwfn
)),
1957 sizeof(port_stats
));
1959 p_stats
->gsi_invalid_hdr
= HILO_64_REGPAIR(port_stats
.gsi_invalid_hdr
);
1960 p_stats
->gsi_invalid_pkt_length
=
1961 HILO_64_REGPAIR(port_stats
.gsi_invalid_pkt_length
);
1962 p_stats
->gsi_unsupported_pkt_typ
=
1963 HILO_64_REGPAIR(port_stats
.gsi_unsupported_pkt_typ
);
1964 p_stats
->gsi_crcchksm_error
=
1965 HILO_64_REGPAIR(port_stats
.gsi_crcchksm_error
);
1968 static void _qed_ll2_get_tstats(struct qed_hwfn
*p_hwfn
,
1969 struct qed_ptt
*p_ptt
,
1970 struct qed_ll2_info
*p_ll2_conn
,
1971 struct qed_ll2_stats
*p_stats
)
1973 struct core_ll2_tstorm_per_queue_stat tstats
;
1974 u8 qid
= p_ll2_conn
->queue_id
;
1977 memset(&tstats
, 0, sizeof(tstats
));
1978 tstats_addr
= BAR0_MAP_REG_TSDM_RAM
+
1979 CORE_LL2_TSTORM_PER_QUEUE_STAT_OFFSET(qid
);
1980 qed_memcpy_from(p_hwfn
, p_ptt
, &tstats
, tstats_addr
, sizeof(tstats
));
1982 p_stats
->packet_too_big_discard
=
1983 HILO_64_REGPAIR(tstats
.packet_too_big_discard
);
1984 p_stats
->no_buff_discard
= HILO_64_REGPAIR(tstats
.no_buff_discard
);
1987 static void _qed_ll2_get_ustats(struct qed_hwfn
*p_hwfn
,
1988 struct qed_ptt
*p_ptt
,
1989 struct qed_ll2_info
*p_ll2_conn
,
1990 struct qed_ll2_stats
*p_stats
)
1992 struct core_ll2_ustorm_per_queue_stat ustats
;
1993 u8 qid
= p_ll2_conn
->queue_id
;
1996 memset(&ustats
, 0, sizeof(ustats
));
1997 ustats_addr
= BAR0_MAP_REG_USDM_RAM
+
1998 CORE_LL2_USTORM_PER_QUEUE_STAT_OFFSET(qid
);
1999 qed_memcpy_from(p_hwfn
, p_ptt
, &ustats
, ustats_addr
, sizeof(ustats
));
2001 p_stats
->rcv_ucast_bytes
= HILO_64_REGPAIR(ustats
.rcv_ucast_bytes
);
2002 p_stats
->rcv_mcast_bytes
= HILO_64_REGPAIR(ustats
.rcv_mcast_bytes
);
2003 p_stats
->rcv_bcast_bytes
= HILO_64_REGPAIR(ustats
.rcv_bcast_bytes
);
2004 p_stats
->rcv_ucast_pkts
= HILO_64_REGPAIR(ustats
.rcv_ucast_pkts
);
2005 p_stats
->rcv_mcast_pkts
= HILO_64_REGPAIR(ustats
.rcv_mcast_pkts
);
2006 p_stats
->rcv_bcast_pkts
= HILO_64_REGPAIR(ustats
.rcv_bcast_pkts
);
2009 static void _qed_ll2_get_pstats(struct qed_hwfn
*p_hwfn
,
2010 struct qed_ptt
*p_ptt
,
2011 struct qed_ll2_info
*p_ll2_conn
,
2012 struct qed_ll2_stats
*p_stats
)
2014 struct core_ll2_pstorm_per_queue_stat pstats
;
2015 u8 stats_id
= p_ll2_conn
->tx_stats_id
;
2018 memset(&pstats
, 0, sizeof(pstats
));
2019 pstats_addr
= BAR0_MAP_REG_PSDM_RAM
+
2020 CORE_LL2_PSTORM_PER_QUEUE_STAT_OFFSET(stats_id
);
2021 qed_memcpy_from(p_hwfn
, p_ptt
, &pstats
, pstats_addr
, sizeof(pstats
));
2023 p_stats
->sent_ucast_bytes
= HILO_64_REGPAIR(pstats
.sent_ucast_bytes
);
2024 p_stats
->sent_mcast_bytes
= HILO_64_REGPAIR(pstats
.sent_mcast_bytes
);
2025 p_stats
->sent_bcast_bytes
= HILO_64_REGPAIR(pstats
.sent_bcast_bytes
);
2026 p_stats
->sent_ucast_pkts
= HILO_64_REGPAIR(pstats
.sent_ucast_pkts
);
2027 p_stats
->sent_mcast_pkts
= HILO_64_REGPAIR(pstats
.sent_mcast_pkts
);
2028 p_stats
->sent_bcast_pkts
= HILO_64_REGPAIR(pstats
.sent_bcast_pkts
);
2031 int qed_ll2_get_stats(void *cxt
,
2032 u8 connection_handle
, struct qed_ll2_stats
*p_stats
)
2034 struct qed_hwfn
*p_hwfn
= cxt
;
2035 struct qed_ll2_info
*p_ll2_conn
= NULL
;
2036 struct qed_ptt
*p_ptt
;
2038 memset(p_stats
, 0, sizeof(*p_stats
));
2040 if ((connection_handle
>= QED_MAX_NUM_OF_LL2_CONNECTIONS
) ||
2041 !p_hwfn
->p_ll2_info
)
2044 p_ll2_conn
= &p_hwfn
->p_ll2_info
[connection_handle
];
2046 p_ptt
= qed_ptt_acquire(p_hwfn
);
2048 DP_ERR(p_hwfn
, "Failed to acquire ptt\n");
2052 if (p_ll2_conn
->input
.gsi_enable
)
2053 _qed_ll2_get_port_stats(p_hwfn
, p_ptt
, p_stats
);
2054 _qed_ll2_get_tstats(p_hwfn
, p_ptt
, p_ll2_conn
, p_stats
);
2055 _qed_ll2_get_ustats(p_hwfn
, p_ptt
, p_ll2_conn
, p_stats
);
2056 if (p_ll2_conn
->tx_stats_en
)
2057 _qed_ll2_get_pstats(p_hwfn
, p_ptt
, p_ll2_conn
, p_stats
);
2059 qed_ptt_release(p_hwfn
, p_ptt
);
2063 static void qed_ll2b_release_rx_packet(void *cxt
,
2064 u8 connection_handle
,
2066 dma_addr_t rx_buf_addr
,
2069 struct qed_hwfn
*p_hwfn
= cxt
;
2071 qed_ll2_dealloc_buffer(p_hwfn
->cdev
, cookie
);
2074 static void qed_ll2_register_cb_ops(struct qed_dev
*cdev
,
2075 const struct qed_ll2_cb_ops
*ops
,
2078 cdev
->ll2
->cbs
= ops
;
2079 cdev
->ll2
->cb_cookie
= cookie
;
2082 struct qed_ll2_cbs ll2_cbs
= {
2083 .rx_comp_cb
= &qed_ll2b_complete_rx_packet
,
2084 .rx_release_cb
= &qed_ll2b_release_rx_packet
,
2085 .tx_comp_cb
= &qed_ll2b_complete_tx_packet
,
2086 .tx_release_cb
= &qed_ll2b_complete_tx_packet
,
2089 static void qed_ll2_set_conn_data(struct qed_dev
*cdev
,
2090 struct qed_ll2_acquire_data
*data
,
2091 struct qed_ll2_params
*params
,
2092 enum qed_ll2_conn_type conn_type
,
2093 u8
*handle
, bool lb
)
2095 memset(data
, 0, sizeof(*data
));
2097 data
->input
.conn_type
= conn_type
;
2098 data
->input
.mtu
= params
->mtu
;
2099 data
->input
.rx_num_desc
= QED_LL2_RX_SIZE
;
2100 data
->input
.rx_drop_ttl0_flg
= params
->drop_ttl0_packets
;
2101 data
->input
.rx_vlan_removal_en
= params
->rx_vlan_stripping
;
2102 data
->input
.tx_num_desc
= QED_LL2_TX_SIZE
;
2103 data
->p_connection_handle
= handle
;
2104 data
->cbs
= &ll2_cbs
;
2105 ll2_cbs
.cookie
= QED_LEADING_HWFN(cdev
);
2108 data
->input
.tx_tc
= PKT_LB_TC
;
2109 data
->input
.tx_dest
= QED_LL2_TX_DEST_LB
;
2111 data
->input
.tx_tc
= 0;
2112 data
->input
.tx_dest
= QED_LL2_TX_DEST_NW
;
2116 static int qed_ll2_start_ooo(struct qed_dev
*cdev
,
2117 struct qed_ll2_params
*params
)
2119 struct qed_hwfn
*hwfn
= QED_LEADING_HWFN(cdev
);
2120 u8
*handle
= &hwfn
->pf_params
.iscsi_pf_params
.ll2_ooo_queue_id
;
2121 struct qed_ll2_acquire_data data
;
2124 qed_ll2_set_conn_data(cdev
, &data
, params
,
2125 QED_LL2_TYPE_OOO
, handle
, true);
2127 rc
= qed_ll2_acquire_connection(hwfn
, &data
);
2129 DP_INFO(cdev
, "Failed to acquire LL2 OOO connection\n");
2133 rc
= qed_ll2_establish_connection(hwfn
, *handle
);
2135 DP_INFO(cdev
, "Failed to establist LL2 OOO connection\n");
2142 qed_ll2_release_connection(hwfn
, *handle
);
2144 *handle
= QED_LL2_UNUSED_HANDLE
;
2148 static int qed_ll2_start(struct qed_dev
*cdev
, struct qed_ll2_params
*params
)
2150 struct qed_ll2_buffer
*buffer
, *tmp_buffer
;
2151 enum qed_ll2_conn_type conn_type
;
2152 struct qed_ll2_acquire_data data
;
2153 struct qed_ptt
*p_ptt
;
2157 /* Initialize LL2 locks & lists */
2158 INIT_LIST_HEAD(&cdev
->ll2
->list
);
2159 spin_lock_init(&cdev
->ll2
->lock
);
2160 cdev
->ll2
->rx_size
= NET_SKB_PAD
+ ETH_HLEN
+
2161 L1_CACHE_BYTES
+ params
->mtu
;
2163 /*Allocate memory for LL2 */
2164 DP_INFO(cdev
, "Allocating LL2 buffers of size %08x bytes\n",
2165 cdev
->ll2
->rx_size
);
2166 for (i
= 0; i
< QED_LL2_RX_SIZE
; i
++) {
2167 buffer
= kzalloc(sizeof(*buffer
), GFP_KERNEL
);
2169 DP_INFO(cdev
, "Failed to allocate LL2 buffers\n");
2173 rc
= qed_ll2_alloc_buffer(cdev
, (u8
**)&buffer
->data
,
2174 &buffer
->phys_addr
);
2180 list_add_tail(&buffer
->list
, &cdev
->ll2
->list
);
2183 switch (QED_LEADING_HWFN(cdev
)->hw_info
.personality
) {
2185 conn_type
= QED_LL2_TYPE_FCOE
;
2188 conn_type
= QED_LL2_TYPE_ISCSI
;
2190 case QED_PCI_ETH_ROCE
:
2191 conn_type
= QED_LL2_TYPE_ROCE
;
2194 conn_type
= QED_LL2_TYPE_TEST
;
2197 qed_ll2_set_conn_data(cdev
, &data
, params
, conn_type
,
2198 &cdev
->ll2
->handle
, false);
2200 rc
= qed_ll2_acquire_connection(QED_LEADING_HWFN(cdev
), &data
);
2202 DP_INFO(cdev
, "Failed to acquire LL2 connection\n");
2206 rc
= qed_ll2_establish_connection(QED_LEADING_HWFN(cdev
),
2209 DP_INFO(cdev
, "Failed to establish LL2 connection\n");
2213 /* Post all Rx buffers to FW */
2214 spin_lock_bh(&cdev
->ll2
->lock
);
2215 list_for_each_entry_safe(buffer
, tmp_buffer
, &cdev
->ll2
->list
, list
) {
2216 rc
= qed_ll2_post_rx_buffer(QED_LEADING_HWFN(cdev
),
2218 buffer
->phys_addr
, 0, buffer
, 1);
2221 "Failed to post an Rx buffer; Deleting it\n");
2222 dma_unmap_single(&cdev
->pdev
->dev
, buffer
->phys_addr
,
2223 cdev
->ll2
->rx_size
, DMA_FROM_DEVICE
);
2224 kfree(buffer
->data
);
2225 list_del(&buffer
->list
);
2228 cdev
->ll2
->rx_cnt
++;
2231 spin_unlock_bh(&cdev
->ll2
->lock
);
2233 if (!cdev
->ll2
->rx_cnt
) {
2234 DP_INFO(cdev
, "Failed passing even a single Rx buffer\n");
2235 goto release_terminate
;
2238 if (!is_valid_ether_addr(params
->ll2_mac_address
)) {
2239 DP_INFO(cdev
, "Invalid Ethernet address\n");
2240 goto release_terminate
;
2243 if (cdev
->hwfns
[0].hw_info
.personality
== QED_PCI_ISCSI
&&
2244 cdev
->hwfns
[0].pf_params
.iscsi_pf_params
.ooo_enable
) {
2245 DP_VERBOSE(cdev
, QED_MSG_STORAGE
, "Starting OOO LL2 queue\n");
2246 rc
= qed_ll2_start_ooo(cdev
, params
);
2249 "Failed to initialize the OOO LL2 queue\n");
2250 goto release_terminate
;
2254 p_ptt
= qed_ptt_acquire(QED_LEADING_HWFN(cdev
));
2256 DP_INFO(cdev
, "Failed to acquire PTT\n");
2257 goto release_terminate
;
2260 rc
= qed_llh_add_mac_filter(QED_LEADING_HWFN(cdev
), p_ptt
,
2261 params
->ll2_mac_address
);
2262 qed_ptt_release(QED_LEADING_HWFN(cdev
), p_ptt
);
2264 DP_ERR(cdev
, "Failed to allocate LLH filter\n");
2265 goto release_terminate_all
;
2268 ether_addr_copy(cdev
->ll2_mac_address
, params
->ll2_mac_address
);
2271 release_terminate_all
:
2274 qed_ll2_terminate_connection(QED_LEADING_HWFN(cdev
), cdev
->ll2
->handle
);
2276 qed_ll2_release_connection(QED_LEADING_HWFN(cdev
), cdev
->ll2
->handle
);
2278 qed_ll2_kill_buffers(cdev
);
2279 cdev
->ll2
->handle
= QED_LL2_UNUSED_HANDLE
;
2283 static int qed_ll2_stop(struct qed_dev
*cdev
)
2285 struct qed_ptt
*p_ptt
;
2288 if (cdev
->ll2
->handle
== QED_LL2_UNUSED_HANDLE
)
2291 p_ptt
= qed_ptt_acquire(QED_LEADING_HWFN(cdev
));
2293 DP_INFO(cdev
, "Failed to acquire PTT\n");
2297 qed_llh_remove_mac_filter(QED_LEADING_HWFN(cdev
), p_ptt
,
2298 cdev
->ll2_mac_address
);
2299 qed_ptt_release(QED_LEADING_HWFN(cdev
), p_ptt
);
2300 eth_zero_addr(cdev
->ll2_mac_address
);
2302 if (cdev
->hwfns
[0].hw_info
.personality
== QED_PCI_ISCSI
&&
2303 cdev
->hwfns
[0].pf_params
.iscsi_pf_params
.ooo_enable
)
2304 qed_ll2_stop_ooo(cdev
);
2306 rc
= qed_ll2_terminate_connection(QED_LEADING_HWFN(cdev
),
2309 DP_INFO(cdev
, "Failed to terminate LL2 connection\n");
2311 qed_ll2_kill_buffers(cdev
);
2313 qed_ll2_release_connection(QED_LEADING_HWFN(cdev
), cdev
->ll2
->handle
);
2314 cdev
->ll2
->handle
= QED_LL2_UNUSED_HANDLE
;
2321 static int qed_ll2_start_xmit(struct qed_dev
*cdev
, struct sk_buff
*skb
)
2323 struct qed_ll2_tx_pkt_info pkt
;
2324 const skb_frag_t
*frag
;
2325 int rc
= -EINVAL
, i
;
2330 if (unlikely(skb
->ip_summed
!= CHECKSUM_NONE
)) {
2331 DP_INFO(cdev
, "Cannot transmit a checksumed packet\n");
2335 if (1 + skb_shinfo(skb
)->nr_frags
> CORE_LL2_TX_MAX_BDS_PER_PACKET
) {
2336 DP_ERR(cdev
, "Cannot transmit a packet with %d fragments\n",
2337 1 + skb_shinfo(skb
)->nr_frags
);
2341 mapping
= dma_map_single(&cdev
->pdev
->dev
, skb
->data
,
2342 skb
->len
, DMA_TO_DEVICE
);
2343 if (unlikely(dma_mapping_error(&cdev
->pdev
->dev
, mapping
))) {
2344 DP_NOTICE(cdev
, "SKB mapping failed\n");
2348 /* Request HW to calculate IP csum */
2349 if (!((vlan_get_protocol(skb
) == htons(ETH_P_IPV6
)) &&
2350 ipv6_hdr(skb
)->nexthdr
== NEXTHDR_IPV6
))
2351 flags
|= BIT(CORE_TX_BD_DATA_IP_CSUM_SHIFT
);
2353 if (skb_vlan_tag_present(skb
)) {
2354 vlan
= skb_vlan_tag_get(skb
);
2355 flags
|= BIT(CORE_TX_BD_DATA_VLAN_INSERTION_SHIFT
);
2358 memset(&pkt
, 0, sizeof(pkt
));
2359 pkt
.num_of_bds
= 1 + skb_shinfo(skb
)->nr_frags
;
2361 pkt
.bd_flags
= flags
;
2362 pkt
.tx_dest
= QED_LL2_TX_DEST_NW
;
2363 pkt
.first_frag
= mapping
;
2364 pkt
.first_frag_len
= skb
->len
;
2367 rc
= qed_ll2_prepare_tx_packet(&cdev
->hwfns
[0], cdev
->ll2
->handle
,
2372 for (i
= 0; i
< skb_shinfo(skb
)->nr_frags
; i
++) {
2373 frag
= &skb_shinfo(skb
)->frags
[i
];
2375 mapping
= skb_frag_dma_map(&cdev
->pdev
->dev
, frag
, 0,
2376 skb_frag_size(frag
), DMA_TO_DEVICE
);
2378 if (unlikely(dma_mapping_error(&cdev
->pdev
->dev
, mapping
))) {
2380 "Unable to map frag - dropping packet\n");
2384 rc
= qed_ll2_set_fragment_of_tx_packet(QED_LEADING_HWFN(cdev
),
2387 skb_frag_size(frag
));
2389 /* if failed not much to do here, partial packet has been posted
2390 * we can't free memory, will need to wait for completion.
2399 dma_unmap_single(&cdev
->pdev
->dev
, mapping
, skb
->len
, DMA_TO_DEVICE
);
2405 static int qed_ll2_stats(struct qed_dev
*cdev
, struct qed_ll2_stats
*stats
)
2410 return qed_ll2_get_stats(QED_LEADING_HWFN(cdev
),
2411 cdev
->ll2
->handle
, stats
);
2414 const struct qed_ll2_ops qed_ll2_ops_pass
= {
2415 .start
= &qed_ll2_start
,
2416 .stop
= &qed_ll2_stop
,
2417 .start_xmit
= &qed_ll2_start_xmit
,
2418 .register_cb_ops
= &qed_ll2_register_cb_ops
,
2419 .get_stats
= &qed_ll2_stats
,
2422 int qed_ll2_alloc_if(struct qed_dev
*cdev
)
2424 cdev
->ll2
= kzalloc(sizeof(*cdev
->ll2
), GFP_KERNEL
);
2425 return cdev
->ll2
? 0 : -ENOMEM
;
2428 void qed_ll2_dealloc_if(struct qed_dev
*cdev
)