[mirror_ubuntu-bionic-kernel.git] / drivers / gpu / drm / i915 / i915_utils.h

/*
 * Copyright © 2016 Intel Corporation
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 * IN THE SOFTWARE.
 *
 */

#ifndef __I915_UTILS_H
#define __I915_UTILS_H

#undef WARN_ON
/* Many gcc seem to no see through this and fall over :( */
#if 0
#define WARN_ON(x) ({ \
	bool __i915_warn_cond = (x); \
	if (__builtin_constant_p(__i915_warn_cond)) \
		BUILD_BUG_ON(__i915_warn_cond); \
	WARN(__i915_warn_cond, "WARN_ON(" #x ")"); })
#else
#define WARN_ON(x) WARN((x), "%s", "WARN_ON(" __stringify(x) ")")
#endif

#undef WARN_ON_ONCE
#define WARN_ON_ONCE(x) WARN_ONCE((x), "%s", "WARN_ON_ONCE(" __stringify(x) ")")

#define MISSING_CASE(x) WARN(1, "Missing switch case (%lu) in %s\n", \
			     (long)(x), __func__)

#if GCC_VERSION >= 70000
#define add_overflows(A, B) \
	__builtin_add_overflow_p((A), (B), (typeof((A) + (B)))0)
#else
#define add_overflows(A, B) ({ \
	typeof(A) a = (A); \
	typeof(B) b = (B); \
	a + b < a; \
})
#endif

#define range_overflows(start, size, max) ({ \
	typeof(start) start__ = (start); \
	typeof(size) size__ = (size); \
	typeof(max) max__ = (max); \
	(void)(&start__ == &size__); \
	(void)(&start__ == &max__); \
	start__ > max__ || size__ > max__ - start__; \
})

#define range_overflows_t(type, start, size, max) \
	range_overflows((type)(start), (type)(size), (type)(max))

/* Note we don't consider signbits :| */
#define overflows_type(x, T) \
	(sizeof(x) > sizeof(T) && (x) >> (sizeof(T) * BITS_PER_BYTE))

#define ptr_mask_bits(ptr, n) ({					\
	unsigned long __v = (unsigned long)(ptr);			\
	(typeof(ptr))(__v & -BIT(n));					\
})

#define ptr_unmask_bits(ptr, n) ((unsigned long)(ptr) & (BIT(n) - 1))

#define ptr_unpack_bits(ptr, bits, n) ({				\
	unsigned long __v = (unsigned long)(ptr);			\
	*(bits) = __v & (BIT(n) - 1);					\
	(typeof(ptr))(__v & -BIT(n));					\
})

#define ptr_pack_bits(ptr, bits, n)					\
	((typeof(ptr))((unsigned long)(ptr) | (bits)))

#define page_mask_bits(ptr) ptr_mask_bits(ptr, PAGE_SHIFT)
#define page_unmask_bits(ptr) ptr_unmask_bits(ptr, PAGE_SHIFT)
#define page_pack_bits(ptr, bits) ptr_pack_bits(ptr, bits, PAGE_SHIFT)
#define page_unpack_bits(ptr, bits) ptr_unpack_bits(ptr, bits, PAGE_SHIFT)

#define ptr_offset(ptr, member) offsetof(typeof(*(ptr)), member)

#define fetch_and_zero(ptr) ({						\
	typeof(*ptr) __T = *(ptr);					\
	*(ptr) = (typeof(*ptr))0;					\
	__T;								\
})

static inline u64 ptr_to_u64(const void *ptr)
{
	return (uintptr_t)ptr;
}

#define u64_to_ptr(T, x) ({						\
	typecheck(u64, x);						\
	(T *)(uintptr_t)(x);						\
})

#define __mask_next_bit(mask) ({					\
	int __idx = ffs(mask) - 1;					\
	mask &= ~BIT(__idx);						\
	__idx;								\
})

#include <linux/list.h>

