1 /* 2 * Copyright (c) 2009-2010 Chelsio, Inc. All rights reserved. 3 * 4 * This software is available to you under a choice of one of two 5 * licenses. You may choose to be licensed under the terms of the GNU 6 * General Public License (GPL) Version 2, available from the file 7 * COPYING in the main directory of this source tree, or the 8 * OpenIB.org BSD license below: 9 * 10 * Redistribution and use in source and binary forms, with or 11 * without modification, are permitted provided that the following 12 * conditions are met: 13 * 14 * - Redistributions of source code must retain the above 15 * copyright notice, this list of conditions and the following 16 * disclaimer. 17 * 18 * - Redistributions in binary form must reproduce the above 19 * copyright notice, this list of conditions and the following 20 * disclaimer in the documentation and/or other materials 21 * provided with the distribution. 22 * 23 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 24 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 25 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 26 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 27 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 28 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 29 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 30 * SOFTWARE. 31 */ 32 /* Crude resource management */ 33 #include <linux/spinlock.h> 34 #include <linux/genalloc.h> 35 #include <linux/ratelimit.h> 36 #include "iw_cxgb4.h" 37 38 static int c4iw_init_qid_table(struct c4iw_rdev *rdev) 39 { 40 u32 i; 41 42 if (c4iw_id_table_alloc(&rdev->resource.qid_table, 43 rdev->lldi.vr->qp.start, 44 rdev->lldi.vr->qp.size, 45 rdev->lldi.vr->qp.size, 0)) 46 return -ENOMEM; 47 48 for (i = rdev->lldi.vr->qp.start; 49 i < rdev->lldi.vr->qp.start + rdev->lldi.vr->qp.size; i++) 50 if (!(i & rdev->qpmask)) 51 c4iw_id_free(&rdev->resource.qid_table, i); 52 return 0; 53 } 54 55 /* nr_* must be power of 2 */ 56 int c4iw_init_resource(struct c4iw_rdev *rdev, u32 nr_tpt, 57 u32 nr_pdid, u32 nr_srqt) 58 { 59 int err = 0; 60 err = c4iw_id_table_alloc(&rdev->resource.tpt_table, 0, nr_tpt, 1, 61 C4IW_ID_TABLE_F_RANDOM); 62 if (err) 63 goto tpt_err; 64 err = c4iw_init_qid_table(rdev); 65 if (err) 66 goto qid_err; 67 err = c4iw_id_table_alloc(&rdev->resource.pdid_table, 0, 68 nr_pdid, 1, 0); 69 if (err) 70 goto pdid_err; 71 if (!nr_srqt) 72 err = c4iw_id_table_alloc(&rdev->resource.srq_table, 0, 73 1, 1, 0); 74 else 75 err = c4iw_id_table_alloc(&rdev->resource.srq_table, 0, 76 nr_srqt, 0, 0); 77 if (err) 78 goto srq_err; 79 return 0; 80 srq_err: 81 c4iw_id_table_free(&rdev->resource.pdid_table); 82 pdid_err: 83 c4iw_id_table_free(&rdev->resource.qid_table); 84 qid_err: 85 c4iw_id_table_free(&rdev->resource.tpt_table); 86 tpt_err: 87 return -ENOMEM; 88 } 89 90 /* 91 * returns 0 if no resource available 92 */ 93 u32 c4iw_get_resource(struct c4iw_id_table *id_table) 94 { 95 u32 entry; 96 entry = c4iw_id_alloc(id_table); 97 if (entry == (u32)(-1)) 98 return 0; 99 return entry; 100 } 101 102 void c4iw_put_resource(struct c4iw_id_table *id_table, u32 entry) 103 { 104 pr_debug("entry 0x%x\n", entry); 105 c4iw_id_free(id_table, entry); 106 } 107 108 u32 c4iw_get_cqid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx) 109 { 110 struct c4iw_qid_list *entry; 111 u32 qid; 112 int i; 113 114 mutex_lock(&uctx->lock); 115 if (!list_empty(&uctx->cqids)) { 116 entry = list_entry(uctx->cqids.next, struct c4iw_qid_list, 117 entry); 118 list_del(&entry->entry); 119 qid = entry->qid; 120 kfree(entry); 121 } else { 122 qid = c4iw_get_resource(&rdev->resource.qid_table); 123 if (!qid) 124 goto out; 125 mutex_lock(&rdev->stats.lock); 126 rdev->stats.qid.cur += rdev->qpmask + 1; 127 mutex_unlock(&rdev->stats.lock); 128 for (i = qid+1; i & rdev->qpmask; i++) { 129 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 130 if (!entry) 131 goto out; 132 entry->qid = i; 133 list_add_tail(&entry->entry, &uctx->cqids); 134 } 135 136 /* 137 * now put the same ids on the qp list since they all 138 * map to the same db/gts page. 139 */ 140 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 141 if (!entry) 142 goto out; 143 entry->qid = qid; 144 list_add_tail(&entry->entry, &uctx->qpids); 145 for (i = qid+1; i & rdev->qpmask; i++) { 146 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 147 if (!entry) 148 goto out; 149 entry->qid = i; 150 list_add_tail(&entry->entry, &uctx->qpids); 151 } 152 } 153 out: 154 mutex_unlock(&uctx->lock); 155 pr_debug("qid 0x%x\n", qid); 156 mutex_lock(&rdev->stats.lock); 157 if (rdev->stats.qid.cur > rdev->stats.qid.max) 158 rdev->stats.qid.max = rdev->stats.qid.cur; 159 mutex_unlock(&rdev->stats.lock); 160 return qid; 161 } 162 163 void c4iw_put_cqid(struct c4iw_rdev *rdev, u32 qid, 164 struct c4iw_dev_ucontext *uctx) 165 { 166 struct c4iw_qid_list *entry; 167 168 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 169 if (!entry) 170 return; 171 pr_debug("qid 0x%x\n", qid); 172 entry->qid = qid; 173 mutex_lock(&uctx->lock); 174 list_add_tail(&entry->entry, &uctx->cqids); 175 mutex_unlock(&uctx->lock); 176 } 177 178 u32 c4iw_get_qpid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx) 179 { 180 struct c4iw_qid_list *entry; 181 u32 qid; 182 int i; 183 184 mutex_lock(&uctx->lock); 185 if (!list_empty(&uctx->qpids)) { 186 entry = list_entry(uctx->qpids.next, struct c4iw_qid_list, 187 entry); 188 list_del(&entry->entry); 189 qid = entry->qid; 190 kfree(entry); 191 } else { 192 qid = c4iw_get_resource(&rdev->resource.qid_table); 193 if (!qid) { 194 mutex_lock(&rdev->stats.lock); 195 rdev->stats.qid.fail++; 196 mutex_unlock(&rdev->stats.lock); 197 goto out; 198 } 199 mutex_lock(&rdev->stats.lock); 200 rdev->stats.qid.cur += rdev->qpmask + 1; 201 mutex_unlock(&rdev->stats.lock); 202 for (i = qid+1; i & rdev->qpmask; i++) { 203 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 204 if (!entry) 205 goto out; 206 entry->qid = i; 207 list_add_tail(&entry->entry, &uctx->qpids); 208 } 209 210 /* 211 * now put the same ids on the cq list since they all 212 * map to the same db/gts page. 213 */ 214 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 215 if (!entry) 216 goto out; 217 entry->qid = qid; 218 list_add_tail(&entry->entry, &uctx->cqids); 219 for (i = qid + 1; i & rdev->qpmask; i++) { 220 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 221 if (!entry) 222 goto out; 223 entry->qid = i; 224 list_add_tail(&entry->entry, &uctx->cqids); 225 } 226 } 227 out: 228 mutex_unlock(&uctx->lock); 229 pr_debug("qid 0x%x\n", qid); 230 mutex_lock(&rdev->stats.lock); 231 if (rdev->stats.qid.cur > rdev->stats.qid.max) 232 rdev->stats.qid.max = rdev->stats.qid.cur; 233 mutex_unlock(&rdev->stats.lock); 234 return qid; 235 } 236 237 void c4iw_put_qpid(struct c4iw_rdev *rdev, u32 qid, 238 struct c4iw_dev_ucontext *uctx) 239 { 240 struct c4iw_qid_list *entry; 241 242 entry = kmalloc(sizeof(*entry), GFP_KERNEL); 243 if (!entry) 244 return; 245 pr_debug("qid 0x%x\n", qid); 246 entry->qid = qid; 247 mutex_lock(&uctx->lock); 248 list_add_tail(&entry->entry, &uctx->qpids); 249 mutex_unlock(&uctx->lock); 250 } 251 252 void c4iw_destroy_resource(struct c4iw_resource *rscp) 253 { 254 c4iw_id_table_free(&rscp->tpt_table); 255 c4iw_id_table_free(&rscp->qid_table); 256 c4iw_id_table_free(&rscp->pdid_table); 257 } 258 259 /* 260 * PBL Memory Manager. Uses Linux generic allocator. 261 */ 262 263 #define MIN_PBL_SHIFT 8 /* 256B == min PBL size (32 entries) */ 264 265 u32 c4iw_pblpool_alloc(struct c4iw_rdev *rdev, int size) 266 { 267 unsigned long addr = gen_pool_alloc(rdev->pbl_pool, size); 268 pr_debug("addr 0x%x size %d\n", (u32)addr, size); 269 mutex_lock(&rdev->stats.lock); 270 if (addr) { 271 rdev->stats.pbl.cur += roundup(size, 1 << MIN_PBL_SHIFT); 272 if (rdev->stats.pbl.cur > rdev->stats.pbl.max) 273 rdev->stats.pbl.max = rdev->stats.pbl.cur; 274 kref_get(&rdev->pbl_kref); 275 } else 276 rdev->stats.pbl.fail++; 277 mutex_unlock(&rdev->stats.lock); 278 return (u32)addr; 279 } 280 281 static void destroy_pblpool(struct kref *kref) 282 { 283 struct c4iw_rdev *rdev; 284 285 rdev = container_of(kref, struct c4iw_rdev, pbl_kref); 286 gen_pool_destroy(rdev->pbl_pool); 287 complete(&rdev->pbl_compl); 288 } 289 290 void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size) 291 { 292 pr_debug("addr 0x%x size %d\n", addr, size); 293 mutex_lock(&rdev->stats.lock); 294 rdev->stats.pbl.cur -= roundup(size, 1 << MIN_PBL_SHIFT); 295 mutex_unlock(&rdev->stats.lock); 296 gen_pool_free(rdev->pbl_pool, (unsigned long)addr, size); 297 kref_put(&rdev->pbl_kref, destroy_pblpool); 298 } 299 300 int c4iw_pblpool_create(struct c4iw_rdev *rdev) 301 { 302 unsigned pbl_start, pbl_chunk, pbl_top; 303 304 rdev->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1); 305 if (!rdev->pbl_pool) 306 return -ENOMEM; 307 308 pbl_start = rdev->lldi.vr->pbl.start; 309 pbl_chunk = rdev->lldi.vr->pbl.size; 310 pbl_top = pbl_start + pbl_chunk; 311 312 while (pbl_start < pbl_top) { 313 pbl_chunk = min(pbl_top - pbl_start + 1, pbl_chunk); 314 if (gen_pool_add(rdev->pbl_pool, pbl_start, pbl_chunk, -1)) { 315 pr_debug("failed to add PBL chunk (%x/%x)\n", 316 pbl_start, pbl_chunk); 317 if (pbl_chunk <= 1024 << MIN_PBL_SHIFT) { 318 pr_warn("Failed to add all PBL chunks (%x/%x)\n", 319 pbl_start, pbl_top - pbl_start); 320 return 0; 321 } 322 pbl_chunk >>= 1; 323 } else { 324 pr_debug("added PBL chunk (%x/%x)\n", 325 pbl_start, pbl_chunk); 326 pbl_start += pbl_chunk; 327 } 328 } 329 330 return 0; 331 } 332 333 void c4iw_pblpool_destroy(struct c4iw_rdev *rdev) 334 { 335 kref_put(&rdev->pbl_kref, destroy_pblpool); 336 } 337 338 /* 339 * RQT Memory Manager. Uses Linux generic allocator. 340 */ 341 342 #define MIN_RQT_SHIFT 10 /* 1KB == min RQT size (16 entries) */ 343 344 u32 c4iw_rqtpool_alloc(struct c4iw_rdev *rdev, int size) 345 { 346 unsigned long addr = gen_pool_alloc(rdev->rqt_pool, size << 6); 347 pr_debug("addr 0x%x size %d\n", (u32)addr, size << 6); 348 if (!addr) 349 pr_warn_ratelimited("%s: Out of RQT memory\n", 350 pci_name(rdev->lldi.pdev)); 351 mutex_lock(&rdev->stats.lock); 352 if (addr) { 353 rdev->stats.rqt.cur += roundup(size << 6, 1 << MIN_RQT_SHIFT); 354 if (rdev->stats.rqt.cur > rdev->stats.rqt.max) 355 rdev->stats.rqt.max = rdev->stats.rqt.cur; 356 kref_get(&rdev->rqt_kref); 357 } else 358 rdev->stats.rqt.fail++; 359 mutex_unlock(&rdev->stats.lock); 360 return (u32)addr; 361 } 362 363 static void destroy_rqtpool(struct kref *kref) 364 { 365 struct c4iw_rdev *rdev; 366 367 rdev = container_of(kref, struct c4iw_rdev, rqt_kref); 368 gen_pool_destroy(rdev->rqt_pool); 369 complete(&rdev->rqt_compl); 370 } 371 372 void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size) 373 { 374 pr_debug("addr 0x%x size %d\n", addr, size << 6); 375 mutex_lock(&rdev->stats.lock); 376 rdev->stats.rqt.cur -= roundup(size << 6, 1 << MIN_RQT_SHIFT); 377 mutex_unlock(&rdev->stats.lock); 378 gen_pool_free(rdev->rqt_pool, (unsigned long)addr, size << 6); 379 kref_put(&rdev->rqt_kref, destroy_rqtpool); 380 } 381 382 int c4iw_rqtpool_create(struct c4iw_rdev *rdev) 383 { 384 unsigned rqt_start, rqt_chunk, rqt_top; 385 int skip = 0; 386 387 rdev->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1); 388 if (!rdev->rqt_pool) 389 return -ENOMEM; 390 391 /* 392 * If SRQs are supported, then never use the first RQE from 393 * the RQT region. This is because HW uses RQT index 0 as NULL. 394 */ 395 if (rdev->lldi.vr->srq.size) 396 skip = T4_RQT_ENTRY_SIZE; 397 398 rqt_start = rdev->lldi.vr->rq.start + skip; 399 rqt_chunk = rdev->lldi.vr->rq.size - skip; 400 rqt_top = rqt_start + rqt_chunk; 401 402 while (rqt_start < rqt_top) { 403 rqt_chunk = min(rqt_top - rqt_start + 1, rqt_chunk); 404 if (gen_pool_add(rdev->rqt_pool, rqt_start, rqt_chunk, -1)) { 405 pr_debug("failed to add RQT chunk (%x/%x)\n", 406 rqt_start, rqt_chunk); 407 if (rqt_chunk <= 1024 << MIN_RQT_SHIFT) { 408 pr_warn("Failed to add all RQT chunks (%x/%x)\n", 409 rqt_start, rqt_top - rqt_start); 410 return 0; 411 } 412 rqt_chunk >>= 1; 413 } else { 414 pr_debug("added RQT chunk (%x/%x)\n", 415 rqt_start, rqt_chunk); 416 rqt_start += rqt_chunk; 417 } 418 } 419 return 0; 420 } 421 422 void c4iw_rqtpool_destroy(struct c4iw_rdev *rdev) 423 { 424 kref_put(&rdev->rqt_kref, destroy_rqtpool); 425 } 426 427 int c4iw_alloc_srq_idx(struct c4iw_rdev *rdev) 428 { 429 int idx; 430 431 idx = c4iw_id_alloc(&rdev->resource.srq_table); 432 mutex_lock(&rdev->stats.lock); 433 if (idx == -1) { 434 rdev->stats.srqt.fail++; 435 mutex_unlock(&rdev->stats.lock); 436 return -ENOMEM; 437 } 438 rdev->stats.srqt.cur++; 439 if (rdev->stats.srqt.cur > rdev->stats.srqt.max) 440 rdev->stats.srqt.max = rdev->stats.srqt.cur; 441 mutex_unlock(&rdev->stats.lock); 442 return idx; 443 } 444 445 void c4iw_free_srq_idx(struct c4iw_rdev *rdev, int idx) 446 { 447 c4iw_id_free(&rdev->resource.srq_table, idx); 448 mutex_lock(&rdev->stats.lock); 449 rdev->stats.srqt.cur--; 450 mutex_unlock(&rdev->stats.lock); 451 } 452 453 /* 454 * On-Chip QP Memory. 455 */ 456 #define MIN_OCQP_SHIFT 12 /* 4KB == min ocqp size */ 457 458 u32 c4iw_ocqp_pool_alloc(struct c4iw_rdev *rdev, int size) 459 { 460 unsigned long addr = gen_pool_alloc(rdev->ocqp_pool, size); 461 pr_debug("addr 0x%x size %d\n", (u32)addr, size); 462 if (addr) { 463 mutex_lock(&rdev->stats.lock); 464 rdev->stats.ocqp.cur += roundup(size, 1 << MIN_OCQP_SHIFT); 465 if (rdev->stats.ocqp.cur > rdev->stats.ocqp.max) 466 rdev->stats.ocqp.max = rdev->stats.ocqp.cur; 467 mutex_unlock(&rdev->stats.lock); 468 } 469 return (u32)addr; 470 } 471 472 void c4iw_ocqp_pool_free(struct c4iw_rdev *rdev, u32 addr, int size) 473 { 474 pr_debug("addr 0x%x size %d\n", addr, size); 475 mutex_lock(&rdev->stats.lock); 476 rdev->stats.ocqp.cur -= roundup(size, 1 << MIN_OCQP_SHIFT); 477 mutex_unlock(&rdev->stats.lock); 478 gen_pool_free(rdev->ocqp_pool, (unsigned long)addr, size); 479 } 480 481 int c4iw_ocqp_pool_create(struct c4iw_rdev *rdev) 482 { 483 unsigned start, chunk, top; 484 485 rdev->ocqp_pool = gen_pool_create(MIN_OCQP_SHIFT, -1); 486 if (!rdev->ocqp_pool) 487 return -ENOMEM; 488 489 start = rdev->lldi.vr->ocq.start; 490 chunk = rdev->lldi.vr->ocq.size; 491 top = start + chunk; 492 493 while (start < top) { 494 chunk = min(top - start + 1, chunk); 495 if (gen_pool_add(rdev->ocqp_pool, start, chunk, -1)) { 496 pr_debug("failed to add OCQP chunk (%x/%x)\n", 497 start, chunk); 498 if (chunk <= 1024 << MIN_OCQP_SHIFT) { 499 pr_warn("Failed to add all OCQP chunks (%x/%x)\n", 500 start, top - start); 501 return 0; 502 } 503 chunk >>= 1; 504 } else { 505 pr_debug("added OCQP chunk (%x/%x)\n", 506 start, chunk); 507 start += chunk; 508 } 509 } 510 return 0; 511 } 512 513 void c4iw_ocqp_pool_destroy(struct c4iw_rdev *rdev) 514 { 515 gen_pool_destroy(rdev->ocqp_pool); 516 } 517