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 #undef WARN_ON
29 /* Many gcc seem to no see through this and fall over :( */
30 #if 0
31 #define WARN_ON(x) ({ \
32 bool __i915_warn_cond = (x); \
33 if (__builtin_constant_p(__i915_warn_cond)) \
34 BUILD_BUG_ON(__i915_warn_cond); \
35 WARN(__i915_warn_cond, "WARN_ON(" #x ")"); })
36 #else
37 #define WARN_ON(x) WARN((x), "%s", "WARN_ON(" __stringify(x) ")")
38 #endif
39
40 #undef WARN_ON_ONCE
41 #define WARN_ON_ONCE(x) WARN_ONCE((x), "%s", "WARN_ON_ONCE(" __stringify(x) ")")
42
43 #define MISSING_CASE(x) WARN(1, "Missing case (%s == %ld)\n", \
44 __stringify(x), (long)(x))
45
46 #if defined(GCC_VERSION) && GCC_VERSION >= 70000
47 #define add_overflows(A, B) \
48 __builtin_add_overflow_p((A), (B), (typeof((A) + (B)))0)
49 #else
50 #define add_overflows(A, B) ({ \
51 typeof(A) a = (A); \
52 typeof(B) b = (B); \
53 a + b < a; \
54 })
55 #endif
56
57 #define range_overflows(start, size, max) ({ \
58 typeof(start) start__ = (start); \
59 typeof(size) size__ = (size); \
60 typeof(max) max__ = (max); \
61 (void)(&start__ == &size__); \
62 (void)(&start__ == &max__); \
63 start__ > max__ || size__ > max__ - start__; \
64 })
65
66 #define range_overflows_t(type, start, size, max) \
67 range_overflows((type)(start), (type)(size), (type)(max))
68
69 /* Note we don't consider signbits :| */
70 #define overflows_type(x, T) \
71 (sizeof(x) > sizeof(T) && (x) >> (sizeof(T) * BITS_PER_BYTE))
72
73 #define ptr_mask_bits(ptr, n) ({ \
74 unsigned long __v = (unsigned long)(ptr); \
75 (typeof(ptr))(__v & -BIT(n)); \
76 })
77
78 #define ptr_unmask_bits(ptr, n) ((unsigned long)(ptr) & (BIT(n) - 1))
79
80 #define ptr_unpack_bits(ptr, bits, n) ({ \
81 unsigned long __v = (unsigned long)(ptr); \
82 *(bits) = __v & (BIT(n) - 1); \
83 (typeof(ptr))(__v & -BIT(n)); \
84 })
85
86 #define ptr_pack_bits(ptr, bits, n) ({ \
87 unsigned long __bits = (bits); \
88 GEM_BUG_ON(__bits & -BIT(n)); \
89 ((typeof(ptr))((unsigned long)(ptr) | __bits)); \
90 })
91
92 #define page_mask_bits(ptr) ptr_mask_bits(ptr, PAGE_SHIFT)
93 #define page_unmask_bits(ptr) ptr_unmask_bits(ptr, PAGE_SHIFT)
94 #define page_pack_bits(ptr, bits) ptr_pack_bits(ptr, bits, PAGE_SHIFT)
95 #define page_unpack_bits(ptr, bits) ptr_unpack_bits(ptr, bits, PAGE_SHIFT)
96
97 #define ptr_offset(ptr, member) offsetof(typeof(*(ptr)), member)
98
99 #define fetch_and_zero(ptr) ({ \
100 typeof(*ptr) __T = *(ptr); \
101 *(ptr) = (typeof(*ptr))0; \
102 __T; \
103 })
104
ptr_to_u64(const void * ptr)105 static inline u64 ptr_to_u64(const void *ptr)
106 {
107 return (uintptr_t)ptr;
108 }
109
110 #define u64_to_ptr(T, x) ({ \
111 typecheck(u64, x); \
112 (T *)(uintptr_t)(x); \
113 })
114
115 #define __mask_next_bit(mask) ({ \
116 int __idx = ffs(mask) - 1; \
117 mask &= ~BIT(__idx); \
118 __idx; \
119 })
120
121 #include <linux/list.h>
122
list_is_first(const struct list_head * list,const struct list_head * head)123 static inline int list_is_first(const struct list_head *list,
124 const struct list_head *head)
125 {
126 return head->next == list;
127 }
128
__list_del_many(struct list_head * head,struct list_head * first)129 static inline void __list_del_many(struct list_head *head,
130 struct list_head *first)
131 {
132 first->prev = head;
133 WRITE_ONCE(head->next, first);
134 }
135
136 /*
137 * Wait until the work is finally complete, even if it tries to postpone
138 * by requeueing itself. Note, that if the worker never cancels itself,
139 * we will spin forever.
140 */
drain_delayed_work(struct delayed_work * dw)141 static inline void drain_delayed_work(struct delayed_work *dw)
142 {
143 do {
144 while (flush_delayed_work(dw))
145 ;
146 } while (delayed_work_pending(dw));
147 }
148
yesno(bool v)149 static inline const char *yesno(bool v)
150 {
151 return v ? "yes" : "no";
152 }
153
onoff(bool v)154 static inline const char *onoff(bool v)
155 {
156 return v ? "on" : "off";
157 }
158
enableddisabled(bool v)159 static inline const char *enableddisabled(bool v)
160 {
161 return v ? "enabled" : "disabled";
162 }
163
164 #endif /* !__I915_UTILS_H */
165
