1  /*
2   * Copyright (c) 2016-2021 The Linux Foundation. All rights reserved.
3   * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
4   *
5   * Permission to use, copy, modify, and/or distribute this software for
6   * any purpose with or without fee is hereby granted, provided that the
7   * above copyright notice and this permission notice appear in all
8   * copies.
9   *
10   * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL
11   * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED
12   * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE
13   * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL
14   * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR
15   * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
16   * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
17   * PERFORMANCE OF THIS SOFTWARE.
18   */
19  
20  #ifndef __PLD_COMMON_H__
21  #define __PLD_COMMON_H__
22  
23  #include <linux/device.h>
24  #include <linux/interrupt.h>
25  #include <linux/pm.h>
26  #include <osapi_linux.h>
27  
28  #ifdef CONFIG_CNSS_OUT_OF_TREE
29  #include "cnss2.h"
30  #else
31  #include <net/cnss2.h>
32  #endif
33  
34  #ifdef CNSS_UTILS
35  #ifdef CONFIG_CNSS_OUT_OF_TREE
36  #include "cnss_utils.h"
37  #else
38  #include <net/cnss_utils.h>
39  #endif
40  #endif
41  
42  #define PLD_IMAGE_FILE               "athwlan.bin"
43  #define PLD_UTF_FIRMWARE_FILE        "utf.bin"
44  #define PLD_BOARD_DATA_FILE          "fakeboar.bin"
45  #define PLD_OTP_FILE                 "otp.bin"
46  #define PLD_SETUP_FILE               "athsetup.bin"
47  #define PLD_EPPING_FILE              "epping.bin"
48  #define PLD_EVICTED_FILE             ""
49  #define PLD_MHI_STATE_L0	1
50  
51  #define TOTAL_DUMP_SIZE         0x00200000
52  
53  #ifdef CNSS_MEM_PRE_ALLOC
54  #ifdef CONFIG_CNSS_OUT_OF_TREE
55  #include "cnss_prealloc.h"
56  #else
57  #include <net/cnss_prealloc.h>
58  #endif
59  #endif
60  
61  #define PLD_LIMIT_LOG_FOR_SEC 6
62  /**
63   * __PLD_TRACE_RATE_LIMITED() - rate limited version of PLD_TRACE
64   * @params: parameters to pass through to PLD_TRACE
65   *
66   * This API prevents logging a message more than once in PLD_LIMIT_LOG_FOR_SEC
67   * seconds. This means any subsequent calls to this API from the same location
68   * within PLD_LIMIT_LOG_FOR_SEC seconds will be dropped.
69   *
70   * Return: None
71   */
72  #define __PLD_TRACE_RATE_LIMITED(params...)\
73  	do {\
74  		static ulong __last_ticks;\
75  		ulong __ticks = jiffies;\
76  		if (time_after(__ticks,\
77  			       __last_ticks + (HZ * PLD_LIMIT_LOG_FOR_SEC))) {\
78  			pr_err(params);\
79  			__last_ticks = __ticks;\
80  		} \
81  	} while (0)
82  
83  #define pld_err_rl(params...) __PLD_TRACE_RATE_LIMITED(params)
84  
85  /**
86   * enum pld_bus_type - bus type
87   * @PLD_BUS_TYPE_NONE: invalid bus type, only return in error cases
88   * @PLD_BUS_TYPE_PCIE: PCIE bus
89   * @PLD_BUS_TYPE_SNOC: SNOC bus
90   * @PLD_BUS_TYPE_SDIO: SDIO bus
91   * @PLD_BUS_TYPE_USB : USB bus
92   * @PLD_BUS_TYPE_SNOC_FW_SIM : SNOC FW SIM bus
93   * @PLD_BUS_TYPE_PCIE_FW_SIM : PCIE FW SIM bus
94   * @PLD_BUS_TYPE_IPCI : IPCI bus
95   * @PLD_BUS_TYPE_IPCI_FW_SIM : IPCI FW SIM bus
96   */
97  enum pld_bus_type {
98  	PLD_BUS_TYPE_NONE = -1,
99  	PLD_BUS_TYPE_PCIE = 0,
100  	PLD_BUS_TYPE_SNOC,
101  	PLD_BUS_TYPE_SDIO,
102  	PLD_BUS_TYPE_USB,
103  	PLD_BUS_TYPE_SNOC_FW_SIM,
104  	PLD_BUS_TYPE_PCIE_FW_SIM,
105  	PLD_BUS_TYPE_IPCI,
106  	PLD_BUS_TYPE_IPCI_FW_SIM,
107  };
108  
109  #define PLD_MAX_FIRMWARE_SIZE (1 * 1024 * 1024)
110  
111  /**
112   * enum pld_bus_width_type - bus bandwidth
113   * @PLD_BUS_WIDTH_NONE: don't vote for bus bandwidth
114   * @PLD_BUS_WIDTH_IDLE: vote for idle bandwidth
115   * @PLD_BUS_WIDTH_LOW: vote for low bus bandwidth
116   * @PLD_BUS_WIDTH_MEDIUM: vote for medium bus bandwidth
117   * @PLD_BUS_WIDTH_HIGH: vote for high bus bandwidth
118   * @PLD_BUS_WIDTH_MID_HIGH: vote for mid high bus bandwidth
119   * @PLD_BUS_WIDTH_VERY_HIGH: vote for very high bus bandwidth
120   * @PLD_BUS_WIDTH_ULTRA_HIGH: vote for ultra high bus bandwidth
121   * @PLD_BUS_WIDTH_LOW_LATENCY: vote for low latency bus bandwidth
122   * @PLD_BUS_WIDTH_MAX:
123   */
124  enum pld_bus_width_type {
125  	PLD_BUS_WIDTH_NONE,
126  	PLD_BUS_WIDTH_IDLE,
127  	PLD_BUS_WIDTH_LOW,
128  	PLD_BUS_WIDTH_MEDIUM,
129  	PLD_BUS_WIDTH_HIGH,
130  	PLD_BUS_WIDTH_VERY_HIGH,
131  	PLD_BUS_WIDTH_ULTRA_HIGH,
132  	PLD_BUS_WIDTH_MAX,
133  	PLD_BUS_WIDTH_LOW_LATENCY,
134  	PLD_BUS_WIDTH_MID_HIGH,
135  };
136  
137  #define PLD_MAX_FILE_NAME NAME_MAX
138  
139  /**
140   * struct pld_fw_files - WLAN FW file names
141   * @image_file: WLAN FW image file
142   * @board_data: WLAN FW board data file
143   * @otp_data: WLAN FW OTP file
144   * @utf_file: WLAN FW UTF file
145   * @utf_board_data: WLAN FW UTF board data file
146   * @epping_file: WLAN FW EPPING mode file
147   * @evicted_data: WLAN FW evicted file
148   * @setup_file: WLAN FW setup file
149   * @ibss_image_file: WLAN FW IBSS mode file
150   *
151   * pld_fw_files is used to store WLAN FW file names
152   */
153  struct pld_fw_files {
154  	char image_file[PLD_MAX_FILE_NAME];
155  	char board_data[PLD_MAX_FILE_NAME];
156  	char otp_data[PLD_MAX_FILE_NAME];
157  	char utf_file[PLD_MAX_FILE_NAME];
158  	char utf_board_data[PLD_MAX_FILE_NAME];
159  	char epping_file[PLD_MAX_FILE_NAME];
160  	char evicted_data[PLD_MAX_FILE_NAME];
161  	char setup_file[PLD_MAX_FILE_NAME];
162  	char ibss_image_file[PLD_MAX_FILE_NAME];
163  };
164  
165  /**
166   * enum pld_platform_cap_flag - platform capability flag
167   * @PLD_HAS_EXTERNAL_SWREG: has external regulator
168   * @PLD_HAS_UART_ACCESS: has UART access
169   * @PLD_HAS_DRV_SUPPORT: has PCIe DRV support
170   */
171  enum pld_platform_cap_flag {
172  	PLD_HAS_EXTERNAL_SWREG = 0x01,
173  	PLD_HAS_UART_ACCESS = 0x02,
174  	PLD_HAS_DRV_SUPPORT = 0x04,
175  };
176  
177  /**
178   * enum pld_wfc_mode - WFC Mode
179   * @PLD_WFC_MODE_OFF: WFC Inactive
180   * @PLD_WFC_MODE_ON: WFC Active
181   */
182  enum pld_wfc_mode {
183  	PLD_WFC_MODE_OFF,
184  	PLD_WFC_MODE_ON,
185  };
186  
187  /**
188   * struct pld_platform_cap - platform capabilities
189   * @cap_flag: capabilities flag
190   *
191   * pld_platform_cap provides platform capabilities which are
192   * extracted from DTS.
193   */
194  struct pld_platform_cap {
195  	u32 cap_flag;
196  };
197  
198  /**
199   * enum pld_uevent - PLD uevent event types
200   * @PLD_FW_DOWN: firmware is down
201   * @PLD_FW_CRASHED: firmware has crashed
202   * @PLD_FW_RECOVERY_START: firmware is starting recovery
203   * @PLD_FW_HANG_EVENT: firmware update hang event
204   * @PLD_BUS_EVENT: update bus/link event
205   * @PLD_SMMU_FAULT: SMMU fault
206   * @PLD_SYS_REBOOT: system is rebooting
207   */
208  enum pld_uevent {
209  	PLD_FW_DOWN,
210  	PLD_FW_CRASHED,
211  	PLD_FW_RECOVERY_START,
212  	PLD_FW_HANG_EVENT,
213  	PLD_BUS_EVENT,
214  	PLD_SMMU_FAULT,
215  	PLD_SYS_REBOOT,
216  };
217  
218  /**
219   * enum pld_bus_event - PLD bus event types
220   * @PLD_BUS_EVENT_PCIE_LINK_DOWN: PCIe link is down
221   * @PLD_BUS_EVENT_INVALID: invalid event type
222   */
223  
224  enum pld_bus_event {
225  	PLD_BUS_EVENT_PCIE_LINK_DOWN = 0,
226  
227  	PLD_BUS_EVENT_INVALID = 0xFFFF,
228  };
229  
230  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0))
231  /**
232   * enum pld_device_config - Get PLD device config
233   * @PLD_IPA_DISABLED: IPA is disabled
234   */
235  enum pld_device_config {
236  	PLD_IPA_DISABLED,
237  };
238  #endif
239  
240  /**
241   * struct pld_uevent_data - uevent status received from platform driver
242   * @uevent: uevent type
243   * @fw_down: FW down info
244   * @hang_data: FW hang data
245   * @bus_data: bus related data
246   */
247  struct pld_uevent_data {
248  	enum pld_uevent uevent;
249  	union {
250  		struct {
251  			bool crashed;
252  		} fw_down;
253  		struct {
254  			void *hang_event_data;
255  			u16 hang_event_data_len;
256  		} hang_data;
257  		struct {
258  			enum pld_bus_event etype;
259  			void *event_data;
260  		} bus_data;
261  	};
262  };
263  
264  /**
265   * struct pld_ce_tgt_pipe_cfg - copy engine target pipe configuration
266   * @pipe_num: pipe number
267   * @pipe_dir: pipe direction
268   * @nentries: number of entries
269   * @nbytes_max: max number of bytes
270   * @flags: flags
271   * @reserved: reserved
272   *
273   * pld_ce_tgt_pipe_cfg is used to store copy engine target pipe
274   * configuration.
275   */
276  struct pld_ce_tgt_pipe_cfg {
277  	u32 pipe_num;
278  	u32 pipe_dir;
279  	u32 nentries;
280  	u32 nbytes_max;
281  	u32 flags;
282  	u32 reserved;
283  };
284  
285  /**
286   * struct pld_ce_svc_pipe_cfg - copy engine service pipe configuration
287   * @service_id: service ID
288   * @pipe_dir: pipe direction
289   * @pipe_num: pipe number
290   *
291   * pld_ce_svc_pipe_cfg is used to store copy engine service pipe
292   * configuration.
293   */
294  struct pld_ce_svc_pipe_cfg {
295  	u32 service_id;
296  	u32 pipe_dir;
297  	u32 pipe_num;
298  };
299  
300  /**
301   * struct pld_shadow_reg_cfg - shadow register configuration
302   * @ce_id: copy engine ID
303   * @reg_offset: register offset
304   *
305   * pld_shadow_reg_cfg is used to store shadow register configuration.
306   */
307  struct pld_shadow_reg_cfg {
308  	u16 ce_id;
309  	u16 reg_offset;
310  };
311  
312  /**
313   * struct pld_shadow_reg_v2_cfg - shadow register version 2 configuration
314   * @addr: shadow register physical address
315   *
316   * pld_shadow_reg_v2_cfg is used to store shadow register version 2
317   * configuration.
318   */
319  struct pld_shadow_reg_v2_cfg {
320  	u32 addr;
321  };
322  
323  #ifdef CONFIG_SHADOW_V3
324  struct pld_shadow_reg_v3_cfg {
325  	u32 addr;
326  };
327  #endif
328  
329  /**
330   * struct pld_rri_over_ddr_cfg - rri_over_ddr configuration
331   * @base_addr_low: lower 32bit
332   * @base_addr_high: higher 32bit
333   *
334   * pld_rri_over_ddr_cfg_s is used in Genoa to pass rri_over_ddr configuration
335   * to firmware to update ring/write index in host DDR.
336   */
337  struct pld_rri_over_ddr_cfg {
338  	u32 base_addr_low;
339  	u32 base_addr_high;
340  };
341  
342  /**
343   * struct pld_wlan_enable_cfg - WLAN FW configuration
344   * @num_ce_tgt_cfg: number of CE target configuration
345   * @ce_tgt_cfg: CE target configuration
346   * @num_ce_svc_pipe_cfg: number of CE service configuration
347   * @ce_svc_cfg: CE service configuration
348   * @num_shadow_reg_cfg: number of shadow register configuration
349   * @shadow_reg_cfg: shadow register configuration
350   * @num_shadow_reg_v2_cfg: number of shadow register version 2 configuration
351   * @shadow_reg_v2_cfg: shadow register version 2 configuration
352   * @rri_over_ddr_cfg_valid: valid flag for rri_over_ddr config
353   * @rri_over_ddr_cfg: rri over ddr config
354   * @num_shadow_reg_v3_cfg: number of shadow register version 3 configuration
355   * @shadow_reg_v3_cfg: shadow register version 3 configuration
356   *
357   * pld_wlan_enable_cfg stores WLAN FW configurations. It will be
358   * passed to WLAN FW when WLAN host driver calls wlan_enable.
359   */
360  struct pld_wlan_enable_cfg {
361  	u32 num_ce_tgt_cfg;
362  	struct pld_ce_tgt_pipe_cfg *ce_tgt_cfg;
363  	u32 num_ce_svc_pipe_cfg;
364  	struct pld_ce_svc_pipe_cfg *ce_svc_cfg;
365  	u32 num_shadow_reg_cfg;
366  	struct pld_shadow_reg_cfg *shadow_reg_cfg;
367  	u32 num_shadow_reg_v2_cfg;
368  	struct pld_shadow_reg_v2_cfg *shadow_reg_v2_cfg;
369  	bool rri_over_ddr_cfg_valid;
370  	struct pld_rri_over_ddr_cfg rri_over_ddr_cfg;
371  #ifdef CONFIG_SHADOW_V3
372  	u32 num_shadow_reg_v3_cfg;
373  	struct pld_shadow_reg_v3_cfg *shadow_reg_v3_cfg;
374  #endif
375  };
376  
377  /**
378   * enum pld_driver_mode - WLAN host driver mode
379   * @PLD_MISSION: mission mode
380   * @PLD_FTM: FTM mode
381   * @PLD_EPPING: EPPING mode
382   * @PLD_WALTEST: WAL test mode, FW standalone test mode
383   * @PLD_OFF: OFF mode
384   * @PLD_COLDBOOT_CALIBRATION: Cold Boot Calibration Mode
385   * @PLD_FTM_COLDBOOT_CALIBRATION: Cold Boot Calibration for FTM Mode
386   */
387  enum pld_driver_mode {
388  	PLD_MISSION,
389  	PLD_FTM,
390  	PLD_EPPING,
391  	PLD_WALTEST,
392  	PLD_OFF,
393  	PLD_COLDBOOT_CALIBRATION = 7,
394  	PLD_FTM_COLDBOOT_CALIBRATION = 10
395  };
396  
397  /**
398   * struct pld_device_version - WLAN device version info
399   * @family_number: family number of WLAN SOC HW
400   * @device_number: device number of WLAN SOC HW
401   * @major_version: major version of WLAN SOC HW
402   * @minor_version: minor version of WLAN SOC HW
403   *
404   * pld_device_version is used to store WLAN device version info
405   */
406  
407  struct pld_device_version {
408  	u32 family_number;
409  	u32 device_number;
410  	u32 major_version;
411  	u32 minor_version;
412  };
413  
414  /**
415   * struct pld_dev_mem_info - WLAN device memory info
416   * @start: start address of the memory block
417   * @size: size of the memory block
418   *
419   * pld_dev_mem_info is used to store WLAN device memory info
420   */
421  struct pld_dev_mem_info {
422  	u64 start;
423  	u64 size;
424  };
425  
426  /**
427   * enum pld_wlan_hw_nss_info - WLAN HW nss info
428   * @PLD_WLAN_HW_CAP_NSS_UNSPECIFIED: nss info not specified
429   * @PLD_WLAN_HW_CAP_NSS_1x1: supported nss link 1x1
430   * @PLD_WLAN_HW_CAP_NSS_2x2: supported nss link 2x2
431   */
432  enum pld_wlan_hw_nss_info {
433  	PLD_WLAN_HW_CAP_NSS_UNSPECIFIED,
434  	PLD_WLAN_HW_CAP_NSS_1x1,
435  	PLD_WLAN_HW_CAP_NSS_2x2
436  };
437  
438  /**
439   * enum pld_wlan_hw_channel_bw_info - WLAN HW channel bw info
440   * @PLD_WLAN_HW_CHANNEL_BW_UNSPECIFIED: bw info not specified
441   * @PLD_WLAN_HW_CHANNEL_BW_80MHZ: supported bw 80MHZ
442   * @PLD_WLAN_HW_CHANNEL_BW_160MHZ: supported bw 160MHZ
443   */
444  enum pld_wlan_hw_channel_bw_info  {
445  	PLD_WLAN_HW_CHANNEL_BW_UNSPECIFIED,
446  	PLD_WLAN_HW_CHANNEL_BW_80MHZ,
447  	PLD_WLAN_HW_CHANNEL_BW_160MHZ
448  };
449  
450  /**
451   * enum pld_wlan_hw_qam_info - WLAN HW qam info
452   * @PLD_WLAN_HW_QAM_UNSPECIFIED: QAM info not specified
453   * @PLD_WLAN_HW_QAM_1K: 1K QAM supported
454   * @PLD_WLAN_HW_QAM_4K: 4K QAM supported
455   */
456  enum pld_wlan_hw_qam_info  {
457  	PLD_WLAN_HW_QAM_UNSPECIFIED,
458  	PLD_WLAN_HW_QAM_1K,
459  	PLD_WLAN_HW_QAM_4K
460  };
461  
462  /**
463   * struct pld_wlan_hw_cap_info - WLAN HW cap info
464   * @nss: nss info
465   * @bw: bw info
466   * @qam: qam info
467   */
468  struct pld_wlan_hw_cap_info {
469  	enum pld_wlan_hw_nss_info nss;
470  	enum pld_wlan_hw_channel_bw_info bw;
471  	enum pld_wlan_hw_qam_info qam;
472  };
473  
474  #define PLD_MAX_TIMESTAMP_LEN 32
475  #define PLD_WLFW_MAX_BUILD_ID_LEN 128
476  #define PLD_MAX_DEV_MEM_NUM 4
477  
478  /**
479   * struct pld_soc_info - SOC information
480   * @v_addr: virtual address of preallocated memory
481   * @p_addr: physical address of preallcoated memory
482   * @chip_id: chip ID
483   * @chip_family: chip family
484   * @board_id: board ID
485   * @soc_id: SOC ID
486   * @fw_version: FW version
487   * @fw_build_timestamp: FW build timestamp
488   * @device_version: WLAN device version info
489   * @dev_mem_info: WLAN device memory info
490   * @fw_build_id: Firmware build identifier
491   * @hw_cap_info: WLAN HW capabilities info
492   *
493   * pld_soc_info is used to store WLAN SOC information.
494   */
495  struct pld_soc_info {
496  	void __iomem *v_addr;
497  	phys_addr_t p_addr;
498  	u32 chip_id;
499  	u32 chip_family;
500  	u32 board_id;
501  	u32 soc_id;
502  	u32 fw_version;
503  	char fw_build_timestamp[PLD_MAX_TIMESTAMP_LEN + 1];
504  	struct pld_device_version device_version;
505  	struct pld_dev_mem_info dev_mem_info[PLD_MAX_DEV_MEM_NUM];
506  	char fw_build_id[PLD_WLFW_MAX_BUILD_ID_LEN + 1];
507  	struct pld_wlan_hw_cap_info hw_cap_info;
508  };
509  
510  /**
511   * enum pld_recovery_reason - WLAN host driver recovery reason
512   * @PLD_REASON_DEFAULT: default
513   * @PLD_REASON_LINK_DOWN: PCIe link down
514   */
515  enum pld_recovery_reason {
516  	PLD_REASON_DEFAULT,
517  	PLD_REASON_LINK_DOWN
518  };
519  
520  #ifdef FEATURE_WLAN_TIME_SYNC_FTM
521  /**
522   * enum pld_wlan_time_sync_trigger_type - WLAN time sync trigger type
523   * @PLD_TRIGGER_POSITIVE_EDGE: Positive edge trigger
524   * @PLD_TRIGGER_NEGATIVE_EDGE: Negative edge trigger
525   */
526  enum pld_wlan_time_sync_trigger_type {
527  	PLD_TRIGGER_POSITIVE_EDGE,
528  	PLD_TRIGGER_NEGATIVE_EDGE
529  };
530  #endif /* FEATURE_WLAN_TIME_SYNC_FTM */
531  
532  /* MAX channel avoid ranges supported in PLD */
533  #define PLD_CH_AVOID_MAX_RANGE   4
534  
535  /**
536   * struct pld_ch_avoid_freq_type
537   * @start_freq: start freq (MHz)
538   * @end_freq: end freq (Mhz)
539   */
540  struct pld_ch_avoid_freq_type {
541  	uint32_t start_freq;
542  	uint32_t end_freq;
543  };
544  
545  /**
546   * struct pld_ch_avoid_ind_type
547   * @ch_avoid_range_cnt: count
548   * @avoid_freq_range: avoid freq range array
549   */
550  struct pld_ch_avoid_ind_type {
551  	uint32_t ch_avoid_range_cnt;
552  	struct pld_ch_avoid_freq_type
553  		avoid_freq_range[PLD_CH_AVOID_MAX_RANGE];
554  };
555  
556  /**
557   * struct pld_driver_ops - driver callback functions
558   * @probe: required operation, will be called when device is detected
559   * @remove: required operation, will be called when device is removed
560   * @idle_shutdown: required operation, will be called when device is doing
561   *                 idle shutdown after interface inactivity timer has fired
562   * @idle_restart: required operation, will be called when device is doing
563   *                idle restart after idle shutdown
564   * @shutdown: optional operation, will be called during SSR
565   * @reinit: optional operation, will be called during SSR
566   * @crash_shutdown: optional operation, will be called when a crash is
567   *                  detected
568   * @suspend: required operation, will be called for power management
569   *           is enabled
570   * @resume: required operation, will be called for power management
571   *          is enabled
572   * @reset_resume: required operation, will be called for power management
573   *                is enabled
574   * @modem_status: optional operation, will be called when platform driver
575   *                sending modem power status to WLAN FW
576   * @uevent: optional operation, will be called when platform driver
577   *                 updating driver status
578   * @collect_driver_dump: optional operation, will be called during SSR to
579   *                       collect driver memory dump
580   * @runtime_suspend: optional operation, prepare the device for a condition
581   *                   in which it won't be able to communicate with the CPU(s)
582   *                   and RAM due to power management.
583   * @runtime_resume: optional operation, put the device into the fully
584   *                  active state in response to a wakeup event generated by
585   *                  hardware or at the request of software.
586   * @suspend_noirq: optional operation, complete the actions started by suspend()
587   * @resume_noirq: optional operation, prepare for the execution of resume()
588   * @set_curr_therm_cdev_state: optional operation, will be called when there is
589   *                        change in the thermal level triggered by the thermal
590   *                        subsystem thus requiring mitigation actions. This will
591   *                        be called every time there is a change in the state
592   *                        and after driver load.
593   */
594  struct pld_driver_ops {
595  	int (*probe)(struct device *dev,
596  		     enum pld_bus_type bus_type,
597  		     void *bdev, void *id);
598  	void (*remove)(struct device *dev,
599  		       enum pld_bus_type bus_type);
600  	int (*idle_shutdown)(struct device *dev,
601  			      enum pld_bus_type bus_type);
602  	int (*idle_restart)(struct device *dev,
603  			     enum pld_bus_type bus_type);
604  	void (*shutdown)(struct device *dev,
605  			 enum pld_bus_type bus_type);
606  	int (*reinit)(struct device *dev,
607  		      enum pld_bus_type bus_type,
608  		      void *bdev, void *id);
609  	void (*crash_shutdown)(struct device *dev,
610  			       enum pld_bus_type bus_type);
611  	int (*suspend)(struct device *dev,
612  		       enum pld_bus_type bus_type,
613  		       pm_message_t state);
614  	int (*resume)(struct device *dev,
615  		      enum pld_bus_type bus_type);
616  	int (*reset_resume)(struct device *dev,
617  		      enum pld_bus_type bus_type);
618  	void (*modem_status)(struct device *dev,
619  			     enum pld_bus_type bus_type,
620  			     int state);
621  	void (*uevent)(struct device *dev, struct pld_uevent_data *uevent);
622  #ifdef WLAN_FEATURE_SSR_DRIVER_DUMP
623  	int (*collect_driver_dump)(struct device *dev,
624  				   enum pld_bus_type bus_type,
625  				   struct cnss_ssr_driver_dump_entry
626  				   *input_array,
627  				   size_t *num_entries_loaded);
628  #endif
629  	int (*runtime_suspend)(struct device *dev,
630  			       enum pld_bus_type bus_type);
631  	int (*runtime_resume)(struct device *dev,
632  			      enum pld_bus_type bus_type);
633  	int (*suspend_noirq)(struct device *dev,
634  			     enum pld_bus_type bus_type);
635  	int (*resume_noirq)(struct device *dev,
636  			    enum pld_bus_type bus_type);
637  	int (*set_curr_therm_cdev_state)(struct device *dev,
638  					 unsigned long state,
639  					 int mon_id);
640  };
641  
642  /**
643   * pld_init() - Initialize PLD module
644   *
645   * Return: 0 for success
646   *         Non zero failure code for errors
647   */
648  int pld_init(void);
649  
650  /**
651   * pld_deinit() - Uninitialize PLD module
652   *
653   * Return: void
654   */
655  void pld_deinit(void);
656  
657  /**
658   * pld_set_mode() - set driver mode in PLD module
659   * @mode: driver mode
660   *
661   * Return: 0 for success
662   *         Non zero failure code for errors
663   */
664  int pld_set_mode(u8 mode);
665  
666  /**
667   * pld_register_driver() - Register driver to kernel
668   * @ops: Callback functions that will be registered to kernel
669   *
670   * This function should be called when other modules want to
671   * register platform driver callback functions to kernel. The
672   * probe() is expected to be called after registration if the
673   * device is online.
674   *
675   * Return: 0 for success
676   *         Non zero failure code for errors
677   */
678  int pld_register_driver(struct pld_driver_ops *ops);
679  
680  /**
681   * pld_unregister_driver() - Unregister driver to kernel
682   *
683   * This function should be called when other modules want to
684   * unregister callback functions from kernel. The remove() is
685   * expected to be called after registration.
686   *
687   * Return: void
688   */
689  void pld_unregister_driver(void);
690  
691  /**
692   * pld_wlan_enable() - Enable WLAN
693   * @dev: device
694   * @config: WLAN configuration data
695   * @mode: WLAN mode
696   *
697   * This function enables WLAN FW. It passed WLAN configuration data,
698   * WLAN mode and host software version to FW.
699   *
700   * Return: 0 for success
701   *         Non zero failure code for errors
702   */
703  int pld_wlan_enable(struct device *dev, struct pld_wlan_enable_cfg *config,
704  		    enum pld_driver_mode mode);
705  
706  /**
707   * pld_wlan_disable() - Disable WLAN
708   * @dev: device
709   * @mode: WLAN mode
710   *
711   * This function disables WLAN FW. It passes WLAN mode to FW.
712   *
713   * Return: 0 for success
714   *         Non zero failure code for errors
715   */
716  int pld_wlan_disable(struct device *dev, enum pld_driver_mode mode);
717  
718  /**
719   * pld_set_fw_log_mode() - Set FW debug log mode
720   * @dev: device
721   * @fw_log_mode: 0 for No log, 1 for WMI, 2 for DIAG
722   *
723   * Switch Fw debug log mode between DIAG logging and WMI logging.
724   *
725   * Return: 0 for success
726   *         Non zero failure code for errors
727   */
728  int pld_set_fw_log_mode(struct device *dev, u8 fw_log_mode);
729  
730  /**
731   * pld_get_default_fw_files() - Get default FW file names
732   * @pfw_files: buffer for FW file names
733   *
734   * Return default FW file names to the buffer.
735   *
736   * Return: void
737   */
738  void pld_get_default_fw_files(struct pld_fw_files *pfw_files);
739  
740  /**
741   * pld_get_fw_files_for_target() - Get FW file names
742   * @dev: device
743   * @pfw_files: buffer for FW file names
744   * @target_type: target type
745   * @target_version: target version
746   *
747   * Return target specific FW file names to the buffer.
748   *
749   * Return: 0 for success
750   *         Non zero failure code for errors
751   */
752  int pld_get_fw_files_for_target(struct device *dev,
753  				struct pld_fw_files *pfw_files,
754  				u32 target_type, u32 target_version);
755  
756  /**
757   * pld_prevent_l1() - Prevent PCIe enter L1 state
758   * @dev: device
759   *
760   * Prevent PCIe enter L1 and L1ss states
761   *
762   * Return: 0 for success
763   *         Non zero failure code for errors
764   */
765  int pld_prevent_l1(struct device *dev);
766  
767  /**
768   * pld_allow_l1() - Allow PCIe enter L1 state
769   * @dev: device
770   *
771   * Allow PCIe enter L1 and L1ss states
772   *
773   * Return: void
774   */
775  void pld_allow_l1(struct device *dev);
776  
777  /**
778   * pld_set_pcie_gen_speed() - Set PCIE gen speed
779   * @dev: device
780   * @pcie_gen_speed: Required PCIE gen speed
781   *
782   * Send required PCIE Gen speed to platform driver
783   *
784   * Return: 0 for success. Negative error codes.
785   */
786  int pld_set_pcie_gen_speed(struct device *dev, u8 pcie_gen_speed);
787  
788  /**
789   * pld_is_pci_link_down() - Notification for pci link down event
790   * @dev: device
791   *
792   * Notify platform that pci link is down.
793   *
794   * Return: void
795   */
796  void pld_is_pci_link_down(struct device *dev);
797  
798  /**
799   * pld_get_bus_reg_dump() - Get bus reg dump
800   * @dev: device
801   * @buf: buffer for hang data
802   * @len: len of hang data
803   *
804   * Get pci reg dump for hang data.
805   *
806   * Return: void
807   */
808  void pld_get_bus_reg_dump(struct device *dev, uint8_t *buf, uint32_t len);
809  
810  int pld_shadow_control(struct device *dev, bool enable);
811  
812  /**
813   * pld_schedule_recovery_work() - Schedule recovery work
814   * @dev: device
815   * @reason: recovery reason
816   *
817   * Schedule a system self recovery work.
818   *
819   * Return: void
820   */
821  void pld_schedule_recovery_work(struct device *dev,
822  				enum pld_recovery_reason reason);
823  
824  /**
825   * pld_wlan_hw_enable() - Enable WLAN HW
826   *
827   * This function enables WLAN HW. If WLAN is secured disabled at boot all wlan
828   * boot time activities are deferred. This is used to run deferred activities
829   * after wlan is enabled.
830   *
831   * Return: 0 for success
832   *         Non zero failure code for errors
833   */
834  int pld_wlan_hw_enable(void);
835  
836  #ifdef FEATURE_WLAN_TIME_SYNC_FTM
837  /**
838   * pld_get_audio_wlan_timestamp() - Get audio timestamp
839   * @dev: device pointer
840   * @type: trigger type
841   * @ts: audio timestamp
842   *
843   * This API can be used to get audio timestamp.
844   *
845   * Return: 0 if trigger to get audio timestamp is successful
846   *         Non zero failure code for errors
847   */
848  int pld_get_audio_wlan_timestamp(struct device *dev,
849  				 enum pld_wlan_time_sync_trigger_type type,
850  				 uint64_t *ts);
851  #endif /* FEATURE_WLAN_TIME_SYNC_FTM */
852  
853  #ifdef CNSS_UTILS
854  #ifdef CNSS_UTILS_VENDOR_UNSAFE_CHAN_API_SUPPORT
855  /**
856   * pld_get_wlan_unsafe_channel_sap() - Get vendor unsafe ch freq ranges
857   * @dev: device
858   * @ch_avoid_ranges: unsafe freq channel ranges
859   *
860   * Get vendor specific unsafe channel frequency ranges
861   *
862   * Return: 0 for success
863   *         Non zero failure code for errors
864   */
865  int pld_get_wlan_unsafe_channel_sap(
866  	struct device *dev, struct pld_ch_avoid_ind_type *ch_avoid_ranges);
867  #else
868  static inline
pld_get_wlan_unsafe_channel_sap(struct device * dev,struct pld_ch_avoid_ind_type * ch_avoid_ranges)869  int pld_get_wlan_unsafe_channel_sap(
870  	struct device *dev, struct pld_ch_avoid_ind_type *ch_avoid_ranges)
871  {
872  	return 0;
873  }
874  #endif
875  
876  /**
877   * pld_set_wlan_unsafe_channel() - Set unsafe channel
878   * @dev: device
879   * @unsafe_ch_list: unsafe channel list
880   * @ch_count: number of channel
881   *
882   * Return: 0 for success
883   *         Non zero failure code for errors
884   */
pld_set_wlan_unsafe_channel(struct device * dev,u16 * unsafe_ch_list,u16 ch_count)885  static inline int pld_set_wlan_unsafe_channel(struct device *dev,
886  					      u16 *unsafe_ch_list,
887  					      u16 ch_count)
888  {
889  	return cnss_utils_set_wlan_unsafe_channel(dev, unsafe_ch_list,
890  						  ch_count);
891  }
892  /**
893   * pld_get_wlan_unsafe_channel() - Get unsafe channel
894   * @dev: device
895   * @unsafe_ch_list: buffer to unsafe channel list
896   * @ch_count: number of channel
897   * @buf_len: buffer length
898   *
899   * Return WLAN unsafe channel to the buffer.
900   *
901   * Return: 0 for success
902   *         Non zero failure code for errors
903   */
pld_get_wlan_unsafe_channel(struct device * dev,u16 * unsafe_ch_list,u16 * ch_count,u16 buf_len)904  static inline int pld_get_wlan_unsafe_channel(struct device *dev,
905  					      u16 *unsafe_ch_list,
906  					      u16 *ch_count, u16 buf_len)
907  {
908  	return cnss_utils_get_wlan_unsafe_channel(dev, unsafe_ch_list,
909  						  ch_count, buf_len);
910  }
911  /**
912   * pld_wlan_set_dfs_nol() - Set DFS info
913   * @dev: device
914   * @info: DFS info
915   * @info_len: info length
916   *
917   * Return: 0 for success
918   *         Non zero failure code for errors
919   */
pld_wlan_set_dfs_nol(struct device * dev,void * info,u16 info_len)920  static inline int pld_wlan_set_dfs_nol(struct device *dev, void *info,
921  				       u16 info_len)
922  {
923  	return cnss_utils_wlan_set_dfs_nol(dev, info, info_len);
924  }
925  /**
926   * pld_wlan_get_dfs_nol() - Get DFS info
927   * @dev: device
928   * @info: buffer to DFS info
929   * @info_len: info length
930   *
931   * Return DFS info to the buffer.
932   *
933   * Return: 0 for success
934   *         Non zero failure code for errors
935   */
pld_wlan_get_dfs_nol(struct device * dev,void * info,u16 info_len)936  static inline int pld_wlan_get_dfs_nol(struct device *dev,
937  				       void *info, u16 info_len)
938  {
939  	return cnss_utils_wlan_get_dfs_nol(dev, info, info_len);
940  }
941  /**
942   * pld_get_wlan_mac_address() - API to query MAC address from Platform
943   * Driver
944   * @dev: Device Structure
945   * @num: Pointer to number of MAC address supported
946   *
947   * Platform Driver can have MAC address stored. This API needs to be used
948   * to get those MAC address
949   *
950   * Return: Pointer to the list of MAC address
951   */
pld_get_wlan_mac_address(struct device * dev,uint32_t * num)952  static inline uint8_t *pld_get_wlan_mac_address(struct device *dev,
953  						uint32_t *num)
954  {
955  	return cnss_utils_get_wlan_mac_address(dev, num);
956  }
957  
958  /**
959   * pld_get_wlan_derived_mac_address() - API to query derived MAC address
960   * from platform Driver
961   * @dev: Device Structure
962   * @num: Pointer to number of MAC address supported
963   *
964   * Platform Driver can have MAC address stored. This API needs to be used
965   * to get those MAC address
966   *
967   * Return: Pointer to the list of MAC address
968   */
pld_get_wlan_derived_mac_address(struct device * dev,uint32_t * num)969  static inline uint8_t *pld_get_wlan_derived_mac_address(struct device *dev,
970  							uint32_t *num)
971  {
972  	return cnss_utils_get_wlan_derived_mac_address(dev, num);
973  }
974  
975  /**
976   * pld_increment_driver_load_cnt() - Maintain driver load count
977   * @dev: device
978   *
979   * This function maintain a count which get increase whenever wiphy
980   * is registered
981   *
982   * Return: void
983   */
pld_increment_driver_load_cnt(struct device * dev)984  static inline void pld_increment_driver_load_cnt(struct device *dev)
985  {
986  	cnss_utils_increment_driver_load_cnt(dev);
987  }
988  /**
989   * pld_get_driver_load_cnt() - get driver load count
990   * @dev: device
991   *
992   * This function provide total wiphy registration count from starting
993   *
994   * Return: driver load count
995   */
pld_get_driver_load_cnt(struct device * dev)996  static inline int pld_get_driver_load_cnt(struct device *dev)
997  {
998  	return cnss_utils_get_driver_load_cnt(dev);
999  }
1000  #else
pld_get_wlan_unsafe_channel_sap(struct device * dev,struct pld_ch_avoid_ind_type * ch_avoid_ranges)1001  static inline int pld_get_wlan_unsafe_channel_sap(
1002  	struct device *dev, struct pld_ch_avoid_ind_type *ch_avoid_ranges)
1003  {
1004  	return 0;
1005  }
1006  
pld_set_wlan_unsafe_channel(struct device * dev,u16 * unsafe_ch_list,u16 ch_count)1007  static inline int pld_set_wlan_unsafe_channel(struct device *dev,
1008  					      u16 *unsafe_ch_list,
1009  					      u16 ch_count)
1010  {
1011  	return 0;
1012  }
pld_get_wlan_unsafe_channel(struct device * dev,u16 * unsafe_ch_list,u16 * ch_count,u16 buf_len)1013  static inline int pld_get_wlan_unsafe_channel(struct device *dev,
1014  					      u16 *unsafe_ch_list,
1015  					      u16 *ch_count, u16 buf_len)
1016  {
1017  	*ch_count = 0;
1018  
1019  	return 0;
1020  }
pld_wlan_set_dfs_nol(struct device * dev,void * info,u16 info_len)1021  static inline int pld_wlan_set_dfs_nol(struct device *dev,
1022  				       void *info, u16 info_len)
1023  {
1024  	return -EINVAL;
1025  }
pld_wlan_get_dfs_nol(struct device * dev,void * info,u16 info_len)1026  static inline int pld_wlan_get_dfs_nol(struct device *dev,
1027  				       void *info, u16 info_len)
1028  {
1029  	return -EINVAL;
1030  }
pld_get_wlan_mac_address(struct device * dev,uint32_t * num)1031  static inline uint8_t *pld_get_wlan_mac_address(struct device *dev,
1032  						uint32_t *num)
1033  {
1034  	*num = 0;
1035  	return NULL;
1036  }
1037  
pld_get_wlan_derived_mac_address(struct device * dev,uint32_t * num)1038  static inline uint8_t *pld_get_wlan_derived_mac_address(struct device *dev,
1039  							uint32_t *num)
1040  {
1041  	*num = 0;
1042  	return NULL;
1043  }
1044  
pld_increment_driver_load_cnt(struct device * dev)1045  static inline void pld_increment_driver_load_cnt(struct device *dev) {}
pld_get_driver_load_cnt(struct device * dev)1046  static inline int pld_get_driver_load_cnt(struct device *dev)
1047  {
1048  	return -EINVAL;
1049  }
1050  #endif
1051  
1052  /**
1053   * pld_wlan_pm_control() - WLAN PM control on PCIE
1054   * @dev: device
1055   * @vote: 0 for enable PCIE PC, 1 for disable PCIE PC
1056   *
1057   * This is for PCIE power collapse control during suspend/resume.
1058   * When PCIE power collapse is disabled, WLAN FW can access memory
1059   * through PCIE when system is suspended.
1060   *
1061   * Return: 0 for success
1062   *         Non zero failure code for errors
1063   */
1064  int pld_wlan_pm_control(struct device *dev, bool vote);
1065  
1066  /**
1067   * pld_get_virt_ramdump_mem() - Get virtual ramdump memory
1068   * @dev: device
1069   * @size: buffer to virtual memory size
1070   *
1071   * Return: virtual ramdump memory address
1072   */
1073  void *pld_get_virt_ramdump_mem(struct device *dev, unsigned long *size);
1074  
1075  /**
1076   * pld_release_virt_ramdump_mem() - Release virtual ramdump memory
1077   * @dev: device
1078   * @address: buffer to virtual memory address
1079   *
1080   * Return: void
1081   */
1082  void pld_release_virt_ramdump_mem(struct device *dev, void *address);
1083  
1084  /**
1085   * pld_device_crashed() - Notification for device crash event
1086   * @dev: device
1087   *
1088   * Notify subsystem a device crashed event. A subsystem restart
1089   * is expected to happen after calling this function.
1090   *
1091   * Return: void
1092   */
1093  void pld_device_crashed(struct device *dev);
1094  
1095  /**
1096   * pld_device_self_recovery() - Device self recovery
1097   * @dev: device
1098   * @reason: recovery reason
1099   *
1100   * Return: void
1101   */
1102  void pld_device_self_recovery(struct device *dev,
1103  			      enum pld_recovery_reason reason);
1104  
1105  /**
1106   * pld_intr_notify_q6() - Notify Q6 FW interrupts
1107   * @dev: device
1108   *
1109   * Notify Q6 that a FW interrupt is triggered.
1110   *
1111   * Return: void
1112   */
1113  void pld_intr_notify_q6(struct device *dev);
1114  
1115  /**
1116   * pld_request_pm_qos() - Request system PM
1117   * @dev: device
1118   * @qos_val: request value
1119   *
1120   * It votes for the value of aggregate QoS expectations.
1121   *
1122   * Return: void
1123   */
1124  void pld_request_pm_qos(struct device *dev, u32 qos_val);
1125  
1126  /**
1127   * pld_remove_pm_qos() - Remove system PM
1128   * @dev: device
1129   *
1130   * Remove the vote request for Qos expectations.
1131   *
1132   * Return: void
1133   */
1134  void pld_remove_pm_qos(struct device *dev);
1135  
1136  /**
1137   * pld_request_bus_bandwidth() - Request bus bandwidth
1138   * @dev: device
1139   * @bandwidth: bus bandwidth
1140   *
1141   * Votes for HIGH/MEDIUM/LOW bus bandwidth.
1142   *
1143   * Return: 0 for success
1144   *         Non zero failure code for errors
1145   */
1146  int pld_request_bus_bandwidth(struct device *dev, int bandwidth);
1147  
1148  /**
1149   * pld_get_platform_cap() - Get platform capabilities
1150   * @dev: device
1151   * @cap: buffer to the capabilities
1152   *
1153   * Return capabilities to the buffer.
1154   *
1155   * Return: 0 for success
1156   *         Non zero failure code for errors
1157   */
1158  int pld_get_platform_cap(struct device *dev, struct pld_platform_cap *cap);
1159  
1160  /**
1161   * pld_get_sha_hash() - Get sha hash number
1162   * @dev: device
1163   * @data: input data
1164   * @data_len: data length
1165   * @hash_idx: hash index
1166   * @out:  output buffer
1167   *
1168   * Return computed hash to the out buffer.
1169   *
1170   * Return: 0 for success
1171   *         Non zero failure code for errors
1172   */
1173  int pld_get_sha_hash(struct device *dev, const u8 *data,
1174  		     u32 data_len, u8 *hash_idx, u8 *out);
1175  
1176  /**
1177   * pld_get_fw_ptr() - Get secure FW memory address
1178   * @dev: device
1179   *
1180   * Return: secure memory address
1181   */
1182  void *pld_get_fw_ptr(struct device *dev);
1183  
1184  /**
1185   * pld_auto_suspend() - Auto suspend
1186   * @dev: device
1187   *
1188   * Return: 0 for success
1189   *         Non zero failure code for errors
1190   */
1191  int pld_auto_suspend(struct device *dev);
1192  
1193  /**
1194   * pld_auto_resume() - Auto resume
1195   * @dev: device
1196   *
1197   * Return: 0 for success
1198   *         Non zero failure code for errors
1199   */
1200  int pld_auto_resume(struct device *dev);
1201  
1202  /**
1203   * pld_force_wake_request() - Request vote to assert WAKE register
1204   * @dev: device
1205   *
1206   * Return: 0 for success
1207   *         Non zero failure code for errors
1208   */
1209  int pld_force_wake_request(struct device *dev);
1210  
1211  /**
1212   * pld_is_direct_link_supported() - Get whether direct_link is supported
1213   *                                  by FW or not
1214   * @dev: device
1215   *
1216   * Return: true if supported
1217   *         false on failure or if not supported
1218   */
1219  bool pld_is_direct_link_supported(struct device *dev);
1220  
1221  /**
1222   * pld_force_wake_request_sync() - Request to awake MHI synchronously
1223   * @dev: device
1224   * @timeout_us: timeout in micro-sec request to wake
1225   *
1226   * Return: 0 for success
1227   *         Non zero failure code for errors
1228   */
1229  int pld_force_wake_request_sync(struct device *dev, int timeout_us);
1230  
1231  /**
1232   * pld_exit_power_save() - Send EXIT_POWER_SAVE QMI to FW
1233   * @dev: device
1234   *
1235   * Return: 0 for success
1236   *         Non zero failure code for errors
1237   */
1238  int pld_exit_power_save(struct device *dev);
1239  
1240  /**
1241   * pld_is_device_awake() - Check if it's ready to access MMIO registers
1242   * @dev: device
1243   *
1244   * Return: True for device awake
1245   *         False for device not awake
1246   *         Negative failure code for errors
1247   */
1248  int pld_is_device_awake(struct device *dev);
1249  
1250  /**
1251   * pld_force_wake_release() - Release vote to assert WAKE register
1252   * @dev: device
1253   *
1254   * Return: 0 for success
1255   *         Non zero failure code for errors
1256   */
1257  int pld_force_wake_release(struct device *dev);
1258  
1259  /**
1260   * pld_ce_request_irq() - Register IRQ for CE
1261   * @dev: device
1262   * @ce_id: CE number
1263   * @handler: IRQ callback function
1264   * @flags: IRQ flags
1265   * @name: IRQ name
1266   * @ctx: IRQ context
1267   *
1268   * Return: 0 for success
1269   *         Non zero failure code for errors
1270   */
1271  int pld_ce_request_irq(struct device *dev, unsigned int ce_id,
1272  		       irqreturn_t (*handler)(int, void *),
1273  		       unsigned long flags, const char *name, void *ctx);
1274  
1275  /**
1276   * pld_ce_free_irq() - Free IRQ for CE
1277   * @dev: device
1278   * @ce_id: CE number
1279   * @ctx: IRQ context
1280   *
1281   * Return: 0 for success
1282   *         Non zero failure code for errors
1283   */
1284  int pld_ce_free_irq(struct device *dev, unsigned int ce_id, void *ctx);
1285  
1286  /**
1287   * pld_enable_irq() - Enable IRQ for CE
1288   * @dev: device
1289   * @ce_id: CE number
1290   *
1291   * Return: void
1292   */
1293  void pld_enable_irq(struct device *dev, unsigned int ce_id);
1294  
1295  /**
1296   * pld_disable_irq() - Disable IRQ for CE
1297   * @dev: device
1298   * @ce_id: CE number
1299   *
1300   * Return: void
1301   */
1302  void pld_disable_irq(struct device *dev, unsigned int ce_id);
1303  
1304  /**
1305   * pld_get_soc_info() - Get SOC information
1306   * @dev: device
1307   * @info: buffer to SOC information
1308   *
1309   * Return SOC info to the buffer.
1310   *
1311   * Return: 0 for success
1312   *         Non zero failure code for errors
1313   */
1314  int pld_get_soc_info(struct device *dev, struct pld_soc_info *info);
1315  
1316  /**
1317   * pld_get_mhi_state() - Get MHI state Info
1318   * @dev: device
1319   *
1320   * MHI state can be determined by reading this address.
1321   *
1322   * Return: MHI state
1323   */
1324  int pld_get_mhi_state(struct device *dev);
1325  
1326  /**
1327   * pld_is_pci_ep_awake() - Check if PCI EP is L0 state
1328   * @dev: device
1329   *
1330   * Return: True for PCI EP awake
1331   *         False for PCI EP not awake
1332   *         Negative failure code for errors
1333   */
1334  int pld_is_pci_ep_awake(struct device *dev);
1335  
1336  /**
1337   * pld_get_ce_id() - Get CE number for the provided IRQ
1338   * @dev: device
1339   * @irq: IRQ number
1340   *
1341   * Return: CE number
1342   */
1343  int pld_get_ce_id(struct device *dev, int irq);
1344  
1345  /**
1346   * pld_get_irq() - Get IRQ number for given CE ID
1347   * @dev: device
1348   * @ce_id: CE ID
1349   *
1350   * Return: IRQ number
1351   */
1352  int pld_get_irq(struct device *dev, int ce_id);
1353  
1354  /**
1355   * pld_lock_reg_window() - Lock register window spinlock
1356   * @dev: device pointer
1357   * @flags: variable pointer to save CPU states
1358   *
1359   * It uses spinlock_bh so avoid calling in top half context.
1360   *
1361   * Return: void
1362   */
1363  void pld_lock_reg_window(struct device *dev, unsigned long *flags);
1364  
1365  /**
1366   * pld_unlock_reg_window() - Unlock register window spinlock
1367   * @dev: device pointer
1368   * @flags: variable pointer to save CPU states
1369   *
1370   * It uses spinlock_bh so avoid calling in top half context.
1371   *
1372   * Return: void
1373   */
1374  void pld_unlock_reg_window(struct device *dev, unsigned long *flags);
1375  
1376  /**
1377   * pld_get_pci_slot() - Get PCI slot of attached device
1378   * @dev: device
1379   *
1380   * Return: pci slot
1381   */
1382  int pld_get_pci_slot(struct device *dev);
1383  
1384  /**
1385   * pld_power_on() - Power on WLAN hardware
1386   * @dev: device
1387   *
1388   * Return: 0 for success
1389   *         Non zero failure code for errors
1390   */
1391  int pld_power_on(struct device *dev);
1392  
1393  /**
1394   * pld_power_off() - Power off WLAN hardware
1395   * @dev: device
1396   *
1397   * Return: 0 for success
1398   *         Non zero failure code for errors
1399   */
1400  int pld_power_off(struct device *dev);
1401  
1402  /**
1403   * pld_athdiag_read() - Read data from WLAN FW
1404   * @dev: device
1405   * @offset: address offset
1406   * @memtype: memory type
1407   * @datalen: data length
1408   * @output: output buffer
1409   *
1410   * Return: 0 for success
1411   *         Non zero failure code for errors
1412   */
1413  int pld_athdiag_read(struct device *dev, uint32_t offset, uint32_t memtype,
1414  		     uint32_t datalen, uint8_t *output);
1415  
1416  /**
1417   * pld_athdiag_write() - Write data to WLAN FW
1418   * @dev: device
1419   * @offset: address offset
1420   * @memtype: memory type
1421   * @datalen: data length
1422   * @input: input buffer
1423   *
1424   * Return: 0 for success
1425   *         Non zero failure code for errors
1426   */
1427  int pld_athdiag_write(struct device *dev, uint32_t offset, uint32_t memtype,
1428  		      uint32_t datalen, uint8_t *input);
1429  
1430  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0))
1431  /**
1432   * pld_smmu_get_domain() - Get SMMU domain
1433   * @dev: device
1434   *
1435   * Return: Pointer to the domain
1436   */
1437  void *pld_smmu_get_domain(struct device *dev);
1438  #else
1439  /**
1440   * pld_smmu_get_mapping() - Get SMMU mapping context
1441   * @dev: device
1442   *
1443   * Return: Pointer to the mapping context
1444   */
1445  void *pld_smmu_get_mapping(struct device *dev);
1446  #endif
1447  
1448  /**
1449   * pld_smmu_map() - Map SMMU
1450   * @dev: device
1451   * @paddr: physical address that needs to map to
1452   * @iova_addr: IOVA address
1453   * @size: size to be mapped
1454   *
1455   * Return: 0 for success
1456   *         Non zero failure code for errors
1457   */
1458  int pld_smmu_map(struct device *dev, phys_addr_t paddr,
1459  		 uint32_t *iova_addr, size_t size);
1460  
1461  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(5, 15, 0))
1462  struct kobject *pld_get_wifi_kobj(struct device *dev);
1463  #else
pld_get_wifi_kobj(struct device * dev)1464  static inline struct kobject *pld_get_wifi_kobj(struct device *dev)
1465  {
1466  	return NULL;
1467  }
1468  #endif
1469  
1470  /**
1471   * pld_smmu_unmap() - Unmap SMMU
1472   * @dev: device
1473   * @iova_addr: IOVA address to be unmapped
1474   * @size: size to be unmapped
1475   *
1476   * Return: 0 for success
1477   *         Non zero failure code for errors
1478   */
1479  #ifdef CONFIG_SMMU_S1_UNMAP
1480  int pld_smmu_unmap(struct device *dev,
1481  		   uint32_t iova_addr, size_t size);
1482  #else
pld_smmu_unmap(struct device * dev,uint32_t iova_addr,size_t size)1483  static inline int pld_smmu_unmap(struct device *dev,
1484  				 uint32_t iova_addr, size_t size)
1485  {
1486  	return 0;
1487  }
1488  #endif
1489  
1490  /**
1491   * pld_get_user_msi_assignment() - Get MSI assignment information
1492   * @dev: device structure
1493   * @user_name: name of the user who requests the MSI assignment
1494   * @num_vectors: number of the MSI vectors assigned for the user
1495   * @user_base_data: MSI base data assigned for the user, this equals to
1496   *                  endpoint base data from config space plus base vector
1497   * @base_vector: base MSI vector (offset) number assigned for the user
1498   *
1499   * Return: 0 for success
1500   *         Negative failure code for errors
1501   */
1502  int pld_get_user_msi_assignment(struct device *dev, char *user_name,
1503  				int *num_vectors, uint32_t *user_base_data,
1504  				uint32_t *base_vector);
1505  
1506  /**
1507   * pld_get_msi_irq() - Get MSI IRQ number used for request_irq()
1508   * @dev: device structure
1509   * @vector: MSI vector (offset) number
1510   *
1511   * Return: Positive IRQ number for success
1512   *         Negative failure code for errors
1513   */
1514  int pld_get_msi_irq(struct device *dev, unsigned int vector);
1515  
1516  /**
1517   * pld_get_msi_address() - Get the MSI address
1518   * @dev: device structure
1519   * @msi_addr_low: lower 32-bit of the address
1520   * @msi_addr_high: higher 32-bit of the address
1521   *
1522   * Return: Void
1523   */
1524  void pld_get_msi_address(struct device *dev, uint32_t *msi_addr_low,
1525  			 uint32_t *msi_addr_high);
1526  
1527  /**
1528   * pld_is_drv_connected() - Check if DRV subsystem is connected
1529   * @dev: device structure
1530   *
1531   *  Return: 1 DRV is connected
1532   *          0 DRV is not connected
1533   *          Non zero failure code for errors
1534   */
1535  int pld_is_drv_connected(struct device *dev);
1536  
1537  /**
1538   * pld_socinfo_get_serial_number() - Get SOC serial number
1539   * @dev: device
1540   *
1541   * Return: SOC serial number
1542   */
1543  unsigned int pld_socinfo_get_serial_number(struct device *dev);
1544  
1545  /**
1546   * pld_is_qmi_disable() - Check QMI support is present or not
1547   * @dev: device
1548   *
1549   *  Return: 1 QMI is not supported
1550   *          0 QMI is supported
1551   *          Non zero failure code for errors
1552   */
1553  int pld_is_qmi_disable(struct device *dev);
1554  
1555  /**
1556   * pld_is_fw_down() - Check WLAN fw is down or not
1557   *
1558   * @dev: device
1559   *
1560   * This API will be called to check if WLAN FW is down or not.
1561   *
1562   *  Return: 0 FW is not down
1563   *          Otherwise FW is down
1564   *          Always return 0 for unsupported bus type
1565   */
1566  int pld_is_fw_down(struct device *dev);
1567  
1568  /**
1569   * pld_force_assert_target() - Send a force assert request to FW.
1570   * @dev: device pointer
1571   *
1572   * This can use various sideband requests available at platform driver to
1573   * initiate a FW assert.
1574   *
1575   * Context: Any context
1576   * Return:
1577   * 0 - force assert of FW is triggered successfully.
1578   * -EOPNOTSUPP - force assert is not supported.
1579   * Other non-zero codes - other failures or errors
1580   */
1581  int pld_force_assert_target(struct device *dev);
1582  
1583  /**
1584   * pld_force_collect_target_dump() - Collect FW dump after asserting FW.
1585   * @dev: device pointer
1586   *
1587   * This API will send force assert request to FW and wait till FW dump has
1588   * been collected.
1589   *
1590   * Context: Process context only since this is a blocking call.
1591   * Return:
1592   * 0 - FW dump is collected successfully.
1593   * -EOPNOTSUPP - forcing assert and collecting FW dump is not supported.
1594   * -ETIMEDOUT - FW dump collection is timed out for any reason.
1595   * Other non-zero codes - other failures or errors
1596   */
1597  int pld_force_collect_target_dump(struct device *dev);
1598  
1599  /**
1600   * pld_qmi_send_get() - Indicate certain data to be sent over QMI
1601   * @dev: device pointer
1602   *
1603   * This API can be used to indicate certain data to be sent over QMI.
1604   * pld_qmi_send() is expected to be called later.
1605   *
1606   * Return: 0 for success
1607   *         Non zero failure code for errors
1608   */
1609  int pld_qmi_send_get(struct device *dev);
1610  
1611  /**
1612   * pld_qmi_send_put() - Indicate response sent over QMI has been processed
1613   * @dev: device pointer
1614   *
1615   * This API can be used to indicate response of the data sent over QMI has
1616   * been processed.
1617   *
1618   * Return: 0 for success
1619   *         Non zero failure code for errors
1620   */
1621  int pld_qmi_send_put(struct device *dev);
1622  
1623  /**
1624   * pld_qmi_send() - Send data request over QMI
1625   * @dev: device pointer
1626   * @type: type of the send data operation
1627   * @cmd: buffer pointer of send data request command
1628   * @cmd_len: size of the command buffer
1629   * @cb_ctx: context pointer if any to pass back in callback
1630   * @cb: callback pointer to pass response back
1631   *
1632   * This API can be used to send data request over QMI.
1633   *
1634   * Return: 0 if data request sends successfully
1635   *         Non zero failure code for errors
1636   */
1637  int pld_qmi_send(struct device *dev, int type, void *cmd,
1638  		 int cmd_len, void *cb_ctx,
1639  		 int (*cb)(void *ctx, void *event, int event_len));
1640  
1641  /**
1642   * pld_qmi_indication() - Send data request over QMI
1643   * @dev: device pointer
1644   * @cb_ctx: context pointer if any to pass back in callback
1645   * @cb: callback pointer to pass response back
1646   *
1647   * This API can be used to register for QMI events.
1648   *
1649   * Return: 0 if registration is successful
1650   *         Non zero failure code for errors
1651   */
1652  int pld_qmi_indication(struct device *dev, void *cb_ctx,
1653  		       int (*cb)(void *ctx, uint16_t type,
1654  				 void *event, int event_len));
1655  
1656  /**
1657   * pld_is_fw_dump_skipped() - get fw dump skipped status.
1658   * @dev: device
1659   *
1660   * The subsys ssr status help the driver to decide whether to skip
1661   * the FW memory dump when FW assert.
1662   * For SDIO case, the memory dump progress takes 1 minutes to
1663   * complete, which is not acceptable in SSR enabled.
1664   *
1665   * Return: true if need to skip FW dump.
1666   */
1667  bool pld_is_fw_dump_skipped(struct device *dev);
1668  
1669  /**
1670   * pld_is_low_power_mode() - Check WLAN fw is in low power
1671   * @dev: device
1672   *
1673   * This API will be called to check if WLAN FW is in low power or not.
1674   * Low power means either Deep Sleep or Hibernate state.
1675   *
1676   * Return: 0 FW is not in low power mode
1677   *         Otherwise FW is low power mode
1678   *         Always return 0 for unsupported bus type
1679   */
1680  #ifdef CONFIG_ENABLE_LOW_POWER_MODE
1681  int pld_is_low_power_mode(struct device *dev);
1682  #else
pld_is_low_power_mode(struct device * dev)1683  static inline int pld_is_low_power_mode(struct device *dev)
1684  {
1685  	return 0;
1686  }
1687  #endif
1688  
1689  /**
1690   * pld_is_pdr() - Check WLAN PD is Restarted
1691   * @dev: device
1692   *
1693   * Help the driver decide whether FW down is due to
1694   * WLAN PD Restart.
1695   *
1696   * Return: 1 WLAN PD is Restarted
1697   *         0 WLAN PD is not Restarted
1698   */
1699  int pld_is_pdr(struct device *dev);
1700  
1701  /**
1702   * pld_is_fw_rejuvenate() - Check WLAN fw is rejuvenating
1703   * @dev: device
1704   *
1705   * Help the driver decide whether FW down is due to
1706   * SSR or FW rejuvenate.
1707   *
1708   * Return: 1 FW is rejuvenating
1709   *         0 FW is not rejuvenating
1710   */
1711  int pld_is_fw_rejuvenate(struct device *dev);
1712  
1713  /**
1714   * pld_have_platform_driver_support() - check if platform driver support
1715   * @dev: device
1716   *
1717   * Return: true if platform driver support.
1718   */
1719  bool pld_have_platform_driver_support(struct device *dev);
1720  
1721  /**
1722   * pld_idle_shutdown - request idle shutdown callback from platform driver
1723   * @dev: pointer to struct dev
1724   * @shutdown_cb: pointer to hdd psoc idle shutdown callback handler
1725   *
1726   * Return: 0 for success and non-zero negative error code for failure
1727   */
1728  int pld_idle_shutdown(struct device *dev,
1729  		      int (*shutdown_cb)(struct device *dev));
1730  
1731  /**
1732   * pld_idle_restart - request idle restart callback from platform driver
1733   * @dev: pointer to struct dev
1734   * @restart_cb: pointer to hdd psoc idle restart callback handler
1735   *
1736   * Return: 0 for success and non-zero negative error code for failure
1737   */
1738  int pld_idle_restart(struct device *dev,
1739  		     int (*restart_cb)(struct device *dev));
1740  
1741  /**
1742   * pld_srng_devm_request_irq() - Register IRQ for SRNG
1743   * @dev: device
1744   * @irq: IRQ number
1745   * @handler: IRQ callback function
1746   * @irqflags: IRQ flags
1747   * @name: IRQ name
1748   * @ctx: IRQ context
1749   *
1750   * Return: 0 for success
1751   *         Non zero failure code for errors
1752   */
1753  int pld_srng_devm_request_irq(struct device *dev, int irq,
1754  			      irq_handler_t handler,
1755  			      unsigned long irqflags,
1756  			      const char *name,
1757  			      void *ctx);
1758  
1759  /**
1760   * pld_srng_request_irq() - Register IRQ for SRNG
1761   * @dev: device
1762   * @irq: IRQ number
1763   * @handler: IRQ callback function
1764   * @irqflags: IRQ flags
1765   * @name: IRQ name
1766   * @ctx: IRQ context
1767   *
1768   * Return: 0 for success
1769   *         Non zero failure code for errors
1770   */
1771  int pld_srng_request_irq(struct device *dev, int irq, irq_handler_t handler,
1772  			 unsigned long irqflags,
1773  			 const char *name,
1774  			 void *ctx);
1775  
1776  /**
1777   * pld_srng_free_irq() - Free IRQ for SRNG
1778   * @dev: device
1779   * @irq: IRQ number
1780   * @ctx: IRQ context
1781   *
1782   * Return: 0 for success
1783   *         Non zero failure code for errors
1784   */
1785  int pld_srng_free_irq(struct device *dev, int irq, void *ctx);
1786  
1787  /**
1788   * pld_srng_enable_irq() - Enable IRQ for SRNG
1789   * @dev: device
1790   * @irq: IRQ number
1791   *
1792   * Return: void
1793   */
1794  void pld_srng_enable_irq(struct device *dev, int irq);
1795  
1796  /**
1797   * pld_srng_disable_irq() - Disable IRQ for SRNG
1798   * @dev: device
1799   * @irq: IRQ number
1800   *
1801   * Return: void
1802   */
1803  void pld_srng_disable_irq(struct device *dev, int irq);
1804  
1805  /**
1806   * pld_srng_disable_irq_sync() - Synchronouus disable IRQ for SRNG
1807   * @dev: device
1808   * @irq: IRQ number
1809   *
1810   * Return: void
1811   */
1812  void pld_srng_disable_irq_sync(struct device *dev, int irq);
1813  
1814  /**
1815   * pld_pci_read_config_word() - Read PCI config
1816   * @pdev: pci device
1817   * @offset: Config space offset
1818   * @val : Value
1819   *
1820   * Return: 0 for success
1821   *         Non zero failure code for errors
1822   */
1823  int pld_pci_read_config_word(struct pci_dev *pdev, int offset, uint16_t *val);
1824  
1825  /**
1826   * pld_pci_write_config_word() - Write PCI config
1827   * @pdev: pci device
1828   * @offset: Config space offset
1829   * @val : Value
1830   *
1831   * Return: 0 for success
1832   *         Non zero failure code for errors
1833   */
1834  int pld_pci_write_config_word(struct pci_dev *pdev, int offset, uint16_t val);
1835  
1836  /**
1837   * pld_pci_read_config_dword() - Read PCI config
1838   * @pdev: pci device
1839   * @offset: Config space offset
1840   * @val : Value
1841   *
1842   * Return: 0 for success
1843   *         Non zero failure code for errors
1844   */
1845  int pld_pci_read_config_dword(struct pci_dev *pdev, int offset, uint32_t *val);
1846  
1847  /**
1848   * pld_pci_write_config_dword() - Write PCI config
1849   * @pdev: pci device
1850   * @offset: Config space offset
1851   * @val : Value
1852   *
1853   * Return: 0 for success
1854   *         Non zero failure code for errors
1855   */
1856  int pld_pci_write_config_dword(struct pci_dev *pdev, int offset, uint32_t val);
1857  
1858  /**
1859   * pld_thermal_register() - Register the thermal device with the thermal system
1860   * @dev: The device structure
1861   * @state: The max state to be configured on registration
1862   * @mon_id: Thermal cooling device ID
1863   *
1864   * Return: Error code on error
1865   */
1866  int pld_thermal_register(struct device *dev, unsigned long state, int mon_id);
1867  
1868  /**
1869   * pld_thermal_unregister() - Unregister the device with the thermal system
1870   * @dev: The device structure
1871   * @mon_id: Thermal cooling device ID
1872   *
1873   * Return: None
1874   */
1875  void pld_thermal_unregister(struct device *dev, int mon_id);
1876  
1877  /**
1878   * pld_set_wfc_mode() - Sent WFC mode to FW via platform driver
1879   * @dev: The device structure
1880   * @wfc_mode: WFC Modes (0 => Inactive, 1 => Active)
1881   *
1882   * Return: Error code on error
1883   */
1884  int pld_set_wfc_mode(struct device *dev, enum pld_wfc_mode wfc_mode);
1885  
1886  /**
1887   * pld_bus_width_type_to_str() - Helper function to convert PLD bandwidth level
1888   *				 to string
1889   * @level: PLD bus width level
1890   *
1891   * Return: String corresponding to input "level"
1892   */
1893  const char *pld_bus_width_type_to_str(enum pld_bus_width_type level);
1894  
1895  /**
1896   * pld_get_thermal_state() - Get the current thermal state from the PLD
1897   * @dev: The device structure
1898   * @thermal_state: param to store the current thermal state
1899   * @mon_id: Thermal cooling device ID
1900   *
1901   * Return: Non-zero code for error; zero for success
1902   */
1903  int pld_get_thermal_state(struct device *dev, unsigned long *thermal_state,
1904  			  int mon_id);
1905  
1906  /**
1907   * pld_set_tsf_sync_period() - Set TSF sync period
1908   * @dev: device
1909   * @val: TSF sync time value
1910   *
1911   * Return: void
1912   */
1913  void pld_set_tsf_sync_period(struct device *dev, u32 val);
1914  
1915  /**
1916   * pld_reset_tsf_sync_period() - Reset TSF sync period
1917   * @dev: device
1918   *
1919   * Return: void
1920   */
1921  void pld_reset_tsf_sync_period(struct device *dev);
1922  
1923  #if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 19, 0))
1924  /**
1925   * pld_is_ipa_offload_disabled() - Check if IPA offload is enabled or not
1926   * @dev: The device structure
1927   *
1928   * Return: Non-zero code for IPA offload disable; zero for IPA offload enable
1929   */
1930  int pld_is_ipa_offload_disabled(struct device *dev);
1931  #else
1932  static inline
pld_is_ipa_offload_disabled(struct device * dev)1933  int pld_is_ipa_offload_disabled(struct device *dev)
1934  {
1935  	return 0;
1936  }
1937  #endif
1938  
1939  #if defined(CNSS_MEM_PRE_ALLOC) && defined(FEATURE_SKB_PRE_ALLOC)
1940  
1941  /**
1942   * pld_nbuf_pre_alloc() - get allocated nbuf from platform driver.
1943   * @size: Netbuf requested size
1944   *
1945   * Return: nbuf or NULL if no memory
1946   */
pld_nbuf_pre_alloc(size_t size)1947  static inline struct sk_buff *pld_nbuf_pre_alloc(size_t size)
1948  {
1949  	struct sk_buff *skb = NULL;
1950  
1951  	if (size >= WCNSS_PRE_SKB_ALLOC_GET_THRESHOLD)
1952  		skb = wcnss_skb_prealloc_get(size);
1953  
1954  	return skb;
1955  }
1956  
1957  /**
1958   * pld_nbuf_pre_alloc_free() - free the nbuf allocated in platform driver.
1959   * @skb: Pointer to network buffer
1960   *
1961   * Return: TRUE if the nbuf is freed
1962   */
pld_nbuf_pre_alloc_free(struct sk_buff * skb)1963  static inline int pld_nbuf_pre_alloc_free(struct sk_buff *skb)
1964  {
1965  	return wcnss_skb_prealloc_put(skb);
1966  }
1967  #else
pld_nbuf_pre_alloc(size_t size)1968  static inline struct sk_buff *pld_nbuf_pre_alloc(size_t size)
1969  {
1970  	return NULL;
1971  }
pld_nbuf_pre_alloc_free(struct sk_buff * skb)1972  static inline int pld_nbuf_pre_alloc_free(struct sk_buff *skb)
1973  {
1974  	return 0;
1975  }
1976  #endif
1977  
1978  #ifdef CONFIG_AFC_SUPPORT
1979  /**
1980   * pld_send_buffer_to_afcmem() - Send afc data to afc memory
1981   * @dev: The device structure
1982   * @afcdb: Pointer to afc data buffer
1983   * @len: Length of afc data
1984   * @slotid: Slot id of afc memory
1985   *
1986   * Return: Non-zero code for error; zero for success
1987   */
1988  int pld_send_buffer_to_afcmem(struct device *dev, const uint8_t *afcdb,
1989  			      uint32_t len, uint8_t slotid);
1990  
1991  /**
1992   * pld_reset_afcmem() - Reset afc data in afc memory
1993   * @dev: The device structure
1994   * @slotid: Slot id of afc memory
1995   *
1996   * Return: Non-zero code for error; zero for success
1997   */
1998  int pld_reset_afcmem(struct device *dev, uint8_t slotid);
1999  #else
2000  static inline
pld_send_buffer_to_afcmem(struct device * dev,const uint8_t * afcdb,uint32_t len,uint8_t slotid)2001  int pld_send_buffer_to_afcmem(struct device *dev, const uint8_t *afcdb,
2002  			      uint32_t len, uint8_t slotid)
2003  {
2004  	return -EINVAL;
2005  }
2006  
2007  static inline
pld_reset_afcmem(struct device * dev,uint8_t slotid)2008  int pld_reset_afcmem(struct device *dev, uint8_t slotid)
2009  {
2010  	return -EINVAL;
2011  }
2012  #endif
2013  
2014  /**
2015   * pld_get_bus_type() - Bus type of the device
2016   * @dev: device
2017   *
2018   * Return: PLD bus type
2019   */
2020  enum pld_bus_type pld_get_bus_type(struct device *dev);
2021  
pfrm_devm_request_irq(struct device * dev,unsigned int ce_id,irqreturn_t (* handler)(int,void *),unsigned long flags,const char * name,void * ctx)2022  static inline int pfrm_devm_request_irq(struct device *dev, unsigned int ce_id,
2023  					irqreturn_t (*handler)(int, void *),
2024  					unsigned long flags, const char *name,
2025  					void *ctx)
2026  {
2027  	return pld_srng_devm_request_irq(dev, ce_id, handler, flags, name, ctx);
2028  }
2029  
pfrm_request_irq(struct device * dev,unsigned int ce_id,irqreturn_t (* handler)(int,void *),unsigned long flags,const char * name,void * ctx)2030  static inline int pfrm_request_irq(struct device *dev, unsigned int ce_id,
2031  				   irqreturn_t (*handler)(int, void *),
2032  				   unsigned long flags, const char *name,
2033  				   void *ctx)
2034  {
2035  	return pld_srng_request_irq(dev, ce_id, handler, flags, name, ctx);
2036  }
2037  
pfrm_free_irq(struct device * dev,int irq,void * ctx)2038  static inline int pfrm_free_irq(struct device *dev, int irq, void *ctx)
2039  {
2040  	return pld_srng_free_irq(dev, irq, ctx);
2041  }
2042  
pfrm_enable_irq(struct device * dev,int irq)2043  static inline void pfrm_enable_irq(struct device *dev, int irq)
2044  {
2045  	pld_srng_enable_irq(dev, irq);
2046  }
2047  
pfrm_disable_irq_nosync(struct device * dev,int irq)2048  static inline void pfrm_disable_irq_nosync(struct device *dev, int irq)
2049  {
2050  	pld_srng_disable_irq(dev, irq);
2051  }
2052  
pfrm_disable_irq(struct device * dev,int irq)2053  static inline void pfrm_disable_irq(struct device *dev, int irq)
2054  {
2055  	pld_srng_disable_irq_sync(dev, irq);
2056  }
2057  
pfrm_read_config_word(struct pci_dev * pdev,int offset,uint16_t * val)2058  static inline int pfrm_read_config_word(struct pci_dev *pdev, int offset,
2059  					uint16_t *val)
2060  {
2061  	return pld_pci_read_config_word(pdev, offset, val);
2062  }
2063  
pfrm_write_config_word(struct pci_dev * pdev,int offset,uint16_t val)2064  static inline int pfrm_write_config_word(struct pci_dev *pdev, int offset,
2065  					 uint16_t val)
2066  {
2067  	return pld_pci_write_config_word(pdev, offset, val);
2068  }
2069  
pfrm_read_config_dword(struct pci_dev * pdev,int offset,uint32_t * val)2070  static inline int pfrm_read_config_dword(struct pci_dev *pdev, int offset,
2071  					 uint32_t *val)
2072  {
2073  	return pld_pci_read_config_dword(pdev, offset, val);
2074  }
2075  
pfrm_write_config_dword(struct pci_dev * pdev,int offset,uint32_t val)2076  static inline int pfrm_write_config_dword(struct pci_dev *pdev, int offset,
2077  					  uint32_t val)
2078  {
2079  	return pld_pci_write_config_dword(pdev, offset, val);
2080  }
2081  
pld_get_enable_intx(struct device * dev)2082  static inline bool pld_get_enable_intx(struct device *dev)
2083  {
2084  	return false;
2085  }
2086  
2087  /**
2088   * pld_is_one_msi()- whether one MSI is used or not
2089   * @dev: device structure
2090   *
2091   * Return: true if it is one MSI
2092   */
2093  bool pld_is_one_msi(struct device *dev);
2094  
2095  #ifdef FEATURE_DIRECT_LINK
2096  /**
2097   * pld_audio_smmu_map()- Map memory region into Audio SMMU CB
2098   * @dev: pointer to device structure
2099   * @paddr: physical address
2100   * @iova: DMA address
2101   * @size: memory region size
2102   *
2103   * Return: 0 on success else failure code
2104   */
2105  int pld_audio_smmu_map(struct device *dev, phys_addr_t paddr, dma_addr_t iova,
2106  		       size_t size);
2107  
2108  /**
2109   * pld_audio_smmu_unmap()- Remove memory region mapping from Audio SMMU CB
2110   * @dev: pointer to device structure
2111   * @iova: DMA address
2112   * @size: memory region size
2113   *
2114   * Return: None
2115   */
2116  void pld_audio_smmu_unmap(struct device *dev, dma_addr_t iova, size_t size);
2117  #else
2118  static inline
pld_audio_smmu_map(struct device * dev,phys_addr_t paddr,dma_addr_t iova,size_t size)2119  int pld_audio_smmu_map(struct device *dev, phys_addr_t paddr, dma_addr_t iova,
2120  		       size_t size)
2121  {
2122  	return 0;
2123  }
2124  
2125  static inline
pld_audio_smmu_unmap(struct device * dev,dma_addr_t iova,size_t size)2126  void pld_audio_smmu_unmap(struct device *dev, dma_addr_t iova, size_t size)
2127  {
2128  }
2129  #endif
2130  #endif
2131