1 /* QLogic qed NIC Driver 2 * Copyright (c) 2015 QLogic Corporation 3 * 4 * This software is available under the terms of the GNU General Public License 5 * (GPL) Version 2, available from the file COPYING in the main directory of 6 * this source tree. 7 */ 8 9 #ifndef _QED_SP_H 10 #define _QED_SP_H 11 12 #include <linux/types.h> 13 #include <linux/kernel.h> 14 #include <linux/list.h> 15 #include <linux/slab.h> 16 #include <linux/spinlock.h> 17 #include <linux/qed/qed_chain.h> 18 #include "qed.h" 19 #include "qed_hsi.h" 20 21 enum spq_mode { 22 QED_SPQ_MODE_BLOCK, /* Client will poll a designated mem. address */ 23 QED_SPQ_MODE_CB, /* Client supplies a callback */ 24 QED_SPQ_MODE_EBLOCK, /* QED should block until completion */ 25 }; 26 27 struct qed_spq_comp_cb { 28 void (*function)(struct qed_hwfn *, 29 void *, 30 union event_ring_data *, 31 u8 fw_return_code); 32 void *cookie; 33 }; 34 35 /** 36 * @brief qed_eth_cqe_completion - handles the completion of a 37 * ramrod on the cqe ring 38 * 39 * @param p_hwfn 40 * @param cqe 41 * 42 * @return int 43 */ 44 int qed_eth_cqe_completion(struct qed_hwfn *p_hwfn, 45 struct eth_slow_path_rx_cqe *cqe); 46 47 /** 48 * @file 49 * 50 * QED Slow-hwfn queue interface 51 */ 52 53 union ramrod_data { 54 struct pf_start_ramrod_data pf_start; 55 struct rx_queue_start_ramrod_data rx_queue_start; 56 struct rx_queue_update_ramrod_data rx_queue_update; 57 struct rx_queue_stop_ramrod_data rx_queue_stop; 58 struct tx_queue_start_ramrod_data tx_queue_start; 59 struct tx_queue_stop_ramrod_data tx_queue_stop; 60 struct vport_start_ramrod_data vport_start; 61 struct vport_stop_ramrod_data vport_stop; 62 struct vport_update_ramrod_data vport_update; 63 struct vport_filter_update_ramrod_data vport_filter_update; 64 }; 65 66 #define EQ_MAX_CREDIT 0xffffffff 67 68 enum spq_priority { 69 QED_SPQ_PRIORITY_NORMAL, 70 QED_SPQ_PRIORITY_HIGH, 71 }; 72 73 union qed_spq_req_comp { 74 struct qed_spq_comp_cb cb; 75 u64 *done_addr; 76 }; 77 78 struct qed_spq_comp_done { 79 u64 done; 80 u8 fw_return_code; 81 }; 82 83 struct qed_spq_entry { 84 struct list_head list; 85 86 u8 flags; 87 88 /* HSI slow path element */ 89 struct slow_path_element elem; 90 91 union ramrod_data ramrod; 92 93 enum spq_priority priority; 94 95 /* pending queue for this entry */ 96 struct list_head *queue; 97 98 enum spq_mode comp_mode; 99 struct qed_spq_comp_cb comp_cb; 100 struct qed_spq_comp_done comp_done; /* SPQ_MODE_EBLOCK */ 101 }; 102 103 struct qed_eq { 104 struct qed_chain chain; 105 u8 eq_sb_index; /* index within the SB */ 106 __le16 *p_fw_cons; /* ptr to index value */ 107 }; 108 109 struct qed_consq { 110 struct qed_chain chain; 111 }; 112 113 struct qed_spq { 114 spinlock_t lock; /* SPQ lock */ 115 116 struct list_head unlimited_pending; 117 struct list_head pending; 118 struct list_head completion_pending; 119 struct list_head free_pool; 120 121 struct qed_chain chain; 122 123 /* allocated dma-able memory for spq entries (+ramrod data) */ 124 dma_addr_t p_phys; 125 struct qed_spq_entry *p_virt; 126 127 #define SPQ_RING_SIZE \ 128 (CORE_SPQE_PAGE_SIZE_BYTES / sizeof(struct slow_path_element)) 129 130 /* Bitmap for handling out-of-order completions */ 131 DECLARE_BITMAP(p_comp_bitmap, SPQ_RING_SIZE); 132 u8 comp_bitmap_idx; 133 134 /* Statistics */ 135 u32 unlimited_pending_count; 136 u32 normal_count; 137 u32 high_count; 138 u32 comp_sent_count; 139 u32 comp_count; 140 141 u32 cid; 142 }; 143 144 /** 145 * @brief qed_spq_post - Posts a Slow hwfn request to FW, or lacking that 146 * Pends it to the future list. 147 * 148 * @param p_hwfn 149 * @param p_req 150 * 151 * @return int 152 */ 153 int qed_spq_post(struct qed_hwfn *p_hwfn, 154 struct qed_spq_entry *p_ent, 155 u8 *fw_return_code); 156 157 /** 158 * @brief qed_spq_allocate - Alloocates & initializes the SPQ and EQ. 159 * 160 * @param p_hwfn 161 * 162 * @return int 163 */ 164 int qed_spq_alloc(struct qed_hwfn *p_hwfn); 165 166 /** 167 * @brief qed_spq_setup - Reset the SPQ to its start state. 168 * 169 * @param p_hwfn 170 */ 171 void qed_spq_setup(struct qed_hwfn *p_hwfn); 172 173 /** 174 * @brief qed_spq_deallocate - Deallocates the given SPQ struct. 175 * 176 * @param p_hwfn 177 */ 178 void qed_spq_free(struct qed_hwfn *p_hwfn); 179 180 /** 181 * @brief qed_spq_get_entry - Obtain an entrry from the spq 182 * free pool list. 183 * 184 * 185 * 186 * @param p_hwfn 187 * @param pp_ent 188 * 189 * @return int 190 */ 191 int 192 qed_spq_get_entry(struct qed_hwfn *p_hwfn, 193 struct qed_spq_entry **pp_ent); 194 195 /** 196 * @brief qed_spq_return_entry - Return an entry to spq free 197 * pool list 198 * 199 * @param p_hwfn 200 * @param p_ent 201 */ 202 void qed_spq_return_entry(struct qed_hwfn *p_hwfn, 203 struct qed_spq_entry *p_ent); 204 /** 205 * @brief qed_eq_allocate - Allocates & initializes an EQ struct 206 * 207 * @param p_hwfn 208 * @param num_elem number of elements in the eq 209 * 210 * @return struct qed_eq* - a newly allocated structure; NULL upon error. 211 */ 212 struct qed_eq *qed_eq_alloc(struct qed_hwfn *p_hwfn, 213 u16 num_elem); 214 215 /** 216 * @brief qed_eq_setup - Reset the SPQ to its start state. 217 * 218 * @param p_hwfn 219 * @param p_eq 220 */ 221 void qed_eq_setup(struct qed_hwfn *p_hwfn, 222 struct qed_eq *p_eq); 223 224 /** 225 * @brief qed_eq_deallocate - deallocates the given EQ struct. 226 * 227 * @param p_hwfn 228 * @param p_eq 229 */ 230 void qed_eq_free(struct qed_hwfn *p_hwfn, 231 struct qed_eq *p_eq); 232 233 /** 234 * @brief qed_eq_prod_update - update the FW with default EQ producer 235 * 236 * @param p_hwfn 237 * @param prod 238 */ 239 void qed_eq_prod_update(struct qed_hwfn *p_hwfn, 240 u16 prod); 241 242 /** 243 * @brief qed_eq_completion - Completes currently pending EQ elements 244 * 245 * @param p_hwfn 246 * @param cookie 247 * 248 * @return int 249 */ 250 int qed_eq_completion(struct qed_hwfn *p_hwfn, 251 void *cookie); 252 253 /** 254 * @brief qed_spq_completion - Completes a single event 255 * 256 * @param p_hwfn 257 * @param echo - echo value from cookie (used for determining completion) 258 * @param p_data - data from cookie (used in callback function if applicable) 259 * 260 * @return int 261 */ 262 int qed_spq_completion(struct qed_hwfn *p_hwfn, 263 __le16 echo, 264 u8 fw_return_code, 265 union event_ring_data *p_data); 266 267 /** 268 * @brief qed_spq_get_cid - Given p_hwfn, return cid for the hwfn's SPQ 269 * 270 * @param p_hwfn 271 * 272 * @return u32 - SPQ CID 273 */ 274 u32 qed_spq_get_cid(struct qed_hwfn *p_hwfn); 275 276 /** 277 * @brief qed_consq_alloc - Allocates & initializes an ConsQ 278 * struct 279 * 280 * @param p_hwfn 281 * 282 * @return struct qed_eq* - a newly allocated structure; NULL upon error. 283 */ 284 struct qed_consq *qed_consq_alloc(struct qed_hwfn *p_hwfn); 285 286 /** 287 * @brief qed_consq_setup - Reset the ConsQ to its start 288 * state. 289 * 290 * @param p_hwfn 291 * @param p_eq 292 */ 293 void qed_consq_setup(struct qed_hwfn *p_hwfn, 294 struct qed_consq *p_consq); 295 296 /** 297 * @brief qed_consq_free - deallocates the given ConsQ struct. 298 * 299 * @param p_hwfn 300 * @param p_eq 301 */ 302 void qed_consq_free(struct qed_hwfn *p_hwfn, 303 struct qed_consq *p_consq); 304 305 /** 306 * @file 307 * 308 * @brief Slow-hwfn low-level commands (Ramrods) function definitions. 309 */ 310 311 #define QED_SP_EQ_COMPLETION 0x01 312 #define QED_SP_CQE_COMPLETION 0x02 313 314 struct qed_sp_init_request_params { 315 size_t ramrod_data_size; 316 enum spq_mode comp_mode; 317 struct qed_spq_comp_cb *p_comp_data; 318 }; 319 320 int qed_sp_init_request(struct qed_hwfn *p_hwfn, 321 struct qed_spq_entry **pp_ent, 322 u32 cid, 323 u16 opaque_fid, 324 u8 cmd, 325 u8 protocol, 326 struct qed_sp_init_request_params *p_params); 327 328 /** 329 * @brief qed_sp_pf_start - PF Function Start Ramrod 330 * 331 * This ramrod is sent to initialize a physical function (PF). It will 332 * configure the function related parameters and write its completion to the 333 * event ring specified in the parameters. 334 * 335 * Ramrods complete on the common event ring for the PF. This ring is 336 * allocated by the driver on host memory and its parameters are written 337 * to the internal RAM of the UStorm by the Function Start Ramrod. 338 * 339 * @param p_hwfn 340 * @param mode 341 * 342 * @return int 343 */ 344 345 int qed_sp_pf_start(struct qed_hwfn *p_hwfn, 346 enum mf_mode mode); 347 348 /** 349 * @brief qed_sp_pf_stop - PF Function Stop Ramrod 350 * 351 * This ramrod is sent to close a Physical Function (PF). It is the last ramrod 352 * sent and the last completion written to the PFs Event Ring. This ramrod also 353 * deletes the context for the Slowhwfn connection on this PF. 354 * 355 * @note Not required for first packet. 356 * 357 * @param p_hwfn 358 * 359 * @return int 360 */ 361 362 int qed_sp_pf_stop(struct qed_hwfn *p_hwfn); 363 364 #endif 365