[linux-block.git] / drivers / net / ethernet / qlogic / qede / qede_rdma.c

// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
/* QLogic qedr NIC Driver
 * Copyright (c) 2015-2017  QLogic Corporation
 * Copyright (c) 2019-2020 Marvell International Ltd.
 */

#include <linux/pci.h>
#include <linux/netdevice.h>
#include <linux/list.h>
#include <linux/mutex.h>
#include <linux/qed/qede_rdma.h>
#include "qede.h"

static struct qedr_driver *qedr_drv;
static LIST_HEAD(qedr_dev_list);
static DEFINE_MUTEX(qedr_dev_list_lock);

bool qede_rdma_supported(struct qede_dev *dev)
{
	return dev->dev_info.common.rdma_supported;
}

static void _qede_rdma_dev_add(struct qede_dev *edev)
{
	if (!qedr_drv)
		return;

	/* Leftovers from previous error recovery */
	edev->rdma_info.exp_recovery = false;
	edev->rdma_info.qedr_dev = qedr_drv->add(edev->cdev, edev->pdev,
						 edev->ndev);
}

static int qede_rdma_create_wq(struct qede_dev *edev)
{
	INIT_LIST_HEAD(&edev->rdma_info.rdma_event_list);
	kref_init(&edev->rdma_info.refcnt);
	init_completion(&edev->rdma_info.event_comp);

	edev->rdma_info.rdma_wq = create_singlethread_workqueue("rdma_wq");
	if (!edev->rdma_info.rdma_wq) {
		DP_NOTICE(edev, "qedr: Could not create workqueue\n");
		return -ENOMEM;
	}

	return 0;
}

static void qede_rdma_cleanup_event(struct qede_dev *edev)
{
	struct list_head *head = &edev->rdma_info.rdma_event_list;
	struct qede_rdma_event_work *event_node;

	flush_workqueue(edev->rdma_info.rdma_wq);
	while (!list_empty(head)) {
		event_node = list_entry(head->next, struct qede_rdma_event_work,
					list);
		cancel_work_sync(&event_node->work);
		list_del(&event_node->list);
		kfree(event_node);
	}
}

static void qede_rdma_complete_event(struct kref *ref)
{
	struct qede_rdma_dev *rdma_dev =
		container_of(ref, struct qede_rdma_dev, refcnt);

	/* no more events will be added after this */
	complete(&rdma_dev->event_comp);
}

static void qede_rdma_destroy_wq(struct qede_dev *edev)
{
	/* Avoid race with add_event flow, make sure it finishes before
	 * we start accessing the list and cleaning up the work
	 */
	kref_put(&edev->rdma_info.refcnt, qede_rdma_complete_event);
	wait_for_completion(&edev->rdma_info.event_comp);

	qede_rdma_cleanup_event(edev);
	destroy_workqueue(edev->rdma_info.rdma_wq);
	edev->rdma_info.rdma_wq = NULL;
}

int qede_rdma_dev_add(struct qede_dev *edev, bool recovery)
{
	int rc;

	if (!qede_rdma_supported(edev))
		return 0;

	/* Cannot start qedr while recovering since it wasn't fully stopped */
	if (recovery)
		return 0;

	rc = qede_rdma_create_wq(edev);
	if (rc)
		return rc;

	INIT_LIST_HEAD(&edev->rdma_info.entry);
	mutex_lock(&qedr_dev_list_lock);
	list_add_tail(&edev->rdma_info.entry, &qedr_dev_list);
	_qede_rdma_dev_add(edev);
	mutex_unlock(&qedr_dev_list_lock);

	return rc;
}

static void _qede_rdma_dev_remove(struct qede_dev *edev)
{
	if (qedr_drv && qedr_drv->remove && edev->rdma_info.qedr_dev)
		qedr_drv->remove(edev->rdma_info.qedr_dev);
}

