TechPanelGM/kernel_xiaomi_sm8250
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "dfc: bearer based QMAP powersave"

Browse Source 
We want to apply a change from sm8350 that drops the RMNET_DFC wakelock,
and sm8350 doesn't have this change.

This reverts commit 2c0f59a745.

Change-Id: I630cdeeed5cc4ee049b04dda487e00d9e6512f70
This commit is contained in:
jabashque
2023-02-17 08:05:21 -08:00
parent ad51bd9fc5
commit 618ddeafeb
8 changed files with 14 additions and 313 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
drivers/net/ethernet/qualcomm/rmnet/rmnet_config.c
View File

@@ -1,6 +1,5 @@
// SPDX-License-Identifier: GPL-2.0-only
/* Copyright (c) 2013-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*
* RMNET configuration engine
*
@@ -718,36 +717,6 @@ bool rmnet_all_flows_enabled(void *port)
}
EXPORT_SYMBOL(rmnet_all_flows_enabled);
void rmnet_prepare_ps_bearers(void *port, u8 *num_bearers, u8 *bearer_id)
{
struct rmnet_endpoint *ep;
unsigned long bkt;
u8 current_num_bearers = 0;
u8 number_bearers_left = 0;
u8 num_bearers_in_out;
if (unlikely(!port || !num_bearers))
return;
number_bearers_left = *num_bearers;
rcu_read_lock();
hash_for_each_rcu(((struct rmnet_port *)port)->muxed_ep,
bkt, ep, hlnode) {
num_bearers_in_out = number_bearers_left;
qmi_rmnet_prepare_ps_bearers(ep->egress_dev,
&num_bearers_in_out,
bearer_id ? bearer_id +
current_num_bearers : NULL);
current_num_bearers += num_bearers_in_out;
number_bearers_left -= num_bearers_in_out;
}
rcu_read_unlock();
*num_bearers = current_num_bearers;
}
EXPORT_SYMBOL(rmnet_prepare_ps_bearers);
int rmnet_get_powersave_notif(void *port)
{
if (!port)

85
drivers/soc/qcom/dfc_qmap.c
View File

@@ -1,7 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2019-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <net/pkt_sched.h>
@@ -12,7 +11,6 @@
#include "dfc_defs.h"
#define QMAP_DFC_VER 1
#define QMAP_PS_MAX_BEARERS 32
#define QMAP_CMD_DONE -1
@@ -25,7 +23,6 @@
#define QMAP_DFC_IND 11
#define QMAP_DFC_QUERY 12
#define QMAP_DFC_END_MARKER 13
#define QMAP_DFC_POWERSAVE 14
struct qmap_hdr {
u8 cd_pad;
@@ -124,22 +121,6 @@ struct qmap_dfc_end_marker_cnf {
u32 reserved4;
} __aligned(1);
struct qmap_dfc_powersave_req {
struct qmap_cmd_hdr hdr;
u8 cmd_ver;
u8 allow:1;
u8 autoshut:1;
u8 reserved:6;
u8 reserved2;
u8 mode:1;
u8 reserved3:7;
__be32 ep_type;
__be32 iface_id;
u8 num_bearers;
u8 bearer_id[QMAP_PS_MAX_BEARERS];
u8 reserved4[3];
} __aligned(1);
static struct dfc_flow_status_ind_msg_v01 qmap_flow_ind;
static struct dfc_tx_link_status_ind_msg_v01 qmap_tx_ind;
static struct dfc_qmi_data __rcu *qmap_dfc_data;
@@ -149,16 +130,14 @@ static void *rmnet_ctl_handle;
static void dfc_qmap_send_end_marker_cnf(struct qos_info *qos,
u8 bearer_id, u16 seq, u32 tx_id);
static int dfc_qmap_send_cmd(struct sk_buff *skb)
static void dfc_qmap_send_cmd(struct sk_buff *skb)
{
trace_dfc_qmap(skb->data, skb->len, false);
if (rmnet_ctl_send_client(rmnet_ctl_handle, skb)) {
pr_err("Failed to send to rmnet ctl\n");
kfree_skb(skb);
return -ECOMM;
}
return 0;
}
static void dfc_qmap_send_inband_ack(struct dfc_qmi_data *dfc,
@@ -472,65 +451,6 @@ static void dfc_qmap_send_end_marker_cnf(struct qos_info *qos,
rmnet_map_tx_qmap_cmd(skb);
}
static int dfc_qmap_send_powersave(u8 enable, u8 num_bearers, u8 *bearer_id)
{
struct sk_buff *skb;
struct qmap_dfc_powersave_req *dfc_powersave;
unsigned int len = sizeof(struct qmap_dfc_powersave_req);
struct dfc_qmi_data *dfc;
u32 ep_type = 0;
u32 iface_id = 0;
rcu_read_lock();
dfc = rcu_dereference(qmap_dfc_data);
if (dfc) {
ep_type = dfc->svc.ep_type;
iface_id = dfc->svc.iface_id;
} else {
rcu_read_unlock();
return -EINVAL;
}
rcu_read_unlock();
skb = alloc_skb(len, GFP_ATOMIC);
if (!skb)
return -ENOMEM;
skb->protocol = htons(ETH_P_MAP);
dfc_powersave = (struct qmap_dfc_powersave_req *)skb_put(skb, len);
memset(dfc_powersave, 0, len);
dfc_powersave->hdr.cd_bit = 1;
dfc_powersave->hdr.mux_id = 0;
dfc_powersave->hdr.pkt_len = htons(len - QMAP_HDR_LEN);
dfc_powersave->hdr.cmd_name = QMAP_DFC_POWERSAVE;
dfc_powersave->hdr.cmd_type = QMAP_CMD_REQUEST;
dfc_powersave->hdr.tx_id = htonl(atomic_inc_return(&qmap_txid));
dfc_powersave->cmd_ver = 3;
dfc_powersave->mode = enable ? 1 : 0;
if (enable && num_bearers) {
if (unlikely(num_bearers > QMAP_PS_MAX_BEARERS))
num_bearers = QMAP_PS_MAX_BEARERS;
dfc_powersave->allow = 1;
dfc_powersave->autoshut = 1;
dfc_powersave->num_bearers = num_bearers;
memcpy(dfc_powersave->bearer_id, bearer_id, num_bearers);
}
dfc_powersave->ep_type = htonl(ep_type);
dfc_powersave->iface_id = htonl(iface_id);
return dfc_qmap_send_cmd(skb);
}
int dfc_qmap_set_powersave(u8 enable, u8 num_bearers, u8 *bearer_id)
{
trace_dfc_set_powersave_mode(enable);
return dfc_qmap_send_powersave(enable, num_bearers, bearer_id);
}
void dfc_qmap_send_ack(struct qos_info *qos, u8 bearer_id, u16 seq, u8 type)
{
struct rmnet_bearer_map *bearer;
@@ -579,8 +499,7 @@ int dfc_qmap_client_init(void *port, int index, struct svc_info *psvc,
pr_info("DFC QMAP init\n");
if (!qmi->ps_ext)
dfc_qmap_send_config(data);
dfc_qmap_send_config(data);
return 0;
}

18
drivers/soc/qcom/dfc_qmi.c
View File

@@ -1,7 +1,6 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#include <net/pkt_sched.h>
@@ -990,9 +989,7 @@ static int dfc_update_fc_map(struct net_device *dev, struct qos_info *qos,
u32 adjusted_grant;
itm = qmi_rmnet_get_bearer_map(qos, fc_info->bearer_id);
/* cache the bearer assuming it is a new bearer */
if (unlikely(!itm && !is_query && fc_info->num_bytes))
if (!itm)
itm = qmi_rmnet_get_bearer_noref(qos, fc_info->bearer_id);
if (itm) {
@@ -1104,18 +1101,9 @@ void dfc_do_burst_flow_control(struct dfc_qmi_data *dfc,
spin_lock_bh(&qos->qos_lock);
/* In powersave, change grant to 1 if it is a enable */
if (qmi_rmnet_ignore_grant(dfc->rmnet_port)) {
if (flow_status->num_bytes) {
flow_status->num_bytes = DEFAULT_GRANT;
flow_status->seq_num = 0;
/* below is to reset bytes-in-flight */
flow_status->rx_bytes_valid = 1;
flow_status->rx_bytes = 0xFFFFFFFF;
} else {
spin_unlock_bh(&qos->qos_lock);
continue;
}
spin_unlock_bh(&qos->qos_lock);
continue;
}
if (unlikely(flow_status->bearer_id == 0xFF))

155
drivers/soc/qcom/qmi_rmnet.c
View File

@@ -27,7 +27,6 @@
#define FLAG_DFC_MASK 0x000F
#define FLAG_POWERSAVE_MASK 0x0010
#define FLAG_QMAP_MASK 0x0020
#define FLAG_PS_EXT_MASK 0x0040
#define FLAG_TO_MODE(f) ((f) & FLAG_DFC_MASK)
@@ -36,12 +35,9 @@
(m) == DFC_MODE_SA)
#define FLAG_TO_QMAP(f) ((f) & FLAG_QMAP_MASK)
#define FLAG_TO_PS_EXT(f) ((f) & FLAG_PS_EXT_MASK)
int dfc_mode;
int dfc_qmap;
int dfc_ps_ext;
#define IS_ANCILLARY(type) ((type) != AF_INET && (type) != AF_INET6)
unsigned int rmnet_wq_frequency __read_mostly = 1000;
@@ -392,15 +388,12 @@ static void __qmi_rmnet_update_mq(struct net_device *dev,
bearer->mq_idx = itm->mq_idx;
}
/* Always enable flow for the newly associated bearer */
if (!bearer->grant_size) {
bearer->grant_size = DEFAULT_GRANT;
bearer->grant_thresh =
qmi_rmnet_grant_per(DEFAULT_GRANT);
}
qmi_rmnet_flow_control(dev, itm->mq_idx, 1);
qmi_rmnet_flow_control(dev, itm->mq_idx,
bearer->grant_size > 0 ? 1 : 0);
if (dfc_mode == DFC_MODE_SA)
qmi_rmnet_flow_control(dev, bearer->ack_mq_idx, 1);
qmi_rmnet_flow_control(dev, bearer->ack_mq_idx,
bearer->grant_size > 0 ? 1 : 0);
}
}
@@ -622,7 +615,6 @@ qmi_rmnet_setup_client(void *port, struct qmi_info *qmi, struct tcmsg *tcm)
}
qmi->flag = tcm->tcm_ifindex;
qmi->ps_ext = FLAG_TO_PS_EXT(qmi->flag);
svc.instance = tcm->tcm_handle;
svc.ep_type = tcm->tcm_info;
svc.iface_id = tcm->tcm_parent;
@@ -724,7 +716,6 @@ void qmi_rmnet_change_link(struct net_device *dev, void *port, void *tcm_pt)
case NLMSG_CLIENT_SETUP:
dfc_mode = FLAG_TO_MODE(tcm->tcm_ifindex);
dfc_qmap = FLAG_TO_QMAP(tcm->tcm_ifindex);
dfc_ps_ext = FLAG_TO_PS_EXT(tcm->tcm_ifindex);
if (!DFC_SUPPORTED_MODE(dfc_mode) &&
!(tcm->tcm_ifindex & FLAG_POWERSAVE_MASK))
@@ -861,54 +852,6 @@ bool qmi_rmnet_all_flows_enabled(struct net_device *dev)
}
EXPORT_SYMBOL(qmi_rmnet_all_flows_enabled);
/**
* rmnet_prepare_ps_bearers - get disabled bearers and
* reset enabled bearers
*/
void qmi_rmnet_prepare_ps_bearers(struct net_device *dev, u8 *num_bearers,
u8 *bearer_id)
{
struct qos_info *qos;
struct rmnet_bearer_map *bearer;
u8 current_num_bearers = 0;
u8 num_bearers_left = 0;
qos = (struct qos_info *)rmnet_get_qos_pt(dev);
if (!qos || !num_bearers)
return;
spin_lock_bh(&qos->qos_lock);
num_bearers_left = *num_bearers;
list_for_each_entry(bearer, &qos->bearer_head, list) {
if (bearer->grant_size) {
bearer->seq = 0;
bearer->ack_req = 0;
bearer->bytes_in_flight = 0;
bearer->tcp_bidir = false;
bearer->rat_switch = false;
qmi_rmnet_watchdog_remove(bearer);
bearer->grant_size = DEFAULT_GRANT;
bearer->grant_thresh =
qmi_rmnet_grant_per(DEFAULT_GRANT);
} else if (num_bearers_left) {
if (bearer_id)
bearer_id[current_num_bearers] =
bearer->bearer_id;
current_num_bearers++;
num_bearers_left--;
} else {
pr_err("DFC: no bearer space\n");
}
}
*num_bearers = current_num_bearers;
spin_unlock_bh(&qos->qos_lock);
}
EXPORT_SYMBOL(qmi_rmnet_prepare_ps_bearers);
#ifdef CONFIG_QCOM_QMI_DFC
bool qmi_rmnet_get_flow_state(struct net_device *dev, struct sk_buff *skb,
bool *drop)
@@ -1122,7 +1065,6 @@ static struct rmnet_powersave_work *rmnet_work;
static bool rmnet_work_quit;
static bool rmnet_work_inited;
static LIST_HEAD(ps_list);
static u8 ps_bearer_id[32];
struct rmnet_powersave_work {
struct delayed_work work;
@@ -1337,78 +1279,6 @@ static void qmi_rmnet_check_stats(struct work_struct *work)
rcu_read_unlock();
}
static void qmi_rmnet_check_stats_2(struct work_struct *work)
{
struct rmnet_powersave_work *real_work;
struct qmi_info *qmi;
u64 rxd, txd;
u64 rx, tx;
u8 num_bearers;
real_work = container_of(to_delayed_work(work),
struct rmnet_powersave_work, work);
if (unlikely(!real_work->port))
return;
qmi = (struct qmi_info *)rmnet_get_qmi_pt(real_work->port);
if (unlikely(!qmi))
return;
if (qmi->ps_enabled) {
/* Ready to accept grant */
qmi->ps_ignore_grant = false;
/* Out of powersave */
if (dfc_qmap_set_powersave(0, 0, NULL))
goto end;
qmi->ps_enabled = false;
if (rmnet_get_powersave_notif(real_work->port))
qmi_rmnet_ps_off_notify(real_work->port);
goto end;
}
rmnet_get_packets(real_work->port, &rx, &tx);
rxd = rx - real_work->old_rx_pkts;
txd = tx - real_work->old_tx_pkts;
real_work->old_rx_pkts = rx;
real_work->old_tx_pkts = tx;
if (!rxd && !txd) {
qmi->ps_ignore_grant = true;
qmi->ps_enabled = true;
clear_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active);
/* Let other CPU's see this update so that packets are
* dropped, instead of further processing packets
*/
smp_mb();
num_bearers = sizeof(ps_bearer_id);
memset(ps_bearer_id, 0, sizeof(ps_bearer_id));
rmnet_prepare_ps_bearers(real_work->port, &num_bearers,
ps_bearer_id);
/* Enter powersave */
dfc_qmap_set_powersave(1, num_bearers, ps_bearer_id);
if (rmnet_get_powersave_notif(real_work->port))
qmi_rmnet_ps_on_notify(real_work->port);
return;
}
end:
rcu_read_lock();
if (!rmnet_work_quit)
alarm_start_relative(&real_work->atimer, PS_INTERVAL_KT);
rcu_read_unlock();
}
static void qmi_rmnet_work_set_active(void *port, int status)
{
struct qmi_info *qmi;
@@ -1440,20 +1310,15 @@ void qmi_rmnet_work_init(void *port)
rmnet_ps_wq = NULL;
return;
}
if (dfc_qmap && dfc_ps_ext)
INIT_DEFERRABLE_WORK(&rmnet_work->work,
qmi_rmnet_check_stats_2);
else
INIT_DEFERRABLE_WORK(&rmnet_work->work, qmi_rmnet_check_stats);
INIT_DEFERRABLE_WORK(&rmnet_work->work, qmi_rmnet_check_stats);
alarm_init(&rmnet_work->atimer, ALARM_BOOTTIME, qmi_rmnet_work_alarm);
rmnet_work->port = port;
rmnet_get_packets(rmnet_work->port, &rmnet_work->old_rx_pkts,
&rmnet_work->old_tx_pkts);
rmnet_work_quit = false;
qmi_rmnet_work_set_active(rmnet_work->port, 0);
qmi_rmnet_work_set_active(rmnet_work->port, 1);
queue_delayed_work(rmnet_ps_wq, &rmnet_work->work, PS_INTERVAL);
rmnet_work_inited = true;
}
EXPORT_SYMBOL(qmi_rmnet_work_init);
@@ -1466,10 +1331,8 @@ void qmi_rmnet_work_maybe_restart(void *port)
if (unlikely(!qmi || !rmnet_work_inited))
return;
if (!test_and_set_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active)) {
qmi->ps_ignore_grant = false;
if (!test_and_set_bit(PS_WORK_ACTIVE_BIT, &qmi->ps_work_active))
qmi_rmnet_work_restart(port);
}
}
EXPORT_SYMBOL(qmi_rmnet_work_maybe_restart);

