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
c4iw_release_dev_ucontext(struct c4iw_rdev * rdev,struct c4iw_dev_ucontext * uctx)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
c4iw_init_dev_ucontext(struct c4iw_rdev * rdev,struct c4iw_dev_ucontext * uctx)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
c4iw_rdev_open(struct c4iw_rdev * rdev)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
c4iw_rdev_close(struct c4iw_rdev * rdev)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
c4iw_dealloc(struct c4iw_dev * iwsc)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 *
c4iw_alloc(struct adapter * sc)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
c4iw_activate(struct adapter * sc)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
c4iw_deactivate(struct adapter * sc)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
c4iw_stop(struct adapter * sc)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
c4iw_restart(struct adapter * sc)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
c4iw_activate_all(struct adapter * sc,void * arg __unused)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
c4iw_deactivate_all(struct adapter * sc,void * arg __unused)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
c4iw_mod_load(void)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
c4iw_mod_unload(void)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
c4iw_modevent(module_t mod,int cmd,void * arg)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