static inline void __list_del_many(struct list_head *head,
				   struct list_head *first)
{
	first->prev = head;
	WRITE_ONCE(head->next, first);
}

/*
 * Wait until the work is finally complete, even if it tries to postpone
 * by requeueing itself. Note, that if the worker never cancels itself,
 * we will spin forever.
 */
static inline void drain_delayed_work(struct delayed_work *dw)
{
	do {
		while (flush_delayed_work(dw))
			;
	} while (delayed_work_pending(dw));
}

#endif /* !__I915_UTILS_H */
Commit	Line	Data
40b326ee CW	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
f0d66153 MW	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
1692cd60 CW	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
40b326ee CW	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
0ce81788	73	#define ptr_mask_bits(ptr, n) ({ \
b7163936	74	unsigned long __v = (unsigned long)(ptr); \
0ce81788	75	(typeof(ptr))(__v & -BIT(n)); \
b7163936 CW	76	})
b7163936 CW	77
0ce81788 CW	78	#define ptr_unmask_bits(ptr, n) ((unsigned long)(ptr) & (BIT(n) - 1))
	79
	80	#define ptr_unpack_bits(ptr, bits, n) ({ \
b7163936	81	unsigned long __v = (unsigned long)(ptr); \
0ce81788 CW	82	*(bits) = __v & (BIT(n) - 1); \
0ce81788 CW	83	(typeof(ptr))(__v & -BIT(n)); \
b7163936 CW	84	})
b7163936 CW	85
0ce81788	86	#define ptr_pack_bits(ptr, bits, n) \
b7163936 CW	87	((typeof(ptr))((unsigned long)(ptr) \| (bits)))
b7163936 CW	88
0ce81788 CW	89	#define page_mask_bits(ptr) ptr_mask_bits(ptr, PAGE_SHIFT)
	90	#define page_unmask_bits(ptr) ptr_unmask_bits(ptr, PAGE_SHIFT)
	91	#define page_pack_bits(ptr, bits) ptr_pack_bits(ptr, bits, PAGE_SHIFT)
	92	#define page_unpack_bits(ptr, bits) ptr_unpack_bits(ptr, bits, PAGE_SHIFT)
	93
16f11f46 MW	94	#define ptr_offset(ptr, member) offsetof(typeof(*(ptr)), member)
16f11f46 MW	95
b7163936 CW	96	#define fetch_and_zero(ptr) ({ \
	97	typeof(ptr) __T = (ptr); \
	98	(ptr) = (typeof(ptr))0; \
	99	__T; \
	100	})
	101
bb8920f5 MW	102	static inline u64 ptr_to_u64(const void *ptr)
	103	{
	104	return (uintptr_t)ptr;
	105	}
	106
4ff4b44c CW	107	#define u64_to_ptr(T, x) ({ \
	108	typecheck(u64, x); \
	109	(T *)(uintptr_t)(x); \
	110	})
	111
16586fcd MW	112	#define __mask_next_bit(mask) ({ \
	113	int __idx = ffs(mask) - 1; \
	114	mask &= ~BIT(__idx); \
	115	__idx; \
	116	})
	117
6c067579 CW	118	#include <linux/list.h>
	119
	120	static inline void __list_del_many(struct list_head *head,
	121	struct list_head *first)
	122	{
	123	first->prev = head;
	124	WRITE_ONCE(head->next, first);
	125	}
	126
7c26240e CW	127	/*
	128	* Wait until the work is finally complete, even if it tries to postpone
	129	* by requeueing itself. Note, that if the worker never cancels itself,
	130	* we will spin forever.
	131	*/
	132	static inline void drain_delayed_work(struct delayed_work *dw)
	133	{
	134	do {
	135	while (flush_delayed_work(dw))
	136	;
	137	} while (delayed_work_pending(dw));
	138	}
	139
40b326ee	140	#endif /* !__I915_UTILS_H */