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, u32 nr_pdid)
  57 {
  58         int err = 0;
  59         err = c4iw_id_table_alloc(&rdev->resource.tpt_table, 0, nr_tpt, 1,
  60                                         C4IW_ID_TABLE_F_RANDOM);
  61         if (err)
  62                 goto tpt_err;
  63         err = c4iw_init_qid_table(rdev);
  64         if (err)
  65                 goto qid_err;
  66         err = c4iw_id_table_alloc(&rdev->resource.pdid_table, 0,
  67                                         nr_pdid, 1, 0);
  68         if (err)
  69                 goto pdid_err;
  70         return 0;
  71  pdid_err:
  72         c4iw_id_table_free(&rdev->resource.qid_table);
  73  qid_err:
  74         c4iw_id_table_free(&rdev->resource.tpt_table);
  75  tpt_err:
  76         return -ENOMEM;
  77 }
  78
  79 /*
  80  * returns 0 if no resource available
  81  */
  82 u32 c4iw_get_resource(struct c4iw_id_table *id_table)
  83 {
  84         u32 entry;
  85         entry = c4iw_id_alloc(id_table);
  86         if (entry == (u32)(-1))
  87                 return 0;
  88         return entry;
  89 }
  90
  91 void c4iw_put_resource(struct c4iw_id_table *id_table, u32 entry)
  92 {
  93         pr_debug("entry 0x%x\n", entry);
  94         c4iw_id_free(id_table, entry);
  95 }
  96
  97 u32 c4iw_get_cqid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
  98 {
  99         struct c4iw_qid_list *entry;
 100         u32 qid;
 101         int i;
 102
 103         mutex_lock(&uctx->lock);
 104         if (!list_empty(&uctx->cqids)) {
 105                 entry = list_entry(uctx->cqids.next, struct c4iw_qid_list,
 106                                    entry);
 107                 list_del(&entry->entry);
 108                 qid = entry->qid;
 109                 kfree(entry);
 110         } else {
 111                 qid = c4iw_get_resource(&rdev->resource.qid_table);
 112                 if (!qid)
 113                         goto out;
 114                 mutex_lock(&rdev->stats.lock);
 115                 rdev->stats.qid.cur += rdev->qpmask + 1;
 116                 mutex_unlock(&rdev->stats.lock);
 117                 for (i = qid+1; i & rdev->qpmask; i++) {
 118                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
 119                         if (!entry)
 120                                 goto out;
 121                         entry->qid = i;
 122                         list_add_tail(&entry->entry, &uctx->cqids);
 123                 }
 124
 125                 /*
 126                  * now put the same ids on the qp list since they all
 127                  * map to the same db/gts page.
 128                  */
 129                 entry = kmalloc(sizeof *entry, GFP_KERNEL);
 130                 if (!entry)
 131                         goto out;
 132                 entry->qid = qid;
 133                 list_add_tail(&entry->entry, &uctx->qpids);
 134                 for (i = qid+1; i & rdev->qpmask; i++) {
 135                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
 136                         if (!entry)
 137                                 goto out;
 138                         entry->qid = i;
 139                         list_add_tail(&entry->entry, &uctx->qpids);
 140                 }
 141         }
 142 out:
 143         mutex_unlock(&uctx->lock);
 144         pr_debug("qid 0x%x\n", qid);
 145         mutex_lock(&rdev->stats.lock);
 146         if (rdev->stats.qid.cur > rdev->stats.qid.max)
 147                 rdev->stats.qid.max = rdev->stats.qid.cur;
 148         mutex_unlock(&rdev->stats.lock);
 149         return qid;
 150 }
 151
 152 void c4iw_put_cqid(struct c4iw_rdev *rdev, u32 qid,
 153                    struct c4iw_dev_ucontext *uctx)
 154 {
 155         struct c4iw_qid_list *entry;
 156
 157         entry = kmalloc(sizeof *entry, GFP_KERNEL);
 158         if (!entry)
 159                 return;
 160         pr_debug("qid 0x%x\n", qid);
 161         entry->qid = qid;
 162         mutex_lock(&uctx->lock);
 163         list_add_tail(&entry->entry, &uctx->cqids);
 164         mutex_unlock(&uctx->lock);
 165 }
 166
 167 u32 c4iw_get_qpid(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
 168 {
 169         struct c4iw_qid_list *entry;
 170         u32 qid;
 171         int i;
 172
 173         mutex_lock(&uctx->lock);
 174         if (!list_empty(&uctx->qpids)) {
 175                 entry = list_entry(uctx->qpids.next, struct c4iw_qid_list,
 176                                    entry);
 177                 list_del(&entry->entry);
 178                 qid = entry->qid;
 179                 kfree(entry);
 180         } else {
 181                 qid = c4iw_get_resource(&rdev->resource.qid_table);
 182                 if (!qid) {
 183                         mutex_lock(&rdev->stats.lock);
 184                         rdev->stats.qid.fail++;
 185                         mutex_unlock(&rdev->stats.lock);
 186                         goto out;
 187                 }
 188                 mutex_lock(&rdev->stats.lock);
 189                 rdev->stats.qid.cur += rdev->qpmask + 1;
 190                 mutex_unlock(&rdev->stats.lock);
 191                 for (i = qid+1; i & rdev->qpmask; i++) {
 192                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
 193                         if (!entry)
 194                                 goto out;
 195                         entry->qid = i;
 196                         list_add_tail(&entry->entry, &uctx->qpids);
 197                 }
 198
 199                 /*
 200                  * now put the same ids on the cq list since they all
 201                  * map to the same db/gts page.
 202                  */
 203                 entry = kmalloc(sizeof *entry, GFP_KERNEL);
 204                 if (!entry)
 205                         goto out;
 206                 entry->qid = qid;
 207                 list_add_tail(&entry->entry, &uctx->cqids);
 208                 for (i = qid; i & rdev->qpmask; i++) {
 209                         entry = kmalloc(sizeof *entry, GFP_KERNEL);
 210                         if (!entry)
 211                                 goto out;
 212                         entry->qid = i;
 213                         list_add_tail(&entry->entry, &uctx->cqids);
 214                 }
 215         }
 216 out:
 217         mutex_unlock(&uctx->lock);
 218         pr_debug("qid 0x%x\n", qid);
 219         mutex_lock(&rdev->stats.lock);
 220         if (rdev->stats.qid.cur > rdev->stats.qid.max)
 221                 rdev->stats.qid.max = rdev->stats.qid.cur;
 222         mutex_unlock(&rdev->stats.lock);
 223         return qid;
 224 }
 225
 226 void c4iw_put_qpid(struct c4iw_rdev *rdev, u32 qid,
 227                    struct c4iw_dev_ucontext *uctx)
 228 {
 229         struct c4iw_qid_list *entry;
 230
 231         entry = kmalloc(sizeof *entry, GFP_KERNEL);
 232         if (!entry)
 233                 return;
 234         pr_debug("qid 0x%x\n", qid);
 235         entry->qid = qid;
 236         mutex_lock(&uctx->lock);
 237         list_add_tail(&entry->entry, &uctx->qpids);
 238         mutex_unlock(&uctx->lock);
 239 }
 240
 241 void c4iw_destroy_resource(struct c4iw_resource *rscp)
 242 {
 243         c4iw_id_table_free(&rscp->tpt_table);
 244         c4iw_id_table_free(&rscp->qid_table);
 245         c4iw_id_table_free(&rscp->pdid_table);
 246 }
 247
 248 /*
 249  * PBL Memory Manager.  Uses Linux generic allocator.
 250  */
 251
 252 #define MIN_PBL_SHIFT 8                 /* 256B == min PBL size (32 entries) */
 253
 254 u32 c4iw_pblpool_alloc(struct c4iw_rdev *rdev, int size)
 255 {
 256         unsigned long addr = gen_pool_alloc(rdev->pbl_pool, size);
 257         pr_debug("addr 0x%x size %d\n", (u32)addr, size);
 258         mutex_lock(&rdev->stats.lock);
 259         if (addr) {
 260                 rdev->stats.pbl.cur += roundup(size, 1 << MIN_PBL_SHIFT);
 261                 if (rdev->stats.pbl.cur > rdev->stats.pbl.max)
 262                         rdev->stats.pbl.max = rdev->stats.pbl.cur;
 263         } else
 264                 rdev->stats.pbl.fail++;
 265         mutex_unlock(&rdev->stats.lock);
 266         return (u32)addr;
 267 }
 268
 269 void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 270 {
 271         pr_debug("addr 0x%x size %d\n", addr, size);
 272         mutex_lock(&rdev->stats.lock);
 273         rdev->stats.pbl.cur -= roundup(size, 1 << MIN_PBL_SHIFT);
 274         mutex_unlock(&rdev->stats.lock);
 275         gen_pool_free(rdev->pbl_pool, (unsigned long)addr, size);
 276 }
 277
 278 int c4iw_pblpool_create(struct c4iw_rdev *rdev)
 279 {
 280         unsigned pbl_start, pbl_chunk, pbl_top;
 281
 282         rdev->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
 283         if (!rdev->pbl_pool)
 284                 return -ENOMEM;
 285
 286         pbl_start = rdev->lldi.vr->pbl.start;
 287         pbl_chunk = rdev->lldi.vr->pbl.size;
 288         pbl_top = pbl_start + pbl_chunk;
 289
 290         while (pbl_start < pbl_top) {
 291                 pbl_chunk = min(pbl_top - pbl_start + 1, pbl_chunk);
 292                 if (gen_pool_add(rdev->pbl_pool, pbl_start, pbl_chunk, -1)) {
 293                         pr_debug("failed to add PBL chunk (%x/%x)\n",
 294                                  pbl_start, pbl_chunk);
 295                         if (pbl_chunk <= 1024 << MIN_PBL_SHIFT) {
 296                                 pr_warn("Failed to add all PBL chunks (%x/%x)\n",
 297                                         pbl_start, pbl_top - pbl_start);
 298                                 return 0;
 299                         }
 300                         pbl_chunk >>= 1;
 301                 } else {
 302                         pr_debug("added PBL chunk (%x/%x)\n",
 303                                  pbl_start, pbl_chunk);
 304                         pbl_start += pbl_chunk;
 305                 }
 306         }
 307
 308         return 0;
 309 }
 310
 311 void c4iw_pblpool_destroy(struct c4iw_rdev *rdev)
 312 {
 313         gen_pool_destroy(rdev->pbl_pool);
 314 }
 315
 316 /*
 317  * RQT Memory Manager.  Uses Linux generic allocator.
 318  */
 319
 320 #define MIN_RQT_SHIFT 10        /* 1KB == min RQT size (16 entries) */
 321
 322 u32 c4iw_rqtpool_alloc(struct c4iw_rdev *rdev, int size)
 323 {
 324         unsigned long addr = gen_pool_alloc(rdev->rqt_pool, size << 6);
 325         pr_debug("addr 0x%x size %d\n", (u32)addr, size << 6);
 326         if (!addr)
 327                 pr_warn_ratelimited("%s: Out of RQT memory\n",
 328                                     pci_name(rdev->lldi.pdev));
 329         mutex_lock(&rdev->stats.lock);
 330         if (addr) {
 331                 rdev->stats.rqt.cur += roundup(size << 6, 1 << MIN_RQT_SHIFT);
 332                 if (rdev->stats.rqt.cur > rdev->stats.rqt.max)
 333                         rdev->stats.rqt.max = rdev->stats.rqt.cur;
 334         } else
 335                 rdev->stats.rqt.fail++;
 336         mutex_unlock(&rdev->stats.lock);
 337         return (u32)addr;
 338 }
 339
 340 void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 341 {
 342         pr_debug("addr 0x%x size %d\n", addr, size << 6);
 343         mutex_lock(&rdev->stats.lock);
 344         rdev->stats.rqt.cur -= roundup(size << 6, 1 << MIN_RQT_SHIFT);
 345         mutex_unlock(&rdev->stats.lock);
 346         gen_pool_free(rdev->rqt_pool, (unsigned long)addr, size << 6);
 347 }
 348
 349 int c4iw_rqtpool_create(struct c4iw_rdev *rdev)
 350 {
 351         unsigned rqt_start, rqt_chunk, rqt_top;
 352
 353         rdev->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1);
 354         if (!rdev->rqt_pool)
 355                 return -ENOMEM;
 356
 357         rqt_start = rdev->lldi.vr->rq.start;
 358         rqt_chunk = rdev->lldi.vr->rq.size;
 359         rqt_top = rqt_start + rqt_chunk;
 360
 361         while (rqt_start < rqt_top) {
 362                 rqt_chunk = min(rqt_top - rqt_start + 1, rqt_chunk);
 363                 if (gen_pool_add(rdev->rqt_pool, rqt_start, rqt_chunk, -1)) {
 364                         pr_debug("failed to add RQT chunk (%x/%x)\n",
 365                                  rqt_start, rqt_chunk);
 366                         if (rqt_chunk <= 1024 << MIN_RQT_SHIFT) {
 367                                 pr_warn("Failed to add all RQT chunks (%x/%x)\n",
 368                                         rqt_start, rqt_top - rqt_start);
 369                                 return 0;
 370                         }
 371                         rqt_chunk >>= 1;
 372                 } else {
 373                         pr_debug("added RQT chunk (%x/%x)\n",
 374                                  rqt_start, rqt_chunk);
 375                         rqt_start += rqt_chunk;
 376                 }
 377         }
 378         return 0;
 379 }
 380
 381 void c4iw_rqtpool_destroy(struct c4iw_rdev *rdev)
 382 {
 383         gen_pool_destroy(rdev->rqt_pool);
 384 }
 385
 386 /*
 387  * On-Chip QP Memory.
 388  */
 389 #define MIN_OCQP_SHIFT 12       /* 4KB == min ocqp size */
 390
 391 u32 c4iw_ocqp_pool_alloc(struct c4iw_rdev *rdev, int size)
 392 {
 393         unsigned long addr = gen_pool_alloc(rdev->ocqp_pool, size);
 394         pr_debug("addr 0x%x size %d\n", (u32)addr, size);
 395         if (addr) {
 396                 mutex_lock(&rdev->stats.lock);
 397                 rdev->stats.ocqp.cur += roundup(size, 1 << MIN_OCQP_SHIFT);
 398                 if (rdev->stats.ocqp.cur > rdev->stats.ocqp.max)
 399                         rdev->stats.ocqp.max = rdev->stats.ocqp.cur;
 400                 mutex_unlock(&rdev->stats.lock);
 401         }
 402         return (u32)addr;
 403 }
 404
 405 void c4iw_ocqp_pool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 406 {
 407         pr_debug("addr 0x%x size %d\n", addr, size);
 408         mutex_lock(&rdev->stats.lock);
 409         rdev->stats.ocqp.cur -= roundup(size, 1 << MIN_OCQP_SHIFT);
 410         mutex_unlock(&rdev->stats.lock);
 411         gen_pool_free(rdev->ocqp_pool, (unsigned long)addr, size);
 412 }
 413
 414 int c4iw_ocqp_pool_create(struct c4iw_rdev *rdev)
 415 {
 416         unsigned start, chunk, top;
 417
 418         rdev->ocqp_pool = gen_pool_create(MIN_OCQP_SHIFT, -1);
 419         if (!rdev->ocqp_pool)
 420                 return -ENOMEM;
 421
 422         start = rdev->lldi.vr->ocq.start;
 423         chunk = rdev->lldi.vr->ocq.size;
 424         top = start + chunk;
 425
 426         while (start < top) {
 427                 chunk = min(top - start + 1, chunk);
 428                 if (gen_pool_add(rdev->ocqp_pool, start, chunk, -1)) {
 429                         pr_debug("failed to add OCQP chunk (%x/%x)\n",
 430                                  start, chunk);
 431                         if (chunk <= 1024 << MIN_OCQP_SHIFT) {
 432                                 pr_warn("Failed to add all OCQP chunks (%x/%x)\n",
 433                                         start, top - start);
 434                                 return 0;
 435                         }
 436                         chunk >>= 1;
 437                 } else {
 438                         pr_debug("added OCQP chunk (%x/%x)\n",
 439                                  start, chunk);
 440                         start += chunk;
 441                 }
 442         }
 443         return 0;
 444 }
 445
 446 void c4iw_ocqp_pool_destroy(struct c4iw_rdev *rdev)
 447 {
 448         gen_pool_destroy(rdev->ocqp_pool);
 449 }