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 switch case (%lu) in %s\n", \
 44			     (long)(x), __func__)
 45
 46#if 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
105static 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
123static inline void __list_del_many(struct list_head *head,
124				   struct list_head *first)
125{
126	first->prev = head;
127	WRITE_ONCE(head->next, first);
128}
129
130/*
131 * Wait until the work is finally complete, even if it tries to postpone
132 * by requeueing itself. Note, that if the worker never cancels itself,
133 * we will spin forever.
134 */
135static inline void drain_delayed_work(struct delayed_work *dw)
136{
137	do {
138		while (flush_delayed_work(dw))
139			;
140	} while (delayed_work_pending(dw));
141}
142
143static inline const char *yesno(bool v)
144{
145	return v ? "yes" : "no";
146}
147
148static inline const char *onoff(bool v)
149{
150	return v ? "on" : "off";
151}
152
153static inline const char *enableddisabled(bool v)
154{
155	return v ? "enabled" : "disabled";
156}
157
158#endif /* !__I915_UTILS_H */