1 /* QLogic qed NIC Driver
2  * Copyright (c) 2015-2017  QLogic Corporation
3  *
4  * This software is available to you under a choice of one of two
5  * licenses.  You may choose to be licensed under the terms of the GNU
6  * General Public License (GPL) Version 2, available from the file
7  * COPYING in the main directory of this source tree, or the
8  * OpenIB.org BSD license below:
9  *
10  *     Redistribution and use in source and binary forms, with or
11  *     without modification, are permitted provided that the following
12  *     conditions are met:
13  *
14  *      - Redistributions of source code must retain the above
15  *        copyright notice, this list of conditions and the following
16  *        disclaimer.
17  *
18  *      - Redistributions in binary form must reproduce the above
19  *        copyright notice, this list of conditions and the following
20  *        disclaimer in the documentation and /or other materials
21  *        provided with the distribution.
22  *
23  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
24  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
25  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
26  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
27  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
28  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
29  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
30  * SOFTWARE.
31  */
32 
33 #ifndef _QED_SP_H
34 #define _QED_SP_H
35 
36 #include <linux/types.h>
37 #include <linux/kernel.h>
38 #include <linux/list.h>
39 #include <linux/slab.h>
40 #include <linux/spinlock.h>
41 #include <linux/qed/qed_chain.h>
42 #include "qed.h"
43 #include "qed_hsi.h"
44 
45 enum spq_mode {
46 	QED_SPQ_MODE_BLOCK,     /* Client will poll a designated mem. address */
47 	QED_SPQ_MODE_CB,        /* Client supplies a callback */
48 	QED_SPQ_MODE_EBLOCK,    /* QED should block until completion */
49 };
50 
51 struct qed_spq_comp_cb {
52 	void	(*function)(struct qed_hwfn *,
53 			    void *,
54 			    union event_ring_data *,
55 			    u8 fw_return_code);
56 	void	*cookie;
57 };
58 
59 /**
60  * @brief qed_eth_cqe_completion - handles the completion of a
61  *        ramrod on the cqe ring
62  *
63  * @param p_hwfn
64  * @param cqe
65  *
66  * @return int
67  */
68 int qed_eth_cqe_completion(struct qed_hwfn *p_hwfn,
69 			   struct eth_slow_path_rx_cqe *cqe);
70 
71 /**
72  *  @file
73  *
74  *  QED Slow-hwfn queue interface
75  */
76 
77 union ramrod_data {
78 	struct pf_start_ramrod_data pf_start;
79 	struct pf_update_ramrod_data pf_update;
80 	struct rx_queue_start_ramrod_data rx_queue_start;
81 	struct rx_queue_update_ramrod_data rx_queue_update;
82 	struct rx_queue_stop_ramrod_data rx_queue_stop;
83 	struct tx_queue_start_ramrod_data tx_queue_start;
84 	struct tx_queue_stop_ramrod_data tx_queue_stop;
85 	struct vport_start_ramrod_data vport_start;
86 	struct vport_stop_ramrod_data vport_stop;
87 	struct rx_update_gft_filter_data rx_update_gft;
88 	struct vport_update_ramrod_data vport_update;
89 	struct core_rx_start_ramrod_data core_rx_queue_start;
90 	struct core_rx_stop_ramrod_data core_rx_queue_stop;
91 	struct core_tx_start_ramrod_data core_tx_queue_start;
92 	struct core_tx_stop_ramrod_data core_tx_queue_stop;
93 	struct vport_filter_update_ramrod_data vport_filter_update;
94 
95 	struct rdma_init_func_ramrod_data rdma_init_func;
96 	struct rdma_close_func_ramrod_data rdma_close_func;
97 	struct rdma_register_tid_ramrod_data rdma_register_tid;
98 	struct rdma_deregister_tid_ramrod_data rdma_deregister_tid;
99 	struct roce_create_qp_resp_ramrod_data roce_create_qp_resp;
100 	struct roce_create_qp_req_ramrod_data roce_create_qp_req;
101 	struct roce_modify_qp_resp_ramrod_data roce_modify_qp_resp;
102 	struct roce_modify_qp_req_ramrod_data roce_modify_qp_req;
103 	struct roce_query_qp_resp_ramrod_data roce_query_qp_resp;
104 	struct roce_query_qp_req_ramrod_data roce_query_qp_req;
105 	struct roce_destroy_qp_resp_ramrod_data roce_destroy_qp_resp;
106 	struct roce_destroy_qp_req_ramrod_data roce_destroy_qp_req;
107 	struct roce_init_func_ramrod_data roce_init_func;
108 	struct rdma_create_cq_ramrod_data rdma_create_cq;
109 	struct rdma_destroy_cq_ramrod_data rdma_destroy_cq;
110 	struct rdma_srq_create_ramrod_data rdma_create_srq;
111 	struct rdma_srq_destroy_ramrod_data rdma_destroy_srq;
112 	struct rdma_srq_modify_ramrod_data rdma_modify_srq;
113 	struct iwarp_create_qp_ramrod_data iwarp_create_qp;
114 	struct iwarp_tcp_offload_ramrod_data iwarp_tcp_offload;
115 	struct iwarp_mpa_offload_ramrod_data iwarp_mpa_offload;
116 	struct iwarp_modify_qp_ramrod_data iwarp_modify_qp;
117 	struct iwarp_init_func_ramrod_data iwarp_init_func;
118 	struct fcoe_init_ramrod_params fcoe_init;
119 	struct fcoe_conn_offload_ramrod_params fcoe_conn_ofld;
120 	struct fcoe_conn_terminate_ramrod_params fcoe_conn_terminate;
121 	struct fcoe_stat_ramrod_params fcoe_stat;
122 
123 	struct iscsi_init_ramrod_params iscsi_init;
124 	struct iscsi_spe_conn_offload iscsi_conn_offload;
125 	struct iscsi_conn_update_ramrod_params iscsi_conn_update;
126 	struct iscsi_spe_conn_mac_update iscsi_conn_mac_update;
127 	struct iscsi_spe_conn_termination iscsi_conn_terminate;
128 
129 	struct vf_start_ramrod_data vf_start;
130 	struct vf_stop_ramrod_data vf_stop;
131 };
132 
133 #define EQ_MAX_CREDIT   0xffffffff
134 
135 enum spq_priority {
136 	QED_SPQ_PRIORITY_NORMAL,
137 	QED_SPQ_PRIORITY_HIGH,
138 };
139 
140 union qed_spq_req_comp {
141 	struct qed_spq_comp_cb	cb;
142 	u64			*done_addr;
143 };
144 
145 struct qed_spq_comp_done {
146 	unsigned int	done;
147 	u8		fw_return_code;
148 };
149 
150 struct qed_spq_entry {
151 	struct list_head		list;
152 
153 	u8				flags;
154 
155 	/* HSI slow path element */
156 	struct slow_path_element	elem;
157 
158 	union ramrod_data		ramrod;
159 
160 	enum spq_priority		priority;
161 
162 	/* pending queue for this entry */
163 	struct list_head		*queue;
164 
165 	enum spq_mode			comp_mode;
166 	struct qed_spq_comp_cb		comp_cb;
167 	struct qed_spq_comp_done	comp_done; /* SPQ_MODE_EBLOCK */
168 
169 	/* Posted entry for unlimited list entry in EBLOCK mode */
170 	struct qed_spq_entry		*post_ent;
171 };
172 
173 struct qed_eq {
174 	struct qed_chain	chain;
175 	u8			eq_sb_index;    /* index within the SB */
176 	__le16			*p_fw_cons;     /* ptr to index value */
177 };
178 
179 struct qed_consq {
180 	struct qed_chain chain;
181 };
182 
183 typedef int
184 (*qed_spq_async_comp_cb)(struct qed_hwfn *p_hwfn,
185 			 u8 opcode,
186 			 u16 echo,
187 			 union event_ring_data *data,
188 			 u8 fw_return_code);
189 
190 int
191 qed_spq_register_async_cb(struct qed_hwfn *p_hwfn,
192 			  enum protocol_type protocol_id,
193 			  qed_spq_async_comp_cb cb);
194 
195 void
196 qed_spq_unregister_async_cb(struct qed_hwfn *p_hwfn,
197 			    enum protocol_type protocol_id);
198 
199 struct qed_spq {
200 	spinlock_t		lock; /* SPQ lock */
201 
202 	struct list_head	unlimited_pending;
203 	struct list_head	pending;
204 	struct list_head	completion_pending;
205 	struct list_head	free_pool;
206 
207 	struct qed_chain	chain;
208 
209 	/* allocated dma-able memory for spq entries (+ramrod data) */
210 	dma_addr_t		p_phys;
211 	struct qed_spq_entry	*p_virt;
212 
213 #define SPQ_RING_SIZE \
214 	(CORE_SPQE_PAGE_SIZE_BYTES / sizeof(struct slow_path_element))
215 
216 	/* Bitmap for handling out-of-order completions */
217 	DECLARE_BITMAP(p_comp_bitmap, SPQ_RING_SIZE);
218 	u8			comp_bitmap_idx;
219 
220 	/* Statistics */
221 	u32			unlimited_pending_count;
222 	u32			normal_count;
223 	u32			high_count;
224 	u32			comp_sent_count;
225 	u32			comp_count;
226 
227 	u32			cid;
228 	u32			db_addr_offset;
229 	struct core_db_data	db_data;
230 	qed_spq_async_comp_cb	async_comp_cb[MAX_PROTOCOL_TYPE];
231 };
232 
233 /**
234  * @brief qed_spq_post - Posts a Slow hwfn request to FW, or lacking that
235  *        Pends it to the future list.
236  *
237  * @param p_hwfn
238  * @param p_req
239  *
240  * @return int
241  */
242 int qed_spq_post(struct qed_hwfn *p_hwfn,
243 		 struct qed_spq_entry *p_ent,
244 		 u8 *fw_return_code);
245 
246 /**
247  * @brief qed_spq_allocate - Alloocates & initializes the SPQ and EQ.
248  *
249  * @param p_hwfn
250  *
251  * @return int
252  */
253 int qed_spq_alloc(struct qed_hwfn *p_hwfn);
254 
255 /**
256  * @brief qed_spq_setup - Reset the SPQ to its start state.
257  *
258  * @param p_hwfn
259  */
260 void qed_spq_setup(struct qed_hwfn *p_hwfn);
261 
262 /**
263  * @brief qed_spq_deallocate - Deallocates the given SPQ struct.
264  *
265  * @param p_hwfn
266  */
267 void qed_spq_free(struct qed_hwfn *p_hwfn);
268 
269 /**
270  * @brief qed_spq_get_entry - Obtain an entrry from the spq
271  *        free pool list.
272  *
273  *
274  *
275  * @param p_hwfn
276  * @param pp_ent
277  *
278  * @return int
279  */
280 int
281 qed_spq_get_entry(struct qed_hwfn *p_hwfn,
282 		  struct qed_spq_entry **pp_ent);
283 
284 /**
285  * @brief qed_spq_return_entry - Return an entry to spq free
286  *                                 pool list
287  *
288  * @param p_hwfn
289  * @param p_ent
290  */
291 void qed_spq_return_entry(struct qed_hwfn *p_hwfn,
292 			  struct qed_spq_entry *p_ent);
293 /**
294  * @brief qed_eq_allocate - Allocates & initializes an EQ struct
295  *
296  * @param p_hwfn
297  * @param num_elem number of elements in the eq
298  *
299  * @return int
300  */
301 int qed_eq_alloc(struct qed_hwfn *p_hwfn, u16 num_elem);
302 
303 /**
304  * @brief qed_eq_setup - Reset the EQ to its start state.
305  *
306  * @param p_hwfn
307  */
308 void qed_eq_setup(struct qed_hwfn *p_hwfn);
309 
310 /**
311  * @brief qed_eq_free - deallocates the given EQ struct.
312  *
313  * @param p_hwfn
314  */
315 void qed_eq_free(struct qed_hwfn *p_hwfn);
316 
317 /**
318  * @brief qed_eq_prod_update - update the FW with default EQ producer
319  *
320  * @param p_hwfn
321  * @param prod
322  */
323 void qed_eq_prod_update(struct qed_hwfn *p_hwfn,
324 			u16 prod);
325 
326 /**
327  * @brief qed_eq_completion - Completes currently pending EQ elements
328  *
329  * @param p_hwfn
330  * @param cookie
331  *
332  * @return int
333  */
334 int qed_eq_completion(struct qed_hwfn *p_hwfn,
335 		      void *cookie);
336 
337 /**
338  * @brief qed_spq_completion - Completes a single event
339  *
340  * @param p_hwfn
341  * @param echo - echo value from cookie (used for determining completion)
342  * @param p_data - data from cookie (used in callback function if applicable)
343  *
344  * @return int
345  */
346 int qed_spq_completion(struct qed_hwfn *p_hwfn,
347 		       __le16 echo,
348 		       u8 fw_return_code,
349 		       union event_ring_data *p_data);
350 
351 /**
352  * @brief qed_spq_get_cid - Given p_hwfn, return cid for the hwfn's SPQ
353  *
354  * @param p_hwfn
355  *
356  * @return u32 - SPQ CID
357  */
358 u32 qed_spq_get_cid(struct qed_hwfn *p_hwfn);
359 
360 /**
361  * @brief qed_consq_alloc - Allocates & initializes an ConsQ
362  *        struct
363  *
364  * @param p_hwfn
365  *
366  * @return int
367  */
368 int qed_consq_alloc(struct qed_hwfn *p_hwfn);
369 
370 /**
371  * @brief qed_consq_setup - Reset the ConsQ to its start state.
372  *
373  * @param p_hwfn
374  */
375 void qed_consq_setup(struct qed_hwfn *p_hwfn);
376 
377 /**
378  * @brief qed_consq_free - deallocates the given ConsQ struct.
379  *
380  * @param p_hwfn
381  */
382 void qed_consq_free(struct qed_hwfn *p_hwfn);
383 int qed_spq_pend_post(struct qed_hwfn *p_hwfn);
384 
385 /**
386  * @file
387  *
388  * @brief Slow-hwfn low-level commands (Ramrods) function definitions.
389  */
390 
391 #define QED_SP_EQ_COMPLETION  0x01
392 #define QED_SP_CQE_COMPLETION 0x02
393 
394 struct qed_sp_init_data {
395 	u32			cid;
396 	u16			opaque_fid;
397 
398 	/* Information regarding operation upon sending & completion */
399 	enum spq_mode		comp_mode;
400 	struct qed_spq_comp_cb *p_comp_data;
401 };
402 
403 /**
404  * @brief Returns a SPQ entry to the pool / frees the entry if allocated.
405  *        Should be called on in error flows after initializing the SPQ entry
406  *        and before posting it.
407  *
408  * @param p_hwfn
409  * @param p_ent
410  */
411 void qed_sp_destroy_request(struct qed_hwfn *p_hwfn,
412 			    struct qed_spq_entry *p_ent);
413 
414 int qed_sp_init_request(struct qed_hwfn *p_hwfn,
415 			struct qed_spq_entry **pp_ent,
416 			u8 cmd,
417 			u8 protocol,
418 			struct qed_sp_init_data *p_data);
419 
420 /**
421  * @brief qed_sp_pf_start - PF Function Start Ramrod
422  *
423  * This ramrod is sent to initialize a physical function (PF). It will
424  * configure the function related parameters and write its completion to the
425  * event ring specified in the parameters.
426  *
427  * Ramrods complete on the common event ring for the PF. This ring is
428  * allocated by the driver on host memory and its parameters are written
429  * to the internal RAM of the UStorm by the Function Start Ramrod.
430  *
431  * @param p_hwfn
432  * @param p_ptt
433  * @param p_tunn
434  * @param allow_npar_tx_switch
435  *
436  * @return int
437  */
438 
439 int qed_sp_pf_start(struct qed_hwfn *p_hwfn,
440 		    struct qed_ptt *p_ptt,
441 		    struct qed_tunnel_info *p_tunn,
442 		    bool allow_npar_tx_switch);
443 
444 /**
445  * @brief qed_sp_pf_update - PF Function Update Ramrod
446  *
447  * This ramrod updates function-related parameters. Every parameter can be
448  * updated independently, according to configuration flags.
449  *
450  * @param p_hwfn
451  *
452  * @return int
453  */
454 
455 int qed_sp_pf_update(struct qed_hwfn *p_hwfn);
456 
457 /**
458  * @brief qed_sp_pf_update_stag - Update firmware of new outer tag
459  *
460  * @param p_hwfn
461  *
462  * @return int
463  */
464 int qed_sp_pf_update_stag(struct qed_hwfn *p_hwfn);
465 
466 /**
467  * @brief qed_sp_pf_stop - PF Function Stop Ramrod
468  *
469  * This ramrod is sent to close a Physical Function (PF). It is the last ramrod
470  * sent and the last completion written to the PFs Event Ring. This ramrod also
471  * deletes the context for the Slowhwfn connection on this PF.
472  *
473  * @note Not required for first packet.
474  *
475  * @param p_hwfn
476  *
477  * @return int
478  */
479 
480 /**
481  * @brief qed_sp_pf_update_ufp - PF ufp update Ramrod
482  *
483  * @param p_hwfn
484  *
485  * @return int
486  */
487 int qed_sp_pf_update_ufp(struct qed_hwfn *p_hwfn);
488 
489 int qed_sp_pf_stop(struct qed_hwfn *p_hwfn);
490 
491 int qed_sp_pf_update_tunn_cfg(struct qed_hwfn *p_hwfn,
492 			      struct qed_ptt *p_ptt,
493 			      struct qed_tunnel_info *p_tunn,
494 			      enum spq_mode comp_mode,
495 			      struct qed_spq_comp_cb *p_comp_data);
496 /**
497  * @brief qed_sp_heartbeat_ramrod - Send empty Ramrod
498  *
499  * @param p_hwfn
500  *
501  * @return int
502  */
503 
504 int qed_sp_heartbeat_ramrod(struct qed_hwfn *p_hwfn);
505 
506 #endif
507