Optimizing Logging in BT Power Driver

- Removing Un-wanted Logging

Change-Id: I0812ec9f558a6f1fe3dd29df1f520fe14a1d16cd
Signed-off-by: Girish BN <quic_gbn@quicinc.com>

include/btpower.h

@@ -1,7 +1,7 @@
 /* SPDX-License-Identifier: GPL-2.0-only */
 /*
  * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
- * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
  */
 
 #ifndef __LINUX_BLUETOOTH_POWER_H
@@ -70,42 +70,6 @@ enum grant_states {
 	UWB_WAITING_FOR_GRANT,
 };
 
-static inline char *ConvertGrantRetToString(enum grant_return_values state)
-{
-	switch (state) {
-	case ACCESS_GRANTED:
-		return "ACCESS_GRANTED";
-	case ACCESS_DENIED:
-		return "ACCESS_DENIED";
-	case ACCESS_RELEASED:
-		return "ACCESS_RELEASED";
-	case ACCESS_DISALLOWED:
-		return "ACCESS_DISALLOWED";
-	default:
-		return "INVALID State";
-	}
-}
-
-static inline char *ConvertGrantToString(enum grant_states state)
-{
-	switch (state) {
-	case NO_GRANT_FOR_ANY_SS:
-		return "NO_GRANT_FOR_ANY_SS";
-	case NO_OTHER_CLIENT_WAITING_FOR_GRANT:
-		return "NO_OTHER_CLIENT_WAITING_FOR_GRANT";
-	case BT_HAS_GRANT :
-		return "BT_HAS_GRANT";
-	case UWB_HAS_GRANT:
-		return "UWB_HAS_GRANT";
-	case BT_WAITING_FOR_GRANT :
-		return "BT_WAITING_FOR_GRANT";
-	case UWB_WAITING_FOR_GRANT:
-		return "UWB_WAITING_FOR_GRANT";
-	default:
-		return "INVALID STATE";
-	}
-}
-
 enum cores {
 	BT_CORE = 0,
 	UWB_CORE,
@@ -143,6 +107,156 @@ enum {
 	PWR_CLIENT_KILLED,
 };
 
+static inline char *ConvertGrantRetToString(enum grant_return_values state) {
+
+	switch (state) {
+	case ACCESS_GRANTED:
+		return "ACCESS_GRANTED";
+	case ACCESS_DENIED:
+		return "ACCESS_DENIED";
+	case ACCESS_RELEASED:
+		return "ACCESS_RELEASED";
+	case ACCESS_DISALLOWED:
+		return "ACCESS_DISALLOWED";
+	default:
+		return "INVALID STATE";
+	}
+}
+
+static inline char *ConvertGrantToString(enum grant_states state) {
+
+	switch (state) {
+	case NO_GRANT_FOR_ANY_SS:
+		return "NO_GRANT_FOR_ANY_SS";
+	case NO_OTHER_CLIENT_WAITING_FOR_GRANT:
+		return "NO_OTHER_CLIENT_WAITING_FOR_GRANT";
+	case BT_HAS_GRANT:
+		return "BT_HAS_GRANT";
+	case UWB_HAS_GRANT:
+		return "UWB_HAS_GRANT";
+	case BT_WAITING_FOR_GRANT:
+		return "BT_WAITING_FOR_GRANT";
+	case UWB_WAITING_FOR_GRANT:
+		return "UWB_WAITING_FOR_GRANT";
+	default:
+		return "INVALID STATE";
+	}
+}
+
+static inline char *ConvertRetentionModeToString(int state) {
+
+	switch (state) {
+	case IDLE:
+		return "Both client not in Retention";
+	case BT_IN_RETENTION:
+		return "BT in Retention";
+	case BT_OUT_OF_RETENTION:
+		return "BT is out off Retention";
+	case UWB_IN_RETENTION:
+		return "UWB in Retention";
+	case UWB_OUT_OF_RETENTION:
+		return "UWB is out off Retention";
+	case BOTH_CLIENTS_IN_RETENTION:
+		return "Both client in Retention";
+	default:
+		return "Retention state = INVALID STATE";
+	}
+}
+
+static inline char *ConvertClientReqToString(int arg) {
+
+	switch (arg) {
+	case POWER_DISABLE:
+		return "Power OFF";
+	case POWER_ENABLE:
+		return "Power ON";
+	case POWER_RETENTION:
+		return "Power Retention";
+	default:
+		return "INVALID STATE";
+	}
+}
+
+static inline char *ConvertPowerStatusToString(int state) {
+
+	switch (state) {
+	case IDLE:
+		return "Current state is ALL Client OFF";
+	case BT_ON:
+		return "Current state is BT powered ON";
+	case UWB_ON:
+		return "Current state is UWB powered ON";
+	case ALL_CLIENTS_ON:
+		return "Current state is ALL Client ON";
+	default:
+		return "Current state is = INVALID STATE";
+	}
+}
+
+static inline char *ConvertSsrStatusToString(int state) {
+
+	switch (state) {
+	case SUB_STATE_IDLE:
+		return "and No SSR";
+	case SSR_ON_BT:
+		return "and SSR on BT";
+	case BT_SSR_COMPLETED:
+		return "and BT SSR completed";
+	case SSR_ON_UWB:
+		return "and SSR on UWB";
+	case UWB_SSR_COMPLETED:
+		return "and UWB SSR completed";
+	default:
+		return "SSR STATE = INVALID STATE";
+	}
+}
+
+static inline char *ConvertPowerReqToString(int arg) {
+
+	switch (arg) {
+	case POWER_ON_BT:
+		return "POWER_ON_BT";
+	case POWER_OFF_BT:
+		return "POWER_OFF_BT";
+	case POWER_ON_UWB:
+		return "POWER_ON_UWB";
+	case POWER_OFF_UWB:
+		return "POWER_OFF_UWB";
+	case POWER_ON_BT_RETENION:
+		return "POWER_ON_BT_RETENION";
+	case POWER_ON_UWB_RETENION:
+		return "POWER_ON_UWB_RETENION";
+	case BT_ACCESS_REQ:
+		return "BT_ACCESS_REQ";
+	case UWB_ACCESS_REQ:
+		return "UWB_ACCESS_REQ";
+	case BT_RELEASE_ACCESS:
+		return "BT_RELEASE_ACCESS";
+	case UWB_RELEASE_ACCESS:
+		return "UWB_RELEASE_ACCESS";
+	case BT_MAX_PWR_STATE:
+		return "BT_MAX_PWR_STATE";
+	default:
+		return "INVALID STATE";
+	}
+};
+
+static inline char *ConvertRegisterModeToString(int reg_mode) {
+
+	switch (reg_mode) {
+	case POWER_DISABLE:
+		return "vote off";
+	case POWER_ENABLE:
+		return "vote on";
+	case POWER_RETENTION:
+		return "vote for retention";
+	case POWER_DISABLE_RETENTION:
+		return "vote offretention";
+	default:
+		return "INVALID STATE";
+	}
+}
+
 enum UwbPrimaryReasonCode{
 	UWB_HOST_REASON_DEFAULT_NONE  = 0x00,                         //INVALID REASON
 	UWB_HOST_REASON_PERI_SOC_CRASHED = 0x01,                      //PERI SOC WAS CRASHED
@@ -569,13 +683,6 @@ int btpower_get_chipset_version(void);
 int btpower_aop_mbox_init(struct platform_pwr_data *pdata);
 int bt_aop_pdc_reconfig(struct platform_pwr_data *pdata);
 
-static const char *pwr_req[] = {"POWER_ON_BT", "POWER_OFF_BT",
-								"POWER_ON_UWB", "POWER_OFF_UWB",
-								"POWER_ON_BT_RETENION",
-								"POWER_ON_UWB_RETENION",
-								"BT_ACCESS_REQ", "UWB_ACCESS_REQ",
-								"BT_RELEASE_ACCESS", "UWB_RELEASE_ACCESS"};
-
 #define WLAN_SW_CTRL_GPIO       "qcom,wlan-sw-ctrl-gpio"
 #define BT_CMD_SLIM_TEST            0xbfac
 #define BT_CMD_PWR_CTRL             0xbfad
@@ -611,18 +718,4 @@ enum btpower_obs_param {
 };
 #endif
 
-static const char * const bt_arg[]= {"power off BT", "power on BT",
-									"BT power retention"};
-static const char * const uwb_arg[]= {"power off UWB", "power on UWB",
-									"UWB power retention"};
-static const char * const pwr_states[]= {"Both Sub-System powered OFF", "BT powered ON",
-									"UWB powered ON",
-					  "Both Sub-System powered ON"};
-static const char * const ssr_state[]= {"No SSR on Sub-Sytem", "SSR on BT",
-									"SSR Completed on BT", "SSR on UWB",
-									"SSR Completed on UWB"};
-static const char * const reg_mode[]= {"vote off", "vote on", "vote for retention", "vote off retention"};
-static const char * const retention_mode[]= {"IDLE", "BT_IN_RETENTION", "BT_OUT_OF_RETENTION",
-									"UWB_IN_RETENTION", "UWB_OUT_OF_RETENTION",
-									"BOTH_CLIENT_IN_RETENTION"};
 #endif /* __LINUX_BLUETOOTH_POWER_H */

pwr/btpower.c

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
- * Copyright (c) 2021-2023 Qualcomm Innovation Center, Inc. All rights reserved.
+ * Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
  */
 
 /*
@@ -465,7 +465,7 @@ static int vreg_enable(struct vreg_data *vreg)
 {
 	int rc = 0;
 
-	pr_err("%s: vreg_en for : %s\n", __func__, vreg->name);
+	pr_debug("%s: vreg_en for : %s\n", __func__, vreg->name);
 
 	if (!vreg->is_enabled) {
 		if (vreg_configure(vreg, false) < 0)
@@ -489,7 +489,7 @@ static int vreg_disable_retention(struct vreg_data *vreg)
 	if (!vreg)
 		return rc;
 
-	pr_err("%s: disable_retention for : %s\n", __func__, vreg->name);
+	pr_debug("%s: disable_retention for : %s\n", __func__, vreg->name);
 
 	if ((vreg->is_enabled) && (vreg->is_retention_supp))
 		rc = vreg_configure(vreg, false);
@@ -504,7 +504,7 @@ static int vreg_enable_retention(struct vreg_data *vreg)
 	if (!vreg)
 		return rc;
 
-	pr_err("%s: enable_retention for : %s\n", __func__, vreg->name);
+	pr_debug("%s: enable_retention for : %s\n", __func__, vreg->name);
 
 	if ((vreg->is_enabled) && (vreg->is_retention_supp))
 		if ((vreg->min_vol != 0) && (vreg->max_vol != 0))
@@ -520,7 +520,7 @@ static int vreg_disable(struct vreg_data *vreg)
 	if (!vreg)
 		return rc;
 
-	pr_err("%s for : %s\n", __func__, vreg->name);
+	pr_debug("%s for : %s\n", __func__, vreg->name);
 
 	if (vreg->is_enabled) {
 		rc = regulator_disable(vreg->reg);
@@ -851,11 +851,11 @@ static int bt_regulators_pwr(int pwr_state)
 
 	if (!bt_num_vregs) {
 		pr_warn("%s: not avilable to %s\n",
-			__func__, reg_mode[pwr_state]);
+			__func__, ConvertRegisterModeToString(pwr_state));
 		return 0;
 	}
 
-	pr_err("%s: %s\n", __func__, reg_mode[pwr_state]);
+	pr_info("%s: %s\n", __func__, ConvertRegisterModeToString(pwr_state));
 
 	if (pwr_state == POWER_ENABLE) {
 		/* Power On */
@@ -950,11 +950,11 @@ static int uwb_regulators_pwr(int pwr_state)
 
 	if (!uwb_num_vregs) {
 		pr_warn("%s: not avilable to %s\n",
-			__func__, reg_mode[pwr_state]);
+			__func__, ConvertRegisterModeToString(pwr_state));
 		return 0;
 	}
 
-	pr_err("%s: %s\n", __func__, reg_mode[pwr_state]);
+	pr_info("%s: %s\n", __func__, ConvertRegisterModeToString(pwr_state));
 
 	switch (pwr_state) {
 	case POWER_ENABLE:
@@ -1020,11 +1020,11 @@ static int platform_regulators_pwr(int pwr_state)
 
 	if (!platform_num_vregs) {
 		pr_warn("%s: not avilable to %s\n",
-			__func__, reg_mode[pwr_state]);
+			__func__, ConvertRegisterModeToString(pwr_state));
 		return 0;
 	}
 
-	pr_err("%s: %s\n", __func__, reg_mode[pwr_state]);
+	pr_info("%s: %s\n", __func__, ConvertRegisterModeToString(pwr_state));
 
 	switch (pwr_state) {
 	case POWER_ENABLE:
@@ -1775,16 +1775,16 @@ static inline enum grant_states btpower_get_grant_state(void)
 	return state;
 }
 
-static void update_sub_state(int state)
-{
-	pwr_data->sub_state = state;
-}
-
 static int get_sub_state(void)
 {
 	return (int)pwr_data->sub_state;
 }
 
+static void update_sub_state(int state)
+{
+	pwr_data->sub_state = state;
+}
+
 int power_enable (enum SubSystem SubSystemType)
 {
 	int ret;
@@ -2062,7 +2062,7 @@ int btpower_on(enum plt_pwr_state client)
 	/* No Point in going further if SSR is on any subsystem */
 	if (current_ssr_state != SUB_STATE_IDLE) {
 		pr_err("%s: %s not allowing to power on\n", __func__,
-			ssr_state[current_ssr_state]);
+			ConvertSsrStatusToString(current_ssr_state));
 		return -1;
 	}
 
@@ -2087,14 +2087,10 @@ int btpower_access_ctrl(enum plt_pwr_state request)
 	enum grant_states grant_pending = btpower_get_grant_pending_state();
 	int current_ssr_state = get_sub_state();
 
-	pr_info("%s: request for %s grant_state %s grant_pending %s\n", __func__,
-		pwr_req[(int)request], ConvertGrantToString(grant_state),
-		ConvertGrantToString(grant_pending));
-
 	if (current_ssr_state != SUB_STATE_IDLE &&
 		(request == BT_ACCESS_REQ || request == UWB_ACCESS_REQ)) {
 		pr_err("%s: not allowing this request as %s\n", __func__,
-			ssr_state[current_ssr_state]);
+			ConvertSsrStatusToString(current_ssr_state));
 		return (int)ACCESS_DISALLOWED;
 	}
 