void qede_rdma_dev_remove(struct qede_dev *edev, bool recovery)
{
	if (!qede_rdma_supported(edev))
		return;

	/* Cannot remove qedr while recovering since it wasn't fully stopped */
	if (!recovery) {
		qede_rdma_destroy_wq(edev);
		mutex_lock(&qedr_dev_list_lock);
		if (!edev->rdma_info.exp_recovery)
			_qede_rdma_dev_remove(edev);
		edev->rdma_info.qedr_dev = NULL;
		list_del(&edev->rdma_info.entry);
		mutex_unlock(&qedr_dev_list_lock);
	} else {
		if (!edev->rdma_info.exp_recovery) {
			mutex_lock(&qedr_dev_list_lock);
			_qede_rdma_dev_remove(edev);
			mutex_unlock(&qedr_dev_list_lock);
		}
		edev->rdma_info.exp_recovery = true;
	}
}

static void _qede_rdma_dev_open(struct qede_dev *edev)
{
	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
		qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_UP);
}

static void qede_rdma_dev_open(struct qede_dev *edev)
{
	if (!qede_rdma_supported(edev))
		return;

	mutex_lock(&qedr_dev_list_lock);
	_qede_rdma_dev_open(edev);
	mutex_unlock(&qedr_dev_list_lock);
}

static void _qede_rdma_dev_close(struct qede_dev *edev)
{
	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
		qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_DOWN);
}

static void qede_rdma_dev_close(struct qede_dev *edev)
{
	if (!qede_rdma_supported(edev))
		return;

	mutex_lock(&qedr_dev_list_lock);
	_qede_rdma_dev_close(edev);
	mutex_unlock(&qedr_dev_list_lock);
}

static void qede_rdma_dev_shutdown(struct qede_dev *edev)
{
	if (!qede_rdma_supported(edev))
		return;

	mutex_lock(&qedr_dev_list_lock);
	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
		qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_CLOSE);
	mutex_unlock(&qedr_dev_list_lock);
}

int qede_rdma_register_driver(struct qedr_driver *drv)
{
	struct qede_dev *edev;
	u8 qedr_counter = 0;

	mutex_lock(&qedr_dev_list_lock);
	if (qedr_drv) {
		mutex_unlock(&qedr_dev_list_lock);
		return -EINVAL;
	}
	qedr_drv = drv;

	list_for_each_entry(edev, &qedr_dev_list, rdma_info.entry) {
		struct net_device *ndev;

		qedr_counter++;
		_qede_rdma_dev_add(edev);
		ndev = edev->ndev;
		if (netif_running(ndev) && netif_oper_up(ndev))
			_qede_rdma_dev_open(edev);
	}
	mutex_unlock(&qedr_dev_list_lock);

	pr_notice("qedr: discovered and registered %d RDMA funcs\n",
		  qedr_counter);

	return 0;
}
EXPORT_SYMBOL(qede_rdma_register_driver);

void qede_rdma_unregister_driver(struct qedr_driver *drv)
{
	struct qede_dev *edev;

	mutex_lock(&qedr_dev_list_lock);
	list_for_each_entry(edev, &qedr_dev_list, rdma_info.entry) {
		/* If device has experienced recovery it was already removed */
		if (edev->rdma_info.qedr_dev && !edev->rdma_info.exp_recovery)
			_qede_rdma_dev_remove(edev);
	}
	qedr_drv = NULL;
	mutex_unlock(&qedr_dev_list_lock);
}
EXPORT_SYMBOL(qede_rdma_unregister_driver);

static void qede_rdma_changeaddr(struct qede_dev *edev)
{
	if (!qede_rdma_supported(edev))
		return;

	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
		qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_CHANGE_ADDR);
}

static void qede_rdma_change_mtu(struct qede_dev *edev)
{
	if (qede_rdma_supported(edev)) {
		if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
			qedr_drv->notify(edev->rdma_info.qedr_dev,
					 QEDE_CHANGE_MTU);
	}
}

