[mirror_ubuntu-hirsute-kernel.git] / drivers / net / ethernet / broadcom / bnxt / bnxt_ulp.c

/* Broadcom NetXtreme-C/E network driver.
 *
 * Copyright (c) 2016-2018 Broadcom Limited
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation.
 */

#include <linux/module.h>

#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
#include <linux/rtnetlink.h>
#include <linux/bitops.h>
#include <linux/irq.h>
#include <asm/byteorder.h>
#include <linux/bitmap.h>

#include "bnxt_hsi.h"
#include "bnxt.h"
#include "bnxt_ulp.h"

static int bnxt_register_dev(struct bnxt_en_dev *edev, int ulp_id,
			     struct bnxt_ulp_ops *ulp_ops, void *handle)
{
	struct net_device *dev = edev->net;
	struct bnxt *bp = netdev_priv(dev);
	struct bnxt_ulp *ulp;

	ASSERT_RTNL();
	if (ulp_id >= BNXT_MAX_ULP)
		return -EINVAL;

	ulp = &edev->ulp_tbl[ulp_id];
	if (rcu_access_pointer(ulp->ulp_ops)) {
		netdev_err(bp->dev, "ulp id %d already registered\n", ulp_id);
		return -EBUSY;
	}
	if (ulp_id == BNXT_ROCE_ULP) {
		unsigned int max_stat_ctxs;

		max_stat_ctxs = bnxt_get_max_func_stat_ctxs(bp);
		if (max_stat_ctxs <= BNXT_MIN_ROCE_STAT_CTXS ||
		    bp->cp_nr_rings == max_stat_ctxs)
			return -ENOMEM;
	}

	atomic_set(&ulp->ref_count, 0);
	ulp->handle = handle;
	rcu_assign_pointer(ulp->ulp_ops, ulp_ops);

	if (ulp_id == BNXT_ROCE_ULP) {
		if (test_bit(BNXT_STATE_OPEN, &bp->state))
			bnxt_hwrm_vnic_cfg(bp, 0);
	}

	return 0;
}

static int bnxt_unregister_dev(struct bnxt_en_dev *edev, int ulp_id)
{
	struct net_device *dev = edev->net;
	struct bnxt *bp = netdev_priv(dev);
	struct bnxt_ulp *ulp;
	int i = 0;

	ASSERT_RTNL();
	if (ulp_id >= BNXT_MAX_ULP)
		return -EINVAL;

	ulp = &edev->ulp_tbl[ulp_id];
	if (!rcu_access_pointer(ulp->ulp_ops)) {
		netdev_err(bp->dev, "ulp id %d not registered\n", ulp_id);
		return -EINVAL;
	}
	if (ulp_id == BNXT_ROCE_ULP && ulp->msix_requested)
		edev->en_ops->bnxt_free_msix(edev, ulp_id);

	if (ulp->max_async_event_id)
		bnxt_hwrm_func_drv_rgtr(bp, NULL, 0, true);

	RCU_INIT_POINTER(ulp->ulp_ops, NULL);
	synchronize_rcu();
	ulp->max_async_event_id = 0;
	ulp->async_events_bmap = NULL;
	while (atomic_read(&ulp->ref_count) != 0 && i < 10) {
		msleep(100);
		i++;
	}
	return 0;
}

static void bnxt_fill_msix_vecs(struct bnxt *bp, struct bnxt_msix_entry *ent)
{
	struct bnxt_en_dev *edev = bp->edev;
	int num_msix, idx, i;

	num_msix = edev->ulp_tbl[BNXT_ROCE_ULP].msix_requested;
	idx = edev->ulp_tbl[BNXT_ROCE_ULP].msix_base;
	for (i = 0; i < num_msix; i++) {
		ent[i].vector = bp->irq_tbl[idx + i].vector;
		ent[i].ring_idx = idx + i;
		if (bp->flags & BNXT_FLAG_CHIP_P5) {
			ent[i].db_offset = DB_PF_OFFSET_P5;
			if (BNXT_VF(bp))
				ent[i].db_offset = DB_VF_OFFSET_P5;
		} else {
			ent[i].db_offset = (idx + i) * 0x80;
		}
	}
}

static int bnxt_req_msix_vecs(struct bnxt_en_dev *edev, int ulp_id,
			      struct bnxt_msix_entry *ent, int num_msix)
{
	struct net_device *dev = edev->net;
	struct bnxt *bp = netdev_priv(dev);
	struct bnxt_hw_resc *hw_resc;
	int max_idx, max_cp_rings;
	int avail_msix, idx;
	int total_vecs;
	int rc = 0;

	ASSERT_RTNL();
	if (ulp_id != BNXT_ROCE_ULP)
		return -EINVAL;

