| /* SPDX-License-Identifier: GPL-2.0-only */ |
| /* |
| * Copyright (c) 2010-2021, The Linux Foundation. All rights reserved. |
| * Copyright (c) 2022-2024 Qualcomm Innovation Center, Inc. All rights reserved. |
| */ |
| #ifndef __KGSL_PWRCTRL_H |
| #define __KGSL_PWRCTRL_H |
| |
| #include <linux/clk.h> |
| #include <linux/pm_qos.h> |
| |
| /***************************************************************************** |
| * power flags |
| ****************************************************************************/ |
| #define KGSL_MAX_CLKS 18 |
| |
| #define KGSL_MAX_PWRLEVELS 32 |
| |
| #define KGSL_PWRFLAGS_POWER_ON 0 |
| #define KGSL_PWRFLAGS_CLK_ON 1 |
| #define KGSL_PWRFLAGS_AXI_ON 2 |
| #define KGSL_PWRFLAGS_IRQ_ON 3 |
| |
| /* Use to enable all the force power on states at once */ |
| #define KGSL_PWR_ON GENMASK(5, 0) |
| |
| /* Only two supported levels, min & max */ |
| #define KGSL_CONSTRAINT_PWR_MAXLEVELS 2 |
| |
| #define KGSL_XO_CLK_FREQ 19200000 |
| #define KGSL_ISENSE_CLK_FREQ 200000000 |
| |
| struct platform_device; |
| struct icc_path; |
| |
| struct kgsl_clk_stats { |
| unsigned int busy; |
| unsigned int total; |
| unsigned int busy_old; |
| unsigned int total_old; |
| }; |
| |
| struct kgsl_pwr_constraint { |
| unsigned int type; |
| unsigned int sub_type; |
| unsigned long expires; |
| uint32_t owner_id; |
| u32 owner_timestamp; |
| }; |
| |
| /** |
| * struct kgsl_pwrlevel - Struct holding different pwrlevel info obtained from |
| * from dtsi file |
| * @gpu_freq: GPU frequency vote in Hz |
| * @bus_freq: Bus bandwidth vote index |
| * @bus_min: Min bus index @gpu_freq |
| * @bus_max: Max bus index @gpu_freq |
| */ |
| struct kgsl_pwrlevel { |
| unsigned int gpu_freq; |
| unsigned int bus_freq; |
| unsigned int bus_min; |
| unsigned int bus_max; |
| unsigned int acd_level; |
| /** @cx_level: CX vote */ |
| u32 cx_level; |
| /** @voltage_level: Voltage level used by the GMU to vote RPMh */ |
| u32 voltage_level; |
| }; |
| |
| /** |
| * struct kgsl_pwrctrl - Power control settings for a KGSL device |
| * @interrupt_num - The interrupt number for the device |
| * @grp_clks - Array of clocks structures that we control |
| * @power_flags - Control flags for power |
| * @pwrlevels - List of supported power levels |
| * @active_pwrlevel - The currently active power level |
| * @previous_pwrlevel - The power level before transition |
| * @thermal_pwrlevel - maximum powerlevel constraint from thermal |
| * @thermal_pwrlevel_floor - minimum powerlevel constraint from thermal |
| * @default_pwrlevel - device wake up power level |
| * @max_pwrlevel - maximum allowable powerlevel per the user |
| * @min_pwrlevel - minimum allowable powerlevel per the user |
| * @num_pwrlevels - number of available power levels |
| * @throttle_mask - LM throttle mask |
| * @interval_timeout - timeout to be idle before a power event |
| * @clock_times - Each GPU frequency's accumulated active time in us |
| * @clk_stats - structure of clock statistics |
| * @input_disable - To disable GPU wakeup on touch input event |
| * @bus_control - true if the bus calculation is independent |
| * @bus_mod - modifier from the current power level for the bus vote |
| * @bus_percent_ab - current percent of total possible bus usage |
| * @bus_width - target specific bus width in number of bytes |
| * @bus_ab_mbytes - AB vote in Mbytes for current bus usage |
| * @constraint - currently active power constraint |
| * @superfast - Boolean flag to indicate that the GPU start should be run in the |
| * higher priority thread |
| * isense_clk_indx - index of isense clock, 0 if no isense |
| * isense_clk_on_level - isense clock rate is XO rate below this level. |
| */ |
| |
| struct kgsl_pwrctrl { |
| int interrupt_num; |
| struct clk *grp_clks[KGSL_MAX_CLKS]; |
| struct clk *gpu_bimc_int_clk; |
| /** @cx_gdsc: Pointer to the CX domain regulator if applicable */ |
| struct regulator *cx_gdsc; |
| /** @gx_gdsc: Pointer to the GX domain regulator if applicable */ |
| struct regulator *gx_gdsc; |
| /** @gx_gdsc: Pointer to the GX domain parent supply */ |
| struct regulator *gx_gdsc_parent; |
| /** @gx_gdsc_parent_min_corner: Minimum supply voltage for GX parent */ |
| u32 gx_gdsc_parent_min_corner; |
| /** @cx_gdsc_nb: Notifier block for cx gdsc regulator */ |
| struct notifier_block cx_gdsc_nb; |
| /** @cx_gdsc_gate: Completion to signal cx gdsc collapse status */ |
| struct completion cx_gdsc_gate; |
| /** @cx_gdsc_wait: Whether to wait for cx gdsc to turn off */ |
| bool cx_gdsc_wait; |
| /** @cx_gdsc_offset: Offset of CX GDSC register */ |
| u32 cx_gdsc_offset; |
| int isense_clk_indx; |
| int isense_clk_on_level; |
| unsigned long power_flags; |
| unsigned long ctrl_flags; |
| struct kgsl_pwrlevel pwrlevels[KGSL_MAX_PWRLEVELS]; |
| unsigned int active_pwrlevel; |
| unsigned int previous_pwrlevel; |
| unsigned int thermal_pwrlevel; |
| unsigned int thermal_pwrlevel_floor; |
| unsigned int default_pwrlevel; |
| unsigned int max_pwrlevel; |
| unsigned int min_pwrlevel; |
| unsigned int num_pwrlevels; |
| unsigned int throttle_mask; |
| u32 interval_timeout; |
| u64 clock_times[KGSL_MAX_PWRLEVELS]; |
| struct kgsl_clk_stats clk_stats; |
| bool bus_control; |
| int bus_mod; |
| unsigned int bus_percent_ab; |
| unsigned int bus_width; |
| unsigned long bus_ab_mbytes; |
| /** @ddr_table: List of the DDR bandwidths in KBps for the target */ |
| u32 *ddr_table; |
| /** @ddr_table_count: Number of objects in @ddr_table */ |
| int ddr_table_count; |
| /** cur_buslevel: The last buslevel voted by the driver */ |
| int cur_buslevel; |
| /** @bus_max: The maximum bandwidth available to the device */ |
| unsigned long bus_max; |
| struct kgsl_pwr_constraint constraint; |
| bool superfast; |
| unsigned int gpu_bimc_int_clk_freq; |
| bool gpu_bimc_interface_enabled; |
| /** @icc_path: Interconnect path for the GPU (if applicable) */ |
| struct icc_path *icc_path; |
| /** cur_ab: The last ab voted by the driver */ |
| u32 cur_ab; |
| /** @sysfs_thermal_req - PM QoS maximum frequency request from user (via sysfs) */ |
| struct dev_pm_qos_request sysfs_thermal_req; |
| /** @time_in_pwrlevel: Each pwrlevel active duration in usec */ |
| u64 time_in_pwrlevel[KGSL_MAX_PWRLEVELS]; |
| /** @last_stat_updated: The last time stats were updated */ |
| ktime_t last_stat_updated; |
| /** @nb_max: Notifier block for DEV_PM_QOS_MAX_FREQUENCY */ |
| struct notifier_block nb_max; |
| /** @cur_dcvs_buslevel: Current bus level decided by bus DCVS */ |
| u32 cur_dcvs_buslevel; |
| /** @rt_bus_hint: IB level hint for real time clients i.e. RB-0 */ |
| u32 rt_bus_hint; |
| /** @rt_bus_hint_active: Boolean flag to indicate if RT bus hint is active */ |
| bool rt_bus_hint_active; |
| /** @wake_on_touch: If true our last wakeup was due to a touch event */ |
| bool wake_on_touch; |
| }; |
| |
| int kgsl_pwrctrl_init(struct kgsl_device *device); |
| void kgsl_pwrctrl_close(struct kgsl_device *device); |
| void kgsl_timer(struct timer_list *t); |
| void kgsl_pre_hwaccess(struct kgsl_device *device); |
| void kgsl_pwrctrl_pwrlevel_change(struct kgsl_device *device, |
| unsigned int level); |
| int kgsl_pwrctrl_init_sysfs(struct kgsl_device *device); |
| int kgsl_pwrctrl_change_state(struct kgsl_device *device, int state); |
| |
| unsigned int kgsl_pwrctrl_adjust_pwrlevel(struct kgsl_device *device, |
| unsigned int new_level); |
| |
| /* |
| * kgsl_pwrctrl_active_freq - get currently configured frequency |
| * @pwr: kgsl_pwrctrl structure for the device |
| * |
| * Returns the currently configured frequency for the device. |
| */ |
| static inline unsigned long |
| kgsl_pwrctrl_active_freq(struct kgsl_pwrctrl *pwr) |
| { |
| return pwr->pwrlevels[pwr->active_pwrlevel].gpu_freq; |
| } |
| |
| /** |
| * kgsl_active_count_wait() - Wait for activity to finish. |
| * @device: Pointer to a KGSL device |
| * @count: Active count value to wait for |
| * @wait_jiffies: Jiffies to wait |
| * |
| * Block until the active_cnt value hits the desired value |
| */ |
| int kgsl_active_count_wait(struct kgsl_device *device, int count, |
| unsigned long wait_jiffies); |
| void kgsl_pwrctrl_busy_time(struct kgsl_device *device, u64 time, u64 busy); |
| |
| /** |
| * kgsl_pwrctrl_set_constraint() - Validate and change enforced constraint |
| * @device: Pointer to the kgsl_device struct |
| * @pwrc: Pointer to requested constraint |
| * @id: Context id which owns the constraint |
| * @ts: The timestamp for which this constraint is enforced |
| * |
| * Accept the new constraint if no previous constraint existed or if the |
| * new constraint is faster than the previous one. If the new and previous |
| * constraints are equal, update the timestamp and ownership to make sure |
| * the constraint expires at the correct time. |
| */ |
| void kgsl_pwrctrl_set_constraint(struct kgsl_device *device, |
| struct kgsl_pwr_constraint *pwrc, u32 id, u32 ts); |
| int kgsl_pwrctrl_set_default_gpu_pwrlevel(struct kgsl_device *device); |
| |
| /** |
| * kgsl_pwrctrl_request_state - Request a specific power state |
| * @device: Pointer to the kgsl device |
| * @state: Power state requested |
| */ |
| void kgsl_pwrctrl_request_state(struct kgsl_device *device, u32 state); |
| |
| /** |
| * kgsl_pwrctrl_set_state - Set a specific power state |
| * @device: Pointer to the kgsl device |
| * @state: Power state requested |
| */ |
| void kgsl_pwrctrl_set_state(struct kgsl_device *device, u32 state); |
| |
| /** |
| * kgsl_pwrctrl_axi - Propagate bus votes during slumber entry and exit |
| * @device: Pointer to the kgsl device |
| * @state: Whether we are going to slumber or coming out of slumber |
| * |
| * This function will propagate the default bus vote when coming out of |
| * slumber and set bus bandwidth to 0 when going into slumber |
| * |
| * Return: 0 on success or negative error on failure |
| */ |
| int kgsl_pwrctrl_axi(struct kgsl_device *device, bool state); |
| |
| /** |
| * kgsl_idle_check - kgsl idle function |
| * @work: work item being run by the function |
| * |
| * This function is called for work that is queued by the interrupt |
| * handler or the idle timer. It attempts to transition to a clocks |
| * off state if the active_cnt is 0 and the hardware is idle. |
| */ |
| void kgsl_idle_check(struct work_struct *work); |
| |
| /** |
| * kgsl_pwrctrl_irq - Enable or disable gpu interrupts |
| * @device: Handle to the kgsl device |
| * @state: Variable to decide whether interrupts need to be enabled or disabled |
| * |
| */ |
| void kgsl_pwrctrl_irq(struct kgsl_device *device, bool state); |
| |
| /** |
| * kgsl_pwrctrl_clear_l3_vote - Relinquish l3 vote |
| * @device: Handle to the kgsl device |
| * |
| * Clear the l3 vote when going into slumber |
| */ |
| void kgsl_pwrctrl_clear_l3_vote(struct kgsl_device *device); |
| |
| /** |
| * kgsl_pwrctrl_enable_cx_gdsc - Enable cx gdsc |
| * @device: Pointer to the kgsl device |
| * |
| * Return: 0 on success or negative error on failure |
| */ |
| int kgsl_pwrctrl_enable_cx_gdsc(struct kgsl_device *device); |
| |
| /** |
| * kgsl_pwrctrl_disable_cx_gdsc - Disable cx gdsc |
| * @device: Pointer to the kgsl device |
| */ |
| void kgsl_pwrctrl_disable_cx_gdsc(struct kgsl_device *device); |
| |
| /** |
| * kgsl_pwrctrl_probe_regulators - Probe regulators |
| * @device: Pointer to the kgsl device |
| * @pdev: Pointer to the platform device |
| * |
| * Return: 0 on success or negative error on failure |
| */ |
| int kgsl_pwrctrl_probe_regulators(struct kgsl_device *device, |
| struct platform_device *pdev); |
| #endif /* __KGSL_PWRCTRL_H */ |
