mlx4: Apply spatch to files imported from Linux
[akaros.git] / kern / drivers / net / mlx4 / alloc.c
1 /*
2  * Copyright (c) 2006, 2007 Cisco Systems, Inc.  All rights reserved.
3  * Copyright (c) 2007, 2008 Mellanox Technologies. All rights reserved.
4  *
5  * This software is available to you under a choice of one of two
6  * licenses.  You may choose to be licensed under the terms of the GNU
7  * General Public License (GPL) Version 2, available from the file
8  * COPYING in the main directory of this source tree, or the
9  * OpenIB.org BSD license below:
10  *
11  *     Redistribution and use in source and binary forms, with or
12  *     without modification, are permitted provided that the following
13  *     conditions are met:
14  *
15  *      - Redistributions of source code must retain the above
16  *        copyright notice, this list of conditions and the following
17  *        disclaimer.
18  *
19  *      - Redistributions in binary form must reproduce the above
20  *        copyright notice, this list of conditions and the following
21  *        disclaimer in the documentation and/or other materials
22  *        provided with the distribution.
23  *
24  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31  * SOFTWARE.
32  */
33
34 #include <linux/errno.h>
35 #include <linux/slab.h>
36 #include <linux/mm.h>
37 #include <linux/export.h>
38 #include <linux/bitmap.h>
39 #include <linux/dma-mapping.h>
40 #include <linux/vmalloc.h>
41
42 #include "mlx4.h"
43
44 uint32_t mlx4_bitmap_alloc(struct mlx4_bitmap *bitmap)
45 {
46         uint32_t obj;
47
48         spin_lock(&bitmap->lock);
49
50         obj = find_next_zero_bit(bitmap->table, bitmap->max, bitmap->last);
51         if (obj >= bitmap->max) {
52                 bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)
53                                 & bitmap->mask;
54                 obj = find_first_zero_bit(bitmap->table, bitmap->max);
55         }
56
57         if (obj < bitmap->max) {
58                 set_bit(obj, bitmap->table);
59                 bitmap->last = (obj + 1);
60                 if (bitmap->last == bitmap->max)
61                         bitmap->last = 0;
62                 obj |= bitmap->top;
63         } else
64                 obj = -1;
65
66         if (obj != -1)
67                 --bitmap->avail;
68
69         spin_unlock(&bitmap->lock);
70
71         return obj;
72 }
73
74 void mlx4_bitmap_free(struct mlx4_bitmap *bitmap, uint32_t obj, int use_rr)
75 {
76         mlx4_bitmap_free_range(bitmap, obj, 1, use_rr);
77 }
78
79 static unsigned long find_aligned_range(unsigned long *bitmap,
80                                         uint32_t start, uint32_t nbits,
81                                         int len, int align,
82                                         uint32_t skip_mask)
83 {
84         unsigned long end, i;
85
86 again:
87         start = ALIGN(start, align);
88
89         while ((start < nbits) && (test_bit(start, bitmap) ||
90                                    (start & skip_mask)))
91                 start += align;
92
93         if (start >= nbits)
94                 return -1;
95
96         end = start+len;
97         if (end > nbits)
98                 return -1;
99
100         for (i = start + 1; i < end; i++) {
101                 if (test_bit(i, bitmap) || ((uint32_t)i & skip_mask)) {
102                         start = i + 1;
103                         goto again;
104                 }
105         }
106
107         return start;
108 }
109
110 uint32_t mlx4_bitmap_alloc_range(struct mlx4_bitmap *bitmap, int cnt,
111                             int align, uint32_t skip_mask)
112 {
113         uint32_t obj;
114
115         if (likely(cnt == 1 && align == 1 && !skip_mask))
116                 return mlx4_bitmap_alloc(bitmap);
117
118         spin_lock(&bitmap->lock);
119
120         obj = find_aligned_range(bitmap->table, bitmap->last,
121                                  bitmap->max, cnt, align, skip_mask);
122         if (obj >= bitmap->max) {
123                 bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)
124                                 & bitmap->mask;
125                 obj = find_aligned_range(bitmap->table, 0, bitmap->max,
126                                          cnt, align, skip_mask);
127         }
128
129         if (obj < bitmap->max) {
130                 bitmap_set(bitmap->table, obj, cnt);
131                 if (obj == bitmap->last) {
132                         bitmap->last = (obj + cnt);
133                         if (bitmap->last >= bitmap->max)
134                                 bitmap->last = 0;
135                 }
136                 obj |= bitmap->top;
137         } else
138                 obj = -1;
139
140         if (obj != -1)
141                 bitmap->avail -= cnt;
142
143         spin_unlock(&bitmap->lock);
144
145         return obj;
146 }
147
148 uint32_t mlx4_bitmap_avail(struct mlx4_bitmap *bitmap)
149 {
150         return bitmap->avail;
151 }
152
153 static uint32_t mlx4_bitmap_masked_value(struct mlx4_bitmap *bitmap,
154                                          uint32_t obj)
155 {
156         return obj & (bitmap->max + bitmap->reserved_top - 1);
157 }
158
159 void mlx4_bitmap_free_range(struct mlx4_bitmap *bitmap, uint32_t obj, int cnt,
160                             int use_rr)
161 {
162         obj &= bitmap->max + bitmap->reserved_top - 1;
163
164         spin_lock(&bitmap->lock);
165         if (!use_rr) {
166                 bitmap->last = MIN(bitmap->last, obj);
167                 bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top)
168                                 & bitmap->mask;
169         }
170         bitmap_clear(bitmap->table, obj, cnt);
171         bitmap->avail += cnt;
172         spin_unlock(&bitmap->lock);
173 }
174
175 int mlx4_bitmap_init(struct mlx4_bitmap *bitmap, uint32_t num, uint32_t mask,
176                      uint32_t reserved_bot, uint32_t reserved_top)
177 {
178         /* num must be a power of 2 */
179         if (num != ROUNDUPPWR2(num))
180                 return -EINVAL;
181
182         bitmap->last = 0;
183         bitmap->top  = 0;
184         bitmap->max  = num - reserved_top;
185         bitmap->mask = mask;
186         bitmap->reserved_top = reserved_top;
187         bitmap->avail = num - reserved_top - reserved_bot;
188         bitmap->effective_len = bitmap->avail;
189         spinlock_init_irqsave(&bitmap->lock);
190         bitmap->table = kzmalloc(BITS_TO_LONGS(bitmap->max) * sizeof(long),
191                                  KMALLOC_WAIT);
192         if (!bitmap->table)
193                 return -ENOMEM;
194
195         bitmap_set(bitmap->table, 0, reserved_bot);
196
197         return 0;
198 }
199
200 void mlx4_bitmap_cleanup(struct mlx4_bitmap *bitmap)
201 {
202         kfree(bitmap->table);
203 }
204
205 struct mlx4_zone_allocator {
206         struct list_head                entries;
207         struct list_head                prios;
208         uint32_t                                last_uid;
209         uint32_t                                mask;
210         /* protect the zone_allocator from concurrent accesses */
211         spinlock_t                      lock;
212         enum mlx4_zone_alloc_flags      flags;
213 };
214
215 struct mlx4_zone_entry {
216         struct list_head                list;
217         struct list_head                prio_list;
218         uint32_t                                uid;
219         struct mlx4_zone_allocator      *allocator;
220         struct mlx4_bitmap              *bitmap;
221         int                             use_rr;
222         int                             priority;
223         int                             offset;
224         enum mlx4_zone_flags            flags;
225 };
226
227 struct mlx4_zone_allocator *mlx4_zone_allocator_create(enum mlx4_zone_alloc_flags flags)
228 {
229         struct mlx4_zone_allocator *zones = kmalloc(sizeof(*zones),
230                                                     KMALLOC_WAIT);
231
232         if (NULL == zones)
233                 return NULL;
234
235         INIT_LIST_HEAD(&zones->entries);
236         INIT_LIST_HEAD(&zones->prios);
237         spinlock_init_irqsave(&zones->lock);
238         zones->last_uid = 0;
239         zones->mask = 0;
240         zones->flags = flags;
241
242         return zones;
243 }
244
245 int mlx4_zone_add_one(struct mlx4_zone_allocator *zone_alloc,
246                       struct mlx4_bitmap *bitmap,
247                       uint32_t flags,
248                       int priority,
249                       int offset,
250                       uint32_t *puid)
251 {
252         uint32_t mask = mlx4_bitmap_masked_value(bitmap, (uint32_t)-1);
253         struct mlx4_zone_entry *it;
254         struct mlx4_zone_entry *zone = kmalloc(sizeof(*zone), KMALLOC_WAIT);
255
256         if (NULL == zone)
257                 return -ENOMEM;
258
259         zone->flags = flags;
260         zone->bitmap = bitmap;
261         zone->use_rr = (flags & MLX4_ZONE_USE_RR) ? MLX4_USE_RR : 0;
262         zone->priority = priority;
263         zone->offset = offset;
264
265         spin_lock(&zone_alloc->lock);
266
267         zone->uid = zone_alloc->last_uid++;
268         zone->allocator = zone_alloc;
269
270         if (zone_alloc->mask < mask)
271                 zone_alloc->mask = mask;
272
273         list_for_each_entry(it, &zone_alloc->prios, prio_list)
274                 if (it->priority >= priority)
275                         break;
276
277         if (&it->prio_list == &zone_alloc->prios || it->priority > priority)
278                 list_add_tail(&zone->prio_list, &it->prio_list);
279         list_add_tail(&zone->list, &it->list);
280
281         spin_unlock(&zone_alloc->lock);
282
283         *puid = zone->uid;
284
285         return 0;
286 }
287
288 /* Should be called under a lock */
289 static int __mlx4_zone_remove_one_entry(struct mlx4_zone_entry *entry)
290 {
291         struct mlx4_zone_allocator *zone_alloc = entry->allocator;
292
293         if (!list_empty(&entry->prio_list)) {
294                 /* Check if we need to add an alternative node to the prio list */
295                 if (!list_is_last(&entry->list, &zone_alloc->entries)) {
296                         struct mlx4_zone_entry *next = list_first_entry(&entry->list,
297                                                                         typeof(*next),
298                                                                         list);
299
300                         if (next->priority == entry->priority)
301                                 list_add_tail(&next->prio_list, &entry->prio_list);
302                 }
303
304                 list_del(&entry->prio_list);
305         }
306
307         list_del(&entry->list);
308
309         if (zone_alloc->flags & MLX4_ZONE_ALLOC_FLAGS_NO_OVERLAP) {
310                 uint32_t mask = 0;
311                 struct mlx4_zone_entry *it;
312
313                 list_for_each_entry(it, &zone_alloc->prios, prio_list) {
314                         uint32_t cur_mask = mlx4_bitmap_masked_value(it->bitmap,
315                                                                      (uint32_t)-1);
316
317                         if (mask < cur_mask)
318                                 mask = cur_mask;
319                 }
320                 zone_alloc->mask = mask;
321         }
322
323         return 0;
324 }
325
326 void mlx4_zone_allocator_destroy(struct mlx4_zone_allocator *zone_alloc)
327 {
328         struct mlx4_zone_entry *zone, *tmp;
329
330         spin_lock(&zone_alloc->lock);
331
332         list_for_each_entry_safe(zone, tmp, &zone_alloc->entries, list) {
333                 list_del(&zone->list);
334                 list_del(&zone->prio_list);
335                 kfree(zone);
336         }
337
338         spin_unlock(&zone_alloc->lock);
339         kfree(zone_alloc);
340 }
341
342 /* Should be called under a lock */
343 static uint32_t __mlx4_alloc_from_zone(struct mlx4_zone_entry *zone, int count,
344                                   int align, uint32_t skip_mask,
345                                   uint32_t *puid)
346 {
347         uint32_t uid;
348         uint32_t res;
349         struct mlx4_zone_allocator *zone_alloc = zone->allocator;
350         struct mlx4_zone_entry *curr_node;
351
352         res = mlx4_bitmap_alloc_range(zone->bitmap, count,
353                                       align, skip_mask);
354
355         if (res != (uint32_t)-1) {
356                 res += zone->offset;
357                 uid = zone->uid;
358                 goto out;
359         }
360
361         list_for_each_entry(curr_node, &zone_alloc->prios, prio_list) {
362                 if (unlikely(curr_node->priority == zone->priority))
363                         break;
364         }
365
366         if (zone->flags & MLX4_ZONE_ALLOW_ALLOC_FROM_LOWER_PRIO) {
367                 struct mlx4_zone_entry *it = curr_node;
368
369                 list_for_each_entry_continue_reverse(it, &zone_alloc->entries, list) {
370                         res = mlx4_bitmap_alloc_range(it->bitmap, count,
371                                                       align, skip_mask);
372                         if (res != (uint32_t)-1) {
373                                 res += it->offset;
374                                 uid = it->uid;
375                                 goto out;
376                         }
377                 }
378         }
379
380         if (zone->flags & MLX4_ZONE_ALLOW_ALLOC_FROM_EQ_PRIO) {
381                 struct mlx4_zone_entry *it = curr_node;
382
383                 list_for_each_entry_from(it, &zone_alloc->entries, list) {
384                         if (unlikely(it == zone))
385                                 continue;
386
387                         if (unlikely(it->priority != curr_node->priority))
388                                 break;
389
390                         res = mlx4_bitmap_alloc_range(it->bitmap, count,
391                                                       align, skip_mask);
392                         if (res != (uint32_t)-1) {
393                                 res += it->offset;
394                                 uid = it->uid;
395                                 goto out;
396                         }
397                 }
398         }
399
400         if (zone->flags & MLX4_ZONE_FALLBACK_TO_HIGHER_PRIO) {
401                 if (list_is_last(&curr_node->prio_list, &zone_alloc->prios))
402                         goto out;
403
404                 curr_node = list_first_entry(&curr_node->prio_list,
405                                              typeof(*curr_node),
406                                              prio_list);
407
408                 list_for_each_entry_from(curr_node, &zone_alloc->entries, list) {
409                         res = mlx4_bitmap_alloc_range(curr_node->bitmap, count,
410                                                       align, skip_mask);
411                         if (res != (uint32_t)-1) {
412                                 res += curr_node->offset;
413                                 uid = curr_node->uid;
414                                 goto out;
415                         }
416                 }
417         }
418
419 out:
420         if (NULL != puid && res != (uint32_t)-1)
421                 *puid = uid;
422         return res;
423 }
424
425 /* Should be called under a lock */
426 static void __mlx4_free_from_zone(struct mlx4_zone_entry *zone, uint32_t obj,
427                                   uint32_t count)
428 {
429         mlx4_bitmap_free_range(zone->bitmap, obj - zone->offset, count, zone->use_rr);
430 }
431
432 /* Should be called under a lock */
433 static struct mlx4_zone_entry *__mlx4_find_zone_by_uid(
434                 struct mlx4_zone_allocator *zones, uint32_t uid)
435 {
436         struct mlx4_zone_entry *zone;
437
438         list_for_each_entry(zone, &zones->entries, list) {
439                 if (zone->uid == uid)
440                         return zone;
441         }
442
443         return NULL;
444 }
445
446 struct mlx4_bitmap *mlx4_zone_get_bitmap(struct mlx4_zone_allocator *zones,
447                                          uint32_t uid)
448 {
449         struct mlx4_zone_entry *zone;
450         struct mlx4_bitmap *bitmap;
451
452         spin_lock(&zones->lock);
453
454         zone = __mlx4_find_zone_by_uid(zones, uid);
455
456         bitmap = zone == NULL ? NULL : zone->bitmap;
457
458         spin_unlock(&zones->lock);
459
460         return bitmap;
461 }
462
463 int mlx4_zone_remove_one(struct mlx4_zone_allocator *zones, uint32_t uid)
464 {
465         struct mlx4_zone_entry *zone;
466         int res;
467
468         spin_lock(&zones->lock);
469
470         zone = __mlx4_find_zone_by_uid(zones, uid);
471
472         if (NULL == zone) {
473                 res = -1;
474                 goto out;
475         }
476
477         res = __mlx4_zone_remove_one_entry(zone);
478
479 out:
480         spin_unlock(&zones->lock);
481         kfree(zone);
482
483         return res;
484 }
485
486 /* Should be called under a lock */
487 static struct mlx4_zone_entry *__mlx4_find_zone_by_uid_unique(
488                 struct mlx4_zone_allocator *zones, uint32_t obj)
489 {
490         struct mlx4_zone_entry *zone, *zone_candidate = NULL;
491         uint32_t dist = (uint32_t)-1;
492
493         /* Search for the smallest zone that this obj could be
494          * allocated from. This is done in order to handle
495          * situations when small bitmaps are allocated from bigger
496          * bitmaps (and the allocated space is marked as reserved in
497          * the bigger bitmap.
498          */
499         list_for_each_entry(zone, &zones->entries, list) {
500                 if (obj >= zone->offset) {
501                         uint32_t mobj = (obj - zone->offset) & zones->mask;
502
503                         if (mobj < zone->bitmap->max) {
504                                 uint32_t curr_dist = zone->bitmap->effective_len;
505
506                                 if (curr_dist < dist) {
507                                         dist = curr_dist;
508                                         zone_candidate = zone;
509                                 }
510                         }
511                 }
512         }
513
514         return zone_candidate;
515 }
516
517 uint32_t mlx4_zone_alloc_entries(struct mlx4_zone_allocator *zones,
518                                  uint32_t uid, int count,
519                                  int align, uint32_t skip_mask,
520                                  uint32_t *puid)
521 {
522         struct mlx4_zone_entry *zone;
523         int res = -1;
524
525         spin_lock(&zones->lock);
526
527         zone = __mlx4_find_zone_by_uid(zones, uid);
528
529         if (NULL == zone)
530                 goto out;
531
532         res = __mlx4_alloc_from_zone(zone, count, align, skip_mask, puid);
533
534 out:
535         spin_unlock(&zones->lock);
536
537         return res;
538 }
539
540 uint32_t mlx4_zone_free_entries(struct mlx4_zone_allocator *zones,
541                                 uint32_t uid, uint32_t obj, uint32_t count)
542 {
543         struct mlx4_zone_entry *zone;
544         int res = 0;
545
546         spin_lock(&zones->lock);
547
548         zone = __mlx4_find_zone_by_uid(zones, uid);
549
550         if (NULL == zone) {
551                 res = -1;
552                 goto out;
553         }
554
555         __mlx4_free_from_zone(zone, obj, count);
556
557 out:
558         spin_unlock(&zones->lock);
559
560         return res;
561 }
562
563 uint32_t mlx4_zone_free_entries_unique(struct mlx4_zone_allocator *zones,
564                                        uint32_t obj, uint32_t count)
565 {
566         struct mlx4_zone_entry *zone;
567         int res;
568
569         if (!(zones->flags & MLX4_ZONE_ALLOC_FLAGS_NO_OVERLAP))
570                 return -EFAULT;
571
572         spin_lock(&zones->lock);
573
574         zone = __mlx4_find_zone_by_uid_unique(zones, obj);
575
576         if (NULL == zone) {
577                 res = -1;
578                 goto out;
579         }
580
581         __mlx4_free_from_zone(zone, obj, count);
582         res = 0;
583
584 out:
585         spin_unlock(&zones->lock);
586
587         return res;
588 }
589 /*
590  * Handling for queue buffers -- we allocate a bunch of memory and
591  * register it in a memory region at HCA virtual address 0.  If the
592  * requested size is > max_direct, we split the allocation into
593  * multiple pages, so we don't require too much contiguous memory.
594  */
595
596 int mlx4_buf_alloc(struct mlx4_dev *dev, int size, int max_direct,
597                    struct mlx4_buf *buf, gfp_t gfp)
598 {
599         dma_addr_t t;
600
601         if (size <= max_direct) {
602                 buf->nbufs        = 1;
603                 buf->npages       = 1;
604                 buf->page_shift   = get_order(size) + PAGE_SHIFT;
605                 buf->direct.buf   = dma_alloc_coherent(&dev->persist->pdev->dev,
606                                                        size, &t, gfp);
607                 if (!buf->direct.buf)
608                         return -ENOMEM;
609
610                 buf->direct.map = t;
611
612                 while (t & ((1 << buf->page_shift) - 1)) {
613                         --buf->page_shift;
614                         buf->npages *= 2;
615                 }
616
617                 memset(buf->direct.buf, 0, size);
618         } else {
619                 int i;
620
621                 buf->direct.buf  = NULL;
622                 buf->nbufs       = (size + PAGE_SIZE - 1) / PAGE_SIZE;
623                 buf->npages      = buf->nbufs;
624                 buf->page_shift  = PAGE_SHIFT;
625                 buf->page_list   = kzmalloc((buf->nbufs) * (sizeof(*buf->page_list)),
626                                             gfp);
627                 if (!buf->page_list)
628                         return -ENOMEM;
629
630                 for (i = 0; i < buf->nbufs; ++i) {
631                         buf->page_list[i].buf =
632                                 dma_alloc_coherent(&dev->persist->pdev->dev,
633                                                    PAGE_SIZE,
634                                                    &t, gfp);
635                         if (!buf->page_list[i].buf)
636                                 goto err_free;
637
638                         buf->page_list[i].map = t;
639
640                         memset(buf->page_list[i].buf, 0, PAGE_SIZE);
641                 }
642
643                 if (BITS_PER_LONG == 64) {
644                         struct page **pages;
645                         pages = kmalloc(sizeof *pages * buf->nbufs, gfp);
646                         if (!pages)
647                                 goto err_free;
648                         for (i = 0; i < buf->nbufs; ++i)
649                                 pages[i] = kva2page(buf->page_list[i].buf);
650                         buf->direct.buf = vmap(pages, buf->nbufs, VM_MAP, PAGE_KERNEL);
651                         kfree(pages);
652                         if (!buf->direct.buf)
653                                 goto err_free;
654                 }
655         }
656
657         return 0;
658
659 err_free:
660         mlx4_buf_free(dev, size, buf);
661
662         return -ENOMEM;
663 }
664 EXPORT_SYMBOL_GPL(mlx4_buf_alloc);
665
666 void mlx4_buf_free(struct mlx4_dev *dev, int size, struct mlx4_buf *buf)
667 {
668         int i;
669
670         if (buf->nbufs == 1)
671                 dma_free_coherent(&dev->persist->pdev->dev, size,
672                                   buf->direct.buf,
673                                   buf->direct.map);
674         else {
675                 if (BITS_PER_LONG == 64)
676                         vunmap(buf->direct.buf);
677
678                 for (i = 0; i < buf->nbufs; ++i)
679                         if (buf->page_list[i].buf)
680                                 dma_free_coherent(&dev->persist->pdev->dev,
681                                                   PAGE_SIZE,
682                                                   buf->page_list[i].buf,
683                                                   buf->page_list[i].map);
684                 kfree(buf->page_list);
685         }
686 }
687 EXPORT_SYMBOL_GPL(mlx4_buf_free);
688
689 static struct mlx4_db_pgdir *mlx4_alloc_db_pgdir(struct device *dma_device,
690                                                  gfp_t gfp)
691 {
692         struct mlx4_db_pgdir *pgdir;
693
694         pgdir = kzmalloc(sizeof *pgdir, gfp);
695         if (!pgdir)
696                 return NULL;
697
698         bitmap_fill(pgdir->order1, MLX4_DB_PER_PAGE / 2);
699         pgdir->bits[0] = pgdir->order0;
700         pgdir->bits[1] = pgdir->order1;
701         pgdir->db_page = dma_alloc_coherent(dma_device, PAGE_SIZE,
702                                             &pgdir->db_dma, gfp);
703         if (!pgdir->db_page) {
704                 kfree(pgdir);
705                 return NULL;
706         }
707
708         return pgdir;
709 }
710
711 static int mlx4_alloc_db_from_pgdir(struct mlx4_db_pgdir *pgdir,
712                                     struct mlx4_db *db, int order)
713 {
714         int o;
715         int i;
716
717         for (o = order; o <= 1; ++o) {
718                 i = find_first_bit(pgdir->bits[o], MLX4_DB_PER_PAGE >> o);
719                 if (i < MLX4_DB_PER_PAGE >> o)
720                         goto found;
721         }
722
723         return -ENOMEM;
724
725 found:
726         clear_bit(i, pgdir->bits[o]);
727
728         i <<= o;
729
730         if (o > order)
731                 set_bit(i ^ 1, pgdir->bits[order]);
732
733         db->u.pgdir = pgdir;
734         db->index   = i;
735         db->db      = pgdir->db_page + db->index;
736         db->dma     = pgdir->db_dma  + db->index * 4;
737         db->order   = order;
738
739         return 0;
740 }
741
742 int mlx4_db_alloc(struct mlx4_dev *dev, struct mlx4_db *db, int order, gfp_t gfp)
743 {
744         struct mlx4_priv *priv = mlx4_priv(dev);
745         struct mlx4_db_pgdir *pgdir;
746         int ret = 0;
747
748         qlock(&priv->pgdir_mutex);
749
750         list_for_each_entry(pgdir, &priv->pgdir_list, list)
751                 if (!mlx4_alloc_db_from_pgdir(pgdir, db, order))
752                         goto out;
753
754         pgdir = mlx4_alloc_db_pgdir(&dev->persist->pdev->dev, gfp);
755         if (!pgdir) {
756                 ret = -ENOMEM;
757                 goto out;
758         }
759
760         list_add(&pgdir->list, &priv->pgdir_list);
761
762         /* This should never fail -- we just allocated an empty page: */
763         warn_on(mlx4_alloc_db_from_pgdir(pgdir, db, order));
764
765 out:
766         qunlock(&priv->pgdir_mutex);
767
768         return ret;
769 }
770 EXPORT_SYMBOL_GPL(mlx4_db_alloc);
771
772 void mlx4_db_free(struct mlx4_dev *dev, struct mlx4_db *db)
773 {
774         struct mlx4_priv *priv = mlx4_priv(dev);
775         int o;
776         int i;
777
778         qlock(&priv->pgdir_mutex);
779
780         o = db->order;
781         i = db->index;
782
783         if (db->order == 0 && test_bit(i ^ 1, db->u.pgdir->order0)) {
784                 clear_bit(i ^ 1, db->u.pgdir->order0);
785                 ++o;
786         }
787         i >>= o;
788         set_bit(i, db->u.pgdir->bits[o]);
789
790         if (bitmap_full(db->u.pgdir->order1, MLX4_DB_PER_PAGE / 2)) {
791                 dma_free_coherent(&dev->persist->pdev->dev, PAGE_SIZE,
792                                   db->u.pgdir->db_page, db->u.pgdir->db_dma);
793                 list_del(&db->u.pgdir->list);
794                 kfree(db->u.pgdir);
795         }
796
797         qunlock(&priv->pgdir_mutex);
798 }
799 EXPORT_SYMBOL_GPL(mlx4_db_free);
800
801 int mlx4_alloc_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
802                        int size, int max_direct)
803 {
804         int err;
805
806         err = mlx4_db_alloc(dev, &wqres->db, 1, KMALLOC_WAIT);
807         if (err)
808                 return err;
809
810         *wqres->db.db = 0;
811
812         err = mlx4_buf_alloc(dev, size, max_direct, &wqres->buf, KMALLOC_WAIT);
813         if (err)
814                 goto err_db;
815
816         err = mlx4_mtt_init(dev, wqres->buf.npages, wqres->buf.page_shift,
817                             &wqres->mtt);
818         if (err)
819                 goto err_buf;
820
821         err = mlx4_buf_write_mtt(dev, &wqres->mtt, &wqres->buf, KMALLOC_WAIT);
822         if (err)
823                 goto err_mtt;
824
825         return 0;
826
827 err_mtt:
828         mlx4_mtt_cleanup(dev, &wqres->mtt);
829 err_buf:
830         mlx4_buf_free(dev, size, &wqres->buf);
831 err_db:
832         mlx4_db_free(dev, &wqres->db);
833
834         return err;
835 }
836 EXPORT_SYMBOL_GPL(mlx4_alloc_hwq_res);
837
838 void mlx4_free_hwq_res(struct mlx4_dev *dev, struct mlx4_hwq_resources *wqres,
839                        int size)
840 {
841         mlx4_mtt_cleanup(dev, &wqres->mtt);
842         mlx4_buf_free(dev, size, &wqres->buf);
843         mlx4_db_free(dev, &wqres->db);
844 }
845 EXPORT_SYMBOL_GPL(mlx4_free_hwq_res);