1 /* 2 * 3 * (C) COPYRIGHT 2010-2016 ARM Limited. All rights reserved. 4 * 5 * This program is free software and is provided to you under the terms of the 6 * GNU General Public License version 2 as published by the Free Software 7 * Foundation, and any use by you of this program is subject to the terms 8 * of such GNU licence. 9 * 10 * A copy of the licence is included with the program, and can also be obtained 11 * from Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, 12 * Boston, MA 02110-1301, USA. 13 * 14 */ 15 16 17 18 19 20 /** 21 * @file mali_kbase_config.h 22 * Configuration API and Attributes for KBase 23 */ 24 25 #ifndef _KBASE_CONFIG_H_ 26 #define _KBASE_CONFIG_H_ 27 28 #include <asm/page.h> 29 30 #include <mali_malisw.h> 31 #include <mali_kbase_backend_config.h> 32 33 /** 34 * @addtogroup base_api 35 * @{ 36 */ 37 38 /** 39 * @addtogroup base_kbase_api 40 * @{ 41 */ 42 43 /** 44 * @addtogroup kbase_config Configuration API and Attributes 45 * @{ 46 */ 47 48 #include <linux/rbtree.h> 49 50 /* Forward declaration of struct kbase_device */ 51 struct kbase_device; 52 53 /** 54 * kbase_platform_funcs_conf - Specifies platform init/term function pointers 55 * 56 * Specifies the functions pointers for platform specific initialization and 57 * termination. By default no functions are required. No additional platform 58 * specific control is necessary. 59 */ 60 struct kbase_platform_funcs_conf { 61 /** 62 * platform_init_func - platform specific init function pointer 63 * @kbdev - kbase_device pointer 64 * 65 * Returns 0 on success, negative error code otherwise. 66 * 67 * Function pointer for platform specific initialization or NULL if no 68 * initialization function is required. At the point this the GPU is 69 * not active and its power and clocks are in unknown (platform specific 70 * state) as kbase doesn't yet have control of power and clocks. 71 * 72 * The platform specific private pointer kbase_device::platform_context 73 * can be accessed (and possibly initialized) in here. 74 */ 75 int (*platform_init_func)(struct kbase_device *kbdev); 76 /** 77 * platform_term_func - platform specific termination function pointer 78 * @kbdev - kbase_device pointer 79 * 80 * Function pointer for platform specific termination or NULL if no 81 * termination function is required. At the point this the GPU will be 82 * idle but still powered and clocked. 83 * 84 * The platform specific private pointer kbase_device::platform_context 85 * can be accessed (and possibly terminated) in here. 86 */ 87 void (*platform_term_func)(struct kbase_device *kbdev); 88 }; 89 90 /* 91 * @brief Specifies the callbacks for power management 92 * 93 * By default no callbacks will be made and the GPU must not be powered off. 94 */ 95 struct kbase_pm_callback_conf { 96 /** Callback for when the GPU is idle and the power to it can be switched off. 97 * 98 * The system integrator can decide whether to either do nothing, just switch off 99 * the clocks to the GPU, or to completely power down the GPU. 100 * The platform specific private pointer kbase_device::platform_context can be accessed and modified in here. It is the 101 * platform \em callbacks responsibility to initialize and terminate this pointer if used (see @ref kbase_platform_funcs_conf). 102 */ 103 void (*power_off_callback)(struct kbase_device *kbdev); 104 105 /** Callback for when the GPU is about to become active and power must be supplied. 106 * 107 * This function must not return until the GPU is powered and clocked sufficiently for register access to 108 * succeed. The return value specifies whether the GPU was powered down since the call to power_off_callback. 109 * If the GPU state has been lost then this function must return 1, otherwise it should return 0. 110 * The platform specific private pointer kbase_device::platform_context can be accessed and modified in here. It is the 111 * platform \em callbacks responsibility to initialize and terminate this pointer if used (see @ref kbase_platform_funcs_conf). 112 * 113 * The return value of the first call to this function is ignored. 114 * 115 * @return 1 if the GPU state may have been lost, 0 otherwise. 116 */ 117 int (*power_on_callback)(struct kbase_device *kbdev); 118 119 /** Callback for when the system is requesting a suspend and GPU power 120 * must be switched off. 121 * 122 * Note that if this callback is present, then this may be called 123 * without a preceding call to power_off_callback. Therefore this 124 * callback must be able to take any action that might otherwise happen 125 * in power_off_callback. 126 * 127 * The platform specific private pointer kbase_device::platform_context 128 * can be accessed and modified in here. It is the platform \em 129 * callbacks responsibility to initialize and terminate this pointer if 130 * used (see @ref kbase_platform_funcs_conf). 131 */ 132 void (*power_suspend_callback)(struct kbase_device *kbdev); 133 134 /** Callback for when the system is resuming from a suspend and GPU 135 * power must be switched on. 136 * 137 * Note that if this callback is present, then this may be called 138 * without a following call to power_on_callback. Therefore this 139 * callback must be able to take any action that might otherwise happen 140 * in power_on_callback. 141 * 142 * The platform specific private pointer kbase_device::platform_context 143 * can be accessed and modified in here. It is the platform \em 144 * callbacks responsibility to initialize and terminate this pointer if 145 * used (see @ref kbase_platform_funcs_conf). 146 */ 147 void (*power_resume_callback)(struct kbase_device *kbdev); 148 149 /** Callback for handling runtime power management initialization. 150 * 151 * The runtime power management callbacks @ref power_runtime_off_callback and @ref power_runtime_on_callback 152 * will become active from calls made to the OS from within this function. 153 * The runtime calls can be triggered by calls from @ref power_off_callback and @ref power_on_callback. 154 * Note: for linux the kernel must have CONFIG_PM_RUNTIME enabled to use this feature. 155 * 156 * @return 0 on success, else int error code. 157 */ 158 int (*power_runtime_init_callback)(struct kbase_device *kbdev); 159 160 /** Callback for handling runtime power management termination. 161 * 162 * The runtime power management callbacks @ref power_runtime_off_callback and @ref power_runtime_on_callback 163 * should no longer be called by the OS on completion of this function. 164 * Note: for linux the kernel must have CONFIG_PM_RUNTIME enabled to use this feature. 165 */ 166 void (*power_runtime_term_callback)(struct kbase_device *kbdev); 167 168 /** Callback for runtime power-off power management callback 169 * 170 * For linux this callback will be called by the kernel runtime_suspend callback. 171 * Note: for linux the kernel must have CONFIG_PM_RUNTIME enabled to use this feature. 172 * 173 * @return 0 on success, else OS error code. 174 */ 175 void (*power_runtime_off_callback)(struct kbase_device *kbdev); 176 177 /** Callback for runtime power-on power management callback 178 * 179 * For linux this callback will be called by the kernel runtime_resume callback. 180 * Note: for linux the kernel must have CONFIG_PM_RUNTIME enabled to use this feature. 181 */ 182 int (*power_runtime_on_callback)(struct kbase_device *kbdev); 183 184 /* 185 * Optional callback for checking if GPU can be suspended when idle 186 * 187 * This callback will be called by the runtime power management core 188 * when the reference count goes to 0 to provide notification that the 189 * GPU now seems idle. 190 * 191 * If this callback finds that the GPU can't be powered off, or handles 192 * suspend by powering off directly or queueing up a power off, a 193 * non-zero value must be returned to prevent the runtime PM core from 194 * also triggering a suspend. 195 * 196 * Returning 0 will cause the runtime PM core to conduct a regular 197 * autosuspend. 198 * 199 * This callback is optional and if not provided regular autosuspend 200 * will be triggered. 201 * 202 * Note: The Linux kernel must have CONFIG_PM_RUNTIME enabled to use 203 * this feature. 204 * 205 * Return 0 if GPU can be suspended, positive value if it can not be 206 * suspeneded by runtime PM, else OS error code 207 */ 208 int (*power_runtime_idle_callback)(struct kbase_device *kbdev); 209 }; 210 211 /** 212 * kbase_cpuprops_get_default_clock_speed - default for CPU_SPEED_FUNC 213 * @clock_speed - see kbase_cpu_clk_speed_func for details on the parameters 214 * 215 * Returns 0 on success, negative error code otherwise. 216 * 217 * Default implementation of CPU_SPEED_FUNC. This function sets clock_speed 218 * to 100, so will be an underestimate for any real system. 219 */ 220 int kbase_cpuprops_get_default_clock_speed(u32 * const clock_speed); 221 222 /** 223 * kbase_cpu_clk_speed_func - Type of the function pointer for CPU_SPEED_FUNC 224 * @param clock_speed - pointer to store the current CPU clock speed in MHz 225 * 226 * Returns 0 on success, otherwise negative error code. 227 * 228 * This is mainly used to implement OpenCL's clGetDeviceInfo(). 229 */ 230 typedef int (*kbase_cpu_clk_speed_func) (u32 *clock_speed); 231 232 /** 233 * kbase_gpu_clk_speed_func - Type of the function pointer for GPU_SPEED_FUNC 234 * @param clock_speed - pointer to store the current GPU clock speed in MHz 235 * 236 * Returns 0 on success, otherwise negative error code. 237 * When an error is returned the caller assumes maximum GPU speed stored in 238 * gpu_freq_khz_max. 239 * 240 * If the system timer is not available then this function is required 241 * for the OpenCL queue profiling to return correct timing information. 242 * 243 */ 244 typedef int (*kbase_gpu_clk_speed_func) (u32 *clock_speed); 245 246 #ifdef CONFIG_OF 247 struct kbase_platform_config { 248 }; 249 #else 250 251 /* 252 * @brief Specifies start and end of I/O memory region. 253 */ 254 struct kbase_io_memory_region { 255 u64 start; 256 u64 end; 257 }; 258 259 /* 260 * @brief Specifies I/O related resources like IRQs and memory region for I/O operations. 261 */ 262 struct kbase_io_resources { 263 u32 job_irq_number; 264 u32 mmu_irq_number; 265 u32 gpu_irq_number; 266 struct kbase_io_memory_region io_memory_region; 267 }; 268 269 struct kbase_platform_config { 270 const struct kbase_io_resources *io_resources; 271 }; 272 273 #endif /* CONFIG_OF */ 274 275 /** 276 * @brief Gets the pointer to platform config. 277 * 278 * @return Pointer to the platform config 279 */ 280 struct kbase_platform_config *kbase_get_platform_config(void); 281 282 /** 283 * kbasep_platform_device_init: - Platform specific call to initialize hardware 284 * @kbdev: kbase device pointer 285 * 286 * Function calls a platform defined routine if specified in the configuration 287 * attributes. The routine can initialize any hardware and context state that 288 * is required for the GPU block to function. 289 * 290 * Return: 0 if no errors have been found in the config. 291 * Negative error code otherwise. 292 */ 293 int kbasep_platform_device_init(struct kbase_device *kbdev); 294 295 /** 296 * kbasep_platform_device_term - Platform specific call to terminate hardware 297 * @kbdev: Kbase device pointer 298 * 299 * Function calls a platform defined routine if specified in the configuration 300 * attributes. The routine can destroy any platform specific context state and 301 * shut down any hardware functionality that are outside of the Power Management 302 * callbacks. 303 * 304 */ 305 void kbasep_platform_device_term(struct kbase_device *kbdev); 306 307 308 /** 309 * kbase_platform_early_init - Early initialisation of the platform code 310 * 311 * This function will be called when the module is loaded to perform any 312 * early initialisation required by the platform code. Such as reading 313 * platform specific device tree entries for the GPU. 314 * 315 * Return: 0 for success, any other fail causes module initialisation to fail 316 */ 317 int kbase_platform_early_init(void); 318 319 #ifndef CONFIG_OF 320 #ifdef CONFIG_MALI_PLATFORM_FAKE 321 /** 322 * kbase_platform_fake_register - Register a platform device for the GPU 323 * 324 * This can be used to register a platform device on systems where device tree 325 * is not enabled and the platform initialisation code in the kernel doesn't 326 * create the GPU device. Where possible device tree should be used instead. 327 * 328 * Return: 0 for success, any other fail causes module initialisation to fail 329 */ 330 int kbase_platform_fake_register(void); 331 332 /** 333 * kbase_platform_fake_unregister - Unregister a fake platform device 334 * 335 * Unregister the platform device created with kbase_platform_fake_register() 336 */ 337 void kbase_platform_fake_unregister(void); 338 #endif 339 #endif 340 341 /** @} *//* end group kbase_config */ 342 /** @} *//* end group base_kbase_api */ 343 /** @} *//* end group base_api */ 344 345 #endif /* _KBASE_CONFIG_H_ */ 346