static struct qede_rdma_event_work *
qede_rdma_get_free_event_node(struct qede_dev *edev)
{
	struct qede_rdma_event_work *event_node = NULL;
	bool found = false;

	list_for_each_entry(event_node, &edev->rdma_info.rdma_event_list,
			    list) {
		if (!work_pending(&event_node->work)) {
			found = true;
			break;
		}
	}

	if (!found) {
		event_node = kzalloc(sizeof(*event_node), GFP_ATOMIC);
		if (!event_node) {
			DP_NOTICE(edev,
				  "qedr: Could not allocate memory for rdma work\n");
			return NULL;
		}
		list_add_tail(&event_node->list,
			      &edev->rdma_info.rdma_event_list);
	}

	return event_node;
}

static void qede_rdma_handle_event(struct work_struct *work)
{
	struct qede_rdma_event_work *event_node;
	enum qede_rdma_event event;
	struct qede_dev *edev;

	event_node = container_of(work, struct qede_rdma_event_work, work);
	event = event_node->event;
	edev = event_node->ptr;

	switch (event) {
	case QEDE_UP:
		qede_rdma_dev_open(edev);
		break;
	case QEDE_DOWN:
		qede_rdma_dev_close(edev);
		break;
	case QEDE_CLOSE:
		qede_rdma_dev_shutdown(edev);
		break;
	case QEDE_CHANGE_ADDR:
		qede_rdma_changeaddr(edev);
		break;
	case QEDE_CHANGE_MTU:
		qede_rdma_change_mtu(edev);
		break;
	default:
		DP_NOTICE(edev, "Invalid rdma event %d", event);
	}
}

static void qede_rdma_add_event(struct qede_dev *edev,
				enum qede_rdma_event event)
{
	struct qede_rdma_event_work *event_node;

	/* If a recovery was experienced avoid adding the event */
	if (edev->rdma_info.exp_recovery)
		return;

	if (!edev->rdma_info.qedr_dev || !edev->rdma_info.rdma_wq)
		return;

	/* We don't want the cleanup flow to start while we're allocating and
	 * scheduling the work
	 */
	if (!kref_get_unless_zero(&edev->rdma_info.refcnt))
		return; /* already being destroyed */

	event_node = qede_rdma_get_free_event_node(edev);
	if (!event_node)
		goto out;

	event_node->event = event;
	event_node->ptr = edev;

	INIT_WORK(&event_node->work, qede_rdma_handle_event);
	queue_work(edev->rdma_info.rdma_wq, &event_node->work);

out:
	kref_put(&edev->rdma_info.refcnt, qede_rdma_complete_event);
}

void qede_rdma_dev_event_open(struct qede_dev *edev)
{
	qede_rdma_add_event(edev, QEDE_UP);
}

void qede_rdma_dev_event_close(struct qede_dev *edev)
{
	qede_rdma_add_event(edev, QEDE_DOWN);
}

void qede_rdma_event_changeaddr(struct qede_dev *edev)
{
	qede_rdma_add_event(edev, QEDE_CHANGE_ADDR);
}

