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