	if (!(bp->flags & BNXT_FLAG_USING_MSIX))
		return -ENODEV;

	if (edev->ulp_tbl[ulp_id].msix_requested)
		return -EAGAIN;

	max_cp_rings = bnxt_get_max_func_cp_rings(bp);
	avail_msix = bnxt_get_avail_msix(bp, num_msix);
	if (!avail_msix)
		return -ENOMEM;
	if (avail_msix > num_msix)
		avail_msix = num_msix;

	if (BNXT_NEW_RM(bp)) {
		idx = bp->cp_nr_rings;
	} else {
		max_idx = min_t(int, bp->total_irqs, max_cp_rings);
		idx = max_idx - avail_msix;
	}
	edev->ulp_tbl[ulp_id].msix_base = idx;
	edev->ulp_tbl[ulp_id].msix_requested = avail_msix;
	hw_resc = &bp->hw_resc;
	total_vecs = idx + avail_msix;
	if (bp->total_irqs < total_vecs ||
	    (BNXT_NEW_RM(bp) && hw_resc->resv_irqs < total_vecs)) {
		if (netif_running(dev)) {
			bnxt_close_nic(bp, true, false);
			rc = bnxt_open_nic(bp, true, false);
		} else {
			rc = bnxt_reserve_rings(bp, true);
		}
	}
	if (rc) {
		edev->ulp_tbl[ulp_id].msix_requested = 0;
		return -EAGAIN;
	}

	if (BNXT_NEW_RM(bp)) {
		int resv_msix;

		resv_msix = hw_resc->resv_irqs - bp->cp_nr_rings;
		avail_msix = min_t(int, resv_msix, avail_msix);
		edev->ulp_tbl[ulp_id].msix_requested = avail_msix;
	}
	bnxt_fill_msix_vecs(bp, ent);
	edev->flags |= BNXT_EN_FLAG_MSIX_REQUESTED;
	return avail_msix;
}

static int bnxt_free_msix_vecs(struct bnxt_en_dev *edev, int ulp_id)
{
	struct net_device *dev = edev->net;
	struct bnxt *bp = netdev_priv(dev);

	ASSERT_RTNL();
	if (ulp_id != BNXT_ROCE_ULP)
		return -EINVAL;

	if (!(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
		return 0;

	edev->ulp_tbl[ulp_id].msix_requested = 0;
	edev->flags &= ~BNXT_EN_FLAG_MSIX_REQUESTED;
	if (netif_running(dev) && !(edev->flags & BNXT_EN_FLAG_ULP_STOPPED)) {
		bnxt_close_nic(bp, true, false);
		bnxt_open_nic(bp, true, false);
	}
	return 0;
}

int bnxt_get_ulp_msix_num(struct bnxt *bp)
{
	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP)) {
		struct bnxt_en_dev *edev = bp->edev;

		return edev->ulp_tbl[BNXT_ROCE_ULP].msix_requested;
	}
	return 0;
}

int bnxt_get_ulp_msix_base(struct bnxt *bp)
{
	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP)) {
		struct bnxt_en_dev *edev = bp->edev;

		if (edev->ulp_tbl[BNXT_ROCE_ULP].msix_requested)
			return edev->ulp_tbl[BNXT_ROCE_ULP].msix_base;
	}
	return 0;
}

int bnxt_get_ulp_stat_ctxs(struct bnxt *bp)
{
	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP))
		return BNXT_MIN_ROCE_STAT_CTXS;

	return 0;
}

static int bnxt_send_msg(struct bnxt_en_dev *edev, int ulp_id,
			 struct bnxt_fw_msg *fw_msg)
{
	struct net_device *dev = edev->net;
	struct bnxt *bp = netdev_priv(dev);
	struct input *req;
	int rc;

	if (ulp_id != BNXT_ROCE_ULP && bp->fw_reset_state)
		return -EBUSY;

	mutex_lock(&bp->hwrm_cmd_lock);
	req = fw_msg->msg;
	req->resp_addr = cpu_to_le64(bp->hwrm_cmd_resp_dma_addr);
	rc = _hwrm_send_message(bp, fw_msg->msg, fw_msg->msg_len,
				fw_msg->timeout);
	if (!rc) {
		struct output *resp = bp->hwrm_cmd_resp_addr;
		u32 len = le16_to_cpu(resp->resp_len);

		if (fw_msg->resp_max_len < len)
			len = fw_msg->resp_max_len;

		memcpy(fw_msg->resp, resp, len);
	}
	mutex_unlock(&bp->hwrm_cmd_lock);
	return rc;
}

static void bnxt_ulp_get(struct bnxt_ulp *ulp)
{
	atomic_inc(&ulp->ref_count);
}

