xref: /linux/drivers/net/ethernet/qlogic/qed/qed_mcp.h (revision ca2d5f1f)
1 /* SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause) */
2 /* QLogic qed NIC Driver
3  * Copyright (c) 2015-2017  QLogic Corporation
4  * Copyright (c) 2019-2020 Marvell International Ltd.
5  */
6 
7 #ifndef _QED_MCP_H
8 #define _QED_MCP_H
9 
10 #include <linux/types.h>
11 #include <linux/delay.h>
12 #include <linux/slab.h>
13 #include <linux/spinlock.h>
14 #include <linux/qed/qed_fcoe_if.h>
15 #include "qed_hsi.h"
16 #include "qed_dev_api.h"
17 
18 #define QED_MFW_REPORT_STR_SIZE	256
19 
20 struct qed_mcp_link_speed_params {
21 	bool					autoneg;
22 
23 	u32					advertised_speeds;
24 #define QED_EXT_SPEED_MASK_RES			0x1
25 #define QED_EXT_SPEED_MASK_1G			0x2
26 #define QED_EXT_SPEED_MASK_10G			0x4
27 #define QED_EXT_SPEED_MASK_20G			0x8
28 #define QED_EXT_SPEED_MASK_25G			0x10
29 #define QED_EXT_SPEED_MASK_40G			0x20
30 #define QED_EXT_SPEED_MASK_50G_R		0x40
31 #define QED_EXT_SPEED_MASK_50G_R2		0x80
32 #define QED_EXT_SPEED_MASK_100G_R2		0x100
33 #define QED_EXT_SPEED_MASK_100G_R4		0x200
34 #define QED_EXT_SPEED_MASK_100G_P4		0x400
35 
36 	u32					forced_speed;	   /* In Mb/s */
37 #define QED_EXT_SPEED_1G			0x1
38 #define QED_EXT_SPEED_10G			0x2
39 #define QED_EXT_SPEED_20G			0x4
40 #define QED_EXT_SPEED_25G			0x8
41 #define QED_EXT_SPEED_40G			0x10
42 #define QED_EXT_SPEED_50G_R			0x20
43 #define QED_EXT_SPEED_50G_R2			0x40
44 #define QED_EXT_SPEED_100G_R2			0x80
45 #define QED_EXT_SPEED_100G_R4			0x100
46 #define QED_EXT_SPEED_100G_P4			0x200
47 };
48 
49 struct qed_mcp_link_pause_params {
50 	bool					autoneg;
51 	bool					forced_rx;
52 	bool					forced_tx;
53 };
54 
55 enum qed_mcp_eee_mode {
56 	QED_MCP_EEE_DISABLED,
57 	QED_MCP_EEE_ENABLED,
58 	QED_MCP_EEE_UNSUPPORTED
59 };
60 
61 struct qed_mcp_link_params {
62 	struct qed_mcp_link_speed_params	speed;
63 	struct qed_mcp_link_pause_params	pause;
64 	u32					loopback_mode;
65 	struct qed_link_eee_params		eee;
66 	u32					fec;
67 
68 	struct qed_mcp_link_speed_params	ext_speed;
69 	u32					ext_fec_mode;
70 };
71 
72 struct qed_mcp_link_capabilities {
73 	u32					speed_capabilities;
74 	bool					default_speed_autoneg;
75 	u32					fec_default;
76 	enum qed_mcp_eee_mode			default_eee;
77 	u32					eee_lpi_timer;
78 	u8					eee_speed_caps;
79 
80 	u32					default_ext_speed_caps;
81 	u32					default_ext_autoneg;
82 	u32					default_ext_speed;
83 	u32					default_ext_fec;
84 };
85 
86 struct qed_mcp_link_state {
87 	bool					link_up;
88 	u32					min_pf_rate;
89 
90 	/* Actual link speed in Mb/s */
91 	u32					line_speed;
92 
93 	/* PF max speed in Mb/s, deduced from line_speed
94 	 * according to PF max bandwidth configuration.
95 	 */
96 	u32					speed;
97 
98 	bool					full_duplex;
99 	bool					an;
100 	bool					an_complete;
101 	bool					parallel_detection;
102 	bool					pfc_enabled;
103 
104 	u32					partner_adv_speed;
105 #define QED_LINK_PARTNER_SPEED_1G_HD		BIT(0)
106 #define QED_LINK_PARTNER_SPEED_1G_FD		BIT(1)
107 #define QED_LINK_PARTNER_SPEED_10G		BIT(2)
108 #define QED_LINK_PARTNER_SPEED_20G		BIT(3)
109 #define QED_LINK_PARTNER_SPEED_25G		BIT(4)
110 #define QED_LINK_PARTNER_SPEED_40G		BIT(5)
111 #define QED_LINK_PARTNER_SPEED_50G		BIT(6)
112 #define QED_LINK_PARTNER_SPEED_100G		BIT(7)
113 
114 	bool					partner_tx_flow_ctrl_en;
115 	bool					partner_rx_flow_ctrl_en;
116 
117 	u8					partner_adv_pause;
118 #define QED_LINK_PARTNER_SYMMETRIC_PAUSE	0x1
119 #define QED_LINK_PARTNER_ASYMMETRIC_PAUSE	0x2
120 #define QED_LINK_PARTNER_BOTH_PAUSE		0x3
121 
122 	bool					sfp_tx_fault;
123 	bool					eee_active;
124 	u8					eee_adv_caps;
125 	u8					eee_lp_adv_caps;
126 
127 	u32					fec_active;
128 };
129 
130 struct qed_mcp_function_info {
131 	u8				pause_on_host;
132 
133 	enum qed_pci_personality	protocol;
134 
135 	u8				bandwidth_min;
136 	u8				bandwidth_max;
137 
138 	u8				mac[ETH_ALEN];
139 
140 	u64				wwn_port;
141 	u64				wwn_node;
142 
143 #define QED_MCP_VLAN_UNSET              (0xffff)
144 	u16				ovlan;
145 
146 	u16				mtu;
147 };
148 
149 struct qed_mcp_nvm_common {
150 	u32	offset;
151 	u32	param;
152 	u32	resp;
153 	u32	cmd;
154 };
155 
156 struct qed_mcp_drv_version {
157 	u32	version;
158 	u8	name[MCP_DRV_VER_STR_SIZE - 4];
159 };
160 
161 struct qed_mcp_lan_stats {
162 	u64 ucast_rx_pkts;
163 	u64 ucast_tx_pkts;
164 	u32 fcs_err;
165 };
166 
167 struct qed_mcp_fcoe_stats {
168 	u64 rx_pkts;
169 	u64 tx_pkts;
170 	u32 fcs_err;
171 	u32 login_failure;
172 };
173 
174 struct qed_mcp_iscsi_stats {
175 	u64 rx_pdus;
176 	u64 tx_pdus;
177 	u64 rx_bytes;
178 	u64 tx_bytes;
179 };
180 
181 struct qed_mcp_rdma_stats {
182 	u64 rx_pkts;
183 	u64 tx_pkts;
184 	u64 rx_bytes;
185 	u64 tx_byts;
186 };
187 
188 enum qed_mcp_protocol_type {
189 	QED_MCP_LAN_STATS,
190 	QED_MCP_FCOE_STATS,
191 	QED_MCP_ISCSI_STATS,
192 	QED_MCP_RDMA_STATS
193 };
194 
195 union qed_mcp_protocol_stats {
196 	struct qed_mcp_lan_stats lan_stats;
197 	struct qed_mcp_fcoe_stats fcoe_stats;
198 	struct qed_mcp_iscsi_stats iscsi_stats;
199 	struct qed_mcp_rdma_stats rdma_stats;
200 };
201 
202 enum qed_ov_eswitch {
203 	QED_OV_ESWITCH_NONE,
204 	QED_OV_ESWITCH_VEB,
205 	QED_OV_ESWITCH_VEPA
206 };
207 
208 enum qed_ov_client {
209 	QED_OV_CLIENT_DRV,
210 	QED_OV_CLIENT_USER,
211 	QED_OV_CLIENT_VENDOR_SPEC
212 };
213 
214 enum qed_ov_driver_state {
215 	QED_OV_DRIVER_STATE_NOT_LOADED,
216 	QED_OV_DRIVER_STATE_DISABLED,
217 	QED_OV_DRIVER_STATE_ACTIVE
218 };
219 
220 enum qed_ov_wol {
221 	QED_OV_WOL_DEFAULT,
222 	QED_OV_WOL_DISABLED,
223 	QED_OV_WOL_ENABLED
224 };
225 
226 enum qed_mfw_tlv_type {
227 	QED_MFW_TLV_GENERIC = 0x1,	/* Core driver TLVs */
228 	QED_MFW_TLV_ETH = 0x2,		/* L2 driver TLVs */
229 	QED_MFW_TLV_FCOE = 0x4,		/* FCoE protocol TLVs */
230 	QED_MFW_TLV_ISCSI = 0x8,	/* SCSI protocol TLVs */
231 	QED_MFW_TLV_MAX = 0x16,
232 };
233 
234 struct qed_mfw_tlv_generic {
235 #define QED_MFW_TLV_FLAGS_SIZE	2
236 	struct {
237 		u8 ipv4_csum_offload;
238 		u8 lso_supported;
239 		bool b_set;
240 	} flags;
241 
242 #define QED_MFW_TLV_MAC_COUNT 3
243 	/* First entry for primary MAC, 2 secondary MACs possible */
244 	u8 mac[QED_MFW_TLV_MAC_COUNT][6];
245 	bool mac_set[QED_MFW_TLV_MAC_COUNT];
246 
247 	u64 rx_frames;
248 	bool rx_frames_set;
249 	u64 rx_bytes;
250 	bool rx_bytes_set;
251 	u64 tx_frames;
252 	bool tx_frames_set;
253 	u64 tx_bytes;
254 	bool tx_bytes_set;
255 };
256 
257 union qed_mfw_tlv_data {
258 	struct qed_mfw_tlv_generic generic;
259 	struct qed_mfw_tlv_eth eth;
260 	struct qed_mfw_tlv_fcoe fcoe;
261 	struct qed_mfw_tlv_iscsi iscsi;
262 };
263 
264 #define QED_NVM_CFG_OPTION_ALL		BIT(0)
265 #define QED_NVM_CFG_OPTION_INIT		BIT(1)
266 #define QED_NVM_CFG_OPTION_COMMIT       BIT(2)
267 #define QED_NVM_CFG_OPTION_FREE		BIT(3)
268 #define QED_NVM_CFG_OPTION_ENTITY_SEL	BIT(4)
269 
270 /**
271  * qed_mcp_get_link_params(): Returns the link params of the hw function.
272  *
273  * @p_hwfn: HW device data.
274  *
275  * Returns: Pointer to link params.
276  */
277 struct qed_mcp_link_params *qed_mcp_get_link_params(struct qed_hwfn *p_hwfn);
278 
279 /**
280  * qed_mcp_get_link_state(): Return the link state of the hw function.
281  *
282  * @p_hwfn: HW device data.
283  *
284  * Returns: Pointer to link state.
285  */
286 struct qed_mcp_link_state *qed_mcp_get_link_state(struct qed_hwfn *p_hwfn);
287 
288 /**
289  * qed_mcp_get_link_capabilities(): Return the link capabilities of the
290  *                                  hw function.
291  *
292  * @p_hwfn: HW device data.
293  *
294  * Returns: Pointer to link capabilities.
295  */
296 struct qed_mcp_link_capabilities
297 	*qed_mcp_get_link_capabilities(struct qed_hwfn *p_hwfn);
298 
299 /**
300  * qed_mcp_set_link(): Request the MFW to set the link according
301  *                     to 'link_input'.
302  *
303  * @p_hwfn: HW device data.
304  * @p_ptt: P_ptt.
305  * @b_up: Raise link if `true'. Reset link if `false'.
306  *
307  * Return: Int.
308  */
309 int qed_mcp_set_link(struct qed_hwfn   *p_hwfn,
310 		     struct qed_ptt     *p_ptt,
311 		     bool               b_up);
312 
313 /**
314  * qed_mcp_get_mfw_ver(): Get the management firmware version value.
315  *
316  * @p_hwfn: HW device data.
317  * @p_ptt: P_ptt.
318  * @p_mfw_ver: MFW version value.
319  * @p_running_bundle_id: Image id in nvram; Optional.
320  *
321  * Return: Int - 0 - operation was successful.
322  */
323 int qed_mcp_get_mfw_ver(struct qed_hwfn *p_hwfn,
324 			struct qed_ptt *p_ptt,
325 			u32 *p_mfw_ver, u32 *p_running_bundle_id);
326 
327 /**
328  * qed_mcp_get_mbi_ver(): Get the MBI version value.
329  *
330  * @p_hwfn: HW device data.
331  * @p_ptt: P_ptt.
332  * @p_mbi_ver: A pointer to a variable to be filled with the MBI version.
333  *
334  * Return: Int - 0 - operation was successful.
335  */
336 int qed_mcp_get_mbi_ver(struct qed_hwfn *p_hwfn,
337 			struct qed_ptt *p_ptt, u32 *p_mbi_ver);
338 
339 /**
340  * qed_mcp_get_media_type(): Get media type value of the port.
341  *
342  * @p_hwfn: HW device data.
343  * @p_ptt: P_ptt.
344  * @media_type: Media type value
345  *
346  * Return: Int - 0 - Operation was successul.
347  *              -EBUSY - Operation failed
348  */
349 int qed_mcp_get_media_type(struct qed_hwfn *p_hwfn,
350 			   struct qed_ptt *p_ptt, u32 *media_type);
351 
352 /**
353  * qed_mcp_get_transceiver_data(): Get transceiver data of the port.
354  *
355  * @p_hwfn: HW device data.
356  * @p_ptt: P_ptt.
357  * @p_transceiver_state: Transceiver state.
358  * @p_tranceiver_type: Media type value.
359  *
360  * Return: Int - 0 - Operation was successul.
361  *              -EBUSY - Operation failed
362  */
363 int qed_mcp_get_transceiver_data(struct qed_hwfn *p_hwfn,
364 				 struct qed_ptt *p_ptt,
365 				 u32 *p_transceiver_state,
366 				 u32 *p_tranceiver_type);
367 
368 /**
369  * qed_mcp_trans_speed_mask(): Get transceiver supported speed mask.
370  *
371  * @p_hwfn: HW device data.
372  * @p_ptt: P_ptt.
373  * @p_speed_mask: Bit mask of all supported speeds.
374  *
375  * Return: Int - 0 - Operation was successul.
376  *              -EBUSY - Operation failed
377  */
378 
379 int qed_mcp_trans_speed_mask(struct qed_hwfn *p_hwfn,
380 			     struct qed_ptt *p_ptt, u32 *p_speed_mask);
381 
382 /**
383  * qed_mcp_get_board_config(): Get board configuration.
384  *
385  * @p_hwfn: HW device data.
386  * @p_ptt: P_ptt.
387  * @p_board_config: Board config.
388  *
389  * Return: Int - 0 - Operation was successul.
390  *              -EBUSY - Operation failed
391  */
392 int qed_mcp_get_board_config(struct qed_hwfn *p_hwfn,
393 			     struct qed_ptt *p_ptt, u32 *p_board_config);
394 
395 /**
396  * qed_mcp_cmd(): Sleepable function for sending commands to the MCP
397  *                mailbox. It acquire mutex lock for the entire
398  *                operation, from sending the request until the MCP
399  *                response. Waiting for MCP response will be checked up
400  *                to 5 seconds every 10ms. Should not be called from atomic
401  *                context.
402  *
403  * @p_hwfn: HW device data.
404  * @p_ptt: PTT required for register access.
405  * @cmd: command to be sent to the MCP.
406  * @param: Optional param
407  * @o_mcp_resp: The MCP response code (exclude sequence).
408  * @o_mcp_param: Optional parameter provided by the MCP
409  *                     response
410  *
411  * Return: Int - 0 - Operation was successul.
412  */
413 int qed_mcp_cmd(struct qed_hwfn *p_hwfn,
414 		struct qed_ptt *p_ptt,
415 		u32 cmd,
416 		u32 param,
417 		u32 *o_mcp_resp,
418 		u32 *o_mcp_param);
419 
420 /**
421  * qed_mcp_cmd_nosleep(): Function for sending commands to the MCP
422  *                        mailbox. It acquire mutex lock for the entire
423  *                        operation, from sending the request until the MCP
424  *                        response. Waiting for MCP response will be checked up
425  *                        to 5 seconds every 10us. Should be called when sleep
426  *                        is not allowed.
427  *
428  * @p_hwfn: HW device data.
429  * @p_ptt: PTT required for register access.
430  * @cmd: command to be sent to the MCP.
431  * @param: Optional param
432  * @o_mcp_resp: The MCP response code (exclude sequence).
433  * @o_mcp_param: Optional parameter provided by the MCP
434  *                     response
435  *
436  * Return: Int - 0 - Operation was successul.
437  */
438 int qed_mcp_cmd_nosleep(struct qed_hwfn *p_hwfn,
439 			struct qed_ptt *p_ptt,
440 			u32 cmd,
441 			u32 param,
442 			u32 *o_mcp_resp,
443 			u32 *o_mcp_param);
444 
445 /**
446  * qed_mcp_drain(): drains the nig, allowing completion to pass in
447  *                  case of pauses.
448  *                  (Should be called only from sleepable context)
449  *
450  * @p_hwfn: HW device data.
451  * @p_ptt: PTT required for register access.
452  *
453  * Return: Int.
454  */
455 int qed_mcp_drain(struct qed_hwfn *p_hwfn,
456 		  struct qed_ptt *p_ptt);
457 
458 /**
459  * qed_mcp_get_flash_size(): Get the flash size value.
460  *
461  * @p_hwfn: HW device data.
462  * @p_ptt: PTT required for register access.
463  * @p_flash_size: Flash size in bytes to be filled.
464  *
465  * Return: Int - 0 - Operation was successul.
466  */
467 int qed_mcp_get_flash_size(struct qed_hwfn     *p_hwfn,
468 			   struct qed_ptt       *p_ptt,
469 			   u32 *p_flash_size);
470 
471 /**
472  * qed_mcp_send_drv_version(): Send driver version to MFW.
473  *
474  * @p_hwfn: HW device data.
475  * @p_ptt: PTT required for register access.
476  * @p_ver: Version value.
477  *
478  * Return: Int - 0 - Operation was successul.
479  */
480 int
481 qed_mcp_send_drv_version(struct qed_hwfn *p_hwfn,
482 			 struct qed_ptt *p_ptt,
483 			 struct qed_mcp_drv_version *p_ver);
484 
485 /**
486  * qed_get_process_kill_counter(): Read the MFW process kill counter.
487  *
488  * @p_hwfn: HW device data.
489  * @p_ptt: PTT required for register access.
490  *
491  * Return: u32.
492  */
493 u32 qed_get_process_kill_counter(struct qed_hwfn *p_hwfn,
494 				 struct qed_ptt *p_ptt);
495 
496 /**
497  * qed_start_recovery_process(): Trigger a recovery process.
498  *
499  * @p_hwfn: HW device data.
500  * @p_ptt: PTT required for register access.
501  *
502  * Return: Int.
503  */
504 int qed_start_recovery_process(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
505 
506 /**
507  * qed_recovery_prolog(): A recovery handler must call this function
508  *                        as its first step.
509  *                        It is assumed that the handler is not run from
510  *                        an interrupt context.
511  *
512  * @cdev: Qed dev pointer.
513  *
514  * Return: int.
515  */
516 int qed_recovery_prolog(struct qed_dev *cdev);
517 
518 /**
519  * qed_mcp_ov_update_current_config(): Notify MFW about the change in base
520  *                                    device properties
521  *
522  * @p_hwfn: HW device data.
523  * @p_ptt: P_ptt.
524  * @client: Qed client type.
525  *
526  * Return: Int - 0 - Operation was successul.
527  */
528 int qed_mcp_ov_update_current_config(struct qed_hwfn *p_hwfn,
529 				     struct qed_ptt *p_ptt,
530 				     enum qed_ov_client client);
531 
532 /**
533  * qed_mcp_ov_update_driver_state(): Notify MFW about the driver state.
534  *
535  * @p_hwfn: HW device data.
536  * @p_ptt: P_ptt.
537  * @drv_state: Driver state.
538  *
539  * Return: Int - 0 - Operation was successul.
540  */
541 int qed_mcp_ov_update_driver_state(struct qed_hwfn *p_hwfn,
542 				   struct qed_ptt *p_ptt,
543 				   enum qed_ov_driver_state drv_state);
544 
545 /**
546  * qed_mcp_ov_update_mtu(): Send MTU size to MFW.
547  *
548  * @p_hwfn: HW device data.
549  * @p_ptt: P_ptt.
550  * @mtu: MTU size.
551  *
552  * Return: Int - 0 - Operation was successul.
553  */
554 int qed_mcp_ov_update_mtu(struct qed_hwfn *p_hwfn,
555 			  struct qed_ptt *p_ptt, u16 mtu);
556 
557 /**
558  * qed_mcp_ov_update_mac(): Send MAC address to MFW.
559  *
560  * @p_hwfn: HW device data.
561  * @p_ptt: P_ptt.
562  * @mac: MAC address.
563  *
564  * Return: Int - 0 - Operation was successul.
565  */
566 int qed_mcp_ov_update_mac(struct qed_hwfn *p_hwfn,
567 			  struct qed_ptt *p_ptt, const u8 *mac);
568 
569 /**
570  * qed_mcp_ov_update_wol(): Send WOL mode to MFW.
571  *
572  * @p_hwfn: HW device data.
573  * @p_ptt: P_ptt.
574  * @wol: WOL mode.
575  *
576  * Return: Int - 0 - Operation was successul.
577  */
578 int qed_mcp_ov_update_wol(struct qed_hwfn *p_hwfn,
579 			  struct qed_ptt *p_ptt,
580 			  enum qed_ov_wol wol);
581 
582 /**
583  * qed_mcp_set_led(): Set LED status.
584  *
585  * @p_hwfn: HW device data.
586  * @p_ptt: P_ptt.
587  * @mode: LED mode.
588  *
589  * Return: Int - 0 - Operation was successul.
590  */
591 int qed_mcp_set_led(struct qed_hwfn *p_hwfn,
592 		    struct qed_ptt *p_ptt,
593 		    enum qed_led_mode mode);
594 
595 /**
596  * qed_mcp_nvm_read(): Read from NVM.
597  *
598  * @cdev: Qed dev pointer.
599  * @addr: NVM offset.
600  * @p_buf: NVM read buffer.
601  * @len: Buffer len.
602  *
603  * Return: Int - 0 - Operation was successul.
604  */
605 int qed_mcp_nvm_read(struct qed_dev *cdev, u32 addr, u8 *p_buf, u32 len);
606 
607 /**
608  * qed_mcp_nvm_write(): Write to NVM.
609  *
610  * @cdev: Qed dev pointer.
611  * @addr: NVM offset.
612  * @cmd: NVM command.
613  * @p_buf: NVM write buffer.
614  * @len: Buffer len.
615  *
616  * Return: Int - 0 - Operation was successul.
617  */
618 int qed_mcp_nvm_write(struct qed_dev *cdev,
619 		      u32 cmd, u32 addr, u8 *p_buf, u32 len);
620 
621 /**
622  * qed_mcp_nvm_resp(): Check latest response.
623  *
624  * @cdev: Qed dev pointer.
625  * @p_buf: NVM write buffer.
626  *
627  * Return: Int - 0 - Operation was successul.
628  */
629 int qed_mcp_nvm_resp(struct qed_dev *cdev, u8 *p_buf);
630 
631 struct qed_nvm_image_att {
632 	u32 start_addr;
633 	u32 length;
634 };
635 
636 /**
637  * qed_mcp_get_nvm_image_att(): Allows reading a whole nvram image.
638  *
639  * @p_hwfn: HW device data.
640  * @image_id: Image to get attributes for.
641  * @p_image_att: Image attributes structure into which to fill data.
642  *
643  * Return: Int - 0 - Operation was successul.
644  */
645 int
646 qed_mcp_get_nvm_image_att(struct qed_hwfn *p_hwfn,
647 			  enum qed_nvm_images image_id,
648 			  struct qed_nvm_image_att *p_image_att);
649 
650 /**
651  * qed_mcp_get_nvm_image(): Allows reading a whole nvram image.
652  *
653  * @p_hwfn: HW device data.
654  * @image_id: image requested for reading.
655  * @p_buffer: allocated buffer into which to fill data.
656  * @buffer_len: length of the allocated buffer.
657  *
658  * Return: 0 if p_buffer now contains the nvram image.
659  */
660 int qed_mcp_get_nvm_image(struct qed_hwfn *p_hwfn,
661 			  enum qed_nvm_images image_id,
662 			  u8 *p_buffer, u32 buffer_len);
663 
664 /**
665  * qed_mcp_bist_register_test(): Bist register test.
666  *
667  * @p_hwfn: HW device data.
668  * @p_ptt: PTT required for register access.
669  *
670  * Return: Int - 0 - Operation was successul.
671  */
672 int qed_mcp_bist_register_test(struct qed_hwfn *p_hwfn,
673 			       struct qed_ptt *p_ptt);
674 
675 /**
676  * qed_mcp_bist_clock_test(): Bist clock test.
677  *
678  * @p_hwfn: HW device data.
679  * @p_ptt: PTT required for register access.
680  *
681  * Return: Int - 0 - Operation was successul.
682  */
683 int qed_mcp_bist_clock_test(struct qed_hwfn *p_hwfn,
684 			    struct qed_ptt *p_ptt);
685 
686 /**
687  * qed_mcp_bist_nvm_get_num_images(): Bist nvm test - get number of images.
688  *
689  * @p_hwfn: HW device data.
690  * @p_ptt: PTT required for register access.
691  * @num_images: number of images if operation was
692  *			  successful. 0 if not.
693  *
694  * Return: Int - 0 - Operation was successul.
695  */
696 int qed_mcp_bist_nvm_get_num_images(struct qed_hwfn *p_hwfn,
697 				    struct qed_ptt *p_ptt,
698 				    u32 *num_images);
699 
700 /**
701  * qed_mcp_bist_nvm_get_image_att(): Bist nvm test - get image attributes
702  *                                   by index.
703  *
704  * @p_hwfn: HW device data.
705  * @p_ptt: PTT required for register access.
706  * @p_image_att: Attributes of image.
707  * @image_index: Index of image to get information for.
708  *
709  * Return: Int - 0 - Operation was successul.
710  */
711 int qed_mcp_bist_nvm_get_image_att(struct qed_hwfn *p_hwfn,
712 				   struct qed_ptt *p_ptt,
713 				   struct bist_nvm_image_att *p_image_att,
714 				   u32 image_index);
715 
716 /**
717  * qed_mfw_process_tlv_req(): Processes the TLV request from MFW i.e.,
718  *                            get the required TLV info
719  *                            from the qed client and send it to the MFW.
720  *
721  * @p_hwfn: HW device data.
722  * @p_ptt: P_ptt.
723  *
724  * Return: 0 upon success.
725  */
726 int qed_mfw_process_tlv_req(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
727 
728 /**
729  * qed_mcp_send_raw_debug_data(): Send raw debug data to the MFW
730  *
731  * @p_hwfn: HW device data.
732  * @p_ptt: P_ptt.
733  * @p_buf: raw debug data buffer.
734  * @size: Buffer size.
735  *
736  * Return : Int.
737  */
738 int
739 qed_mcp_send_raw_debug_data(struct qed_hwfn *p_hwfn,
740 			    struct qed_ptt *p_ptt, u8 *p_buf, u32 size);
741 
742 /* Using hwfn number (and not pf_num) is required since in CMT mode,
743  * same pf_num may be used by two different hwfn
744  * TODO - this shouldn't really be in .h file, but until all fields
745  * required during hw-init will be placed in their correct place in shmem
746  * we need it in qed_dev.c [for readin the nvram reflection in shmem].
747  */
748 #define MCP_PF_ID_BY_REL(p_hwfn, rel_pfid) (QED_IS_BB((p_hwfn)->cdev) ?	       \
749 					    ((rel_pfid) |		       \
750 					     ((p_hwfn)->abs_pf_id & 1) << 3) : \
751 					    rel_pfid)
752 #define MCP_PF_ID(p_hwfn) MCP_PF_ID_BY_REL(p_hwfn, (p_hwfn)->rel_pf_id)
753 
754 struct qed_mcp_info {
755 	/* List for mailbox commands which were sent and wait for a response */
756 	struct list_head			cmd_list;
757 
758 	/* Spinlock used for protecting the access to the mailbox commands list
759 	 * and the sending of the commands.
760 	 */
761 	spinlock_t				cmd_lock;
762 
763 	/* Flag to indicate whether sending a MFW mailbox command is blocked */
764 	bool					b_block_cmd;
765 
766 	/* Spinlock used for syncing SW link-changes and link-changes
767 	 * originating from attention context.
768 	 */
769 	spinlock_t				link_lock;
770 
771 	u32					public_base;
772 	u32					drv_mb_addr;
773 	u32					mfw_mb_addr;
774 	u32					port_addr;
775 	u16					drv_mb_seq;
776 	u16					drv_pulse_seq;
777 	struct qed_mcp_link_params		link_input;
778 	struct qed_mcp_link_state		link_output;
779 	struct qed_mcp_link_capabilities	link_capabilities;
780 	struct qed_mcp_function_info		func_info;
781 	u8					*mfw_mb_cur;
782 	u8					*mfw_mb_shadow;
783 	u16					mfw_mb_length;
784 	u32					mcp_hist;
785 
786 	/* Capabilties negotiated with the MFW */
787 	u32					capabilities;
788 
789 	/* S/N for debug data mailbox commands */
790 	atomic_t dbg_data_seq;
791 
792 	/* Spinlock used to sync the flag mcp_handling_status with
793 	 * the mfw events handler
794 	 */
795 	spinlock_t unload_lock;
796 	unsigned long mcp_handling_status;
797 #define QED_MCP_BYPASS_PROC_BIT 0
798 #define QED_MCP_IN_PROCESSING_BIT       1
799 };
800 
801 struct qed_mcp_mb_params {
802 	u32 cmd;
803 	u32 param;
804 	void *p_data_src;
805 	void *p_data_dst;
806 	u8 data_src_size;
807 	u8 data_dst_size;
808 	u32 mcp_resp;
809 	u32 mcp_param;
810 	u32 flags;
811 #define QED_MB_FLAG_CAN_SLEEP	(0x1 << 0)
812 #define QED_MB_FLAG_AVOID_BLOCK	(0x1 << 1)
813 #define QED_MB_FLAGS_IS_SET(params, flag) \
814 	({ typeof(params) __params = (params); \
815 	   (__params && (__params->flags & QED_MB_FLAG_ ## flag)); })
816 };
817 
818 struct qed_drv_tlv_hdr {
819 	u8 tlv_type;
820 	u8 tlv_length;	/* In dwords - not including this header */
821 	u8 tlv_reserved;
822 #define QED_DRV_TLV_FLAGS_CHANGED 0x01
823 	u8 tlv_flags;
824 };
825 
826 /**
827  * qed_mcp_is_ext_speed_supported() - Check if management firmware supports
828  *                                    extended speeds.
829  * @p_hwfn: HW device data.
830  *
831  * Return: true if supported, false otherwise.
832  */
833 static inline bool
qed_mcp_is_ext_speed_supported(const struct qed_hwfn * p_hwfn)834 qed_mcp_is_ext_speed_supported(const struct qed_hwfn *p_hwfn)
835 {
836 	return !!(p_hwfn->mcp_info->capabilities &
837 		  FW_MB_PARAM_FEATURE_SUPPORT_EXT_SPEED_FEC_CONTROL);
838 }
839 
840 /**
841  * qed_mcp_cmd_init(): Initialize the interface with the MCP.
842  *
843  * @p_hwfn: HW device data.
844  * @p_ptt: PTT required for register access.
845  *
846  * Return: Int.
847  */
848 int qed_mcp_cmd_init(struct qed_hwfn *p_hwfn,
849 		     struct qed_ptt *p_ptt);
850 
851 /**
852  * qed_mcp_cmd_port_init(): Initialize the port interface with the MCP
853  *
854  * @p_hwfn: HW device data.
855  * @p_ptt: P_ptt.
856  *
857  * Return: Void.
858  *
859  * Can only be called after `num_ports_in_engines' is set
860  */
861 void qed_mcp_cmd_port_init(struct qed_hwfn *p_hwfn,
862 			   struct qed_ptt *p_ptt);
863 /**
864  * qed_mcp_free(): Releases resources allocated during the init process.
865  *
866  * @p_hwfn: HW function.
867  *
868  * Return: Int.
869  */
870 
871 int qed_mcp_free(struct qed_hwfn *p_hwfn);
872 
873 /**
874  * qed_mcp_handle_events(): This function is called from the DPC context.
875  *           After pointing PTT to the mfw mb, check for events sent by
876  *           the MCP to the driver and ack them. In case a critical event
877  *           detected, it will be handled here, otherwise the work will be
878  *            queued to a sleepable work-queue.
879  *
880  * @p_hwfn: HW function.
881  * @p_ptt: PTT required for register access.
882  *
883  * Return: Int - 0 - Operation was successul.
884  */
885 int qed_mcp_handle_events(struct qed_hwfn *p_hwfn,
886 			  struct qed_ptt *p_ptt);
887 
888 enum qed_drv_role {
889 	QED_DRV_ROLE_OS,
890 	QED_DRV_ROLE_KDUMP,
891 };
892 
893 struct qed_load_req_params {
894 	/* Input params */
895 	enum qed_drv_role drv_role;
896 	u8 timeout_val;
897 	bool avoid_eng_reset;
898 	enum qed_override_force_load override_force_load;
899 
900 	/* Output params */
901 	u32 load_code;
902 };
903 
904 /**
905  * qed_mcp_load_req(): Sends a LOAD_REQ to the MFW, and in case the
906  *                     operation succeeds, returns whether this PF is
907  *                     the first on the engine/port or function.
908  *
909  * @p_hwfn: HW device data.
910  * @p_ptt: P_ptt.
911  * @p_params: Params.
912  *
913  * Return: Int - 0 - Operation was successul.
914  */
915 int qed_mcp_load_req(struct qed_hwfn *p_hwfn,
916 		     struct qed_ptt *p_ptt,
917 		     struct qed_load_req_params *p_params);
918 
919 /**
920  * qed_mcp_load_done(): Sends a LOAD_DONE message to the MFW.
921  *
922  * @p_hwfn: HW device data.
923  * @p_ptt: P_ptt.
924  *
925  * Return: Int - 0 - Operation was successul.
926  */
927 int qed_mcp_load_done(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
928 
929 /**
930  * qed_mcp_unload_req(): Sends a UNLOAD_REQ message to the MFW.
931  *
932  * @p_hwfn: HW device data.
933  * @p_ptt: P_ptt.
934  *
935  * Return: Int - 0 - Operation was successul.
936  */
937 int qed_mcp_unload_req(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
938 
939 /**
940  * qed_mcp_unload_done(): Sends a UNLOAD_DONE message to the MFW
941  *
942  * @p_hwfn: HW device data.
943  * @p_ptt: P_ptt.
944  *
945  * Return: Int - 0 - Operation was successul.
946  */
947 int qed_mcp_unload_done(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
948 
949 /**
950  * qed_mcp_read_mb(): Read the MFW mailbox into Current buffer.
951  *
952  * @p_hwfn: HW device data.
953  * @p_ptt: P_ptt.
954  *
955  * Return: Void.
956  */
957 void qed_mcp_read_mb(struct qed_hwfn *p_hwfn,
958 		     struct qed_ptt *p_ptt);
959 
960 /**
961  * qed_mcp_ack_vf_flr(): Ack to mfw that driver finished FLR process for VFs
962  *
963  * @p_hwfn: HW device data.
964  * @p_ptt: P_ptt.
965  * @vfs_to_ack: bit mask of all engine VFs for which the PF acks.
966  *
967  * Return: Int - 0 - Operation was successul.
968  */
969 int qed_mcp_ack_vf_flr(struct qed_hwfn *p_hwfn,
970 		       struct qed_ptt *p_ptt, u32 *vfs_to_ack);
971 
972 /**
973  * qed_mcp_fill_shmem_func_info(): Calls during init to read shmem of
974  *                                 all function-related info.
975  *
976  * @p_hwfn: HW device data.
977  * @p_ptt: P_ptt.
978  *
979  * Return: 0 upon success.
980  */
981 int qed_mcp_fill_shmem_func_info(struct qed_hwfn *p_hwfn,
982 				 struct qed_ptt *p_ptt);
983 
984 /**
985  * qed_mcp_reset(): Reset the MCP using mailbox command.
986  *
987  * @p_hwfn: HW device data.
988  * @p_ptt: P_ptt.
989  *
990  * Return: 0 upon success.
991  */
992 int qed_mcp_reset(struct qed_hwfn *p_hwfn,
993 		  struct qed_ptt *p_ptt);
994 
995 /**
996  * qed_mcp_nvm_rd_cmd(): Sends an NVM read command request to the MFW to get
997  *                       a buffer.
998  *
999  * @p_hwfn: HW device data.
1000  * @p_ptt: P_ptt.
1001  * @cmd: (Command) DRV_MSG_CODE_NVM_GET_FILE_DATA or
1002  *            DRV_MSG_CODE_NVM_READ_NVRAM commands.
1003  * @param: [0:23] - Offset [24:31] - Size.
1004  * @o_mcp_resp: MCP response.
1005  * @o_mcp_param: MCP response param.
1006  * @o_txn_size: Buffer size output.
1007  * @o_buf: Pointer to the buffer returned by the MFW.
1008  * @b_can_sleep: Can sleep.
1009  *
1010  * Return: 0 upon success.
1011  */
1012 int qed_mcp_nvm_rd_cmd(struct qed_hwfn *p_hwfn,
1013 		       struct qed_ptt *p_ptt,
1014 		       u32 cmd,
1015 		       u32 param,
1016 		       u32 *o_mcp_resp,
1017 		       u32 *o_mcp_param,
1018 		       u32 *o_txn_size, u32 *o_buf, bool b_can_sleep);
1019 
1020 /**
1021  * qed_mcp_phy_sfp_read(): Read from sfp.
1022  *
1023  * @p_hwfn: HW device data.
1024  * @p_ptt: PTT required for register access.
1025  * @port: transceiver port.
1026  * @addr: I2C address.
1027  * @offset: offset in sfp.
1028  * @len: buffer length.
1029  * @p_buf: buffer to read into.
1030  *
1031  * Return: Int - 0 - Operation was successul.
1032  */
1033 int qed_mcp_phy_sfp_read(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
1034 			 u32 port, u32 addr, u32 offset, u32 len, u8 *p_buf);
1035 
1036 /**
1037  * qed_mcp_is_init(): indicates whether the MFW objects [under mcp_info]
1038  *                    are accessible
1039  *
1040  * @p_hwfn: HW device data.
1041  *
1042  * Return: true if MFW is running and mcp_info is initialized.
1043  */
1044 bool qed_mcp_is_init(struct qed_hwfn *p_hwfn);
1045 
1046 /**
1047  * qed_mcp_config_vf_msix(): Request MFW to configure MSI-X for a VF.
1048  *
1049  * @p_hwfn: HW device data.
1050  * @p_ptt: P_ptt.
1051  * @vf_id: absolute inside engine.
1052  * @num: number of entries to request.
1053  *
1054  * Return: Int.
1055  */
1056 int qed_mcp_config_vf_msix(struct qed_hwfn *p_hwfn,
1057 			   struct qed_ptt *p_ptt, u8 vf_id, u8 num);
1058 
1059 /**
1060  * qed_mcp_halt(): Halt the MCP.
1061  *
1062  * @p_hwfn: HW device data.
1063  * @p_ptt: P_ptt.
1064  *
1065  * Return: 0 upon success.
1066  */
1067 int qed_mcp_halt(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
1068 
1069 /**
1070  * qed_mcp_resume: Wake up the MCP.
1071  *
1072  * @p_hwfn: HW device data.
1073  * @p_ptt: P_ptt.
1074  *
1075  * Return: 0 upon success.
1076  */
1077 int qed_mcp_resume(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
1078 
1079 int qed_configure_pf_min_bandwidth(struct qed_dev *cdev, u8 min_bw);
1080 int qed_configure_pf_max_bandwidth(struct qed_dev *cdev, u8 max_bw);
1081 int __qed_configure_pf_max_bandwidth(struct qed_hwfn *p_hwfn,
1082 				     struct qed_ptt *p_ptt,
1083 				     struct qed_mcp_link_state *p_link,
1084 				     u8 max_bw);
1085 int __qed_configure_pf_min_bandwidth(struct qed_hwfn *p_hwfn,
1086 				     struct qed_ptt *p_ptt,
1087 				     struct qed_mcp_link_state *p_link,
1088 				     u8 min_bw);
1089 
1090 int qed_mcp_mask_parities(struct qed_hwfn *p_hwfn,
1091 			  struct qed_ptt *p_ptt, u32 mask_parities);
1092 
1093 /* qed_mcp_mdump_get_retain(): Gets the mdump retained data from the MFW.
1094  *
1095  * @p_hwfn: HW device data.
1096  * @p_ptt: P_ptt.
1097  * @p_mdump_retain: mdump retain.
1098  *
1099  * Return: Int - 0 - Operation was successul.
1100  */
1101 int
1102 qed_mcp_mdump_get_retain(struct qed_hwfn *p_hwfn,
1103 			 struct qed_ptt *p_ptt,
1104 			 struct mdump_retain_data_stc *p_mdump_retain);
1105 
1106 /**
1107  * qed_mcp_set_resc_max_val(): Sets the MFW's max value for the given resource.
1108  *
1109  * @p_hwfn: HW device data.
1110  * @p_ptt: P_ptt.
1111  * @res_id: RES ID.
1112  * @resc_max_val: Resec max val.
1113  * @p_mcp_resp: MCP Resp
1114  *
1115  * Return: Int - 0 - Operation was successul.
1116  */
1117 int
1118 qed_mcp_set_resc_max_val(struct qed_hwfn *p_hwfn,
1119 			 struct qed_ptt *p_ptt,
1120 			 enum qed_resources res_id,
1121 			 u32 resc_max_val, u32 *p_mcp_resp);
1122 
1123 /**
1124  * qed_mcp_get_resc_info(): Gets the MFW allocation info for the given
1125  *                          resource.
1126  *
1127  * @p_hwfn: HW device data.
1128  * @p_ptt: P_ptt.
1129  * @res_id: Res ID.
1130  * @p_mcp_resp: MCP resp.
1131  * @p_resc_num: Resc num.
1132  * @p_resc_start: Resc start.
1133  *
1134  * Return: Int - 0 - Operation was successul.
1135  */
1136 int
1137 qed_mcp_get_resc_info(struct qed_hwfn *p_hwfn,
1138 		      struct qed_ptt *p_ptt,
1139 		      enum qed_resources res_id,
1140 		      u32 *p_mcp_resp, u32 *p_resc_num, u32 *p_resc_start);
1141 
1142 /**
1143  * qed_mcp_ov_update_eswitch(): Send eswitch mode to MFW.
1144  *
1145  * @p_hwfn: HW device data.
1146  * @p_ptt: P_ptt.
1147  * @eswitch: eswitch mode.
1148  *
1149  * Return: Int - 0 - Operation was successul.
1150  */
1151 int qed_mcp_ov_update_eswitch(struct qed_hwfn *p_hwfn,
1152 			      struct qed_ptt *p_ptt,
1153 			      enum qed_ov_eswitch eswitch);
1154 
1155 #define QED_MCP_RESC_LOCK_MIN_VAL       RESOURCE_DUMP
1156 #define QED_MCP_RESC_LOCK_MAX_VAL       31
1157 
1158 enum qed_resc_lock {
1159 	QED_RESC_LOCK_DBG_DUMP = QED_MCP_RESC_LOCK_MIN_VAL,
1160 	QED_RESC_LOCK_PTP_PORT0,
1161 	QED_RESC_LOCK_PTP_PORT1,
1162 	QED_RESC_LOCK_PTP_PORT2,
1163 	QED_RESC_LOCK_PTP_PORT3,
1164 	QED_RESC_LOCK_RESC_ALLOC = QED_MCP_RESC_LOCK_MAX_VAL,
1165 	QED_RESC_LOCK_RESC_INVALID
1166 };
1167 
1168 /**
1169  * qed_mcp_initiate_pf_flr(): Initiates PF FLR.
1170  *
1171  * @p_hwfn: HW device data.
1172  * @p_ptt: P_ptt.
1173  *
1174  * Return: Int - 0 - Operation was successul.
1175  */
1176 int qed_mcp_initiate_pf_flr(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
1177 struct qed_resc_lock_params {
1178 	/* Resource number [valid values are 0..31] */
1179 	u8 resource;
1180 
1181 	/* Lock timeout value in seconds [default, none or 1..254] */
1182 	u8 timeout;
1183 #define QED_MCP_RESC_LOCK_TO_DEFAULT    0
1184 #define QED_MCP_RESC_LOCK_TO_NONE       255
1185 
1186 	/* Number of times to retry locking */
1187 	u8 retry_num;
1188 #define QED_MCP_RESC_LOCK_RETRY_CNT_DFLT        10
1189 
1190 	/* The interval in usec between retries */
1191 	u16 retry_interval;
1192 #define QED_MCP_RESC_LOCK_RETRY_VAL_DFLT        10000
1193 
1194 	/* Use sleep or delay between retries */
1195 	bool sleep_b4_retry;
1196 
1197 	/* Will be set as true if the resource is free and granted */
1198 	bool b_granted;
1199 
1200 	/* Will be filled with the resource owner.
1201 	 * [0..15 = PF0-15, 16 = MFW]
1202 	 */
1203 	u8 owner;
1204 };
1205 
1206 /**
1207  * qed_mcp_resc_lock(): Acquires MFW generic resource lock.
1208  *
1209  * @p_hwfn: HW device data.
1210  * @p_ptt: P_ptt.
1211  * @p_params: Params.
1212  *
1213  * Return: Int - 0 - Operation was successul.
1214  */
1215 int
1216 qed_mcp_resc_lock(struct qed_hwfn *p_hwfn,
1217 		  struct qed_ptt *p_ptt, struct qed_resc_lock_params *p_params);
1218 
1219 struct qed_resc_unlock_params {
1220 	/* Resource number [valid values are 0..31] */
1221 	u8 resource;
1222 
1223 	/* Allow to release a resource even if belongs to another PF */
1224 	bool b_force;
1225 
1226 	/* Will be set as true if the resource is released */
1227 	bool b_released;
1228 };
1229 
1230 /**
1231  * qed_mcp_resc_unlock(): Releases MFW generic resource lock.
1232  *
1233  * @p_hwfn: HW device data.
1234  * @p_ptt: P_ptt.
1235  * @p_params: Params.
1236  *
1237  * Return: Int - 0 - Operation was successul.
1238  */
1239 int
1240 qed_mcp_resc_unlock(struct qed_hwfn *p_hwfn,
1241 		    struct qed_ptt *p_ptt,
1242 		    struct qed_resc_unlock_params *p_params);
1243 
1244 /**
1245  * qed_mcp_resc_lock_default_init(): Default initialization for
1246  *                                   lock/unlock resource structs.
1247  *
1248  * @p_lock: lock params struct to be initialized; Can be NULL.
1249  * @p_unlock: unlock params struct to be initialized; Can be NULL.
1250  * @resource: the requested resource.
1251  * @b_is_permanent: disable retries & aging when set.
1252  *
1253  * Return: Void.
1254  */
1255 void qed_mcp_resc_lock_default_init(struct qed_resc_lock_params *p_lock,
1256 				    struct qed_resc_unlock_params *p_unlock,
1257 				    enum qed_resc_lock
1258 				    resource, bool b_is_permanent);
1259 
1260 /**
1261  * qed_mcp_is_smart_an_supported(): Return whether management firmware
1262  *                                  support smart AN
1263  *
1264  * @p_hwfn: HW device data.
1265  *
1266  * Return: bool true if feature is supported.
1267  */
1268 bool qed_mcp_is_smart_an_supported(struct qed_hwfn *p_hwfn);
1269 
1270 /**
1271  * qed_mcp_get_capabilities(): Learn of supported MFW features;
1272  *                             To be done during early init.
1273  *
1274  * @p_hwfn: HW device data.
1275  * @p_ptt: P_ptt.
1276  *
1277  * Return: Int.
1278  */
1279 int qed_mcp_get_capabilities(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
1280 
1281 /**
1282  * qed_mcp_set_capabilities(): Inform MFW of set of features supported
1283  *                             by driver. Should be done inside the content
1284  *                             of the LOAD_REQ.
1285  *
1286  * @p_hwfn: HW device data.
1287  * @p_ptt: P_ptt.
1288  *
1289  * Return: Int.
1290  */
1291 int qed_mcp_set_capabilities(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
1292 
1293 /**
1294  * qed_mcp_read_ufp_config(): Read ufp config from the shared memory.
1295  *
1296  * @p_hwfn: HW device data.
1297  * @p_ptt: P_ptt.
1298  *
1299  * Return: Void.
1300  */
1301 void qed_mcp_read_ufp_config(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
1302 
1303 /**
1304  * qed_mcp_nvm_info_populate(): Populate the nvm info shadow in the given
1305  *                              hardware function.
1306  *
1307  * @p_hwfn: HW device data.
1308  *
1309  * Return: Int.
1310  */
1311 int qed_mcp_nvm_info_populate(struct qed_hwfn *p_hwfn);
1312 
1313 /**
1314  * qed_mcp_nvm_info_free(): Delete nvm info shadow in the given
1315  *                          hardware function.
1316  *
1317  * @p_hwfn: HW device data.
1318  *
1319  * Return: Void.
1320  */
1321 void qed_mcp_nvm_info_free(struct qed_hwfn *p_hwfn);
1322 
1323 /**
1324  * qed_mcp_get_engine_config(): Get the engine affinity configuration.
1325  *
1326  * @p_hwfn: HW device data.
1327  * @p_ptt: P_ptt.
1328  *
1329  * Return: Int.
1330  */
1331 int qed_mcp_get_engine_config(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
1332 
1333 /**
1334  * qed_mcp_get_ppfid_bitmap(): Get the PPFID bitmap.
1335  *
1336  * @p_hwfn: HW device data.
1337  * @p_ptt: P_ptt.
1338  *
1339  * Return: Int.
1340  */
1341 int qed_mcp_get_ppfid_bitmap(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt);
1342 
1343 /**
1344  * qed_mcp_nvm_get_cfg(): Get NVM config attribute value.
1345  *
1346  * @p_hwfn: HW device data.
1347  * @p_ptt: P_ptt.
1348  * @option_id: Option ID.
1349  * @entity_id: Entity ID.
1350  * @flags: Flags.
1351  * @p_buf: Buf.
1352  * @p_len: Len.
1353  *
1354  * Return: Int.
1355  */
1356 int qed_mcp_nvm_get_cfg(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
1357 			u16 option_id, u8 entity_id, u16 flags, u8 *p_buf,
1358 			u32 *p_len);
1359 
1360 /**
1361  * qed_mcp_nvm_set_cfg(): Set NVM config attribute value.
1362  *
1363  * @p_hwfn: HW device data.
1364  * @p_ptt: P_ptt.
1365  * @option_id: Option ID.
1366  * @entity_id: Entity ID.
1367  * @flags: Flags.
1368  * @p_buf: Buf.
1369  * @len: Len.
1370  *
1371  * Return: Int.
1372  */
1373 int qed_mcp_nvm_set_cfg(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt,
1374 			u16 option_id, u8 entity_id, u16 flags, u8 *p_buf,
1375 			u32 len);
1376 
1377 /**
1378  * qed_mcp_is_esl_supported(): Return whether management firmware support ESL or not.
1379  *
1380  * @p_hwfn: hw function pointer
1381  *
1382  * Return: true if esl is supported, otherwise return false
1383  */
1384 bool qed_mcp_is_esl_supported(struct qed_hwfn *p_hwfn);
1385 
1386 /**
1387  * qed_mcp_get_esl_status(): Get enhanced system lockdown status
1388  *
1389  * @p_hwfn: hw function pointer
1390  * @p_ptt: ptt resource pointer
1391  * @active: ESL active status data pointer
1392  *
1393  * Return: 0 with esl status info on success, otherwise return error
1394  */
1395 int qed_mcp_get_esl_status(struct qed_hwfn *p_hwfn, struct qed_ptt *p_ptt, bool *active);
1396 #endif
1397