Cleanup the bitmap_xxx() functions in the LinuxKPI:

- Move all bitmap related functions from bitops.h to bitmap.h, similar
  to what Linux does.

- Apply some minor code cleanup and simplifications to optimize the
  generated code when using static inline functions.

- Implement the following list of bitmap functions which are needed by
  drm-next and ibcore:
  - bitmap_find_next_zero_area_off()
  - bitmap_find_next_zero_area()
  - bitmap_or()
  - bitmap_and()
  - bitmap_xor()

- Add missing include directives to the qlnxe driver
  (davidcs@ has been notified)

MFC after:		1 week
Sponsored by:		Mellanox Technologies

sys/compat/linuxkpi/common/include/linux/bitmap.h

@@ -0,0 +1,279 @@
+/*
+ * Copyright (c) 2013-2017 Mellanox Technologies, Ltd.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _LINUX_BITMAP_H_
+#define	_LINUX_BITMAP_H_
+
+#include <linux/bitops.h>
+
+static inline void
+bitmap_zero(unsigned long *addr, const unsigned int size)
+{
+	memset(addr, 0, BITS_TO_LONGS(size) * sizeof(long));
+}
+
+static inline void
+bitmap_fill(unsigned long *addr, const unsigned int size)
+{
+	const unsigned int tail = size & (BITS_PER_LONG - 1);
+
+	memset(addr, 0xff, BIT_WORD(size) * sizeof(long));
+
+	if (tail)
+		addr[BIT_WORD(size)] = BITMAP_LAST_WORD_MASK(tail);
+}
+
+static inline int
+bitmap_full(unsigned long *addr, const unsigned int size)
+{
+	const unsigned int end = BIT_WORD(size);
+	const unsigned int tail = size & (BITS_PER_LONG - 1);
+	unsigned int i;
+
+	for (i = 0; i != end; i++) {
+		if (addr[i] != ~0UL)
+			return (0);
+	}
+
+	if (tail) {
+		const unsigned long mask = BITMAP_LAST_WORD_MASK(tail);
+
+		if ((addr[end] & mask) != mask)
+			return (0);
+	}
+	return (1);
+}
+
+static inline int
+bitmap_empty(unsigned long *addr, const unsigned int size)
+{
+	const unsigned int end = BIT_WORD(size);
+	const unsigned int tail = size & (BITS_PER_LONG - 1);
+	unsigned int i;
+
+	for (i = 0; i != end; i++) {
+		if (addr[i] != 0)
+			return (0);
+	}
+
+	if (tail) {
+		const unsigned long mask = BITMAP_LAST_WORD_MASK(tail);
+
+		if ((addr[end] & mask) != 0)
+			return (0);
+	}
+	return (1);
+}
+
+static inline void
+bitmap_set(unsigned long *map, unsigned int start, int nr)
+{
+	const unsigned int size = start + nr;
+	int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
+	unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
+
+	map += BIT_WORD(start);
+
+	while (nr - bits_to_set >= 0) {
+		*map |= mask_to_set;
+		nr -= bits_to_set;
+		bits_to_set = BITS_PER_LONG;
+		mask_to_set = ~0UL;
+		map++;
+	}
+
+	if (nr) {
+		mask_to_set &= BITMAP_LAST_WORD_MASK(size);
+		*map |= mask_to_set;
+	}
+}
+
+static inline void
+bitmap_clear(unsigned long *map, unsigned int start, int nr)
+{
+	const unsigned int size = start + nr;
+	int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
+	unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
+
+	map += BIT_WORD(start);
+
+	while (nr - bits_to_clear >= 0) {
+		*map &= ~mask_to_clear;
+		nr -= bits_to_clear;
+		bits_to_clear = BITS_PER_LONG;
+		mask_to_clear = ~0UL;
+		map++;
+	}
+
+	if (nr) {
+		mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
+		*map &= ~mask_to_clear;
+	}
+}
+
+static inline unsigned int
+bitmap_find_next_zero_area_off(const unsigned long *map,
+    const unsigned int size, unsigned int start,
+    unsigned int nr, unsigned int align_mask,
+    unsigned int align_offset)
+{
+	unsigned int index;
+	unsigned int end;
+	unsigned int i;
+
+retry:
+	index = find_next_zero_bit(map, size, start);
+
+	index = (((index + align_offset) + align_mask) & ~align_mask) - align_offset;
+
+	end = index + nr;
+	if (end > size)
+		return (end);
+
+	i = find_next_bit(map, end, index);
+	if (i < end) {
+		start = i + 1;
+		goto retry;
+	}
+	return (index);
+}
+
+static inline unsigned int
+bitmap_find_next_zero_area(const unsigned long *map,
+    const unsigned int size, unsigned int start,
+    unsigned int nr, unsigned int align_mask)
+{
+	return (bitmap_find_next_zero_area_off(map, size,
+	    start, nr, align_mask, 0));
+}
+
+static inline int
+bitmap_find_free_region(unsigned long *bitmap, int bits, int order)
+{
+	int pos;
+	int end;
+
+	for (pos = 0; (end = pos + (1 << order)) <= bits; pos = end) {
+		if (!linux_reg_op(bitmap, pos, order, REG_OP_ISFREE))
+			continue;
+		linux_reg_op(bitmap, pos, order, REG_OP_ALLOC);
+		return (pos);
+	}
+	return (-ENOMEM);
+}
+
+static inline int
+bitmap_allocate_region(unsigned long *bitmap, int pos, int order)
+{
+	if (!linux_reg_op(bitmap, pos, order, REG_OP_ISFREE))
+		return (-EBUSY);
+	linux_reg_op(bitmap, pos, order, REG_OP_ALLOC);
+	return (0);
+}
+
+static inline void
+bitmap_release_region(unsigned long *bitmap, int pos, int order)
+{
+	linux_reg_op(bitmap, pos, order, REG_OP_RELEASE);
+}
+
+static inline unsigned int
+bitmap_weight(unsigned long *addr, const unsigned int size)
+{
+	const unsigned int end = BIT_WORD(size);
+	const unsigned int tail = size & (BITS_PER_LONG - 1);
+	unsigned int retval = 0;
+	unsigned int i;
+
+	for (i = 0; i != end; i++)
+		retval += hweight_long(addr[i]);
+
+	if (tail) {
+		const unsigned long mask = BITMAP_LAST_WORD_MASK(tail);
+
+		retval += hweight_long(addr[end] & mask);
+	}
+	return (retval);
+}
+
+static inline int
+bitmap_equal(const unsigned long *pa,
+    const unsigned long *pb, unsigned size)
+{
+	const unsigned int end = BIT_WORD(size);
+	const unsigned int tail = size & (BITS_PER_LONG - 1);
+	unsigned int i;
+
+	for (i = 0; i != end; i++) {
+		if (pa[i] != pb[i])
+			return (0);
+	}
+
+	if (tail) {
+		const unsigned long mask = BITMAP_LAST_WORD_MASK(tail);
+
+		if ((pa[end] ^ pb[end]) & mask)
+			return (0);
+	}
+	return (1);
+}
+
+static inline void
+bitmap_or(unsigned long *dst, const unsigned long *src1,
+    const unsigned long *src2, const unsigned int size)
+{
+	const unsigned int end = BITS_TO_LONGS(size);
+	unsigned int i;
+
+	for (i = 0; i != end; i++)
+		dst[i] = src1[i] | src2[i];
+}
+
+static inline void
+bitmap_and(unsigned long *dst, const unsigned long *src1,
+    const unsigned long *src2, const unsigned int size)
+{
+	const unsigned int end = BITS_TO_LONGS(size);
+	unsigned int i;
+
+	for (i = 0; i != end; i++)
+		dst[i] = src1[i] & src2[i];
+}
+
+static inline void
+bitmap_xor(unsigned long *dst, const unsigned long *src1,
+    const unsigned long *src2, const unsigned int size)
+{
+	const unsigned int end = BITS_TO_LONGS(size);
+	unsigned int i;
+
+	for (i = 0; i != end; i++)
+		dst[i] = src1[i] ^ src2[i];
+}
+
+#endif					/* _LINUX_BITMAP_H_ */

