1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License, v.1, (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://opensource.org/licenses/CDDL-1.0. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 22 /* 23 * Copyright 2014-2017 Cavium, Inc. 24 * The contents of this file are subject to the terms of the Common Development 25 * and Distribution License, v.1, (the "License"). 26 27 * You may not use this file except in compliance with the License. 28 29 * You can obtain a copy of the License at available 30 * at http://opensource.org/licenses/CDDL-1.0 31 32 * See the License for the specific language governing permissions and 33 * limitations under the License. 34 */ 35 36 #ifndef __ECORE_MCP_H__ 37 #define __ECORE_MCP_H__ 38 39 #include "bcm_osal.h" 40 #include "mcp_public.h" 41 #include "ecore.h" 42 #include "ecore_mcp_api.h" 43 #include "ecore_dev_api.h" 44 45 /* Using hwfn number (and not pf_num) is required since in CMT mode, 46 * same pf_num may be used by two different hwfn 47 * TODO - this shouldn't really be in .h file, but until all fields 48 * required during hw-init will be placed in their correct place in shmem 49 * we need it in ecore_dev.c [for readin the nvram reflection in shmem]. 50 */ 51 #define MCP_PF_ID_BY_REL(p_hwfn, rel_pfid) (ECORE_IS_BB((p_hwfn)->p_dev) ? \ 52 ((rel_pfid) | \ 53 ((p_hwfn)->abs_pf_id & 1) << 3) : \ 54 rel_pfid) 55 #define MCP_PF_ID(p_hwfn) MCP_PF_ID_BY_REL(p_hwfn, (p_hwfn)->rel_pf_id) 56 57 #define MFW_PORT(_p_hwfn) ((_p_hwfn)->abs_pf_id % \ 58 ((_p_hwfn)->p_dev->num_ports_in_engine * \ 59 ecore_device_num_engines((_p_hwfn)->p_dev))) 60 61 struct ecore_mcp_info { 62 /* Spinlock used for protecting the access to the MFW mailbox */ 63 osal_spinlock_t lock; 64 65 /* Spinglock used for syncing SW link-changes and link-changes 66 * originating from attention context. 67 */ 68 osal_spinlock_t link_lock; 69 70 /* Flag to indicate whether sending a MFW mailbox is forbidden */ 71 bool block_mb_sending; 72 73 /* Address of the MCP public area */ 74 u32 public_base; 75 /* Address of the driver mailbox */ 76 u32 drv_mb_addr; 77 /* Address of the MFW mailbox */ 78 u32 mfw_mb_addr; 79 /* Address of the port configuration (link) */ 80 u32 port_addr; 81 82 /* Current driver mailbox sequence */ 83 u16 drv_mb_seq; 84 /* Current driver pulse sequence */ 85 u16 drv_pulse_seq; 86 87 struct ecore_mcp_link_params link_input; 88 struct ecore_mcp_link_state link_output; 89 struct ecore_mcp_link_capabilities link_capabilities; 90 91 struct ecore_mcp_function_info func_info; 92 93 u8 *mfw_mb_cur; 94 u8 *mfw_mb_shadow; 95 u16 mfw_mb_length; 96 u16 mcp_hist; 97 98 /* Capabilties negotiated with the MFW */ 99 u32 capabilities; 100 }; 101 102 struct ecore_mcp_mb_params { 103 u32 cmd; 104 u32 param; 105 void *p_data_src; 106 u8 data_src_size; 107 void *p_data_dst; 108 u8 data_dst_size; 109 u32 mcp_resp; 110 u32 mcp_param; 111 }; 112 113 enum ecore_ov_eswitch { 114 ECORE_OV_ESWITCH_NONE, 115 ECORE_OV_ESWITCH_VEB, 116 ECORE_OV_ESWITCH_VEPA 117 }; 118 119 struct ecore_drv_tlv_hdr { 120 u8 tlv_type; /* According to the enum below */ 121 u8 tlv_length; /* In dwords - not including this header */ 122 u8 tlv_reserved; 123 #define ECORE_DRV_TLV_FLAGS_CHANGED 0x01 124 u8 tlv_flags; 125 }; 126 127 /** 128 * @brief Initialize the interface with the MCP 129 * 130 * @param p_hwfn - HW func 131 * @param p_ptt - PTT required for register access 132 * 133 * @return enum _ecore_status_t 134 */ 135 enum _ecore_status_t ecore_mcp_cmd_init(struct ecore_hwfn *p_hwfn, 136 struct ecore_ptt *p_ptt); 137 138 /** 139 * @brief Intialize the port interface with the MCP 140 * 141 * @param p_hwfn 142 * @param p_ptt 143 * Can only be called after `num_ports_in_engine' is set 144 */ 145 void ecore_mcp_cmd_port_init(struct ecore_hwfn *p_hwfn, 146 struct ecore_ptt *p_ptt); 147 /** 148 * @brief Releases resources allocated during the init process. 149 * 150 * @param p_hwfn - HW func 151 * @param p_ptt - PTT required for register access 152 * 153 * @return enum _ecore_status_t 154 */ 155 156 enum _ecore_status_t ecore_mcp_free(struct ecore_hwfn *p_hwfn); 157 158 /** 159 * @brief This function is called from the DPC context. After 160 * pointing PTT to the mfw mb, check for events sent by the MCP 161 * to the driver and ack them. In case a critical event 162 * detected, it will be handled here, otherwise the work will be 163 * queued to a sleepable work-queue. 164 * 165 * @param p_hwfn - HW function 166 * @param p_ptt - PTT required for register access 167 * @return enum _ecore_status_t - ECORE_SUCCESS - operation 168 * was successul. 169 */ 170 enum _ecore_status_t ecore_mcp_handle_events(struct ecore_hwfn *p_hwfn, 171 struct ecore_ptt *p_ptt); 172 173 /** 174 * @brief When MFW doesn't get driver pulse for couple of seconds, at some 175 * threshold before timeout expires, it will generate interrupt 176 * through a dedicated status block (DPSB - Driver Pulse Status 177 * Block), which the driver should respond immediately, by 178 * providing keepalive indication after setting the PTT to the 179 * driver-MFW mailbox. This function is called directly from the 180 * DPC upon receiving the DPSB attention. 181 * 182 * @param p_hwfn - hw function 183 * @param p_ptt - PTT required for register access 184 * @return enum _ecore_status_t - ECORE_SUCCESS - operation 185 * was successful. 186 */ 187 enum _ecore_status_t ecore_issue_pulse(struct ecore_hwfn *p_hwfn, 188 struct ecore_ptt *p_ptt); 189 190 enum ecore_drv_role { 191 ECORE_DRV_ROLE_OS, 192 ECORE_DRV_ROLE_KDUMP, 193 }; 194 195 struct ecore_load_req_params { 196 /* Input params */ 197 enum ecore_drv_role drv_role; 198 u8 timeout_val; /* 1..254, '0' - default value, '255' - no timeout */ 199 bool avoid_eng_reset; 200 enum ecore_override_force_load override_force_load; 201 202 /* Output params */ 203 u32 load_code; 204 }; 205 206 /** 207 * @brief Sends a LOAD_REQ to the MFW, and in case the operation succeeds, 208 * returns whether this PF is the first on the engine/port or function. 209 * 210 * @param p_hwfn 211 * @param p_ptt 212 * @param p_params 213 * 214 * @return enum _ecore_status_t - ECORE_SUCCESS - Operation was successful. 215 */ 216 enum _ecore_status_t ecore_mcp_load_req(struct ecore_hwfn *p_hwfn, 217 struct ecore_ptt *p_ptt, 218 struct ecore_load_req_params *p_params); 219 220 /** 221 * @brief Sends a UNLOAD_REQ message to the MFW 222 * 223 * @param p_hwfn 224 * @param p_ptt 225 * 226 * @return enum _ecore_status_t - ECORE_SUCCESS - Operation was successful. 227 */ 228 enum _ecore_status_t ecore_mcp_unload_req(struct ecore_hwfn *p_hwfn, 229 struct ecore_ptt *p_ptt); 230 231 /** 232 * @brief Sends a UNLOAD_DONE message to the MFW 233 * 234 * @param p_hwfn 235 * @param p_ptt 236 * 237 * @return enum _ecore_status_t - ECORE_SUCCESS - Operation was successful. 238 */ 239 enum _ecore_status_t ecore_mcp_unload_done(struct ecore_hwfn *p_hwfn, 240 struct ecore_ptt *p_ptt); 241 242 /** 243 * @brief Read the MFW mailbox into Current buffer. 244 * 245 * @param p_hwfn 246 * @param p_ptt 247 */ 248 void ecore_mcp_read_mb(struct ecore_hwfn *p_hwfn, 249 struct ecore_ptt *p_ptt); 250 251 /** 252 * @brief Ack to mfw that driver finished FLR process for VFs 253 * 254 * @param p_hwfn 255 * @param p_ptt 256 * @param vfs_to_ack - bit mask of all engine VFs for which the PF acks. 257 * 258 * @param return enum _ecore_status_t - ECORE_SUCCESS upon success. 259 */ 260 enum _ecore_status_t ecore_mcp_ack_vf_flr(struct ecore_hwfn *p_hwfn, 261 struct ecore_ptt *p_ptt, 262 u32 *vfs_to_ack); 263 264 /** 265 * @brief - calls during init to read shmem of all function-related info. 266 * 267 * @param p_hwfn 268 * 269 * @param return ECORE_SUCCESS upon success. 270 */ 271 enum _ecore_status_t ecore_mcp_fill_shmem_func_info(struct ecore_hwfn *p_hwfn, 272 struct ecore_ptt *p_ptt); 273 274 /** 275 * @brief - Reset the MCP using mailbox command. 276 * 277 * @param p_hwfn 278 * @param p_ptt 279 * 280 * @param return ECORE_SUCCESS upon success. 281 */ 282 enum _ecore_status_t ecore_mcp_reset(struct ecore_hwfn *p_hwfn, 283 struct ecore_ptt *p_ptt); 284 285 /** 286 * @brief - Sends an NVM write command request to the MFW with 287 * payload. 288 * 289 * @param p_hwfn 290 * @param p_ptt 291 * @param cmd - Command: Either DRV_MSG_CODE_NVM_WRITE_NVRAM or 292 * DRV_MSG_CODE_NVM_PUT_FILE_DATA 293 * @param param - [0:23] - Offset [24:31] - Size 294 * @param o_mcp_resp - MCP response 295 * @param o_mcp_param - MCP response param 296 * @param i_txn_size - Buffer size 297 * @param i_buf - Pointer to the buffer 298 * 299 * @param return ECORE_SUCCESS upon success. 300 */ 301 enum _ecore_status_t ecore_mcp_nvm_wr_cmd(struct ecore_hwfn *p_hwfn, 302 struct ecore_ptt *p_ptt, 303 u32 cmd, 304 u32 param, 305 u32 *o_mcp_resp, 306 u32 *o_mcp_param, 307 u32 i_txn_size, 308 u32 *i_buf); 309 310 /** 311 * @brief - Sends an NVM read command request to the MFW to get 312 * a buffer. 313 * 314 * @param p_hwfn 315 * @param p_ptt 316 * @param cmd - Command: DRV_MSG_CODE_NVM_GET_FILE_DATA or 317 * DRV_MSG_CODE_NVM_READ_NVRAM commands 318 * @param param - [0:23] - Offset [24:31] - Size 319 * @param o_mcp_resp - MCP response 320 * @param o_mcp_param - MCP response param 321 * @param o_txn_size - Buffer size output 322 * @param o_buf - Pointer to the buffer returned by the MFW. 323 * 324 * @param return ECORE_SUCCESS upon success. 325 */ 326 enum _ecore_status_t ecore_mcp_nvm_rd_cmd(struct ecore_hwfn *p_hwfn, 327 struct ecore_ptt *p_ptt, 328 u32 cmd, 329 u32 param, 330 u32 *o_mcp_resp, 331 u32 *o_mcp_param, 332 u32 *o_txn_size, 333 u32 *o_buf); 334 335 /** 336 * @brief indicates whether the MFW objects [under mcp_info] are accessible 337 * 338 * @param p_hwfn 339 * 340 * @return true iff MFW is running and mcp_info is initialized 341 */ 342 bool ecore_mcp_is_init(struct ecore_hwfn *p_hwfn); 343 344 /** 345 * @brief request MFW to configure MSI-X for a VF 346 * 347 * @param p_hwfn 348 * @param p_ptt 349 * @param vf_id - absolute inside engine 350 * @param num_sbs - number of entries to request 351 * 352 * @return enum _ecore_status_t 353 */ 354 enum _ecore_status_t ecore_mcp_config_vf_msix(struct ecore_hwfn *p_hwfn, 355 struct ecore_ptt *p_ptt, 356 u8 vf_id, u8 num); 357 358 /** 359 * @brief - Halt the MCP. 360 * 361 * @param p_hwfn 362 * @param p_ptt 363 * 364 * @param return ECORE_SUCCESS upon success. 365 */ 366 enum _ecore_status_t ecore_mcp_halt(struct ecore_hwfn *p_hwfn, 367 struct ecore_ptt *p_ptt); 368 369 /** 370 * @brief - Wake up the MCP. 371 * 372 * @param p_hwfn 373 * @param p_ptt 374 * 375 * @param return ECORE_SUCCESS upon success. 376 */ 377 enum _ecore_status_t ecore_mcp_resume(struct ecore_hwfn *p_hwfn, 378 struct ecore_ptt *p_ptt); 379 int __ecore_configure_pf_max_bandwidth(struct ecore_hwfn *p_hwfn, 380 struct ecore_ptt *p_ptt, 381 struct ecore_mcp_link_state *p_link, 382 u8 max_bw); 383 int __ecore_configure_pf_min_bandwidth(struct ecore_hwfn *p_hwfn, 384 struct ecore_ptt *p_ptt, 385 struct ecore_mcp_link_state *p_link, 386 u8 min_bw); 387 enum _ecore_status_t ecore_mcp_mask_parities(struct ecore_hwfn *p_hwfn, 388 struct ecore_ptt *p_ptt, 389 u32 mask_parities); 390 #if 0 391 enum _ecore_status_t ecore_hw_init_first_eth(struct ecore_hwfn *p_hwfn, 392 struct ecore_ptt *p_ptt, 393 u8 *p_pf); 394 #endif 395 396 /** 397 * @brief - Sends crash mdump related info to the MFW. 398 * 399 * @param p_hwfn 400 * @param p_ptt 401 * @param epoch 402 * 403 * @param return ECORE_SUCCESS upon success. 404 */ 405 enum _ecore_status_t ecore_mcp_mdump_set_values(struct ecore_hwfn *p_hwfn, 406 struct ecore_ptt *p_ptt, 407 u32 epoch); 408 409 /** 410 * @brief - Triggers a MFW crash dump procedure. 411 * 412 * @param p_hwfn 413 * @param p_ptt 414 * 415 * @param return ECORE_SUCCESS upon success. 416 */ 417 enum _ecore_status_t ecore_mcp_mdump_trigger(struct ecore_hwfn *p_hwfn, 418 struct ecore_ptt *p_ptt); 419 420 struct ecore_mdump_retain_data { 421 u32 valid; 422 u32 epoch; 423 u32 pf; 424 u32 status; 425 }; 426 427 /** 428 * @brief - Gets the mdump retained data from the MFW. 429 * 430 * @param p_hwfn 431 * @param p_ptt 432 * @param p_mdump_retain 433 * 434 * @param return ECORE_SUCCESS upon success. 435 */ 436 enum _ecore_status_t 437 ecore_mcp_mdump_get_retain(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, 438 struct ecore_mdump_retain_data *p_mdump_retain); 439 440 /** 441 * @brief - Clear the mdump retained data. 442 * 443 * @param p_hwfn 444 * @param p_ptt 445 * 446 * @param return ECORE_SUCCESS upon success. 447 */ 448 enum _ecore_status_t ecore_mcp_mdump_clr_retain(struct ecore_hwfn *p_hwfn, 449 struct ecore_ptt *p_ptt); 450 451 /** 452 * @brief - Sets the MFW's max value for the given resource 453 * 454 * @param p_hwfn 455 * @param p_ptt 456 * @param res_id 457 * @param resc_max_val 458 * @param p_mcp_resp 459 * 460 * @return enum _ecore_status_t - ECORE_SUCCESS - operation was successful. 461 */ 462 enum _ecore_status_t 463 ecore_mcp_set_resc_max_val(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, 464 enum ecore_resources res_id, u32 resc_max_val, 465 u32 *p_mcp_resp); 466 467 /** 468 * @brief - Gets the MFW allocation info for the given resource 469 * 470 * @param p_hwfn 471 * @param p_ptt 472 * @param res_id 473 * @param p_mcp_resp 474 * @param p_resc_num 475 * @param p_resc_start 476 * 477 * @return enum _ecore_status_t - ECORE_SUCCESS - operation was successful. 478 */ 479 enum _ecore_status_t 480 ecore_mcp_get_resc_info(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, 481 enum ecore_resources res_id, u32 *p_mcp_resp, 482 u32 *p_resc_num, u32 *p_resc_start); 483 484 /** 485 * @brief - Initiates PF FLR 486 * 487 * @param p_hwfn 488 * @param p_ptt 489 * 490 * @return enum _ecore_status_t - ECORE_SUCCESS - operation was successful. 491 */ 492 enum _ecore_status_t ecore_mcp_initiate_pf_flr(struct ecore_hwfn *p_hwfn, 493 struct ecore_ptt *p_ptt); 494 495 /** 496 * @brief Send eswitch mode to MFW 497 * 498 * @param p_hwfn 499 * @param p_ptt 500 * @param eswitch - eswitch mode 501 * 502 * @return enum _ecore_status_t - ECORE_SUCCESS - operation was successful. 503 */ 504 enum _ecore_status_t 505 ecore_mcp_ov_update_eswitch(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, 506 enum ecore_ov_eswitch eswitch); 507 508 #define ECORE_MCP_RESC_LOCK_MIN_VAL RESOURCE_DUMP /* 0 */ 509 #define ECORE_MCP_RESC_LOCK_MAX_VAL 31 510 511 enum ecore_resc_lock { 512 ECORE_RESC_LOCK_DBG_DUMP = ECORE_MCP_RESC_LOCK_MIN_VAL, 513 /* Locks that the MFW is aware of should be added here downwards */ 514 515 /* Ecore only locks should be added here upwards */ 516 ECORE_RESC_LOCK_PTP_PORT0, 517 ECORE_RESC_LOCK_PTP_PORT1, 518 ECORE_RESC_LOCK_PTP_PORT2, 519 ECORE_RESC_LOCK_PTP_PORT3, 520 ECORE_RESC_LOCK_RESC_ALLOC = ECORE_MCP_RESC_LOCK_MAX_VAL 521 }; 522 523 struct ecore_resc_lock_params { 524 /* Resource number [valid values are 0..31] */ 525 u8 resource; 526 527 /* Lock timeout value in seconds [default, none or 1..254] */ 528 u8 timeout; 529 #define ECORE_MCP_RESC_LOCK_TO_DEFAULT 0 530 #define ECORE_MCP_RESC_LOCK_TO_NONE 255 531 532 /* Number of times to retry locking */ 533 u8 retry_num; 534 535 /* The interval in usec between retries */ 536 u16 retry_interval; 537 538 /* Use sleep or delay between retries */ 539 bool sleep_b4_retry; 540 541 /* Will be set as true if the resource is free and granted */ 542 bool b_granted; 543 544 /* Will be filled with the resource owner. 545 * [0..15 = PF0-15, 16 = MFW, 17 = diag over serial] 546 */ 547 u8 owner; 548 }; 549 550 /** 551 * @brief Acquires MFW generic resource lock 552 * 553 * @param p_hwfn 554 * @param p_ptt 555 * @param p_params 556 * 557 * @return enum _ecore_status_t - ECORE_SUCCESS - operation was successful. 558 */ 559 enum _ecore_status_t 560 ecore_mcp_resc_lock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, 561 struct ecore_resc_lock_params *p_params); 562 563 struct ecore_resc_unlock_params { 564 /* Resource number [valid values are 0..31] */ 565 u8 resource; 566 567 /* Allow to release a resource even if belongs to another PF */ 568 bool b_force; 569 570 /* Will be set as true if the resource is released */ 571 bool b_released; 572 }; 573 574 /** 575 * @brief Releases MFW generic resource lock 576 * 577 * @param p_hwfn 578 * @param p_ptt 579 * @param p_params 580 * 581 * @return enum _ecore_status_t - ECORE_SUCCESS - operation was successful. 582 */ 583 enum _ecore_status_t 584 ecore_mcp_resc_unlock(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, 585 struct ecore_resc_unlock_params *p_params); 586 587 void ecore_mcp_wol_wr(struct ecore_hwfn *p_hwfn, struct ecore_ptt *p_ptt, 588 u32 offset, u32 val); 589 590 /** 591 * @brief Learn of supported MFW features; To be done during early init 592 * 593 * @param p_hwfn 594 * @param p_ptt 595 */ 596 enum _ecore_status_t ecore_mcp_get_capabilities(struct ecore_hwfn *p_hwfn, 597 struct ecore_ptt *p_ptt); 598 599 /** 600 * @brief Inform MFW of set of features supported by driver. Should be done 601 * inside the contet of the LOAD_REQ. 602 * 603 * @param p_hwfn 604 * @param p_ptt 605 */ 606 enum _ecore_status_t ecore_mcp_set_capabilities(struct ecore_hwfn *p_hwfn, 607 struct ecore_ptt *p_ptt); 608 609 /** 610 * @brief Initialize MFW mailbox and sequence values for driver interaction. 611 * 612 * @param p_hwfn 613 * @param p_ptt 614 */ 615 enum _ecore_status_t ecore_load_mcp_offsets(struct ecore_hwfn *p_hwfn, 616 struct ecore_ptt *p_ptt); 617 618 #endif /* __ECORE_MCP_H__ */ 619