mlx4_core: Add QP range reservation support

To allow allocating an aligned range of consecutive QP numbers, add an
interface to reserve an aligned range of QP numbers and have the QP
allocation function always take a QP number.

This will be used for RSS support in the mlx4_en Ethernet driver and
also potentially by IPoIB RSS support.

Signed-off-by: Yevgeny Petrilin <yevgenyp@mellanox.co.il>
Signed-off-by: Roland Dreier <rolandd@cisco.com>

1 files changed, 73 insertions, 1 deletions

diff --git a/drivers/net/mlx4/alloc.c b/drivers/net/mlx4/alloc.c
index 096bca54bcf7..e6c0d5bb5dcb 100644
--- a/drivers/net/mlx4/alloc.c
+++ b/drivers/net/mlx4/alloc.c
@@ -65,10 +65,82 @@ u32 mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)
 
 void mlx4_bitmap_free(struct mlx4_bitmap *bitmap, u32 obj)
 {
+        mlx4_bitmap_free_range(bitmap, obj, 1);
+}
+
+static unsigned long find_aligned_range(unsigned long *bitmap,
+                                        u32 start, u32 nbits,
+                                        int len, int align)
+{
+        unsigned long end, i;
+
+again:
+        start = ALIGN(start, align);
+
+        while ((start < nbits) && test_bit(start, bitmap))
+                start += align;
+
+        if (start >= nbits)
+                return -1;
+
+        end = start+len;
+        if (end > nbits)
+                return -1;
+
+        for (i = start + 1; i < end; i++) {
+                if (test_bit(i, bitmap)) {
+                        start = i + 1;
+                        goto again;
+                }
+        }
+
+        return start;
+}
+
+u32 mlx4_bitmap_alloc_range(struct mlx4_bitmap *bitmap, int cnt, int align)
+{
+        u32 obj, i;
+
+        if (likely(cnt == 1 && align == 1))
+                return mlx4_bitmap_alloc(bitmap);
+
+        spin_lock(&bitmap->lock);
+
+        obj = find_aligned_range(bitmap->table, bitmap->last,
+                                 bitmap->max, cnt, align);
+        if (obj >= bitmap->max) {
+                bitmap->top = (bitmap->top + bitmap->max) & bitmap->mask;
+                obj = find_aligned_range(bitmap->table, 0,
+                                         bitmap->max,
+                                         cnt, align);
+        }
+
+        if (obj < bitmap->max) {
+                for (i = 0; i < cnt; i++)
+                        set_bit(obj + i, bitmap->table);
+                if (obj == bitmap->last) {
+                        bitmap->last = (obj + cnt);
+                        if (bitmap->last >= bitmap->max)
+                                bitmap->last = 0;
+                }
+                obj |= bitmap->top;
+        } else
+                obj = -1;
+
+        spin_unlock(&bitmap->lock);
+
+        return obj;
+}
+
+void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, u32 obj, int cnt)
+{
+        u32 i;
+
         obj &= bitmap->max - 1;
 
         spin_lock(&bitmap->lock);
-        clear_bit(obj, bitmap->table);
+        for (i = 0; i < cnt; i++)
+                clear_bit(obj + i, bitmap->table);
         bitmap->last = min(bitmap->last, obj);
         bitmap->top = (bitmap->top + bitmap->max) & bitmap->mask;
         spin_unlock(&bitmap->lock);