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_DEV_API_H 34 #define _QED_DEV_API_H 35 36 #include <linux/types.h> 37 #include <linux/kernel.h> 38 #include <linux/slab.h> 39 #include <linux/qed/qed_chain.h> 40 #include <linux/qed/qed_if.h> 41 #include "qed_int.h" 42 43 /** 44 * @brief qed_init_dp - initialize the debug level 45 * 46 * @param cdev 47 * @param dp_module 48 * @param dp_level 49 */ 50 void qed_init_dp(struct qed_dev *cdev, 51 u32 dp_module, 52 u8 dp_level); 53 54 /** 55 * @brief qed_init_struct - initialize the device structure to 56 * its defaults 57 * 58 * @param cdev 59 */ 60 void qed_init_struct(struct qed_dev *cdev); 61 62 /** 63 * @brief qed_resc_free - 64 * 65 * @param cdev 66 */ 67 void qed_resc_free(struct qed_dev *cdev); 68 69 /** 70 * @brief qed_resc_alloc - 71 * 72 * @param cdev 73 * 74 * @return int 75 */ 76 int qed_resc_alloc(struct qed_dev *cdev); 77 78 /** 79 * @brief qed_resc_setup - 80 * 81 * @param cdev 82 */ 83 void qed_resc_setup(struct qed_dev *cdev); 84 85 enum qed_override_force_load { 86 QED_OVERRIDE_FORCE_LOAD_NONE, 87 QED_OVERRIDE_FORCE_LOAD_ALWAYS, 88 QED_OVERRIDE_FORCE_LOAD_NEVER, 89 }; 90 91 struct qed_drv_load_params { 92 /* Indicates whether the driver is running over a crash kernel. 93 * As part of the load request, this will be used for providing the 94 * driver role to the MFW. 95 * In case of a crash kernel over PDA - this should be set to false. 96 */ 97 bool is_crash_kernel; 98 99 /* The timeout value that the MFW should use when locking the engine for 100 * the driver load process. 101 * A value of '0' means the default value, and '255' means no timeout. 102 */ 103 u8 mfw_timeout_val; 104 #define QED_LOAD_REQ_LOCK_TO_DEFAULT 0 105 #define QED_LOAD_REQ_LOCK_TO_NONE 255 106 107 /* Avoid engine reset when first PF loads on it */ 108 bool avoid_eng_reset; 109 110 /* Allow overriding the default force load behavior */ 111 enum qed_override_force_load override_force_load; 112 }; 113 114 struct qed_hw_init_params { 115 /* Tunneling parameters */ 116 struct qed_tunnel_info *p_tunn; 117 118 bool b_hw_start; 119 120 /* Interrupt mode [msix, inta, etc.] to use */ 121 enum qed_int_mode int_mode; 122 123 /* NPAR tx switching to be used for vports for tx-switching */ 124 bool allow_npar_tx_switch; 125 126 /* Binary fw data pointer in binary fw file */ 127 const u8 *bin_fw_data; 128 129 /* Driver load parameters */ 130 struct qed_drv_load_params *p_drv_load_params; 131 }; 132 133 /** 134 * @brief qed_hw_init - 135 * 136 * @param cdev 137 * @param p_params 138 * 139 * @return int 140 */ 141 int qed_hw_init(struct qed_dev *cdev, struct qed_hw_init_params *p_params); 142 143 /** 144 * @brief qed_hw_timers_stop_all - stop the timers HW block 145 * 146 * @param cdev 147 * 148 * @return void 149 */ 150 void qed_hw_timers_stop_all(struct qed_dev *cdev); 151 152 /** 153 * @brief qed_hw_stop - 154 * 155 * @param cdev 156 * 157 * @return int 158 */ 159 int qed_hw_stop(struct qed_dev *cdev); 160 161 /** 162 * @brief qed_hw_stop_fastpath -should be called incase 163 * slowpath is still required for the device, 164 * but fastpath is not. 165 * 166 * @param cdev 167 * 168 * @return int 169 */ 170 int qed_hw_stop_fastpath(struct qed_dev *cdev); 171 172 /** 173 * @brief qed_hw_start_fastpath -restart fastpath traffic, 174 * only if hw_stop_fastpath was called 175 * 176 * @param p_hwfn 177 * 178 * @return int 179 */ 180 int qed_hw_start_fastpath(struct qed_hwfn *p_hwfn); 181 182 183 /** 184 * @brief qed_hw_prepare - 185 * 186 * @param cdev 187 * @param personality - personality to initialize 188 * 189 * @return int 190 */ 191 int qed_hw_prepare(struct qed_dev *cdev, 192 int personality); 193 194 /** 195 * @brief qed_hw_remove - 196 * 197 * @param cdev 198 */ 199 void qed_hw_remove(struct qed_dev *cdev); 200 201 /** 202 * @brief qed_ptt_acquire - Allocate a PTT window 203 * 204 * Should be called at the entry point to the driver (at the beginning of an 205 * exported function) 206 * 207 * @param p_hwfn 208 * 209 * @return struct qed_ptt 210 */ 211 struct qed_ptt *qed_ptt_acquire(struct qed_hwfn *p_hwfn); 212 213 /** 214 * @brief qed_ptt_release - Release PTT Window 215 * 216 * Should be called at the end of a flow - at the end of the function that 217 * acquired the PTT. 218 * 219 * 220 * @param p_hwfn 221 * @param p_ptt 222 */ 223 void qed_ptt_release(struct qed_hwfn *p_hwfn, 224 struct qed_ptt *p_ptt); 225 void qed_reset_vport_stats(struct qed_dev *cdev); 226 227 enum qed_dmae_address_type_t { 228 QED_DMAE_ADDRESS_HOST_VIRT, 229 QED_DMAE_ADDRESS_HOST_PHYS, 230 QED_DMAE_ADDRESS_GRC 231 }; 232 233 /** 234 * @brief qed_dmae_host2grc - copy data from source addr to 235 * dmae registers using the given ptt 236 * 237 * @param p_hwfn 238 * @param p_ptt 239 * @param source_addr 240 * @param grc_addr (dmae_data_offset) 241 * @param size_in_dwords 242 * @param p_params (default parameters will be used in case of NULL) 243 */ 244 int 245 qed_dmae_host2grc(struct qed_hwfn *p_hwfn, 246 struct qed_ptt *p_ptt, 247 u64 source_addr, 248 u32 grc_addr, 249 u32 size_in_dwords, 250 struct qed_dmae_params *p_params); 251 252 /** 253 * @brief qed_dmae_grc2host - Read data from dmae data offset 254 * to source address using the given ptt 255 * 256 * @param p_ptt 257 * @param grc_addr (dmae_data_offset) 258 * @param dest_addr 259 * @param size_in_dwords 260 * @param p_params (default parameters will be used in case of NULL) 261 */ 262 int qed_dmae_grc2host(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, 263 u32 grc_addr, dma_addr_t dest_addr, u32 size_in_dwords, 264 struct qed_dmae_params *p_params); 265 266 /** 267 * @brief qed_dmae_host2host - copy data from to source address 268 * to a destination adress (for SRIOV) using the given ptt 269 * 270 * @param p_hwfn 271 * @param p_ptt 272 * @param source_addr 273 * @param dest_addr 274 * @param size_in_dwords 275 * @param p_params (default parameters will be used in case of NULL) 276 */ 277 int qed_dmae_host2host(struct qed_hwfn *p_hwfn, 278 struct qed_ptt *p_ptt, 279 dma_addr_t source_addr, 280 dma_addr_t dest_addr, 281 u32 size_in_dwords, struct qed_dmae_params *p_params); 282 283 /** 284 * @brief qed_chain_alloc - Allocate and initialize a chain 285 * 286 * @param p_hwfn 287 * @param intended_use 288 * @param mode 289 * @param num_elems 290 * @param elem_size 291 * @param p_chain 292 * @param ext_pbl - a possible external PBL 293 * 294 * @return int 295 */ 296 int 297 qed_chain_alloc(struct qed_dev *cdev, 298 enum qed_chain_use_mode intended_use, 299 enum qed_chain_mode mode, 300 enum qed_chain_cnt_type cnt_type, 301 u32 num_elems, 302 size_t elem_size, 303 struct qed_chain *p_chain, struct qed_chain_ext_pbl *ext_pbl); 304 305 /** 306 * @brief qed_chain_free - Free chain DMA memory 307 * 308 * @param p_hwfn 309 * @param p_chain 310 */ 311 void qed_chain_free(struct qed_dev *cdev, struct qed_chain *p_chain); 312 313 /** 314 * @@brief qed_fw_l2_queue - Get absolute L2 queue ID 315 * 316 * @param p_hwfn 317 * @param src_id - relative to p_hwfn 318 * @param dst_id - absolute per engine 319 * 320 * @return int 321 */ 322 int qed_fw_l2_queue(struct qed_hwfn *p_hwfn, 323 u16 src_id, 324 u16 *dst_id); 325 326 /** 327 * @@brief qed_fw_vport - Get absolute vport ID 328 * 329 * @param p_hwfn 330 * @param src_id - relative to p_hwfn 331 * @param dst_id - absolute per engine 332 * 333 * @return int 334 */ 335 int qed_fw_vport(struct qed_hwfn *p_hwfn, 336 u8 src_id, 337 u8 *dst_id); 338 339 /** 340 * @@brief qed_fw_rss_eng - Get absolute RSS engine ID 341 * 342 * @param p_hwfn 343 * @param src_id - relative to p_hwfn 344 * @param dst_id - absolute per engine 345 * 346 * @return int 347 */ 348 int qed_fw_rss_eng(struct qed_hwfn *p_hwfn, 349 u8 src_id, 350 u8 *dst_id); 351 352 /** 353 * @brief qed_llh_get_num_ppfid - Return the allocated number of LLH filter 354 * banks that are allocated to the PF. 355 * 356 * @param cdev 357 * 358 * @return u8 - Number of LLH filter banks 359 */ 360 u8 qed_llh_get_num_ppfid(struct qed_dev *cdev); 361 362 enum qed_eng { 363 QED_ENG0, 364 QED_ENG1, 365 QED_BOTH_ENG, 366 }; 367 368 /** 369 * @brief qed_llh_set_ppfid_affinity - Set the engine affinity for the given 370 * LLH filter bank. 371 * 372 * @param cdev 373 * @param ppfid - relative within the allocated ppfids ('0' is the default one). 374 * @param eng 375 * 376 * @return int 377 */ 378 int qed_llh_set_ppfid_affinity(struct qed_dev *cdev, 379 u8 ppfid, enum qed_eng eng); 380 381 /** 382 * @brief qed_llh_set_roce_affinity - Set the RoCE engine affinity 383 * 384 * @param cdev 385 * @param eng 386 * 387 * @return int 388 */ 389 int qed_llh_set_roce_affinity(struct qed_dev *cdev, enum qed_eng eng); 390 391 /** 392 * @brief qed_llh_add_mac_filter - Add a LLH MAC filter into the given filter 393 * bank. 394 * 395 * @param cdev 396 * @param ppfid - relative within the allocated ppfids ('0' is the default one). 397 * @param mac_addr - MAC to add 398 */ 399 int qed_llh_add_mac_filter(struct qed_dev *cdev, 400 u8 ppfid, u8 mac_addr[ETH_ALEN]); 401 402 /** 403 * @brief qed_llh_remove_mac_filter - Remove a LLH MAC filter from the given 404 * filter bank. 405 * 406 * @param p_ptt 407 * @param p_filter - MAC to remove 408 */ 409 void qed_llh_remove_mac_filter(struct qed_dev *cdev, 410 u8 ppfid, u8 mac_addr[ETH_ALEN]); 411 412 enum qed_llh_prot_filter_type_t { 413 QED_LLH_FILTER_ETHERTYPE, 414 QED_LLH_FILTER_TCP_SRC_PORT, 415 QED_LLH_FILTER_TCP_DEST_PORT, 416 QED_LLH_FILTER_TCP_SRC_AND_DEST_PORT, 417 QED_LLH_FILTER_UDP_SRC_PORT, 418 QED_LLH_FILTER_UDP_DEST_PORT, 419 QED_LLH_FILTER_UDP_SRC_AND_DEST_PORT 420 }; 421 422 /** 423 * @brief qed_llh_add_protocol_filter - Add a LLH protocol filter into the 424 * given filter bank. 425 * 426 * @param cdev 427 * @param ppfid - relative within the allocated ppfids ('0' is the default one). 428 * @param type - type of filters and comparing 429 * @param source_port_or_eth_type - source port or ethertype to add 430 * @param dest_port - destination port to add 431 * @param type - type of filters and comparing 432 */ 433 int 434 qed_llh_add_protocol_filter(struct qed_dev *cdev, 435 u8 ppfid, 436 enum qed_llh_prot_filter_type_t type, 437 u16 source_port_or_eth_type, u16 dest_port); 438 439 /** 440 * @brief qed_llh_remove_protocol_filter - Remove a LLH protocol filter from 441 * the given filter bank. 442 * 443 * @param cdev 444 * @param ppfid - relative within the allocated ppfids ('0' is the default one). 445 * @param type - type of filters and comparing 446 * @param source_port_or_eth_type - source port or ethertype to add 447 * @param dest_port - destination port to add 448 */ 449 void 450 qed_llh_remove_protocol_filter(struct qed_dev *cdev, 451 u8 ppfid, 452 enum qed_llh_prot_filter_type_t type, 453 u16 source_port_or_eth_type, u16 dest_port); 454 455 /** 456 * *@brief Cleanup of previous driver remains prior to load 457 * 458 * @param p_hwfn 459 * @param p_ptt 460 * @param id - For PF, engine-relative. For VF, PF-relative. 461 * @param is_vf - true iff cleanup is made for a VF. 462 * 463 * @return int 464 */ 465 int qed_final_cleanup(struct qed_hwfn *p_hwfn, 466 struct qed_ptt *p_ptt, u16 id, bool is_vf); 467 468 /** 469 * @brief qed_get_queue_coalesce - Retrieve coalesce value for a given queue. 470 * 471 * @param p_hwfn 472 * @param p_coal - store coalesce value read from the hardware. 473 * @param p_handle 474 * 475 * @return int 476 **/ 477 int qed_get_queue_coalesce(struct qed_hwfn *p_hwfn, u16 *coal, void *handle); 478 479 /** 480 * @brief qed_set_queue_coalesce - Configure coalesce parameters for Rx and 481 * Tx queue. The fact that we can configure coalescing to up to 511, but on 482 * varying accuracy [the bigger the value the less accurate] up to a mistake 483 * of 3usec for the highest values. 484 * While the API allows setting coalescing per-qid, all queues sharing a SB 485 * should be in same range [i.e., either 0-0x7f, 0x80-0xff or 0x100-0x1ff] 486 * otherwise configuration would break. 487 * 488 * 489 * @param rx_coal - Rx Coalesce value in micro seconds. 490 * @param tx_coal - TX Coalesce value in micro seconds. 491 * @param p_handle 492 * 493 * @return int 494 **/ 495 int 496 qed_set_queue_coalesce(u16 rx_coal, u16 tx_coal, void *p_handle); 497 498 /** 499 * @brief qed_pglueb_set_pfid_enable - Enable or disable PCI BUS MASTER 500 * 501 * @param p_hwfn 502 * @param p_ptt 503 * @param b_enable - true/false 504 * 505 * @return int 506 */ 507 int qed_pglueb_set_pfid_enable(struct qed_hwfn *p_hwfn, 508 struct qed_ptt *p_ptt, bool b_enable); 509 510 /** 511 * @brief db_recovery_add - add doorbell information to the doorbell 512 * recovery mechanism. 513 * 514 * @param cdev 515 * @param db_addr - doorbell address 516 * @param db_data - address of where db_data is stored 517 * @param db_width - doorbell is 32b pr 64b 518 * @param db_space - doorbell recovery addresses are user or kernel space 519 */ 520 int qed_db_recovery_add(struct qed_dev *cdev, 521 void __iomem *db_addr, 522 void *db_data, 523 enum qed_db_rec_width db_width, 524 enum qed_db_rec_space db_space); 525 526 /** 527 * @brief db_recovery_del - remove doorbell information from the doorbell 528 * recovery mechanism. db_data serves as key (db_addr is not unique). 529 * 530 * @param cdev 531 * @param db_addr - doorbell address 532 * @param db_data - address where db_data is stored. Serves as key for the 533 * entry to delete. 534 */ 535 int qed_db_recovery_del(struct qed_dev *cdev, 536 void __iomem *db_addr, void *db_data); 537 538 539 const char *qed_hw_get_resc_name(enum qed_resources res_id); 540 #endif 541