1 /* 2 * Copyright (c) 2016 Hisilicon Limited. 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/platform_device.h> 35 #include <linux/vmalloc.h> 36 #include "hns_roce_device.h" 37 38 int hns_roce_bitmap_alloc(struct hns_roce_bitmap *bitmap, unsigned long *obj) 39 { 40 int ret = 0; 41 42 spin_lock(&bitmap->lock); 43 *obj = find_next_zero_bit(bitmap->table, bitmap->max, bitmap->last); 44 if (*obj >= bitmap->max) { 45 bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top) 46 & bitmap->mask; 47 *obj = find_first_zero_bit(bitmap->table, bitmap->max); 48 } 49 50 if (*obj < bitmap->max) { 51 set_bit(*obj, bitmap->table); 52 bitmap->last = (*obj + 1); 53 if (bitmap->last == bitmap->max) 54 bitmap->last = 0; 55 *obj |= bitmap->top; 56 } else { 57 ret = -1; 58 } 59 60 spin_unlock(&bitmap->lock); 61 62 return ret; 63 } 64 65 void hns_roce_bitmap_free(struct hns_roce_bitmap *bitmap, unsigned long obj, 66 int rr) 67 { 68 hns_roce_bitmap_free_range(bitmap, obj, 1, rr); 69 } 70 EXPORT_SYMBOL_GPL(hns_roce_bitmap_free); 71 72 int hns_roce_bitmap_alloc_range(struct hns_roce_bitmap *bitmap, int cnt, 73 int align, unsigned long *obj) 74 { 75 int ret = 0; 76 int i; 77 78 if (likely(cnt == 1 && align == 1)) 79 return hns_roce_bitmap_alloc(bitmap, obj); 80 81 spin_lock(&bitmap->lock); 82 83 *obj = bitmap_find_next_zero_area(bitmap->table, bitmap->max, 84 bitmap->last, cnt, align - 1); 85 if (*obj >= bitmap->max) { 86 bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top) 87 & bitmap->mask; 88 *obj = bitmap_find_next_zero_area(bitmap->table, bitmap->max, 0, 89 cnt, align - 1); 90 } 91 92 if (*obj < bitmap->max) { 93 for (i = 0; i < cnt; i++) 94 set_bit(*obj + i, bitmap->table); 95 96 if (*obj == bitmap->last) { 97 bitmap->last = (*obj + cnt); 98 if (bitmap->last >= bitmap->max) 99 bitmap->last = 0; 100 } 101 *obj |= bitmap->top; 102 } else { 103 ret = -1; 104 } 105 106 spin_unlock(&bitmap->lock); 107 108 return ret; 109 } 110 111 void hns_roce_bitmap_free_range(struct hns_roce_bitmap *bitmap, 112 unsigned long obj, int cnt, 113 int rr) 114 { 115 int i; 116 117 obj &= bitmap->max + bitmap->reserved_top - 1; 118 119 spin_lock(&bitmap->lock); 120 for (i = 0; i < cnt; i++) 121 clear_bit(obj + i, bitmap->table); 122 123 if (!rr) 124 bitmap->last = min(bitmap->last, obj); 125 bitmap->top = (bitmap->top + bitmap->max + bitmap->reserved_top) 126 & bitmap->mask; 127 spin_unlock(&bitmap->lock); 128 } 129 130 int hns_roce_bitmap_init(struct hns_roce_bitmap *bitmap, u32 num, u32 mask, 131 u32 reserved_bot, u32 reserved_top) 132 { 133 u32 i; 134 135 if (num != roundup_pow_of_two(num)) 136 return -EINVAL; 137 138 bitmap->last = 0; 139 bitmap->top = 0; 140 bitmap->max = num - reserved_top; 141 bitmap->mask = mask; 142 bitmap->reserved_top = reserved_top; 143 spin_lock_init(&bitmap->lock); 144 bitmap->table = kcalloc(BITS_TO_LONGS(bitmap->max), sizeof(long), 145 GFP_KERNEL); 146 if (!bitmap->table) 147 return -ENOMEM; 148 149 for (i = 0; i < reserved_bot; ++i) 150 set_bit(i, bitmap->table); 151 152 return 0; 153 } 154 155 void hns_roce_bitmap_cleanup(struct hns_roce_bitmap *bitmap) 156 { 157 kfree(bitmap->table); 158 } 159 160 void hns_roce_buf_free(struct hns_roce_dev *hr_dev, u32 size, 161 struct hns_roce_buf *buf) 162 { 163 int i; 164 struct device *dev = hr_dev->dev; 165 166 if (buf->nbufs == 1) { 167 dma_free_coherent(dev, size, buf->direct.buf, buf->direct.map); 168 } else { 169 for (i = 0; i < buf->nbufs; ++i) 170 if (buf->page_list[i].buf) 171 dma_free_coherent(dev, 1 << buf->page_shift, 172 buf->page_list[i].buf, 173 buf->page_list[i].map); 174 kfree(buf->page_list); 175 } 176 } 177 EXPORT_SYMBOL_GPL(hns_roce_buf_free); 178 179 int hns_roce_buf_alloc(struct hns_roce_dev *hr_dev, u32 size, u32 max_direct, 180 struct hns_roce_buf *buf, u32 page_shift) 181 { 182 int i = 0; 183 dma_addr_t t; 184 struct device *dev = hr_dev->dev; 185 u32 page_size = 1 << page_shift; 186 u32 order; 187 188 /* SQ/RQ buf lease than one page, SQ + RQ = 8K */ 189 if (size <= max_direct) { 190 buf->nbufs = 1; 191 /* Npages calculated by page_size */ 192 order = get_order(size); 193 if (order <= page_shift - PAGE_SHIFT) 194 order = 0; 195 else 196 order -= page_shift - PAGE_SHIFT; 197 buf->npages = 1 << order; 198 buf->page_shift = page_shift; 199 /* MTT PA must be recorded in 4k alignment, t is 4k aligned */ 200 buf->direct.buf = dma_alloc_coherent(dev, size, &t, 201 GFP_KERNEL); 202 if (!buf->direct.buf) 203 return -ENOMEM; 204 205 buf->direct.map = t; 206 207 while (t & ((1 << buf->page_shift) - 1)) { 208 --buf->page_shift; 209 buf->npages *= 2; 210 } 211 } else { 212 buf->nbufs = (size + page_size - 1) / page_size; 213 buf->npages = buf->nbufs; 214 buf->page_shift = page_shift; 215 buf->page_list = kcalloc(buf->nbufs, sizeof(*buf->page_list), 216 GFP_KERNEL); 217 218 if (!buf->page_list) 219 return -ENOMEM; 220 221 for (i = 0; i < buf->nbufs; ++i) { 222 buf->page_list[i].buf = dma_alloc_coherent(dev, 223 page_size, 224 &t, 225 GFP_KERNEL); 226 227 if (!buf->page_list[i].buf) 228 goto err_free; 229 230 buf->page_list[i].map = t; 231 } 232 } 233 234 return 0; 235 236 err_free: 237 hns_roce_buf_free(hr_dev, size, buf); 238 return -ENOMEM; 239 } 240 241 void hns_roce_cleanup_bitmap(struct hns_roce_dev *hr_dev) 242 { 243 if (hr_dev->caps.flags & HNS_ROCE_CAP_FLAG_SRQ) 244 hns_roce_cleanup_srq_table(hr_dev); 245 hns_roce_cleanup_qp_table(hr_dev); 246 hns_roce_cleanup_cq_table(hr_dev); 247 hns_roce_cleanup_mr_table(hr_dev); 248 hns_roce_cleanup_pd_table(hr_dev); 249 hns_roce_cleanup_uar_table(hr_dev); 250 } 251