2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
4 * Copyright (c) 2009-2013 Chelsio, Inc. All rights reserved.
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:
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
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.
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
34 #include <sys/cdefs.h>
35 __FBSDID("$FreeBSD$");
41 #include <linux/module.h>
42 #include <linux/moduleparam.h>
44 #include <rdma/ib_verbs.h>
45 #include <linux/idr.h>
51 c4iw_release_dev_ucontext(struct c4iw_rdev *rdev,
52 struct c4iw_dev_ucontext *uctx)
54 struct list_head *pos, *nxt;
55 struct c4iw_qid_list *entry;
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,
64 mutex_lock(&rdev->stats.lock);
65 rdev->stats.qid.cur -= rdev->qpmask + 1;
66 mutex_unlock(&rdev->stats.lock);
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);
76 mutex_unlock(&uctx->lock);
80 c4iw_init_dev_ucontext(struct c4iw_rdev *rdev, struct c4iw_dev_ucontext *uctx)
83 INIT_LIST_HEAD(&uctx->qpids);
84 INIT_LIST_HEAD(&uctx->cqids);
85 mutex_init(&uctx->lock);
89 c4iw_rdev_open(struct c4iw_rdev *rdev)
91 struct adapter *sc = rdev->adap;
92 struct sge_params *sp = &sc->params.sge;
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 */
98 c4iw_init_dev_ucontext(rdev, &rdev->uctx);
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.
105 if (udb_density != ucq_density) {
106 device_printf(sc->dev, "unsupported udb/ucq densities %u/%u\n",
107 udb_density, ucq_density);
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,
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);
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);
143 if (c4iw_num_stags(rdev) == 0) {
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;
154 rc = c4iw_init_resource(rdev, c4iw_num_stags(rdev), T4_MAX_NUM_PD);
156 device_printf(sc->dev, "error %d initializing resources\n", rc);
159 rc = c4iw_pblpool_create(rdev);
161 device_printf(sc->dev, "error %d initializing pbl pool\n", rc);
164 rc = c4iw_rqtpool_create(rdev);
166 device_printf(sc->dev, "error %d initializing rqt pool\n", rc);
169 rdev->status_page = (struct t4_dev_status_page *)
170 __get_free_page(GFP_KERNEL);
171 if (!rdev->status_page) {
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;
180 /* T5 and above devices don't need Doorbell recovery logic,
181 * so db_off is always set to '0'.
183 rdev->status_page->db_off = 0;
185 rdev->status_page->wc_supported = rdev->adap->iwt.wc_en;
187 rdev->free_workq = create_singlethread_workqueue("iw_cxgb4_free");
188 if (!rdev->free_workq) {
194 free_page((unsigned long)rdev->status_page);
196 c4iw_rqtpool_destroy(rdev);
198 c4iw_pblpool_destroy(rdev);
200 c4iw_destroy_resource(&rdev->resource);
205 static void c4iw_rdev_close(struct c4iw_rdev *rdev)
207 free_page((unsigned long)rdev->status_page);
208 c4iw_pblpool_destroy(rdev);
209 c4iw_rqtpool_destroy(rdev);
210 c4iw_destroy_resource(&rdev->resource);
214 c4iw_dealloc(struct c4iw_dev *iwsc)
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);
224 static struct c4iw_dev *
225 c4iw_alloc(struct adapter *sc)
227 struct c4iw_dev *iwsc;
230 iwsc = (struct c4iw_dev *)ib_alloc_device(sizeof(*iwsc));
232 device_printf(sc->dev, "Cannot allocate ib device.\n");
233 return (ERR_PTR(-ENOMEM));
235 iwsc->rdev.adap = sc;
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);
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;
258 /* As T5 and above devices support BAR2 kernel doorbells & WC, we map
259 * all of BAR2, for both User and Kernel Doorbells-GTS.
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);
265 rc = c4iw_rdev_open(&iwsc->rdev);
267 device_printf(sc->dev, "Unable to open CXIO rdev (%d)\n", rc);
268 ib_dealloc_device(&iwsc->ibdev);
269 return (ERR_PTR(rc));
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;
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 *);
287 static struct uld_info c4iw_uld_info = {
289 .activate = c4iw_activate,
290 .deactivate = c4iw_deactivate,
294 c4iw_activate(struct adapter *sc)
296 struct c4iw_dev *iwsc;
299 ASSERT_SYNCHRONIZED_OP(sc);
302 device_printf(sc->dev, "No iWARP support for T4 devices, "
303 "please install T5 or above devices.\n");
307 if (uld_active(sc, ULD_IWARP)) {
308 KASSERT(0, ("%s: RDMA already eanbled on sc %p", __func__, sc));
312 if (sc->rdmacaps == 0) {
313 device_printf(sc->dev,
314 "RDMA not supported or RDMA cap is not enabled.\n");
318 iwsc = c4iw_alloc(sc);
321 device_printf(sc->dev, "initialization failed: %d\n", rc);
325 sc->iwarp_softc = iwsc;
327 rc = -c4iw_register_device(iwsc);
329 device_printf(sc->dev, "RDMA registration failed: %d\n", rc);
331 sc->iwarp_softc = NULL;
338 c4iw_deactivate(struct adapter *sc)
340 struct c4iw_dev *iwsc = sc->iwarp_softc;
342 ASSERT_SYNCHRONIZED_OP(sc);
344 c4iw_unregister_device(iwsc);
346 sc->iwarp_softc = NULL;
352 c4iw_activate_all(struct adapter *sc, void *arg __unused)
355 if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwact") != 0)
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);
362 end_synchronized_op(sc, 0);
366 c4iw_deactivate_all(struct adapter *sc, void *arg __unused)
369 if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwdea") != 0)
372 if (uld_active(sc, ULD_IWARP))
373 (void) t4_deactivate_uld(sc, ULD_IWARP);
375 end_synchronized_op(sc, 0);
383 rc = -c4iw_cm_init();
387 rc = t4_register_uld(&c4iw_uld_info);
393 t4_iterate(c4iw_activate_all, NULL);
399 c4iw_mod_unload(void)
402 t4_iterate(c4iw_deactivate_all, NULL);
406 if (t4_unregister_uld(&c4iw_uld_info) == EBUSY)
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
420 c4iw_modevent(module_t mod, int cmd, void *arg)
427 rc = c4iw_mod_load();
429 printf("iw_cxgbe: Chelsio T5/T6 RDMA driver loaded.\n");
433 rc = c4iw_mod_unload();
440 printf("t4_tom: compiled without TCP_OFFLOAD support.\n");
446 static moduledata_t c4iw_mod_data = {
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);