drivers/gpu/arm/midgard/mali_kbase_config.h

   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_ */