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