drivers/gpu/arm/midgard/mali_kbase_config.h

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