void qede_rdma_event_change_mtu(struct qede_dev *edev)
{
	qede_rdma_add_event(edev, QEDE_CHANGE_MTU);
}
Commit	Line	Data
	1	// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)
	2	/* QLogic qedr NIC Driver
	3	* Copyright (c) 2015-2017 QLogic Corporation
	4	* Copyright (c) 2019-2020 Marvell International Ltd.
	5	*/
	6
	7	#include <linux/pci.h>
	8	#include <linux/netdevice.h>
	9	#include <linux/list.h>
	10	#include <linux/mutex.h>
	11	#include <linux/qed/qede_rdma.h>
	12	#include "qede.h"
	13
	14	static struct qedr_driver *qedr_drv;
	15	static LIST_HEAD(qedr_dev_list);
	16	static DEFINE_MUTEX(qedr_dev_list_lock);
	17
	18	bool qede_rdma_supported(struct qede_dev *dev)
	19	{
	20	return dev->dev_info.common.rdma_supported;
	21	}
	22
	23	static void _qede_rdma_dev_add(struct qede_dev *edev)
	24	{
	25	if (!qedr_drv)
	26	return;
	27
	28	/* Leftovers from previous error recovery */
	29	edev->rdma_info.exp_recovery = false;
	30	edev->rdma_info.qedr_dev = qedr_drv->add(edev->cdev, edev->pdev,
	31	edev->ndev);
	32	}
	33
	34	static int qede_rdma_create_wq(struct qede_dev *edev)
	35	{
	36	INIT_LIST_HEAD(&edev->rdma_info.rdma_event_list);
	37	kref_init(&edev->rdma_info.refcnt);
	38	init_completion(&edev->rdma_info.event_comp);
	39
	40	edev->rdma_info.rdma_wq = create_singlethread_workqueue("rdma_wq");
	41	if (!edev->rdma_info.rdma_wq) {
	42	DP_NOTICE(edev, "qedr: Could not create workqueue\n");
	43	return -ENOMEM;
	44	}
	45
	46	return 0;
	47	}
	48
	49	static void qede_rdma_cleanup_event(struct qede_dev *edev)
	50	{
	51	struct list_head *head = &edev->rdma_info.rdma_event_list;
	52	struct qede_rdma_event_work *event_node;
	53
	54	flush_workqueue(edev->rdma_info.rdma_wq);
	55	while (!list_empty(head)) {
	56	event_node = list_entry(head->next, struct qede_rdma_event_work,
	57	list);
	58	cancel_work_sync(&event_node->work);
	59	list_del(&event_node->list);
	60	kfree(event_node);
	61	}
	62	}
	63
	64	static void qede_rdma_complete_event(struct kref *ref)
	65	{
	66	struct qede_rdma_dev *rdma_dev =
	67	container_of(ref, struct qede_rdma_dev, refcnt);
	68
	69	/* no more events will be added after this */
	70	complete(&rdma_dev->event_comp);
	71	}
	72
	73	static void qede_rdma_destroy_wq(struct qede_dev *edev)
	74	{
	75	/* Avoid race with add_event flow, make sure it finishes before
	76	* we start accessing the list and cleaning up the work
	77	*/
	78	kref_put(&edev->rdma_info.refcnt, qede_rdma_complete_event);
	79	wait_for_completion(&edev->rdma_info.event_comp);
	80
	81	qede_rdma_cleanup_event(edev);
	82	destroy_workqueue(edev->rdma_info.rdma_wq);
	83	edev->rdma_info.rdma_wq = NULL;
	84	}
	85
	86	int qede_rdma_dev_add(struct qede_dev *edev, bool recovery)
	87	{
	88	int rc;
	89
	90	if (!qede_rdma_supported(edev))
	91	return 0;
	92
	93	/* Cannot start qedr while recovering since it wasn't fully stopped */
	94	if (recovery)
	95	return 0;
	96
	97	rc = qede_rdma_create_wq(edev);
	98	if (rc)
	99	return rc;
	100
	101	INIT_LIST_HEAD(&edev->rdma_info.entry);
	102	mutex_lock(&qedr_dev_list_lock);
	103	list_add_tail(&edev->rdma_info.entry, &qedr_dev_list);
	104	_qede_rdma_dev_add(edev);
	105	mutex_unlock(&qedr_dev_list_lock);
	106
	107	return rc;
	108	}
	109
	110	static void _qede_rdma_dev_remove(struct qede_dev *edev)
	111	{
	112	if (qedr_drv && qedr_drv->remove && edev->rdma_info.qedr_dev)
	113	qedr_drv->remove(edev->rdma_info.qedr_dev);
	114	}
	115
	116	void qede_rdma_dev_remove(struct qede_dev *edev, bool recovery)
	117	{
	118	if (!qede_rdma_supported(edev))
	119	return;
	120
	121	/* Cannot remove qedr while recovering since it wasn't fully stopped */
	122	if (!recovery) {
	123	qede_rdma_destroy_wq(edev);
	124	mutex_lock(&qedr_dev_list_lock);
	125	if (!edev->rdma_info.exp_recovery)
	126	_qede_rdma_dev_remove(edev);
	127	edev->rdma_info.qedr_dev = NULL;
	128	list_del(&edev->rdma_info.entry);
	129	mutex_unlock(&qedr_dev_list_lock);
	130	} else {
	131	if (!edev->rdma_info.exp_recovery) {
	132	mutex_lock(&qedr_dev_list_lock);
	133	_qede_rdma_dev_remove(edev);
	134	mutex_unlock(&qedr_dev_list_lock);
	135	}
	136	edev->rdma_info.exp_recovery = true;
	137	}
	138	}
	139
	140	static void _qede_rdma_dev_open(struct qede_dev *edev)
	141	{
	142	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
	143	qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_UP);
	144	}
	145
	146	static void qede_rdma_dev_open(struct qede_dev *edev)
	147	{
	148	if (!qede_rdma_supported(edev))
	149	return;
	150
	151	mutex_lock(&qedr_dev_list_lock);
	152	_qede_rdma_dev_open(edev);
	153	mutex_unlock(&qedr_dev_list_lock);
	154	}
	155
	156	static void _qede_rdma_dev_close(struct qede_dev *edev)
	157	{
	158	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
	159	qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_DOWN);
	160	}
	161
	162	static void qede_rdma_dev_close(struct qede_dev *edev)
	163	{
	164	if (!qede_rdma_supported(edev))
	165	return;
	166
	167	mutex_lock(&qedr_dev_list_lock);
	168	_qede_rdma_dev_close(edev);
	169	mutex_unlock(&qedr_dev_list_lock);
	170	}
	171
	172	static void qede_rdma_dev_shutdown(struct qede_dev *edev)
	173	{
	174	if (!qede_rdma_supported(edev))
	175	return;
	176
	177	mutex_lock(&qedr_dev_list_lock);
	178	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
	179	qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_CLOSE);
	180	mutex_unlock(&qedr_dev_list_lock);
	181	}
	182
	183	int qede_rdma_register_driver(struct qedr_driver *drv)
	184	{
	185	struct qede_dev *edev;
	186	u8 qedr_counter = 0;
	187
	188	mutex_lock(&qedr_dev_list_lock);
	189	if (qedr_drv) {
	190	mutex_unlock(&qedr_dev_list_lock);
	191	return -EINVAL;
	192	}
	193	qedr_drv = drv;
	194
	195	list_for_each_entry(edev, &qedr_dev_list, rdma_info.entry) {
	196	struct net_device *ndev;
	197
	198	qedr_counter++;
	199	_qede_rdma_dev_add(edev);
	200	ndev = edev->ndev;
	201	if (netif_running(ndev) && netif_oper_up(ndev))
	202	_qede_rdma_dev_open(edev);
	203	}
	204	mutex_unlock(&qedr_dev_list_lock);
	205
	206	pr_notice("qedr: discovered and registered %d RDMA funcs\n",
	207	qedr_counter);
	208
	209	return 0;
	210	}
	211	EXPORT_SYMBOL(qede_rdma_register_driver);
	212
	213	void qede_rdma_unregister_driver(struct qedr_driver *drv)
	214	{
	215	struct qede_dev *edev;
	216
	217	mutex_lock(&qedr_dev_list_lock);
	218	list_for_each_entry(edev, &qedr_dev_list, rdma_info.entry) {
	219	/* If device has experienced recovery it was already removed */
	220	if (edev->rdma_info.qedr_dev && !edev->rdma_info.exp_recovery)
	221	_qede_rdma_dev_remove(edev);
	222	}
	223	qedr_drv = NULL;
	224	mutex_unlock(&qedr_dev_list_lock);
	225	}
	226	EXPORT_SYMBOL(qede_rdma_unregister_driver);
	227
	228	static void qede_rdma_changeaddr(struct qede_dev *edev)
	229	{
	230	if (!qede_rdma_supported(edev))
	231	return;
	232
	233	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
	234	qedr_drv->notify(edev->rdma_info.qedr_dev, QEDE_CHANGE_ADDR);
	235	}
	236
	237	static void qede_rdma_change_mtu(struct qede_dev *edev)
	238	{
	239	if (qede_rdma_supported(edev)) {
	240	if (qedr_drv && edev->rdma_info.qedr_dev && qedr_drv->notify)
	241	qedr_drv->notify(edev->rdma_info.qedr_dev,
	242	QEDE_CHANGE_MTU);
	243	}
	244	}
	245
	246	static struct qede_rdma_event_work *
	247	qede_rdma_get_free_event_node(struct qede_dev *edev)
	248	{
	249	struct qede_rdma_event_work *event_node = NULL;
	250	bool found = false;
	251
	252	list_for_each_entry(event_node, &edev->rdma_info.rdma_event_list,
	253	list) {
	254	if (!work_pending(&event_node->work)) {
	255	found = true;
	256	break;
	257	}
	258	}
	259
	260	if (!found) {
	261	event_node = kzalloc(sizeof(*event_node), GFP_ATOMIC);
	262	if (!event_node) {
	263	DP_NOTICE(edev,
	264	"qedr: Could not allocate memory for rdma work\n");
	265	return NULL;
	266	}
	267	list_add_tail(&event_node->list,
	268	&edev->rdma_info.rdma_event_list);
	269	}
	270
	271	return event_node;
	272	}
	273
	274	static void qede_rdma_handle_event(struct work_struct *work)
	275	{
	276	struct qede_rdma_event_work *event_node;
	277	enum qede_rdma_event event;
	278	struct qede_dev *edev;
	279
	280	event_node = container_of(work, struct qede_rdma_event_work, work);
	281	event = event_node->event;
	282	edev = event_node->ptr;
	283
	284	switch (event) {
	285	case QEDE_UP:
	286	qede_rdma_dev_open(edev);
	287	break;
	288	case QEDE_DOWN:
	289	qede_rdma_dev_close(edev);
	290	break;
	291	case QEDE_CLOSE:
	292	qede_rdma_dev_shutdown(edev);
	293	break;
	294	case QEDE_CHANGE_ADDR:
	295	qede_rdma_changeaddr(edev);
	296	break;
	297	case QEDE_CHANGE_MTU:
	298	qede_rdma_change_mtu(edev);
	299	break;
	300	default:
	301	DP_NOTICE(edev, "Invalid rdma event %d", event);
	302	}
	303	}
	304
	305	static void qede_rdma_add_event(struct qede_dev *edev,
	306	enum qede_rdma_event event)
	307	{
	308	struct qede_rdma_event_work *event_node;
	309
	310	/* If a recovery was experienced avoid adding the event */
	311	if (edev->rdma_info.exp_recovery)
	312	return;
	313
	314	if (!edev->rdma_info.qedr_dev \|\| !edev->rdma_info.rdma_wq)
	315	return;
	316
	317	/* We don't want the cleanup flow to start while we're allocating and
	318	* scheduling the work
	319	*/
	320	if (!kref_get_unless_zero(&edev->rdma_info.refcnt))
	321	return; /* already being destroyed */
	322
	323	event_node = qede_rdma_get_free_event_node(edev);
	324	if (!event_node)
	325	goto out;
	326
	327	event_node->event = event;
	328	event_node->ptr = edev;
	329
	330	INIT_WORK(&event_node->work, qede_rdma_handle_event);
	331	queue_work(edev->rdma_info.rdma_wq, &event_node->work);
	332
	333	out:
	334	kref_put(&edev->rdma_info.refcnt, qede_rdma_complete_event);
	335	}
	336
	337	void qede_rdma_dev_event_open(struct qede_dev *edev)
	338	{
	339	qede_rdma_add_event(edev, QEDE_UP);
	340	}
	341
	342	void qede_rdma_dev_event_close(struct qede_dev *edev)
	343	{
	344	qede_rdma_add_event(edev, QEDE_DOWN);
	345	}
	346
	347	void qede_rdma_event_changeaddr(struct qede_dev *edev)
	348	{
	349	qede_rdma_add_event(edev, QEDE_CHANGE_ADDR);
	350	}
	351
	352	void qede_rdma_event_change_mtu(struct qede_dev *edev)
	353	{
	354	qede_rdma_add_event(edev, QEDE_CHANGE_MTU);
	355	}