include/drm/drm_managed.h

   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
  12 typedef void (*drmres_release_t)(struct drm_device *dev, void *res);
  13
  14 /**
  15  * drmm_add_action - add a managed release action to a &drm_device
  16  * @dev: DRM device
  17  * @action: function which should be called when @dev is released
  18  * @data: opaque pointer, passed to @action
  19  *
  20  * This function adds the @release action with optional parameter @data to the
  21  * list of cleanup actions for @dev. The cleanup actions will be run in reverse
  22  * order in the final drm_dev_put() call for @dev.
  23  */
  24 #define drmm_add_action(dev, action, data) \
  25         __drmm_add_action(dev, action, data, #action)
  26
  27 int __must_check __drmm_add_action(struct drm_device *dev,
  28                                    drmres_release_t action,
  29                                    void *data, const char *name);
  30
  31 /**
  32  * drmm_add_action_or_reset - add a managed release action to a &drm_device
  33  * @dev: DRM device
  34  * @action: function which should be called when @dev is released
  35  * @data: opaque pointer, passed to @action
  36  *
  37  * Similar to drmm_add_action(), with the only difference that upon failure
  38  * @action is directly called for any cleanup work necessary on failures.
  39  */
  40 #define drmm_add_action_or_reset(dev, action, data) \
  41         __drmm_add_action_or_reset(dev, action, data, #action)
  42
  43 int __must_check __drmm_add_action_or_reset(struct drm_device *dev,
  44                                             drmres_release_t action,
  45                                             void *data, const char *name);
  46
  47 void *drmm_kmalloc(struct drm_device *dev, size_t size, gfp_t gfp) __malloc;
  48
  49 /**
  50  * drmm_kzalloc - &drm_device managed kzalloc()
  51  * @dev: DRM device
  52  * @size: size of the memory allocation
  53  * @gfp: GFP allocation flags
  54  *
  55  * This is a &drm_device managed version of kzalloc(). The allocated memory is
  56  * automatically freed on the final drm_dev_put(). Memory can also be freed
  57  * before the final drm_dev_put() by calling drmm_kfree().
  58  */
  59 static inline void *drmm_kzalloc(struct drm_device *dev, size_t size, gfp_t gfp)
  60 {
  61         return drmm_kmalloc(dev, size, gfp | __GFP_ZERO);
  62 }
  63
  64 /**
  65  * drmm_kmalloc_array - &drm_device managed kmalloc_array()
  66  * @dev: DRM device
  67  * @n: number of array elements to allocate
  68  * @size: size of array member
  69  * @flags: GFP allocation flags
  70  *
  71  * This is a &drm_device managed version of kmalloc_array(). The allocated
  72  * memory is automatically freed on the final drm_dev_put() and works exactly
  73  * like a memory allocation obtained by drmm_kmalloc().
  74  */
  75 static inline void *drmm_kmalloc_array(struct drm_device *dev,
  76                                        size_t n, size_t size, gfp_t flags)
  77 {
  78         size_t bytes;
  79
  80         if (unlikely(check_mul_overflow(n, size, &bytes)))
  81                 return NULL;
  82
  83         return drmm_kmalloc(dev, bytes, flags);
  84 }
  85
  86 /**
  87  * drmm_kcalloc - &drm_device managed kcalloc()
  88  * @dev: DRM device
  89  * @n: number of array elements to allocate
  90  * @size: size of array member
  91  * @flags: GFP allocation flags
  92  *
  93  * This is a &drm_device managed version of kcalloc(). The allocated memory is
  94  * automatically freed on the final drm_dev_put() and works exactly like a
  95  * memory allocation obtained by drmm_kmalloc().
  96  */
  97 static inline void *drmm_kcalloc(struct drm_device *dev,
  98                                  size_t n, size_t size, gfp_t flags)
  99 {
 100         return drmm_kmalloc_array(dev, n, size, flags | __GFP_ZERO);
 101 }
 102
 103 char *drmm_kstrdup(struct drm_device *dev, const char *s, gfp_t gfp);
 104
 105 void drmm_kfree(struct drm_device *dev, void *data);
 106
 107 #endif