1 /*
2 * Copyright (c) 2018-2019 Cavium, Inc.
3 * All rights reserved.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
7 * are met:
8 *
9 * 1. Redistributions of source code must retain the above copyright
10 * notice, this list of conditions and the following disclaimer.
11 * 2. Redistributions in binary form must reproduce the above copyright
12 * notice, this list of conditions and the following disclaimer in the
13 * documentation and/or other materials provided with the distribution.
14 *
15 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
16 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
18 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
19 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
20 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
21 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
22 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
23 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
24 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
25 * POSSIBILITY OF SUCH DAMAGE.
26 */
27
28 /*
29 * File : ecore_ll2.c
30 */
31 #include <sys/cdefs.h>
32 #include "bcm_osal.h"
33
34 #include "ecore.h"
35 #include "ecore_status.h"
36 #include "ecore_ll2.h"
37 #include "reg_addr.h"
38 #include "ecore_int.h"
39 #include "ecore_cxt.h"
40 #include "ecore_sp_commands.h"
41 #include "ecore_hw.h"
42 #include "reg_addr.h"
43 #include "ecore_dev_api.h"
44 #include "ecore_iro.h"
45 #include "ecore_gtt_reg_addr.h"
46 #include "ecore_ooo.h"
47 #include "ecore_hw.h"
48 #include "ecore_mcp.h"
49
50 #define ECORE_LL2_RX_REGISTERED(ll2) ((ll2)->rx_queue.b_cb_registred)
51 #define ECORE_LL2_TX_REGISTERED(ll2) ((ll2)->tx_queue.b_cb_registred)
52
53 #ifdef _NTDDK_
54 #pragma warning(push)
55 #pragma warning(disable : 28167)
56 #pragma warning(disable : 28123)
57 #pragma warning(disable : 28121)
58 #endif
59
60 static struct ecore_ll2_info *
__ecore_ll2_handle_sanity(struct ecore_hwfn * p_hwfn,u8 connection_handle,bool b_lock,bool b_only_active)61 __ecore_ll2_handle_sanity(struct ecore_hwfn *p_hwfn,
62 u8 connection_handle,
63 bool b_lock, bool b_only_active)
64 {
65 struct ecore_ll2_info *p_ll2_conn, *p_ret = OSAL_NULL;
66
67 if (connection_handle >= ECORE_MAX_NUM_OF_LL2_CONNECTIONS)
68 return OSAL_NULL;
69
70 if (!p_hwfn->p_ll2_info)
71 return OSAL_NULL;
72
73 /* TODO - is there really need for the locked vs. unlocked
74 * variant? I simply used what was already there.
75 */
76 p_ll2_conn = &p_hwfn->p_ll2_info[connection_handle];
77
78 if (b_only_active) {
79 if (b_lock)
80 OSAL_MUTEX_ACQUIRE(&p_ll2_conn->mutex);
81 if (p_ll2_conn->b_active)
82 p_ret = p_ll2_conn;
83 if (b_lock)
84 OSAL_MUTEX_RELEASE(&p_ll2_conn->mutex);
85 } else {
86 p_ret = p_ll2_conn;
87 }
88
89 return p_ret;
90 }
91
92 static struct ecore_ll2_info *
ecore_ll2_handle_sanity(struct ecore_hwfn * p_hwfn,u8 connection_handle)93 ecore_ll2_handle_sanity(struct ecore_hwfn *p_hwfn,
94 u8 connection_handle)
95 {
96 return __ecore_ll2_handle_sanity(p_hwfn, connection_handle,
97 false, true);
98 }
99
100 static struct ecore_ll2_info *
ecore_ll2_handle_sanity_lock(struct ecore_hwfn * p_hwfn,u8 connection_handle)101 ecore_ll2_handle_sanity_lock(struct ecore_hwfn *p_hwfn,
102 u8 connection_handle)
103 {
104 return __ecore_ll2_handle_sanity(p_hwfn, connection_handle,
105 true, true);
106 }
107
108 static struct ecore_ll2_info *
ecore_ll2_handle_sanity_inactive(struct ecore_hwfn * p_hwfn,u8 connection_handle)109 ecore_ll2_handle_sanity_inactive(struct ecore_hwfn *p_hwfn,
110 u8 connection_handle)
111 {
112 return __ecore_ll2_handle_sanity(p_hwfn, connection_handle,
113 false, false);
114 }
115
116 #ifndef LINUX_REMOVE
117 /* TODO - is this really been used by anyone? Is it a on future todo list? */
118 enum _ecore_status_t
ecore_ll2_get_fragment_of_tx_packet(struct ecore_hwfn * p_hwfn,u8 connection_handle,dma_addr_t * p_addr,bool * b_last_fragment)119 ecore_ll2_get_fragment_of_tx_packet(struct ecore_hwfn *p_hwfn,
120 u8 connection_handle,
121 dma_addr_t *p_addr,
122 bool *b_last_fragment)
123 {
124 struct ecore_ll2_tx_packet *p_pkt;
125 struct ecore_ll2_info *p_ll2_conn;
126 u16 cur_frag_idx = 0;
127
128 p_ll2_conn = ecore_ll2_handle_sanity(p_hwfn, connection_handle);
129 if (p_ll2_conn == OSAL_NULL)
130 return ECORE_INVAL;
131 p_pkt = &p_ll2_conn->tx_queue.cur_completing_packet;
132
133 if (!p_ll2_conn->tx_queue.b_completing_packet || !p_addr)
134 return ECORE_INVAL;
135
136 if (p_ll2_conn->tx_queue.cur_completing_bd_idx == p_pkt->bd_used)
137 return ECORE_INVAL;
138
139 /* Packet is available and has at least one more frag - provide it */
140 cur_frag_idx = p_ll2_conn->tx_queue.cur_completing_bd_idx++;
141 *p_addr = p_pkt->bds_set[cur_frag_idx].tx_frag;
142 if (b_last_fragment)
143 *b_last_fragment = p_pkt->bd_used ==
144 p_ll2_conn->tx_queue.cur_completing_bd_idx;
145
146 return ECORE_SUCCESS;
147 }
148 #endif
149
ecore_ll2_txq_flush(struct ecore_hwfn * p_hwfn,u8 connection_handle)150 static void ecore_ll2_txq_flush(struct ecore_hwfn *p_hwfn,
151 u8 connection_handle)
152 {
153 bool b_last_packet = false, b_last_frag = false;
154 struct ecore_ll2_tx_packet *p_pkt = OSAL_NULL;
155 struct ecore_ll2_info *p_ll2_conn;
156 struct ecore_ll2_tx_queue *p_tx;
157 unsigned long flags = 0;
158 dma_addr_t tx_frag;
159
160 p_ll2_conn = ecore_ll2_handle_sanity_inactive(p_hwfn,
161 connection_handle);
162 if (p_ll2_conn == OSAL_NULL)
163 return;
164 p_tx = &p_ll2_conn->tx_queue;
165
166 OSAL_SPIN_LOCK_IRQSAVE(&p_tx->lock, flags);
167 while (!OSAL_LIST_IS_EMPTY(&p_tx->active_descq)) {
168 p_pkt = OSAL_LIST_FIRST_ENTRY(&p_tx->active_descq,
169 struct ecore_ll2_tx_packet,
170 list_entry);
171
172 if (p_pkt == OSAL_NULL)
173 break;
174
175 #if defined(_NTDDK_)
176 #pragma warning(suppress : 6011 28182)
177 #endif
178 OSAL_LIST_REMOVE_ENTRY(&p_pkt->list_entry,
179 &p_tx->active_descq);
180 b_last_packet = OSAL_LIST_IS_EMPTY(&p_tx->active_descq);
181 OSAL_LIST_PUSH_TAIL(&p_pkt->list_entry,
182 &p_tx->free_descq);
183 OSAL_SPIN_UNLOCK_IRQSAVE(&p_tx->lock, flags);
184 if (p_ll2_conn->input.conn_type == ECORE_LL2_TYPE_OOO) {
185 struct ecore_ooo_buffer *p_buffer;
186
187 p_buffer = (struct ecore_ooo_buffer *)p_pkt->cookie;
188 ecore_ooo_put_free_buffer(p_hwfn->p_ooo_info, p_buffer);
189 } else {
190 p_tx->cur_completing_packet = *p_pkt;
191 p_tx->cur_completing_bd_idx = 1;
192 b_last_frag = p_tx->cur_completing_bd_idx ==
193 p_pkt->bd_used;
194
195 tx_frag = p_pkt->bds_set[0].tx_frag;
196 p_ll2_conn->cbs.tx_release_cb(p_ll2_conn->cbs.cookie,
197 p_ll2_conn->my_id,
198 p_pkt->cookie,
199 tx_frag,
200 b_last_frag,
201 b_last_packet);
202 }
203 OSAL_SPIN_LOCK_IRQSAVE(&p_tx->lock, flags);
204 }
205 OSAL_SPIN_UNLOCK_IRQSAVE(&p_tx->lock, flags);
206 }
207
208 static enum _ecore_status_t
ecore_ll2_txq_completion(struct ecore_hwfn * p_hwfn,void * p_cookie)209 ecore_ll2_txq_completion(struct ecore_hwfn *p_hwfn,
210 void *p_cookie)
211 {
212 struct ecore_ll2_info *p_ll2_conn = (struct ecore_ll2_info*)p_cookie;
213 struct ecore_ll2_tx_queue *p_tx = &p_ll2_conn->tx_queue;
214 u16 new_idx = 0, num_bds = 0, num_bds_in_packet = 0;
215 struct ecore_ll2_tx_packet *p_pkt;
216 bool b_last_frag = false;
217 unsigned long flags;
218 enum _ecore_status_t rc = ECORE_INVAL;
219
220 OSAL_SPIN_LOCK_IRQSAVE(&p_tx->lock, flags);
221 if (p_tx->b_completing_packet) {
222 /* TODO - this looks completely unnecessary to me - the only
223 * way we can re-enter is by the DPC calling us again, but this
224 * would only happen AFTER we return, and we unset this at end
225 * of the function.
226 */
227 rc = ECORE_BUSY;
228 goto out;
229 }
230
231 new_idx = OSAL_LE16_TO_CPU(*p_tx->p_fw_cons);
232 num_bds = ((s16)new_idx - (s16)p_tx->bds_idx);
233 while (num_bds) {
234 if (OSAL_LIST_IS_EMPTY(&p_tx->active_descq))
235 goto out;
236
237 p_pkt = OSAL_LIST_FIRST_ENTRY(&p_tx->active_descq,
238 struct ecore_ll2_tx_packet,
239 list_entry);
240 if (!p_pkt)
241 goto out;
242
243 p_tx->b_completing_packet = true;
244 p_tx->cur_completing_packet = *p_pkt;
245 num_bds_in_packet = p_pkt->bd_used;
246 #if defined(_NTDDK_)
247 #pragma warning(suppress : 6011 28182)
248 #endif
249 OSAL_LIST_REMOVE_ENTRY(&p_pkt->list_entry,
250 &p_tx->active_descq);
251
252 if (num_bds < num_bds_in_packet) {
253 DP_NOTICE(p_hwfn, true,
254 "Rest of BDs does not cover whole packet\n");
255 goto out;
256 }
257
258 num_bds -= num_bds_in_packet;
259 p_tx->bds_idx += num_bds_in_packet;
260 while (num_bds_in_packet--)
261 ecore_chain_consume(&p_tx->txq_chain);
262
263 p_tx->cur_completing_bd_idx = 1;
264 b_last_frag = p_tx->cur_completing_bd_idx ==
265 p_pkt->bd_used;
266 OSAL_LIST_PUSH_TAIL(&p_pkt->list_entry,
267 &p_tx->free_descq);
268
269 OSAL_SPIN_UNLOCK_IRQSAVE(&p_tx->lock, flags);
270
271 p_ll2_conn->cbs.tx_comp_cb(p_ll2_conn->cbs.cookie,
272 p_ll2_conn->my_id,
273 p_pkt->cookie,
274 p_pkt->bds_set[0].tx_frag,
275 b_last_frag,
276 !num_bds);
277
278 OSAL_SPIN_LOCK_IRQSAVE(&p_tx->lock, flags);
279 }
280
281 p_tx->b_completing_packet = false;
282 rc = ECORE_SUCCESS;
283 out:
284 OSAL_SPIN_UNLOCK_IRQSAVE(&p_tx->lock, flags);
285 return rc;
286 }
287
ecore_ll2_rxq_parse_gsi(union core_rx_cqe_union * p_cqe,struct ecore_ll2_comp_rx_data * data)288 static void ecore_ll2_rxq_parse_gsi(union core_rx_cqe_union *p_cqe,
289 struct ecore_ll2_comp_rx_data *data)
290 {
291 data->parse_flags =
292 OSAL_LE16_TO_CPU(p_cqe->rx_cqe_gsi.parse_flags.flags);
293 data->length.data_length =
294 OSAL_LE16_TO_CPU(p_cqe->rx_cqe_gsi.data_length);
295 data->vlan =
296 OSAL_LE16_TO_CPU(p_cqe->rx_cqe_gsi.vlan);
297 data->opaque_data_0 =
298 OSAL_LE32_TO_CPU(p_cqe->rx_cqe_gsi.src_mac_addrhi);
299 data->opaque_data_1 =
300 OSAL_LE16_TO_CPU(p_cqe->rx_cqe_gsi.src_mac_addrlo);
301 data->u.data_length_error =
302 p_cqe->rx_cqe_gsi.data_length_error;
303 data->qp_id = OSAL_LE16_TO_CPU(p_cqe->rx_cqe_gsi.qp_id);
304
305 data->src_qp = OSAL_LE32_TO_CPU(p_cqe->rx_cqe_gsi.src_qp);
306 }
307
ecore_ll2_rxq_parse_reg(union core_rx_cqe_union * p_cqe,struct ecore_ll2_comp_rx_data * data)308 static void ecore_ll2_rxq_parse_reg(union core_rx_cqe_union *p_cqe,
309 struct ecore_ll2_comp_rx_data *data)
310 {
311 data->parse_flags =
312 OSAL_LE16_TO_CPU(p_cqe->rx_cqe_fp.parse_flags.flags);
313 data->err_flags =
314 OSAL_LE16_TO_CPU(p_cqe->rx_cqe_fp.err_flags.flags);
315 data->length.packet_length =
316 OSAL_LE16_TO_CPU(p_cqe->rx_cqe_fp.packet_length);
317 data->vlan =
318 OSAL_LE16_TO_CPU(p_cqe->rx_cqe_fp.vlan);
319 data->opaque_data_0 =
320 OSAL_LE32_TO_CPU(p_cqe->rx_cqe_fp.opaque_data.data[0]);
321 data->opaque_data_1 =
322 OSAL_LE32_TO_CPU(p_cqe->rx_cqe_fp.opaque_data.data[1]);
323 data->u.placement_offset =
324 p_cqe->rx_cqe_fp.placement_offset;
325 }
326
327 #if defined(_NTDDK_)
328 #pragma warning(suppress : 28167 26110)
329 #endif
330 static enum _ecore_status_t
ecore_ll2_handle_slowpath(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn,union core_rx_cqe_union * p_cqe,unsigned long * p_lock_flags)331 ecore_ll2_handle_slowpath(struct ecore_hwfn *p_hwfn,
332 struct ecore_ll2_info *p_ll2_conn,
333 union core_rx_cqe_union *p_cqe,
334 unsigned long *p_lock_flags)
335 {
336 struct ecore_ll2_rx_queue *p_rx = &p_ll2_conn->rx_queue;
337 struct core_rx_slow_path_cqe *sp_cqe;
338
339 sp_cqe = &p_cqe->rx_cqe_sp;
340 if (sp_cqe->ramrod_cmd_id != CORE_RAMROD_RX_QUEUE_FLUSH) {
341 DP_NOTICE(p_hwfn, true,
342 "LL2 - unexpected Rx CQE slowpath ramrod_cmd_id:%d\n",
343 sp_cqe->ramrod_cmd_id);
344 return ECORE_INVAL;
345 }
346
347 if (p_ll2_conn->cbs.slowpath_cb == OSAL_NULL) {
348 DP_NOTICE(p_hwfn, true,
349 "LL2 - received RX_QUEUE_FLUSH but no callback was provided\n");
350 return ECORE_INVAL;
351 }
352
353 OSAL_SPIN_UNLOCK_IRQSAVE(&p_rx->lock, *p_lock_flags);
354
355 p_ll2_conn->cbs.slowpath_cb(p_ll2_conn->cbs.cookie,
356 p_ll2_conn->my_id,
357 OSAL_LE32_TO_CPU(sp_cqe->opaque_data.data[0]),
358 OSAL_LE32_TO_CPU(sp_cqe->opaque_data.data[1]));
359
360 OSAL_SPIN_LOCK_IRQSAVE(&p_rx->lock, *p_lock_flags);
361
362 return ECORE_SUCCESS;
363 }
364
365 static enum _ecore_status_t
ecore_ll2_rxq_handle_completion(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn,union core_rx_cqe_union * p_cqe,unsigned long * p_lock_flags,bool b_last_cqe)366 ecore_ll2_rxq_handle_completion(struct ecore_hwfn *p_hwfn,
367 struct ecore_ll2_info *p_ll2_conn,
368 union core_rx_cqe_union *p_cqe,
369 unsigned long *p_lock_flags,
370 bool b_last_cqe)
371 {
372 struct ecore_ll2_rx_queue *p_rx = &p_ll2_conn->rx_queue;
373 struct ecore_ll2_rx_packet *p_pkt = OSAL_NULL;
374 struct ecore_ll2_comp_rx_data data;
375
376 if (!OSAL_LIST_IS_EMPTY(&p_rx->active_descq))
377 p_pkt = OSAL_LIST_FIRST_ENTRY(&p_rx->active_descq,
378 struct ecore_ll2_rx_packet,
379 list_entry);
380 if (!p_pkt) {
381 DP_NOTICE(p_hwfn, false,
382 "[%d] LL2 Rx completion but active_descq is empty\n",
383 p_ll2_conn->input.conn_type);
384
385 return ECORE_IO;
386 }
387
388 OSAL_LIST_REMOVE_ENTRY(&p_pkt->list_entry, &p_rx->active_descq);
389
390 if (p_cqe->rx_cqe_sp.type == CORE_RX_CQE_TYPE_REGULAR)
391 ecore_ll2_rxq_parse_reg(p_cqe, &data);
392 else
393 ecore_ll2_rxq_parse_gsi(p_cqe, &data);
394
395 if (ecore_chain_consume(&p_rx->rxq_chain) != p_pkt->rxq_bd) {
396 DP_NOTICE(p_hwfn, false,
397 "Mismatch between active_descq and the LL2 Rx chain\n");
398 /* TODO - didn't return error value since this wasn't handled
399 * before, but this is obviously lacking.
400 */
401 }
402
403 OSAL_LIST_PUSH_TAIL(&p_pkt->list_entry, &p_rx->free_descq);
404
405 data.connection_handle = p_ll2_conn->my_id;
406 data.cookie = p_pkt->cookie;
407 data.rx_buf_addr = p_pkt->rx_buf_addr;
408 data.b_last_packet = b_last_cqe;
409
410 OSAL_SPIN_UNLOCK_IRQSAVE(&p_rx->lock, *p_lock_flags);
411 p_ll2_conn->cbs.rx_comp_cb(p_ll2_conn->cbs.cookie,
412 &data);
413
414 OSAL_SPIN_LOCK_IRQSAVE(&p_rx->lock, *p_lock_flags);
415
416 return ECORE_SUCCESS;
417 }
418
ecore_ll2_rxq_completion(struct ecore_hwfn * p_hwfn,void * cookie)419 static enum _ecore_status_t ecore_ll2_rxq_completion(struct ecore_hwfn *p_hwfn,
420 void *cookie)
421 {
422 struct ecore_ll2_info *p_ll2_conn = (struct ecore_ll2_info*)cookie;
423 struct ecore_ll2_rx_queue *p_rx = &p_ll2_conn->rx_queue;
424 union core_rx_cqe_union *cqe = OSAL_NULL;
425 u16 cq_new_idx = 0, cq_old_idx = 0;
426 unsigned long flags = 0;
427 enum _ecore_status_t rc = ECORE_SUCCESS;
428
429 OSAL_SPIN_LOCK_IRQSAVE(&p_rx->lock, flags);
430 cq_new_idx = OSAL_LE16_TO_CPU(*p_rx->p_fw_cons);
431 cq_old_idx = ecore_chain_get_cons_idx(&p_rx->rcq_chain);
432
433 while (cq_new_idx != cq_old_idx) {
434 bool b_last_cqe = (cq_new_idx == cq_old_idx);
435
436 cqe = (union core_rx_cqe_union *)ecore_chain_consume(&p_rx->rcq_chain);
437 cq_old_idx = ecore_chain_get_cons_idx(&p_rx->rcq_chain);
438
439 DP_VERBOSE(p_hwfn, ECORE_MSG_LL2,
440 "LL2 [sw. cons %04x, fw. at %04x] - Got Packet of type %02x\n",
441 cq_old_idx, cq_new_idx, cqe->rx_cqe_sp.type);
442
443 switch (cqe->rx_cqe_sp.type) {
444 case CORE_RX_CQE_TYPE_SLOW_PATH:
445 rc = ecore_ll2_handle_slowpath(p_hwfn, p_ll2_conn,
446 cqe, &flags);
447 break;
448 case CORE_RX_CQE_TYPE_GSI_OFFLOAD:
449 case CORE_RX_CQE_TYPE_REGULAR:
450 rc = ecore_ll2_rxq_handle_completion(p_hwfn, p_ll2_conn,
451 cqe, &flags,
452 b_last_cqe);
453 break;
454 default:
455 rc = ECORE_IO;
456 }
457 }
458
459 OSAL_SPIN_UNLOCK_IRQSAVE(&p_rx->lock, flags);
460 return rc;
461 }
462
ecore_ll2_rxq_flush(struct ecore_hwfn * p_hwfn,u8 connection_handle)463 static void ecore_ll2_rxq_flush(struct ecore_hwfn *p_hwfn,
464 u8 connection_handle)
465 {
466 struct ecore_ll2_info *p_ll2_conn = OSAL_NULL;
467 struct ecore_ll2_rx_packet *p_pkt = OSAL_NULL;
468 struct ecore_ll2_rx_queue *p_rx;
469 unsigned long flags = 0;
470
471 p_ll2_conn = ecore_ll2_handle_sanity_inactive(p_hwfn,
472 connection_handle);
473 if (p_ll2_conn == OSAL_NULL)
474 return;
475 p_rx = &p_ll2_conn->rx_queue;
476
477 OSAL_SPIN_LOCK_IRQSAVE(&p_rx->lock, flags);
478 while (!OSAL_LIST_IS_EMPTY(&p_rx->active_descq)) {
479 bool b_last;
480 p_pkt = OSAL_LIST_FIRST_ENTRY(&p_rx->active_descq,
481 struct ecore_ll2_rx_packet,
482 list_entry);
483 if (p_pkt == OSAL_NULL)
484 break;
485 #if defined(_NTDDK_)
486 #pragma warning(suppress : 6011 28182)
487 #endif
488 OSAL_LIST_REMOVE_ENTRY(&p_pkt->list_entry,
489 &p_rx->active_descq);
490 OSAL_LIST_PUSH_TAIL(&p_pkt->list_entry,
491 &p_rx->free_descq);
492 b_last = OSAL_LIST_IS_EMPTY(&p_rx->active_descq);
493 OSAL_SPIN_UNLOCK_IRQSAVE(&p_rx->lock, flags);
494
495 if (p_ll2_conn->input.conn_type == ECORE_LL2_TYPE_OOO) {
496 struct ecore_ooo_buffer *p_buffer;
497
498 p_buffer = (struct ecore_ooo_buffer *)p_pkt->cookie;
499 ecore_ooo_put_free_buffer(p_hwfn->p_ooo_info, p_buffer);
500 } else {
501 dma_addr_t rx_buf_addr = p_pkt->rx_buf_addr;
502 void *cookie = p_pkt->cookie;
503
504 p_ll2_conn->cbs.rx_release_cb(p_ll2_conn->cbs.cookie,
505 p_ll2_conn->my_id,
506 cookie,
507 rx_buf_addr,
508 b_last);
509 }
510 OSAL_SPIN_LOCK_IRQSAVE(&p_rx->lock, flags);
511 }
512 OSAL_SPIN_UNLOCK_IRQSAVE(&p_rx->lock, flags);
513 }
514
515 static bool
ecore_ll2_lb_rxq_handler_slowpath(struct ecore_hwfn * p_hwfn,struct core_rx_slow_path_cqe * p_cqe)516 ecore_ll2_lb_rxq_handler_slowpath(struct ecore_hwfn *p_hwfn,
517 struct core_rx_slow_path_cqe *p_cqe)
518 {
519 struct ooo_opaque *iscsi_ooo;
520 u32 cid;
521
522 if (p_cqe->ramrod_cmd_id != CORE_RAMROD_RX_QUEUE_FLUSH)
523 return false;
524
525 iscsi_ooo = (struct ooo_opaque *)&p_cqe->opaque_data;
526 if (iscsi_ooo->ooo_opcode != TCP_EVENT_DELETE_ISLES)
527 return false;
528
529 /* Need to make a flush */
530 cid = OSAL_LE32_TO_CPU(iscsi_ooo->cid);
531 ecore_ooo_release_connection_isles(p_hwfn->p_ooo_info, cid);
532
533 return true;
534 }
535
536 static enum _ecore_status_t
ecore_ll2_lb_rxq_handler(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)537 ecore_ll2_lb_rxq_handler(struct ecore_hwfn *p_hwfn,
538 struct ecore_ll2_info *p_ll2_conn)
539 {
540 struct ecore_ll2_rx_queue *p_rx = &p_ll2_conn->rx_queue;
541 u16 packet_length = 0, parse_flags = 0, vlan = 0;
542 struct ecore_ll2_rx_packet *p_pkt = OSAL_NULL;
543 u32 cid;
544 union core_rx_cqe_union *cqe = OSAL_NULL;
545 u16 cq_new_idx = 0, cq_old_idx = 0;
546 struct ecore_ooo_buffer *p_buffer;
547 struct ooo_opaque *iscsi_ooo;
548 u8 placement_offset = 0;
549 u8 cqe_type;
550
551 cq_new_idx = OSAL_LE16_TO_CPU(*p_rx->p_fw_cons);
552 cq_old_idx = ecore_chain_get_cons_idx(&p_rx->rcq_chain);
553 if (cq_new_idx == cq_old_idx)
554 return ECORE_SUCCESS;
555
556 while (cq_new_idx != cq_old_idx) {
557 struct core_rx_fast_path_cqe *p_cqe_fp;
558
559 cqe = (union core_rx_cqe_union *)ecore_chain_consume(&p_rx->rcq_chain);
560 cq_old_idx = ecore_chain_get_cons_idx(&p_rx->rcq_chain);
561 cqe_type = cqe->rx_cqe_sp.type;
562
563 if (cqe_type == CORE_RX_CQE_TYPE_SLOW_PATH)
564 if (ecore_ll2_lb_rxq_handler_slowpath(p_hwfn,
565 &cqe->rx_cqe_sp))
566 continue;
567
568 if (cqe_type != CORE_RX_CQE_TYPE_REGULAR) {
569 DP_NOTICE(p_hwfn, true,
570 "Got a non-regular LB LL2 completion [type 0x%02x]\n",
571 cqe_type);
572 return ECORE_INVAL;
573 }
574 p_cqe_fp = &cqe->rx_cqe_fp;
575
576 placement_offset = p_cqe_fp->placement_offset;
577 parse_flags = OSAL_LE16_TO_CPU(p_cqe_fp->parse_flags.flags);
578 packet_length = OSAL_LE16_TO_CPU(p_cqe_fp->packet_length);
579 vlan = OSAL_LE16_TO_CPU(p_cqe_fp->vlan);
580 iscsi_ooo = (struct ooo_opaque *)&p_cqe_fp->opaque_data;
581 ecore_ooo_save_history_entry(p_hwfn->p_ooo_info, iscsi_ooo);
582 cid = OSAL_LE32_TO_CPU(iscsi_ooo->cid);
583
584 /* Process delete isle first*/
585 if (iscsi_ooo->drop_size)
586 ecore_ooo_delete_isles(p_hwfn, p_hwfn->p_ooo_info, cid,
587 iscsi_ooo->drop_isle,
588 iscsi_ooo->drop_size);
589
590 if (iscsi_ooo->ooo_opcode == TCP_EVENT_NOP)
591 continue;
592
593 /* Now process create/add/join isles */
594 if (OSAL_LIST_IS_EMPTY(&p_rx->active_descq)) {
595 DP_NOTICE(p_hwfn, true,
596 "LL2 OOO RX chain has no submitted buffers\n");
597 return ECORE_IO;
598 }
599
600 p_pkt = OSAL_LIST_FIRST_ENTRY(&p_rx->active_descq,
601 struct ecore_ll2_rx_packet,
602 list_entry);
603
604 if ((iscsi_ooo->ooo_opcode == TCP_EVENT_ADD_NEW_ISLE) ||
605 (iscsi_ooo->ooo_opcode == TCP_EVENT_ADD_ISLE_RIGHT) ||
606 (iscsi_ooo->ooo_opcode == TCP_EVENT_ADD_ISLE_LEFT) ||
607 (iscsi_ooo->ooo_opcode == TCP_EVENT_ADD_PEN) ||
608 (iscsi_ooo->ooo_opcode == TCP_EVENT_JOIN)) {
609 if (!p_pkt) {
610 DP_NOTICE(p_hwfn, true,
611 "LL2 OOO RX packet is not valid\n");
612 return ECORE_IO;
613 }
614 #if defined(_NTDDK_)
615 #pragma warning(suppress : 6011 28182)
616 #endif
617 OSAL_LIST_REMOVE_ENTRY(&p_pkt->list_entry,
618 &p_rx->active_descq);
619 p_buffer = (struct ecore_ooo_buffer *)p_pkt->cookie;
620 p_buffer->packet_length = packet_length;
621 p_buffer->parse_flags = parse_flags;
622 p_buffer->vlan = vlan;
623 p_buffer->placement_offset = placement_offset;
624 if (ecore_chain_consume(&p_rx->rxq_chain) !=
625 p_pkt->rxq_bd) {
626 /**/
627 }
628 ecore_ooo_dump_rx_event(p_hwfn, iscsi_ooo, p_buffer);
629 OSAL_LIST_PUSH_TAIL(&p_pkt->list_entry,
630 &p_rx->free_descq);
631
632 switch (iscsi_ooo->ooo_opcode) {
633 case TCP_EVENT_ADD_NEW_ISLE:
634 ecore_ooo_add_new_isle(p_hwfn,
635 p_hwfn->p_ooo_info,
636 cid,
637 iscsi_ooo->ooo_isle,
638 p_buffer);
639 break;
640 case TCP_EVENT_ADD_ISLE_RIGHT:
641 ecore_ooo_add_new_buffer(p_hwfn,
642 p_hwfn->p_ooo_info,
643 cid,
644 iscsi_ooo->ooo_isle,
645 p_buffer,
646 ECORE_OOO_RIGHT_BUF);
647 break;
648 case TCP_EVENT_ADD_ISLE_LEFT:
649 ecore_ooo_add_new_buffer(p_hwfn,
650 p_hwfn->p_ooo_info,
651 cid,
652 iscsi_ooo->ooo_isle,
653 p_buffer,
654 ECORE_OOO_LEFT_BUF);
655 break;
656 case TCP_EVENT_JOIN:
657 ecore_ooo_add_new_buffer(p_hwfn,
658 p_hwfn->p_ooo_info,
659 cid,
660 iscsi_ooo->ooo_isle +
661 1,
662 p_buffer,
663 ECORE_OOO_LEFT_BUF);
664 ecore_ooo_join_isles(p_hwfn,
665 p_hwfn->p_ooo_info,
666 cid,
667 iscsi_ooo->ooo_isle);
668 break;
669 case TCP_EVENT_ADD_PEN:
670 ecore_ooo_put_ready_buffer(p_hwfn->p_ooo_info,
671 p_buffer, true);
672 break;
673 }
674 } else {
675 DP_NOTICE(p_hwfn, true,
676 "Unexpected event (%d) TX OOO completion\n",
677 iscsi_ooo->ooo_opcode);
678 }
679 }
680
681 return ECORE_SUCCESS;
682 }
683
684 static void
ecore_ooo_submit_tx_buffers(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)685 ecore_ooo_submit_tx_buffers(struct ecore_hwfn *p_hwfn,
686 struct ecore_ll2_info *p_ll2_conn)
687 {
688 struct ecore_ll2_tx_pkt_info tx_pkt;
689 struct ecore_ooo_buffer *p_buffer;
690 dma_addr_t first_frag;
691 u16 l4_hdr_offset_w;
692 u8 bd_flags;
693 enum _ecore_status_t rc;
694
695 /* Submit Tx buffers here */
696 while ((p_buffer = ecore_ooo_get_ready_buffer(p_hwfn->p_ooo_info))) {
697 l4_hdr_offset_w = 0;
698 bd_flags = 0;
699
700 first_frag = p_buffer->rx_buffer_phys_addr +
701 p_buffer->placement_offset;
702 SET_FIELD(bd_flags, CORE_TX_BD_DATA_FORCE_VLAN_MODE, 1);
703 SET_FIELD(bd_flags, CORE_TX_BD_DATA_L4_PROTOCOL, 1);
704
705 OSAL_MEM_ZERO(&tx_pkt, sizeof(tx_pkt));
706 tx_pkt.num_of_bds = 1;
707 tx_pkt.vlan = p_buffer->vlan;
708 tx_pkt.bd_flags = bd_flags;
709 tx_pkt.l4_hdr_offset_w = l4_hdr_offset_w;
710 tx_pkt.tx_dest = (enum ecore_ll2_tx_dest)p_ll2_conn->tx_dest;
711 tx_pkt.first_frag = first_frag;
712 tx_pkt.first_frag_len = p_buffer->packet_length;
713 tx_pkt.cookie = p_buffer;
714
715 rc = ecore_ll2_prepare_tx_packet(p_hwfn, p_ll2_conn->my_id,
716 &tx_pkt, true);
717 if (rc != ECORE_SUCCESS) {
718 ecore_ooo_put_ready_buffer(p_hwfn->p_ooo_info,
719 p_buffer, false);
720 break;
721 }
722 }
723 }
724
725 static void
ecore_ooo_submit_rx_buffers(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)726 ecore_ooo_submit_rx_buffers(struct ecore_hwfn *p_hwfn,
727 struct ecore_ll2_info *p_ll2_conn)
728 {
729 struct ecore_ooo_buffer *p_buffer;
730 enum _ecore_status_t rc;
731
732 while ((p_buffer = ecore_ooo_get_free_buffer(p_hwfn->p_ooo_info))) {
733 rc = ecore_ll2_post_rx_buffer(p_hwfn,
734 p_ll2_conn->my_id,
735 p_buffer->rx_buffer_phys_addr,
736 0, p_buffer, true);
737 if (rc != ECORE_SUCCESS) {
738 ecore_ooo_put_free_buffer(p_hwfn->p_ooo_info, p_buffer);
739 break;
740 }
741 }
742 }
743
744 static enum _ecore_status_t
ecore_ll2_lb_rxq_completion(struct ecore_hwfn * p_hwfn,void * p_cookie)745 ecore_ll2_lb_rxq_completion(struct ecore_hwfn *p_hwfn,
746 void *p_cookie)
747 {
748 struct ecore_ll2_info *p_ll2_conn = (struct ecore_ll2_info *)p_cookie;
749 enum _ecore_status_t rc;
750
751 rc = ecore_ll2_lb_rxq_handler(p_hwfn, p_ll2_conn);
752 if (rc != ECORE_SUCCESS)
753 return rc;
754
755 ecore_ooo_submit_rx_buffers(p_hwfn, p_ll2_conn);
756 ecore_ooo_submit_tx_buffers(p_hwfn, p_ll2_conn);
757
758 return 0;
759 }
760
761 static enum _ecore_status_t
ecore_ll2_lb_txq_completion(struct ecore_hwfn * p_hwfn,void * p_cookie)762 ecore_ll2_lb_txq_completion(struct ecore_hwfn *p_hwfn,
763 void *p_cookie)
764 {
765 struct ecore_ll2_info *p_ll2_conn = (struct ecore_ll2_info *)p_cookie;
766 struct ecore_ll2_tx_queue *p_tx = &p_ll2_conn->tx_queue;
767 struct ecore_ll2_tx_packet *p_pkt = OSAL_NULL;
768 struct ecore_ooo_buffer *p_buffer;
769 bool b_dont_submit_rx = false;
770 u16 new_idx = 0, num_bds = 0;
771 enum _ecore_status_t rc;
772
773 new_idx = OSAL_LE16_TO_CPU(*p_tx->p_fw_cons);
774 num_bds = ((s16)new_idx - (s16)p_tx->bds_idx);
775
776 if (!num_bds)
777 return ECORE_SUCCESS;
778
779 while (num_bds) {
780 if (OSAL_LIST_IS_EMPTY(&p_tx->active_descq))
781 return ECORE_INVAL;
782
783 p_pkt = OSAL_LIST_FIRST_ENTRY(&p_tx->active_descq,
784 struct ecore_ll2_tx_packet,
785 list_entry);
786 if (!p_pkt)
787 return ECORE_INVAL;
788
789 if (p_pkt->bd_used != 1) {
790 DP_NOTICE(p_hwfn, true,
791 "Unexpectedly many BDs(%d) in TX OOO completion\n",
792 p_pkt->bd_used);
793 return ECORE_INVAL;
794 }
795
796 OSAL_LIST_REMOVE_ENTRY(&p_pkt->list_entry,
797 &p_tx->active_descq);
798
799 num_bds--;
800 p_tx->bds_idx++;
801 ecore_chain_consume(&p_tx->txq_chain);
802
803 p_buffer = (struct ecore_ooo_buffer *)p_pkt->cookie;
804 OSAL_LIST_PUSH_TAIL(&p_pkt->list_entry,
805 &p_tx->free_descq);
806
807 if (b_dont_submit_rx) {
808 ecore_ooo_put_free_buffer(p_hwfn->p_ooo_info, p_buffer);
809 continue;
810 }
811
812 rc = ecore_ll2_post_rx_buffer(p_hwfn, p_ll2_conn->my_id,
813 p_buffer->rx_buffer_phys_addr, 0,
814 p_buffer, true);
815 if (rc != ECORE_SUCCESS) {
816 ecore_ooo_put_free_buffer(p_hwfn->p_ooo_info, p_buffer);
817 b_dont_submit_rx = true;
818 }
819 }
820
821 ecore_ooo_submit_tx_buffers(p_hwfn, p_ll2_conn);
822
823 return ECORE_SUCCESS;
824 }
825
ecore_sp_ll2_rx_queue_start(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn,u8 action_on_error)826 static enum _ecore_status_t ecore_sp_ll2_rx_queue_start(struct ecore_hwfn *p_hwfn,
827 struct ecore_ll2_info *p_ll2_conn,
828 u8 action_on_error)
829 {
830 enum ecore_ll2_conn_type conn_type = p_ll2_conn->input.conn_type;
831 struct ecore_ll2_rx_queue *p_rx = &p_ll2_conn->rx_queue;
832 struct core_rx_start_ramrod_data *p_ramrod = OSAL_NULL;
833 struct ecore_spq_entry *p_ent = OSAL_NULL;
834 struct ecore_sp_init_data init_data;
835 u16 cqe_pbl_size;
836 enum _ecore_status_t rc = ECORE_SUCCESS;
837
838 /* Get SPQ entry */
839 OSAL_MEMSET(&init_data, 0, sizeof(init_data));
840 init_data.cid = p_ll2_conn->cid;
841 init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
842 init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
843
844 rc = ecore_sp_init_request(p_hwfn, &p_ent,
845 CORE_RAMROD_RX_QUEUE_START,
846 PROTOCOLID_CORE, &init_data);
847 if (rc != ECORE_SUCCESS)
848 return rc;
849
850 p_ramrod = &p_ent->ramrod.core_rx_queue_start;
851
852 p_ramrod->sb_id = OSAL_CPU_TO_LE16(ecore_int_get_sp_sb_id(p_hwfn));
853 p_ramrod->sb_index = p_rx->rx_sb_index;
854 p_ramrod->complete_event_flg = 1;
855
856 p_ramrod->mtu = OSAL_CPU_TO_LE16(p_ll2_conn->input.mtu);
857 DMA_REGPAIR_LE(p_ramrod->bd_base,
858 p_rx->rxq_chain.p_phys_addr);
859 cqe_pbl_size = (u16)ecore_chain_get_page_cnt(&p_rx->rcq_chain);
860 p_ramrod->num_of_pbl_pages = OSAL_CPU_TO_LE16(cqe_pbl_size);
861 DMA_REGPAIR_LE(p_ramrod->cqe_pbl_addr,
862 ecore_chain_get_pbl_phys(&p_rx->rcq_chain));
863
864 p_ramrod->drop_ttl0_flg = p_ll2_conn->input.rx_drop_ttl0_flg;
865 p_ramrod->inner_vlan_stripping_en =
866 p_ll2_conn->input.rx_vlan_removal_en;
867
868 if (OSAL_TEST_BIT(ECORE_MF_UFP_SPECIFIC, &p_hwfn->p_dev->mf_bits) &&
869 (p_ll2_conn->input.conn_type == ECORE_LL2_TYPE_FCOE))
870 p_ramrod->report_outer_vlan = 1;
871 p_ramrod->queue_id = p_ll2_conn->queue_id;
872 p_ramrod->main_func_queue = p_ll2_conn->main_func_queue;
873
874 if (OSAL_TEST_BIT(ECORE_MF_LL2_NON_UNICAST,
875 &p_hwfn->p_dev->mf_bits) &&
876 p_ramrod->main_func_queue &&
877 ((conn_type != ECORE_LL2_TYPE_ROCE) &&
878 (conn_type != ECORE_LL2_TYPE_IWARP))) {
879 p_ramrod->mf_si_bcast_accept_all = 1;
880 p_ramrod->mf_si_mcast_accept_all = 1;
881 } else {
882 p_ramrod->mf_si_bcast_accept_all = 0;
883 p_ramrod->mf_si_mcast_accept_all = 0;
884 }
885
886 p_ramrod->action_on_error.error_type = action_on_error;
887 p_ramrod->gsi_offload_flag = p_ll2_conn->input.gsi_enable;
888 return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
889 }
890
ecore_sp_ll2_tx_queue_start(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)891 static enum _ecore_status_t ecore_sp_ll2_tx_queue_start(struct ecore_hwfn *p_hwfn,
892 struct ecore_ll2_info *p_ll2_conn)
893 {
894 enum ecore_ll2_conn_type conn_type = p_ll2_conn->input.conn_type;
895 struct ecore_ll2_tx_queue *p_tx = &p_ll2_conn->tx_queue;
896 struct core_tx_start_ramrod_data *p_ramrod = OSAL_NULL;
897 struct ecore_spq_entry *p_ent = OSAL_NULL;
898 struct ecore_sp_init_data init_data;
899 u16 pq_id = 0, pbl_size;
900 enum _ecore_status_t rc = ECORE_NOTIMPL;
901
902 if (!ECORE_LL2_TX_REGISTERED(p_ll2_conn))
903 return ECORE_SUCCESS;
904
905 if (p_ll2_conn->input.conn_type == ECORE_LL2_TYPE_OOO)
906 p_ll2_conn->tx_stats_en = 0;
907 else
908 p_ll2_conn->tx_stats_en = 1;
909
910 /* Get SPQ entry */
911 OSAL_MEMSET(&init_data, 0, sizeof(init_data));
912 init_data.cid = p_ll2_conn->cid;
913 init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
914 init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
915
916 rc = ecore_sp_init_request(p_hwfn, &p_ent,
917 CORE_RAMROD_TX_QUEUE_START,
918 PROTOCOLID_CORE, &init_data);
919 if (rc != ECORE_SUCCESS)
920 return rc;
921
922 p_ramrod = &p_ent->ramrod.core_tx_queue_start;
923
924 p_ramrod->sb_id = OSAL_CPU_TO_LE16(ecore_int_get_sp_sb_id(p_hwfn));
925 p_ramrod->sb_index = p_tx->tx_sb_index;
926 p_ramrod->mtu = OSAL_CPU_TO_LE16(p_ll2_conn->input.mtu);
927 p_ramrod->stats_en = p_ll2_conn->tx_stats_en;
928 p_ramrod->stats_id = p_ll2_conn->tx_stats_id;
929
930 DMA_REGPAIR_LE(p_ramrod->pbl_base_addr,
931 ecore_chain_get_pbl_phys(&p_tx->txq_chain));
932 pbl_size = (u16)ecore_chain_get_page_cnt(&p_tx->txq_chain);
933 p_ramrod->pbl_size = OSAL_CPU_TO_LE16(pbl_size);
934
935 /* TODO RESC_ALLOC pq for ll2 */
936 switch (p_ll2_conn->input.tx_tc) {
937 case PURE_LB_TC:
938 pq_id = ecore_get_cm_pq_idx(p_hwfn, PQ_FLAGS_LB);
939 break;
940 case PKT_LB_TC:
941 pq_id = ecore_get_cm_pq_idx(p_hwfn, PQ_FLAGS_OOO);
942 break;
943 default:
944 pq_id = ecore_get_cm_pq_idx(p_hwfn, PQ_FLAGS_OFLD);
945 }
946
947 p_ramrod->qm_pq_id = OSAL_CPU_TO_LE16(pq_id);
948
949 switch (conn_type) {
950 case ECORE_LL2_TYPE_FCOE:
951 p_ramrod->conn_type = PROTOCOLID_FCOE;
952 break;
953 case ECORE_LL2_TYPE_ISCSI:
954 p_ramrod->conn_type = PROTOCOLID_ISCSI;
955 break;
956 case ECORE_LL2_TYPE_ROCE:
957 p_ramrod->conn_type = PROTOCOLID_ROCE;
958 break;
959 case ECORE_LL2_TYPE_IWARP:
960 p_ramrod->conn_type = PROTOCOLID_IWARP;
961 break;
962 case ECORE_LL2_TYPE_OOO:
963 if (p_hwfn->hw_info.personality == ECORE_PCI_ISCSI) {
964 p_ramrod->conn_type = PROTOCOLID_ISCSI;
965 } else {
966 p_ramrod->conn_type = PROTOCOLID_IWARP;
967 }
968 break;
969 default:
970 p_ramrod->conn_type = PROTOCOLID_ETH;
971 DP_NOTICE(p_hwfn, false, "Unknown connection type: %d\n",
972 conn_type);
973 }
974
975 p_ramrod->gsi_offload_flag = p_ll2_conn->input.gsi_enable;
976
977 rc = ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
978 if (rc != ECORE_SUCCESS)
979 return rc;
980
981 rc = ecore_db_recovery_add(p_hwfn->p_dev, p_tx->doorbell_addr,
982 &p_tx->db_msg, DB_REC_WIDTH_32B,
983 DB_REC_KERNEL);
984 return rc;
985 }
986
ecore_sp_ll2_rx_queue_stop(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)987 static enum _ecore_status_t ecore_sp_ll2_rx_queue_stop(struct ecore_hwfn *p_hwfn,
988 struct ecore_ll2_info *p_ll2_conn)
989 {
990 struct core_rx_stop_ramrod_data *p_ramrod = OSAL_NULL;
991 struct ecore_spq_entry *p_ent = OSAL_NULL;
992 struct ecore_sp_init_data init_data;
993 enum _ecore_status_t rc = ECORE_NOTIMPL;
994
995 /* Get SPQ entry */
996 OSAL_MEMSET(&init_data, 0, sizeof(init_data));
997 init_data.cid = p_ll2_conn->cid;
998 init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
999 init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
1000
1001 rc = ecore_sp_init_request(p_hwfn, &p_ent,
1002 CORE_RAMROD_RX_QUEUE_STOP,
1003 PROTOCOLID_CORE, &init_data);
1004 if (rc != ECORE_SUCCESS)
1005 return rc;
1006
1007 p_ramrod = &p_ent->ramrod.core_rx_queue_stop;
1008
1009 p_ramrod->complete_event_flg = 1;
1010 p_ramrod->queue_id = p_ll2_conn->queue_id;
1011
1012 return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
1013 }
1014
ecore_sp_ll2_tx_queue_stop(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)1015 static enum _ecore_status_t ecore_sp_ll2_tx_queue_stop(struct ecore_hwfn *p_hwfn,
1016 struct ecore_ll2_info *p_ll2_conn)
1017 {
1018 struct ecore_ll2_tx_queue *p_tx = &p_ll2_conn->tx_queue;
1019 struct ecore_spq_entry *p_ent = OSAL_NULL;
1020 struct ecore_sp_init_data init_data;
1021 enum _ecore_status_t rc = ECORE_NOTIMPL;
1022
1023 ecore_db_recovery_del(p_hwfn->p_dev, p_tx->doorbell_addr,
1024 &p_tx->db_msg);
1025
1026 /* Get SPQ entry */
1027 OSAL_MEMSET(&init_data, 0, sizeof(init_data));
1028 init_data.cid = p_ll2_conn->cid;
1029 init_data.opaque_fid = p_hwfn->hw_info.opaque_fid;
1030 init_data.comp_mode = ECORE_SPQ_MODE_EBLOCK;
1031
1032 rc = ecore_sp_init_request(p_hwfn, &p_ent,
1033 CORE_RAMROD_TX_QUEUE_STOP,
1034 PROTOCOLID_CORE, &init_data);
1035 if (rc != ECORE_SUCCESS)
1036 return rc;
1037
1038 return ecore_spq_post(p_hwfn, p_ent, OSAL_NULL);
1039 }
1040
1041 static enum _ecore_status_t
ecore_ll2_acquire_connection_rx(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_info)1042 ecore_ll2_acquire_connection_rx(struct ecore_hwfn *p_hwfn,
1043 struct ecore_ll2_info *p_ll2_info)
1044 {
1045 struct ecore_ll2_rx_packet *p_descq;
1046 u32 capacity;
1047 enum _ecore_status_t rc = ECORE_SUCCESS;
1048
1049 if (!p_ll2_info->input.rx_num_desc)
1050 goto out;
1051
1052 rc = ecore_chain_alloc(p_hwfn->p_dev,
1053 ECORE_CHAIN_USE_TO_CONSUME_PRODUCE,
1054 ECORE_CHAIN_MODE_NEXT_PTR,
1055 ECORE_CHAIN_CNT_TYPE_U16,
1056 p_ll2_info->input.rx_num_desc,
1057 sizeof(struct core_rx_bd),
1058 &p_ll2_info->rx_queue.rxq_chain, OSAL_NULL);
1059 if (rc) {
1060 DP_NOTICE(p_hwfn, false,
1061 "Failed to allocate ll2 rxq chain\n");
1062 goto out;
1063 }
1064
1065 capacity = ecore_chain_get_capacity(&p_ll2_info->rx_queue.rxq_chain);
1066 p_descq = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL,
1067 capacity * sizeof(struct ecore_ll2_rx_packet));
1068 if (!p_descq) {
1069 rc = ECORE_NOMEM;
1070 DP_NOTICE(p_hwfn, false,
1071 "Failed to allocate ll2 Rx desc\n");
1072 goto out;
1073 }
1074 p_ll2_info->rx_queue.descq_array = p_descq;
1075
1076 rc = ecore_chain_alloc(p_hwfn->p_dev,
1077 ECORE_CHAIN_USE_TO_CONSUME_PRODUCE,
1078 ECORE_CHAIN_MODE_PBL,
1079 ECORE_CHAIN_CNT_TYPE_U16,
1080 p_ll2_info->input.rx_num_desc,
1081 sizeof(struct core_rx_fast_path_cqe),
1082 &p_ll2_info->rx_queue.rcq_chain, OSAL_NULL);
1083 if (rc != ECORE_SUCCESS) {
1084 DP_NOTICE(p_hwfn, false,
1085 "Failed to allocate ll2 rcq chain\n");
1086 goto out;
1087 }
1088
1089 DP_VERBOSE(p_hwfn, ECORE_MSG_LL2,
1090 "Allocated LL2 Rxq [Type %08x] with 0x%08x buffers\n",
1091 p_ll2_info->input.conn_type,
1092 p_ll2_info->input.rx_num_desc);
1093
1094 out:
1095 return rc;
1096 }
1097
1098 static enum _ecore_status_t
ecore_ll2_acquire_connection_tx(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_info)1099 ecore_ll2_acquire_connection_tx(struct ecore_hwfn *p_hwfn,
1100 struct ecore_ll2_info *p_ll2_info)
1101 {
1102 struct ecore_ll2_tx_packet *p_descq;
1103 u32 capacity;
1104 enum _ecore_status_t rc = ECORE_SUCCESS;
1105 u32 desc_size;
1106
1107 if (!p_ll2_info->input.tx_num_desc)
1108 goto out;
1109
1110 rc = ecore_chain_alloc(p_hwfn->p_dev,
1111 ECORE_CHAIN_USE_TO_CONSUME_PRODUCE,
1112 ECORE_CHAIN_MODE_PBL,
1113 ECORE_CHAIN_CNT_TYPE_U16,
1114 p_ll2_info->input.tx_num_desc,
1115 sizeof(struct core_tx_bd),
1116 &p_ll2_info->tx_queue.txq_chain, OSAL_NULL);
1117 if (rc != ECORE_SUCCESS)
1118 goto out;
1119
1120 capacity = ecore_chain_get_capacity(&p_ll2_info->tx_queue.txq_chain);
1121 desc_size = (sizeof(*p_descq) +
1122 (p_ll2_info->input.tx_max_bds_per_packet - 1) *
1123 sizeof(p_descq->bds_set));
1124
1125 p_descq = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL,
1126 capacity * desc_size);
1127 if (!p_descq) {
1128 rc = ECORE_NOMEM;
1129 goto out;
1130 }
1131 p_ll2_info->tx_queue.descq_array = p_descq;
1132
1133 DP_VERBOSE(p_hwfn, ECORE_MSG_LL2,
1134 "Allocated LL2 Txq [Type %08x] with 0x%08x buffers\n",
1135 p_ll2_info->input.conn_type,
1136 p_ll2_info->input.tx_num_desc);
1137
1138 out:
1139 if (rc != ECORE_SUCCESS)
1140 DP_NOTICE(p_hwfn, false,
1141 "Can't allocate memory for Tx LL2 with 0x%08x buffers\n",
1142 p_ll2_info->input.tx_num_desc);
1143 return rc;
1144 }
1145
1146 static enum _ecore_status_t
ecore_ll2_acquire_connection_ooo(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_info,u16 mtu)1147 ecore_ll2_acquire_connection_ooo(struct ecore_hwfn *p_hwfn,
1148 struct ecore_ll2_info *p_ll2_info, u16 mtu)
1149 {
1150 struct ecore_ooo_buffer *p_buf = OSAL_NULL;
1151 u32 rx_buffer_size = 0;
1152 void *p_virt;
1153 u16 buf_idx;
1154 enum _ecore_status_t rc = ECORE_SUCCESS;
1155
1156 if (p_ll2_info->input.conn_type != ECORE_LL2_TYPE_OOO)
1157 return rc;
1158
1159 /* Correct number of requested OOO buffers if needed */
1160 if (!p_ll2_info->input.rx_num_ooo_buffers) {
1161 u16 num_desc = p_ll2_info->input.rx_num_desc;
1162
1163 if (!num_desc)
1164 return ECORE_INVAL;
1165 p_ll2_info->input.rx_num_ooo_buffers = num_desc * 2;
1166 }
1167
1168 /* TODO - use some defines for buffer size */
1169 rx_buffer_size = mtu + 14 + 4 + 8 + ETH_CACHE_LINE_SIZE;
1170 rx_buffer_size = (rx_buffer_size + ETH_CACHE_LINE_SIZE - 1) &
1171 ~(ETH_CACHE_LINE_SIZE - 1);
1172
1173 for (buf_idx = 0; buf_idx < p_ll2_info->input.rx_num_ooo_buffers;
1174 buf_idx++) {
1175 p_buf = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL, sizeof(*p_buf));
1176 if (!p_buf) {
1177 DP_NOTICE(p_hwfn, false,
1178 "Failed to allocate ooo descriptor\n");
1179 rc = ECORE_NOMEM;
1180 goto out;
1181 }
1182
1183 p_buf->rx_buffer_size = rx_buffer_size;
1184 p_virt = OSAL_DMA_ALLOC_COHERENT(p_hwfn->p_dev,
1185 &p_buf->rx_buffer_phys_addr,
1186 p_buf->rx_buffer_size);
1187 if (!p_virt) {
1188 DP_NOTICE(p_hwfn, false,
1189 "Failed to allocate ooo buffer\n");
1190 OSAL_FREE(p_hwfn->p_dev, p_buf);
1191 rc = ECORE_NOMEM;
1192 goto out;
1193 }
1194 p_buf->rx_buffer_virt_addr = p_virt;
1195 ecore_ooo_put_free_buffer(p_hwfn->p_ooo_info, p_buf);
1196 }
1197
1198 DP_VERBOSE(p_hwfn, ECORE_MSG_LL2,
1199 "Allocated [%04x] LL2 OOO buffers [each of size 0x%08x]\n",
1200 p_ll2_info->input.rx_num_ooo_buffers, rx_buffer_size);
1201
1202 out:
1203 return rc;
1204 }
1205
1206 static enum _ecore_status_t
ecore_ll2_set_cbs(struct ecore_ll2_info * p_ll2_info,const struct ecore_ll2_cbs * cbs)1207 ecore_ll2_set_cbs(struct ecore_ll2_info *p_ll2_info,
1208 const struct ecore_ll2_cbs *cbs)
1209 {
1210 if (!cbs || (!cbs->rx_comp_cb ||
1211 !cbs->rx_release_cb ||
1212 !cbs->tx_comp_cb ||
1213 !cbs->tx_release_cb ||
1214 !cbs->cookie))
1215 return ECORE_INVAL;
1216
1217 p_ll2_info->cbs.rx_comp_cb = cbs->rx_comp_cb;
1218 p_ll2_info->cbs.rx_release_cb = cbs->rx_release_cb;
1219 p_ll2_info->cbs.tx_comp_cb = cbs->tx_comp_cb;
1220 p_ll2_info->cbs.tx_release_cb = cbs->tx_release_cb;
1221 p_ll2_info->cbs.slowpath_cb = cbs->slowpath_cb;
1222 p_ll2_info->cbs.cookie = cbs->cookie;
1223
1224 return ECORE_SUCCESS;
1225 }
1226
1227 static enum core_error_handle
ecore_ll2_get_error_choice(enum ecore_ll2_error_handle err)1228 ecore_ll2_get_error_choice(enum ecore_ll2_error_handle err)
1229 {
1230 switch (err) {
1231 case ECORE_LL2_DROP_PACKET:
1232 return LL2_DROP_PACKET;
1233 case ECORE_LL2_DO_NOTHING:
1234 return LL2_DO_NOTHING;
1235 case ECORE_LL2_ASSERT:
1236 return LL2_ASSERT;
1237 default:
1238 return LL2_DO_NOTHING;
1239 }
1240 }
1241
1242 enum _ecore_status_t
ecore_ll2_acquire_connection(void * cxt,struct ecore_ll2_acquire_data * data)1243 ecore_ll2_acquire_connection(void *cxt,
1244 struct ecore_ll2_acquire_data *data)
1245 {
1246 struct ecore_hwfn *p_hwfn = (struct ecore_hwfn *)cxt;
1247 ecore_int_comp_cb_t comp_rx_cb, comp_tx_cb;
1248 struct ecore_ll2_info *p_ll2_info = OSAL_NULL;
1249 enum _ecore_status_t rc;
1250 u8 i, *p_tx_max;
1251
1252 if (!data->p_connection_handle || !p_hwfn->p_ll2_info) {
1253 DP_NOTICE(p_hwfn, false, "Invalid connection handle, ll2_info not allocated\n");
1254 return ECORE_INVAL;
1255 }
1256
1257 /* Find a free connection to be used */
1258 for (i = 0; (i < ECORE_MAX_NUM_OF_LL2_CONNECTIONS); i++) {
1259 OSAL_MUTEX_ACQUIRE(&p_hwfn->p_ll2_info[i].mutex);
1260 if (p_hwfn->p_ll2_info[i].b_active) {
1261 OSAL_MUTEX_RELEASE(&p_hwfn->p_ll2_info[i].mutex);
1262 continue;
1263 }
1264
1265 p_hwfn->p_ll2_info[i].b_active = true;
1266 p_ll2_info = &p_hwfn->p_ll2_info[i];
1267 OSAL_MUTEX_RELEASE(&p_hwfn->p_ll2_info[i].mutex);
1268 break;
1269 }
1270 if (p_ll2_info == OSAL_NULL) {
1271 DP_NOTICE(p_hwfn, false, "No available ll2 connection\n");
1272 return ECORE_BUSY;
1273 }
1274
1275 OSAL_MEMCPY(&p_ll2_info->input, &data->input,
1276 sizeof(p_ll2_info->input));
1277
1278 switch (data->input.tx_dest) {
1279 case ECORE_LL2_TX_DEST_NW:
1280 p_ll2_info->tx_dest = CORE_TX_DEST_NW;
1281 break;
1282 case ECORE_LL2_TX_DEST_LB:
1283 p_ll2_info->tx_dest = CORE_TX_DEST_LB;
1284 break;
1285 case ECORE_LL2_TX_DEST_DROP:
1286 p_ll2_info->tx_dest = CORE_TX_DEST_DROP;
1287 break;
1288 default:
1289 return ECORE_INVAL;
1290 }
1291
1292 if ((data->input.conn_type == ECORE_LL2_TYPE_OOO) ||
1293 data->input.secondary_queue)
1294 p_ll2_info->main_func_queue = false;
1295 else
1296 p_ll2_info->main_func_queue = true;
1297
1298 /* Correct maximum number of Tx BDs */
1299 p_tx_max = &p_ll2_info->input.tx_max_bds_per_packet;
1300 if (*p_tx_max == 0)
1301 *p_tx_max = CORE_LL2_TX_MAX_BDS_PER_PACKET;
1302 else
1303 *p_tx_max = OSAL_MIN_T(u8, *p_tx_max,
1304 CORE_LL2_TX_MAX_BDS_PER_PACKET);
1305
1306 rc = ecore_ll2_set_cbs(p_ll2_info, data->cbs);
1307 if (rc) {
1308 DP_NOTICE(p_hwfn, false, "Invalid callback functions\n");
1309 goto q_allocate_fail;
1310 }
1311
1312 rc = ecore_ll2_acquire_connection_rx(p_hwfn, p_ll2_info);
1313 if (rc != ECORE_SUCCESS) {
1314 DP_NOTICE(p_hwfn, false, "ll2 acquire rx connection failed\n");
1315 goto q_allocate_fail;
1316 }
1317
1318 rc = ecore_ll2_acquire_connection_tx(p_hwfn, p_ll2_info);
1319 if (rc != ECORE_SUCCESS) {
1320 DP_NOTICE(p_hwfn, false, "ll2 acquire tx connection failed\n");
1321 goto q_allocate_fail;
1322 }
1323
1324 rc = ecore_ll2_acquire_connection_ooo(p_hwfn, p_ll2_info,
1325 data->input.mtu);
1326 if (rc != ECORE_SUCCESS) {
1327 DP_NOTICE(p_hwfn, false, "ll2 acquire ooo connection failed\n");
1328 goto q_allocate_fail;
1329 }
1330
1331 /* Register callbacks for the Rx/Tx queues */
1332 if (data->input.conn_type == ECORE_LL2_TYPE_OOO) {
1333 comp_rx_cb = ecore_ll2_lb_rxq_completion;
1334 comp_tx_cb = ecore_ll2_lb_txq_completion;
1335
1336 } else {
1337 comp_rx_cb = ecore_ll2_rxq_completion;
1338 comp_tx_cb = ecore_ll2_txq_completion;
1339 }
1340
1341 if (data->input.rx_num_desc) {
1342 ecore_int_register_cb(p_hwfn, comp_rx_cb,
1343 &p_hwfn->p_ll2_info[i],
1344 &p_ll2_info->rx_queue.rx_sb_index,
1345 &p_ll2_info->rx_queue.p_fw_cons);
1346 p_ll2_info->rx_queue.b_cb_registred = true;
1347 }
1348
1349 if (data->input.tx_num_desc) {
1350 ecore_int_register_cb(p_hwfn,
1351 comp_tx_cb,
1352 &p_hwfn->p_ll2_info[i],
1353 &p_ll2_info->tx_queue.tx_sb_index,
1354 &p_ll2_info->tx_queue.p_fw_cons);
1355 p_ll2_info->tx_queue.b_cb_registred = true;
1356 }
1357
1358 *(data->p_connection_handle) = i;
1359 return rc;
1360
1361 q_allocate_fail:
1362 ecore_ll2_release_connection(p_hwfn, i);
1363 return ECORE_NOMEM;
1364 }
1365
ecore_ll2_establish_connection_rx(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)1366 static enum _ecore_status_t ecore_ll2_establish_connection_rx(struct ecore_hwfn *p_hwfn,
1367 struct ecore_ll2_info *p_ll2_conn)
1368 {
1369 enum ecore_ll2_error_handle error_input;
1370 enum core_error_handle error_mode;
1371 u8 action_on_error = 0;
1372
1373 if (!ECORE_LL2_RX_REGISTERED(p_ll2_conn))
1374 return ECORE_SUCCESS;
1375
1376 DIRECT_REG_WR(p_hwfn, p_ll2_conn->rx_queue.set_prod_addr, 0x0);
1377 error_input = p_ll2_conn->input.ai_err_packet_too_big;
1378 error_mode = ecore_ll2_get_error_choice(error_input);
1379 SET_FIELD(action_on_error,
1380 CORE_RX_ACTION_ON_ERROR_PACKET_TOO_BIG, error_mode);
1381 error_input = p_ll2_conn->input.ai_err_no_buf;
1382 error_mode = ecore_ll2_get_error_choice(error_input);
1383 SET_FIELD(action_on_error,
1384 CORE_RX_ACTION_ON_ERROR_NO_BUFF, error_mode);
1385
1386 return ecore_sp_ll2_rx_queue_start(p_hwfn, p_ll2_conn, action_on_error);
1387 }
1388
1389 static void
ecore_ll2_establish_connection_ooo(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)1390 ecore_ll2_establish_connection_ooo(struct ecore_hwfn *p_hwfn,
1391 struct ecore_ll2_info *p_ll2_conn)
1392 {
1393 if (p_ll2_conn->input.conn_type != ECORE_LL2_TYPE_OOO)
1394 return;
1395
1396 ecore_ooo_release_all_isles(p_hwfn->p_ooo_info);
1397 ecore_ooo_submit_rx_buffers(p_hwfn, p_ll2_conn);
1398 }
1399
ecore_ll2_establish_connection(void * cxt,u8 connection_handle)1400 enum _ecore_status_t ecore_ll2_establish_connection(void *cxt,
1401 u8 connection_handle)
1402 {
1403 struct ecore_hwfn *p_hwfn = (struct ecore_hwfn *)cxt;
1404 struct e4_core_conn_context *p_cxt;
1405 struct ecore_ll2_info *p_ll2_conn;
1406 struct ecore_cxt_info cxt_info;
1407 struct ecore_ll2_rx_queue *p_rx;
1408 struct ecore_ll2_tx_queue *p_tx;
1409 struct ecore_ll2_tx_packet *p_pkt;
1410 struct ecore_ptt *p_ptt;
1411 enum _ecore_status_t rc = ECORE_NOTIMPL;
1412 u32 i, capacity;
1413 u32 desc_size;
1414 u8 qid;
1415
1416 p_ptt = ecore_ptt_acquire(p_hwfn);
1417 if (!p_ptt)
1418 return ECORE_AGAIN;
1419
1420 p_ll2_conn = ecore_ll2_handle_sanity_lock(p_hwfn, connection_handle);
1421 if (p_ll2_conn == OSAL_NULL) {
1422 rc = ECORE_INVAL;
1423 goto out;
1424 }
1425
1426 p_rx = &p_ll2_conn->rx_queue;
1427 p_tx = &p_ll2_conn->tx_queue;
1428
1429 ecore_chain_reset(&p_rx->rxq_chain);
1430 ecore_chain_reset(&p_rx->rcq_chain);
1431 OSAL_LIST_INIT(&p_rx->active_descq);
1432 OSAL_LIST_INIT(&p_rx->free_descq);
1433 OSAL_LIST_INIT(&p_rx->posting_descq);
1434 OSAL_SPIN_LOCK_INIT(&p_rx->lock);
1435 capacity = ecore_chain_get_capacity(&p_rx->rxq_chain);
1436 for (i = 0; i < capacity; i++)
1437 OSAL_LIST_PUSH_TAIL(&p_rx->descq_array[i].list_entry,
1438 &p_rx->free_descq);
1439 *p_rx->p_fw_cons = 0;
1440
1441 ecore_chain_reset(&p_tx->txq_chain);
1442 OSAL_LIST_INIT(&p_tx->active_descq);
1443 OSAL_LIST_INIT(&p_tx->free_descq);
1444 OSAL_LIST_INIT(&p_tx->sending_descq);
1445 OSAL_SPIN_LOCK_INIT(&p_tx->lock);
1446 capacity = ecore_chain_get_capacity(&p_tx->txq_chain);
1447 /* The size of the element in descq_array is flexible */
1448 desc_size = (sizeof(*p_pkt) +
1449 (p_ll2_conn->input.tx_max_bds_per_packet - 1) *
1450 sizeof(p_pkt->bds_set));
1451
1452 for (i = 0; i < capacity; i++) {
1453 p_pkt = (struct ecore_ll2_tx_packet *)((u8 *)p_tx->descq_array +
1454 desc_size*i);
1455 OSAL_LIST_PUSH_TAIL(&p_pkt->list_entry,
1456 &p_tx->free_descq);
1457 }
1458 p_tx->cur_completing_bd_idx = 0;
1459 p_tx->bds_idx = 0;
1460 p_tx->b_completing_packet = false;
1461 p_tx->cur_send_packet = OSAL_NULL;
1462 p_tx->cur_send_frag_num = 0;
1463 p_tx->cur_completing_frag_num = 0;
1464 *p_tx->p_fw_cons = 0;
1465
1466 rc = ecore_cxt_acquire_cid(p_hwfn, PROTOCOLID_CORE, &p_ll2_conn->cid);
1467 if (rc)
1468 goto out;
1469 cxt_info.iid = p_ll2_conn->cid;
1470 rc = ecore_cxt_get_cid_info(p_hwfn, &cxt_info);
1471 if (rc) {
1472 DP_NOTICE(p_hwfn, true, "Cannot find context info for cid=%d\n",
1473 p_ll2_conn->cid);
1474 goto out;
1475 }
1476
1477 p_cxt = cxt_info.p_cxt;
1478
1479 /* @@@TBD we zero the context until we have ilt_reset implemented. */
1480 OSAL_MEM_ZERO(p_cxt, sizeof(*p_cxt));
1481
1482 qid = ecore_ll2_handle_to_queue_id(p_hwfn, connection_handle);
1483 p_ll2_conn->queue_id = qid;
1484 p_ll2_conn->tx_stats_id = qid;
1485 p_rx->set_prod_addr = (u8 OSAL_IOMEM*)p_hwfn->regview +
1486 GTT_BAR0_MAP_REG_TSDM_RAM +
1487 TSTORM_LL2_RX_PRODS_OFFSET(qid);
1488 p_tx->doorbell_addr = (u8 OSAL_IOMEM*)p_hwfn->doorbells +
1489 DB_ADDR(p_ll2_conn->cid,
1490 DQ_DEMS_LEGACY);
1491
1492 /* prepare db data */
1493 SET_FIELD(p_tx->db_msg.params, CORE_DB_DATA_DEST, DB_DEST_XCM);
1494 SET_FIELD(p_tx->db_msg.params, CORE_DB_DATA_AGG_CMD,
1495 DB_AGG_CMD_SET);
1496 SET_FIELD(p_tx->db_msg.params, CORE_DB_DATA_AGG_VAL_SEL,
1497 DQ_XCM_CORE_TX_BD_PROD_CMD);
1498 p_tx->db_msg.agg_flags = DQ_XCM_CORE_DQ_CF_CMD;
1499
1500 rc = ecore_ll2_establish_connection_rx(p_hwfn, p_ll2_conn);
1501 if (rc)
1502 goto out;
1503
1504 rc = ecore_sp_ll2_tx_queue_start(p_hwfn, p_ll2_conn);
1505 if (rc)
1506 goto out;
1507
1508 if (!ECORE_IS_RDMA_PERSONALITY(p_hwfn))
1509 ecore_wr(p_hwfn, p_ptt, PRS_REG_USE_LIGHT_L2, 1);
1510
1511 ecore_ll2_establish_connection_ooo(p_hwfn, p_ll2_conn);
1512
1513 if (p_ll2_conn->input.conn_type == ECORE_LL2_TYPE_FCOE) {
1514 if (!OSAL_TEST_BIT(ECORE_MF_UFP_SPECIFIC,
1515 &p_hwfn->p_dev->mf_bits))
1516 ecore_llh_add_protocol_filter(p_hwfn->p_dev, 0,
1517 ECORE_LLH_FILTER_ETHERTYPE,
1518 0x8906, 0);
1519 ecore_llh_add_protocol_filter(p_hwfn->p_dev, 0,
1520 ECORE_LLH_FILTER_ETHERTYPE,
1521 0x8914, 0);
1522 }
1523
1524 out:
1525 ecore_ptt_release(p_hwfn, p_ptt);
1526
1527 return rc;
1528 }
1529
ecore_ll2_post_rx_buffer_notify_fw(struct ecore_hwfn * p_hwfn,struct ecore_ll2_rx_queue * p_rx,struct ecore_ll2_rx_packet * p_curp)1530 static void ecore_ll2_post_rx_buffer_notify_fw(struct ecore_hwfn *p_hwfn,
1531 struct ecore_ll2_rx_queue *p_rx,
1532 struct ecore_ll2_rx_packet *p_curp)
1533 {
1534 struct ecore_ll2_rx_packet *p_posting_packet = OSAL_NULL;
1535 struct core_ll2_rx_prod rx_prod = {0, 0, 0};
1536 bool b_notify_fw = false;
1537 u16 bd_prod, cq_prod;
1538
1539 /* This handles the flushing of already posted buffers */
1540 while (!OSAL_LIST_IS_EMPTY(&p_rx->posting_descq)) {
1541 p_posting_packet = OSAL_LIST_FIRST_ENTRY(&p_rx->posting_descq,
1542 struct ecore_ll2_rx_packet,
1543 list_entry);
1544 #if defined(_NTDDK_)
1545 #pragma warning(suppress : 6011 28182)
1546 #endif
1547 OSAL_LIST_REMOVE_ENTRY(&p_posting_packet->list_entry, &p_rx->posting_descq);
1548 OSAL_LIST_PUSH_TAIL(&p_posting_packet->list_entry, &p_rx->active_descq);
1549 b_notify_fw = true;
1550 }
1551
1552 /* This handles the supplied packet [if there is one] */
1553 if (p_curp) {
1554 OSAL_LIST_PUSH_TAIL(&p_curp->list_entry,
1555 &p_rx->active_descq);
1556 b_notify_fw = true;
1557 }
1558
1559 if (!b_notify_fw)
1560 return;
1561
1562 bd_prod = ecore_chain_get_prod_idx(&p_rx->rxq_chain);
1563 cq_prod = ecore_chain_get_prod_idx(&p_rx->rcq_chain);
1564 rx_prod.bd_prod = OSAL_CPU_TO_LE16(bd_prod);
1565 rx_prod.cqe_prod = OSAL_CPU_TO_LE16(cq_prod);
1566 DIRECT_REG_WR(p_hwfn, p_rx->set_prod_addr, *((u32 *)&rx_prod));
1567 }
1568
ecore_ll2_post_rx_buffer(void * cxt,u8 connection_handle,dma_addr_t addr,u16 buf_len,void * cookie,u8 notify_fw)1569 enum _ecore_status_t ecore_ll2_post_rx_buffer(void *cxt,
1570 u8 connection_handle,
1571 dma_addr_t addr,
1572 u16 buf_len,
1573 void *cookie,
1574 u8 notify_fw)
1575 {
1576 struct ecore_hwfn *p_hwfn = (struct ecore_hwfn *)cxt;
1577 struct core_rx_bd_with_buff_len *p_curb = OSAL_NULL;
1578 struct ecore_ll2_rx_packet *p_curp = OSAL_NULL;
1579 struct ecore_ll2_info *p_ll2_conn;
1580 struct ecore_ll2_rx_queue *p_rx;
1581 unsigned long flags;
1582 void *p_data;
1583 enum _ecore_status_t rc = ECORE_SUCCESS;
1584
1585 p_ll2_conn = ecore_ll2_handle_sanity(p_hwfn, connection_handle);
1586 if (p_ll2_conn == OSAL_NULL)
1587 return ECORE_INVAL;
1588 p_rx = &p_ll2_conn->rx_queue;
1589 if (p_rx->set_prod_addr == OSAL_NULL)
1590 return ECORE_IO;
1591
1592 OSAL_SPIN_LOCK_IRQSAVE(&p_rx->lock, flags);
1593 if (!OSAL_LIST_IS_EMPTY(&p_rx->free_descq))
1594 p_curp = OSAL_LIST_FIRST_ENTRY(&p_rx->free_descq,
1595 struct ecore_ll2_rx_packet,
1596 list_entry);
1597 if (p_curp) {
1598 if (ecore_chain_get_elem_left(&p_rx->rxq_chain) &&
1599 ecore_chain_get_elem_left(&p_rx->rcq_chain)) {
1600 p_data = ecore_chain_produce(&p_rx->rxq_chain);
1601 p_curb = (struct core_rx_bd_with_buff_len *)p_data;
1602 ecore_chain_produce(&p_rx->rcq_chain);
1603 }
1604 }
1605
1606 /* If we're lacking entires, let's try to flush buffers to FW */
1607 if (!p_curp || !p_curb) {
1608 rc = ECORE_BUSY;
1609 p_curp = OSAL_NULL;
1610 goto out_notify;
1611 }
1612
1613 /* We have an Rx packet we can fill */
1614 DMA_REGPAIR_LE(p_curb->addr, addr);
1615 p_curb->buff_length = OSAL_CPU_TO_LE16(buf_len);
1616 p_curp->rx_buf_addr = addr;
1617 p_curp->cookie = cookie;
1618 p_curp->rxq_bd = p_curb;
1619 p_curp->buf_length = buf_len;
1620 OSAL_LIST_REMOVE_ENTRY(&p_curp->list_entry,
1621 &p_rx->free_descq);
1622
1623 /* Check if we only want to enqueue this packet without informing FW */
1624 if (!notify_fw) {
1625 OSAL_LIST_PUSH_TAIL(&p_curp->list_entry,
1626 &p_rx->posting_descq);
1627 goto out;
1628 }
1629
1630 out_notify:
1631 ecore_ll2_post_rx_buffer_notify_fw(p_hwfn, p_rx, p_curp);
1632 out:
1633 OSAL_SPIN_UNLOCK_IRQSAVE(&p_rx->lock, flags);
1634 return rc;
1635 }
1636
ecore_ll2_prepare_tx_packet_set(struct ecore_ll2_tx_queue * p_tx,struct ecore_ll2_tx_packet * p_curp,struct ecore_ll2_tx_pkt_info * pkt,u8 notify_fw)1637 static void ecore_ll2_prepare_tx_packet_set(struct ecore_ll2_tx_queue *p_tx,
1638 struct ecore_ll2_tx_packet *p_curp,
1639 struct ecore_ll2_tx_pkt_info *pkt,
1640 u8 notify_fw)
1641 {
1642 OSAL_LIST_REMOVE_ENTRY(&p_curp->list_entry,
1643 &p_tx->free_descq);
1644 p_curp->cookie = pkt->cookie;
1645 p_curp->bd_used = pkt->num_of_bds;
1646 p_curp->notify_fw = notify_fw;
1647 p_tx->cur_send_packet = p_curp;
1648 p_tx->cur_send_frag_num = 0;
1649
1650 p_curp->bds_set[p_tx->cur_send_frag_num].tx_frag = pkt->first_frag;
1651 p_curp->bds_set[p_tx->cur_send_frag_num].frag_len = pkt->first_frag_len;
1652 p_tx->cur_send_frag_num++;
1653 }
1654
ecore_ll2_prepare_tx_packet_set_bd(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2,struct ecore_ll2_tx_packet * p_curp,struct ecore_ll2_tx_pkt_info * pkt)1655 static void ecore_ll2_prepare_tx_packet_set_bd(
1656 struct ecore_hwfn *p_hwfn,
1657 struct ecore_ll2_info *p_ll2,
1658 struct ecore_ll2_tx_packet *p_curp,
1659 struct ecore_ll2_tx_pkt_info *pkt)
1660 {
1661 struct ecore_chain *p_tx_chain = &p_ll2->tx_queue.txq_chain;
1662 u16 prod_idx = ecore_chain_get_prod_idx(p_tx_chain);
1663 struct core_tx_bd *start_bd = OSAL_NULL;
1664 enum core_roce_flavor_type roce_flavor;
1665 enum core_tx_dest tx_dest;
1666 u16 bd_data = 0, frag_idx;
1667
1668 roce_flavor = (pkt->ecore_roce_flavor == ECORE_LL2_ROCE) ?
1669 CORE_ROCE : CORE_RROCE;
1670
1671 switch (pkt->tx_dest) {
1672 case ECORE_LL2_TX_DEST_NW:
1673 tx_dest = CORE_TX_DEST_NW;
1674 break;
1675 case ECORE_LL2_TX_DEST_LB:
1676 tx_dest = CORE_TX_DEST_LB;
1677 break;
1678 case ECORE_LL2_TX_DEST_DROP:
1679 tx_dest = CORE_TX_DEST_DROP;
1680 break;
1681 default:
1682 tx_dest = CORE_TX_DEST_LB;
1683 break;
1684 }
1685
1686 start_bd = (struct core_tx_bd*)ecore_chain_produce(p_tx_chain);
1687
1688 if (ECORE_IS_IWARP_PERSONALITY(p_hwfn) &&
1689 (p_ll2->input.conn_type == ECORE_LL2_TYPE_OOO)) {
1690 start_bd->nw_vlan_or_lb_echo =
1691 OSAL_CPU_TO_LE16(IWARP_LL2_IN_ORDER_TX_QUEUE);
1692 } else {
1693 start_bd->nw_vlan_or_lb_echo = OSAL_CPU_TO_LE16(pkt->vlan);
1694 if (OSAL_TEST_BIT(ECORE_MF_UFP_SPECIFIC, &p_hwfn->p_dev->mf_bits) &&
1695 (p_ll2->input.conn_type == ECORE_LL2_TYPE_FCOE))
1696 pkt->remove_stag = true;
1697 }
1698
1699 SET_FIELD(start_bd->bitfield1, CORE_TX_BD_L4_HDR_OFFSET_W,
1700 OSAL_CPU_TO_LE16(pkt->l4_hdr_offset_w));
1701 SET_FIELD(start_bd->bitfield1, CORE_TX_BD_TX_DST, tx_dest);
1702 bd_data |= pkt->bd_flags;
1703 SET_FIELD(bd_data, CORE_TX_BD_DATA_START_BD, 0x1);
1704 SET_FIELD(bd_data, CORE_TX_BD_DATA_NBDS, pkt->num_of_bds);
1705 SET_FIELD(bd_data, CORE_TX_BD_DATA_ROCE_FLAV, roce_flavor);
1706 SET_FIELD(bd_data, CORE_TX_BD_DATA_IP_CSUM, !!(pkt->enable_ip_cksum));
1707 SET_FIELD(bd_data, CORE_TX_BD_DATA_L4_CSUM, !!(pkt->enable_l4_cksum));
1708 SET_FIELD(bd_data, CORE_TX_BD_DATA_IP_LEN, !!(pkt->calc_ip_len));
1709 SET_FIELD(bd_data, CORE_TX_BD_DATA_DISABLE_STAG_INSERTION,
1710 !!(pkt->remove_stag));
1711
1712 start_bd->bd_data.as_bitfield = OSAL_CPU_TO_LE16(bd_data);
1713 DMA_REGPAIR_LE(start_bd->addr, pkt->first_frag);
1714 start_bd->nbytes = OSAL_CPU_TO_LE16(pkt->first_frag_len);
1715
1716 DP_VERBOSE(p_hwfn, (ECORE_MSG_TX_QUEUED | ECORE_MSG_LL2),
1717 "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",
1718 p_ll2->queue_id, p_ll2->cid, p_ll2->input.conn_type,
1719 prod_idx, pkt->first_frag_len, pkt->num_of_bds,
1720 OSAL_LE32_TO_CPU(start_bd->addr.hi),
1721 OSAL_LE32_TO_CPU(start_bd->addr.lo));
1722
1723 if (p_ll2->tx_queue.cur_send_frag_num == pkt->num_of_bds)
1724 return;
1725
1726 /* Need to provide the packet with additional BDs for frags */
1727 for (frag_idx = p_ll2->tx_queue.cur_send_frag_num;
1728 frag_idx < pkt->num_of_bds; frag_idx++) {
1729 struct core_tx_bd **p_bd = &p_curp->bds_set[frag_idx].txq_bd;
1730
1731 *p_bd = (struct core_tx_bd *)ecore_chain_produce(p_tx_chain);
1732 (*p_bd)->bd_data.as_bitfield = 0;
1733 (*p_bd)->bitfield1 = 0;
1734 p_curp->bds_set[frag_idx].tx_frag = 0;
1735 p_curp->bds_set[frag_idx].frag_len = 0;
1736 }
1737 }
1738
1739 /* This should be called while the Txq spinlock is being held */
ecore_ll2_tx_packet_notify(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)1740 static void ecore_ll2_tx_packet_notify(struct ecore_hwfn *p_hwfn,
1741 struct ecore_ll2_info *p_ll2_conn)
1742 {
1743 bool b_notify = p_ll2_conn->tx_queue.cur_send_packet->notify_fw;
1744 struct ecore_ll2_tx_queue *p_tx = &p_ll2_conn->tx_queue;
1745 struct ecore_ll2_tx_packet *p_pkt = OSAL_NULL;
1746 u16 bd_prod;
1747
1748 /* If there are missing BDs, don't do anything now */
1749 if (p_ll2_conn->tx_queue.cur_send_frag_num !=
1750 p_ll2_conn->tx_queue.cur_send_packet->bd_used)
1751 return;
1752
1753 /* Push the current packet to the list and clean after it */
1754 OSAL_LIST_PUSH_TAIL(&p_ll2_conn->tx_queue.cur_send_packet->list_entry,
1755 &p_ll2_conn->tx_queue.sending_descq);
1756 p_ll2_conn->tx_queue.cur_send_packet = OSAL_NULL;
1757 p_ll2_conn->tx_queue.cur_send_frag_num = 0;
1758
1759 /* Notify FW of packet only if requested to */
1760 if (!b_notify)
1761 return;
1762
1763 bd_prod = ecore_chain_get_prod_idx(&p_ll2_conn->tx_queue.txq_chain);
1764
1765 while (!OSAL_LIST_IS_EMPTY(&p_tx->sending_descq)) {
1766 p_pkt = OSAL_LIST_FIRST_ENTRY(&p_tx->sending_descq,
1767 struct ecore_ll2_tx_packet,
1768 list_entry);
1769 if (p_pkt == OSAL_NULL)
1770 break;
1771 #if defined(_NTDDK_)
1772 #pragma warning(suppress : 6011 28182)
1773 #endif
1774 OSAL_LIST_REMOVE_ENTRY(&p_pkt->list_entry,
1775 &p_tx->sending_descq);
1776 OSAL_LIST_PUSH_TAIL(&p_pkt->list_entry, &p_tx->active_descq);
1777 }
1778
1779 p_tx->db_msg.spq_prod = OSAL_CPU_TO_LE16(bd_prod);
1780
1781 /* Make sure the BDs data is updated before ringing the doorbell */
1782 OSAL_WMB(p_hwfn->p_dev);
1783
1784 //DIRECT_REG_WR(p_hwfn, p_tx->doorbell_addr, *((u32 *)&p_tx->db_msg));
1785 DIRECT_REG_WR_DB(p_hwfn, p_tx->doorbell_addr, *((u32 *)&p_tx->db_msg));
1786
1787 DP_VERBOSE(p_hwfn, (ECORE_MSG_TX_QUEUED | ECORE_MSG_LL2),
1788 "LL2 [q 0x%02x cid 0x%08x type 0x%08x] Doorbelled [producer 0x%04x]\n",
1789 p_ll2_conn->queue_id, p_ll2_conn->cid,
1790 p_ll2_conn->input.conn_type,
1791 p_tx->db_msg.spq_prod);
1792 }
1793
ecore_ll2_prepare_tx_packet(void * cxt,u8 connection_handle,struct ecore_ll2_tx_pkt_info * pkt,bool notify_fw)1794 enum _ecore_status_t ecore_ll2_prepare_tx_packet(
1795 void *cxt,
1796 u8 connection_handle,
1797 struct ecore_ll2_tx_pkt_info *pkt,
1798 bool notify_fw)
1799 {
1800 struct ecore_hwfn *p_hwfn = (struct ecore_hwfn *)cxt;
1801 struct ecore_ll2_tx_packet *p_curp = OSAL_NULL;
1802 struct ecore_ll2_info *p_ll2_conn = OSAL_NULL;
1803 struct ecore_ll2_tx_queue *p_tx;
1804 struct ecore_chain *p_tx_chain;
1805 unsigned long flags;
1806 enum _ecore_status_t rc = ECORE_SUCCESS;
1807
1808 p_ll2_conn = ecore_ll2_handle_sanity(p_hwfn, connection_handle);
1809 if (p_ll2_conn == OSAL_NULL)
1810 return ECORE_INVAL;
1811 p_tx = &p_ll2_conn->tx_queue;
1812 p_tx_chain = &p_tx->txq_chain;
1813
1814 if (pkt->num_of_bds > p_ll2_conn->input.tx_max_bds_per_packet)
1815 return ECORE_IO; /* coalescing is requireed */
1816
1817 OSAL_SPIN_LOCK_IRQSAVE(&p_tx->lock, flags);
1818 if (p_tx->cur_send_packet) {
1819 rc = ECORE_EXISTS;
1820 goto out;
1821 }
1822
1823 /* Get entry, but only if we have tx elements for it */
1824 if (!OSAL_LIST_IS_EMPTY(&p_tx->free_descq))
1825 p_curp = OSAL_LIST_FIRST_ENTRY(&p_tx->free_descq,
1826 struct ecore_ll2_tx_packet,
1827 list_entry);
1828 if (p_curp && ecore_chain_get_elem_left(p_tx_chain) < pkt->num_of_bds)
1829 p_curp = OSAL_NULL;
1830
1831 if (!p_curp) {
1832 rc = ECORE_BUSY;
1833 goto out;
1834 }
1835
1836 /* Prepare packet and BD, and perhaps send a doorbell to FW */
1837 ecore_ll2_prepare_tx_packet_set(p_tx, p_curp, pkt, notify_fw);
1838
1839 ecore_ll2_prepare_tx_packet_set_bd(p_hwfn, p_ll2_conn, p_curp,
1840 pkt);
1841
1842 ecore_ll2_tx_packet_notify(p_hwfn, p_ll2_conn);
1843
1844 out:
1845 OSAL_SPIN_UNLOCK_IRQSAVE(&p_tx->lock, flags);
1846 return rc;
1847 }
1848
ecore_ll2_set_fragment_of_tx_packet(void * cxt,u8 connection_handle,dma_addr_t addr,u16 nbytes)1849 enum _ecore_status_t ecore_ll2_set_fragment_of_tx_packet(void *cxt,
1850 u8 connection_handle,
1851 dma_addr_t addr,
1852 u16 nbytes)
1853 {
1854 struct ecore_ll2_tx_packet *p_cur_send_packet = OSAL_NULL;
1855 struct ecore_hwfn *p_hwfn = (struct ecore_hwfn *)cxt;
1856 struct ecore_ll2_info *p_ll2_conn = OSAL_NULL;
1857 u16 cur_send_frag_num = 0;
1858 struct core_tx_bd *p_bd;
1859 unsigned long flags;
1860
1861 p_ll2_conn = ecore_ll2_handle_sanity(p_hwfn, connection_handle);
1862 if (p_ll2_conn == OSAL_NULL)
1863 return ECORE_INVAL;
1864
1865 if (!p_ll2_conn->tx_queue.cur_send_packet)
1866 return ECORE_INVAL;
1867
1868 p_cur_send_packet = p_ll2_conn->tx_queue.cur_send_packet;
1869 cur_send_frag_num = p_ll2_conn->tx_queue.cur_send_frag_num;
1870
1871 if (cur_send_frag_num >= p_cur_send_packet->bd_used)
1872 return ECORE_INVAL;
1873
1874 /* Fill the BD information, and possibly notify FW */
1875 p_bd = p_cur_send_packet->bds_set[cur_send_frag_num].txq_bd;
1876 DMA_REGPAIR_LE(p_bd->addr, addr);
1877 p_bd->nbytes = OSAL_CPU_TO_LE16(nbytes);
1878 p_cur_send_packet->bds_set[cur_send_frag_num].tx_frag = addr;
1879 p_cur_send_packet->bds_set[cur_send_frag_num].frag_len = nbytes;
1880
1881 p_ll2_conn->tx_queue.cur_send_frag_num++;
1882
1883 OSAL_SPIN_LOCK_IRQSAVE(&p_ll2_conn->tx_queue.lock, flags);
1884 ecore_ll2_tx_packet_notify(p_hwfn, p_ll2_conn);
1885 OSAL_SPIN_UNLOCK_IRQSAVE(&p_ll2_conn->tx_queue.lock, flags);
1886
1887 return ECORE_SUCCESS;
1888 }
1889
ecore_ll2_terminate_connection(void * cxt,u8 connection_handle)1890 enum _ecore_status_t ecore_ll2_terminate_connection(void *cxt,
1891 u8 connection_handle)
1892 {
1893 struct ecore_hwfn *p_hwfn = (struct ecore_hwfn *)cxt;
1894 struct ecore_ll2_info *p_ll2_conn = OSAL_NULL;
1895 enum _ecore_status_t rc = ECORE_NOTIMPL;
1896 struct ecore_ptt *p_ptt;
1897
1898 p_ptt = ecore_ptt_acquire(p_hwfn);
1899 if (!p_ptt)
1900 return ECORE_AGAIN;
1901
1902 p_ll2_conn = ecore_ll2_handle_sanity_lock(p_hwfn, connection_handle);
1903 if (p_ll2_conn == OSAL_NULL) {
1904 rc = ECORE_INVAL;
1905 goto out;
1906 }
1907
1908 /* Stop Tx & Rx of connection, if needed */
1909 if (ECORE_LL2_TX_REGISTERED(p_ll2_conn)) {
1910 rc = ecore_sp_ll2_tx_queue_stop(p_hwfn, p_ll2_conn);
1911 if (rc != ECORE_SUCCESS)
1912 goto out;
1913 ecore_ll2_txq_flush(p_hwfn, connection_handle);
1914 }
1915
1916 if (ECORE_LL2_RX_REGISTERED(p_ll2_conn)) {
1917 rc = ecore_sp_ll2_rx_queue_stop(p_hwfn, p_ll2_conn);
1918 if (rc)
1919 goto out;
1920 ecore_ll2_rxq_flush(p_hwfn, connection_handle);
1921 }
1922
1923 if (p_ll2_conn->input.conn_type == ECORE_LL2_TYPE_OOO)
1924 ecore_ooo_release_all_isles(p_hwfn->p_ooo_info);
1925
1926 if (p_ll2_conn->input.conn_type == ECORE_LL2_TYPE_FCOE) {
1927 if (!OSAL_TEST_BIT(ECORE_MF_UFP_SPECIFIC,
1928 &p_hwfn->p_dev->mf_bits))
1929 ecore_llh_remove_protocol_filter(p_hwfn->p_dev, 0,
1930 ECORE_LLH_FILTER_ETHERTYPE,
1931 0x8906, 0);
1932 ecore_llh_remove_protocol_filter(p_hwfn->p_dev, 0,
1933 ECORE_LLH_FILTER_ETHERTYPE,
1934 0x8914, 0);
1935 }
1936
1937 out:
1938 ecore_ptt_release(p_hwfn, p_ptt);
1939
1940 return rc;
1941 }
1942
ecore_ll2_release_connection_ooo(struct ecore_hwfn * p_hwfn,struct ecore_ll2_info * p_ll2_conn)1943 static void ecore_ll2_release_connection_ooo(struct ecore_hwfn *p_hwfn,
1944 struct ecore_ll2_info *p_ll2_conn)
1945 {
1946 struct ecore_ooo_buffer *p_buffer;
1947
1948 if (p_ll2_conn->input.conn_type != ECORE_LL2_TYPE_OOO)
1949 return;
1950
1951 ecore_ooo_release_all_isles(p_hwfn->p_ooo_info);
1952 while ((p_buffer = ecore_ooo_get_free_buffer(p_hwfn->p_ooo_info))) {
1953 OSAL_DMA_FREE_COHERENT(p_hwfn->p_dev,
1954 p_buffer->rx_buffer_virt_addr,
1955 p_buffer->rx_buffer_phys_addr,
1956 p_buffer->rx_buffer_size);
1957 OSAL_FREE(p_hwfn->p_dev, p_buffer);
1958 }
1959 }
1960
ecore_ll2_release_connection(void * cxt,u8 connection_handle)1961 void ecore_ll2_release_connection(void *cxt,
1962 u8 connection_handle)
1963 {
1964 struct ecore_hwfn *p_hwfn = (struct ecore_hwfn *)cxt;
1965 struct ecore_ll2_info *p_ll2_conn = OSAL_NULL;
1966
1967 p_ll2_conn = ecore_ll2_handle_sanity(p_hwfn, connection_handle);
1968 if (p_ll2_conn == OSAL_NULL)
1969 return;
1970
1971 if (ECORE_LL2_RX_REGISTERED(p_ll2_conn)) {
1972 p_ll2_conn->rx_queue.b_cb_registred = false;
1973 ecore_int_unregister_cb(p_hwfn,
1974 p_ll2_conn->rx_queue.rx_sb_index);
1975 }
1976
1977 if (ECORE_LL2_TX_REGISTERED(p_ll2_conn)) {
1978 p_ll2_conn->tx_queue.b_cb_registred = false;
1979 ecore_int_unregister_cb(p_hwfn,
1980 p_ll2_conn->tx_queue.tx_sb_index);
1981 }
1982
1983 OSAL_FREE(p_hwfn->p_dev, p_ll2_conn->tx_queue.descq_array);
1984 ecore_chain_free(p_hwfn->p_dev, &p_ll2_conn->tx_queue.txq_chain);
1985
1986 OSAL_FREE(p_hwfn->p_dev, p_ll2_conn->rx_queue.descq_array);
1987 ecore_chain_free(p_hwfn->p_dev, &p_ll2_conn->rx_queue.rxq_chain);
1988 ecore_chain_free(p_hwfn->p_dev, &p_ll2_conn->rx_queue.rcq_chain);
1989
1990 ecore_cxt_release_cid(p_hwfn, p_ll2_conn->cid);
1991
1992 ecore_ll2_release_connection_ooo(p_hwfn, p_ll2_conn);
1993
1994 OSAL_MUTEX_ACQUIRE(&p_ll2_conn->mutex);
1995 p_ll2_conn->b_active = false;
1996 OSAL_MUTEX_RELEASE(&p_ll2_conn->mutex);
1997 }
1998
1999 /* ECORE LL2: internal functions */
2000
ecore_ll2_alloc(struct ecore_hwfn * p_hwfn)2001 enum _ecore_status_t ecore_ll2_alloc(struct ecore_hwfn *p_hwfn)
2002 {
2003 struct ecore_ll2_info *p_ll2_info;
2004 u8 i;
2005
2006 /* Allocate LL2's set struct */
2007 p_ll2_info = OSAL_ZALLOC(p_hwfn->p_dev, GFP_KERNEL,
2008 sizeof(struct ecore_ll2_info) *
2009 ECORE_MAX_NUM_OF_LL2_CONNECTIONS);
2010 if (!p_ll2_info) {
2011 DP_NOTICE(p_hwfn, false,
2012 "Failed to allocate `struct ecore_ll2'\n");
2013 return ECORE_NOMEM;
2014 }
2015
2016 p_hwfn->p_ll2_info = p_ll2_info;
2017
2018 for (i = 0; i < ECORE_MAX_NUM_OF_LL2_CONNECTIONS; i++) {
2019 #ifdef CONFIG_ECORE_LOCK_ALLOC
2020 if (OSAL_MUTEX_ALLOC(p_hwfn, &p_ll2_info[i].mutex))
2021 goto handle_err;
2022 if (OSAL_SPIN_LOCK_ALLOC(p_hwfn, &p_ll2_info[i].rx_queue.lock))
2023 goto handle_err;
2024 if (OSAL_SPIN_LOCK_ALLOC(p_hwfn, &p_ll2_info[i].tx_queue.lock))
2025 goto handle_err;
2026 #endif
2027 p_ll2_info[i].my_id = i;
2028 }
2029
2030 return ECORE_SUCCESS;
2031 #ifdef CONFIG_ECORE_LOCK_ALLOC
2032 handle_err:
2033 ecore_ll2_free(p_hwfn);
2034 return ECORE_NOMEM;
2035 #endif
2036 }
2037
ecore_ll2_setup(struct ecore_hwfn * p_hwfn)2038 void ecore_ll2_setup(struct ecore_hwfn *p_hwfn)
2039 {
2040 int i;
2041
2042 for (i = 0; i < ECORE_MAX_NUM_OF_LL2_CONNECTIONS; i++)
2043 OSAL_MUTEX_INIT(&p_hwfn->p_ll2_info[i].mutex);
2044 }
2045
ecore_ll2_free(struct ecore_hwfn * p_hwfn)2046 void ecore_ll2_free(struct ecore_hwfn *p_hwfn)
2047 {
2048 #ifdef CONFIG_ECORE_LOCK_ALLOC
2049 int i;
2050 #endif
2051 if (!p_hwfn->p_ll2_info)
2052 return;
2053
2054 #ifdef CONFIG_ECORE_LOCK_ALLOC
2055 for (i = 0; i < ECORE_MAX_NUM_OF_LL2_CONNECTIONS; i++) {
2056 OSAL_SPIN_LOCK_DEALLOC(&p_hwfn->p_ll2_info[i].rx_queue.lock);
2057 OSAL_SPIN_LOCK_DEALLOC(&p_hwfn->p_ll2_info[i].tx_queue.lock);
2058 OSAL_MUTEX_DEALLOC(&p_hwfn->p_ll2_info[i].mutex);
2059 }
2060 #endif
2061 OSAL_FREE(p_hwfn->p_dev, p_hwfn->p_ll2_info);
2062 p_hwfn->p_ll2_info = OSAL_NULL;
2063 }
2064
_ecore_ll2_get_port_stats(struct ecore_hwfn * p_hwfn,struct ecore_ptt * p_ptt,struct ecore_ll2_stats * p_stats)2065 static void _ecore_ll2_get_port_stats(struct ecore_hwfn *p_hwfn,
2066 struct ecore_ptt *p_ptt,
2067 struct ecore_ll2_stats *p_stats)
2068 {
2069 struct core_ll2_port_stats port_stats;
2070
2071 OSAL_MEMSET(&port_stats, 0, sizeof(port_stats));
2072 ecore_memcpy_from(p_hwfn, p_ptt, &port_stats,
2073 BAR0_MAP_REG_TSDM_RAM +
2074 TSTORM_LL2_PORT_STAT_OFFSET(MFW_PORT(p_hwfn)),
2075 sizeof(port_stats));
2076
2077 p_stats->gsi_invalid_hdr +=
2078 HILO_64_REGPAIR(port_stats.gsi_invalid_hdr);
2079 p_stats->gsi_invalid_pkt_length +=
2080 HILO_64_REGPAIR(port_stats.gsi_invalid_pkt_length);
2081 p_stats->gsi_unsupported_pkt_typ +=
2082 HILO_64_REGPAIR(port_stats.gsi_unsupported_pkt_typ);
2083 p_stats->gsi_crcchksm_error +=
2084 HILO_64_REGPAIR(port_stats.gsi_crcchksm_error);
2085 }
2086
_ecore_ll2_get_tstats(struct ecore_hwfn * p_hwfn,struct ecore_ptt * p_ptt,struct ecore_ll2_info * p_ll2_conn,struct ecore_ll2_stats * p_stats)2087 static void _ecore_ll2_get_tstats(struct ecore_hwfn *p_hwfn,
2088 struct ecore_ptt *p_ptt,
2089 struct ecore_ll2_info *p_ll2_conn,
2090 struct ecore_ll2_stats *p_stats)
2091 {
2092 struct core_ll2_tstorm_per_queue_stat tstats;
2093 u8 qid = p_ll2_conn->queue_id;
2094 u32 tstats_addr;
2095
2096 OSAL_MEMSET(&tstats, 0, sizeof(tstats));
2097 tstats_addr = BAR0_MAP_REG_TSDM_RAM +
2098 CORE_LL2_TSTORM_PER_QUEUE_STAT_OFFSET(qid);
2099 ecore_memcpy_from(p_hwfn, p_ptt, &tstats,
2100 tstats_addr,
2101 sizeof(tstats));
2102
2103 p_stats->packet_too_big_discard +=
2104 HILO_64_REGPAIR(tstats.packet_too_big_discard);
2105 p_stats->no_buff_discard +=
2106 HILO_64_REGPAIR(tstats.no_buff_discard);
2107 }
2108
_ecore_ll2_get_ustats(struct ecore_hwfn * p_hwfn,struct ecore_ptt * p_ptt,struct ecore_ll2_info * p_ll2_conn,struct ecore_ll2_stats * p_stats)2109 static void _ecore_ll2_get_ustats(struct ecore_hwfn *p_hwfn,
2110 struct ecore_ptt *p_ptt,
2111 struct ecore_ll2_info *p_ll2_conn,
2112 struct ecore_ll2_stats *p_stats)
2113 {
2114 struct core_ll2_ustorm_per_queue_stat ustats;
2115 u8 qid = p_ll2_conn->queue_id;
2116 u32 ustats_addr;
2117
2118 OSAL_MEMSET(&ustats, 0, sizeof(ustats));
2119 ustats_addr = BAR0_MAP_REG_USDM_RAM +
2120 CORE_LL2_USTORM_PER_QUEUE_STAT_OFFSET(qid);
2121 ecore_memcpy_from(p_hwfn, p_ptt, &ustats,
2122 ustats_addr,
2123 sizeof(ustats));
2124
2125 p_stats->rcv_ucast_bytes += HILO_64_REGPAIR(ustats.rcv_ucast_bytes);
2126 p_stats->rcv_mcast_bytes += HILO_64_REGPAIR(ustats.rcv_mcast_bytes);
2127 p_stats->rcv_bcast_bytes += HILO_64_REGPAIR(ustats.rcv_bcast_bytes);
2128 p_stats->rcv_ucast_pkts += HILO_64_REGPAIR(ustats.rcv_ucast_pkts);
2129 p_stats->rcv_mcast_pkts += HILO_64_REGPAIR(ustats.rcv_mcast_pkts);
2130 p_stats->rcv_bcast_pkts += HILO_64_REGPAIR(ustats.rcv_bcast_pkts);
2131 }
2132
_ecore_ll2_get_pstats(struct ecore_hwfn * p_hwfn,struct ecore_ptt * p_ptt,struct ecore_ll2_info * p_ll2_conn,struct ecore_ll2_stats * p_stats)2133 static void _ecore_ll2_get_pstats(struct ecore_hwfn *p_hwfn,
2134 struct ecore_ptt *p_ptt,
2135 struct ecore_ll2_info *p_ll2_conn,
2136 struct ecore_ll2_stats *p_stats)
2137 {
2138 struct core_ll2_pstorm_per_queue_stat pstats;
2139 u8 stats_id = p_ll2_conn->tx_stats_id;
2140 u32 pstats_addr;
2141
2142 OSAL_MEMSET(&pstats, 0, sizeof(pstats));
2143 pstats_addr = BAR0_MAP_REG_PSDM_RAM +
2144 CORE_LL2_PSTORM_PER_QUEUE_STAT_OFFSET(stats_id);
2145 ecore_memcpy_from(p_hwfn, p_ptt, &pstats,
2146 pstats_addr,
2147 sizeof(pstats));
2148
2149 p_stats->sent_ucast_bytes += HILO_64_REGPAIR(pstats.sent_ucast_bytes);
2150 p_stats->sent_mcast_bytes += HILO_64_REGPAIR(pstats.sent_mcast_bytes);
2151 p_stats->sent_bcast_bytes += HILO_64_REGPAIR(pstats.sent_bcast_bytes);
2152 p_stats->sent_ucast_pkts += HILO_64_REGPAIR(pstats.sent_ucast_pkts);
2153 p_stats->sent_mcast_pkts += HILO_64_REGPAIR(pstats.sent_mcast_pkts);
2154 p_stats->sent_bcast_pkts += HILO_64_REGPAIR(pstats.sent_bcast_pkts);
2155 }
2156
__ecore_ll2_get_stats(void * cxt,u8 connection_handle,struct ecore_ll2_stats * p_stats)2157 enum _ecore_status_t __ecore_ll2_get_stats(void *cxt,
2158 u8 connection_handle,
2159 struct ecore_ll2_stats *p_stats)
2160 {
2161 struct ecore_hwfn *p_hwfn = (struct ecore_hwfn *)cxt;
2162 struct ecore_ll2_info *p_ll2_conn = OSAL_NULL;
2163 struct ecore_ptt *p_ptt;
2164
2165 if ((connection_handle >= ECORE_MAX_NUM_OF_LL2_CONNECTIONS) ||
2166 !p_hwfn->p_ll2_info) {
2167 return ECORE_INVAL;
2168 }
2169
2170 p_ll2_conn = &p_hwfn->p_ll2_info[connection_handle];
2171
2172 p_ptt = ecore_ptt_acquire(p_hwfn);
2173 if (!p_ptt) {
2174 DP_ERR(p_hwfn, "Failed to acquire ptt\n");
2175 return ECORE_INVAL;
2176 }
2177
2178 if (p_ll2_conn->input.gsi_enable)
2179 _ecore_ll2_get_port_stats(p_hwfn, p_ptt, p_stats);
2180
2181 _ecore_ll2_get_tstats(p_hwfn, p_ptt, p_ll2_conn, p_stats);
2182
2183 _ecore_ll2_get_ustats(p_hwfn, p_ptt, p_ll2_conn, p_stats);
2184
2185 if (p_ll2_conn->tx_stats_en)
2186 _ecore_ll2_get_pstats(p_hwfn, p_ptt, p_ll2_conn, p_stats);
2187
2188 ecore_ptt_release(p_hwfn, p_ptt);
2189
2190 return ECORE_SUCCESS;
2191 }
2192
ecore_ll2_get_stats(void * cxt,u8 connection_handle,struct ecore_ll2_stats * p_stats)2193 enum _ecore_status_t ecore_ll2_get_stats(void *cxt,
2194 u8 connection_handle,
2195 struct ecore_ll2_stats *p_stats)
2196 {
2197 OSAL_MEMSET(p_stats, 0, sizeof(*p_stats));
2198
2199 return __ecore_ll2_get_stats(cxt, connection_handle, p_stats);
2200 }
2201
2202 /**/
2203
2204 #ifdef _NTDDK_
2205 #pragma warning(pop)
2206 #endif
2207