Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 993e15a9 authored by Chris Lew's avatar Chris Lew
Browse files

Revert "net: qrtr: Send HELLO message on endpoint register" 



This reverts commit d33025a7.

Originally MHI Host API's assumed the client would not send until it
first received a packet from the device. This assumption is broken with
the change to queue hello work.

The MHI driver should split the channel initialization so that probe
occurs after the UL channel is started. This will allow the QRTR driver
to send immediately after probe. Revert this change until the channel
initialization change from MHI is ready.

Change-Id: I174d8c204eb1c36b0519005f15d79080fed8139f
Signed-off-by: default avatarChris Lew <clew@codeaurora.org>
parent a7269cee

net/qrtr/mhi.c

+2 −1
Original line number Diff line number Diff line
@@ -175,11 +175,12 @@ static int qcom_mhi_qrtr_probe(struct mhi_device *mhi_dev, 
	INIT_LIST_HEAD(&qdev->ul_pkts);

	spin_lock_init(&qdev->ul_lock);



	dev_set_drvdata(&mhi_dev->dev, qdev);

	rc = qrtr_endpoint_register(&qdev->ep, net_id, rt);

	if (rc)

		return rc;



	dev_set_drvdata(&mhi_dev->dev, qdev);



	dev_dbg(qdev->dev, "Qualcomm MHI QRTR driver probed\n");



	return 0;

net/qrtr/qrtr.c

+7 −74
Original line number Diff line number Diff line
@@ -151,7 +151,6 @@ static DEFINE_MUTEX(qrtr_port_lock); 
 * @kworker: worker thread for recv work

 * @task: task to run the worker thread

 * @read_data: scheduled work for recv work

 * @say_hello: scheduled work for initiating hello

 * @ws: wakeupsource avoid system suspend

 * @ilc: ipc logging context reference

 */
@@ -162,7 +161,6 @@ struct qrtr_node { 
	unsigned int nid;

	unsigned int net_id;

	atomic_t hello_sent;

	atomic_t hello_rcvd;



	struct radix_tree_root qrtr_tx_flow;

	struct wait_queue_head resume_tx;
@@ -174,7 +172,6 @@ struct qrtr_node { 
	struct kthread_worker kworker;

	struct task_struct *task;

	struct kthread_work read_data;

	struct kthread_work say_hello;



	struct wakeup_source *ws;
@@ -519,10 +516,6 @@ static int qrtr_node_enqueue(struct qrtr_node *node, struct sk_buff *skb, 
		kfree_skb(skb);

		return rc;

	}

	if (atomic_read(&node->hello_sent) && type == QRTR_TYPE_HELLO) {

		kfree_skb(skb);

		return 0;

	}



	/* If sk is null, this is a forwarded packet and should not wait */

	if (!skb->sk) {
@@ -885,30 +878,6 @@ static void qrtr_fwd_pkt(struct sk_buff *skb, struct qrtr_cb *cb) 
	qrtr_node_enqueue(node, skb, cb->type, &from, &to, 0);

	qrtr_node_release(node);

}



static void qrtr_sock_queue_skb(struct qrtr_node *node, struct sk_buff *skb,

				struct qrtr_sock *ipc)

{

	struct qrtr_cb *cb = (struct qrtr_cb *)skb->cb;

	int rc;



	/* Don't queue HELLO if control port already received */

	if (cb->type == QRTR_TYPE_HELLO) {

		if (atomic_read(&node->hello_rcvd)) {

			kfree_skb(skb);

			return;

		}

		atomic_inc(&node->hello_rcvd);

	}



	rc = sock_queue_rcv_skb(&ipc->sk, skb);

	if (rc) {

		pr_err("%s: qrtr pkt dropped flow[%d] rc[%d]\n",

		       __func__, cb->confirm_rx, rc);

		kfree_skb(skb);

	}

}



/* Handle and route a received packet.

 *

 * This will auto-reply with resume-tx packet as necessary.
@@ -951,40 +920,18 @@ static void qrtr_node_rx_work(struct kthread_work *work) 
			if (!ipc) {

				kfree_skb(skb);

			} else {

				qrtr_sock_queue_skb(node, skb, ipc);

				if (sock_queue_rcv_skb(&ipc->sk, skb)) {

					pr_err("%s qrtr pkt dropped flow[%d]\n",

					       __func__, cb->confirm_rx);

					kfree_skb(skb);

				}



				qrtr_port_put(ipc);

			}

		}

	}

}



static void qrtr_hello_work(struct kthread_work *work)

{

	struct sockaddr_qrtr from = {AF_QIPCRTR, 0, QRTR_PORT_CTRL};

	struct sockaddr_qrtr to = {AF_QIPCRTR, 0, QRTR_PORT_CTRL};

	struct qrtr_ctrl_pkt *pkt;

	struct qrtr_node *node;

	struct qrtr_sock *ctrl;

	struct sk_buff *skb;



	ctrl = qrtr_port_lookup(QRTR_PORT_CTRL);

	if (!ctrl)

		return;



	skb = qrtr_alloc_ctrl_packet(&pkt);

	if (!skb) {

		qrtr_port_put(ctrl);

		return;

	}



	node = container_of(work, struct qrtr_node, say_hello);

	pkt->cmd = cpu_to_le32(QRTR_TYPE_HELLO);

	from.sq_node = qrtr_local_nid;

	to.sq_node = node->nid;

	qrtr_node_enqueue(node, skb, QRTR_TYPE_HELLO, &from, &to, 0);

	qrtr_port_put(ctrl);

}



/**

 * qrtr_endpoint_register() - register a new endpoint

 * @ep: endpoint to register
@@ -1013,10 +960,8 @@ int qrtr_endpoint_register(struct qrtr_endpoint *ep, unsigned int net_id, 
	node->nid = QRTR_EP_NID_AUTO;

	node->ep = ep;

	atomic_set(&node->hello_sent, 0);

	atomic_set(&node->hello_rcvd, 0);



	kthread_init_work(&node->read_data, qrtr_node_rx_work);

	kthread_init_work(&node->say_hello, qrtr_hello_work);

	kthread_init_worker(&node->kworker);

	node->task = kthread_run(kthread_worker_fn, &node->kworker, "qrtr_rx");

	if (IS_ERR(node->task)) {
@@ -1038,7 +983,6 @@ int qrtr_endpoint_register(struct qrtr_endpoint *ep, unsigned int net_id, 
	up_write(&qrtr_node_lock);

	ep->node = node;



	kthread_queue_work(&node->kworker, &node->say_hello);

	return 0;

}

EXPORT_SYMBOL_GPL(qrtr_endpoint_register);
@@ -1320,17 +1264,6 @@ static int __qrtr_bind(struct socket *sock, 
		qrtr_reset_ports();

	mutex_unlock(&qrtr_port_lock);



	if (port == QRTR_PORT_CTRL) {

		struct qrtr_node *node;



		down_write(&qrtr_node_lock);

		list_for_each_entry(node, &qrtr_all_epts, item) {

			atomic_set(&node->hello_sent, 0);

			atomic_set(&node->hello_rcvd, 0);

		}

		up_write(&qrtr_node_lock);

	}



	/* unbind previous, if any */

	if (!zapped)

		qrtr_port_remove(ipc);
@@ -1430,7 +1363,7 @@ static int qrtr_bcast_enqueue(struct qrtr_node *node, struct sk_buff *skb, 


	down_read(&qrtr_node_lock);

	list_for_each_entry(node, &qrtr_all_epts, item) {

		if (node->nid == QRTR_EP_NID_AUTO && type != QRTR_TYPE_HELLO)

		if (node->nid == QRTR_EP_NID_AUTO)

			continue;

		skbn = skb_clone(skb, GFP_KERNEL);

		if (!skbn)