static void bnxt_ulp_put(struct bnxt_ulp *ulp)
{
	atomic_dec(&ulp->ref_count);
}

void bnxt_ulp_stop(struct bnxt *bp)
{
	struct bnxt_en_dev *edev = bp->edev;
	struct bnxt_ulp_ops *ops;
	int i;

	if (!edev)
		return;

	edev->flags |= BNXT_EN_FLAG_ULP_STOPPED;
	for (i = 0; i < BNXT_MAX_ULP; i++) {
		struct bnxt_ulp *ulp = &edev->ulp_tbl[i];

		ops = rtnl_dereference(ulp->ulp_ops);
		if (!ops || !ops->ulp_stop)
			continue;
		ops->ulp_stop(ulp->handle);
	}
}

void bnxt_ulp_start(struct bnxt *bp, int err)
{
	struct bnxt_en_dev *edev = bp->edev;
	struct bnxt_ulp_ops *ops;
	int i;

	if (!edev)
		return;

	edev->flags &= ~BNXT_EN_FLAG_ULP_STOPPED;

	if (err)
		return;

	for (i = 0; i < BNXT_MAX_ULP; i++) {
		struct bnxt_ulp *ulp = &edev->ulp_tbl[i];

		ops = rtnl_dereference(ulp->ulp_ops);
		if (!ops || !ops->ulp_start)
			continue;
		ops->ulp_start(ulp->handle);
	}
}

void bnxt_ulp_sriov_cfg(struct bnxt *bp, int num_vfs)
{
	struct bnxt_en_dev *edev = bp->edev;
	struct bnxt_ulp_ops *ops;
	int i;

	if (!edev)
		return;

	for (i = 0; i < BNXT_MAX_ULP; i++) {
		struct bnxt_ulp *ulp = &edev->ulp_tbl[i];

		rcu_read_lock();
		ops = rcu_dereference(ulp->ulp_ops);
		if (!ops || !ops->ulp_sriov_config) {
			rcu_read_unlock();
			continue;
		}
		bnxt_ulp_get(ulp);
		rcu_read_unlock();
		ops->ulp_sriov_config(ulp->handle, num_vfs);
		bnxt_ulp_put(ulp);
	}
}

void bnxt_ulp_shutdown(struct bnxt *bp)
{
	struct bnxt_en_dev *edev = bp->edev;
	struct bnxt_ulp_ops *ops;
	int i;

	if (!edev)
		return;

	for (i = 0; i < BNXT_MAX_ULP; i++) {
		struct bnxt_ulp *ulp = &edev->ulp_tbl[i];

		ops = rtnl_dereference(ulp->ulp_ops);
		if (!ops || !ops->ulp_shutdown)
			continue;
		ops->ulp_shutdown(ulp->handle);
	}
}

void bnxt_ulp_irq_stop(struct bnxt *bp)
{
	struct bnxt_en_dev *edev = bp->edev;
	struct bnxt_ulp_ops *ops;

	if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
		return;

	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP)) {
		struct bnxt_ulp *ulp = &edev->ulp_tbl[BNXT_ROCE_ULP];

		if (!ulp->msix_requested)
			return;

		ops = rtnl_dereference(ulp->ulp_ops);
		if (!ops || !ops->ulp_irq_stop)
			return;
		ops->ulp_irq_stop(ulp->handle);
	}
}

void bnxt_ulp_irq_restart(struct bnxt *bp, int err)
{
	struct bnxt_en_dev *edev = bp->edev;
	struct bnxt_ulp_ops *ops;

	if (!edev || !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
		return;

	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP)) {
		struct bnxt_ulp *ulp = &edev->ulp_tbl[BNXT_ROCE_ULP];
		struct bnxt_msix_entry *ent = NULL;

		if (!ulp->msix_requested)
			return;

		ops = rtnl_dereference(ulp->ulp_ops);
		if (!ops || !ops->ulp_irq_restart)
			return;

		if (!err) {
			ent = kcalloc(ulp->msix_requested, sizeof(*ent),
				      GFP_KERNEL);
			if (!ent)
				return;
			bnxt_fill_msix_vecs(bp, ent);
		}
		ops->ulp_irq_restart(ulp->handle, ent);
		kfree(ent);
	}
}

