drivers/infiniband/hw/cxgb4/resource.c

   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; 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 }