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         PDBG("%s entry 0x%x\n", __func__, 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         PDBG("%s qid 0x%x\n", __func__, 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         PDBG("%s qid 0x%x\n", __func__, 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         PDBG("%s qid 0x%x\n", __func__, 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         PDBG("%s qid 0x%x\n", __func__, 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         PDBG("%s addr 0x%x size %d\n", __func__, (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                 kref_get(&rdev->pbl_kref);
 264         } else
 265                 rdev->stats.pbl.fail++;
 266         mutex_unlock(&rdev->stats.lock);
 267         return (u32)addr;
 268 }
 269
 270 static void destroy_pblpool(struct kref *kref)
 271 {
 272         struct c4iw_rdev *rdev;
 273
 274         rdev = container_of(kref, struct c4iw_rdev, pbl_kref);
 275         gen_pool_destroy(rdev->pbl_pool);
 276         complete(&rdev->pbl_compl);
 277 }
 278
 279 void c4iw_pblpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 280 {
 281         PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
 282         mutex_lock(&rdev->stats.lock);
 283         rdev->stats.pbl.cur -= roundup(size, 1 << MIN_PBL_SHIFT);
 284         mutex_unlock(&rdev->stats.lock);
 285         gen_pool_free(rdev->pbl_pool, (unsigned long)addr, size);
 286         kref_put(&rdev->pbl_kref, destroy_pblpool);
 287 }
 288
 289 int c4iw_pblpool_create(struct c4iw_rdev *rdev)
 290 {
 291         unsigned pbl_start, pbl_chunk, pbl_top;
 292
 293         rdev->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
 294         if (!rdev->pbl_pool)
 295                 return -ENOMEM;
 296
 297         pbl_start = rdev->lldi.vr->pbl.start;
 298         pbl_chunk = rdev->lldi.vr->pbl.size;
 299         pbl_top = pbl_start + pbl_chunk;
 300
 301         while (pbl_start < pbl_top) {
 302                 pbl_chunk = min(pbl_top - pbl_start + 1, pbl_chunk);
 303                 if (gen_pool_add(rdev->pbl_pool, pbl_start, pbl_chunk, -1)) {
 304                         PDBG("%s failed to add PBL chunk (%x/%x)\n",
 305                              __func__, pbl_start, pbl_chunk);
 306                         if (pbl_chunk <= 1024 << MIN_PBL_SHIFT) {
 307                                 printk(KERN_WARNING MOD
 308                                        "Failed to add all PBL chunks (%x/%x)\n",
 309                                        pbl_start,
 310                                        pbl_top - pbl_start);
 311                                 return 0;
 312                         }
 313                         pbl_chunk >>= 1;
 314                 } else {
 315                         PDBG("%s added PBL chunk (%x/%x)\n",
 316                              __func__, pbl_start, pbl_chunk);
 317                         pbl_start += pbl_chunk;
 318                 }
 319         }
 320
 321         return 0;
 322 }
 323
 324 void c4iw_pblpool_destroy(struct c4iw_rdev *rdev)
 325 {
 326         kref_put(&rdev->pbl_kref, destroy_pblpool);
 327 }
 328
 329 /*
 330  * RQT Memory Manager.  Uses Linux generic allocator.
 331  */
 332
 333 #define MIN_RQT_SHIFT 10        /* 1KB == min RQT size (16 entries) */
 334
 335 u32 c4iw_rqtpool_alloc(struct c4iw_rdev *rdev, int size)
 336 {
 337         unsigned long addr = gen_pool_alloc(rdev->rqt_pool, size << 6);
 338         PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size << 6);
 339         if (!addr)
 340                 pr_warn_ratelimited(MOD "%s: Out of RQT memory\n",
 341                                     pci_name(rdev->lldi.pdev));
 342         mutex_lock(&rdev->stats.lock);
 343         if (addr) {
 344                 rdev->stats.rqt.cur += roundup(size << 6, 1 << MIN_RQT_SHIFT);
 345                 if (rdev->stats.rqt.cur > rdev->stats.rqt.max)
 346                         rdev->stats.rqt.max = rdev->stats.rqt.cur;
 347                 kref_get(&rdev->rqt_kref);
 348         } else
 349                 rdev->stats.rqt.fail++;
 350         mutex_unlock(&rdev->stats.lock);
 351         return (u32)addr;
 352 }
 353
 354 static void destroy_rqtpool(struct kref *kref)
 355 {
 356         struct c4iw_rdev *rdev;
 357
 358         rdev = container_of(kref, struct c4iw_rdev, rqt_kref);
 359         gen_pool_destroy(rdev->rqt_pool);
 360         complete(&rdev->rqt_compl);
 361 }
 362
 363 void c4iw_rqtpool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 364 {
 365         PDBG("%s addr 0x%x size %d\n", __func__, addr, size << 6);
 366         mutex_lock(&rdev->stats.lock);
 367         rdev->stats.rqt.cur -= roundup(size << 6, 1 << MIN_RQT_SHIFT);
 368         mutex_unlock(&rdev->stats.lock);
 369         gen_pool_free(rdev->rqt_pool, (unsigned long)addr, size << 6);
 370         kref_put(&rdev->rqt_kref, destroy_rqtpool);
 371 }
 372
 373 int c4iw_rqtpool_create(struct c4iw_rdev *rdev)
 374 {
 375         unsigned rqt_start, rqt_chunk, rqt_top;
 376
 377         rdev->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1);
 378         if (!rdev->rqt_pool)
 379                 return -ENOMEM;
 380
 381         rqt_start = rdev->lldi.vr->rq.start;
 382         rqt_chunk = rdev->lldi.vr->rq.size;
 383         rqt_top = rqt_start + rqt_chunk;
 384
 385         while (rqt_start < rqt_top) {
 386                 rqt_chunk = min(rqt_top - rqt_start + 1, rqt_chunk);
 387                 if (gen_pool_add(rdev->rqt_pool, rqt_start, rqt_chunk, -1)) {
 388                         PDBG("%s failed to add RQT chunk (%x/%x)\n",
 389                              __func__, rqt_start, rqt_chunk);
 390                         if (rqt_chunk <= 1024 << MIN_RQT_SHIFT) {
 391                                 printk(KERN_WARNING MOD
 392                                        "Failed to add all RQT chunks (%x/%x)\n",
 393                                        rqt_start, rqt_top - rqt_start);
 394                                 return 0;
 395                         }
 396                         rqt_chunk >>= 1;
 397                 } else {
 398                         PDBG("%s added RQT chunk (%x/%x)\n",
 399                              __func__, rqt_start, rqt_chunk);
 400                         rqt_start += rqt_chunk;
 401                 }
 402         }
 403         return 0;
 404 }
 405
 406 void c4iw_rqtpool_destroy(struct c4iw_rdev *rdev)
 407 {
 408         kref_put(&rdev->rqt_kref, destroy_rqtpool);
 409 }
 410
 411 /*
 412  * On-Chip QP Memory.
 413  */
 414 #define MIN_OCQP_SHIFT 12       /* 4KB == min ocqp size */
 415
 416 u32 c4iw_ocqp_pool_alloc(struct c4iw_rdev *rdev, int size)
 417 {
 418         unsigned long addr = gen_pool_alloc(rdev->ocqp_pool, size);
 419         PDBG("%s addr 0x%x size %d\n", __func__, (u32)addr, size);
 420         if (addr) {
 421                 mutex_lock(&rdev->stats.lock);
 422                 rdev->stats.ocqp.cur += roundup(size, 1 << MIN_OCQP_SHIFT);
 423                 if (rdev->stats.ocqp.cur > rdev->stats.ocqp.max)
 424                         rdev->stats.ocqp.max = rdev->stats.ocqp.cur;
 425                 mutex_unlock(&rdev->stats.lock);
 426         }
 427         return (u32)addr;
 428 }
 429
 430 void c4iw_ocqp_pool_free(struct c4iw_rdev *rdev, u32 addr, int size)
 431 {
 432         PDBG("%s addr 0x%x size %d\n", __func__, addr, size);
 433         mutex_lock(&rdev->stats.lock);
 434         rdev->stats.ocqp.cur -= roundup(size, 1 << MIN_OCQP_SHIFT);
 435         mutex_unlock(&rdev->stats.lock);
 436         gen_pool_free(rdev->ocqp_pool, (unsigned long)addr, size);
 437 }
 438
 439 int c4iw_ocqp_pool_create(struct c4iw_rdev *rdev)
 440 {
 441         unsigned start, chunk, top;
 442
 443         rdev->ocqp_pool = gen_pool_create(MIN_OCQP_SHIFT, -1);
 444         if (!rdev->ocqp_pool)
 445                 return -ENOMEM;
 446
 447         start = rdev->lldi.vr->ocq.start;
 448         chunk = rdev->lldi.vr->ocq.size;
 449         top = start + chunk;
 450
 451         while (start < top) {
 452                 chunk = min(top - start + 1, chunk);
 453                 if (gen_pool_add(rdev->ocqp_pool, start, chunk, -1)) {
 454                         PDBG("%s failed to add OCQP chunk (%x/%x)\n",
 455                              __func__, start, chunk);
 456                         if (chunk <= 1024 << MIN_OCQP_SHIFT) {
 457                                 printk(KERN_WARNING MOD
 458                                        "Failed to add all OCQP chunks (%x/%x)\n",
 459                                        start, top - start);
 460                                 return 0;
 461                         }
 462                         chunk >>= 1;
 463                 } else {
 464                         PDBG("%s added OCQP chunk (%x/%x)\n",
 465                              __func__, start, chunk);
 466                         start += chunk;
 467                 }
 468         }
 469         return 0;
 470 }
 471
 472 void c4iw_ocqp_pool_destroy(struct c4iw_rdev *rdev)
 473 {
 474         gen_pool_destroy(rdev->ocqp_pool);
 475 }