11f4d4ed6SAlexander Lobakin // SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
2fe56b9e6SYuval Mintz /* QLogic qed NIC Driver
3e8f1cb50SMintz, Yuval * Copyright (c) 2015-2017 QLogic Corporation
4663eacd8SAlexander Lobakin * Copyright (c) 2019-2020 Marvell International Ltd.
5fe56b9e6SYuval Mintz */
6fe56b9e6SYuval Mintz
7fe56b9e6SYuval Mintz #include <linux/types.h>
8fe56b9e6SYuval Mintz #include <asm/byteorder.h>
9fe56b9e6SYuval Mintz #include <linux/io.h>
10fe56b9e6SYuval Mintz #include <linux/delay.h>
11fe56b9e6SYuval Mintz #include <linux/dma-mapping.h>
12fe56b9e6SYuval Mintz #include <linux/errno.h>
13fe56b9e6SYuval Mintz #include <linux/kernel.h>
14fe56b9e6SYuval Mintz #include <linux/list.h>
15fe56b9e6SYuval Mintz #include <linux/pci.h>
16fe56b9e6SYuval Mintz #include <linux/slab.h>
17fe56b9e6SYuval Mintz #include <linux/spinlock.h>
18fe56b9e6SYuval Mintz #include <linux/string.h>
19fe56b9e6SYuval Mintz #include "qed.h"
20fe56b9e6SYuval Mintz #include "qed_cxt.h"
21fe56b9e6SYuval Mintz #include "qed_dev_api.h"
22fe56b9e6SYuval Mintz #include "qed_hsi.h"
23ee824f4bSOmkar Kulkarni #include "qed_iro_hsi.h"
24fe56b9e6SYuval Mintz #include "qed_hw.h"
25fe56b9e6SYuval Mintz #include "qed_int.h"
26fc831825SYuval Mintz #include "qed_iscsi.h"
27fe56b9e6SYuval Mintz #include "qed_mcp.h"
281d6cff4fSYuval Mintz #include "qed_ooo.h"
29fe56b9e6SYuval Mintz #include "qed_reg_addr.h"
30fe56b9e6SYuval Mintz #include "qed_sp.h"
3137bff2b9SYuval Mintz #include "qed_sriov.h"
32b71b9afdSKalderon, Michal #include "qed_rdma.h"
33fe56b9e6SYuval Mintz
34fe56b9e6SYuval Mintz /***************************************************************************
35fe56b9e6SYuval Mintz * Structures & Definitions
36fe56b9e6SYuval Mintz ***************************************************************************/
37fe56b9e6SYuval Mintz
38fe56b9e6SYuval Mintz #define SPQ_HIGH_PRI_RESERVE_DEFAULT (1)
39c59f5291SYuval Mintz
40c59f5291SYuval Mintz #define SPQ_BLOCK_DELAY_MAX_ITER (10)
41c59f5291SYuval Mintz #define SPQ_BLOCK_DELAY_US (10)
42c59f5291SYuval Mintz #define SPQ_BLOCK_SLEEP_MAX_ITER (1000)
43c59f5291SYuval Mintz #define SPQ_BLOCK_SLEEP_MS (5)
44fe56b9e6SYuval Mintz
45fe56b9e6SYuval Mintz /***************************************************************************
46fe56b9e6SYuval Mintz * Blocking Imp. (BLOCK/EBLOCK mode)
47fe56b9e6SYuval Mintz ***************************************************************************/
qed_spq_blocking_cb(struct qed_hwfn * p_hwfn,void * cookie,union event_ring_data * data,u8 fw_return_code)48fe56b9e6SYuval Mintz static void qed_spq_blocking_cb(struct qed_hwfn *p_hwfn,
49fe56b9e6SYuval Mintz void *cookie,
501a635e48SYuval Mintz union event_ring_data *data, u8 fw_return_code)
51fe56b9e6SYuval Mintz {
52fe56b9e6SYuval Mintz struct qed_spq_comp_done *comp_done;
53fe56b9e6SYuval Mintz
54fe56b9e6SYuval Mintz comp_done = (struct qed_spq_comp_done *)cookie;
55fe56b9e6SYuval Mintz
56fe56b9e6SYuval Mintz comp_done->fw_return_code = fw_return_code;
57fe56b9e6SYuval Mintz
58d5df7688SManish Chopra /* Make sure completion done is visible on waiting thread */
59d5df7688SManish Chopra smp_store_release(&comp_done->done, 0x1);
60fe56b9e6SYuval Mintz }
61fe56b9e6SYuval Mintz
__qed_spq_block(struct qed_hwfn * p_hwfn,struct qed_spq_entry * p_ent,u8 * p_fw_ret,bool sleep_between_iter)62c59f5291SYuval Mintz static int __qed_spq_block(struct qed_hwfn *p_hwfn,
63c59f5291SYuval Mintz struct qed_spq_entry *p_ent,
64c59f5291SYuval Mintz u8 *p_fw_ret, bool sleep_between_iter)
65c59f5291SYuval Mintz {
66c59f5291SYuval Mintz struct qed_spq_comp_done *comp_done;
67c59f5291SYuval Mintz u32 iter_cnt;
68c59f5291SYuval Mintz
69c59f5291SYuval Mintz comp_done = (struct qed_spq_comp_done *)p_ent->comp_cb.cookie;
70c59f5291SYuval Mintz iter_cnt = sleep_between_iter ? SPQ_BLOCK_SLEEP_MAX_ITER
71c59f5291SYuval Mintz : SPQ_BLOCK_DELAY_MAX_ITER;
72c59f5291SYuval Mintz
73c59f5291SYuval Mintz while (iter_cnt--) {
74c59f5291SYuval Mintz /* Validate we receive completion update */
75cb7e125eSPaul E. McKenney if (smp_load_acquire(&comp_done->done) == 1) { /* ^^^ */
76c59f5291SYuval Mintz if (p_fw_ret)
77c59f5291SYuval Mintz *p_fw_ret = comp_done->fw_return_code;
78c59f5291SYuval Mintz return 0;
79c59f5291SYuval Mintz }
80c59f5291SYuval Mintz
81c59f5291SYuval Mintz if (sleep_between_iter)
82c59f5291SYuval Mintz msleep(SPQ_BLOCK_SLEEP_MS);
83c59f5291SYuval Mintz else
84c59f5291SYuval Mintz udelay(SPQ_BLOCK_DELAY_US);
85c59f5291SYuval Mintz }
86c59f5291SYuval Mintz
87c59f5291SYuval Mintz return -EBUSY;
88c59f5291SYuval Mintz }
89c59f5291SYuval Mintz
qed_spq_block(struct qed_hwfn * p_hwfn,struct qed_spq_entry * p_ent,u8 * p_fw_ret,bool skip_quick_poll)90fe56b9e6SYuval Mintz static int qed_spq_block(struct qed_hwfn *p_hwfn,
91fe56b9e6SYuval Mintz struct qed_spq_entry *p_ent,
92c59f5291SYuval Mintz u8 *p_fw_ret, bool skip_quick_poll)
93fe56b9e6SYuval Mintz {
94fe56b9e6SYuval Mintz struct qed_spq_comp_done *comp_done;
9515582962SRahul Verma struct qed_ptt *p_ptt;
96fe56b9e6SYuval Mintz int rc;
97fe56b9e6SYuval Mintz
98c59f5291SYuval Mintz /* A relatively short polling period w/o sleeping, to allow the FW to
99c59f5291SYuval Mintz * complete the ramrod and thus possibly to avoid the following sleeps.
100c59f5291SYuval Mintz */
101c59f5291SYuval Mintz if (!skip_quick_poll) {
102c59f5291SYuval Mintz rc = __qed_spq_block(p_hwfn, p_ent, p_fw_ret, false);
103c59f5291SYuval Mintz if (!rc)
104fe56b9e6SYuval Mintz return 0;
105fe56b9e6SYuval Mintz }
106c59f5291SYuval Mintz
107c59f5291SYuval Mintz /* Move to polling with a sleeping period between iterations */
108c59f5291SYuval Mintz rc = __qed_spq_block(p_hwfn, p_ent, p_fw_ret, true);
109c59f5291SYuval Mintz if (!rc)
110c59f5291SYuval Mintz return 0;
111fe56b9e6SYuval Mintz
11215582962SRahul Verma p_ptt = qed_ptt_acquire(p_hwfn);
11315582962SRahul Verma if (!p_ptt) {
11415582962SRahul Verma DP_NOTICE(p_hwfn, "ptt, failed to acquire\n");
11515582962SRahul Verma return -EAGAIN;
11615582962SRahul Verma }
11715582962SRahul Verma
118fe56b9e6SYuval Mintz DP_INFO(p_hwfn, "Ramrod is stuck, requesting MCP drain\n");
11915582962SRahul Verma rc = qed_mcp_drain(p_hwfn, p_ptt);
120fa5c448dSSagiv Ozeri qed_ptt_release(p_hwfn, p_ptt);
121c59f5291SYuval Mintz if (rc) {
122fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn, "MCP drain failed\n");
123c59f5291SYuval Mintz goto err;
124c59f5291SYuval Mintz }
125fe56b9e6SYuval Mintz
126fe56b9e6SYuval Mintz /* Retry after drain */
127c59f5291SYuval Mintz rc = __qed_spq_block(p_hwfn, p_ent, p_fw_ret, true);
128c59f5291SYuval Mintz if (!rc)
129fe56b9e6SYuval Mintz return 0;
13015582962SRahul Verma
131fa5c448dSSagiv Ozeri comp_done = (struct qed_spq_comp_done *)p_ent->comp_cb.cookie;
132fa5c448dSSagiv Ozeri if (comp_done->done == 1) {
133fa5c448dSSagiv Ozeri if (p_fw_ret)
134fa5c448dSSagiv Ozeri *p_fw_ret = comp_done->fw_return_code;
135fa5c448dSSagiv Ozeri return 0;
136fa5c448dSSagiv Ozeri }
137c59f5291SYuval Mintz err:
1382ec276d5SIgor Russkikh p_ptt = qed_ptt_acquire(p_hwfn);
1392ec276d5SIgor Russkikh if (!p_ptt)
1402ec276d5SIgor Russkikh return -EBUSY;
1412ec276d5SIgor Russkikh qed_hw_err_notify(p_hwfn, p_ptt, QED_HW_ERR_RAMROD_FAIL,
142*7e9979e3SPrabhakar Kushwaha "Ramrod is stuck [CID %08x %s:%02x %s:%02x echo %04x]\n",
143c59f5291SYuval Mintz le32_to_cpu(p_ent->elem.hdr.cid),
144*7e9979e3SPrabhakar Kushwaha qed_get_ramrod_cmd_id_str(p_ent->elem.hdr.protocol_id,
145*7e9979e3SPrabhakar Kushwaha p_ent->elem.hdr.cmd_id),
146c59f5291SYuval Mintz p_ent->elem.hdr.cmd_id,
147*7e9979e3SPrabhakar Kushwaha qed_get_protocol_type_str(p_ent->elem.hdr.protocol_id),
148c59f5291SYuval Mintz p_ent->elem.hdr.protocol_id,
149c59f5291SYuval Mintz le16_to_cpu(p_ent->elem.hdr.echo));
1502ec276d5SIgor Russkikh qed_ptt_release(p_hwfn, p_ptt);
151fe56b9e6SYuval Mintz
152fe56b9e6SYuval Mintz return -EBUSY;
153fe56b9e6SYuval Mintz }
154fe56b9e6SYuval Mintz
155fe56b9e6SYuval Mintz /***************************************************************************
156fe56b9e6SYuval Mintz * SPQ entries inner API
157fe56b9e6SYuval Mintz ***************************************************************************/
qed_spq_fill_entry(struct qed_hwfn * p_hwfn,struct qed_spq_entry * p_ent)1581a635e48SYuval Mintz static int qed_spq_fill_entry(struct qed_hwfn *p_hwfn,
159fe56b9e6SYuval Mintz struct qed_spq_entry *p_ent)
160fe56b9e6SYuval Mintz {
161fe56b9e6SYuval Mintz p_ent->flags = 0;
162fe56b9e6SYuval Mintz
163fe56b9e6SYuval Mintz switch (p_ent->comp_mode) {
164fe56b9e6SYuval Mintz case QED_SPQ_MODE_EBLOCK:
165fe56b9e6SYuval Mintz case QED_SPQ_MODE_BLOCK:
166fe56b9e6SYuval Mintz p_ent->comp_cb.function = qed_spq_blocking_cb;
167fe56b9e6SYuval Mintz break;
168fe56b9e6SYuval Mintz case QED_SPQ_MODE_CB:
169fe56b9e6SYuval Mintz break;
170fe56b9e6SYuval Mintz default:
171fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn, "Unknown SPQE completion mode %d\n",
172fe56b9e6SYuval Mintz p_ent->comp_mode);
173fe56b9e6SYuval Mintz return -EINVAL;
174fe56b9e6SYuval Mintz }
175fe56b9e6SYuval Mintz
176*7e9979e3SPrabhakar Kushwaha DP_VERBOSE(p_hwfn,
177*7e9979e3SPrabhakar Kushwaha QED_MSG_SPQ,
178*7e9979e3SPrabhakar Kushwaha "Ramrod hdr: [CID 0x%08x %s:0x%02x %s:0x%02x] Data ptr: [%08x:%08x] Cmpltion Mode: %s\n",
179fe56b9e6SYuval Mintz p_ent->elem.hdr.cid,
180*7e9979e3SPrabhakar Kushwaha qed_get_ramrod_cmd_id_str(p_ent->elem.hdr.protocol_id,
181*7e9979e3SPrabhakar Kushwaha p_ent->elem.hdr.cmd_id),
182fe56b9e6SYuval Mintz p_ent->elem.hdr.cmd_id,
183*7e9979e3SPrabhakar Kushwaha qed_get_protocol_type_str(p_ent->elem.hdr.protocol_id),
184fe56b9e6SYuval Mintz p_ent->elem.hdr.protocol_id,
185*7e9979e3SPrabhakar Kushwaha p_ent->elem.data_ptr.hi, p_ent->elem.data_ptr.lo,
186fe56b9e6SYuval Mintz D_TRINE(p_ent->comp_mode, QED_SPQ_MODE_EBLOCK,
187fe56b9e6SYuval Mintz QED_SPQ_MODE_BLOCK, "MODE_EBLOCK", "MODE_BLOCK",
188fe56b9e6SYuval Mintz "MODE_CB"));
189fe56b9e6SYuval Mintz
190fe56b9e6SYuval Mintz return 0;
191fe56b9e6SYuval Mintz }
192fe56b9e6SYuval Mintz
193fe56b9e6SYuval Mintz /***************************************************************************
194fe56b9e6SYuval Mintz * HSI access
195fe56b9e6SYuval Mintz ***************************************************************************/
qed_spq_hw_initialize(struct qed_hwfn * p_hwfn,struct qed_spq * p_spq)196fe56b9e6SYuval Mintz static void qed_spq_hw_initialize(struct qed_hwfn *p_hwfn,
197fe56b9e6SYuval Mintz struct qed_spq *p_spq)
198fe56b9e6SYuval Mintz {
199fb09a1edSShai Malin struct core_conn_context *p_cxt;
200b5a9ee7cSAriel Elior struct qed_cxt_info cxt_info;
201b5a9ee7cSAriel Elior u16 physical_q;
202fe56b9e6SYuval Mintz int rc;
203fe56b9e6SYuval Mintz
204fe56b9e6SYuval Mintz cxt_info.iid = p_spq->cid;
205fe56b9e6SYuval Mintz
206fe56b9e6SYuval Mintz rc = qed_cxt_get_cid_info(p_hwfn, &cxt_info);
207fe56b9e6SYuval Mintz
208fe56b9e6SYuval Mintz if (rc < 0) {
209fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn, "Cannot find context info for cid=%d\n",
210fe56b9e6SYuval Mintz p_spq->cid);
211fe56b9e6SYuval Mintz return;
212fe56b9e6SYuval Mintz }
213fe56b9e6SYuval Mintz
214fe56b9e6SYuval Mintz p_cxt = cxt_info.p_cxt;
215fe56b9e6SYuval Mintz
216fe56b9e6SYuval Mintz SET_FIELD(p_cxt->xstorm_ag_context.flags10,
217fb09a1edSShai Malin XSTORM_CORE_CONN_AG_CTX_DQ_CF_EN, 1);
218fe56b9e6SYuval Mintz SET_FIELD(p_cxt->xstorm_ag_context.flags1,
219fb09a1edSShai Malin XSTORM_CORE_CONN_AG_CTX_DQ_CF_ACTIVE, 1);
220fe56b9e6SYuval Mintz SET_FIELD(p_cxt->xstorm_ag_context.flags9,
221fb09a1edSShai Malin XSTORM_CORE_CONN_AG_CTX_CONSOLID_PROD_CF_EN, 1);
222fe56b9e6SYuval Mintz
223fe56b9e6SYuval Mintz /* QM physical queue */
224b5a9ee7cSAriel Elior physical_q = qed_get_cm_pq_idx(p_hwfn, PQ_FLAGS_LB);
225b5a9ee7cSAriel Elior p_cxt->xstorm_ag_context.physical_q0 = cpu_to_le16(physical_q);
226fe56b9e6SYuval Mintz
227fe40a830SPrabhakar Kushwaha p_cxt->xstorm_st_context.spq_base_addr.lo =
228fe56b9e6SYuval Mintz DMA_LO_LE(p_spq->chain.p_phys_addr);
229fe40a830SPrabhakar Kushwaha p_cxt->xstorm_st_context.spq_base_addr.hi =
230fe56b9e6SYuval Mintz DMA_HI_LE(p_spq->chain.p_phys_addr);
231fe56b9e6SYuval Mintz }
232fe56b9e6SYuval Mintz
qed_spq_hw_post(struct qed_hwfn * p_hwfn,struct qed_spq * p_spq,struct qed_spq_entry * p_ent)233fe56b9e6SYuval Mintz static int qed_spq_hw_post(struct qed_hwfn *p_hwfn,
2341a635e48SYuval Mintz struct qed_spq *p_spq, struct qed_spq_entry *p_ent)
235fe56b9e6SYuval Mintz {
236fe56b9e6SYuval Mintz struct qed_chain *p_chain = &p_hwfn->p_spq->chain;
2379ecd8c3fSAriel Elior struct core_db_data *p_db_data = &p_spq->db_data;
23876a9a364STomer Tayar u16 echo = qed_chain_get_prod_idx(p_chain);
239fe56b9e6SYuval Mintz struct slow_path_element *elem;
240fe56b9e6SYuval Mintz
24176a9a364STomer Tayar p_ent->elem.hdr.echo = cpu_to_le16(echo);
242fe56b9e6SYuval Mintz elem = qed_chain_produce(p_chain);
243fe56b9e6SYuval Mintz if (!elem) {
244fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn, "Failed to produce from SPQ chain\n");
245fe56b9e6SYuval Mintz return -EINVAL;
246fe56b9e6SYuval Mintz }
247fe56b9e6SYuval Mintz
248fe56b9e6SYuval Mintz *elem = p_ent->elem; /* struct assignment */
249fe56b9e6SYuval Mintz
250fe56b9e6SYuval Mintz /* send a doorbell on the slow hwfn session */
2519ecd8c3fSAriel Elior p_db_data->spq_prod = cpu_to_le16(qed_chain_get_prod_idx(p_chain));
252fe56b9e6SYuval Mintz
25334c7bb47SSudarsana Reddy Kalluru /* make sure the SPQE is updated before the doorbell */
25434c7bb47SSudarsana Reddy Kalluru wmb();
255fe56b9e6SYuval Mintz
2569ecd8c3fSAriel Elior DOORBELL(p_hwfn, p_spq->db_addr_offset, *(u32 *)p_db_data);
257fe56b9e6SYuval Mintz
258fe56b9e6SYuval Mintz /* make sure doorbell is rang */
25934c7bb47SSudarsana Reddy Kalluru wmb();
260fe56b9e6SYuval Mintz
261fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
262fe56b9e6SYuval Mintz "Doorbelled [0x%08x, CID 0x%08x] with Flags: %02x agg_params: %02x, prod: %04x\n",
2639ecd8c3fSAriel Elior p_spq->db_addr_offset,
2649ecd8c3fSAriel Elior p_spq->cid,
2659ecd8c3fSAriel Elior p_db_data->params,
2669ecd8c3fSAriel Elior p_db_data->agg_flags, qed_chain_get_prod_idx(p_chain));
267fe56b9e6SYuval Mintz
268fe56b9e6SYuval Mintz return 0;
269fe56b9e6SYuval Mintz }
270fe56b9e6SYuval Mintz
271fe56b9e6SYuval Mintz /***************************************************************************
272fe56b9e6SYuval Mintz * Asynchronous events
273fe56b9e6SYuval Mintz ***************************************************************************/
274fe56b9e6SYuval Mintz static int
qed_async_event_completion(struct qed_hwfn * p_hwfn,struct event_ring_entry * p_eqe)275fe56b9e6SYuval Mintz qed_async_event_completion(struct qed_hwfn *p_hwfn,
276fe56b9e6SYuval Mintz struct event_ring_entry *p_eqe)
277fe56b9e6SYuval Mintz {
2786c9e80eaSMichal Kalderon qed_spq_async_comp_cb cb;
2796c9e80eaSMichal Kalderon
280*7e9979e3SPrabhakar Kushwaha if (!p_hwfn->p_spq)
281fc831825SYuval Mintz return -EINVAL;
282fc831825SYuval Mintz
283*7e9979e3SPrabhakar Kushwaha if (p_eqe->protocol_id >= MAX_PROTOCOL_TYPE) {
284*7e9979e3SPrabhakar Kushwaha DP_ERR(p_hwfn, "Wrong protocol: %s:%d\n",
285*7e9979e3SPrabhakar Kushwaha qed_get_protocol_type_str(p_eqe->protocol_id),
286*7e9979e3SPrabhakar Kushwaha p_eqe->protocol_id);
287*7e9979e3SPrabhakar Kushwaha
288*7e9979e3SPrabhakar Kushwaha return -EINVAL;
289*7e9979e3SPrabhakar Kushwaha }
290*7e9979e3SPrabhakar Kushwaha
2916c9e80eaSMichal Kalderon cb = p_hwfn->p_spq->async_comp_cb[p_eqe->protocol_id];
2926c9e80eaSMichal Kalderon if (cb) {
2936c9e80eaSMichal Kalderon return cb(p_hwfn, p_eqe->opcode, p_eqe->echo,
2946c9e80eaSMichal Kalderon &p_eqe->data, p_eqe->fw_return_code);
295fc831825SYuval Mintz } else {
296fc831825SYuval Mintz DP_NOTICE(p_hwfn,
297*7e9979e3SPrabhakar Kushwaha "Unknown Async completion for %s:%d\n",
298*7e9979e3SPrabhakar Kushwaha qed_get_protocol_type_str(p_eqe->protocol_id),
299fe56b9e6SYuval Mintz p_eqe->protocol_id);
300*7e9979e3SPrabhakar Kushwaha
301fe56b9e6SYuval Mintz return -EINVAL;
302fe56b9e6SYuval Mintz }
30337bff2b9SYuval Mintz }
304fe56b9e6SYuval Mintz
3056c9e80eaSMichal Kalderon int
qed_spq_register_async_cb(struct qed_hwfn * p_hwfn,enum protocol_type protocol_id,qed_spq_async_comp_cb cb)3066c9e80eaSMichal Kalderon qed_spq_register_async_cb(struct qed_hwfn *p_hwfn,
3076c9e80eaSMichal Kalderon enum protocol_type protocol_id,
3086c9e80eaSMichal Kalderon qed_spq_async_comp_cb cb)
3096c9e80eaSMichal Kalderon {
3106c9e80eaSMichal Kalderon if (!p_hwfn->p_spq || (protocol_id >= MAX_PROTOCOL_TYPE))
3116c9e80eaSMichal Kalderon return -EINVAL;
3126c9e80eaSMichal Kalderon
3136c9e80eaSMichal Kalderon p_hwfn->p_spq->async_comp_cb[protocol_id] = cb;
3146c9e80eaSMichal Kalderon return 0;
3156c9e80eaSMichal Kalderon }
3166c9e80eaSMichal Kalderon
3176c9e80eaSMichal Kalderon void
qed_spq_unregister_async_cb(struct qed_hwfn * p_hwfn,enum protocol_type protocol_id)3186c9e80eaSMichal Kalderon qed_spq_unregister_async_cb(struct qed_hwfn *p_hwfn,
3196c9e80eaSMichal Kalderon enum protocol_type protocol_id)
3206c9e80eaSMichal Kalderon {
3216c9e80eaSMichal Kalderon if (!p_hwfn->p_spq || (protocol_id >= MAX_PROTOCOL_TYPE))
3226c9e80eaSMichal Kalderon return;
3236c9e80eaSMichal Kalderon
3246c9e80eaSMichal Kalderon p_hwfn->p_spq->async_comp_cb[protocol_id] = NULL;
3256c9e80eaSMichal Kalderon }
3266c9e80eaSMichal Kalderon
327fe56b9e6SYuval Mintz /***************************************************************************
328fe56b9e6SYuval Mintz * EQ API
329fe56b9e6SYuval Mintz ***************************************************************************/
qed_eq_prod_update(struct qed_hwfn * p_hwfn,u16 prod)3301a635e48SYuval Mintz void qed_eq_prod_update(struct qed_hwfn *p_hwfn, u16 prod)
331fe56b9e6SYuval Mintz {
332e2dbc223SPrabhakar Kushwaha u32 addr = GET_GTT_REG_ADDR(GTT_BAR0_MAP_REG_USDM_RAM,
333e2dbc223SPrabhakar Kushwaha USTORM_EQE_CONS, p_hwfn->rel_pf_id);
334fe56b9e6SYuval Mintz
335fe56b9e6SYuval Mintz REG_WR16(p_hwfn, addr, prod);
336fe56b9e6SYuval Mintz }
337fe56b9e6SYuval Mintz
qed_eq_completion(struct qed_hwfn * p_hwfn,void * cookie)3381a635e48SYuval Mintz int qed_eq_completion(struct qed_hwfn *p_hwfn, void *cookie)
339fe56b9e6SYuval Mintz {
340fe56b9e6SYuval Mintz struct qed_eq *p_eq = cookie;
341fe56b9e6SYuval Mintz struct qed_chain *p_chain = &p_eq->chain;
342fe56b9e6SYuval Mintz int rc = 0;
343fe56b9e6SYuval Mintz
344fe56b9e6SYuval Mintz /* take a snapshot of the FW consumer */
345fe56b9e6SYuval Mintz u16 fw_cons_idx = le16_to_cpu(*p_eq->p_fw_cons);
346fe56b9e6SYuval Mintz
347fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_SPQ, "fw_cons_idx %x\n", fw_cons_idx);
348fe56b9e6SYuval Mintz
349fe56b9e6SYuval Mintz /* Need to guarantee the fw_cons index we use points to a usuable
350fe56b9e6SYuval Mintz * element (to comply with our chain), so our macros would comply
351fe56b9e6SYuval Mintz */
352fe56b9e6SYuval Mintz if ((fw_cons_idx & qed_chain_get_usable_per_page(p_chain)) ==
353fe56b9e6SYuval Mintz qed_chain_get_usable_per_page(p_chain))
354fe56b9e6SYuval Mintz fw_cons_idx += qed_chain_get_unusable_per_page(p_chain);
355fe56b9e6SYuval Mintz
356fe56b9e6SYuval Mintz /* Complete current segment of eq entries */
357fe56b9e6SYuval Mintz while (fw_cons_idx != qed_chain_get_cons_idx(p_chain)) {
358fe56b9e6SYuval Mintz struct event_ring_entry *p_eqe = qed_chain_consume(p_chain);
359fe56b9e6SYuval Mintz
360fe56b9e6SYuval Mintz if (!p_eqe) {
361fe56b9e6SYuval Mintz rc = -EINVAL;
362fe56b9e6SYuval Mintz break;
363fe56b9e6SYuval Mintz }
364fe56b9e6SYuval Mintz
365fe56b9e6SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
366fe56b9e6SYuval Mintz "op %x prot %x res0 %x echo %x fwret %x flags %x\n",
367fe56b9e6SYuval Mintz p_eqe->opcode,
368fe56b9e6SYuval Mintz p_eqe->protocol_id,
369fe56b9e6SYuval Mintz p_eqe->reserved0,
370fe56b9e6SYuval Mintz le16_to_cpu(p_eqe->echo),
371fe56b9e6SYuval Mintz p_eqe->fw_return_code,
372fe56b9e6SYuval Mintz p_eqe->flags);
373fe56b9e6SYuval Mintz
374fe56b9e6SYuval Mintz if (GET_FIELD(p_eqe->flags, EVENT_RING_ENTRY_ASYNC)) {
375fe56b9e6SYuval Mintz if (qed_async_event_completion(p_hwfn, p_eqe))
376fe56b9e6SYuval Mintz rc = -EINVAL;
377fe56b9e6SYuval Mintz } else if (qed_spq_completion(p_hwfn,
378fe56b9e6SYuval Mintz p_eqe->echo,
379fe56b9e6SYuval Mintz p_eqe->fw_return_code,
380fe56b9e6SYuval Mintz &p_eqe->data)) {
381fe56b9e6SYuval Mintz rc = -EINVAL;
382fe56b9e6SYuval Mintz }
383fe56b9e6SYuval Mintz
384fe56b9e6SYuval Mintz qed_chain_recycle_consumed(p_chain);
385fe56b9e6SYuval Mintz }
386fe56b9e6SYuval Mintz
387fe56b9e6SYuval Mintz qed_eq_prod_update(p_hwfn, qed_chain_get_prod_idx(p_chain));
388fe56b9e6SYuval Mintz
389660492bcSManish Chopra /* Attempt to post pending requests */
390660492bcSManish Chopra spin_lock_bh(&p_hwfn->p_spq->lock);
391660492bcSManish Chopra rc = qed_spq_pend_post(p_hwfn);
392660492bcSManish Chopra spin_unlock_bh(&p_hwfn->p_spq->lock);
393660492bcSManish Chopra
394fe56b9e6SYuval Mintz return rc;
395fe56b9e6SYuval Mintz }
396fe56b9e6SYuval Mintz
qed_eq_alloc(struct qed_hwfn * p_hwfn,u16 num_elem)3973587cb87STomer Tayar int qed_eq_alloc(struct qed_hwfn *p_hwfn, u16 num_elem)
398fe56b9e6SYuval Mintz {
399b6db3f71SAlexander Lobakin struct qed_chain_init_params params = {
400b6db3f71SAlexander Lobakin .mode = QED_CHAIN_MODE_PBL,
401b6db3f71SAlexander Lobakin .intended_use = QED_CHAIN_USE_TO_PRODUCE,
402b6db3f71SAlexander Lobakin .cnt_type = QED_CHAIN_CNT_TYPE_U16,
403b6db3f71SAlexander Lobakin .num_elems = num_elem,
404b6db3f71SAlexander Lobakin .elem_size = sizeof(union event_ring_element),
405b6db3f71SAlexander Lobakin };
406fe56b9e6SYuval Mintz struct qed_eq *p_eq;
407b6db3f71SAlexander Lobakin int ret;
408fe56b9e6SYuval Mintz
409fe56b9e6SYuval Mintz /* Allocate EQ struct */
41060fffb3bSYuval Mintz p_eq = kzalloc(sizeof(*p_eq), GFP_KERNEL);
4112591c280SJoe Perches if (!p_eq)
4123587cb87STomer Tayar return -ENOMEM;
413fe56b9e6SYuval Mintz
414b6db3f71SAlexander Lobakin ret = qed_chain_alloc(p_hwfn->cdev, &p_eq->chain, ¶ms);
415b6db3f71SAlexander Lobakin if (ret) {
416b6db3f71SAlexander Lobakin DP_NOTICE(p_hwfn, "Failed to allocate EQ chain\n");
417fe56b9e6SYuval Mintz goto eq_allocate_fail;
418b6db3f71SAlexander Lobakin }
419fe56b9e6SYuval Mintz
420fe56b9e6SYuval Mintz /* register EQ completion on the SP SB */
4211a635e48SYuval Mintz qed_int_register_cb(p_hwfn, qed_eq_completion,
4221a635e48SYuval Mintz p_eq, &p_eq->eq_sb_index, &p_eq->p_fw_cons);
423fe56b9e6SYuval Mintz
4243587cb87STomer Tayar p_hwfn->p_eq = p_eq;
4253587cb87STomer Tayar return 0;
426fe56b9e6SYuval Mintz
427fe56b9e6SYuval Mintz eq_allocate_fail:
428fe56b9e6SYuval Mintz kfree(p_eq);
429b6db3f71SAlexander Lobakin
430b6db3f71SAlexander Lobakin return ret;
4313587cb87STomer Tayar }
4323587cb87STomer Tayar
qed_eq_setup(struct qed_hwfn * p_hwfn)4333587cb87STomer Tayar void qed_eq_setup(struct qed_hwfn *p_hwfn)
4343587cb87STomer Tayar {
4353587cb87STomer Tayar qed_chain_reset(&p_hwfn->p_eq->chain);
4363587cb87STomer Tayar }
4373587cb87STomer Tayar
qed_eq_free(struct qed_hwfn * p_hwfn)4383587cb87STomer Tayar void qed_eq_free(struct qed_hwfn *p_hwfn)
4393587cb87STomer Tayar {
4403587cb87STomer Tayar if (!p_hwfn->p_eq)
4413587cb87STomer Tayar return;
4423587cb87STomer Tayar
4433587cb87STomer Tayar qed_chain_free(p_hwfn->cdev, &p_hwfn->p_eq->chain);
4443587cb87STomer Tayar
4453587cb87STomer Tayar kfree(p_hwfn->p_eq);
4463587cb87STomer Tayar p_hwfn->p_eq = NULL;
447fe56b9e6SYuval Mintz }
448fe56b9e6SYuval Mintz
449fe56b9e6SYuval Mintz /***************************************************************************
450cee4d264SManish Chopra * CQE API - manipulate EQ functionality
451cee4d264SManish Chopra ***************************************************************************/
qed_cqe_completion(struct qed_hwfn * p_hwfn,struct eth_slow_path_rx_cqe * cqe,enum protocol_type protocol)4521a635e48SYuval Mintz static int qed_cqe_completion(struct qed_hwfn *p_hwfn,
453cee4d264SManish Chopra struct eth_slow_path_rx_cqe *cqe,
454cee4d264SManish Chopra enum protocol_type protocol)
455cee4d264SManish Chopra {
4561408cc1fSYuval Mintz if (IS_VF(p_hwfn->cdev))
4571408cc1fSYuval Mintz return 0;
4581408cc1fSYuval Mintz
459cee4d264SManish Chopra /* @@@tmp - it's possible we'll eventually want to handle some
460cee4d264SManish Chopra * actual commands that can arrive here, but for now this is only
461cee4d264SManish Chopra * used to complete the ramrod using the echo value on the cqe
462cee4d264SManish Chopra */
463cee4d264SManish Chopra return qed_spq_completion(p_hwfn, cqe->echo, 0, NULL);
464cee4d264SManish Chopra }
465cee4d264SManish Chopra
qed_eth_cqe_completion(struct qed_hwfn * p_hwfn,struct eth_slow_path_rx_cqe * cqe)466cee4d264SManish Chopra int qed_eth_cqe_completion(struct qed_hwfn *p_hwfn,
467cee4d264SManish Chopra struct eth_slow_path_rx_cqe *cqe)
468cee4d264SManish Chopra {
469cee4d264SManish Chopra int rc;
470cee4d264SManish Chopra
471cee4d264SManish Chopra rc = qed_cqe_completion(p_hwfn, cqe, PROTOCOLID_ETH);
472cee4d264SManish Chopra if (rc)
473cee4d264SManish Chopra DP_NOTICE(p_hwfn,
474cee4d264SManish Chopra "Failed to handle RXQ CQE [cmd 0x%02x]\n",
475cee4d264SManish Chopra cqe->ramrod_cmd_id);
476cee4d264SManish Chopra
477cee4d264SManish Chopra return rc;
478cee4d264SManish Chopra }
479cee4d264SManish Chopra
480cee4d264SManish Chopra /***************************************************************************
481fe56b9e6SYuval Mintz * Slow hwfn Queue (spq)
482fe56b9e6SYuval Mintz ***************************************************************************/
qed_spq_setup(struct qed_hwfn * p_hwfn)483fe56b9e6SYuval Mintz void qed_spq_setup(struct qed_hwfn *p_hwfn)
484fe56b9e6SYuval Mintz {
485fe56b9e6SYuval Mintz struct qed_spq *p_spq = p_hwfn->p_spq;
486fe56b9e6SYuval Mintz struct qed_spq_entry *p_virt = NULL;
4879ecd8c3fSAriel Elior struct core_db_data *p_db_data;
4889ecd8c3fSAriel Elior void __iomem *db_addr;
489fe56b9e6SYuval Mintz dma_addr_t p_phys = 0;
490a91eb52aSYuval Mintz u32 i, capacity;
4919ecd8c3fSAriel Elior int rc;
492fe56b9e6SYuval Mintz
493fe56b9e6SYuval Mintz INIT_LIST_HEAD(&p_spq->pending);
494fe56b9e6SYuval Mintz INIT_LIST_HEAD(&p_spq->completion_pending);
495fe56b9e6SYuval Mintz INIT_LIST_HEAD(&p_spq->free_pool);
496fe56b9e6SYuval Mintz INIT_LIST_HEAD(&p_spq->unlimited_pending);
497fe56b9e6SYuval Mintz spin_lock_init(&p_spq->lock);
498fe56b9e6SYuval Mintz
499fe56b9e6SYuval Mintz /* SPQ empty pool */
500fe56b9e6SYuval Mintz p_phys = p_spq->p_phys + offsetof(struct qed_spq_entry, ramrod);
501fe56b9e6SYuval Mintz p_virt = p_spq->p_virt;
502fe56b9e6SYuval Mintz
503a91eb52aSYuval Mintz capacity = qed_chain_get_capacity(&p_spq->chain);
504a91eb52aSYuval Mintz for (i = 0; i < capacity; i++) {
50594494598SYuval Mintz DMA_REGPAIR_LE(p_virt->elem.data_ptr, p_phys);
506fe56b9e6SYuval Mintz
507fe56b9e6SYuval Mintz list_add_tail(&p_virt->list, &p_spq->free_pool);
508fe56b9e6SYuval Mintz
509fe56b9e6SYuval Mintz p_virt++;
510fe56b9e6SYuval Mintz p_phys += sizeof(struct qed_spq_entry);
511fe56b9e6SYuval Mintz }
512fe56b9e6SYuval Mintz
513fe56b9e6SYuval Mintz /* Statistics */
514fe56b9e6SYuval Mintz p_spq->normal_count = 0;
515fe56b9e6SYuval Mintz p_spq->comp_count = 0;
516fe56b9e6SYuval Mintz p_spq->comp_sent_count = 0;
517fe56b9e6SYuval Mintz p_spq->unlimited_pending_count = 0;
51876a9a364STomer Tayar
51976a9a364STomer Tayar bitmap_zero(p_spq->p_comp_bitmap, SPQ_RING_SIZE);
52076a9a364STomer Tayar p_spq->comp_bitmap_idx = 0;
521fe56b9e6SYuval Mintz
522fe56b9e6SYuval Mintz /* SPQ cid, cannot fail */
523fe56b9e6SYuval Mintz qed_cxt_acquire_cid(p_hwfn, PROTOCOLID_CORE, &p_spq->cid);
524fe56b9e6SYuval Mintz qed_spq_hw_initialize(p_hwfn, p_spq);
525fe56b9e6SYuval Mintz
526fe56b9e6SYuval Mintz /* reset the chain itself */
527fe56b9e6SYuval Mintz qed_chain_reset(&p_spq->chain);
5289ecd8c3fSAriel Elior
5299ecd8c3fSAriel Elior /* Initialize the address/data of the SPQ doorbell */
5309ecd8c3fSAriel Elior p_spq->db_addr_offset = qed_db_addr(p_spq->cid, DQ_DEMS_LEGACY);
5319ecd8c3fSAriel Elior p_db_data = &p_spq->db_data;
5329ecd8c3fSAriel Elior memset(p_db_data, 0, sizeof(*p_db_data));
5339ecd8c3fSAriel Elior SET_FIELD(p_db_data->params, CORE_DB_DATA_DEST, DB_DEST_XCM);
5349ecd8c3fSAriel Elior SET_FIELD(p_db_data->params, CORE_DB_DATA_AGG_CMD, DB_AGG_CMD_MAX);
5359ecd8c3fSAriel Elior SET_FIELD(p_db_data->params, CORE_DB_DATA_AGG_VAL_SEL,
5369ecd8c3fSAriel Elior DQ_XCM_CORE_SPQ_PROD_CMD);
5379ecd8c3fSAriel Elior p_db_data->agg_flags = DQ_XCM_CORE_DQ_CF_CMD;
5389ecd8c3fSAriel Elior
5399ecd8c3fSAriel Elior /* Register the SPQ doorbell with the doorbell recovery mechanism */
5409ecd8c3fSAriel Elior db_addr = (void __iomem *)((u8 __iomem *)p_hwfn->doorbells +
5419ecd8c3fSAriel Elior p_spq->db_addr_offset);
5429ecd8c3fSAriel Elior rc = qed_db_recovery_add(p_hwfn->cdev, db_addr, &p_spq->db_data,
5439ecd8c3fSAriel Elior DB_REC_WIDTH_32B, DB_REC_KERNEL);
5449ecd8c3fSAriel Elior if (rc)
5459ecd8c3fSAriel Elior DP_INFO(p_hwfn,
5469ecd8c3fSAriel Elior "Failed to register the SPQ doorbell with the doorbell recovery mechanism\n");
547fe56b9e6SYuval Mintz }
548fe56b9e6SYuval Mintz
qed_spq_alloc(struct qed_hwfn * p_hwfn)549fe56b9e6SYuval Mintz int qed_spq_alloc(struct qed_hwfn *p_hwfn)
550fe56b9e6SYuval Mintz {
551b6db3f71SAlexander Lobakin struct qed_chain_init_params params = {
552b6db3f71SAlexander Lobakin .mode = QED_CHAIN_MODE_SINGLE,
553b6db3f71SAlexander Lobakin .intended_use = QED_CHAIN_USE_TO_PRODUCE,
554b6db3f71SAlexander Lobakin .cnt_type = QED_CHAIN_CNT_TYPE_U16,
555b6db3f71SAlexander Lobakin .elem_size = sizeof(struct slow_path_element),
556b6db3f71SAlexander Lobakin };
557b6db3f71SAlexander Lobakin struct qed_dev *cdev = p_hwfn->cdev;
558a91eb52aSYuval Mintz struct qed_spq_entry *p_virt = NULL;
559fe56b9e6SYuval Mintz struct qed_spq *p_spq = NULL;
560fe56b9e6SYuval Mintz dma_addr_t p_phys = 0;
561a91eb52aSYuval Mintz u32 capacity;
562b6db3f71SAlexander Lobakin int ret;
563fe56b9e6SYuval Mintz
564fe56b9e6SYuval Mintz /* SPQ struct */
565fe40a830SPrabhakar Kushwaha p_spq = kzalloc(sizeof(*p_spq), GFP_KERNEL);
5662591c280SJoe Perches if (!p_spq)
567fe56b9e6SYuval Mintz return -ENOMEM;
568fe56b9e6SYuval Mintz
569fe56b9e6SYuval Mintz /* SPQ ring */
570b6db3f71SAlexander Lobakin ret = qed_chain_alloc(cdev, &p_spq->chain, ¶ms);
571b6db3f71SAlexander Lobakin if (ret) {
572b6db3f71SAlexander Lobakin DP_NOTICE(p_hwfn, "Failed to allocate SPQ chain\n");
573b6db3f71SAlexander Lobakin goto spq_chain_alloc_fail;
574b6db3f71SAlexander Lobakin }
575fe56b9e6SYuval Mintz
576fe56b9e6SYuval Mintz /* allocate and fill the SPQ elements (incl. ramrod data list) */
577a91eb52aSYuval Mintz capacity = qed_chain_get_capacity(&p_spq->chain);
578b6db3f71SAlexander Lobakin ret = -ENOMEM;
579b6db3f71SAlexander Lobakin
580b6db3f71SAlexander Lobakin p_virt = dma_alloc_coherent(&cdev->pdev->dev,
5812591c280SJoe Perches capacity * sizeof(struct qed_spq_entry),
582a91eb52aSYuval Mintz &p_phys, GFP_KERNEL);
583fe56b9e6SYuval Mintz if (!p_virt)
584b6db3f71SAlexander Lobakin goto spq_alloc_fail;
585fe56b9e6SYuval Mintz
586fe56b9e6SYuval Mintz p_spq->p_virt = p_virt;
587fe56b9e6SYuval Mintz p_spq->p_phys = p_phys;
588fe56b9e6SYuval Mintz p_hwfn->p_spq = p_spq;
589fe56b9e6SYuval Mintz
590fe56b9e6SYuval Mintz return 0;
591fe56b9e6SYuval Mintz
592b6db3f71SAlexander Lobakin spq_alloc_fail:
593b6db3f71SAlexander Lobakin qed_chain_free(cdev, &p_spq->chain);
594b6db3f71SAlexander Lobakin spq_chain_alloc_fail:
595fe56b9e6SYuval Mintz kfree(p_spq);
596b6db3f71SAlexander Lobakin
597b6db3f71SAlexander Lobakin return ret;
598fe56b9e6SYuval Mintz }
599fe56b9e6SYuval Mintz
qed_spq_free(struct qed_hwfn * p_hwfn)600fe56b9e6SYuval Mintz void qed_spq_free(struct qed_hwfn *p_hwfn)
601fe56b9e6SYuval Mintz {
602fe56b9e6SYuval Mintz struct qed_spq *p_spq = p_hwfn->p_spq;
6039ecd8c3fSAriel Elior void __iomem *db_addr;
604a91eb52aSYuval Mintz u32 capacity;
605fe56b9e6SYuval Mintz
606fe56b9e6SYuval Mintz if (!p_spq)
607fe56b9e6SYuval Mintz return;
608fe56b9e6SYuval Mintz
6099ecd8c3fSAriel Elior /* Delete the SPQ doorbell from the doorbell recovery mechanism */
6109ecd8c3fSAriel Elior db_addr = (void __iomem *)((u8 __iomem *)p_hwfn->doorbells +
6119ecd8c3fSAriel Elior p_spq->db_addr_offset);
6129ecd8c3fSAriel Elior qed_db_recovery_del(p_hwfn->cdev, db_addr, &p_spq->db_data);
6139ecd8c3fSAriel Elior
614a91eb52aSYuval Mintz if (p_spq->p_virt) {
615a91eb52aSYuval Mintz capacity = qed_chain_get_capacity(&p_spq->chain);
616fe56b9e6SYuval Mintz dma_free_coherent(&p_hwfn->cdev->pdev->dev,
617a91eb52aSYuval Mintz capacity *
618fe56b9e6SYuval Mintz sizeof(struct qed_spq_entry),
619a91eb52aSYuval Mintz p_spq->p_virt, p_spq->p_phys);
620a91eb52aSYuval Mintz }
621fe56b9e6SYuval Mintz
622fe56b9e6SYuval Mintz qed_chain_free(p_hwfn->cdev, &p_spq->chain);
623fe56b9e6SYuval Mintz kfree(p_spq);
6243587cb87STomer Tayar p_hwfn->p_spq = NULL;
625fe56b9e6SYuval Mintz }
626fe56b9e6SYuval Mintz
qed_spq_get_entry(struct qed_hwfn * p_hwfn,struct qed_spq_entry ** pp_ent)6271a635e48SYuval Mintz int qed_spq_get_entry(struct qed_hwfn *p_hwfn, struct qed_spq_entry **pp_ent)
628fe56b9e6SYuval Mintz {
629fe56b9e6SYuval Mintz struct qed_spq *p_spq = p_hwfn->p_spq;
630fe56b9e6SYuval Mintz struct qed_spq_entry *p_ent = NULL;
631fe56b9e6SYuval Mintz int rc = 0;
632fe56b9e6SYuval Mintz
633fe56b9e6SYuval Mintz spin_lock_bh(&p_spq->lock);
634fe56b9e6SYuval Mintz
635fe56b9e6SYuval Mintz if (list_empty(&p_spq->free_pool)) {
636fe56b9e6SYuval Mintz p_ent = kzalloc(sizeof(*p_ent), GFP_ATOMIC);
637fe56b9e6SYuval Mintz if (!p_ent) {
6381a635e48SYuval Mintz DP_NOTICE(p_hwfn,
6391a635e48SYuval Mintz "Failed to allocate an SPQ entry for a pending ramrod\n");
640fe56b9e6SYuval Mintz rc = -ENOMEM;
641fe56b9e6SYuval Mintz goto out_unlock;
642fe56b9e6SYuval Mintz }
643fe56b9e6SYuval Mintz p_ent->queue = &p_spq->unlimited_pending;
644fe56b9e6SYuval Mintz } else {
645fe56b9e6SYuval Mintz p_ent = list_first_entry(&p_spq->free_pool,
6461a635e48SYuval Mintz struct qed_spq_entry, list);
647fe56b9e6SYuval Mintz list_del(&p_ent->list);
648fe56b9e6SYuval Mintz p_ent->queue = &p_spq->pending;
649fe56b9e6SYuval Mintz }
650fe56b9e6SYuval Mintz
651fe56b9e6SYuval Mintz *pp_ent = p_ent;
652fe56b9e6SYuval Mintz
653fe56b9e6SYuval Mintz out_unlock:
654fe56b9e6SYuval Mintz spin_unlock_bh(&p_spq->lock);
655fe56b9e6SYuval Mintz return rc;
656fe56b9e6SYuval Mintz }
657fe56b9e6SYuval Mintz
658fe56b9e6SYuval Mintz /* Locked variant; Should be called while the SPQ lock is taken */
__qed_spq_return_entry(struct qed_hwfn * p_hwfn,struct qed_spq_entry * p_ent)659fe56b9e6SYuval Mintz static void __qed_spq_return_entry(struct qed_hwfn *p_hwfn,
660fe56b9e6SYuval Mintz struct qed_spq_entry *p_ent)
661fe56b9e6SYuval Mintz {
662fe56b9e6SYuval Mintz list_add_tail(&p_ent->list, &p_hwfn->p_spq->free_pool);
663fe56b9e6SYuval Mintz }
664fe56b9e6SYuval Mintz
qed_spq_return_entry(struct qed_hwfn * p_hwfn,struct qed_spq_entry * p_ent)6651a635e48SYuval Mintz void qed_spq_return_entry(struct qed_hwfn *p_hwfn, struct qed_spq_entry *p_ent)
666fe56b9e6SYuval Mintz {
667fe56b9e6SYuval Mintz spin_lock_bh(&p_hwfn->p_spq->lock);
668fe56b9e6SYuval Mintz __qed_spq_return_entry(p_hwfn, p_ent);
669fe56b9e6SYuval Mintz spin_unlock_bh(&p_hwfn->p_spq->lock);
670fe56b9e6SYuval Mintz }
671fe56b9e6SYuval Mintz
672fe56b9e6SYuval Mintz /**
67371e11a3fSAlexander Lobakin * qed_spq_add_entry() - Add a new entry to the pending list.
67471e11a3fSAlexander Lobakin * Should be used while lock is being held.
675fe56b9e6SYuval Mintz *
67671e11a3fSAlexander Lobakin * @p_hwfn: HW device data.
67771e11a3fSAlexander Lobakin * @p_ent: An entry to add.
67871e11a3fSAlexander Lobakin * @priority: Desired priority.
67971e11a3fSAlexander Lobakin *
68071e11a3fSAlexander Lobakin * Adds an entry to the pending list is there is room (an empty
681fe56b9e6SYuval Mintz * element is available in the free_pool), or else places the
682fe56b9e6SYuval Mintz * entry in the unlimited_pending pool.
683fe56b9e6SYuval Mintz *
68471e11a3fSAlexander Lobakin * Return: zero on success, -EINVAL on invalid @priority.
685fe56b9e6SYuval Mintz */
qed_spq_add_entry(struct qed_hwfn * p_hwfn,struct qed_spq_entry * p_ent,enum spq_priority priority)6861a635e48SYuval Mintz static int qed_spq_add_entry(struct qed_hwfn *p_hwfn,
687fe56b9e6SYuval Mintz struct qed_spq_entry *p_ent,
688fe56b9e6SYuval Mintz enum spq_priority priority)
689fe56b9e6SYuval Mintz {
690fe56b9e6SYuval Mintz struct qed_spq *p_spq = p_hwfn->p_spq;
691fe56b9e6SYuval Mintz
692fe56b9e6SYuval Mintz if (p_ent->queue == &p_spq->unlimited_pending) {
693fe56b9e6SYuval Mintz if (list_empty(&p_spq->free_pool)) {
694fe56b9e6SYuval Mintz list_add_tail(&p_ent->list, &p_spq->unlimited_pending);
695fe56b9e6SYuval Mintz p_spq->unlimited_pending_count++;
696fe56b9e6SYuval Mintz
697fe56b9e6SYuval Mintz return 0;
69876a9a364STomer Tayar } else {
69976a9a364STomer Tayar struct qed_spq_entry *p_en2;
700fe56b9e6SYuval Mintz
701fe56b9e6SYuval Mintz p_en2 = list_first_entry(&p_spq->free_pool,
7021a635e48SYuval Mintz struct qed_spq_entry, list);
703fe56b9e6SYuval Mintz list_del(&p_en2->list);
704fe56b9e6SYuval Mintz
70576a9a364STomer Tayar /* Copy the ring element physical pointer to the new
70676a9a364STomer Tayar * entry, since we are about to override the entire ring
70776a9a364STomer Tayar * entry and don't want to lose the pointer.
70876a9a364STomer Tayar */
70976a9a364STomer Tayar p_ent->elem.data_ptr = p_en2->elem.data_ptr;
71076a9a364STomer Tayar
711fe56b9e6SYuval Mintz *p_en2 = *p_ent;
712fe56b9e6SYuval Mintz
713db511c37SYuval Mintz /* EBLOCK responsible to free the allocated p_ent */
714db511c37SYuval Mintz if (p_ent->comp_mode != QED_SPQ_MODE_EBLOCK)
715fe56b9e6SYuval Mintz kfree(p_ent);
7162632f22eSDenis Bolotin else
7172632f22eSDenis Bolotin p_ent->post_ent = p_en2;
718fe56b9e6SYuval Mintz
719fe56b9e6SYuval Mintz p_ent = p_en2;
720fe56b9e6SYuval Mintz }
72176a9a364STomer Tayar }
722fe56b9e6SYuval Mintz
723fe56b9e6SYuval Mintz /* entry is to be placed in 'pending' queue */
724fe56b9e6SYuval Mintz switch (priority) {
725fe56b9e6SYuval Mintz case QED_SPQ_PRIORITY_NORMAL:
726fe56b9e6SYuval Mintz list_add_tail(&p_ent->list, &p_spq->pending);
727fe56b9e6SYuval Mintz p_spq->normal_count++;
728fe56b9e6SYuval Mintz break;
729fe56b9e6SYuval Mintz case QED_SPQ_PRIORITY_HIGH:
730fe56b9e6SYuval Mintz list_add(&p_ent->list, &p_spq->pending);
731fe56b9e6SYuval Mintz p_spq->high_count++;
732fe56b9e6SYuval Mintz break;
733fe56b9e6SYuval Mintz default:
734fe56b9e6SYuval Mintz return -EINVAL;
735fe56b9e6SYuval Mintz }
736fe56b9e6SYuval Mintz
737fe56b9e6SYuval Mintz return 0;
738fe56b9e6SYuval Mintz }
739fe56b9e6SYuval Mintz
740fe56b9e6SYuval Mintz /***************************************************************************
741fe56b9e6SYuval Mintz * Accessor
742fe56b9e6SYuval Mintz ***************************************************************************/
qed_spq_get_cid(struct qed_hwfn * p_hwfn)743fe56b9e6SYuval Mintz u32 qed_spq_get_cid(struct qed_hwfn *p_hwfn)
744fe56b9e6SYuval Mintz {
745fe56b9e6SYuval Mintz if (!p_hwfn->p_spq)
746fe56b9e6SYuval Mintz return 0xffffffff; /* illegal */
747fe56b9e6SYuval Mintz return p_hwfn->p_spq->cid;
748fe56b9e6SYuval Mintz }
749fe56b9e6SYuval Mintz
750fe56b9e6SYuval Mintz /***************************************************************************
751fe56b9e6SYuval Mintz * Posting new Ramrods
752fe56b9e6SYuval Mintz ***************************************************************************/
qed_spq_post_list(struct qed_hwfn * p_hwfn,struct list_head * head,u32 keep_reserve)753fe56b9e6SYuval Mintz static int qed_spq_post_list(struct qed_hwfn *p_hwfn,
7541a635e48SYuval Mintz struct list_head *head, u32 keep_reserve)
755fe56b9e6SYuval Mintz {
756fe56b9e6SYuval Mintz struct qed_spq *p_spq = p_hwfn->p_spq;
757fe56b9e6SYuval Mintz int rc;
758fe56b9e6SYuval Mintz
759fe56b9e6SYuval Mintz while (qed_chain_get_elem_left(&p_spq->chain) > keep_reserve &&
760fe56b9e6SYuval Mintz !list_empty(head)) {
761fe56b9e6SYuval Mintz struct qed_spq_entry *p_ent =
762fe56b9e6SYuval Mintz list_first_entry(head, struct qed_spq_entry, list);
763631e871eSzhong jiang list_move_tail(&p_ent->list, &p_spq->completion_pending);
764fe56b9e6SYuval Mintz p_spq->comp_sent_count++;
765fe56b9e6SYuval Mintz
766fe56b9e6SYuval Mintz rc = qed_spq_hw_post(p_hwfn, p_spq, p_ent);
767fe56b9e6SYuval Mintz if (rc) {
768fe56b9e6SYuval Mintz list_del(&p_ent->list);
769fe56b9e6SYuval Mintz __qed_spq_return_entry(p_hwfn, p_ent);
770fe56b9e6SYuval Mintz return rc;
771fe56b9e6SYuval Mintz }
772fe56b9e6SYuval Mintz }
773fe56b9e6SYuval Mintz
774fe56b9e6SYuval Mintz return 0;
775fe56b9e6SYuval Mintz }
776fe56b9e6SYuval Mintz
qed_spq_pend_post(struct qed_hwfn * p_hwfn)777660492bcSManish Chopra int qed_spq_pend_post(struct qed_hwfn *p_hwfn)
778fe56b9e6SYuval Mintz {
779fe56b9e6SYuval Mintz struct qed_spq *p_spq = p_hwfn->p_spq;
780fe56b9e6SYuval Mintz struct qed_spq_entry *p_ent = NULL;
781fe56b9e6SYuval Mintz
782fe56b9e6SYuval Mintz while (!list_empty(&p_spq->free_pool)) {
783fe56b9e6SYuval Mintz if (list_empty(&p_spq->unlimited_pending))
784fe56b9e6SYuval Mintz break;
785fe56b9e6SYuval Mintz
786fe56b9e6SYuval Mintz p_ent = list_first_entry(&p_spq->unlimited_pending,
7871a635e48SYuval Mintz struct qed_spq_entry, list);
788fe56b9e6SYuval Mintz if (!p_ent)
789fe56b9e6SYuval Mintz return -EINVAL;
790fe56b9e6SYuval Mintz
791fe56b9e6SYuval Mintz list_del(&p_ent->list);
792fe56b9e6SYuval Mintz
793fe56b9e6SYuval Mintz qed_spq_add_entry(p_hwfn, p_ent, p_ent->priority);
794fe56b9e6SYuval Mintz }
795fe56b9e6SYuval Mintz
796fe56b9e6SYuval Mintz return qed_spq_post_list(p_hwfn, &p_spq->pending,
797fe56b9e6SYuval Mintz SPQ_HIGH_PRI_RESERVE_DEFAULT);
798fe56b9e6SYuval Mintz }
799fe56b9e6SYuval Mintz
qed_spq_recov_set_ret_code(struct qed_spq_entry * p_ent,u8 * fw_return_code)80064515dc8STomer Tayar static void qed_spq_recov_set_ret_code(struct qed_spq_entry *p_ent,
80164515dc8STomer Tayar u8 *fw_return_code)
80264515dc8STomer Tayar {
80364515dc8STomer Tayar if (!fw_return_code)
80464515dc8STomer Tayar return;
80564515dc8STomer Tayar
80664515dc8STomer Tayar if (p_ent->elem.hdr.protocol_id == PROTOCOLID_ROCE ||
80764515dc8STomer Tayar p_ent->elem.hdr.protocol_id == PROTOCOLID_IWARP)
80864515dc8STomer Tayar *fw_return_code = RDMA_RETURN_OK;
80964515dc8STomer Tayar }
81064515dc8STomer Tayar
8112632f22eSDenis Bolotin /* Avoid overriding of SPQ entries when getting out-of-order completions, by
8122632f22eSDenis Bolotin * marking the completions in a bitmap and increasing the chain consumer only
8132632f22eSDenis Bolotin * for the first successive completed entries.
8142632f22eSDenis Bolotin */
qed_spq_comp_bmap_update(struct qed_hwfn * p_hwfn,__le16 echo)8152632f22eSDenis Bolotin static void qed_spq_comp_bmap_update(struct qed_hwfn *p_hwfn, __le16 echo)
8162632f22eSDenis Bolotin {
8172632f22eSDenis Bolotin u16 pos = le16_to_cpu(echo) % SPQ_RING_SIZE;
8182632f22eSDenis Bolotin struct qed_spq *p_spq = p_hwfn->p_spq;
8192632f22eSDenis Bolotin
8202632f22eSDenis Bolotin __set_bit(pos, p_spq->p_comp_bitmap);
8212632f22eSDenis Bolotin while (test_bit(p_spq->comp_bitmap_idx,
8222632f22eSDenis Bolotin p_spq->p_comp_bitmap)) {
8232632f22eSDenis Bolotin __clear_bit(p_spq->comp_bitmap_idx,
8242632f22eSDenis Bolotin p_spq->p_comp_bitmap);
8252632f22eSDenis Bolotin p_spq->comp_bitmap_idx++;
8262632f22eSDenis Bolotin qed_chain_return_produced(&p_spq->chain);
8272632f22eSDenis Bolotin }
8282632f22eSDenis Bolotin }
8292632f22eSDenis Bolotin
qed_spq_post(struct qed_hwfn * p_hwfn,struct qed_spq_entry * p_ent,u8 * fw_return_code)830fe56b9e6SYuval Mintz int qed_spq_post(struct qed_hwfn *p_hwfn,
8311a635e48SYuval Mintz struct qed_spq_entry *p_ent, u8 *fw_return_code)
832fe56b9e6SYuval Mintz {
833fe56b9e6SYuval Mintz int rc = 0;
834fe56b9e6SYuval Mintz struct qed_spq *p_spq = p_hwfn ? p_hwfn->p_spq : NULL;
835fe56b9e6SYuval Mintz bool b_ret_ent = true;
83670eeff66SRoland Dreier bool eblock;
837fe56b9e6SYuval Mintz
838fe56b9e6SYuval Mintz if (!p_hwfn)
839fe56b9e6SYuval Mintz return -EINVAL;
840fe56b9e6SYuval Mintz
841fe56b9e6SYuval Mintz if (!p_ent) {
842fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn, "Got a NULL pointer\n");
843fe56b9e6SYuval Mintz return -EINVAL;
844fe56b9e6SYuval Mintz }
845fe56b9e6SYuval Mintz
84664515dc8STomer Tayar if (p_hwfn->cdev->recov_in_prog) {
84764515dc8STomer Tayar DP_VERBOSE(p_hwfn,
84864515dc8STomer Tayar QED_MSG_SPQ,
849*7e9979e3SPrabhakar Kushwaha "Recovery is in progress. Skip spq post [%s:%02x %s:%02x]\n",
850*7e9979e3SPrabhakar Kushwaha qed_get_ramrod_cmd_id_str(p_ent->elem.hdr.protocol_id,
851*7e9979e3SPrabhakar Kushwaha p_ent->elem.hdr.cmd_id),
852*7e9979e3SPrabhakar Kushwaha p_ent->elem.hdr.cmd_id,
853*7e9979e3SPrabhakar Kushwaha qed_get_protocol_type_str(p_ent->elem.hdr.protocol_id),
854*7e9979e3SPrabhakar Kushwaha p_ent->elem.hdr.protocol_id);
85564515dc8STomer Tayar
85664515dc8STomer Tayar /* Let the flow complete w/o any error handling */
85764515dc8STomer Tayar qed_spq_recov_set_ret_code(p_ent, fw_return_code);
85864515dc8STomer Tayar return 0;
85964515dc8STomer Tayar }
86064515dc8STomer Tayar
861fe56b9e6SYuval Mintz /* Complete the entry */
862fe56b9e6SYuval Mintz rc = qed_spq_fill_entry(p_hwfn, p_ent);
863fe56b9e6SYuval Mintz
864fe56b9e6SYuval Mintz spin_lock_bh(&p_spq->lock);
865fe56b9e6SYuval Mintz
866fe56b9e6SYuval Mintz /* Check return value after LOCK is taken for cleaner error flow */
867fe56b9e6SYuval Mintz if (rc)
868fe56b9e6SYuval Mintz goto spq_post_fail;
869fe56b9e6SYuval Mintz
87070eeff66SRoland Dreier /* Check if entry is in block mode before qed_spq_add_entry,
87170eeff66SRoland Dreier * which might kfree p_ent.
87270eeff66SRoland Dreier */
87370eeff66SRoland Dreier eblock = (p_ent->comp_mode == QED_SPQ_MODE_EBLOCK);
87470eeff66SRoland Dreier
875fe56b9e6SYuval Mintz /* Add the request to the pending queue */
876fe56b9e6SYuval Mintz rc = qed_spq_add_entry(p_hwfn, p_ent, p_ent->priority);
877fe56b9e6SYuval Mintz if (rc)
878fe56b9e6SYuval Mintz goto spq_post_fail;
879fe56b9e6SYuval Mintz
880fe56b9e6SYuval Mintz rc = qed_spq_pend_post(p_hwfn);
881fe56b9e6SYuval Mintz if (rc) {
882fe56b9e6SYuval Mintz /* Since it's possible that pending failed for a different
883fe56b9e6SYuval Mintz * entry [although unlikely], the failed entry was already
884fe56b9e6SYuval Mintz * dealt with; No need to return it here.
885fe56b9e6SYuval Mintz */
886fe56b9e6SYuval Mintz b_ret_ent = false;
887fe56b9e6SYuval Mintz goto spq_post_fail;
888fe56b9e6SYuval Mintz }
889fe56b9e6SYuval Mintz
890fe56b9e6SYuval Mintz spin_unlock_bh(&p_spq->lock);
891fe56b9e6SYuval Mintz
89270eeff66SRoland Dreier if (eblock) {
893fe56b9e6SYuval Mintz /* For entries in QED BLOCK mode, the completion code cannot
894fe56b9e6SYuval Mintz * perform the necessary cleanup - if it did, we couldn't
895fe56b9e6SYuval Mintz * access p_ent here to see whether it's successful or not.
896fe56b9e6SYuval Mintz * Thus, after gaining the answer perform the cleanup here.
897fe56b9e6SYuval Mintz */
898c59f5291SYuval Mintz rc = qed_spq_block(p_hwfn, p_ent, fw_return_code,
899c59f5291SYuval Mintz p_ent->queue == &p_spq->unlimited_pending);
900db511c37SYuval Mintz
901db511c37SYuval Mintz if (p_ent->queue == &p_spq->unlimited_pending) {
9022632f22eSDenis Bolotin struct qed_spq_entry *p_post_ent = p_ent->post_ent;
9032632f22eSDenis Bolotin
904db511c37SYuval Mintz kfree(p_ent);
9052632f22eSDenis Bolotin
9062632f22eSDenis Bolotin /* Return the entry which was actually posted */
9072632f22eSDenis Bolotin p_ent = p_post_ent;
908db511c37SYuval Mintz }
909db511c37SYuval Mintz
910fe56b9e6SYuval Mintz if (rc)
911fe56b9e6SYuval Mintz goto spq_post_fail2;
912fe56b9e6SYuval Mintz
913fe56b9e6SYuval Mintz /* return to pool */
914fe56b9e6SYuval Mintz qed_spq_return_entry(p_hwfn, p_ent);
915fe56b9e6SYuval Mintz }
916fe56b9e6SYuval Mintz return rc;
917fe56b9e6SYuval Mintz
918fe56b9e6SYuval Mintz spq_post_fail2:
919fe56b9e6SYuval Mintz spin_lock_bh(&p_spq->lock);
920fe56b9e6SYuval Mintz list_del(&p_ent->list);
9212632f22eSDenis Bolotin qed_spq_comp_bmap_update(p_hwfn, p_ent->elem.hdr.echo);
922fe56b9e6SYuval Mintz
923fe56b9e6SYuval Mintz spq_post_fail:
924fe56b9e6SYuval Mintz /* return to the free pool */
925fe56b9e6SYuval Mintz if (b_ret_ent)
926fe56b9e6SYuval Mintz __qed_spq_return_entry(p_hwfn, p_ent);
927fe56b9e6SYuval Mintz spin_unlock_bh(&p_spq->lock);
928fe56b9e6SYuval Mintz
929fe56b9e6SYuval Mintz return rc;
930fe56b9e6SYuval Mintz }
931fe56b9e6SYuval Mintz
qed_spq_completion(struct qed_hwfn * p_hwfn,__le16 echo,u8 fw_return_code,union event_ring_data * p_data)932fe56b9e6SYuval Mintz int qed_spq_completion(struct qed_hwfn *p_hwfn,
933fe56b9e6SYuval Mintz __le16 echo,
934fe56b9e6SYuval Mintz u8 fw_return_code,
935fe56b9e6SYuval Mintz union event_ring_data *p_data)
936fe56b9e6SYuval Mintz {
937fe56b9e6SYuval Mintz struct qed_spq *p_spq;
938fe56b9e6SYuval Mintz struct qed_spq_entry *p_ent = NULL;
939fe56b9e6SYuval Mintz struct qed_spq_entry *tmp;
940fe56b9e6SYuval Mintz struct qed_spq_entry *found = NULL;
941fe56b9e6SYuval Mintz
942fe56b9e6SYuval Mintz if (!p_hwfn)
943fe56b9e6SYuval Mintz return -EINVAL;
944fe56b9e6SYuval Mintz
945fe56b9e6SYuval Mintz p_spq = p_hwfn->p_spq;
946fe56b9e6SYuval Mintz if (!p_spq)
947fe56b9e6SYuval Mintz return -EINVAL;
948fe56b9e6SYuval Mintz
949fe56b9e6SYuval Mintz spin_lock_bh(&p_spq->lock);
9501a635e48SYuval Mintz list_for_each_entry_safe(p_ent, tmp, &p_spq->completion_pending, list) {
951fe56b9e6SYuval Mintz if (p_ent->elem.hdr.echo == echo) {
952fe56b9e6SYuval Mintz list_del(&p_ent->list);
9532632f22eSDenis Bolotin qed_spq_comp_bmap_update(p_hwfn, echo);
954fe56b9e6SYuval Mintz p_spq->comp_count++;
955fe56b9e6SYuval Mintz found = p_ent;
956fe56b9e6SYuval Mintz break;
957fe56b9e6SYuval Mintz }
95876a9a364STomer Tayar
95976a9a364STomer Tayar /* This is relatively uncommon - depends on scenarios
96076a9a364STomer Tayar * which have mutliple per-PF sent ramrods.
96176a9a364STomer Tayar */
96276a9a364STomer Tayar DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
96376a9a364STomer Tayar "Got completion for echo %04x - doesn't match echo %04x in completion pending list\n",
96476a9a364STomer Tayar le16_to_cpu(echo),
96576a9a364STomer Tayar le16_to_cpu(p_ent->elem.hdr.echo));
966fe56b9e6SYuval Mintz }
967fe56b9e6SYuval Mintz
968fe56b9e6SYuval Mintz /* Release lock before callback, as callback may post
969fe56b9e6SYuval Mintz * an additional ramrod.
970fe56b9e6SYuval Mintz */
971fe56b9e6SYuval Mintz spin_unlock_bh(&p_spq->lock);
972fe56b9e6SYuval Mintz
973fe56b9e6SYuval Mintz if (!found) {
974fe56b9e6SYuval Mintz DP_NOTICE(p_hwfn,
975525ef5c0SYuval Mintz "Failed to find an entry this EQE [echo %04x] completes\n",
976525ef5c0SYuval Mintz le16_to_cpu(echo));
977fe56b9e6SYuval Mintz return -EEXIST;
978fe56b9e6SYuval Mintz }
979fe56b9e6SYuval Mintz
980525ef5c0SYuval Mintz DP_VERBOSE(p_hwfn, QED_MSG_SPQ,
981525ef5c0SYuval Mintz "Complete EQE [echo %04x]: func %p cookie %p)\n",
982525ef5c0SYuval Mintz le16_to_cpu(echo),
983fe56b9e6SYuval Mintz p_ent->comp_cb.function, p_ent->comp_cb.cookie);
984fe56b9e6SYuval Mintz if (found->comp_cb.function)
985fe56b9e6SYuval Mintz found->comp_cb.function(p_hwfn, found->comp_cb.cookie, p_data,
986fe56b9e6SYuval Mintz fw_return_code);
987525ef5c0SYuval Mintz else
988525ef5c0SYuval Mintz DP_VERBOSE(p_hwfn,
989525ef5c0SYuval Mintz QED_MSG_SPQ,
990525ef5c0SYuval Mintz "Got a completion without a callback function\n");
991fe56b9e6SYuval Mintz
9922632f22eSDenis Bolotin if (found->comp_mode != QED_SPQ_MODE_EBLOCK)
993db511c37SYuval Mintz /* EBLOCK is responsible for returning its own entry into the
9942632f22eSDenis Bolotin * free list.
995db511c37SYuval Mintz */
996fe56b9e6SYuval Mintz qed_spq_return_entry(p_hwfn, found);
997fe56b9e6SYuval Mintz
998660492bcSManish Chopra return 0;
999fe56b9e6SYuval Mintz }
1000fe56b9e6SYuval Mintz
1001b6db3f71SAlexander Lobakin #define QED_SPQ_CONSQ_ELEM_SIZE 0x80
1002b6db3f71SAlexander Lobakin
qed_consq_alloc(struct qed_hwfn * p_hwfn)10033587cb87STomer Tayar int qed_consq_alloc(struct qed_hwfn *p_hwfn)
1004fe56b9e6SYuval Mintz {
1005b6db3f71SAlexander Lobakin struct qed_chain_init_params params = {
1006b6db3f71SAlexander Lobakin .mode = QED_CHAIN_MODE_PBL,
1007b6db3f71SAlexander Lobakin .intended_use = QED_CHAIN_USE_TO_PRODUCE,
1008b6db3f71SAlexander Lobakin .cnt_type = QED_CHAIN_CNT_TYPE_U16,
1009b6db3f71SAlexander Lobakin .num_elems = QED_CHAIN_PAGE_SIZE / QED_SPQ_CONSQ_ELEM_SIZE,
1010b6db3f71SAlexander Lobakin .elem_size = QED_SPQ_CONSQ_ELEM_SIZE,
1011b6db3f71SAlexander Lobakin };
1012fe56b9e6SYuval Mintz struct qed_consq *p_consq;
1013b6db3f71SAlexander Lobakin int ret;
1014fe56b9e6SYuval Mintz
1015fe56b9e6SYuval Mintz /* Allocate ConsQ struct */
101660fffb3bSYuval Mintz p_consq = kzalloc(sizeof(*p_consq), GFP_KERNEL);
10172591c280SJoe Perches if (!p_consq)
10183587cb87STomer Tayar return -ENOMEM;
1019fe56b9e6SYuval Mintz
1020b6db3f71SAlexander Lobakin /* Allocate and initialize ConsQ chain */
1021b6db3f71SAlexander Lobakin ret = qed_chain_alloc(p_hwfn->cdev, &p_consq->chain, ¶ms);
1022b6db3f71SAlexander Lobakin if (ret) {
1023b6db3f71SAlexander Lobakin DP_NOTICE(p_hwfn, "Failed to allocate ConsQ chain");
1024b6db3f71SAlexander Lobakin goto consq_alloc_fail;
1025b6db3f71SAlexander Lobakin }
1026fe56b9e6SYuval Mintz
10273587cb87STomer Tayar p_hwfn->p_consq = p_consq;
1028b6db3f71SAlexander Lobakin
10293587cb87STomer Tayar return 0;
1030fe56b9e6SYuval Mintz
1031b6db3f71SAlexander Lobakin consq_alloc_fail:
1032fe56b9e6SYuval Mintz kfree(p_consq);
1033b6db3f71SAlexander Lobakin
1034b6db3f71SAlexander Lobakin return ret;
10353587cb87STomer Tayar }
10363587cb87STomer Tayar
qed_consq_setup(struct qed_hwfn * p_hwfn)10373587cb87STomer Tayar void qed_consq_setup(struct qed_hwfn *p_hwfn)
10383587cb87STomer Tayar {
10393587cb87STomer Tayar qed_chain_reset(&p_hwfn->p_consq->chain);
10403587cb87STomer Tayar }
10413587cb87STomer Tayar
qed_consq_free(struct qed_hwfn * p_hwfn)10423587cb87STomer Tayar void qed_consq_free(struct qed_hwfn *p_hwfn)
10433587cb87STomer Tayar {
10443587cb87STomer Tayar if (!p_hwfn->p_consq)
10453587cb87STomer Tayar return;
10463587cb87STomer Tayar
10473587cb87STomer Tayar qed_chain_free(p_hwfn->cdev, &p_hwfn->p_consq->chain);
10483587cb87STomer Tayar
10493587cb87STomer Tayar kfree(p_hwfn->p_consq);
10503587cb87STomer Tayar p_hwfn->p_consq = NULL;
1051fe56b9e6SYuval Mintz }
1052