7
drivers/soc/qcom/qmi_rmnet_i.h
View File

@@ -102,7 +102,6 @@ struct qmi_info {
bool ps_ignore_grant;
bool wakelock_active;
struct wakeup_source *ws;
int ps_ext;
};
enum data_ep_type_enum_v01 {
@@ -220,7 +219,6 @@ wda_qmi_client_init(void *port, struct svc_info *psvc, struct qmi_info *qmi);
void wda_qmi_client_exit(void *wda_data);
int wda_set_powersave_mode(void *wda_data, u8 enable);
void qmi_rmnet_flush_ps_wq(void);
int dfc_qmap_set_powersave(u8 enable, u8 num_bearers, u8 *bearer_id);
#else
static inline int
wda_qmi_client_init(void *port, struct svc_info *psvc, struct qmi_info *qmi)
@@ -239,10 +237,5 @@ static inline int wda_set_powersave_mode(void *wda_data, u8 enable)
static inline void qmi_rmnet_flush_ps_wq(void)
{
}
static inline int dfc_qmap_set_powersave(u8 enable, u8 num_bearers,
u8 *bearer_id)
{
return -EINVAL;
}
#endif
#endif /*_RMNET_QMI_I_H*/

10
include/soc/qcom/qmi_rmnet.h
View File

@@ -22,8 +22,6 @@ void qmi_rmnet_qmi_exit(void *qmi_pt, void *port);
void qmi_rmnet_change_link(struct net_device *dev, void *port, void *tcm_pt);
void qmi_rmnet_enable_all_flows(struct net_device *dev);
bool qmi_rmnet_all_flows_enabled(struct net_device *dev);
void qmi_rmnet_prepare_ps_bearers(struct net_device *dev, u8 *num_bearers,
u8 *bearer_id);
#else
static inline void qmi_rmnet_qmi_exit(void *qmi_pt, void *port)
{
@@ -44,14 +42,6 @@ qmi_rmnet_all_flows_enabled(struct net_device *dev)
{
return true;
}
static inline void qmi_rmnet_prepare_ps_bearers(struct net_device *dev,
u8 *num_bearers, u8 *bearer_id)
{
if (num_bearers)
*num_bearers = 0;
}
#endif
#ifdef CONFIG_QCOM_QMI_DFC

2
include/soc/qcom/rmnet_qmi.h
View File

@@ -1,7 +1,6 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/*
* Copyright (c) 2018-2019, The Linux Foundation. All rights reserved.
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#ifndef _RMNET_QMI_H
@@ -27,7 +26,6 @@ void rmnet_get_packets(void *port, u64 *rx, u64 *tx);
int rmnet_get_powersave_notif(void *port);
struct net_device *rmnet_get_real_dev(void *port);
int rmnet_get_dlmarker_info(void *port);
void rmnet_prepare_ps_bearers(void *port, u8 *num_bearers, u8 *bearer_id);
#else
static inline void *rmnet_get_qmi_pt(void *port)
{

19
include/trace/events/dfc.h
View File

@@ -1,6 +1,5 @@
/* SPDX-License-Identifier: GPL-2.0-only */
/* Copyright (c) 2018-2020, The Linux Foundation. All rights reserved.
* Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved.
*/
#undef TRACE_SYSTEM
@@ -304,24 +303,6 @@ TRACE_EVENT(dfc_watchdog,
__entry->mux_id, __entry->bearer_id, __entry->event)
);
TRACE_EVENT(dfc_set_powersave_mode,
TP_PROTO(int enable),
TP_ARGS(enable),
TP_STRUCT__entry(
__field(int, enable)
),
TP_fast_assign(
__entry->enable = enable;
),
TP_printk("set powersave mode to %s",
__entry->enable ? "enable" : "disable")
);
#endif /* _TRACE_DFC_H */
/* This part must be outside protection */