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 /* Used as index for completions (returns on EQ by FW) */ 128 u16 echo_idx; 129 130 /* Statistics */ 131 u32 unlimited_pending_count; 132 u32 normal_count; 133 u32 high_count; 134 u32 comp_sent_count; 135 u32 comp_count; 136 137 u32 cid; 138 }; 139 140 /** 141 * @brief qed_spq_post - Posts a Slow hwfn request to FW, or lacking that 142 * Pends it to the future list. 143 * 144 * @param p_hwfn 145 * @param p_req 146 * 147 * @return int 148 */ 149 int qed_spq_post(struct qed_hwfn *p_hwfn, 150 struct qed_spq_entry *p_ent, 151 u8 *fw_return_code); 152 153 /** 154 * @brief qed_spq_allocate - Alloocates & initializes the SPQ and EQ. 155 * 156 * @param p_hwfn 157 * 158 * @return int 159 */ 160 int qed_spq_alloc(struct qed_hwfn *p_hwfn); 161 162 /** 163 * @brief qed_spq_setup - Reset the SPQ to its start state. 164 * 165 * @param p_hwfn 166 */ 167 void qed_spq_setup(struct qed_hwfn *p_hwfn); 168 169 /** 170 * @brief qed_spq_deallocate - Deallocates the given SPQ struct. 171 * 172 * @param p_hwfn 173 */ 174 void qed_spq_free(struct qed_hwfn *p_hwfn); 175 176 /** 177 * @brief qed_spq_get_entry - Obtain an entrry from the spq 178 * free pool list. 179 * 180 * 181 * 182 * @param p_hwfn 183 * @param pp_ent 184 * 185 * @return int 186 */ 187 int 188 qed_spq_get_entry(struct qed_hwfn *p_hwfn, 189 struct qed_spq_entry **pp_ent); 190 191 /** 192 * @brief qed_spq_return_entry - Return an entry to spq free 193 * pool list 194 * 195 * @param p_hwfn 196 * @param p_ent 197 */ 198 void qed_spq_return_entry(struct qed_hwfn *p_hwfn, 199 struct qed_spq_entry *p_ent); 200 /** 201 * @brief qed_eq_allocate - Allocates & initializes an EQ struct 202 * 203 * @param p_hwfn 204 * @param num_elem number of elements in the eq 205 * 206 * @return struct qed_eq* - a newly allocated structure; NULL upon error. 207 */ 208 struct qed_eq *qed_eq_alloc(struct qed_hwfn *p_hwfn, 209 u16 num_elem); 210 211 /** 212 * @brief qed_eq_setup - Reset the SPQ to its start state. 213 * 214 * @param p_hwfn 215 * @param p_eq 216 */ 217 void qed_eq_setup(struct qed_hwfn *p_hwfn, 218 struct qed_eq *p_eq); 219 220 /** 221 * @brief qed_eq_deallocate - deallocates the given EQ struct. 222 * 223 * @param p_hwfn 224 * @param p_eq 225 */ 226 void qed_eq_free(struct qed_hwfn *p_hwfn, 227 struct qed_eq *p_eq); 228 229 /** 230 * @brief qed_eq_prod_update - update the FW with default EQ producer 231 * 232 * @param p_hwfn 233 * @param prod 234 */ 235 void qed_eq_prod_update(struct qed_hwfn *p_hwfn, 236 u16 prod); 237 238 /** 239 * @brief qed_eq_completion - Completes currently pending EQ elements 240 * 241 * @param p_hwfn 242 * @param cookie 243 * 244 * @return int 245 */ 246 int qed_eq_completion(struct qed_hwfn *p_hwfn, 247 void *cookie); 248 249 /** 250 * @brief qed_spq_completion - Completes a single event 251 * 252 * @param p_hwfn 253 * @param echo - echo value from cookie (used for determining completion) 254 * @param p_data - data from cookie (used in callback function if applicable) 255 * 256 * @return int 257 */ 258 int qed_spq_completion(struct qed_hwfn *p_hwfn, 259 __le16 echo, 260 u8 fw_return_code, 261 union event_ring_data *p_data); 262 263 /** 264 * @brief qed_spq_get_cid - Given p_hwfn, return cid for the hwfn's SPQ 265 * 266 * @param p_hwfn 267 * 268 * @return u32 - SPQ CID 269 */ 270 u32 qed_spq_get_cid(struct qed_hwfn *p_hwfn); 271 272 /** 273 * @brief qed_consq_alloc - Allocates & initializes an ConsQ 274 * struct 275 * 276 * @param p_hwfn 277 * 278 * @return struct qed_eq* - a newly allocated structure; NULL upon error. 279 */ 280 struct qed_consq *qed_consq_alloc(struct qed_hwfn *p_hwfn); 281 282 /** 283 * @brief qed_consq_setup - Reset the ConsQ to its start 284 * state. 285 * 286 * @param p_hwfn 287 * @param p_eq 288 */ 289 void qed_consq_setup(struct qed_hwfn *p_hwfn, 290 struct qed_consq *p_consq); 291 292 /** 293 * @brief qed_consq_free - deallocates the given ConsQ struct. 294 * 295 * @param p_hwfn 296 * @param p_eq 297 */ 298 void qed_consq_free(struct qed_hwfn *p_hwfn, 299 struct qed_consq *p_consq); 300 301 /** 302 * @file 303 * 304 * @brief Slow-hwfn low-level commands (Ramrods) function definitions. 305 */ 306 307 #define QED_SP_EQ_COMPLETION 0x01 308 #define QED_SP_CQE_COMPLETION 0x02 309 310 struct qed_sp_init_request_params { 311 size_t ramrod_data_size; 312 enum spq_mode comp_mode; 313 struct qed_spq_comp_cb *p_comp_data; 314 }; 315 316 int qed_sp_init_request(struct qed_hwfn *p_hwfn, 317 struct qed_spq_entry **pp_ent, 318 u32 cid, 319 u16 opaque_fid, 320 u8 cmd, 321 u8 protocol, 322 struct qed_sp_init_request_params *p_params); 323 324 /** 325 * @brief qed_sp_pf_start - PF Function Start Ramrod 326 * 327 * This ramrod is sent to initialize a physical function (PF). It will 328 * configure the function related parameters and write its completion to the 329 * event ring specified in the parameters. 330 * 331 * Ramrods complete on the common event ring for the PF. This ring is 332 * allocated by the driver on host memory and its parameters are written 333 * to the internal RAM of the UStorm by the Function Start Ramrod. 334 * 335 * @param p_hwfn 336 * @param mode 337 * 338 * @return int 339 */ 340 341 int qed_sp_pf_start(struct qed_hwfn *p_hwfn, 342 enum mf_mode mode); 343 344 /** 345 * @brief qed_sp_pf_stop - PF Function Stop Ramrod 346 * 347 * This ramrod is sent to close a Physical Function (PF). It is the last ramrod 348 * sent and the last completion written to the PFs Event Ring. This ramrod also 349 * deletes the context for the Slowhwfn connection on this PF. 350 * 351 * @note Not required for first packet. 352 * 353 * @param p_hwfn 354 * 355 * @return int 356 */ 357 358 int qed_sp_pf_stop(struct qed_hwfn *p_hwfn); 359 360 #endif 361