1 /* Broadcom NetXtreme-C/E network driver.
3 * Copyright (c) 2016-2018 Broadcom Limited
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.
10 #include <linux/module.h>
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>
26 #include "bnxt_hwrm.h"
29 static DEFINE_IDA(bnxt_aux_dev_ids);
31 static void bnxt_fill_msix_vecs(struct bnxt *bp, struct bnxt_msix_entry *ent)
33 struct bnxt_en_dev *edev = bp->edev;
36 if (!edev->ulp_tbl->msix_requested) {
37 netdev_warn(bp->dev, "Requested MSI-X vectors insufficient\n");
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_PLUS)
46 ent[i].db_offset = bp->db_offset;
48 ent[i].db_offset = (idx + i) * 0x80;
52 int bnxt_register_dev(struct bnxt_en_dev *edev,
53 struct bnxt_ulp_ops *ulp_ops,
56 struct net_device *dev = edev->net;
57 struct bnxt *bp = netdev_priv(dev);
58 unsigned int max_stat_ctxs;
61 max_stat_ctxs = bnxt_get_max_func_stat_ctxs(bp);
62 if (max_stat_ctxs <= BNXT_MIN_ROCE_STAT_CTXS ||
63 bp->cp_nr_rings == max_stat_ctxs)
71 rcu_assign_pointer(ulp->ulp_ops, ulp_ops);
73 if (test_bit(BNXT_STATE_OPEN, &bp->state))
74 bnxt_hwrm_vnic_cfg(bp, 0);
76 bnxt_fill_msix_vecs(bp, bp->edev->msix_entries);
77 edev->flags |= BNXT_EN_FLAG_MSIX_REQUESTED;
80 EXPORT_SYMBOL(bnxt_register_dev);
82 void bnxt_unregister_dev(struct bnxt_en_dev *edev)
84 struct net_device *dev = edev->net;
85 struct bnxt *bp = netdev_priv(dev);
90 if (ulp->msix_requested)
91 edev->flags &= ~BNXT_EN_FLAG_MSIX_REQUESTED;
93 if (ulp->max_async_event_id)
94 bnxt_hwrm_func_drv_rgtr(bp, NULL, 0, true);
96 RCU_INIT_POINTER(ulp->ulp_ops, NULL);
98 ulp->max_async_event_id = 0;
99 ulp->async_events_bmap = NULL;
100 while (atomic_read(&ulp->ref_count) != 0 && i < 10) {
106 EXPORT_SYMBOL(bnxt_unregister_dev);
108 int bnxt_get_ulp_msix_num(struct bnxt *bp)
110 u32 roce_msix = BNXT_VF(bp) ?
111 BNXT_MAX_VF_ROCE_MSIX : BNXT_MAX_ROCE_MSIX;
113 return ((bp->flags & BNXT_FLAG_ROCE_CAP) ?
114 min_t(u32, roce_msix, num_online_cpus()) : 0);
117 int bnxt_get_ulp_msix_base(struct bnxt *bp)
119 if (bnxt_ulp_registered(bp->edev)) {
120 struct bnxt_en_dev *edev = bp->edev;
122 if (edev->ulp_tbl->msix_requested)
123 return edev->ulp_tbl->msix_base;
128 int bnxt_get_ulp_stat_ctxs(struct bnxt *bp)
130 if (bnxt_ulp_registered(bp->edev)) {
131 struct bnxt_en_dev *edev = bp->edev;
133 if (edev->ulp_tbl->msix_requested)
134 return BNXT_MIN_ROCE_STAT_CTXS;
140 int bnxt_send_msg(struct bnxt_en_dev *edev,
141 struct bnxt_fw_msg *fw_msg)
143 struct net_device *dev = edev->net;
144 struct bnxt *bp = netdev_priv(dev);
150 if (bp->fw_reset_state)
153 rc = hwrm_req_init(bp, req, 0 /* don't care */);
157 rc = hwrm_req_replace(bp, req, fw_msg->msg, fw_msg->msg_len);
161 hwrm_req_timeout(bp, req, fw_msg->timeout);
162 resp = hwrm_req_hold(bp, req);
163 rc = hwrm_req_send(bp, req);
164 resp_len = le16_to_cpu(resp->resp_len);
166 if (fw_msg->resp_max_len < resp_len)
167 resp_len = fw_msg->resp_max_len;
169 memcpy(fw_msg->resp, resp, resp_len);
171 hwrm_req_drop(bp, req);
174 EXPORT_SYMBOL(bnxt_send_msg);
176 void bnxt_ulp_stop(struct bnxt *bp)
178 struct bnxt_aux_priv *aux_priv = bp->aux_priv;
179 struct bnxt_en_dev *edev = bp->edev;
184 edev->flags |= BNXT_EN_FLAG_ULP_STOPPED;
186 struct auxiliary_device *adev;
188 adev = &aux_priv->aux_dev;
189 if (adev->dev.driver) {
190 struct auxiliary_driver *adrv;
191 pm_message_t pm = {};
193 adrv = to_auxiliary_drv(adev->dev.driver);
194 edev->en_state = bp->state;
195 adrv->suspend(adev, pm);
200 void bnxt_ulp_start(struct bnxt *bp, int err)
202 struct bnxt_aux_priv *aux_priv = bp->aux_priv;
203 struct bnxt_en_dev *edev = bp->edev;
208 edev->flags &= ~BNXT_EN_FLAG_ULP_STOPPED;
214 struct auxiliary_device *adev;
216 adev = &aux_priv->aux_dev;
217 if (adev->dev.driver) {
218 struct auxiliary_driver *adrv;
220 adrv = to_auxiliary_drv(adev->dev.driver);
221 edev->en_state = bp->state;
228 void bnxt_ulp_irq_stop(struct bnxt *bp)
230 struct bnxt_en_dev *edev = bp->edev;
231 struct bnxt_ulp_ops *ops;
233 if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
236 if (bnxt_ulp_registered(bp->edev)) {
237 struct bnxt_ulp *ulp = edev->ulp_tbl;
239 if (!ulp->msix_requested)
242 ops = rtnl_dereference(ulp->ulp_ops);
243 if (!ops || !ops->ulp_irq_stop)
245 ops->ulp_irq_stop(ulp->handle);
249 void bnxt_ulp_irq_restart(struct bnxt *bp, int err)
251 struct bnxt_en_dev *edev = bp->edev;
252 struct bnxt_ulp_ops *ops;
254 if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
257 if (bnxt_ulp_registered(bp->edev)) {
258 struct bnxt_ulp *ulp = edev->ulp_tbl;
259 struct bnxt_msix_entry *ent = NULL;
261 if (!ulp->msix_requested)
264 ops = rtnl_dereference(ulp->ulp_ops);
265 if (!ops || !ops->ulp_irq_restart)
269 ent = kcalloc(ulp->msix_requested, sizeof(*ent),
273 bnxt_fill_msix_vecs(bp, ent);
275 ops->ulp_irq_restart(ulp->handle, ent);
280 int bnxt_register_async_events(struct bnxt_en_dev *edev,
281 unsigned long *events_bmap,
284 struct net_device *dev = edev->net;
285 struct bnxt *bp = netdev_priv(dev);
286 struct bnxt_ulp *ulp;
289 ulp->async_events_bmap = events_bmap;
290 /* Make sure bnxt_ulp_async_events() sees this order */
292 ulp->max_async_event_id = max_id;
293 bnxt_hwrm_func_drv_rgtr(bp, events_bmap, max_id + 1, true);
296 EXPORT_SYMBOL(bnxt_register_async_events);
298 void bnxt_rdma_aux_device_uninit(struct bnxt *bp)
300 struct bnxt_aux_priv *aux_priv;
301 struct auxiliary_device *adev;
303 /* Skip if no auxiliary device init was done. */
307 aux_priv = bp->aux_priv;
308 adev = &aux_priv->aux_dev;
309 auxiliary_device_delete(adev);
310 auxiliary_device_uninit(adev);
313 static void bnxt_aux_dev_release(struct device *dev)
315 struct bnxt_aux_priv *aux_priv =
316 container_of(dev, struct bnxt_aux_priv, aux_dev.dev);
317 struct bnxt *bp = netdev_priv(aux_priv->edev->net);
319 ida_free(&bnxt_aux_dev_ids, aux_priv->id);
320 kfree(aux_priv->edev->ulp_tbl);
322 kfree(aux_priv->edev);
327 static void bnxt_set_edev_info(struct bnxt_en_dev *edev, struct bnxt *bp)
330 edev->pdev = bp->pdev;
331 edev->l2_db_size = bp->db_size;
332 edev->l2_db_size_nc = bp->db_size;
333 edev->l2_db_offset = bp->db_offset;
335 if (bp->flags & BNXT_FLAG_ROCEV1_CAP)
336 edev->flags |= BNXT_EN_FLAG_ROCEV1_CAP;
337 if (bp->flags & BNXT_FLAG_ROCEV2_CAP)
338 edev->flags |= BNXT_EN_FLAG_ROCEV2_CAP;
339 if (bp->flags & BNXT_FLAG_VF)
340 edev->flags |= BNXT_EN_FLAG_VF;
342 edev->chip_num = bp->chip_num;
343 edev->hw_ring_stats_size = bp->hw_ring_stats_size;
344 edev->pf_port_id = bp->pf.port_id;
345 edev->en_state = bp->state;
346 edev->bar0 = bp->bar0;
347 edev->ulp_tbl->msix_requested = bnxt_get_ulp_msix_num(bp);
350 void bnxt_rdma_aux_device_init(struct bnxt *bp)
352 struct auxiliary_device *aux_dev;
353 struct bnxt_aux_priv *aux_priv;
354 struct bnxt_en_dev *edev;
355 struct bnxt_ulp *ulp;
358 if (!(bp->flags & BNXT_FLAG_ROCE_CAP))
361 aux_priv = kzalloc(sizeof(*bp->aux_priv), GFP_KERNEL);
365 aux_priv->id = ida_alloc(&bnxt_aux_dev_ids, GFP_KERNEL);
366 if (aux_priv->id < 0) {
368 "ida alloc failed for ROCE auxiliary device\n");
373 aux_dev = &aux_priv->aux_dev;
374 aux_dev->id = aux_priv->id;
375 aux_dev->name = "rdma";
376 aux_dev->dev.parent = &bp->pdev->dev;
377 aux_dev->dev.release = bnxt_aux_dev_release;
379 rc = auxiliary_device_init(aux_dev);
381 ida_free(&bnxt_aux_dev_ids, aux_priv->id);
385 bp->aux_priv = aux_priv;
387 /* From this point, all cleanup will happen via the .release callback &
388 * any error unwinding will need to include a call to
389 * auxiliary_device_uninit.
391 edev = kzalloc(sizeof(*edev), GFP_KERNEL);
395 ulp = kzalloc(sizeof(*ulp), GFP_KERNEL);
400 aux_priv->edev = edev;
402 bnxt_set_edev_info(edev, bp);
404 rc = auxiliary_device_add(aux_dev);
407 "Failed to add auxiliary device for ROCE\n");
414 auxiliary_device_uninit(aux_dev);
416 bp->flags &= ~BNXT_FLAG_ROCE_CAP;