sys/compat/linuxkpi/common/include/linux/bitops.h

@@ -2,7 +2,7 @@
  * Copyright (c) 2010 Isilon Systems, Inc.
  * Copyright (c) 2010 iX Systems, Inc.
  * Copyright (c) 2010 Panasas, Inc.
- * Copyright (c) 2013-2015 Mellanox Technologies, Ltd.
+ * Copyright (c) 2013-2017 Mellanox Technologies, Ltd.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -256,70 +256,6 @@ find_next_zero_bit(const unsigned long *addr, unsigned long size,
 	return (bit);
 }
 
-static inline void
-bitmap_zero(unsigned long *addr, int size)
-{
-	int len;
-
-	len = BITS_TO_LONGS(size) * sizeof(long);
-	memset(addr, 0, len);
-}
-
-static inline void
-bitmap_fill(unsigned long *addr, int size)
-{
-	int tail;
-	int len;
-
-	len = (size / BITS_PER_LONG) * sizeof(long);
-	memset(addr, 0xff, len);
-	tail = size & (BITS_PER_LONG - 1);
-	if (tail) 
-		addr[size / BITS_PER_LONG] = BITMAP_LAST_WORD_MASK(tail);
-}
-
-static inline int
-bitmap_full(unsigned long *addr, int size)
-{
-	unsigned long mask;
-	int tail;
-	int len;
-	int i;
-
-	len = size / BITS_PER_LONG;
-	for (i = 0; i < len; i++)
-		if (addr[i] != ~0UL)
-			return (0);
-	tail = size & (BITS_PER_LONG - 1);
-	if (tail) {
-		mask = BITMAP_LAST_WORD_MASK(tail);
-		if ((addr[i] & mask) != mask)
-			return (0);
-	}
-	return (1);
-}
-
-static inline int
-bitmap_empty(unsigned long *addr, int size)
-{
-	unsigned long mask;
-	int tail;
-	int len;
-	int i;
-
-	len = size / BITS_PER_LONG;
-	for (i = 0; i < len; i++)
-		if (addr[i] != 0)
-			return (0);
-	tail = size & (BITS_PER_LONG - 1);
-	if (tail) {
-		mask = BITMAP_LAST_WORD_MASK(tail);
-		if ((addr[i] & mask) != 0)
-			return (0);
-	}
-	return (1);
-}
-
 #define	__set_bit(i, a)							\
     atomic_set_long(&((volatile unsigned long *)(a))[BIT_WORD(i)], BIT_MASK(i))
 