@@ -2170,10 +2166,11 @@ static void bt_power_vote(struct work_struct *work)
 		request = STREAM_TO_UINT32(skb);
 		skb_pull(skb, sizeof(uint32_t));
 		mutex_unlock(&pwr_data->pwr_mtx);
-		pr_err("%s: request from is %s cur state = %s %s retention %s access %s pending %s\n",
+		pr_info("%s: Start %s %s, %s state access %s pending %s\n",
-			__func__, pwr_req[request], pwr_states[get_pwr_state()],
+			__func__,
-			ssr_state[get_sub_state()],
+			ConvertPowerStatusToString(get_pwr_state()),
-			retention_mode[btpower_get_retenion_mode_state()],
+			ConvertSsrStatusToString(get_sub_state()),
+			ConvertRetentionModeToString(btpower_get_retenion_mode_state()),
 			ConvertGrantToString(btpower_get_grant_state()),
 			ConvertGrantToString(btpower_get_grant_pending_state()));
 		if (request == POWER_ON_BT || request == POWER_ON_UWB)
@@ -2186,10 +2183,11 @@ static void bt_power_vote(struct work_struct *work)
 			ret = btpower_access_ctrl(request);
 			pr_info("%s: grant status %s\n", __func__, ConvertGrantRetToString((int)ret));
 		}