void bnxt_ulp_async_events(struct bnxt *bp, struct hwrm_async_event_cmpl *cmpl)
{
	u16 event_id = le16_to_cpu(cmpl->event_id);
	struct bnxt_en_dev *edev = bp->edev;
	struct bnxt_ulp_ops *ops;
	int i;

	if (!edev)
		return;

	rcu_read_lock();
	for (i = 0; i < BNXT_MAX_ULP; i++) {
		struct bnxt_ulp *ulp = &edev->ulp_tbl[i];

		ops = rcu_dereference(ulp->ulp_ops);
		if (!ops || !ops->ulp_async_notifier)
			continue;
		if (!ulp->async_events_bmap ||
		    event_id > ulp->max_async_event_id)
			continue;

		/* Read max_async_event_id first before testing the bitmap. */
		smp_rmb();
		if (test_bit(event_id, ulp->async_events_bmap))
			ops->ulp_async_notifier(ulp->handle, cmpl);
	}
	rcu_read_unlock();
}

static int bnxt_register_async_events(struct bnxt_en_dev *edev, int ulp_id,
				      unsigned long *events_bmap, u16 max_id)
{
	struct net_device *dev = edev->net;
	struct bnxt *bp = netdev_priv(dev);
	struct bnxt_ulp *ulp;

	if (ulp_id >= BNXT_MAX_ULP)
		return -EINVAL;

	ulp = &edev->ulp_tbl[ulp_id];
	ulp->async_events_bmap = events_bmap;
	/* Make sure bnxt_ulp_async_events() sees this order */
	smp_wmb();
	ulp->max_async_event_id = max_id;
	bnxt_hwrm_func_drv_rgtr(bp, events_bmap, max_id + 1, true);
	return 0;
}

static const struct bnxt_en_ops bnxt_en_ops_tbl = {
	.bnxt_register_device	= bnxt_register_dev,
	.bnxt_unregister_device	= bnxt_unregister_dev,
	.bnxt_request_msix	= bnxt_req_msix_vecs,
	.bnxt_free_msix		= bnxt_free_msix_vecs,
	.bnxt_send_fw_msg	= bnxt_send_msg,
	.bnxt_register_fw_async_events	= bnxt_register_async_events,
};

struct bnxt_en_dev *bnxt_ulp_probe(struct net_device *dev)
{
	struct bnxt *bp = netdev_priv(dev);
	struct bnxt_en_dev *edev;

