LCOV - code coverage report
Current view: top level - drivers/gpu/drm/i915 - i915_utils.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 0 28 0.0 %
Date: 2022-03-28 16:04:14 Functions: 0 1 0.0 %
Branches: 0 204 0.0 %

           Branch data     Line data    Source code
       1                 :            : /*
       2                 :            :  * Copyright © 2016 Intel Corporation
       3                 :            :  *
       4                 :            :  * Permission is hereby granted, free of charge, to any person obtaining a
       5                 :            :  * copy of this software and associated documentation files (the "Software"),
       6                 :            :  * to deal in the Software without restriction, including without limitation
       7                 :            :  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
       8                 :            :  * and/or sell copies of the Software, and to permit persons to whom the
       9                 :            :  * Software is furnished to do so, subject to the following conditions:
      10                 :            :  *
      11                 :            :  * The above copyright notice and this permission notice (including the next
      12                 :            :  * paragraph) shall be included in all copies or substantial portions of the
      13                 :            :  * 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 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
      19                 :            :  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
      20                 :            :  * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
      21                 :            :  * IN THE SOFTWARE.
      22                 :            :  *
      23                 :            :  */
      24                 :            : 
      25                 :            : #ifndef __I915_UTILS_H
      26                 :            : #define __I915_UTILS_H
      27                 :            : 
      28                 :            : #include <linux/list.h>
      29                 :            : #include <linux/overflow.h>
      30                 :            : #include <linux/sched.h>
      31                 :            : #include <linux/types.h>
      32                 :            : #include <linux/workqueue.h>
      33                 :            : 
      34                 :            : struct drm_i915_private;
      35                 :            : struct timer_list;
      36                 :            : 
      37                 :            : #undef WARN_ON
      38                 :            : /* Many gcc seem to no see through this and fall over :( */
      39                 :            : #if 0
      40                 :            : #define WARN_ON(x) ({ \
      41                 :            :         bool __i915_warn_cond = (x); \
      42                 :            :         if (__builtin_constant_p(__i915_warn_cond)) \
      43                 :            :                 BUILD_BUG_ON(__i915_warn_cond); \
      44                 :            :         WARN(__i915_warn_cond, "WARN_ON(" #x ")"); })
      45                 :            : #else
      46                 :            : #define WARN_ON(x) WARN((x), "%s", "WARN_ON(" __stringify(x) ")")
      47                 :            : #endif
      48                 :            : 
      49                 :            : #undef WARN_ON_ONCE
      50                 :            : #define WARN_ON_ONCE(x) WARN_ONCE((x), "%s", "WARN_ON_ONCE(" __stringify(x) ")")
      51                 :            : 
      52                 :            : #define MISSING_CASE(x) WARN(1, "Missing case (%s == %ld)\n", \
      53                 :            :                              __stringify(x), (long)(x))
      54                 :            : 
      55                 :            : void __printf(3, 4)
      56                 :            : __i915_printk(struct drm_i915_private *dev_priv, const char *level,
      57                 :            :               const char *fmt, ...);
      58                 :            : 
      59                 :            : #define i915_report_error(dev_priv, fmt, ...)                              \
      60                 :            :         __i915_printk(dev_priv, KERN_ERR, fmt, ##__VA_ARGS__)
      61                 :            : 
      62                 :            : #if IS_ENABLED(CONFIG_DRM_I915_DEBUG)
      63                 :            : 
      64                 :            : int __i915_inject_probe_error(struct drm_i915_private *i915, int err,
      65                 :            :                               const char *func, int line);
      66                 :            : #define i915_inject_probe_error(_i915, _err) \
      67                 :            :         __i915_inject_probe_error((_i915), (_err), __func__, __LINE__)
      68                 :            : bool i915_error_injected(void);
      69                 :            : 
      70                 :            : #else
      71                 :            : 
      72                 :            : #define i915_inject_probe_error(i915, e) ({ BUILD_BUG_ON_INVALID(i915); 0; })
      73                 :            : #define i915_error_injected() false
      74                 :            : 
      75                 :            : #endif
      76                 :            : 
      77                 :            : #define i915_inject_probe_failure(i915) i915_inject_probe_error((i915), -ENODEV)
      78                 :            : 
      79                 :            : #define i915_probe_error(i915, fmt, ...)                                   \
      80                 :            :         __i915_printk(i915, i915_error_injected() ? KERN_DEBUG : KERN_ERR, \
      81                 :            :                       fmt, ##__VA_ARGS__)
      82                 :            : 
      83                 :            : #if defined(GCC_VERSION) && GCC_VERSION >= 70000
      84                 :            : #define add_overflows_t(T, A, B) \
      85                 :            :         __builtin_add_overflow_p((A), (B), (T)0)
      86                 :            : #else
      87                 :            : #define add_overflows_t(T, A, B) ({ \
      88                 :            :         typeof(A) a = (A); \
      89                 :            :         typeof(B) b = (B); \
      90                 :            :         (T)(a + b) < a; \
      91                 :            : })
      92                 :            : #endif
      93                 :            : 
      94                 :            : #define add_overflows(A, B) \
      95                 :            :         add_overflows_t(typeof((A) + (B)), (A), (B))
      96                 :            : 
      97                 :            : #define range_overflows(start, size, max) ({ \
      98                 :            :         typeof(start) start__ = (start); \
      99                 :            :         typeof(size) size__ = (size); \
     100                 :            :         typeof(max) max__ = (max); \
     101                 :            :         (void)(&start__ == &size__); \
     102                 :            :         (void)(&start__ == &max__); \
     103                 :            :         start__ > max__ || size__ > max__ - start__; \
     104                 :            : })
     105                 :            : 
     106                 :            : #define range_overflows_t(type, start, size, max) \
     107                 :            :         range_overflows((type)(start), (type)(size), (type)(max))
     108                 :            : 
     109                 :            : /* Note we don't consider signbits :| */
     110                 :            : #define overflows_type(x, T) \
     111                 :            :         (sizeof(x) > sizeof(T) && (x) >> BITS_PER_TYPE(T))
     112                 :            : 
     113                 :            : static inline bool
     114                 :            : __check_struct_size(size_t base, size_t arr, size_t count, size_t *size)
     115                 :            : {
     116                 :            :         size_t sz;
     117                 :            : 
     118                 :            :         if (check_mul_overflow(count, arr, &sz))
     119                 :            :                 return false;
     120                 :            : 
     121                 :            :         if (check_add_overflow(sz, base, &sz))
     122                 :            :                 return false;
     123                 :            : 
     124                 :            :         *size = sz;
     125                 :            :         return true;
     126                 :            : }
     127                 :            : 
     128                 :            : /**
     129                 :            :  * check_struct_size() - Calculate size of structure with trailing array.
     130                 :            :  * @p: Pointer to the structure.
     131                 :            :  * @member: Name of the array member.
     132                 :            :  * @n: Number of elements in the array.
     133                 :            :  * @sz: Total size of structure and array
     134                 :            :  *
     135                 :            :  * Calculates size of memory needed for structure @p followed by an
     136                 :            :  * array of @n @member elements, like struct_size() but reports
     137                 :            :  * whether it overflowed, and the resultant size in @sz
     138                 :            :  *
     139                 :            :  * Return: false if the calculation overflowed.
     140                 :            :  */
     141                 :            : #define check_struct_size(p, member, n, sz) \
     142                 :            :         likely(__check_struct_size(sizeof(*(p)), \
     143                 :            :                                    sizeof(*(p)->member) + __must_be_array((p)->member), \
     144                 :            :                                    n, sz))
     145                 :            : 
     146                 :            : #define ptr_mask_bits(ptr, n) ({                                        \
     147                 :            :         unsigned long __v = (unsigned long)(ptr);                       \
     148                 :            :         (typeof(ptr))(__v & -BIT(n));                                       \
     149                 :            : })
     150                 :            : 
     151                 :            : #define ptr_unmask_bits(ptr, n) ((unsigned long)(ptr) & (BIT(n) - 1))
     152                 :            : 
     153                 :            : #define ptr_unpack_bits(ptr, bits, n) ({                                \
     154                 :            :         unsigned long __v = (unsigned long)(ptr);                       \
     155                 :            :         *(bits) = __v & (BIT(n) - 1);                                       \
     156                 :            :         (typeof(ptr))(__v & -BIT(n));                                       \
     157                 :            : })
     158                 :            : 
     159                 :            : #define ptr_pack_bits(ptr, bits, n) ({                                  \
     160                 :            :         unsigned long __bits = (bits);                                  \
     161                 :            :         GEM_BUG_ON(__bits & -BIT(n));                                       \
     162                 :            :         ((typeof(ptr))((unsigned long)(ptr) | __bits));                 \
     163                 :            : })
     164                 :            : 
     165                 :            : #define ptr_dec(ptr) ({                                                 \
     166                 :            :         unsigned long __v = (unsigned long)(ptr);                       \
     167                 :            :         (typeof(ptr))(__v - 1);                                         \
     168                 :            : })
     169                 :            : 
     170                 :            : #define ptr_inc(ptr) ({                                                 \
     171                 :            :         unsigned long __v = (unsigned long)(ptr);                       \
     172                 :            :         (typeof(ptr))(__v + 1);                                         \
     173                 :            : })
     174                 :            : 
     175                 :            : #define page_mask_bits(ptr) ptr_mask_bits(ptr, PAGE_SHIFT)
     176                 :            : #define page_unmask_bits(ptr) ptr_unmask_bits(ptr, PAGE_SHIFT)
     177                 :            : #define page_pack_bits(ptr, bits) ptr_pack_bits(ptr, bits, PAGE_SHIFT)
     178                 :            : #define page_unpack_bits(ptr, bits) ptr_unpack_bits(ptr, bits, PAGE_SHIFT)
     179                 :            : 
     180                 :            : #define struct_member(T, member) (((T *)0)->member)
     181                 :            : 
     182                 :            : #define ptr_offset(ptr, member) offsetof(typeof(*(ptr)), member)
     183                 :            : 
     184                 :            : #define fetch_and_zero(ptr) ({                                          \
     185                 :            :         typeof(*ptr) __T = *(ptr);                                      \
     186                 :            :         *(ptr) = (typeof(*ptr))0;                                       \
     187                 :            :         __T;                                                            \
     188                 :            : })
     189                 :            : 
     190                 :            : /*
     191                 :            :  * container_of_user: Extract the superclass from a pointer to a member.
     192                 :            :  *
     193                 :            :  * Exactly like container_of() with the exception that it plays nicely
     194                 :            :  * with sparse for __user @ptr.
     195                 :            :  */
     196                 :            : #define container_of_user(ptr, type, member) ({                         \
     197                 :            :         void __user *__mptr = (void __user *)(ptr);                     \
     198                 :            :         BUILD_BUG_ON_MSG(!__same_type(*(ptr), struct_member(type, member)) && \
     199                 :            :                          !__same_type(*(ptr), void),                    \
     200                 :            :                          "pointer type mismatch in container_of()");  \
     201                 :            :         ((type __user *)(__mptr - offsetof(type, member))); })
     202                 :            : 
     203                 :            : /*
     204                 :            :  * check_user_mbz: Check that a user value exists and is zero
     205                 :            :  *
     206                 :            :  * Frequently in our uABI we reserve space for future extensions, and
     207                 :            :  * two ensure that userspace is prepared we enforce that space must
     208                 :            :  * be zero. (Then any future extension can safely assume a default value
     209                 :            :  * of 0.)
     210                 :            :  *
     211                 :            :  * check_user_mbz() combines checking that the user pointer is accessible
     212                 :            :  * and that the contained value is zero.
     213                 :            :  *
     214                 :            :  * Returns: -EFAULT if not accessible, -EINVAL if !zero, or 0 on success.
     215                 :            :  */
     216                 :            : #define check_user_mbz(U) ({                                            \
     217                 :            :         typeof(*(U)) mbz__;                                             \
     218                 :            :         get_user(mbz__, (U)) ? -EFAULT : mbz__ ? -EINVAL : 0;           \
     219                 :            : })
     220                 :            : 
     221                 :            : static inline u64 ptr_to_u64(const void *ptr)
     222                 :            : {
     223                 :            :         return (uintptr_t)ptr;
     224                 :            : }
     225                 :            : 
     226                 :            : #define u64_to_ptr(T, x) ({                                             \
     227                 :            :         typecheck(u64, x);                                              \
     228                 :            :         (T *)(uintptr_t)(x);                                            \
     229                 :            : })
     230                 :            : 
     231                 :            : #define __mask_next_bit(mask) ({                                        \
     232                 :            :         int __idx = ffs(mask) - 1;                                      \
     233                 :            :         mask &= ~BIT(__idx);                                                \
     234                 :            :         __idx;                                                          \
     235                 :            : })
     236                 :            : 
     237                 :            : static inline bool is_power_of_2_u64(u64 n)
     238                 :            : {
     239                 :            :         return (n != 0 && ((n & (n - 1)) == 0));
     240                 :            : }
     241                 :            : 
     242                 :          0 : static inline void __list_del_many(struct list_head *head,
     243                 :            :                                    struct list_head *first)
     244                 :            : {
     245                 :          0 :         first->prev = head;
     246         [ #  # ]:          0 :         WRITE_ONCE(head->next, first);
     247                 :            : }
     248                 :            : 
     249                 :            : /*
     250                 :            :  * Wait until the work is finally complete, even if it tries to postpone
     251                 :            :  * by requeueing itself. Note, that if the worker never cancels itself,
     252                 :            :  * we will spin forever.
     253                 :            :  */
     254                 :            : static inline void drain_delayed_work(struct delayed_work *dw)
     255                 :            : {
     256                 :            :         do {
     257                 :            :                 while (flush_delayed_work(dw))
     258                 :            :                         ;
     259                 :            :         } while (delayed_work_pending(dw));
     260                 :            : }
     261                 :            : 
     262                 :          0 : static inline unsigned long msecs_to_jiffies_timeout(const unsigned int m)
     263                 :            : {
     264         [ #  # ]:          0 :         unsigned long j = msecs_to_jiffies(m);
     265                 :            : 
     266         [ #  # ]:          0 :         return min_t(unsigned long, MAX_JIFFY_OFFSET, j + 1);
     267                 :            : }
     268                 :            : 
     269                 :            : /*
     270                 :            :  * If you need to wait X milliseconds between events A and B, but event B
     271                 :            :  * doesn't happen exactly after event A, you record the timestamp (jiffies) of
     272                 :            :  * when event A happened, then just before event B you call this function and
     273                 :            :  * pass the timestamp as the first argument, and X as the second argument.
     274                 :            :  */
     275                 :            : static inline void
     276                 :          0 : wait_remaining_ms_from_jiffies(unsigned long timestamp_jiffies, int to_wait_ms)
     277                 :            : {
     278                 :          0 :         unsigned long target_jiffies, tmp_jiffies, remaining_jiffies;
     279                 :            : 
     280                 :            :         /*
     281                 :            :          * Don't re-read the value of "jiffies" every time since it may change
     282                 :            :          * behind our back and break the math.
     283                 :            :          */
     284                 :          0 :         tmp_jiffies = jiffies;
     285                 :          0 :         target_jiffies = timestamp_jiffies +
     286         [ #  # ]:          0 :                          msecs_to_jiffies_timeout(to_wait_ms);
     287                 :            : 
     288         [ #  # ]:          0 :         if (time_after(target_jiffies, tmp_jiffies)) {
     289                 :          0 :                 remaining_jiffies = target_jiffies - tmp_jiffies;
     290         [ #  # ]:          0 :                 while (remaining_jiffies)
     291                 :          0 :                         remaining_jiffies =
     292                 :          0 :                             schedule_timeout_uninterruptible(remaining_jiffies);
     293                 :            :         }
     294                 :          0 : }
     295                 :            : 
     296                 :            : /**
     297                 :            :  * __wait_for - magic wait macro
     298                 :            :  *
     299                 :            :  * Macro to help avoid open coding check/wait/timeout patterns. Note that it's
     300                 :            :  * important that we check the condition again after having timed out, since the
     301                 :            :  * timeout could be due to preemption or similar and we've never had a chance to
     302                 :            :  * check the condition before the timeout.
     303                 :            :  */
     304                 :            : #define __wait_for(OP, COND, US, Wmin, Wmax) ({ \
     305                 :            :         const ktime_t end__ = ktime_add_ns(ktime_get_raw(), 1000ll * (US)); \
     306                 :            :         long wait__ = (Wmin); /* recommended min for usleep is 10 us */ \
     307                 :            :         int ret__;                                                      \
     308                 :            :         might_sleep();                                                  \
     309                 :            :         for (;;) {                                                      \
     310                 :            :                 const bool expired__ = ktime_after(ktime_get_raw(), end__); \
     311                 :            :                 OP;                                                     \
     312                 :            :                 /* Guarantee COND check prior to timeout */             \
     313                 :            :                 barrier();                                              \
     314                 :            :                 if (COND) {                                             \
     315                 :            :                         ret__ = 0;                                      \
     316                 :            :                         break;                                          \
     317                 :            :                 }                                                       \
     318                 :            :                 if (expired__) {                                        \
     319                 :            :                         ret__ = -ETIMEDOUT;                             \
     320                 :            :                         break;                                          \
     321                 :            :                 }                                                       \
     322                 :            :                 usleep_range(wait__, wait__ * 2);                       \
     323                 :            :                 if (wait__ < (Wmax))                                 \
     324                 :            :                         wait__ <<= 1;                                     \
     325                 :            :         }                                                               \
     326                 :            :         ret__;                                                          \
     327                 :            : })
     328                 :            : 
     329                 :            : #define _wait_for(COND, US, Wmin, Wmax) __wait_for(, (COND), (US), (Wmin), \
     330                 :            :                                                    (Wmax))
     331                 :            : #define wait_for(COND, MS)              _wait_for((COND), (MS) * 1000, 10, 1000)
     332                 :            : 
     333                 :            : /* If CONFIG_PREEMPT_COUNT is disabled, in_atomic() always reports false. */
     334                 :            : #if defined(CONFIG_DRM_I915_DEBUG) && defined(CONFIG_PREEMPT_COUNT)
     335                 :            : # define _WAIT_FOR_ATOMIC_CHECK(ATOMIC) WARN_ON_ONCE((ATOMIC) && !in_atomic())
     336                 :            : #else
     337                 :            : # define _WAIT_FOR_ATOMIC_CHECK(ATOMIC) do { } while (0)
     338                 :            : #endif
     339                 :            : 
     340                 :            : #define _wait_for_atomic(COND, US, ATOMIC) \
     341                 :            : ({ \
     342                 :            :         int cpu, ret, timeout = (US) * 1000; \
     343                 :            :         u64 base; \
     344                 :            :         _WAIT_FOR_ATOMIC_CHECK(ATOMIC); \
     345                 :            :         if (!(ATOMIC)) { \
     346                 :            :                 preempt_disable(); \
     347                 :            :                 cpu = smp_processor_id(); \
     348                 :            :         } \
     349                 :            :         base = local_clock(); \
     350                 :            :         for (;;) { \
     351                 :            :                 u64 now = local_clock(); \
     352                 :            :                 if (!(ATOMIC)) \
     353                 :            :                         preempt_enable(); \
     354                 :            :                 /* Guarantee COND check prior to timeout */ \
     355                 :            :                 barrier(); \
     356                 :            :                 if (COND) { \
     357                 :            :                         ret = 0; \
     358                 :            :                         break; \
     359                 :            :                 } \
     360                 :            :                 if (now - base >= timeout) { \
     361                 :            :                         ret = -ETIMEDOUT; \
     362                 :            :                         break; \
     363                 :            :                 } \
     364                 :            :                 cpu_relax(); \
     365                 :            :                 if (!(ATOMIC)) { \
     366                 :            :                         preempt_disable(); \
     367                 :            :                         if (unlikely(cpu != smp_processor_id())) { \
     368                 :            :                                 timeout -= now - base; \
     369                 :            :                                 cpu = smp_processor_id(); \
     370                 :            :                                 base = local_clock(); \
     371                 :            :                         } \
     372                 :            :                 } \
     373                 :            :         } \
     374                 :            :         ret; \
     375                 :            : })
     376                 :            : 
     377                 :            : #define wait_for_us(COND, US) \
     378                 :            : ({ \
     379                 :            :         int ret__; \
     380                 :            :         BUILD_BUG_ON(!__builtin_constant_p(US)); \
     381                 :            :         if ((US) > 10) \
     382                 :            :                 ret__ = _wait_for((COND), (US), 10, 10); \
     383                 :            :         else \
     384                 :            :                 ret__ = _wait_for_atomic((COND), (US), 0); \
     385                 :            :         ret__; \
     386                 :            : })
     387                 :            : 
     388                 :            : #define wait_for_atomic_us(COND, US) \
     389                 :            : ({ \
     390                 :            :         BUILD_BUG_ON(!__builtin_constant_p(US)); \
     391                 :            :         BUILD_BUG_ON((US) > 50000); \
     392                 :            :         _wait_for_atomic((COND), (US), 1); \
     393                 :            : })
     394                 :            : 
     395                 :            : #define wait_for_atomic(COND, MS) wait_for_atomic_us((COND), (MS) * 1000)
     396                 :            : 
     397                 :            : #define KHz(x) (1000 * (x))
     398                 :            : #define MHz(x) KHz(1000 * (x))
     399                 :            : 
     400                 :            : #define KBps(x) (1000 * (x))
     401                 :            : #define MBps(x) KBps(1000 * (x))
     402                 :            : #define GBps(x) ((u64)1000 * MBps((x)))
     403                 :            : 
     404                 :          0 : static inline const char *yesno(bool v)
     405                 :            : {
     406   [ #  #  #  #  :          0 :         return v ? "yes" : "no";
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     407                 :            : }
     408                 :            : 
     409                 :          0 : static inline const char *onoff(bool v)
     410                 :            : {
     411   [ #  #  #  #  :          0 :         return v ? "on" : "off";
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                #  #  # ]
     412                 :            : }
     413                 :            : 
     414                 :          0 : static inline const char *enableddisabled(bool v)
     415                 :            : {
     416   [ #  #  #  #  :          0 :         return v ? "enabled" : "disabled";
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     417                 :            : }
     418                 :            : 
     419                 :          0 : static inline void add_taint_for_CI(unsigned int taint)
     420                 :            : {
     421                 :            :         /*
     422                 :            :          * The system is "ok", just about surviving for the user, but
     423                 :            :          * CI results are now unreliable as the HW is very suspect.
     424                 :            :          * CI checks the taint state after every test and will reboot
     425                 :            :          * the machine if the kernel is tainted.
     426                 :            :          */
     427                 :          0 :         add_taint(taint, LOCKDEP_STILL_OK);
     428                 :          0 : }
     429                 :            : 
     430                 :            : void cancel_timer(struct timer_list *t);
     431                 :            : void set_timer_ms(struct timer_list *t, unsigned long timeout);
     432                 :            : 
     433                 :          0 : static inline bool timer_expired(const struct timer_list *t)
     434                 :            : {
     435   [ #  #  #  #  :          0 :         return READ_ONCE(t->expires) && !timer_pending(t);
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
     436                 :            : }
     437                 :            : 
     438                 :            : /*
     439                 :            :  * This is a lookalike for IS_ENABLED() that takes a kconfig value,
     440                 :            :  * e.g. CONFIG_DRM_I915_SPIN_REQUEST, and evaluates whether it is non-zero
     441                 :            :  * i.e. whether the configuration is active. Wrapping up the config inside
     442                 :            :  * a boolean context prevents clang and smatch from complaining about potential
     443                 :            :  * issues in confusing logical-&& with bitwise-& for constants.
     444                 :            :  *
     445                 :            :  * Sadly IS_ENABLED() itself does not work with kconfig values.
     446                 :            :  *
     447                 :            :  * Returns 0 if @config is 0, 1 if set to any value.
     448                 :            :  */
     449                 :            : #define IS_ACTIVE(config) ((config) != 0)
     450                 :            : 
     451                 :            : #endif /* !__I915_UTILS_H */

Generated by: LCOV version 1.14