Line data    Source code

       1             : // SPDX-License-Identifier: GPL-2.0
       2             : 
       3             : #ifndef _DRM_MANAGED_H_
       4             : #define _DRM_MANAGED_H_
       5             : 
       6             : #include <linux/gfp.h>
       7             : #include <linux/overflow.h>
       8             : #include <linux/types.h>
       9             : 
      10             : struct drm_device;
      11             : struct mutex;
      12             : 
      13             : typedef void (*drmres_release_t)(struct drm_device *dev, void *res);
      14             : 
      15             : /**
      16             :  * drmm_add_action - add a managed release action to a &drm_device
      17             :  * @dev: DRM device
      18             :  * @action: function which should be called when @dev is released
      19             :  * @data: opaque pointer, passed to @action
      20             :  *
      21             :  * This function adds the @release action with optional parameter @data to the
      22             :  * list of cleanup actions for @dev. The cleanup actions will be run in reverse
      23             :  * order in the final drm_dev_put() call for @dev.
      24             :  */
      25             : #define drmm_add_action(dev, action, data) \
      26             :         __drmm_add_action(dev, action, data, #action)
      27             : 
      28             : int __must_check __drmm_add_action(struct drm_device *dev,
      29             :                                    drmres_release_t action,
      30             :                                    void *data, const char *name);
      31             : 
      32             : /**
      33             :  * drmm_add_action_or_reset - add a managed release action to a &drm_device
      34             :  * @dev: DRM device
      35             :  * @action: function which should be called when @dev is released
      36             :  * @data: opaque pointer, passed to @action
      37             :  *
      38             :  * Similar to drmm_add_action(), with the only difference that upon failure
      39             :  * @action is directly called for any cleanup work necessary on failures.
      40             :  */
      41             : #define drmm_add_action_or_reset(dev, action, data) \
      42             :         __drmm_add_action_or_reset(dev, action, data, #action)
      43             : 
      44             : int __must_check __drmm_add_action_or_reset(struct drm_device *dev,
      45             :                                             drmres_release_t action,
      46             :                                             void *data, const char *name);
      47             : 
      48             : void *drmm_kmalloc(struct drm_device *dev, size_t size, gfp_t gfp) __malloc;
      49             : 
      50             : /**
      51             :  * drmm_kzalloc - &drm_device managed kzalloc()
      52             :  * @dev: DRM device
      53             :  * @size: size of the memory allocation
      54             :  * @gfp: GFP allocation flags
      55             :  *
      56             :  * This is a &drm_device managed version of kzalloc(). The allocated memory is
      57             :  * automatically freed on the final drm_dev_put(). Memory can also be freed
      58             :  * before the final drm_dev_put() by calling drmm_kfree().
      59             :  */
      60             : static inline void *drmm_kzalloc(struct drm_device *dev, size_t size, gfp_t gfp)
      61             : {
      62           5 :         return drmm_kmalloc(dev, size, gfp | __GFP_ZERO);
      63             : }
      64             : 
      65             : /**
      66             :  * drmm_kmalloc_array - &drm_device managed kmalloc_array()
      67             :  * @dev: DRM device
      68             :  * @n: number of array elements to allocate
      69             :  * @size: size of array member
      70             :  * @flags: GFP allocation flags
      71             :  *
      72             :  * This is a &drm_device managed version of kmalloc_array(). The allocated
      73             :  * memory is automatically freed on the final drm_dev_put() and works exactly
      74             :  * like a memory allocation obtained by drmm_kmalloc().
      75             :  */
      76             : static inline void *drmm_kmalloc_array(struct drm_device *dev,
      77             :                                        size_t n, size_t size, gfp_t flags)
      78             : {
      79             :         size_t bytes;
      80             : 
      81           0 :         if (unlikely(check_mul_overflow(n, size, &bytes)))
      82             :                 return NULL;
      83             : 
      84           0 :         return drmm_kmalloc(dev, bytes, flags);
      85             : }
      86             : 
      87             : /**
      88             :  * drmm_kcalloc - &drm_device managed kcalloc()
      89             :  * @dev: DRM device
      90             :  * @n: number of array elements to allocate
      91             :  * @size: size of array member
      92             :  * @flags: GFP allocation flags
      93             :  *
      94             :  * This is a &drm_device managed version of kcalloc(). The allocated memory is
      95             :  * automatically freed on the final drm_dev_put() and works exactly like a
      96             :  * memory allocation obtained by drmm_kmalloc().
      97             :  */
      98             : static inline void *drmm_kcalloc(struct drm_device *dev,
      99             :                                  size_t n, size_t size, gfp_t flags)
     100             : {
     101           0 :         return drmm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
     102             : }
     103             : 
     104             : char *drmm_kstrdup(struct drm_device *dev, const char *s, gfp_t gfp);
     105             : 
     106             : void drmm_kfree(struct drm_device *dev, void *data);
     107             : 
     108             : void __drmm_mutex_release(struct drm_device *dev, void *res);
     109             : 
     110             : /**
     111             :  * drmm_mutex_init - &drm_device-managed mutex_init()
     112             :  * @dev: DRM device
     113             :  * @lock: lock to be initialized
     114             :  *
     115             :  * Returns:
     116             :  * 0 on success, or a negative errno code otherwise.
     117             :  *
     118             :  * This is a &drm_device-managed version of mutex_init(). The initialized
     119             :  * lock is automatically destroyed on the final drm_dev_put().
     120             :  */
     121             : #define drmm_mutex_init(dev, lock) ({                                        \
     122             :         mutex_init(lock);                                                    \
     123             :         drmm_add_action_or_reset(dev, __drmm_mutex_release, lock);           \
     124             : })                                                                           \
     125             : 
     126             : #endif