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

Commit 19a85100 authored by Subash Abhinov Kasiviswanathan's avatar Subash Abhinov Kasiviswanathan
Browse files

soc: qcom: dfc: DFC powersave fixes 



-Fixed possible data stall that could happen after APM due to
queues not being enabled.
-Removed rtnl lock so powersave will not be delayed.
-Fixed race condition to set default grant when powersave is enabled.

Change-Id: Iaef95e814c2a3dee39e1da6dd334a3439c0ccbf8
Acked-by: default avatarWeiyi Chen <weiyic@qti.qualcomm.com>
Signed-off-by: default avatarSubash Abhinov Kasiviswanathan <subashab@codeaurora.org>
parent 1d004cde

drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c

+20 −2
Original line number Diff line number Diff line
@@ -221,6 +221,7 @@ static void rmnet_dellink(struct net_device *dev, struct list_head *head) 
		hlist_del_init_rcu(&ep->hlnode);

		rmnet_unregister_bridge(dev, port);

		rmnet_vnd_dellink(mux_id, port, ep);

		synchronize_rcu();

		kfree(ep);

	}

	rmnet_unregister_real_device(real_dev, port);
@@ -244,7 +245,6 @@ static void rmnet_force_unassociate_device(struct net_device *dev) 


	port = rmnet_get_port_rtnl(dev);



	rcu_read_lock();

	rmnet_unregister_bridge(dev, port);



	hash_for_each_safe(port->muxed_ep, bkt_ep, tmp_ep, ep, hlnode) {
@@ -252,10 +252,10 @@ static void rmnet_force_unassociate_device(struct net_device *dev) 
		rmnet_vnd_dellink(ep->mux_id, port, ep);



		hlist_del_init_rcu(&ep->hlnode);

		synchronize_rcu();

		kfree(ep);

	}



	rcu_read_unlock();

	unregister_netdevice_many(&list);



	qmi_rmnet_qmi_exit(port->qmi_info, port);
@@ -587,6 +587,24 @@ void rmnet_clear_powersave_format(void *port) 
	((struct rmnet_port *)port)->data_format &= ~RMNET_INGRESS_FORMAT_PS;

}

EXPORT_SYMBOL(rmnet_clear_powersave_format);



void rmnet_enable_all_flows(void *port)

{

	struct rmnet_endpoint *ep;

	unsigned long bkt;



	if (unlikely(!port))

		return;



	rcu_read_lock();

	hash_for_each_rcu(((struct rmnet_port *)port)->muxed_ep,

			  bkt, ep, hlnode) {

		qmi_rmnet_enable_all_flows(ep->egress_dev);

	}

	rcu_read_unlock();

}

EXPORT_SYMBOL(rmnet_enable_all_flows);



#endif



/* Startup/Shutdown */

drivers/net/ethernet/qualcomm/rmnet/rmnet_handlers.c

+4 −10
Original line number Diff line number Diff line
@@ -170,11 +170,8 @@ __rmnet_map_ingress_handler(struct sk_buff *skb, 
			skb->ip_summed = CHECKSUM_UNNECESSARY;

	}



	if ((port->data_format & RMNET_INGRESS_FORMAT_PS) &&

	    !qmi_rmnet_work_get_active(port)) {

		/* register for powersave indications*/

		qmi_rmnet_work_restart(port);

	}

	if (port->data_format & RMNET_INGRESS_FORMAT_PS)

		qmi_rmnet_work_maybe_restart(port);



	skb_trim(skb, len);

	rmnet_deliver_skb(skb, port);
@@ -252,11 +249,8 @@ static int rmnet_map_egress_handler(struct sk_buff *skb, 
			return -ENOMEM;

	}



	if ((port->data_format & RMNET_INGRESS_FORMAT_PS) &&

	    !qmi_rmnet_work_get_active(port)) {

		/* register for powersave indications*/

		qmi_rmnet_work_restart(port);

	}

	if (port->data_format & RMNET_INGRESS_FORMAT_PS)

		qmi_rmnet_work_maybe_restart(port);



	if (port->data_format & RMNET_FLAGS_EGRESS_MAP_CKSUMV4)

		rmnet_map_checksum_uplink_packet(skb, orig_dev);

drivers/soc/qcom/dfc_qmi.c

