1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2009-2013 Chelsio, Inc. All rights reserved. 5 * 6 * This software is available to you under a choice of one of two 7 * licenses. You may choose to be licensed under the terms of the GNU 8 * General Public License (GPL) Version 2, available from the file 9 * COPYING in the main directory of this source tree, or the 10 * OpenIB.org BSD license below: 11 * 12 * Redistribution and use in source and binary forms, with or 13 * without modification, are permitted provided that the following 14 * conditions are met: 15 * 16 * - Redistributions of source code must retain the above 17 * copyright notice, this list of conditions and the following 18 * disclaimer. 19 * 20 * - Redistributions in binary form must reproduce the above 21 * copyright notice, this list of conditions and the following 22 * disclaimer in the documentation and/or other materials 23 * provided with the distribution. 24 * 25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, 26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN 30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN 31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 32 * SOFTWARE. 33 */ 34 #include <sys/cdefs.h> 35 __FBSDID("$FreeBSD$"); 36 37 #include "opt_inet.h" 38 39 #include <sys/ktr.h> 40 41 #include <linux/module.h> 42 #include <linux/moduleparam.h> 43 44 #include <rdma/ib_verbs.h> 45 #include <linux/idr.h> 46 47 #ifdef TCP_OFFLOAD 48 #include "iw_cxgbe.h" 49 50 void 51 c4iw_release_dev_ucontext(struct c4iw_rdev *rdev, 52 struct c4iw_dev_ucontext *uctx) 53 { 54 struct list_head *pos, *nxt; 55 struct c4iw_qid_list *entry; 56 57 mutex_lock(&uctx->lock); 58 list_for_each_safe(pos, nxt, &uctx->qpids) { 59 entry = list_entry(pos, struct c4iw_qid_list, entry); 60 list_del_init(&entry->entry); 61 if (!(entry->qid & rdev->qpmask)) { 62 c4iw_put_resource(&rdev->resource.qid_table, 63 entry->qid); 64 mutex_lock(&rdev->stats.lock); 65 rdev->stats.qid.cur -= rdev->qpmask + 1; 66 mutex_unlock(&rdev->stats.lock); 67 } 68 kfree(entry); 69 } 70 71 list_for_each_safe(pos, nxt, &uctx->cqids) { 72 entry = list_entry(pos, struct c4iw_qid_list, entry); 73 list_del_init(&entry->entry); 74 kfree(entry); 75 } 76 mutex_unlock(&uctx->lock); 77 } 78 79 void 80 c4iw_init_dev_ucontext(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx) 81 { 82 83 INIT_LIST_HEAD(&uctx->qpids); 84 INIT_LIST_HEAD(&uctx->cqids); 85 mutex_init(&uctx->lock); 86 } 87 88 static int 89 c4iw_rdev_open(struct c4iw_rdev *rdev) 90 { 91 struct adapter *sc = rdev->adap; 92 struct sge_params *sp = &sc->params.sge; 93 int rc; 94 unsigned short ucq_density = 1 << sp->iq_s_qpp; /* # of user CQs/page */ 95 unsigned short udb_density = 1 << sp->eq_s_qpp; /* # of user DB/page */ 96 97 98 c4iw_init_dev_ucontext(rdev, &rdev->uctx); 99 100 /* 101 * This implementation assumes udb_density == ucq_density! Eventually 102 * we might need to support this but for now fail the open. Also the 103 * cqid and qpid range must match for now. 104 */ 105 if (udb_density != ucq_density) { 106 device_printf(sc->dev, "unsupported udb/ucq densities %u/%u\n", 107 udb_density, ucq_density); 108 rc = -EINVAL; 109 goto err1; 110 } 111 if (sc->vres.qp.start != sc->vres.cq.start || 112 sc->vres.qp.size != sc->vres.cq.size) { 113 device_printf(sc->dev, "%s: unsupported qp and cq id ranges " 114 "qp start %u size %u cq start %u size %u\n", __func__, 115 sc->vres.qp.start, sc->vres.qp.size, sc->vres.cq.start, 116 sc->vres.cq.size); 117 rc = -EINVAL; 118 goto err1; 119 } 120 121 rdev->qpshift = PAGE_SHIFT - sp->eq_s_qpp; 122 rdev->qpmask = udb_density - 1; 123 rdev->cqshift = PAGE_SHIFT - sp->iq_s_qpp; 124 rdev->cqmask = ucq_density - 1; 125 CTR5(KTR_IW_CXGBE, "%s dev %s stag start 0x%0x size 0x%0x num stags %d", 126 __func__, device_get_nameunit(sc->dev), sc->vres.stag.start, 127 sc->vres.stag.size, c4iw_num_stags(rdev)); 128 CTR5(KTR_IW_CXGBE, "%s pbl start 0x%0x size 0x%0x" 129 " rq start 0x%0x size 0x%0x", __func__, 130 sc->vres.pbl.start, sc->vres.pbl.size, 131 sc->vres.rq.start, sc->vres.rq.size); 132 CTR5(KTR_IW_CXGBE, "%s:qp qid start %u size %u cq qid start %u size %u", 133 __func__, sc->vres.qp.start, sc->vres.qp.size, 134 sc->vres.cq.start, sc->vres.cq.size); 135 /*TODO 136 CTR5(KTR_IW_CXGBE, "%s udb %pR db_reg %p gts_reg %p" 137 "qpmask 0x%x cqmask 0x%x", __func__, 138 db_reg,gts_reg,rdev->qpmask, rdev->cqmask); 139 */ 140 141 142 143 if (c4iw_num_stags(rdev) == 0) { 144 rc = -EINVAL; 145 goto err1; 146 } 147 148 rdev->stats.pd.total = T4_MAX_NUM_PD; 149 rdev->stats.stag.total = sc->vres.stag.size; 150 rdev->stats.pbl.total = sc->vres.pbl.size; 151 rdev->stats.rqt.total = sc->vres.rq.size; 152 rdev->stats.qid.total = sc->vres.qp.size; 153 154 rc = c4iw_init_resource(rdev, c4iw_num_stags(rdev), T4_MAX_NUM_PD); 155 if (rc) { 156 device_printf(sc->dev, "error %d initializing resources\n", rc); 157 goto err1; 158 } 159 rc = c4iw_pblpool_create(rdev); 160 if (rc) { 161 device_printf(sc->dev, "error %d initializing pbl pool\n", rc); 162 goto err2; 163 } 164 rc = c4iw_rqtpool_create(rdev); 165 if (rc) { 166 device_printf(sc->dev, "error %d initializing rqt pool\n", rc); 167 goto err3; 168 } 169 rdev->status_page = (struct t4_dev_status_page *) 170 __get_free_page(GFP_KERNEL); 171 if (!rdev->status_page) { 172 rc = -ENOMEM; 173 goto err4; 174 } 175 rdev->status_page->qp_start = sc->vres.qp.start; 176 rdev->status_page->qp_size = sc->vres.qp.size; 177 rdev->status_page->cq_start = sc->vres.cq.start; 178 rdev->status_page->cq_size = sc->vres.cq.size; 179 180 /* T5 and above devices don't need Doorbell recovery logic, 181 * so db_off is always set to '0'. 182 */ 183 rdev->status_page->db_off = 0; 184 185 rdev->status_page->wc_supported = rdev->adap->iwt.wc_en; 186 187 rdev->free_workq = create_singlethread_workqueue("iw_cxgb4_free"); 188 if (!rdev->free_workq) { 189 rc = -ENOMEM; 190 goto err5; 191 } 192 return (0); 193 err5: 194 free_page((unsigned long)rdev->status_page); 195 err4: 196 c4iw_rqtpool_destroy(rdev); 197 err3: 198 c4iw_pblpool_destroy(rdev); 199 err2: 200 c4iw_destroy_resource(&rdev->resource); 201 err1: 202 return (rc); 203 } 204 205 static void c4iw_rdev_close(struct c4iw_rdev *rdev) 206 { 207 free_page((unsigned long)rdev->status_page); 208 c4iw_pblpool_destroy(rdev); 209 c4iw_rqtpool_destroy(rdev); 210 c4iw_destroy_resource(&rdev->resource); 211 } 212 213 static void 214 c4iw_dealloc(struct c4iw_dev *iwsc) 215 { 216 217 c4iw_rdev_close(&iwsc->rdev); 218 idr_destroy(&iwsc->cqidr); 219 idr_destroy(&iwsc->qpidr); 220 idr_destroy(&iwsc->mmidr); 221 ib_dealloc_device(&iwsc->ibdev); 222 } 223 224 static struct c4iw_dev * 225 c4iw_alloc(struct adapter *sc) 226 { 227 struct c4iw_dev *iwsc; 228 int rc; 229 230 iwsc = (struct c4iw_dev *)ib_alloc_device(sizeof(*iwsc)); 231 if (iwsc == NULL) { 232 device_printf(sc->dev, "Cannot allocate ib device.\n"); 233 return (ERR_PTR(-ENOMEM)); 234 } 235 iwsc->rdev.adap = sc; 236 237 /* init various hw-queue params based on lld info */ 238 CTR3(KTR_IW_CXGBE, "%s: Ing. padding boundary is %d, " 239 "egrsstatuspagesize = %d", __func__, 240 sc->params.sge.pad_boundary, 241 sc->params.sge.spg_len); 242 243 iwsc->rdev.hw_queue.t4_eq_status_entries = 244 sc->params.sge.spg_len / EQ_ESIZE; 245 iwsc->rdev.hw_queue.t4_max_eq_size = 65520; 246 iwsc->rdev.hw_queue.t4_max_iq_size = 65520; 247 iwsc->rdev.hw_queue.t4_max_rq_size = 8192 - 248 iwsc->rdev.hw_queue.t4_eq_status_entries - 1; 249 iwsc->rdev.hw_queue.t4_max_sq_size = 250 iwsc->rdev.hw_queue.t4_max_eq_size - 251 iwsc->rdev.hw_queue.t4_eq_status_entries - 1; 252 iwsc->rdev.hw_queue.t4_max_qp_depth = 253 iwsc->rdev.hw_queue.t4_max_rq_size; 254 iwsc->rdev.hw_queue.t4_max_cq_depth = 255 iwsc->rdev.hw_queue.t4_max_iq_size - 2; 256 iwsc->rdev.hw_queue.t4_stat_len = iwsc->rdev.adap->params.sge.spg_len; 257 258 /* As T5 and above devices support BAR2 kernel doorbells & WC, we map 259 * all of BAR2, for both User and Kernel Doorbells-GTS. 260 */ 261 iwsc->rdev.bar2_kva = (void __iomem *)((u64)iwsc->rdev.adap->udbs_base); 262 iwsc->rdev.bar2_pa = vtophys(iwsc->rdev.adap->udbs_base); 263 iwsc->rdev.bar2_len = rman_get_size(iwsc->rdev.adap->udbs_res); 264 265 rc = c4iw_rdev_open(&iwsc->rdev); 266 if (rc != 0) { 267 device_printf(sc->dev, "Unable to open CXIO rdev (%d)\n", rc); 268 ib_dealloc_device(&iwsc->ibdev); 269 return (ERR_PTR(rc)); 270 } 271 272 idr_init(&iwsc->cqidr); 273 idr_init(&iwsc->qpidr); 274 idr_init(&iwsc->mmidr); 275 spin_lock_init(&iwsc->lock); 276 mutex_init(&iwsc->rdev.stats.lock); 277 iwsc->avail_ird = iwsc->rdev.adap->params.max_ird_adapter; 278 279 return (iwsc); 280 } 281 282 static int c4iw_mod_load(void); 283 static int c4iw_mod_unload(void); 284 static int c4iw_activate(struct adapter *); 285 static int c4iw_deactivate(struct adapter *); 286 287 static struct uld_info c4iw_uld_info = { 288 .uld_id = ULD_IWARP, 289 .activate = c4iw_activate, 290 .deactivate = c4iw_deactivate, 291 }; 292 293 static int 294 c4iw_activate(struct adapter *sc) 295 { 296 struct c4iw_dev *iwsc; 297 int rc; 298 299 ASSERT_SYNCHRONIZED_OP(sc); 300 301 if (is_t4(sc)) { 302 device_printf(sc->dev, "No iWARP support for T4 devices, " 303 "please install T5 or above devices.\n"); 304 return (ENOSYS); 305 } 306 307 if (uld_active(sc, ULD_IWARP)) { 308 KASSERT(0, ("%s: RDMA already eanbled on sc %p", __func__, sc)); 309 return (0); 310 } 311 312 if (sc->rdmacaps == 0) { 313 device_printf(sc->dev, 314 "RDMA not supported or RDMA cap is not enabled.\n"); 315 return (ENOSYS); 316 } 317 318 iwsc = c4iw_alloc(sc); 319 if (IS_ERR(iwsc)) { 320 rc = -PTR_ERR(iwsc); 321 device_printf(sc->dev, "initialization failed: %d\n", rc); 322 return (rc); 323 } 324 325 sc->iwarp_softc = iwsc; 326 327 rc = -c4iw_register_device(iwsc); 328 if (rc) { 329 device_printf(sc->dev, "RDMA registration failed: %d\n", rc); 330 c4iw_dealloc(iwsc); 331 sc->iwarp_softc = NULL; 332 } 333 334 return (rc); 335 } 336 337 static int 338 c4iw_deactivate(struct adapter *sc) 339 { 340 struct c4iw_dev *iwsc = sc->iwarp_softc; 341 342 ASSERT_SYNCHRONIZED_OP(sc); 343 344 c4iw_unregister_device(iwsc); 345 c4iw_dealloc(iwsc); 346 sc->iwarp_softc = NULL; 347 348 return (0); 349 } 350 351 static void 352 c4iw_activate_all(struct adapter *sc, void *arg __unused) 353 { 354 355 if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwact") != 0) 356 return; 357 358 /* Activate iWARP if any port on this adapter has IFCAP_TOE enabled. */ 359 if (sc->offload_map && !uld_active(sc, ULD_IWARP)) 360 (void) t4_activate_uld(sc, ULD_IWARP); 361 362 end_synchronized_op(sc, 0); 363 } 364 365 static void 366 c4iw_deactivate_all(struct adapter *sc, void *arg __unused) 367 { 368 369 if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwdea") != 0) 370 return; 371 372 if (uld_active(sc, ULD_IWARP)) 373 (void) t4_deactivate_uld(sc, ULD_IWARP); 374 375 end_synchronized_op(sc, 0); 376 } 377 378 static int 379 c4iw_mod_load(void) 380 { 381 int rc; 382 383 rc = -c4iw_cm_init(); 384 if (rc != 0) 385 return (rc); 386 387 rc = t4_register_uld(&c4iw_uld_info); 388 if (rc != 0) { 389 c4iw_cm_term(); 390 return (rc); 391 } 392 393 t4_iterate(c4iw_activate_all, NULL); 394 395 return (rc); 396 } 397 398 static int 399 c4iw_mod_unload(void) 400 { 401 402 t4_iterate(c4iw_deactivate_all, NULL); 403 404 c4iw_cm_term(); 405 406 if (t4_unregister_uld(&c4iw_uld_info) == EBUSY) 407 return (EBUSY); 408 409 return (0); 410 } 411 412 #endif 413 414 /* 415 * t4_tom won't load on kernels without TCP_OFFLOAD and this module's dependency 416 * on t4_tom ensures that it won't either. So we don't directly check for 417 * TCP_OFFLOAD here. 418 */ 419 static int 420 c4iw_modevent(module_t mod, int cmd, void *arg) 421 { 422 int rc = 0; 423 424 #ifdef TCP_OFFLOAD 425 switch (cmd) { 426 case MOD_LOAD: 427 rc = c4iw_mod_load(); 428 if (rc == 0) 429 printf("iw_cxgbe: Chelsio T5/T6 RDMA driver loaded.\n"); 430 break; 431 432 case MOD_UNLOAD: 433 rc = c4iw_mod_unload(); 434 break; 435 436 default: 437 rc = EINVAL; 438 } 439 #else 440 printf("t4_tom: compiled without TCP_OFFLOAD support.\n"); 441 rc = EOPNOTSUPP; 442 #endif 443 return (rc); 444 } 445 446 static moduledata_t c4iw_mod_data = { 447 "iw_cxgbe", 448 c4iw_modevent, 449 0 450 }; 451 452 MODULE_VERSION(iw_cxgbe, 1); 453 MODULE_DEPEND(iw_cxgbe, t4nex, 1, 1, 1); 454 MODULE_DEPEND(iw_cxgbe, t4_tom, 1, 1, 1); 455 MODULE_DEPEND(iw_cxgbe, ibcore, 1, 1, 1); 456 MODULE_DEPEND(iw_cxgbe, linuxkpi, 1, 1, 1); 457 DECLARE_MODULE(iw_cxgbe, c4iw_mod_data, SI_SUB_EXEC, SI_ORDER_ANY); 458