device.c revision 346923 
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: stable/11/sys/dev/cxgbe/iw_cxgbe/device.c 346923 2019-04-29 20:10:28Z np $");
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
48void
49c4iw_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
77void
78c4iw_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
86static int
87c4iw_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);
174err5:
175	free_page((unsigned long)rdev->status_page);
176err4:
177	c4iw_rqtpool_destroy(rdev);
178err3:
179	c4iw_pblpool_destroy(rdev);
180err2:
181	c4iw_destroy_resource(&rdev->resource);
182err1:
183	return (rc);
184}
185
186static 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
194static void
195c4iw_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
205static struct c4iw_dev *
206c4iw_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
258static int c4iw_mod_load(void);
259static int c4iw_mod_unload(void);
260static int c4iw_activate(struct adapter *);
261static int c4iw_deactivate(struct adapter *);
262
263static struct uld_info c4iw_uld_info = {
264	.uld_id = ULD_IWARP,
265	.activate = c4iw_activate,
266	.deactivate = c4iw_deactivate,
267};
268
269static int
270c4iw_activate(struct adapter *sc)
271{
272	struct c4iw_dev *iwsc;
273	int rc;
274
275	ASSERT_SYNCHRONIZED_OP(sc);
276
277	if (is_t4(sc)) {
278		device_printf(sc->dev, "No iWARP support for T4 devices, "
279				"please install T5 or above devices.\n");
280		return (ENOSYS);
281	}
282
283	if (uld_active(sc, ULD_IWARP)) {
284		KASSERT(0, ("%s: RDMA already eanbled on sc %p", __func__, sc));
285		return (0);
286	}
287
288	if (sc->rdmacaps == 0) {
289		device_printf(sc->dev,
290		    "RDMA not supported or RDMA cap is not enabled.\n");
291		return (ENOSYS);
292	}
293
294	iwsc = c4iw_alloc(sc);
295	if (IS_ERR(iwsc)) {
296		rc = -PTR_ERR(iwsc);
297		device_printf(sc->dev, "initialization failed: %d\n", rc);
298		return (rc);
299	}
300
301	sc->iwarp_softc = iwsc;
302
303	rc = -c4iw_register_device(iwsc);
304	if (rc) {
305		device_printf(sc->dev, "RDMA registration failed: %d\n", rc);
306		c4iw_dealloc(iwsc);
307		sc->iwarp_softc = NULL;
308	}
309
310	return (rc);
311}
312
313static int
314c4iw_deactivate(struct adapter *sc)
315{
316	struct c4iw_dev *iwsc = sc->iwarp_softc;
317
318	ASSERT_SYNCHRONIZED_OP(sc);
319
320	c4iw_unregister_device(iwsc);
321	c4iw_dealloc(iwsc);
322	sc->iwarp_softc = NULL;
323
324	return (0);
325}
326
327static void
328c4iw_activate_all(struct adapter *sc, void *arg __unused)
329{
330
331	if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwact") != 0)
332		return;
333
334	/* Activate iWARP if any port on this adapter has IFCAP_TOE enabled. */
335	if (sc->offload_map && !uld_active(sc, ULD_IWARP))
336		(void) t4_activate_uld(sc, ULD_IWARP);
337
338	end_synchronized_op(sc, 0);
339}
340
341static void
342c4iw_deactivate_all(struct adapter *sc, void *arg __unused)
343{
344
345	if (begin_synchronized_op(sc, NULL, SLEEP_OK | INTR_OK, "t4iwdea") != 0)
346		return;
347
348	if (uld_active(sc, ULD_IWARP))
349	    (void) t4_deactivate_uld(sc, ULD_IWARP);
350
351	end_synchronized_op(sc, 0);
352}
353
354static int
355c4iw_mod_load(void)
356{
357	int rc;
358
359	rc = -c4iw_cm_init();
360	if (rc != 0)
361		return (rc);
362
363	rc = t4_register_uld(&c4iw_uld_info);
364	if (rc != 0) {
365		c4iw_cm_term();
366		return (rc);
367	}
368
369	t4_iterate(c4iw_activate_all, NULL);
370
371	return (rc);
372}
373
374static int
375c4iw_mod_unload(void)
376{
377
378	t4_iterate(c4iw_deactivate_all, NULL);
379
380	c4iw_cm_term();
381
382	if (t4_unregister_uld(&c4iw_uld_info) == EBUSY)
383		return (EBUSY);
384
385	return (0);
386}
387
388#endif
389
390/*
391 * t4_tom won't load on kernels without TCP_OFFLOAD and this module's dependency
392 * on t4_tom ensures that it won't either.  So we don't directly check for
393 * TCP_OFFLOAD here.
394 */
395static int
396c4iw_modevent(module_t mod, int cmd, void *arg)
397{
398	int rc = 0;
399
400#ifdef TCP_OFFLOAD
401	switch (cmd) {
402	case MOD_LOAD:
403		rc = c4iw_mod_load();
404		if (rc == 0)
405			printf("iw_cxgbe: Chelsio T5/T6 RDMA driver loaded.\n");
406		break;
407
408	case MOD_UNLOAD:
409		rc = c4iw_mod_unload();
410		break;
411
412	default:
413		rc = EINVAL;
414	}
415#else
416	printf("t4_tom: compiled without TCP_OFFLOAD support.\n");
417	rc = EOPNOTSUPP;
418#endif
419	return (rc);
420}
421
422static moduledata_t c4iw_mod_data = {
423	"iw_cxgbe",
424	c4iw_modevent,
425	0
426};
427
428MODULE_VERSION(iw_cxgbe, 1);
429MODULE_DEPEND(iw_cxgbe, t4nex, 1, 1, 1);
430MODULE_DEPEND(iw_cxgbe, t4_tom, 1, 1, 1);
431MODULE_DEPEND(iw_cxgbe, ibcore, 1, 1, 1);
432MODULE_DEPEND(iw_cxgbe, linuxkpi, 1, 1, 1);
433DECLARE_MODULE(iw_cxgbe, c4iw_mod_data, SI_SUB_EXEC, SI_ORDER_ANY);
434