	edev = bp->edev;
	if (!edev) {
		edev = kzalloc(sizeof(*edev), GFP_KERNEL);
		if (!edev)
			return ERR_PTR(-ENOMEM);
		edev->en_ops = &bnxt_en_ops_tbl;
		if (bp->flags & BNXT_FLAG_ROCEV1_CAP)
			edev->flags |= BNXT_EN_FLAG_ROCEV1_CAP;
		if (bp->flags & BNXT_FLAG_ROCEV2_CAP)
			edev->flags |= BNXT_EN_FLAG_ROCEV2_CAP;
		edev->net = dev;
		edev->pdev = bp->pdev;
		edev->l2_db_size = bp->db_size;
		edev->l2_db_size_nc = bp->db_size;
		bp->edev = edev;
	}
	return bp->edev;
}
Commit	Line	Data
a588e458 MC	1	/* Broadcom NetXtreme-C/E network driver.
a588e458 MC	2	*
ec86f14e	3	* Copyright (c) 2016-2018 Broadcom Limited
a588e458 MC	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
	23	#include "bnxt_hsi.h"
	24	#include "bnxt.h"
	25	#include "bnxt_ulp.h"
	26
	27	static int bnxt_register_dev(struct bnxt_en_dev *edev, int ulp_id,
	28	struct bnxt_ulp_ops ulp_ops, void handle)
	29	{
	30	struct net_device *dev = edev->net;
	31	struct bnxt *bp = netdev_priv(dev);
	32	struct bnxt_ulp *ulp;
	33
	34	ASSERT_RTNL();
	35	if (ulp_id >= BNXT_MAX_ULP)
	36	return -EINVAL;
	37
	38	ulp = &edev->ulp_tbl[ulp_id];
	39	if (rcu_access_pointer(ulp->ulp_ops)) {
	40	netdev_err(bp->dev, "ulp id %d already registered\n", ulp_id);
	41	return -EBUSY;
	42	}
	43	if (ulp_id == BNXT_ROCE_ULP) {
	44	unsigned int max_stat_ctxs;
	45
	46	max_stat_ctxs = bnxt_get_max_func_stat_ctxs(bp);
	47	if (max_stat_ctxs <= BNXT_MIN_ROCE_STAT_CTXS \|\|
c027c6b4	48	bp->cp_nr_rings == max_stat_ctxs)
a588e458	49	return -ENOMEM;
a588e458 MC	50	}
	51
	52	atomic_set(&ulp->ref_count, 0);
	53	ulp->handle = handle;
	54	rcu_assign_pointer(ulp->ulp_ops, ulp_ops);
	55
	56	if (ulp_id == BNXT_ROCE_ULP) {
	57	if (test_bit(BNXT_STATE_OPEN, &bp->state))
	58	bnxt_hwrm_vnic_cfg(bp, 0);
	59	}
	60
	61	return 0;
	62	}
	63
	64	static int bnxt_unregister_dev(struct bnxt_en_dev *edev, int ulp_id)
	65	{
	66	struct net_device *dev = edev->net;
	67	struct bnxt *bp = netdev_priv(dev);
	68	struct bnxt_ulp *ulp;
	69	int i = 0;
	70
	71	ASSERT_RTNL();
	72	if (ulp_id >= BNXT_MAX_ULP)
	73	return -EINVAL;
	74
	75	ulp = &edev->ulp_tbl[ulp_id];
	76	if (!rcu_access_pointer(ulp->ulp_ops)) {
	77	netdev_err(bp->dev, "ulp id %d not registered\n", ulp_id);
	78	return -EINVAL;
	79	}
f4e89614 VV	80	if (ulp_id == BNXT_ROCE_ULP && ulp->msix_requested)
f4e89614 VV	81	edev->en_ops->bnxt_free_msix(edev, ulp_id);
a588e458	82
a588e458	83	if (ulp->max_async_event_id)
2e882468	84	bnxt_hwrm_func_drv_rgtr(bp, NULL, 0, true);
a588e458 MC	85
	86	RCU_INIT_POINTER(ulp->ulp_ops, NULL);
	87	synchronize_rcu();
	88	ulp->max_async_event_id = 0;
	89	ulp->async_events_bmap = NULL;
	90	while (atomic_read(&ulp->ref_count) != 0 && i < 10) {
	91	msleep(100);
	92	i++;
	93	}
	94	return 0;
	95	}
	96
ec86f14e MC	97	static void bnxt_fill_msix_vecs(struct bnxt bp, struct bnxt_msix_entry ent)
	98	{
	99	struct bnxt_en_dev *edev = bp->edev;
	100	int num_msix, idx, i;
	101
	102	num_msix = edev->ulp_tbl[BNXT_ROCE_ULP].msix_requested;
	103	idx = edev->ulp_tbl[BNXT_ROCE_ULP].msix_base;
	104	for (i = 0; i < num_msix; i++) {
	105	ent[i].vector = bp->irq_tbl[idx + i].vector;
	106	ent[i].ring_idx = idx + i;
e93b30d5 MC	107	if (bp->flags & BNXT_FLAG_CHIP_P5) {
	108	ent[i].db_offset = DB_PF_OFFSET_P5;
	109	if (BNXT_VF(bp))
	110	ent[i].db_offset = DB_VF_OFFSET_P5;
	111	} else {
	112	ent[i].db_offset = (idx + i) * 0x80;
	113	}
ec86f14e MC	114	}
	115	}
	116
a588e458 MC	117	static int bnxt_req_msix_vecs(struct bnxt_en_dev *edev, int ulp_id,
	118	struct bnxt_msix_entry *ent, int num_msix)
	119	{
	120	struct net_device *dev = edev->net;
	121	struct bnxt *bp = netdev_priv(dev);
0c722ec0	122	struct bnxt_hw_resc *hw_resc;
a588e458	123	int max_idx, max_cp_rings;
ec86f14e	124	int avail_msix, idx;
0c722ec0	125	int total_vecs;
fbcfc8e4	126	int rc = 0;
a588e458 MC	127
	128	ASSERT_RTNL();
	129	if (ulp_id != BNXT_ROCE_ULP)
	130	return -EINVAL;
	131
	132	if (!(bp->flags & BNXT_FLAG_USING_MSIX))
	133	return -ENODEV;
	134
08654eb2 MC	135	if (edev->ulp_tbl[ulp_id].msix_requested)
	136	return -EAGAIN;
	137
a588e458	138	max_cp_rings = bnxt_get_max_func_cp_rings(bp);
fbcfc8e4	139	avail_msix = bnxt_get_avail_msix(bp, num_msix);
a588e458 MC	140	if (!avail_msix)
	141	return -ENOMEM;
	142	if (avail_msix > num_msix)
	143	avail_msix = num_msix;
	144
f1ca94de	145	if (BNXT_NEW_RM(bp)) {
08654eb2	146	idx = bp->cp_nr_rings;
fbcfc8e4 MC	147	} else {
fbcfc8e4 MC	148	max_idx = min_t(int, bp->total_irqs, max_cp_rings);
08654eb2	149	idx = max_idx - avail_msix;
fbcfc8e4	150	}
08654eb2	151	edev->ulp_tbl[ulp_id].msix_base = idx;
fbcfc8e4	152	edev->ulp_tbl[ulp_id].msix_requested = avail_msix;
0c722ec0 MC	153	hw_resc = &bp->hw_resc;
	154	total_vecs = idx + avail_msix;
	155	if (bp->total_irqs < total_vecs \|\|
	156	(BNXT_NEW_RM(bp) && hw_resc->resv_irqs < total_vecs)) {
fbcfc8e4 MC	157	if (netif_running(dev)) {
	158	bnxt_close_nic(bp, true, false);
	159	rc = bnxt_open_nic(bp, true, false);
	160	} else {
1b3f0b75	161	rc = bnxt_reserve_rings(bp, true);
fbcfc8e4 MC	162	}
	163	}
	164	if (rc) {
	165	edev->ulp_tbl[ulp_id].msix_requested = 0;
	166	return -EAGAIN;
	167	}
	168
f1ca94de	169	if (BNXT_NEW_RM(bp)) {
1dbc59fa	170	int resv_msix;
fbcfc8e4	171
1dbc59fa MC	172	resv_msix = hw_resc->resv_irqs - bp->cp_nr_rings;
1dbc59fa MC	173	avail_msix = min_t(int, resv_msix, avail_msix);
fbcfc8e4 MC	174	edev->ulp_tbl[ulp_id].msix_requested = avail_msix;
fbcfc8e4 MC	175	}
ec86f14e	176	bnxt_fill_msix_vecs(bp, ent);
ec86f14e	177	edev->flags \|= BNXT_EN_FLAG_MSIX_REQUESTED;
a588e458 MC	178	return avail_msix;
	179	}
	180
	181	static int bnxt_free_msix_vecs(struct bnxt_en_dev *edev, int ulp_id)
	182	{
	183	struct net_device *dev = edev->net;
	184	struct bnxt *bp = netdev_priv(dev);
a588e458 MC	185
	186	ASSERT_RTNL();
	187	if (ulp_id != BNXT_ROCE_ULP)
	188	return -EINVAL;
	189
ec86f14e MC	190	if (!(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
	191	return 0;
	192
a588e458	193	edev->ulp_tbl[ulp_id].msix_requested = 0;
ec86f14e	194	edev->flags &= ~BNXT_EN_FLAG_MSIX_REQUESTED;
aa46dfff	195	if (netif_running(dev) && !(edev->flags & BNXT_EN_FLAG_ULP_STOPPED)) {
fbcfc8e4 MC	196	bnxt_close_nic(bp, true, false);
	197	bnxt_open_nic(bp, true, false);
	198	}
a588e458 MC	199	return 0;
	200	}
	201
08654eb2 MC	202	int bnxt_get_ulp_msix_num(struct bnxt *bp)
	203	{
	204	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP)) {
	205	struct bnxt_en_dev *edev = bp->edev;
	206
	207	return edev->ulp_tbl[BNXT_ROCE_ULP].msix_requested;
	208	}
	209	return 0;
	210	}
	211
	212	int bnxt_get_ulp_msix_base(struct bnxt *bp)
	213	{
	214	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP)) {
	215	struct bnxt_en_dev *edev = bp->edev;
	216
	217	if (edev->ulp_tbl[BNXT_ROCE_ULP].msix_requested)
	218	return edev->ulp_tbl[BNXT_ROCE_ULP].msix_base;
	219	}
	220	return 0;
	221	}
	222
c027c6b4 VV	223	int bnxt_get_ulp_stat_ctxs(struct bnxt *bp)
	224	{
	225	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP))
	226	return BNXT_MIN_ROCE_STAT_CTXS;
	227
	228	return 0;
	229	}
	230
a588e458 MC	231	static int bnxt_send_msg(struct bnxt_en_dev *edev, int ulp_id,
	232	struct bnxt_fw_msg *fw_msg)
	233	{
	234	struct net_device *dev = edev->net;
	235	struct bnxt *bp = netdev_priv(dev);
	236	struct input *req;
	237	int rc;
	238
230d1f0d MC	239	if (ulp_id != BNXT_ROCE_ULP && bp->fw_reset_state)
	240	return -EBUSY;
	241
a588e458 MC	242	mutex_lock(&bp->hwrm_cmd_lock);
	243	req = fw_msg->msg;
	244	req->resp_addr = cpu_to_le64(bp->hwrm_cmd_resp_dma_addr);
	245	rc = _hwrm_send_message(bp, fw_msg->msg, fw_msg->msg_len,
	246	fw_msg->timeout);
	247	if (!rc) {
	248	struct output *resp = bp->hwrm_cmd_resp_addr;
	249	u32 len = le16_to_cpu(resp->resp_len);
	250
	251	if (fw_msg->resp_max_len < len)
	252	len = fw_msg->resp_max_len;
	253
	254	memcpy(fw_msg->resp, resp, len);
	255	}
	256	mutex_unlock(&bp->hwrm_cmd_lock);
	257	return rc;
	258	}
	259
	260	static void bnxt_ulp_get(struct bnxt_ulp *ulp)
	261	{
	262	atomic_inc(&ulp->ref_count);
	263	}
	264
	265	static void bnxt_ulp_put(struct bnxt_ulp *ulp)
	266	{
	267	atomic_dec(&ulp->ref_count);
	268	}
	269
	270	void bnxt_ulp_stop(struct bnxt *bp)
	271	{
	272	struct bnxt_en_dev *edev = bp->edev;
	273	struct bnxt_ulp_ops *ops;
	274	int i;
	275
	276	if (!edev)
	277	return;
	278
aa46dfff	279	edev->flags \|= BNXT_EN_FLAG_ULP_STOPPED;
a588e458 MC	280	for (i = 0; i < BNXT_MAX_ULP; i++) {
	281	struct bnxt_ulp *ulp = &edev->ulp_tbl[i];
	282
	283	ops = rtnl_dereference(ulp->ulp_ops);
	284	if (!ops \|\| !ops->ulp_stop)
	285	continue;
	286	ops->ulp_stop(ulp->handle);
	287	}
	288	}
	289
aa46dfff	290	void bnxt_ulp_start(struct bnxt *bp, int err)
a588e458 MC	291	{
	292	struct bnxt_en_dev *edev = bp->edev;
	293	struct bnxt_ulp_ops *ops;
	294	int i;
	295
	296	if (!edev)
	297	return;
	298
aa46dfff VV	299	edev->flags &= ~BNXT_EN_FLAG_ULP_STOPPED;
	300
	301	if (err)
	302	return;
	303
a588e458 MC	304	for (i = 0; i < BNXT_MAX_ULP; i++) {
	305	struct bnxt_ulp *ulp = &edev->ulp_tbl[i];
	306
	307	ops = rtnl_dereference(ulp->ulp_ops);
	308	if (!ops \|\| !ops->ulp_start)
	309	continue;
	310	ops->ulp_start(ulp->handle);
	311	}
	312	}
	313
	314	void bnxt_ulp_sriov_cfg(struct bnxt *bp, int num_vfs)
	315	{
	316	struct bnxt_en_dev *edev = bp->edev;
	317	struct bnxt_ulp_ops *ops;
	318	int i;
	319
	320	if (!edev)
	321	return;
	322
	323	for (i = 0; i < BNXT_MAX_ULP; i++) {
	324	struct bnxt_ulp *ulp = &edev->ulp_tbl[i];
	325
	326	rcu_read_lock();
	327	ops = rcu_dereference(ulp->ulp_ops);
	328	if (!ops \|\| !ops->ulp_sriov_config) {
	329	rcu_read_unlock();
	330	continue;
	331	}
	332	bnxt_ulp_get(ulp);
	333	rcu_read_unlock();
	334	ops->ulp_sriov_config(ulp->handle, num_vfs);
	335	bnxt_ulp_put(ulp);
	336	}
	337	}
	338
0efd2fc6 MC	339	void bnxt_ulp_shutdown(struct bnxt *bp)
	340	{
	341	struct bnxt_en_dev *edev = bp->edev;
	342	struct bnxt_ulp_ops *ops;
	343	int i;
	344
	345	if (!edev)
	346	return;
	347
	348	for (i = 0; i < BNXT_MAX_ULP; i++) {
	349	struct bnxt_ulp *ulp = &edev->ulp_tbl[i];
	350
	351	ops = rtnl_dereference(ulp->ulp_ops);
	352	if (!ops \|\| !ops->ulp_shutdown)
	353	continue;
	354	ops->ulp_shutdown(ulp->handle);
	355	}
	356	}
	357
ec86f14e MC	358	void bnxt_ulp_irq_stop(struct bnxt *bp)
	359	{
	360	struct bnxt_en_dev *edev = bp->edev;
	361	struct bnxt_ulp_ops *ops;
	362
	363	if (!edev \|\| !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
	364	return;
	365
	366	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP)) {
	367	struct bnxt_ulp *ulp = &edev->ulp_tbl[BNXT_ROCE_ULP];
	368
	369	if (!ulp->msix_requested)
	370	return;
	371
	372	ops = rtnl_dereference(ulp->ulp_ops);
	373	if (!ops \|\| !ops->ulp_irq_stop)
	374	return;
	375	ops->ulp_irq_stop(ulp->handle);
	376	}
	377	}
	378
	379	void bnxt_ulp_irq_restart(struct bnxt *bp, int err)
	380	{
	381	struct bnxt_en_dev *edev = bp->edev;
	382	struct bnxt_ulp_ops *ops;
	383
	384	if (!edev \|\| !(edev->flags & BNXT_EN_FLAG_MSIX_REQUESTED))
	385	return;
	386
	387	if (bnxt_ulp_registered(bp->edev, BNXT_ROCE_ULP)) {
	388	struct bnxt_ulp *ulp = &edev->ulp_tbl[BNXT_ROCE_ULP];
	389	struct bnxt_msix_entry *ent = NULL;
	390
	391	if (!ulp->msix_requested)
	392	return;
	393
	394	ops = rtnl_dereference(ulp->ulp_ops);
	395	if (!ops \|\| !ops->ulp_irq_restart)
	396	return;
	397
	398	if (!err) {
	399	ent = kcalloc(ulp->msix_requested, sizeof(*ent),
	400	GFP_KERNEL);
	401	if (!ent)
	402	return;
	403	bnxt_fill_msix_vecs(bp, ent);
	404	}
	405	ops->ulp_irq_restart(ulp->handle, ent);
	406	kfree(ent);
	407	}
	408	}
	409
a588e458 MC	410	void bnxt_ulp_async_events(struct bnxt bp, struct hwrm_async_event_cmpl cmpl)
	411	{
	412	u16 event_id = le16_to_cpu(cmpl->event_id);
	413	struct bnxt_en_dev *edev = bp->edev;
	414	struct bnxt_ulp_ops *ops;
	415	int i;
	416
	417	if (!edev)
	418	return;
	419
	420	rcu_read_lock();
	421	for (i = 0; i < BNXT_MAX_ULP; i++) {
	422	struct bnxt_ulp *ulp = &edev->ulp_tbl[i];
	423
	424	ops = rcu_dereference(ulp->ulp_ops);
	425	if (!ops \|\| !ops->ulp_async_notifier)
	426	continue;
	427	if (!ulp->async_events_bmap \|\|
	428	event_id > ulp->max_async_event_id)
	429	continue;
	430
	431	/* Read max_async_event_id first before testing the bitmap. */
	432	smp_rmb();
	433	if (test_bit(event_id, ulp->async_events_bmap))
	434	ops->ulp_async_notifier(ulp->handle, cmpl);
	435	}
	436	rcu_read_unlock();
	437	}
	438
	439	static int bnxt_register_async_events(struct bnxt_en_dev *edev, int ulp_id,
	440	unsigned long *events_bmap, u16 max_id)
	441	{
	442	struct net_device *dev = edev->net;
	443	struct bnxt *bp = netdev_priv(dev);
	444	struct bnxt_ulp *ulp;
	445
	446	if (ulp_id >= BNXT_MAX_ULP)
	447	return -EINVAL;
	448
	449	ulp = &edev->ulp_tbl[ulp_id];
	450	ulp->async_events_bmap = events_bmap;
	451	/* Make sure bnxt_ulp_async_events() sees this order */
	452	smp_wmb();
	453	ulp->max_async_event_id = max_id;
2e882468	454	bnxt_hwrm_func_drv_rgtr(bp, events_bmap, max_id + 1, true);
a588e458 MC	455	return 0;
	456	}
	457
	458	static const struct bnxt_en_ops bnxt_en_ops_tbl = {
	459	.bnxt_register_device = bnxt_register_dev,
	460	.bnxt_unregister_device = bnxt_unregister_dev,
	461	.bnxt_request_msix = bnxt_req_msix_vecs,
	462	.bnxt_free_msix = bnxt_free_msix_vecs,
	463	.bnxt_send_fw_msg = bnxt_send_msg,
	464	.bnxt_register_fw_async_events = bnxt_register_async_events,
	465	};
	466
	467	struct bnxt_en_dev bnxt_ulp_probe(struct net_device dev)
	468	{
	469	struct bnxt *bp = netdev_priv(dev);
	470	struct bnxt_en_dev *edev;
	471
	472	edev = bp->edev;
	473	if (!edev) {
	474	edev = kzalloc(sizeof(*edev), GFP_KERNEL);
	475	if (!edev)
	476	return ERR_PTR(-ENOMEM);
	477	edev->en_ops = &bnxt_en_ops_tbl;
	478	if (bp->flags & BNXT_FLAG_ROCEV1_CAP)
	479	edev->flags \|= BNXT_EN_FLAG_ROCEV1_CAP;
	480	if (bp->flags & BNXT_FLAG_ROCEV2_CAP)
	481	edev->flags \|= BNXT_EN_FLAG_ROCEV2_CAP;
	482	edev->net = dev;
	483	edev->pdev = bp->pdev;
098286ff MC	484	edev->l2_db_size = bp->db_size;
098286ff MC	485	edev->l2_db_size_nc = bp->db_size;
a588e458 MC	486	bp->edev = edev;
	487	}
	488	return bp->edev;
	489	}