+18 −5
Original line number Diff line number Diff line
@@ -589,9 +589,9 @@ static int dfc_bearer_flow_ctl(struct net_device *dev, 
		if (itm->bearer_id == bearer->bearer_id) {

			qlen = qmi_rmnet_flow_control(dev, itm->tcm_handle,

						    enable);

			trace_dfc_qmi_tc(itm->bearer_id, itm->flow_id,

					 bearer->grant_size, qlen,

					 itm->tcm_handle, enable);

			trace_dfc_qmi_tc(dev->name, itm->bearer_id,

					 itm->flow_id, bearer->grant_size,

					 qlen, itm->tcm_handle, enable);

			rc++;

		}

	}
@@ -630,7 +630,7 @@ static int dfc_all_bearer_flow_ctl(struct net_device *dev, 
	else

		netif_tx_stop_all_queues(dev);



	trace_dfc_qmi_tc(0xFF, 0, fc_info->num_bytes, 0, 0, enable);

	trace_dfc_qmi_tc(dev->name, 0xFF, 0, fc_info->num_bytes, 0, 0, enable);



	if (enable == 0 && ack_req)

		dfc_send_ack(dev, fc_info->bearer_id,
@@ -902,7 +902,8 @@ void dfc_qmi_burst_check(struct net_device *dev, struct qos_info *qos, 
	if (unlikely(!bearer))

		goto out;



	trace_dfc_flow_check(bearer->bearer_id, len, bearer->grant_size);

	trace_dfc_flow_check(dev->name, bearer->bearer_id,

			     len, bearer->grant_size);



	if (!bearer->grant_size)

		goto out;
@@ -926,3 +927,15 @@ void dfc_qmi_burst_check(struct net_device *dev, struct qos_info *qos, 
out:

	spin_unlock(&qos->qos_lock);

}



void dfc_qmi_wq_flush(struct qmi_info *qmi)

{

	struct dfc_qmi_data *dfc_data;

	int i;



	for (i = 0; i < MAX_CLIENT_NUM; i++) {

		dfc_data = (struct dfc_qmi_data *)(qmi->fc_info[i].dfc_client);

		if (dfc_data)

			flush_workqueue(dfc_data->dfc_wq);

	}

}

drivers/soc/qcom/qmi_rmnet.c

+90 −125
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ unsigned int rmnet_wq_frequency __read_mostly = 4; 
module_param(rmnet_wq_frequency, uint, 0644);

MODULE_PARM_DESC(rmnet_wq_frequency, "Frequency of PS check");



#define PS_WORK_ACTIVE_BIT 0

#define PS_INTERVAL (((!rmnet_wq_frequency) ? 1 : rmnet_wq_frequency) * HZ)

#define NO_DELAY (0x0000 * HZ)
@@ -100,38 +101,6 @@ qmi_rmnet_has_client(struct qmi_info *qmi) 
}



#ifdef CONFIG_QCOM_QMI_DFC

static void

qmi_rmnet_update_flow_link(struct qmi_info *qmi, struct net_device *dev,

			   struct rmnet_flow_map *itm, int add_flow)

{

	int i;



	if (add_flow) {

		if (qmi->flow_cnt == MAX_FLOW_NUM - 1) {

			pr_err("%s() No more space for new flow\n", __func__);

			return;

		}



		qmi->flow[qmi->flow_cnt].dev = dev;

		qmi->flow[qmi->flow_cnt].itm = itm;

		qmi->flow_cnt++;

	} else {

		for (i = 0; i < qmi->flow_cnt; i++) {

			if ((qmi->flow[i].dev == dev) &&

			    (qmi->flow[i].itm == itm)) {

				qmi->flow[i].dev =

					qmi->flow[qmi->flow_cnt-1].dev;

				qmi->flow[i].itm =

					qmi->flow[qmi->flow_cnt-1].itm;

				qmi->flow[qmi->flow_cnt-1].dev = NULL;

				qmi->flow[qmi->flow_cnt-1].itm = NULL;

				qmi->flow_cnt--;

				break;

			}

		}

	}

}



static void

qmi_rmnet_clean_flow_list(struct qmi_info *qmi, struct net_device *dev,

			  struct qos_info *qos)
@@ -142,7 +111,6 @@ qmi_rmnet_clean_flow_list(struct qmi_info *qmi, struct net_device *dev, 
	ASSERT_RTNL();



	list_for_each_entry_safe(itm, fl_tmp, &qos->flow_head, list) {

		qmi_rmnet_update_flow_link(qmi, dev, itm, 0);

		list_del(&itm->list);

		kfree(itm);

	}
@@ -232,7 +200,7 @@ static int qmi_rmnet_add_flow(struct net_device *dev, struct tcmsg *tcm, 
	new_map.flow_id = tcm->tcm_parent;

	new_map.ip_type = tcm->tcm_ifindex;

	new_map.tcm_handle = tcm->tcm_handle;

	trace_dfc_flow_info(new_map.bearer_id, new_map.flow_id,

	trace_dfc_flow_info(dev->name, new_map.bearer_id, new_map.flow_id,

			    new_map.ip_type, new_map.tcm_handle, 1);



	spin_lock_bh(&qos_info->qos_lock);
@@ -248,7 +216,6 @@ static int qmi_rmnet_add_flow(struct net_device *dev, struct tcmsg *tcm, 
			return -ENOMEM;

		}



		qmi_rmnet_update_flow_link(qmi, dev, itm, 1);

		qmi_rmnet_update_flow_map(itm, &new_map);

		list_add(&itm->list, &qos_info->flow_head);
@@ -273,6 +240,9 @@ static int qmi_rmnet_add_flow(struct net_device *dev, struct tcmsg *tcm, 


		qmi_rmnet_flow_control(dev, itm->tcm_handle,

				bearer->grant_size > 0 ? 1 : 0);



		trace_dfc_qmi_tc(dev->name, itm->bearer_id, itm->flow_id,

				 bearer->grant_size, 0, itm->tcm_handle, 1);

	}



	spin_unlock_bh(&qos_info->qos_lock);
@@ -287,7 +257,6 @@ qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm, 
	struct qos_info *qos_info = (struct qos_info *)rmnet_get_qos_pt(dev);

	struct rmnet_flow_map new_map, *itm;

	struct rmnet_bearer_map *bearer;

	int bearer_removed = 0;



	if (!qos_info)

		return -EINVAL;
@@ -307,64 +276,32 @@ qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm, 
	itm = qmi_rmnet_get_flow_map(qos_info, new_map.flow_id,

				     new_map.ip_type);

	if (itm) {

		trace_dfc_flow_info(new_map.bearer_id, new_map.flow_id,

				    new_map.ip_type, itm->tcm_handle, 0);

		qmi_rmnet_update_flow_link(qmi, dev, itm, 0);

		trace_dfc_flow_info(dev->name, new_map.bearer_id,

				    new_map.flow_id, new_map.ip_type,

				    itm->tcm_handle, 0);

		list_del(&itm->list);



		/* Enable flow to allow new call setup */

		qmi_rmnet_flow_control(dev, itm->tcm_handle, 1);

		trace_dfc_qmi_tc(dev->name, itm->bearer_id, itm->flow_id,

				 0, 0, itm->tcm_handle, 1);



		/*clear bearer map*/

		bearer = qmi_rmnet_get_bearer_map(qos_info, new_map.bearer_id);

		if (bearer && --bearer->flow_ref == 0) {

			list_del(&bearer->list);

			bearer_removed = 1;

		}



		kfree(itm);

		if (bearer_removed)

			kfree(bearer);

		}



	spin_unlock_bh(&qos_info->qos_lock);



	return 0;

		kfree(itm);

	}



static int qmi_rmnet_enable_all_flows(struct qmi_info *qmi)

{

	int i;

	struct qos_info *qos;

	struct rmnet_flow_map *m;

	struct rmnet_bearer_map *bearer;

	int qlen;



	if (!qmi_rmnet_has_dfc_client(qmi) || (qmi->flow_cnt == 0))

		return 0;



	ASSERT_RTNL();



	for (i = 0; i < qmi->flow_cnt; i++) {

		qos = (struct qos_info *)rmnet_get_qos_pt(qmi->flow[i].dev);

		m = qmi->flow[i].itm;



		spin_lock_bh(&qos->qos_lock);



		bearer = qmi_rmnet_get_bearer_map(qos, m->bearer_id);

		if (bearer) {

			bearer->grant_size = DEFAULT_GRANT;

			bearer->grant_thresh =

				qmi_rmnet_grant_per(DEFAULT_GRANT);

			bearer->seq = 0;

			bearer->ack_req = 0;

	if (list_empty(&qos_info->flow_head)) {

		netif_tx_wake_all_queues(dev);

		trace_dfc_qmi_tc(dev->name, 0xFF, 0, DEFAULT_GRANT, 0, 0, 1);

	}



		qlen = qmi_rmnet_flow_control(qmi->flow[i].dev,

					     m->tcm_handle, 1);

		trace_dfc_qmi_tc(m->bearer_id, m->flow_id,

				 DEFAULT_GRANT, qlen,

				 m->tcm_handle, 1);



		spin_unlock_bh(&qos->qos_lock);

	}

	spin_unlock_bh(&qos_info->qos_lock);



	return 0;

}
@@ -419,11 +356,6 @@ qmi_rmnet_del_flow(struct net_device *dev, struct tcmsg *tcm, 
{

	return -EINVAL;

}



static inline int qmi_rmnet_enable_all_flows(struct qmi_info *qmi)

{

	return 0;

}

#endif



static int
@@ -568,13 +500,13 @@ void qmi_rmnet_qmi_exit(void *qmi_pt, void *port) 


	ASSERT_RTNL();



	qmi_rmnet_work_exit(port);



	if (qmi->wda_client) {

		wda_qmi_client_exit(qmi->wda_client);

		qmi->wda_client = NULL;

	}



	qmi_rmnet_work_exit(port);



	for (i = 0; i < MAX_CLIENT_NUM; i++) {

		if (!__qmi_rmnet_delete_client(port, qmi, i))

			return;
@@ -582,6 +514,37 @@ void qmi_rmnet_qmi_exit(void *qmi_pt, void *port) 
}

EXPORT_SYMBOL(qmi_rmnet_qmi_exit);



void qmi_rmnet_enable_all_flows(struct net_device *dev)

{

	struct qos_info *qos;

	struct rmnet_bearer_map *bearer;

	int do_wake = 0;



	qos = (struct qos_info *)rmnet_get_qos_pt(dev);

	if (!qos)

		return;



	spin_lock_bh(&qos->qos_lock);



	list_for_each_entry(bearer, &qos->bearer_head, list) {

		bearer->grant_before_ps = bearer->grant_size;

		bearer->seq_before_ps = bearer->seq;

		bearer->grant_size = DEFAULT_GRANT;

		bearer->grant_thresh = qmi_rmnet_grant_per(DEFAULT_GRANT);

		bearer->seq = 0;

		bearer->ack_req = 0;

		do_wake = 1;

	}



	if (do_wake) {

		netif_tx_wake_all_queues(dev);

		trace_dfc_qmi_tc(dev->name, 0xFF, 0, DEFAULT_GRANT, 0, 0, 1);

	}



	spin_unlock_bh(&qos->qos_lock);

}

EXPORT_SYMBOL(qmi_rmnet_enable_all_flows);



#ifdef CONFIG_QCOM_QMI_DFC

void qmi_rmnet_burst_fc_check(struct net_device *dev,

			      int ip_type, u32 mark, unsigned int len)
@@ -661,8 +624,11 @@ int qmi_rmnet_set_powersave_mode(void *port, uint8_t enable) 
			__func__, enable, rc);

		return rc;

	}

	if (enable)

		qmi_rmnet_enable_all_flows(qmi);



	if (enable) {

		dfc_qmi_wq_flush(qmi);

		rmnet_enable_all_flows(port);

	}



	return 0;

}
@@ -679,9 +645,9 @@ EXPORT_SYMBOL(qmi_rmnet_work_restart); 
static void qmi_rmnet_check_stats(struct work_struct *work)

{

	struct rmnet_powersave_work *real_work;

	struct qmi_info *qmi;

	u64 rxd, txd;

	u64 rx, tx;

	unsigned long lock_delay;



	real_work = container_of(to_delayed_work(work),

				 struct rmnet_powersave_work, work);
@@ -689,28 +655,22 @@ static void qmi_rmnet_check_stats(struct work_struct *work) 
	if (unlikely(!real_work || !real_work->port))

		return;



	/* Min Delay for retry errors */

	lock_delay = qmi_rmnet_work_get_active(real_work->port) ?

			PS_INTERVAL : (HZ / 50);



	if (!rtnl_trylock()) {

		queue_delayed_work(rmnet_ps_wq, &real_work->work, lock_delay);

	qmi = (struct qmi_info *)rmnet_get_qmi_pt(real_work->port);

	if (unlikely(!qmi))

		return;

	}

	if (!qmi_rmnet_work_get_active(real_work->port)) {

		qmi_rmnet_work_set_active(real_work->port, 1);



	if (qmi->ps_enabled) {

		/* Retry after small delay if qmi error

		 * This resumes UL grants by disabling

		 * powersave mode if successful.

		 */

		if (qmi_rmnet_set_powersave_mode(real_work->port, 0) < 0) {

			qmi_rmnet_work_set_active(real_work->port, 0);

			queue_delayed_work(rmnet_ps_wq,

					   &real_work->work, lock_delay);

			rtnl_unlock();

					   &real_work->work, HZ / 50);

			return;



		}

		qmi->ps_enabled = 0;

		goto end;

	}
@@ -721,26 +681,34 @@ static void qmi_rmnet_check_stats(struct work_struct *work) 
	real_work->old_tx_pkts = tx;



	if (!rxd && !txd) {

		qmi_rmnet_work_set_active(real_work->port, 0);

		/* Retry after lock delay if enabling powersave fails.

		 * This will cause UL grants to continue being sent

		 * suboptimally. Keeps wq active until successful.

		 */

		if (qmi_rmnet_set_powersave_mode(real_work->port, 1) < 0) {

			qmi_rmnet_work_set_active(real_work->port, 1);

			queue_delayed_work(rmnet_ps_wq,

					   &real_work->work, PS_INTERVAL);



			return;

		}

		qmi->ps_enabled = 1;

		clear_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);



		rtnl_unlock();

		return;

	}

end:

	rtnl_unlock();

	queue_delayed_work(rmnet_ps_wq, &real_work->work, PS_INTERVAL);

}



static void qmi_rmnet_work_set_active(void *port, int status)

{

	struct qmi_info *qmi;



	qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);

	if (unlikely(!qmi))

		return;



	if (status)

		set_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);

	else

		clear_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);

}



