Line data    Source code

       1             : /*
       2             :  * Copyright (C) 2014 Red Hat
       3             :  * Author: Rob Clark <robdclark@gmail.com>
       4             :  *
       5             :  * Permission is hereby granted, free of charge, to any person obtaining a
       6             :  * copy of this software and associated documentation files (the "Software"),
       7             :  * to deal in the Software without restriction, including without limitation
       8             :  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
       9             :  * and/or sell copies of the Software, and to permit persons to whom the
      10             :  * Software is furnished to do so, subject to the following conditions:
      11             :  *
      12             :  * The above copyright notice and this permission notice shall be included in
      13             :  * all copies or substantial portions of the Software.
      14             :  *
      15             :  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
      16             :  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
      17             :  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
      18             :  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
      19             :  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
      20             :  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
      21             :  * OTHER DEALINGS IN THE SOFTWARE.
      22             :  */
      23             : 
      24             : #ifndef DRM_MODESET_LOCK_H_
      25             : #define DRM_MODESET_LOCK_H_
      26             : 
      27             : #include <dev/pci/drm/linux_ww_mutex.h>
      28             : 
      29             : struct drm_modeset_lock;
      30             : 
      31             : /**
      32             :  * struct drm_modeset_acquire_ctx - locking context (see ww_acquire_ctx)
      33             :  * @ww_ctx: base acquire ctx
      34             :  * @contended: used internally for -EDEADLK handling
      35             :  * @locked: list of held locks
      36             :  * @trylock_only: trylock mode used in atomic contexts/panic notifiers
      37             :  *
      38             :  * Each thread competing for a set of locks must use one acquire
      39             :  * ctx.  And if any lock fxn returns -EDEADLK, it must backoff and
      40             :  * retry.
      41             :  */
      42             : struct drm_modeset_acquire_ctx {
      43             : 
      44             :         struct ww_acquire_ctx ww_ctx;
      45             : 
      46             :         /*
      47             :          * Contended lock: if a lock is contended you should only call
      48             :          * drm_modeset_backoff() which drops locks and slow-locks the
      49             :          * contended lock.
      50             :          */
      51             :         struct drm_modeset_lock *contended;
      52             : 
      53             :         /*
      54             :          * list of held locks (drm_modeset_lock)
      55             :          */
      56             :         struct list_head locked;
      57             : 
      58             :         /*
      59             :          * Trylock mode, use only for panic handlers!
      60             :          */
      61             :         bool trylock_only;
      62             : };
      63             : 
      64             : /**
      65             :  * struct drm_modeset_lock - used for locking modeset resources.
      66             :  * @mutex: resource locking
      67             :  * @head: used to hold it's place on state->locked list when
      68             :  *    part of an atomic update
      69             :  *
      70             :  * Used for locking CRTCs and other modeset resources.
      71             :  */
      72             : struct drm_modeset_lock {
      73             :         /*
      74             :          * modeset lock
      75             :          */
      76             :         struct ww_mutex mutex;
      77             : 
      78             :         /*
      79             :          * Resources that are locked as part of an atomic update are added
      80             :          * to a list (so we know what to unlock at the end).
      81             :          */
      82             :         struct list_head head;
      83             : };
      84             : 
      85             : extern struct ww_class crtc_ww_class;
      86             : 
      87             : void drm_modeset_acquire_init(struct drm_modeset_acquire_ctx *ctx,
      88             :                 uint32_t flags);
      89             : void drm_modeset_acquire_fini(struct drm_modeset_acquire_ctx *ctx);
      90             : void drm_modeset_drop_locks(struct drm_modeset_acquire_ctx *ctx);
      91             : void drm_modeset_backoff(struct drm_modeset_acquire_ctx *ctx);
      92             : int drm_modeset_backoff_interruptible(struct drm_modeset_acquire_ctx *ctx);
      93             : 
      94             : /**
      95             :  * drm_modeset_lock_init - initialize lock
      96             :  * @lock: lock to init
      97             :  */
      98           0 : static inline void drm_modeset_lock_init(struct drm_modeset_lock *lock)
      99             : {
     100           0 :         ww_mutex_init(&lock->mutex, &crtc_ww_class);
     101           0 :         INIT_LIST_HEAD(&lock->head);
     102           0 : }
     103             : 
     104             : /**
     105             :  * drm_modeset_lock_fini - cleanup lock
     106             :  * @lock: lock to cleanup
     107             :  */
     108           0 : static inline void drm_modeset_lock_fini(struct drm_modeset_lock *lock)
     109             : {
     110           0 :         WARN_ON(!list_empty(&lock->head));
     111           0 : }
     112             : 
     113             : /**
     114             :  * drm_modeset_is_locked - equivalent to mutex_is_locked()
     115             :  * @lock: lock to check
     116             :  */
     117           0 : static inline bool drm_modeset_is_locked(struct drm_modeset_lock *lock)
     118             : {
     119           0 :         return ww_mutex_is_locked(&lock->mutex);
     120             : }
     121             : 
     122             : int drm_modeset_lock(struct drm_modeset_lock *lock,
     123             :                 struct drm_modeset_acquire_ctx *ctx);
     124             : int drm_modeset_lock_interruptible(struct drm_modeset_lock *lock,
     125             :                 struct drm_modeset_acquire_ctx *ctx);
     126             : void drm_modeset_unlock(struct drm_modeset_lock *lock);
     127             : 
     128             : struct drm_device;
     129             : struct drm_crtc;
     130             : struct drm_plane;
     131             : 
     132             : void drm_modeset_lock_all(struct drm_device *dev);
     133             : void drm_modeset_unlock_all(struct drm_device *dev);
     134             : void drm_modeset_lock_crtc(struct drm_crtc *crtc,
     135             :                            struct drm_plane *plane);
     136             : void drm_modeset_unlock_crtc(struct drm_crtc *crtc);
     137             : void drm_warn_on_modeset_not_all_locked(struct drm_device *dev);
     138             : struct drm_modeset_acquire_ctx *
     139             : drm_modeset_legacy_acquire_ctx(struct drm_crtc *crtc);
     140             : 
     141             : int drm_modeset_lock_all_crtcs(struct drm_device *dev,
     142             :                 struct drm_modeset_acquire_ctx *ctx);
     143             : 
     144             : #endif /* DRM_MODESET_LOCK_H_ */