sys/dev/cxgbe/iw_cxgbe/device.c

   1 /*
   2  * Copyright (c) 2009-2013 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 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include "opt_inet.h"
  36
  37 #include <sys/ktr.h>
  38
  39 #include <linux/module.h>
  40 #include <linux/moduleparam.h>
  41
  42 #include <rdma/ib_verbs.h>
  43 #include <linux/idr.h>
  44
  45 #ifdef TCP_OFFLOAD
  46 #include "iw_cxgbe.h"
  47
  48 void
  49 c4iw_release_dev_ucontext(struct c4iw_rdev *rdev,
  50     struct c4iw_dev_ucontext *uctx)
  51 {
  52         struct list_head *pos, *nxt;
  53         struct c4iw_qid_list *entry;
  54
  55         mutex_lock(&uctx->lock);
  56         list_for_each_safe(pos, nxt, &uctx->qpids) {
  57                 entry = list_entry(pos, struct c4iw_qid_list, entry);
  58                 list_del_init(&entry->entry);
  59                 if (!(entry->qid & rdev->qpmask)) {
  60                         c4iw_put_resource(&rdev->resource.qid_table,
  61                                           entry->qid);
  62                         mutex_lock(&rdev->stats.lock);
  63                         rdev->stats.qid.cur -= rdev->qpmask + 1;
  64                         mutex_unlock(&rdev->stats.lock);
  65                 }
  66                 kfree(entry);
  67         }
  68
  69         list_for_each_safe(pos, nxt, &uctx->qpids) {
  70                 entry = list_entry(pos, struct c4iw_qid_list, entry);
  71                 list_del_init(&entry->entry);
  72                 kfree(entry);
  73         }
  74         mutex_unlock(&uctx->lock);
  75 }
  76
  77 void
  78 c4iw_init_dev_ucontext(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
  79 {
  80
  81         INIT_LIST_HEAD(&uctx->qpids);
  82         INIT_LIST_HEAD(&uctx->cqids);
  83         mutex_init(&uctx->lock);
  84 }
  85
  86 static int
  87 c4iw_rdev_open(struct c4iw_rdev *rdev)
  88 {
  89         struct adapter *sc = rdev->adap;
  90         struct sge_params *sp = &sc->params.sge;
  91         int rc;
  92
  93         c4iw_init_dev_ucontext(rdev, &rdev->uctx);
  94
  95         /* XXX: we can probably make this work */
  96         if (sp->eq_s_qpp > PAGE_SHIFT || sp->iq_s_qpp > PAGE_SHIFT) {
  97                 device_printf(sc->dev,
  98                     "doorbell density too high (eq %d, iq %d, pg %d).\n",
  99                     sp->eq_s_qpp, sp->eq_s_qpp, PAGE_SHIFT);
 100                 rc = -EINVAL;
 101                 goto err1;
 102         }
 103
 104         rdev->qpshift = PAGE_SHIFT - sp->eq_s_qpp;
 105         rdev->qpmask = (1 << sp->eq_s_qpp) - 1;
 106         rdev->cqshift = PAGE_SHIFT - sp->iq_s_qpp;
 107         rdev->cqmask = (1 << sp->iq_s_qpp) - 1;
 108
 109         if (c4iw_num_stags(rdev) == 0) {
 110                 rc = -EINVAL;
 111                 goto err1;
 112         }
 113
 114         rdev->stats.pd.total = T4_MAX_NUM_PD;
 115         rdev->stats.stag.total = sc->vres.stag.size;
 116         rdev->stats.pbl.total = sc->vres.pbl.size;
 117         rdev->stats.rqt.total = sc->vres.rq.size;
 118         rdev->stats.qid.total = sc->vres.qp.size;
 119
 120         rc = c4iw_init_resource(rdev, c4iw_num_stags(rdev), T4_MAX_NUM_PD);
 121         if (rc) {
 122                 device_printf(sc->dev, "error %d initializing resources\n", rc);
 123                 goto err1;
 124         }
 125         rc = c4iw_pblpool_create(rdev);
 126         if (rc) {
 127                 device_printf(sc->dev, "error %d initializing pbl pool\n", rc);
 128                 goto err2;
 129         }
 130         rc = c4iw_rqtpool_create(rdev);
 131         if (rc) {
 132                 device_printf(sc->dev, "error %d initializing rqt pool\n", rc);
 133                 goto err3;
 134         }
 135
 136         return (0);
 137 err3:
 138         c4iw_pblpool_destroy(rdev);
 139 err2:
 140         c4iw_destroy_resource(&rdev->resource);
 141 err1:
 142         return (rc);
 143 }
 144
 145 static void c4iw_rdev_close(struct c4iw_rdev *rdev)
 146 {
 147         c4iw_pblpool_destroy(rdev);
 148         c4iw_rqtpool_destroy(rdev);
 149         c4iw_destroy_resource(&rdev->resource);
 150 }
 151
 152 static void
 153 c4iw_dealloc(struct c4iw_dev *iwsc)
 154 {
 155
 156         c4iw_rdev_close(&iwsc->rdev);
 157         idr_destroy(&iwsc->cqidr);
 158         idr_destroy(&iwsc->qpidr);
 159         idr_destroy(&iwsc->mmidr);
 160         ib_dealloc_device(&iwsc->ibdev);
 161 }
 162
 163 static struct c4iw_dev *
 164 c4iw_alloc(struct adapter *sc)
 165 {
 166         struct c4iw_dev *iwsc;
 167         int rc;
 168
 169         iwsc = (struct c4iw_dev *)ib_alloc_device(sizeof(*iwsc));
 170         if (iwsc == NULL) {
 171                 device_printf(sc->dev, "Cannot allocate ib device.\n");
 172                 return (ERR_PTR(-ENOMEM));
 173         }
 174         iwsc->rdev.adap = sc;
 175
 176         rc = c4iw_rdev_open(&iwsc->rdev);
 177         if (rc != 0) {
 178                 device_printf(sc->dev, "Unable to open CXIO rdev (%d)\n", rc);
 179                 ib_dealloc_device(&iwsc->ibdev);
 180                 return (ERR_PTR(rc));
 181         }
 182
 183         idr_init(&iwsc->cqidr);
 184         idr_init(&iwsc->qpidr);
 185         idr_init(&iwsc->mmidr);
 186         spin_lock_init(&iwsc->lock);
 187         mutex_init(&iwsc->rdev.stats.lock);
 188
 189         return (iwsc);
 190 }
 191
 192 static int c4iw_mod_load(void);
 193 static int c4iw_mod_unload(void);
 194 static int c4iw_activate(struct adapter *);
 195 static int c4iw_deactivate(struct adapter *);
 196
 197 static struct uld_info c4iw_uld_info = {
 198         .uld_id = ULD_IWARP,
 199         .activate = c4iw_activate,
 200         .deactivate = c4iw_deactivate,
 201 };
 202
 203 static int
 204 c4iw_activate(struct adapter *sc)
 205 {
 206         struct c4iw_dev *iwsc;
 207         int rc;
 208
 209         ASSERT_SYNCHRONIZED_OP(sc);
 210
 211         if (uld_active(sc, ULD_IWARP)) {
 212                 KASSERT(0, ("%s: RDMA already eanbled on sc %p", __func__, sc));
 213                 return (0);
 214         }
 215
 216         if (sc->rdmacaps == 0) {
 217                 device_printf(sc->dev,
 218                     "RDMA not supported or RDMA cap is not enabled.\n");
 219                 return (ENOSYS);
 220         }
 221
 222         iwsc = c4iw_alloc(sc);
 223         if (IS_ERR(iwsc)) {
 224                 rc = -PTR_ERR(iwsc);
 225                 device_printf(sc->dev, "initialization failed: %d\n", rc);
 226                 return (rc);
 227         }
 228
 229         sc->iwarp_softc = iwsc;
 230         c4iw_cm_init_cpl(sc);
 231
 232         rc = -c4iw_register_device(iwsc);
 233         if (rc) {
 234                 device_printf(sc->dev, "RDMA registration failed: %d\n", rc);
 235                 c4iw_dealloc(iwsc);
 236                 sc->iwarp_softc = NULL;
 237         }
 238
 239         return (rc);
 240 }
 241
 242 static int
 243 c4iw_deactivate(struct adapter *sc)
 244 {
 245         struct c4iw_dev *iwsc = sc->iwarp_softc;
 246
 247         ASSERT_SYNCHRONIZED_OP(sc);
 248
 249         c4iw_unregister_device(iwsc);
 250         c4iw_dealloc(iwsc);
 251         sc->iwarp_softc = NULL;
 252
 253         return (0);
 254 }
 255
 256 static void
 257 c4iw_activate_all(struct adapter *sc, void *arg __unused)
 258 {
 259
 260         if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwact") != 0)
 261                 return;
 262
 263         /* Activate iWARP if any port on this adapter has IFCAP_TOE enabled. */
 264         if (sc->offload_map && !uld_active(sc, ULD_IWARP))
 265                 (void) t4_activate_uld(sc, ULD_IWARP);
 266
 267         end_synchronized_op(sc, 0);
 268 }
 269
 270 static void
 271 c4iw_deactivate_all(struct adapter *sc, void *arg __unused)
 272 {
 273
 274         if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwdea") != 0)
 275                 return;
 276
 277         if (uld_active(sc, ULD_IWARP))
 278             (void) t4_deactivate_uld(sc, ULD_IWARP);
 279
 280         end_synchronized_op(sc, 0);
 281 }
 282
 283 static int
 284 c4iw_mod_load(void)
 285 {
 286         int rc;
 287
 288         rc = -c4iw_cm_init();
 289         if (rc != 0)
 290                 return (rc);
 291
 292         rc = t4_register_uld(&c4iw_uld_info);
 293         if (rc != 0) {
 294                 c4iw_cm_term();
 295                 return (rc);
 296         }
 297
 298         t4_iterate(c4iw_activate_all, NULL);
 299
 300         return (rc);
 301 }
 302
 303 static int
 304 c4iw_mod_unload(void)
 305 {
 306
 307         t4_iterate(c4iw_deactivate_all, NULL);
 308
 309         c4iw_cm_term();
 310
 311         if (t4_unregister_uld(&c4iw_uld_info) == EBUSY)
 312                 return (EBUSY);
 313
 314         return (0);
 315 }
 316
 317 #endif
 318 #undef MODULE_VERSION
 319 #include <sys/module.h>
 320
 321 /*
 322  * t4_tom won't load on kernels without TCP_OFFLOAD and this module's dependency
 323  * on t4_tom ensures that it won't either.  So we don't directly check for
 324  * TCP_OFFLOAD here.
 325  */
 326 static int
 327 c4iw_modevent(module_t mod, int cmd, void *arg)
 328 {
 329         int rc = 0;
 330
 331 #ifdef TCP_OFFLOAD
 332         switch (cmd) {
 333         case MOD_LOAD:
 334                 rc = c4iw_mod_load();
 335                 if (rc == 0)
 336                         printf("iw_cxgbe: Chelsio T4/T5 RDMA driver loaded.\n");
 337                 break;
 338
 339         case MOD_UNLOAD:
 340                 rc = c4iw_mod_unload();
 341                 break;
 342
 343         default:
 344                 rc = EINVAL;
 345         }
 346 #else
 347         printf("t4_tom: compiled without TCP_OFFLOAD support.\n");
 348         rc = EOPNOTSUPP;
 349 #endif
 350         return (rc);
 351 }
 352
 353 static moduledata_t c4iw_mod_data = {
 354         "iw_cxgbe",
 355         c4iw_modevent,
 356         0
 357 };
 358
 359 MODULE_VERSION(iw_cxgbe, 1);
 360 MODULE_DEPEND(iw_cxgbe, t4nex, 1, 1, 1);
 361 MODULE_DEPEND(iw_cxgbe, t4_tom, 1, 1, 1);
 362 MODULE_DEPEND(iw_cxgbe, ibcore, 1, 1, 1);
 363 DECLARE_MODULE(iw_cxgbe, c4iw_mod_data, SI_SUB_EXEC, SI_ORDER_ANY);