void qmi_rmnet_work_init(void *port)

{

	if (rmnet_ps_wq)
@@ -766,29 +734,26 @@ void qmi_rmnet_work_init(void *port) 
}

EXPORT_SYMBOL(qmi_rmnet_work_init);



void qmi_rmnet_work_set_active(void *port, int status)

void qmi_rmnet_work_maybe_restart(void *port)

{

	if (!port)

	struct qmi_info *qmi;



	qmi = (struct qmi_info *)rmnet_get_qmi_pt(port);

	if (unlikely(!qmi))

		return;

	((struct qmi_info *)rmnet_get_qmi_pt(port))->active = status;

}

EXPORT_SYMBOL(qmi_rmnet_work_set_active);



int qmi_rmnet_work_get_active(void *port)

{

	if (!port)

		return 0;

	return ((struct qmi_info *)rmnet_get_qmi_pt(port))->active;

	if (!test_and_set_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active))

		qmi_rmnet_work_restart(port);

}

EXPORT_SYMBOL(qmi_rmnet_work_get_active);

EXPORT_SYMBOL(qmi_rmnet_work_maybe_restart);



void qmi_rmnet_work_exit(void *port)

{

	qmi_rmnet_work_set_active(port, 0);

	if (!rmnet_ps_wq || !rmnet_work)

		return;

	cancel_delayed_work_sync(&rmnet_work->work);

	destroy_workqueue(rmnet_ps_wq);

	qmi_rmnet_work_set_active(port, 0);

	rmnet_ps_wq = NULL;

	kfree(rmnet_work);

	rmnet_work = NULL;

drivers/soc/qcom/qmi_rmnet_i.h

+11 −3
Original line number Diff line number Diff line
@@ -40,6 +40,8 @@ struct rmnet_bearer_map { 
	u32 grant_thresh;

	u16 seq;

	u8  ack_req;

	u32 grant_before_ps;

	u16 seq_before_ps;

};



struct svc_info {
@@ -70,11 +72,10 @@ struct flow_info { 


struct qmi_info {

	int flag;

	int flow_cnt;

	struct flow_info flow[MAX_FLOW_NUM];

	void *wda_client;

	struct fc_info fc_info[MAX_CLIENT_NUM];

	int active;

	unsigned long ps_work_active;

	int ps_enabled;

};



enum data_ep_type_enum_v01 {
@@ -116,6 +117,8 @@ void dfc_qmi_burst_check(struct net_device *dev, struct qos_info *qos, 


int qmi_rmnet_flow_control(struct net_device *dev, u32 tcm_handle, int enable);



void dfc_qmi_wq_flush(struct qmi_info *qmi);



#else

static inline struct rmnet_flow_map *

qmi_rmnet_get_flow_map(struct qos_info *qos_info,
@@ -145,6 +148,11 @@ dfc_qmi_burst_check(struct net_device *dev, struct qos_info *qos, 
		    int ip_type, u32 mark, unsigned int len)

{

}



static inline void

dfc_qmi_wq_flush(struct qmi_info *qmi)

{

}

#endif



#ifdef CONFIG_QCOM_QMI_POWER_COLLAPSE