@@ -396,48 +332,6 @@ __test_and_set_bit(long bit, volatile unsigned long *var)
 	return !!(val & bit);
 }
 
-static inline void
-bitmap_set(unsigned long *map, int start, int nr)
-{
-	unsigned long *p = map + BIT_WORD(start);
-	const int size = start + nr;
-	int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG);
-	unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start);
-
-	while (nr - bits_to_set >= 0) {
-		*p |= mask_to_set;
-		nr -= bits_to_set;
-		bits_to_set = BITS_PER_LONG;
-		mask_to_set = ~0UL;
-		p++;
-	}
-	if (nr) {
-		mask_to_set &= BITMAP_LAST_WORD_MASK(size);
-		*p |= mask_to_set;
-	}
-}
-
-static inline void
-bitmap_clear(unsigned long *map, int start, int nr)
-{
-	unsigned long *p = map + BIT_WORD(start);
-	const int size = start + nr;
-	int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG);
-	unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start);
-
-	while (nr - bits_to_clear >= 0) {
-		*p &= ~mask_to_clear;
-		nr -= bits_to_clear;
-		bits_to_clear = BITS_PER_LONG;
-		mask_to_clear = ~0UL;
-		p++;
-	}
-	if (nr) {
-		mask_to_clear &= BITMAP_LAST_WORD_MASK(size);
-		*p &= ~mask_to_clear;
-	}
-}
-
 enum {
         REG_OP_ISFREE,
         REG_OP_ALLOC,
@@ -445,7 +339,7 @@ enum {
 };
 
 static inline int
-__reg_op(unsigned long *bitmap, int pos, int order, int reg_op)
+linux_reg_op(unsigned long *bitmap, int pos, int order, int reg_op)
 {
         int nbits_reg;
         int index;
@@ -489,71 +383,11 @@ done:
         return ret;
 }
 
-static inline int 
-bitmap_find_free_region(unsigned long *bitmap, int bits, int order)
-{
-        int pos;
-        int end;
-
-        for (pos = 0 ; (end = pos + (1 << order)) <= bits; pos = end) {
-                if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
-                        continue;
-                __reg_op(bitmap, pos, order, REG_OP_ALLOC);
-                return pos;
-        }
-        return -ENOMEM;
-}
-
-static inline int
-bitmap_allocate_region(unsigned long *bitmap, int pos, int order)
-{
-        if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
-                return -EBUSY;
-        __reg_op(bitmap, pos, order, REG_OP_ALLOC);
-        return 0;
-}
-
-static inline void 
-bitmap_release_region(unsigned long *bitmap, int pos, int order)
-{
-        __reg_op(bitmap, pos, order, REG_OP_RELEASE);
-}
-
 #define for_each_set_bit(bit, addr, size) \
 	for ((bit) = find_first_bit((addr), (size));		\
 	     (bit) < (size);					\
 	     (bit) = find_next_bit((addr), (size), (bit) + 1))
 
-static inline unsigned
-bitmap_weight(unsigned long *bitmap, unsigned nbits)
-{
-	unsigned bit;
-	unsigned retval = 0;
-
-	for_each_set_bit(bit, bitmap, nbits)
-		retval++;
-	return (retval);
-}
-
-static inline int
-bitmap_equal(const unsigned long *pa,
-    const unsigned long *pb, unsigned bits)
-{
-	unsigned x;
-	unsigned y = bits / BITS_PER_LONG;
- 
-	for (x = 0; x != y; x++) {
-		if (pa[x] != pb[x])
-			return (0);
-	}
-
-	y = bits % BITS_PER_LONG;
-	if (y != 0) {
-		if ((pa[x] ^ pb[x]) & BITMAP_LAST_WORD_MASK(y))
-			return (0);
-	}
-	return (1);
-}
 
 static inline uint64_t
 sign_extend64(uint64_t value, int index)

sys/compat/linuxkpi/common/include/linux/sched.h

@@ -43,6 +43,8 @@
 #include <linux/pid.h>
 #include <linux/slab.h>
 #include <linux/mm_types.h>
+#include <linux/string.h>
+#include <linux/bitmap.h>
 
 #include <asm/atomic.h>
 

sys/compat/linuxkpi/common/src/linux_idr.c

@@ -40,7 +40,7 @@ __FBSDID("$FreeBSD$");
 
 #include <machine/stdarg.h>
 
-#include <linux/bitops.h>
+#include <linux/bitmap.h>
 #include <linux/kobject.h>
 #include <linux/slab.h>
 #include <linux/idr.h>

sys/conf/files.amd64

@@ -366,20 +366,34 @@ dev/qlxgbe/ql_isr.c		optional	qlxgbe pci
 dev/qlxgbe/ql_misc.c		optional	qlxgbe pci
 dev/qlxgbe/ql_os.c		optional	qlxgbe pci
 dev/qlxgbe/ql_reset.c		optional	qlxgbe pci
-dev/qlnx/qlnxe/ecore_cxt.c	optional	qlnxe pci
+dev/qlnx/qlnxe/ecore_cxt.c	optional	qlnxe pci \
-dev/qlnx/qlnxe/ecore_dbg_fw_funcs.c optional	qlnxe pci
+	compile-with "${LINUXKPI_C}"
-dev/qlnx/qlnxe/ecore_dcbx.c	optional	qlnxe pci
+dev/qlnx/qlnxe/ecore_dbg_fw_funcs.c optional	qlnxe pci \
-dev/qlnx/qlnxe/ecore_dev.c	optional	qlnxe pci
+	compile-with "${LINUXKPI_C}"
-dev/qlnx/qlnxe/ecore_hw.c	optional	qlnxe pci
+dev/qlnx/qlnxe/ecore_dcbx.c	optional	qlnxe pci \
-dev/qlnx/qlnxe/ecore_init_fw_funcs.c optional	qlnxe pci
+	compile-with "${LINUXKPI_C}"
-dev/qlnx/qlnxe/ecore_init_ops.c	optional	qlnxe pci
+dev/qlnx/qlnxe/ecore_dev.c	optional	qlnxe pci \
-dev/qlnx/qlnxe/ecore_int.c	optional	qlnxe pci
+	compile-with "${LINUXKPI_C}"
-dev/qlnx/qlnxe/ecore_l2.c	optional	qlnxe pci
+dev/qlnx/qlnxe/ecore_hw.c	optional	qlnxe pci \
-dev/qlnx/qlnxe/ecore_mcp.c	optional	qlnxe pci
+	compile-with "${LINUXKPI_C}"
-dev/qlnx/qlnxe/ecore_sp_commands.c optional	qlnxe pci
+dev/qlnx/qlnxe/ecore_init_fw_funcs.c optional	qlnxe pci \
-dev/qlnx/qlnxe/ecore_spq.c	optional	qlnxe pci
+	compile-with "${LINUXKPI_C}"
-dev/qlnx/qlnxe/qlnx_ioctl.c	optional	qlnxe pci
+dev/qlnx/qlnxe/ecore_init_ops.c	optional	qlnxe pci \
-dev/qlnx/qlnxe/qlnx_os.c	optional	qlnxe pci
+	compile-with "${LINUXKPI_C}"
+dev/qlnx/qlnxe/ecore_int.c	optional	qlnxe pci \
+	compile-with "${LINUXKPI_C}"
+dev/qlnx/qlnxe/ecore_l2.c	optional	qlnxe pci \
+	compile-with "${LINUXKPI_C}"
+dev/qlnx/qlnxe/ecore_mcp.c	optional	qlnxe pci \
+	compile-with "${LINUXKPI_C}"
+dev/qlnx/qlnxe/ecore_sp_commands.c optional	qlnxe pci \
+	compile-with "${LINUXKPI_C}"
+dev/qlnx/qlnxe/ecore_spq.c	optional	qlnxe pci \
+	compile-with "${LINUXKPI_C}"
+dev/qlnx/qlnxe/qlnx_ioctl.c	optional	qlnxe pci \
+	compile-with "${LINUXKPI_C}"
+dev/qlnx/qlnxe/qlnx_os.c	optional	qlnxe pci \
+	compile-with "${LINUXKPI_C}"
 dev/sfxge/common/ef10_ev.c	optional	sfxge pci
 dev/sfxge/common/ef10_filter.c	optional	sfxge pci
 dev/sfxge/common/ef10_intr.c	optional	sfxge pci

sys/dev/qlnx/qlnxe/bcm_osal.h

@@ -35,7 +35,7 @@
 #include <sys/bitstring.h>
 
 #if __FreeBSD_version >= 1100090
-#include <compat/linuxkpi/common/include/linux/bitops.h>
+#include <linux/bitmap.h>
 #else
 #include <ofed/include/linux/bitops.h>
 #endif

sys/modules/qlnx/qlnxe/Makefile

@@ -57,6 +57,8 @@ CFLAGS += -DECORE_PACKAGE
 CFLAGS += -DCONFIG_ECORE_L2
 CFLAGS += -DECORE_CONFIG_DIRECT_HWFN
 
+CFLAGS+= -I${SRCTOP}/sys/compat/linuxkpi/common/include
+
 #CFLAGS += -g
 #CFLAGS += -fno-inline