drivers/infiniband/hw/cxgb3/cxio_resource.c

   1 /*
   2  * Copyright (c) 2006 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/kernel.h>
  34 #include <linux/random.h>
  35 #include <linux/slab.h>
  36 #include <linux/kfifo.h>
  37 #include <linux/spinlock.h>
  38 #include <linux/errno.h>
  39 #include "cxio_resource.h"
  40 #include "cxio_hal.h"
  41
  42 static struct kfifo *rhdl_fifo;
  43 static spinlock_t rhdl_fifo_lock;
  44
  45 #define RANDOM_SIZE 16
  46
  47 static int __cxio_init_resource_fifo(struct kfifo **fifo,
  48                                    spinlock_t *fifo_lock,
  49                                    u32 nr, u32 skip_low,
  50                                    u32 skip_high,
  51                                    int random)
  52 {
  53         u32 i, j, entry = 0, idx;
  54         u32 random_bytes;
  55         u32 rarray[16];
  56         spin_lock_init(fifo_lock);
  57
  58         *fifo = kfifo_alloc(nr * sizeof(u32), GFP_KERNEL, fifo_lock);
  59         if (IS_ERR(*fifo))
  60                 return -ENOMEM;
  61
  62         for (i = 0; i < skip_low + skip_high; i++)
  63                 __kfifo_put(*fifo, (unsigned char *) &entry, sizeof(u32));
  64         if (random) {
  65                 j = 0;
  66                 random_bytes = random32();
  67                 for (i = 0; i < RANDOM_SIZE; i++)
  68                         rarray[i] = i + skip_low;
  69                 for (i = skip_low + RANDOM_SIZE; i < nr - skip_high; i++) {
  70                         if (j >= RANDOM_SIZE) {
  71                                 j = 0;
  72                                 random_bytes = random32();
  73                         }
  74                         idx = (random_bytes >> (j * 2)) & 0xF;
  75                         __kfifo_put(*fifo,
  76                                 (unsigned char *) &rarray[idx],
  77                                 sizeof(u32));
  78                         rarray[idx] = i;
  79                         j++;
  80                 }
  81                 for (i = 0; i < RANDOM_SIZE; i++)
  82                         __kfifo_put(*fifo,
  83                                 (unsigned char *) &rarray[i],
  84                                 sizeof(u32));
  85         } else
  86                 for (i = skip_low; i < nr - skip_high; i++)
  87                         __kfifo_put(*fifo, (unsigned char *) &i, sizeof(u32));
  88
  89         for (i = 0; i < skip_low + skip_high; i++)
  90                 kfifo_get(*fifo, (unsigned char *) &entry, sizeof(u32));
  91         return 0;
  92 }
  93
  94 static int cxio_init_resource_fifo(struct kfifo **fifo, spinlock_t * fifo_lock,
  95                                    u32 nr, u32 skip_low, u32 skip_high)
  96 {
  97         return (__cxio_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
  98                                           skip_high, 0));
  99 }
 100
 101 static int cxio_init_resource_fifo_random(struct kfifo **fifo,
 102                                    spinlock_t * fifo_lock,
 103                                    u32 nr, u32 skip_low, u32 skip_high)
 104 {
 105
 106         return (__cxio_init_resource_fifo(fifo, fifo_lock, nr, skip_low,
 107                                           skip_high, 1));
 108 }
 109
 110 static int cxio_init_qpid_fifo(struct cxio_rdev *rdev_p)
 111 {
 112         u32 i;
 113
 114         spin_lock_init(&rdev_p->rscp->qpid_fifo_lock);
 115
 116         rdev_p->rscp->qpid_fifo = kfifo_alloc(T3_MAX_NUM_QP * sizeof(u32),
 117                                               GFP_KERNEL,
 118                                               &rdev_p->rscp->qpid_fifo_lock);
 119         if (IS_ERR(rdev_p->rscp->qpid_fifo))
 120                 return -ENOMEM;
 121
 122         for (i = 16; i < T3_MAX_NUM_QP; i++)
 123                 if (!(i & rdev_p->qpmask))
 124                         __kfifo_put(rdev_p->rscp->qpid_fifo,
 125                                     (unsigned char *) &i, sizeof(u32));
 126         return 0;
 127 }
 128
 129 int cxio_hal_init_rhdl_resource(u32 nr_rhdl)
 130 {
 131         return cxio_init_resource_fifo(&rhdl_fifo, &rhdl_fifo_lock, nr_rhdl, 1,
 132                                        0);
 133 }
 134
 135 void cxio_hal_destroy_rhdl_resource(void)
 136 {
 137         kfifo_free(rhdl_fifo);
 138 }
 139
 140 /* nr_* must be power of 2 */
 141 int cxio_hal_init_resource(struct cxio_rdev *rdev_p,
 142                            u32 nr_tpt, u32 nr_pbl,
 143                            u32 nr_rqt, u32 nr_qpid, u32 nr_cqid, u32 nr_pdid)
 144 {
 145         int err = 0;
 146         struct cxio_hal_resource *rscp;
 147
 148         rscp = kmalloc(sizeof(*rscp), GFP_KERNEL);
 149         if (!rscp)
 150                 return -ENOMEM;
 151         rdev_p->rscp = rscp;
 152         err = cxio_init_resource_fifo_random(&rscp->tpt_fifo,
 153                                       &rscp->tpt_fifo_lock,
 154                                       nr_tpt, 1, 0);
 155         if (err)
 156                 goto tpt_err;
 157         err = cxio_init_qpid_fifo(rdev_p);
 158         if (err)
 159                 goto qpid_err;
 160         err = cxio_init_resource_fifo(&rscp->cqid_fifo, &rscp->cqid_fifo_lock,
 161                                       nr_cqid, 1, 0);
 162         if (err)
 163                 goto cqid_err;
 164         err = cxio_init_resource_fifo(&rscp->pdid_fifo, &rscp->pdid_fifo_lock,
 165                                       nr_pdid, 1, 0);
 166         if (err)
 167                 goto pdid_err;
 168         return 0;
 169 pdid_err:
 170         kfifo_free(rscp->cqid_fifo);
 171 cqid_err:
 172         kfifo_free(rscp->qpid_fifo);
 173 qpid_err:
 174         kfifo_free(rscp->tpt_fifo);
 175 tpt_err:
 176         return -ENOMEM;
 177 }
 178
 179 /*
 180  * returns 0 if no resource available
 181  */
 182 static u32 cxio_hal_get_resource(struct kfifo *fifo)
 183 {
 184         u32 entry;
 185         if (kfifo_get(fifo, (unsigned char *) &entry, sizeof(u32)))
 186                 return entry;
 187         else
 188                 return 0;       /* fifo emptry */
 189 }
 190
 191 static void cxio_hal_put_resource(struct kfifo *fifo, u32 entry)
 192 {
 193         BUG_ON(kfifo_put(fifo, (unsigned char *) &entry, sizeof(u32)) == 0);
 194 }
 195
 196 u32 cxio_hal_get_stag(struct cxio_hal_resource *rscp)
 197 {
 198         return cxio_hal_get_resource(rscp->tpt_fifo);
 199 }
 200
 201 void cxio_hal_put_stag(struct cxio_hal_resource *rscp, u32 stag)
 202 {
 203         cxio_hal_put_resource(rscp->tpt_fifo, stag);
 204 }
 205
 206 u32 cxio_hal_get_qpid(struct cxio_hal_resource *rscp)
 207 {
 208         u32 qpid = cxio_hal_get_resource(rscp->qpid_fifo);
 209         PDBG("%s qpid 0x%x\n", __FUNCTION__, qpid);
 210         return qpid;
 211 }
 212
 213 void cxio_hal_put_qpid(struct cxio_hal_resource *rscp, u32 qpid)
 214 {
 215         PDBG("%s qpid 0x%x\n", __FUNCTION__, qpid);
 216         cxio_hal_put_resource(rscp->qpid_fifo, qpid);
 217 }
 218
 219 u32 cxio_hal_get_cqid(struct cxio_hal_resource *rscp)
 220 {
 221         return cxio_hal_get_resource(rscp->cqid_fifo);
 222 }
 223
 224 void cxio_hal_put_cqid(struct cxio_hal_resource *rscp, u32 cqid)
 225 {
 226         cxio_hal_put_resource(rscp->cqid_fifo, cqid);
 227 }
 228
 229 u32 cxio_hal_get_pdid(struct cxio_hal_resource *rscp)
 230 {
 231         return cxio_hal_get_resource(rscp->pdid_fifo);
 232 }
 233
 234 void cxio_hal_put_pdid(struct cxio_hal_resource *rscp, u32 pdid)
 235 {
 236         cxio_hal_put_resource(rscp->pdid_fifo, pdid);
 237 }
 238
 239 void cxio_hal_destroy_resource(struct cxio_hal_resource *rscp)
 240 {
 241         kfifo_free(rscp->tpt_fifo);
 242         kfifo_free(rscp->cqid_fifo);
 243         kfifo_free(rscp->qpid_fifo);
 244         kfifo_free(rscp->pdid_fifo);
 245         kfree(rscp);
 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 #define PBL_CHUNK 2*1024*1024
 254
 255 u32 cxio_hal_pblpool_alloc(struct cxio_rdev *rdev_p, int size)
 256 {
 257         unsigned long addr = gen_pool_alloc(rdev_p->pbl_pool, size);
 258         PDBG("%s addr 0x%x size %d\n", __FUNCTION__, (u32)addr, size);
 259         return (u32)addr;
 260 }
 261
 262 void cxio_hal_pblpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
 263 {
 264         PDBG("%s addr 0x%x size %d\n", __FUNCTION__, addr, size);
 265         gen_pool_free(rdev_p->pbl_pool, (unsigned long)addr, size);
 266 }
 267
 268 int cxio_hal_pblpool_create(struct cxio_rdev *rdev_p)
 269 {
 270         unsigned long i;
 271         rdev_p->pbl_pool = gen_pool_create(MIN_PBL_SHIFT, -1);
 272         if (rdev_p->pbl_pool)
 273                 for (i = rdev_p->rnic_info.pbl_base;
 274                      i <= rdev_p->rnic_info.pbl_top - PBL_CHUNK + 1;
 275                      i += PBL_CHUNK)
 276                         gen_pool_add(rdev_p->pbl_pool, i, PBL_CHUNK, -1);
 277         return rdev_p->pbl_pool ? 0 : -ENOMEM;
 278 }
 279
 280 void cxio_hal_pblpool_destroy(struct cxio_rdev *rdev_p)
 281 {
 282         gen_pool_destroy(rdev_p->pbl_pool);
 283 }
 284
 285 /*
 286  * RQT Memory Manager.  Uses Linux generic allocator.
 287  */
 288
 289 #define MIN_RQT_SHIFT 10        /* 1KB == mini RQT size (16 entries) */
 290 #define RQT_CHUNK 2*1024*1024
 291
 292 u32 cxio_hal_rqtpool_alloc(struct cxio_rdev *rdev_p, int size)
 293 {
 294         unsigned long addr = gen_pool_alloc(rdev_p->rqt_pool, size << 6);
 295         PDBG("%s addr 0x%x size %d\n", __FUNCTION__, (u32)addr, size << 6);
 296         return (u32)addr;
 297 }
 298
 299 void cxio_hal_rqtpool_free(struct cxio_rdev *rdev_p, u32 addr, int size)
 300 {
 301         PDBG("%s addr 0x%x size %d\n", __FUNCTION__, addr, size << 6);
 302         gen_pool_free(rdev_p->rqt_pool, (unsigned long)addr, size << 6);
 303 }
 304
 305 int cxio_hal_rqtpool_create(struct cxio_rdev *rdev_p)
 306 {
 307         unsigned long i;
 308         rdev_p->rqt_pool = gen_pool_create(MIN_RQT_SHIFT, -1);
 309         if (rdev_p->rqt_pool)
 310                 for (i = rdev_p->rnic_info.rqt_base;
 311                      i <= rdev_p->rnic_info.rqt_top - RQT_CHUNK + 1;
 312                      i += RQT_CHUNK)
 313                         gen_pool_add(rdev_p->rqt_pool, i, RQT_CHUNK, -1);
 314         return rdev_p->rqt_pool ? 0 : -ENOMEM;
 315 }
 316
 317 void cxio_hal_rqtpool_destroy(struct cxio_rdev *rdev_p)
 318 {
 319         gen_pool_destroy(rdev_p->rqt_pool);
 320 }