1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause 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 #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->cqids) { 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 unsigned short ucq_density = 1 << sp->iq_s_qpp; /* # of user CQs/page */ 93 unsigned short udb_density = 1 << sp->eq_s_qpp; /* # of user DB/page */ 94 95 96 c4iw_init_dev_ucontext(rdev, &rdev->uctx); 97 98 /* 99 * This implementation assumes udb_density == ucq_density! Eventually 100 * we might need to support this but for now fail the open. Also the 101 * cqid and qpid range must match for now. 102 */ 103 if (udb_density != ucq_density) { 104 device_printf(sc->dev, "unsupported udb/ucq densities %u/%u\n", 105 udb_density, ucq_density); 106 rc = -EINVAL; 107 goto err1; 108 } 109 if (sc->vres.qp.start != sc->vres.cq.start || 110 sc->vres.qp.size != sc->vres.cq.size) { 111 device_printf(sc->dev, "%s: unsupported qp and cq id ranges " 112 "qp start %u size %u cq start %u size %u\n", __func__, 113 sc->vres.qp.start, sc->vres.qp.size, sc->vres.cq.start, 114 sc->vres.cq.size); 115 rc = -EINVAL; 116 goto err1; 117 } 118 119 rdev->qpshift = PAGE_SHIFT - sp->eq_s_qpp; 120 rdev->qpmask = udb_density - 1; 121 rdev->cqshift = PAGE_SHIFT - sp->iq_s_qpp; 122 rdev->cqmask = ucq_density - 1; 123 124 if (c4iw_num_stags(rdev) == 0) { 125 rc = -EINVAL; 126 goto err1; 127 } 128 129 rdev->stats.pd.total = T4_MAX_NUM_PD; 130 rdev->stats.stag.total = sc->vres.stag.size; 131 rdev->stats.pbl.total = sc->vres.pbl.size; 132 rdev->stats.rqt.total = sc->vres.rq.size; 133 rdev->stats.qid.total = sc->vres.qp.size; 134 135 rc = c4iw_init_resource(rdev, c4iw_num_stags(rdev), T4_MAX_NUM_PD); 136 if (rc) { 137 device_printf(sc->dev, "error %d initializing resources\n", rc); 138 goto err1; 139 } 140 rc = c4iw_pblpool_create(rdev); 141 if (rc) { 142 device_printf(sc->dev, "error %d initializing pbl pool\n", rc); 143 goto err2; 144 } 145 rc = c4iw_rqtpool_create(rdev); 146 if (rc) { 147 device_printf(sc->dev, "error %d initializing rqt pool\n", rc); 148 goto err3; 149 } 150 rdev->status_page = (struct t4_dev_status_page *) 151 __get_free_page(GFP_KERNEL); 152 if (!rdev->status_page) { 153 rc = -ENOMEM; 154 goto err4; 155 } 156 rdev->status_page->qp_start = sc->vres.qp.start; 157 rdev->status_page->qp_size = sc->vres.qp.size; 158 rdev->status_page->cq_start = sc->vres.cq.start; 159 rdev->status_page->cq_size = sc->vres.cq.size; 160 161 /* T5 and above devices don't need Doorbell recovery logic, 162 * so db_off is always set to '0'. 163 */ 164 rdev->status_page->db_off = 0; 165 166 rdev->status_page->wc_supported = rdev->adap->iwt.wc_en; 167 168 rdev->free_workq = create_singlethread_workqueue("iw_cxgb4_free"); 169 if (!rdev->free_workq) { 170 rc = -ENOMEM; 171 goto err5; 172 } 173 return (0); 174 err5: 175 free_page((unsigned long)rdev->status_page); 176 err4: 177 c4iw_rqtpool_destroy(rdev); 178 err3: 179 c4iw_pblpool_destroy(rdev); 180 err2: 181 c4iw_destroy_resource(&rdev->resource); 182 err1: 183 return (rc); 184 } 185 186 static void c4iw_rdev_close(struct c4iw_rdev *rdev) 187 { 188 free_page((unsigned long)rdev->status_page); 189 c4iw_pblpool_destroy(rdev); 190 c4iw_rqtpool_destroy(rdev); 191 c4iw_destroy_resource(&rdev->resource); 192 } 193 194 static void 195 c4iw_dealloc(struct c4iw_dev *iwsc) 196 { 197 198 c4iw_rdev_close(&iwsc->rdev); 199 idr_destroy(&iwsc->cqidr); 200 idr_destroy(&iwsc->qpidr); 201 idr_destroy(&iwsc->mmidr); 202 ib_dealloc_device(&iwsc->ibdev); 203 } 204 205 static struct c4iw_dev * 206 c4iw_alloc(struct adapter *sc) 207 { 208 struct c4iw_dev *iwsc; 209 int rc; 210 211 iwsc = (struct c4iw_dev *)ib_alloc_device(sizeof(*iwsc)); 212 if (iwsc == NULL) { 213 device_printf(sc->dev, "Cannot allocate ib device.\n"); 214 return (ERR_PTR(-ENOMEM)); 215 } 216 iwsc->rdev.adap = sc; 217 218 /* init various hw-queue params based on lld info */ 219 iwsc->rdev.hw_queue.t4_eq_status_entries = 220 sc->params.sge.spg_len / EQ_ESIZE; 221 iwsc->rdev.hw_queue.t4_max_eq_size = 65520; 222 iwsc->rdev.hw_queue.t4_max_iq_size = 65520; 223 iwsc->rdev.hw_queue.t4_max_rq_size = 8192 - 224 iwsc->rdev.hw_queue.t4_eq_status_entries - 1; 225 iwsc->rdev.hw_queue.t4_max_sq_size = 226 iwsc->rdev.hw_queue.t4_max_eq_size - 227 iwsc->rdev.hw_queue.t4_eq_status_entries - 1; 228 iwsc->rdev.hw_queue.t4_max_qp_depth = 229 iwsc->rdev.hw_queue.t4_max_rq_size; 230 iwsc->rdev.hw_queue.t4_max_cq_depth = 231 iwsc->rdev.hw_queue.t4_max_iq_size - 2; 232 iwsc->rdev.hw_queue.t4_stat_len = iwsc->rdev.adap->params.sge.spg_len; 233 234 /* As T5 and above devices support BAR2 kernel doorbells & WC, we map 235 * all of BAR2, for both User and Kernel Doorbells-GTS. 236 */ 237 iwsc->rdev.bar2_kva = (void __iomem *)((u64)iwsc->rdev.adap->udbs_base); 238 iwsc->rdev.bar2_pa = vtophys(iwsc->rdev.adap->udbs_base); 239 iwsc->rdev.bar2_len = rman_get_size(iwsc->rdev.adap->udbs_res); 240 241 rc = c4iw_rdev_open(&iwsc->rdev); 242 if (rc != 0) { 243 device_printf(sc->dev, "Unable to open CXIO rdev (%d)\n", rc); 244 ib_dealloc_device(&iwsc->ibdev); 245 return (ERR_PTR(rc)); 246 } 247 248 idr_init(&iwsc->cqidr); 249 idr_init(&iwsc->qpidr); 250 idr_init(&iwsc->mmidr); 251 spin_lock_init(&iwsc->lock); 252 mutex_init(&iwsc->rdev.stats.lock); 253 iwsc->avail_ird = iwsc->rdev.adap->params.max_ird_adapter; 254 255 return (iwsc); 256 } 257 258 static int c4iw_mod_load(void); 259 static int c4iw_mod_unload(void); 260 static int c4iw_activate(struct adapter *); 261 static int c4iw_deactivate(struct adapter *); 262 static int c4iw_stop(struct adapter *); 263 static int c4iw_restart(struct adapter *); 264 265 static struct uld_info c4iw_uld_info = { 266 .uld_activate = c4iw_activate, 267 .uld_deactivate = c4iw_deactivate, 268 .uld_stop = c4iw_stop, 269 .uld_restart = c4iw_restart, 270 }; 271 272 static int 273 c4iw_activate(struct adapter *sc) 274 { 275 struct c4iw_dev *iwsc; 276 int rc; 277 278 ASSERT_SYNCHRONIZED_OP(sc); 279 280 if (is_t4(sc)) { 281 device_printf(sc->dev, "No iWARP support for T4 devices, " 282 "please install T5 or above devices.\n"); 283 return (ENOSYS); 284 } 285 286 if (uld_active(sc, ULD_IWARP)) { 287 KASSERT(0, ("%s: RDMA already enabled on sc %p", __func__, sc)); 288 return (0); 289 } 290 291 if (sc->rdmacaps == 0) { 292 device_printf(sc->dev, 293 "RDMA not supported or RDMA cap is not enabled.\n"); 294 return (ENOSYS); 295 } 296 297 iwsc = c4iw_alloc(sc); 298 if (IS_ERR(iwsc)) { 299 rc = -PTR_ERR(iwsc); 300 device_printf(sc->dev, "initialization failed: %d\n", rc); 301 return (rc); 302 } 303 304 sc->iwarp_softc = iwsc; 305 306 rc = -c4iw_register_device(iwsc); 307 if (rc) { 308 device_printf(sc->dev, "RDMA registration failed: %d\n", rc); 309 c4iw_dealloc(iwsc); 310 sc->iwarp_softc = NULL; 311 } 312 313 return (rc); 314 } 315 316 static int 317 c4iw_deactivate(struct adapter *sc) 318 { 319 struct c4iw_dev *iwsc = sc->iwarp_softc; 320 321 ASSERT_SYNCHRONIZED_OP(sc); 322 323 c4iw_unregister_device(iwsc); 324 c4iw_dealloc(iwsc); 325 sc->iwarp_softc = NULL; 326 327 return (0); 328 } 329 330 static int 331 c4iw_stop(struct adapter *sc) 332 { 333 struct c4iw_dev *iwsc = sc->iwarp_softc; 334 335 if (iwsc) { 336 struct ib_event event = {0}; 337 338 device_printf(sc->dev, "iWARP driver stopped.\n"); 339 iwsc->rdev.flags |= T4_IW_STOPPED; 340 event.event = IB_EVENT_DEVICE_FATAL; 341 event.device = &iwsc->ibdev; 342 ib_dispatch_event(&event); 343 } 344 345 return (0); 346 } 347 348 static int 349 c4iw_restart(struct adapter *sc) 350 { 351 struct c4iw_dev *iwsc = sc->iwarp_softc; 352 353 if (iwsc) { 354 device_printf(sc->dev, "iWARP driver restarted.\n"); 355 iwsc->rdev.flags &= ~T4_IW_STOPPED; 356 } 357 return (0); 358 } 359 360 static void 361 c4iw_activate_all(struct adapter *sc, void *arg __unused) 362 { 363 364 if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwact") != 0) 365 return; 366 367 /* Activate iWARP if any port on this adapter has IFCAP_TOE enabled. */ 368 if (sc->offload_map && !uld_active(sc, ULD_IWARP)) 369 (void) t4_activate_uld(sc, ULD_IWARP); 370 371 end_synchronized_op(sc, 0); 372 } 373 374 static void 375 c4iw_deactivate_all(struct adapter *sc, void *arg __unused) 376 { 377 378 if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwdea") != 0) 379 return; 380 381 if (uld_active(sc, ULD_IWARP)) 382 (void) t4_deactivate_uld(sc, ULD_IWARP); 383 384 end_synchronized_op(sc, 0); 385 } 386 387 static int 388 c4iw_mod_load(void) 389 { 390 int rc; 391 392 rc = -c4iw_cm_init(); 393 if (rc != 0) 394 return (rc); 395 396 rc = t4_register_uld(&c4iw_uld_info, ULD_IWARP); 397 if (rc != 0) { 398 c4iw_cm_term(); 399 return (rc); 400 } 401 402 t4_iterate(c4iw_activate_all, NULL); 403 404 return (rc); 405 } 406 407 static int 408 c4iw_mod_unload(void) 409 { 410 411 t4_iterate(c4iw_deactivate_all, NULL); 412 413 c4iw_cm_term(); 414 415 if (t4_unregister_uld(&c4iw_uld_info, ULD_IWARP) == EBUSY) 416 return (EBUSY); 417 418 return (0); 419 } 420 421 #endif 422 423 /* 424 * t4_tom won't load on kernels without TCP_OFFLOAD and this module's dependency 425 * on t4_tom ensures that it won't either. So we don't directly check for 426 * TCP_OFFLOAD here. 427 */ 428 static int 429 c4iw_modevent(module_t mod, int cmd, void *arg) 430 { 431 int rc = 0; 432 433 #ifdef TCP_OFFLOAD 434 switch (cmd) { 435 case MOD_LOAD: 436 rc = c4iw_mod_load(); 437 if (rc == 0) 438 printf("iw_cxgbe: Chelsio T5/T6 RDMA driver loaded.\n"); 439 break; 440 441 case MOD_UNLOAD: 442 rc = c4iw_mod_unload(); 443 break; 444 445 default: 446 rc = EINVAL; 447 } 448 #else 449 printf("t4_tom: compiled without TCP_OFFLOAD support.\n"); 450 rc = EOPNOTSUPP; 451 #endif 452 return (rc); 453 } 454 455 static moduledata_t c4iw_mod_data = { 456 "iw_cxgbe", 457 c4iw_modevent, 458 0 459 }; 460 461 MODULE_VERSION(iw_cxgbe, 1); 462 MODULE_DEPEND(iw_cxgbe, t4nex, 1, 1, 1); 463 MODULE_DEPEND(iw_cxgbe, t4_tom, 1, 1, 1); 464 MODULE_DEPEND(iw_cxgbe, ibcore, 1, 1, 1); 465 MODULE_DEPEND(iw_cxgbe, linuxkpi, 1, 1, 1); 466 DECLARE_MODULE(iw_cxgbe, c4iw_mod_data, SI_SUB_EXEC, SI_ORDER_ANY); 467