-		pr_err("%s: request from is %s cur state = %s %s retention %s access %s pending %s\n",
+		pr_info("%s: Completed %s %s, %s state access %s pending %s\n",
-			__func__, pwr_req[request], pwr_states[get_pwr_state()],
+			__func__,
-			ssr_state[get_sub_state()],
+			ConvertPowerStatusToString(get_pwr_state()),
-			retention_mode[btpower_get_retenion_mode_state()],
+			ConvertSsrStatusToString(get_sub_state()),
+			ConvertRetentionModeToString(btpower_get_retenion_mode_state()),
 			ConvertGrantToString(btpower_get_grant_state()),
 			ConvertGrantToString(btpower_get_grant_pending_state()));
 		pwr_data->wait_status[request] = ret;
@@ -2268,10 +2266,10 @@ int btpower_handle_client_request(unsigned int cmd, int arg)
 {
 	int ret = -1;
 
-	pr_info("%s: %s cmd voted to %s, current state = %s, %s\n", __func__,
+	pr_info("%s: Start of %s cmd request to %s.\n",
+		__func__,
 		(cmd == BT_CMD_PWR_CTRL ? "BT_CMD_PWR_CTRL" : "UWB_CMD_PWR_CTRL"),
-		bt_arg[(int)arg], pwr_states[get_pwr_state()],
+		ConvertClientReqToString(arg));
-		ssr_state[(int)get_sub_state()]);
 
 	if (cmd == BT_CMD_PWR_CTRL) {
 		switch ((int)arg) {
@@ -2298,9 +2296,6 @@ int btpower_handle_client_request(unsigned int cmd, int arg)
 			break;
 		}
 	}
-	pr_err("%s: %s, SSR state = %s\n", __func__,
-		pwr_states[get_pwr_state()], ssr_state[(int)get_sub_state()]);
-
 	return ret;
 }
 
@@ -2309,7 +2304,7 @@ int btpower_process_access_req(unsigned int cmd, int req)
 	int ret = -1;
 
 	pr_info("%s: by %s: request type %s\n", __func__,
-		cmd == BT_CMD_ACCESS_CTRL ? "BT" : "UWB",
+		cmd == BT_CMD_ACCESS_CTRL ? "BT_CMD_ACCESS_CTRL" : "UWB_CMD_ACCESS_CTRL",
 		req == 1 ? "Request" : "Release");
 	if (cmd == BT_CMD_ACCESS_CTRL && req == 1)
 		ret = schedule_client_voting(BT_ACCESS_REQ);