1 /* Broadcom NetXtreme-C/E network driver.
2  *
3  * Copyright (c) 2016-2018 Broadcom Limited
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation.
8  */
9 
10 #include <linux/module.h>
11 
12 #include <linux/kernel.h>
13 #include <linux/errno.h>
14 #include <linux/interrupt.h>
15 #include <linux/pci.h>
16 #include <linux/netdevice.h>
17 #include <linux/rtnetlink.h>
18 #include <linux/bitops.h>
19 #include <linux/irq.h>
20 #include <asm/byteorder.h>
21 #include <linux/bitmap.h>
22 #include <linux/auxiliary_bus.h>
23 
24 #include "bnxt_hsi.h"
25 #include "bnxt.h"
26 #include "bnxt_hwrm.h"
27 #include "bnxt_ulp.h"
28 
29 static DEFINE_IDA(bnxt_aux_dev_ids);
30 
bnxt_fill_msix_vecs(struct bnxt * bp,struct bnxt_msix_entry * ent)31 static void bnxt_fill_msix_vecs(struct bnxt *bp, struct bnxt_msix_entry *ent)
32 {
33 	struct bnxt_en_dev *edev = bp->edev;
34 	int num_msix, idx, i;
35 
36 	if (!edev->ulp_tbl->msix_requested) {
37 		netdev_warn(bp->dev, "Requested MSI-X vectors insufficient\n");
38 		return;
39 	}
40 	num_msix = edev->ulp_tbl->msix_requested;
41 	idx = edev->ulp_tbl->msix_base;
42 	for (i = 0; i < num_msix; i++) {
43 		ent[i].vector = bp->irq_tbl[idx + i].vector;
44 		ent[i].ring_idx = idx + i;
45 		if (bp->flags & BNXT_FLAG_CHIP_P5) {
46 			ent[i].db_offset = DB_PF_OFFSET_P5;
47 			if (BNXT_VF(bp))
48 				ent[i].db_offset = DB_VF_OFFSET_P5;
49 		} else {
50 			ent[i].db_offset = (idx + i) * 0x80;
51 		}
52 	}
53 }
54 
bnxt_register_dev(struct bnxt_en_dev * edev,struct bnxt_ulp_ops * ulp_ops,void * handle)55 int bnxt_register_dev(struct bnxt_en_dev *edev,
56 		      struct bnxt_ulp_ops *ulp_ops,
57 		      void *handle)
58 {
59 	struct net_device *dev = edev->net;
60 	struct bnxt *bp = netdev_priv(dev);
61 	unsigned int max_stat_ctxs;
62 	struct bnxt_ulp *ulp;
63 
64 	max_stat_ctxs = bnxt_get_max_func_stat_ctxs(bp);
65 	if (max_stat_ctxs <= BNXT_MIN_ROCE_STAT_CTXS ||
66 	    bp->cp_nr_rings == max_stat_ctxs)
67 		return -ENOMEM;
68 
69 	ulp = edev->ulp_tbl;
70 	if (!ulp)
71 		return -ENOMEM;
72 
73 	ulp->handle = handle;
74 	rcu_assign_pointer(ulp->ulp_ops, ulp_ops);
75 
76 	if (test_bit(BNXT_STATE_OPEN, &bp->state))
77 		bnxt_hwrm_vnic_cfg(bp, 0);
78 
79 	bnxt_fill_msix_vecs(bp, bp->edev->msix_entries);
80 	edev->flags |= BNXT_EN_FLAG_MSIX_REQUESTED;
81 	return 0;
82 }
83 EXPORT_SYMBOL(bnxt_register_dev);
84 
bnxt_unregister_dev(struct bnxt_en_dev * edev)85 void bnxt_unregister_dev(struct bnxt_en_dev *edev)
86 {
87 	struct net_device *dev = edev->net;
88 	struct bnxt *bp = netdev_priv(dev);
89 	struct bnxt_ulp *ulp;
90 	int i = 0;
91 
92 	ulp = edev->ulp_tbl;
93 	if (ulp->msix_requested)
94 		edev->flags &= ~BNXT_EN_FLAG_MSIX_REQUESTED;
95 
96 	if (ulp->max_async_event_id)
97 		bnxt_hwrm_func_drv_rgtr(bp, NULL, 0, true);
98 
99 	RCU_INIT_POINTER(ulp->ulp_ops, NULL);
100 	synchronize_rcu();
101 	ulp->max_async_event_id = 0;
102 	ulp->async_events_bmap = NULL;
103 	while (atomic_read(&ulp->ref_count) != 0 && i < 10) {
104 		msleep(100);
105 		i++;
106 	}
107 	return;
108 }
109 EXPORT_SYMBOL(bnxt_unregister_dev);
110 
bnxt_get_ulp_msix_num(struct bnxt * bp)111 int bnxt_get_ulp_msix_num(struct bnxt *bp)
112 {
113 	u32 roce_msix = BNXT_VF(bp) ?
114 			BNXT_MAX_VF_ROCE_MSIX : BNXT_MAX_ROCE_MSIX;
115 
116 	return ((bp->flags & BNXT_FLAG_ROCE_CAP) ?
117 		min_t(u32, roce_msix, num_online_cpus()) : 0);
118 }
119 
bnxt_get_ulp_msix_base(struct bnxt * bp)120 int bnxt_get_ulp_msix_base(struct bnxt *bp)
121 {
122 	if (bnxt_ulp_registered(bp->edev)) {
123 		struct bnxt_en_dev *edev = bp->edev;
124 
125 		if (edev->ulp_tbl->msix_requested)
126 			return edev->ulp_tbl->msix_base;
127 	}
128 	return 0;
129 }
130 
bnxt_get_ulp_stat_ctxs(struct bnxt * bp)131 int bnxt_get_ulp_stat_ctxs(struct bnxt *bp)
132 {
133 	if (bnxt_ulp_registered(bp->edev)) {
134 		struct bnxt_en_dev *edev = bp->edev;
135 
136 		if (edev->ulp_tbl->msix_requested)
137 			return BNXT_MIN_ROCE_STAT_CTXS;
138 	}
139 
140 	return 0;
141 }
142 
bnxt_send_msg(struct bnxt_en_dev * edev,struct bnxt_fw_msg * fw_msg)143 int bnxt_send_msg(struct bnxt_en_dev *edev,
144 			 struct bnxt_fw_msg *fw_msg)
145 {
146 	struct net_device *dev = edev->net;
147 	struct bnxt *bp = netdev_priv(dev);
148 	struct output *resp;
149 	struct input *req;
150 	u32 resp_len;
151 	int rc;
152 
153 	if (bp->fw_reset_state)
154 		return -EBUSY;
155 
156 	rc = hwrm_req_init(bp, req, 0 /* don't care */);
157 	if (rc)
158 		return rc;
159 
160 	rc = hwrm_req_replace(bp, req, fw_msg->msg, fw_msg->msg_len);
161 	if (rc)
162 		return rc;
163 
164 	hwrm_req_timeout(bp, req, fw_msg->timeout);
165 	resp = hwrm_req_hold(bp, req);
166 	rc = hwrm_req_send(bp, req);
167 	resp_len = le16_to_cpu(resp->resp_len);
168 	if (resp_len) {
169 		if (fw_msg->resp_max_len < resp_len)
170 			resp_len = fw_msg->resp_max_len;
171 
172 		memcpy(fw_msg->resp, resp, resp_len);
173 	}
174 	hwrm_req_drop(bp, req);
175 	return rc;
176 }
177 EXPORT_SYMBOL(bnxt_send_msg);
178 
bnxt_ulp_stop(struct bnxt * bp)179 void bnxt_ulp_stop(struct bnxt *bp)
180 {
181 	struct bnxt_aux_priv *aux_priv = bp->aux_priv;
182 	struct bnxt_en_dev *edev = bp->edev;
183 
184 	if (!edev)
185 		return;
186 
187 	edev->flags |= BNXT_EN_FLAG_ULP_STOPPED;
188 	if (aux_priv) {
189 		struct auxiliary_device *adev;
190 
191 		adev = &aux_priv->aux_dev;
192 		if (adev->dev.driver) {
193 			struct auxiliary_driver *adrv;
194 			pm_message_t pm = {};
195 
196 			adrv = to_auxiliary_drv(adev->dev.driver);
197 			edev->en_state = bp->state;
198 			adrv->suspend(adev, pm);
199 		}
200 	}
201 }
202 
bnxt_ulp_start(struct bnxt * bp,int err)203 void bnxt_ulp_start(struct bnxt *bp, int err)
204 {
205 	struct bnxt_aux_priv *aux_priv = bp->aux_priv;
206 	struct bnxt_en_dev *edev = bp->edev;
207 
208 	if (!edev)
209 		return;
210 
211 	edev->flags &= ~BNXT_EN_FLAG_ULP_STOPPED;
212 
213 	if (err)
214 		return;
215 
216 	if (aux_priv) {
217 		struct auxiliary_device *adev;
218 
219 		adev = &aux_priv->aux_dev;
220 		if (adev->dev.driver) {
221 			struct auxiliary_driver *adrv;
222 
223 			adrv = to_auxiliary_drv(adev->dev.driver);
224 			edev->en_state = bp->state;
225 			adrv->resume(adev);
226 		}
227 	}
228 
229 }
230 
bnxt_ulp_irq_stop(struct bnxt * bp)231 void bnxt_ulp_irq_stop(struct bnxt *bp)
232 {
233 	struct bnxt_en_dev *edev = bp->edev;
234 	struct bnxt_ulp_ops *ops;
235 
236 	if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
237 		return;
238 
239 	if (bnxt_ulp_registered(bp->edev)) {
240 		struct bnxt_ulp *ulp = edev->ulp_tbl;
241 
242 		if (!ulp->msix_requested)
243 			return;
244 
245 		ops = rtnl_dereference(ulp->ulp_ops);
246 		if (!ops || !ops->ulp_irq_stop)
247 			return;
248 		ops->ulp_irq_stop(ulp->handle);
249 	}
250 }
251 
bnxt_ulp_irq_restart(struct bnxt * bp,int err)252 void bnxt_ulp_irq_restart(struct bnxt *bp, int err)
253 {
254 	struct bnxt_en_dev *edev = bp->edev;
255 	struct bnxt_ulp_ops *ops;
256 
257 	if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
258 		return;
259 
260 	if (bnxt_ulp_registered(bp->edev)) {
261 		struct bnxt_ulp *ulp = edev->ulp_tbl;
262 		struct bnxt_msix_entry *ent = NULL;
263 
264 		if (!ulp->msix_requested)
265 			return;
266 
267 		ops = rtnl_dereference(ulp->ulp_ops);
268 		if (!ops || !ops->ulp_irq_restart)
269 			return;
270 
271 		if (!err) {
272 			ent = kcalloc(ulp->msix_requested, sizeof(*ent),
273 				      GFP_KERNEL);
274 			if (!ent)
275 				return;
276 			bnxt_fill_msix_vecs(bp, ent);
277 		}
278 		ops->ulp_irq_restart(ulp->handle, ent);
279 		kfree(ent);
280 	}
281 }
282 
bnxt_register_async_events(struct bnxt_en_dev * edev,unsigned long * events_bmap,u16 max_id)283 int bnxt_register_async_events(struct bnxt_en_dev *edev,
284 			       unsigned long *events_bmap,
285 			       u16 max_id)
286 {
287 	struct net_device *dev = edev->net;
288 	struct bnxt *bp = netdev_priv(dev);
289 	struct bnxt_ulp *ulp;
290 
291 	ulp = edev->ulp_tbl;
292 	ulp->async_events_bmap = events_bmap;
293 	/* Make sure bnxt_ulp_async_events() sees this order */
294 	smp_wmb();
295 	ulp->max_async_event_id = max_id;
296 	bnxt_hwrm_func_drv_rgtr(bp, events_bmap, max_id + 1, true);
297 	return 0;
298 }
299 EXPORT_SYMBOL(bnxt_register_async_events);
300 
bnxt_rdma_aux_device_uninit(struct bnxt * bp)301 void bnxt_rdma_aux_device_uninit(struct bnxt *bp)
302 {
303 	struct bnxt_aux_priv *aux_priv;
304 	struct auxiliary_device *adev;
305 
306 	/* Skip if no auxiliary device init was done. */
307 	if (!bp->aux_priv)
308 		return;
309 
310 	aux_priv = bp->aux_priv;
311 	adev = &aux_priv->aux_dev;
312 	auxiliary_device_delete(adev);
313 	auxiliary_device_uninit(adev);
314 }
315 
bnxt_aux_dev_release(struct device * dev)316 static void bnxt_aux_dev_release(struct device *dev)
317 {
318 	struct bnxt_aux_priv *aux_priv =
319 		container_of(dev, struct bnxt_aux_priv, aux_dev.dev);
320 	struct bnxt *bp = netdev_priv(aux_priv->edev->net);
321 
322 	ida_free(&bnxt_aux_dev_ids, aux_priv->id);
323 	kfree(aux_priv->edev->ulp_tbl);
324 	bp->edev = NULL;
325 	kfree(aux_priv->edev);
326 	kfree(aux_priv);
327 	bp->aux_priv = NULL;
328 }
329 
bnxt_set_edev_info(struct bnxt_en_dev * edev,struct bnxt * bp)330 static void bnxt_set_edev_info(struct bnxt_en_dev *edev, struct bnxt *bp)
331 {
332 	edev->net = bp->dev;
333 	edev->pdev = bp->pdev;
334 	edev->l2_db_size = bp->db_size;
335 	edev->l2_db_size_nc = bp->db_size;
336 
337 	if (bp->flags & BNXT_FLAG_ROCEV1_CAP)
338 		edev->flags |= BNXT_EN_FLAG_ROCEV1_CAP;
339 	if (bp->flags & BNXT_FLAG_ROCEV2_CAP)
340 		edev->flags |= BNXT_EN_FLAG_ROCEV2_CAP;
341 	if (bp->flags & BNXT_FLAG_VF)
342 		edev->flags |= BNXT_EN_FLAG_VF;
343 
344 	edev->chip_num = bp->chip_num;
345 	edev->hw_ring_stats_size = bp->hw_ring_stats_size;
346 	edev->pf_port_id = bp->pf.port_id;
347 	edev->en_state = bp->state;
348 	edev->bar0 = bp->bar0;
349 	edev->ulp_tbl->msix_requested = bnxt_get_ulp_msix_num(bp);
350 }
351 
bnxt_rdma_aux_device_init(struct bnxt * bp)352 void bnxt_rdma_aux_device_init(struct bnxt *bp)
353 {
354 	struct auxiliary_device *aux_dev;
355 	struct bnxt_aux_priv *aux_priv;
356 	struct bnxt_en_dev *edev;
357 	struct bnxt_ulp *ulp;
358 	int rc;
359 
360 	if (!(bp->flags & BNXT_FLAG_ROCE_CAP))
361 		return;
362 
363 	aux_priv = kzalloc(sizeof(*bp->aux_priv), GFP_KERNEL);
364 	if (!aux_priv)
365 		goto exit;
366 
367 	aux_priv->id = ida_alloc(&bnxt_aux_dev_ids, GFP_KERNEL);
368 	if (aux_priv->id < 0) {
369 		netdev_warn(bp->dev,
370 			    "ida alloc failed for ROCE auxiliary device\n");
371 		kfree(aux_priv);
372 		goto exit;
373 	}
374 
375 	aux_dev = &aux_priv->aux_dev;
376 	aux_dev->id = aux_priv->id;
377 	aux_dev->name = "rdma";
378 	aux_dev->dev.parent = &bp->pdev->dev;
379 	aux_dev->dev.release = bnxt_aux_dev_release;
380 
381 	rc = auxiliary_device_init(aux_dev);
382 	if (rc) {
383 		ida_free(&bnxt_aux_dev_ids, aux_priv->id);
384 		kfree(aux_priv);
385 		goto exit;
386 	}
387 	bp->aux_priv = aux_priv;
388 
389 	/* From this point, all cleanup will happen via the .release callback &
390 	 * any error unwinding will need to include a call to
391 	 * auxiliary_device_uninit.
392 	 */
393 	edev = kzalloc(sizeof(*edev), GFP_KERNEL);
394 	if (!edev)
395 		goto aux_dev_uninit;
396 
397 	ulp = kzalloc(sizeof(*ulp), GFP_KERNEL);
398 	if (!ulp)
399 		goto aux_dev_uninit;
400 
401 	edev->ulp_tbl = ulp;
402 	aux_priv->edev = edev;
403 	bp->edev = edev;
404 	bnxt_set_edev_info(edev, bp);
405 
406 	rc = auxiliary_device_add(aux_dev);
407 	if (rc) {
408 		netdev_warn(bp->dev,
409 			    "Failed to add auxiliary device for ROCE\n");
410 		goto aux_dev_uninit;
411 	}
412 
413 	return;
414 
415 aux_dev_uninit:
416 	auxiliary_device_uninit(aux_dev);
417 exit:
418 	bp->flags &= ~BNXT_FLAG_ROCE_CAP;
419 }
420