samsung_sm8750/android_kernel_samsung_sm8750-modules
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

replace common qcom sources with samsung ones

Browse Source
This commit is contained in:
SaschaNes
2025-08-12 22:13:00 +02:00
parent ba24dcded9
commit 6f7753de11
5682 changed files with 2450203 additions and 103634 deletions
Download Patch File Download Diff File Expand all files Collapse all files

320
qcom/opensource/bt-kernel/pwr/btpower.c
View File

@@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-2.0-only
/*
* Copyright (c) 2016-2021, The Linux Foundation. All rights reserved.
* Copyright (c) 2021-2025 Qualcomm Innovation Center, Inc. All rights reserved.
* Copyright (c) 2021-2024 Qualcomm Innovation Center, Inc. All rights reserved.
*/
/*
@@ -77,9 +77,6 @@
#define SIGIO_SSR_ON_UWB 0x00000001
#define SIGIO_UWB_SSR_COMPLETED 0x00000002
#define RESETB_GPIO_HIGH 0x00000001
#define RESETB_GPIO_LOW 0x00000000
#define CRASH_REASON_NOT_FOUND ((char *)"Crash reason not found")
#define PERI_SS (0x00)
@@ -87,10 +84,8 @@
#define UWB_SS (0x02)
#define TME_SS (0x03)
#define INVALID_SOC 0x00
#define PEACH_SOC_VERSION_1_0 0x01
#define PEACH_SOC_VERSION_2_0 0x02
#define OTHER_FMD_SUPPORTED_BT_SOC 0x03
#define SOC_VERSION_1_0 0x01
#define SOC_VERSION_2_0 0x02
/**
* enum btpower_vreg_param: Voltage regulator TCS param
@@ -347,6 +342,7 @@ static const struct of_device_id bt_power_match_table[] = {
{},
};
static int btpower_enable_ipa_vreg(struct platform_pwr_data *pdata);
static struct platform_pwr_data *pwr_data;
static bool previous;
static struct class *bt_class;
@@ -354,10 +350,7 @@ static int bt_major;
static int soc_id;
static bool probe_finished;
static struct fmdOperationStruct fmdStruct;
char *default_crash_reason = "Crash reason not found";
static int btpower_enable_ipa_vreg(struct platform_pwr_data *pdata);
static inline int btpower_get_retenion_mode_state(void);
static void bt_power_vote(struct work_struct *work);
static struct {
@@ -727,34 +720,6 @@ static int get_fmd_mode(void)
return pwr_data->is_fmd_mode_enable;
}
static int bt_pull_resetb(int resetb_gpio, int value)
{
int rc = 0;
rc = gpio_direction_output(resetb_gpio, value);
if (rc) {
pr_err("%s: Unable to set direction\n", __func__);
return rc;
}
return rc;
}
static int bt_resetb_operation(int resetb)
{
int rc = 0;
/* making resetb to low */
pr_info("BTON: Turn bt_resetb_gpio to low\n");
rc = bt_pull_resetb(resetb, RESETB_GPIO_LOW);
if (rc)
return rc;
msleep(20);
/* making resetb to high after delay */
pr_info("BTON: Turn bt_resetb_gpio to High\n");
rc = bt_pull_resetb(resetb, RESETB_GPIO_HIGH);
return rc;
}
static int bt_configure_gpios(int on)
{
int rc = 0;
@@ -762,7 +727,6 @@ static int bt_configure_gpios(int on)
int wl_reset_gpio = pwr_data->wl_gpio_sys_rst;
int bt_sw_ctrl_gpio = pwr_data->bt_gpio_sw_ctrl;
int bt_debug_gpio = pwr_data->bt_gpio_debug;
int bt_resetb_gpio = pwr_data->bt_gpio_resetb;
int assert_dbg_gpio = 0;
if (on) {
@@ -772,14 +736,6 @@ static int bt_configure_gpios(int on)
__func__, bt_reset_gpio, rc);
return rc;
}
if (bt_resetb_gpio >= 0) {
rc = gpio_request(bt_resetb_gpio, "bt_resetb_gpio_n");
if (rc) {
pr_err("%s: unable to request gpio %d (%d)\n",
__func__, bt_resetb_gpio, rc);
return rc;
}
}
pr_info("BTON:Turn Bt OFF asserting BT_EN to low\n");
pr_info("bt-reset-gpio(%d) value(%d)\n", bt_reset_gpio,
@@ -842,18 +798,13 @@ static int bt_configure_gpios(int on)
}
power_src.platform_state[BT_RESET_GPIO] =
gpio_get_value(bt_reset_gpio);
if (bt_resetb_gpio >= 0) {
pr_err("BTON:Turn resetb High\n");
bt_pull_resetb(bt_resetb_gpio, RESETB_GPIO_HIGH);
}
}
pr_info("BTON: WLAN OFF waiting for 100ms delay\n");
pr_info("for AON output to fully discharge\n");
msleep(100);
pr_info("BTON: WLAN OFF Asserting BT_EN to high\n");
btpower_set_xo_clk_gpio_state(true);
if (bt_resetb_gpio >= 0)
bt_resetb_operation(bt_resetb_gpio);
rc = gpio_direction_output(bt_reset_gpio, 1);
if (rc) {
pr_err("%s: Unable to set direction\n", __func__);
@@ -936,34 +887,6 @@ static int bt_configure_gpios(int on)
return rc;
}
static int handle_pwr_disable_req(int core, int reg_num, int retenion_state, int fmd_state)
{
struct vreg_data *vregs;
int rc;
for (int i = 0; i < reg_num; i++) {
if (core == BT_CORE)
vregs = &pwr_data->bt_vregs[i];
else if (core == UWB_CORE)
vregs = &pwr_data->uwb_vregs[i];
else if (core == PLATFORM_CORE)
vregs = &pwr_data->platform_vregs[i];
if (fmd_state && vregs->fmd_mode_set) {
if (retenion_state != RETENTION_IDLE) {
vreg_disable_retention(vregs);
pr_err("%s: Brought %s reg out-of retention for FMD\n",
__func__, vregs->name);
}
pr_err("%s: Keeping %s reg on power-on state for FMD\n",
__func__, vregs->name);
} else {
rc = vreg_disable(vregs);
}
}
return rc;
}
static int bt_regulators_pwr(int pwr_state)
{
int i, log_indx, bt_num_vregs, rc = 0;
@@ -1023,26 +946,26 @@ static int bt_regulators_pwr(int pwr_state)
pr_err("%s: secure hw mode on, not allowed to access gpio",
__func__);
}else {
if (!get_fmd_mode())
bt_configure_gpios(POWER_DISABLE);
bt_configure_gpios(POWER_DISABLE);
}
}
gpio_fail:
if (!get_fmd_mode()) {
if (pwr_data->bt_gpio_sys_rst > 0)
gpio_free(pwr_data->bt_gpio_sys_rst);
if (pwr_data->bt_gpio_debug > 0)
gpio_free(pwr_data->bt_gpio_debug);
if (pwr_data->bt_chip_clk)
bt_clk_disable(pwr_data->bt_chip_clk);
if (pwr_data->bt_gpio_resetb > 0)
gpio_free(pwr_data->bt_gpio_resetb);
}
if (pwr_data->bt_gpio_sys_rst > 0)
gpio_free(pwr_data->bt_gpio_sys_rst);
if (pwr_data->bt_gpio_debug > 0)
gpio_free(pwr_data->bt_gpio_debug);
if (pwr_data->bt_chip_clk)
bt_clk_disable(pwr_data->bt_chip_clk);
regulator_fail:
rc = handle_pwr_disable_req(BT_CORE,
bt_num_vregs,
btpower_get_retenion_mode_state(),
get_fmd_mode());
for (i = 0; i < bt_num_vregs; i++) {
bt_vregs = &pwr_data->bt_vregs[i];
if (get_fmd_mode() && bt_vregs->fmd_mode_set) {
pr_err("%s: FMD Mode Set: Skipping regulator %s\n",
__func__, bt_vregs->name);
continue;
}
rc = vreg_disable(bt_vregs);
}
} else if (pwr_state == POWER_RETENTION) {
/* Retention mode */
for (i = 0; i < bt_num_vregs; i++) {
@@ -1208,10 +1131,17 @@ gpio_failed:
gpio_free(pwr_data->bt_gpio_debug);
}
regulator_failed:
rc = handle_pwr_disable_req(PLATFORM_CORE,
platform_num_vregs,
btpower_get_retenion_mode_state(),
get_fmd_mode());
for (i = 0; i < platform_num_vregs; i++) {
platform_vregs = &pwr_data->platform_vregs[i];
pr_err("%s: FMD MODE regulator %s\n",
__func__, platform_vregs->name);
if (get_fmd_mode() && platform_vregs->fmd_mode_set) {
pr_err("%s: FMD Mode Set: Skipping regulator %s\n",
__func__, platform_vregs->name);
continue;
}
rc = vreg_disable(platform_vregs);
}
break;
case POWER_RETENTION:
for (i = 0; i < platform_num_vregs; i++) {
@@ -1304,7 +1234,7 @@ static int btpower_rfkill_probe(struct platform_device *pdev)
pdev->dev.platform_data);
if (!rfkill) {
dev_err(&pdev->dev, "rfkill allocate failed\n");
pr_err("btpower : rfkill allocate failed\n");
return -ENOMEM;
}
@@ -1319,7 +1249,7 @@ static int btpower_rfkill_probe(struct platform_device *pdev)
ret = rfkill_register(rfkill);
if (ret) {
dev_err(&pdev->dev, "rfkill register failed=%d\n", ret);
pr_err("btpower : rfkill register failed=%d\n", ret);
rfkill_destroy(rfkill);
return ret;
}
@@ -1355,6 +1285,8 @@ static int dt_parse_vreg_info(struct device *dev, struct device_node *child,
if (!child)
np = dev->of_node;
//pr_err("btpower : %s\n", __func__);
snprintf(prop_name, sizeof(prop_name), "%s-supply", vreg_name);
if (of_parse_phandle(np, prop_name, 0)) {
vreg->reg = regulator_get(dev, vreg_name);
@@ -1408,7 +1340,7 @@ static int bt_dt_parse_clk_info(struct device *dev,
struct bt_power_clk_data *clk = NULL;
struct device_node *np = dev->of_node;
pr_debug("%s\n", __func__);
//pr_err("btpower : %s\n", __func__);
*clk_data = NULL;
if (of_parse_phandle(np, "clocks", 0)) {
@@ -1454,6 +1386,8 @@ static void bt_power_vreg_put(void)
struct vreg_data *bt_vregs = NULL;
int bt_num_vregs = pwr_data->bt_num_vregs;
//pr_err("btpower : %s\n", __func__);
for (; i < bt_num_vregs; i++) {
bt_vregs = &pwr_data->bt_vregs[i];
if (bt_vregs->reg)
@@ -1468,8 +1402,11 @@ static int get_gpio_dt_pinfo(struct platform_device *pdev)
struct pinctrl *pinctrl1;
#ifdef CONFIG_FMD_ENABLE
struct pinctrl_state *sw_ctrl;
struct pinctrl_state *bt_en;
#endif
//pr_err("btpower : %s\n", __func__);
child = pdev->dev.of_node;
pinctrl1 = devm_pinctrl_get(&pdev->dev);
@@ -1486,13 +1423,6 @@ static int get_gpio_dt_pinfo(struct platform_device *pdev)
pr_err("%s: wl-reset-gpio not provided in device tree\n",
__func__);
pwr_data->bt_gpio_resetb =
of_get_named_gpio(child,
"qcom,wl-resetb-gpio", 0);
if (pwr_data->bt_gpio_resetb < 0)
pr_err("%s: bt_gpio_resetb not provided in device tree\n",
__func__);
pwr_data->bt_gpio_sw_ctrl =
of_get_named_gpio(child,
"qcom,bt-sw-ctrl-gpio", 0);
@@ -1511,6 +1441,7 @@ static int get_gpio_dt_pinfo(struct platform_device *pdev)
pr_warn("sw_cntrl-gpio not provided in devicetree\n");
}
#ifdef CONFIG_FMD_ENABLE
pr_warn("CONFIG_FMD_ENABLE\n");
if (pinctrl1) {
sw_ctrl = pinctrl_lookup_state(pinctrl1, "sw_ctrl");
if (IS_ERR_OR_NULL(sw_ctrl)) {
@@ -1521,15 +1452,6 @@ static int get_gpio_dt_pinfo(struct platform_device *pdev)
if (ret)
pr_err("Failed to select sw_ctrl state, err = %d\n", ret);
}
bt_en = pinctrl_lookup_state(pinctrl1, "bt_en");
if (IS_ERR_OR_NULL(bt_en)) {
ret = PTR_ERR(bt_en);
pr_err("Failed to get bt_en state, err = %d\n", ret);
} else {
ret = pinctrl_select_state(pinctrl1, bt_en);
if (ret)
pr_err("Failed to select bt_en state, err = %d\n", ret);
}
} else {
pr_err("%s: pinctrl is null\n", __func__);
}
@@ -1568,6 +1490,8 @@ static int get_power_dt_pinfo(struct platform_device *pdev)
int rc, i;
const struct pwr_data *data;
//pr_err("btpower : %s\n", __func__);
data = of_device_get_match_data(&pdev->dev);
if (!data) {
pr_err("%s: failed to get dev node\n", __func__);
@@ -1634,6 +1558,8 @@ static int bt_power_populate_dt_pinfo(struct platform_device *pdev)
struct device_node *of_node;
int rc;
//pr_err("btpower : %s\n", __func__);
if (!pwr_data)
return -ENOMEM;
@@ -1723,6 +1649,8 @@ static int bt_power_probe(struct platform_device *pdev)
int ret = 0;
int itr;
pr_err("btpower : %s\n", __func__);
/* Fill whole array with -2 i.e NOT_AVAILABLE state by default
* for any GPIO or Reg handle.
*/
@@ -1734,15 +1662,16 @@ static int bt_power_probe(struct platform_device *pdev)
pwr_data = kzalloc(sizeof(*pwr_data), GFP_KERNEL);
if (!pwr_data)
if (!pwr_data) {
pr_err("btpower : %s !pwr_data\n", __func__);
return -ENOMEM;
}
pwr_data->pdev = pdev;
pwr_data->reftask_bt = NULL;
pwr_data->reftask_uwb = NULL;
struct device *devi = &pwr_data->pdev->dev;
int rc = 0;
pr_info("%s: Get FMD nvmem-cells\n", __func__);
/* Get fmd_set NVMEM Cell Handler */
pwr_data->nvmem_cell_fmd_set =
@@ -1841,8 +1770,10 @@ static int bt_power_probe(struct platform_device *pdev)
goto free_pdata;
}
if (btpower_rfkill_probe(pdev) < 0)
if (btpower_rfkill_probe(pdev) < 0) {
pr_err("btpower : %s btpower_rfkill_probe<0 \n", __func__);
goto free_pdata;
}
bt_power_pdc_init_params(pwr_data);
btpower_aop_mbox_init(pwr_data);
@@ -2056,21 +1987,10 @@ int power_enable (enum SubSystem SubSystemType)
void send_signal_to_subsystem(int SubSystemType, int state)
{
pwr_data->wrkq_signal_state = state;
if (SubSystemType == BLUETOOTH) {
if (!pwr_data->reftask_bt) {
pr_err("%s: BT client is not register to send signal\n",
__func__);
return;
}
if (SubSystemType == BLUETOOTH)
queue_work(pwr_data->workq, &pwr_data->bt_wq);
} else {
if (!pwr_data->reftask_uwb) {
pr_err("%s: UWB client is not register to send signal\n",
__func__);
return;
}
else
queue_work(pwr_data->workq, &pwr_data->uwb_wq);
}
}
int power_disable (enum SubSystem SubSystemType)
@@ -2167,19 +2087,34 @@ static int client_state_notified(int SubSystemType)
if (SubSystemType == BLUETOOTH) {
update_sub_state(SSR_ON_BT);
if (get_pwr_state() == ALL_CLIENTS_ON)
if (get_pwr_state() == ALL_CLIENTS_ON) {
if (!pwr_data->reftask_uwb) {
pr_err("%s: UWB PID is not register to send signal\n",
__func__);
return -1;
}
send_signal_to_subsystem(UWB, SSR_ON_BT);
}
} else {
update_sub_state(SSR_ON_UWB);
if (get_pwr_state() == ALL_CLIENTS_ON)
if (get_pwr_state() == ALL_CLIENTS_ON) {
if (!pwr_data->reftask_bt) {
pr_err("%s: BT PID is not register to send signal\n",
__func__);
return -1;
}
send_signal_to_subsystem(BLUETOOTH,
(SIGIO_NOTIFICATION_SIGNAL|SIGIO_SSR_ON_UWB));
}
}
return 0;
}
void btpower_register_client(int client, int cmd)
{
//pr_err("btpower_retenion : %s\n", __func__);
if (cmd == REG_BT_PID) {
pwr_data->reftask_bt = get_current();
pr_info("%s: Registering BT Service(PID-%d) with Power driver\n",
@@ -2224,6 +2159,8 @@ int btpower_retenion(enum plt_pwr_state client)
int current_pwr_state = get_pwr_state();
int retention_mode_state = btpower_get_retenion_mode_state();
//pr_err("btpower_retenion : %s\n", __func__);
if (current_pwr_state == IDLE) {
pr_err("%s: invalid retention_mode request", __func__);
return -1;
@@ -2262,6 +2199,7 @@ int btpower_retenion(enum plt_pwr_state client)
int btpower_off(enum plt_pwr_state client)
{
pr_err("btpower : %s\n", __func__);
return power_disable((client == POWER_OFF_BT) ? BLUETOOTH : UWB);
}
@@ -2271,6 +2209,8 @@ int btpower_on(enum plt_pwr_state client)
int current_ssr_state = get_sub_state();
int retention_mode_state = btpower_get_retenion_mode_state();
pr_err("btpower : %s\n", __func__);
if (retention_mode_state == UWB_IN_RETENTION ||
retention_mode_state == BT_IN_RETENTION) {
ret = platform_regulators_pwr(POWER_DISABLE_RETENTION);
@@ -2686,37 +2626,39 @@ int perform_fmd_operation(void)
int ret = 0;
switch ((enum FmdOperation) fmdStruct.fmdOperation) {
case UPDATE_SOC_VER: {
if ((fmdStruct.socFwVer == INVALID_SOC) ||
(fmdStruct.socFwVer > OTHER_FMD_SUPPORTED_BT_SOC)) {
pr_err("%s: Invalid SOC VERSION sent = %d\n",
__func__, fmdStruct.socFwVer);
return -EINVAL;
}
pwr_data->is_fmd_mode_enable = true;
if (fmdStruct.socFwVer == PEACH_SOC_VERSION_1_0) {
pr_info("%s: UPDATE_SOC_VER :: PEACH_SOC_VER_1_0\n",
if (fmdStruct.socFwVer == SOC_VERSION_1_0) {
pr_info("%s: UPDATE_SOC_VER :: SOC_VERSION_1_0\n",
__func__);
} else if (fmdStruct.socFwVer == PEACH_SOC_VERSION_2_0) {
pr_info("%s: UPDATE_SOC_VER :: PEACH_SOC_VERSION_2_0\n",
pwr_data->is_fmd_mode_enable = true;
if (pwr_data->bt_chip_clk) {
ret = bt_clk_enable(pwr_data->bt_chip_clk);
if (ret < 0) {
pr_err("%s: failed to bt_chip_clk\n", __func__);
return -EINVAL;
}
}
} else if (fmdStruct.socFwVer == SOC_VERSION_2_0) {
pr_info("%s: UPDATE_SOC_VER :: SOC_VERSION_2_0\n",
__func__);
pwr_data->is_fmd_mode_enable = true;
#ifdef CONFIG_FMD_ENABLE
cnss_utils_fmd_status(true);
#endif
if (vote_wlan_reg_for_fmd() < 0) {
pr_err("%s: failed to vote wlan_reg\n", __func__);
pr_err("%s: failed to vote_wlan_reg_for_fmd\n", __func__);
return -EINVAL;
}
if (pwr_data->bt_chip_clk) {
ret = bt_clk_enable(pwr_data->bt_chip_clk);
if (ret < 0) {
pr_err("%s: failed to bt_chip_clk\n", __func__);
return -EINVAL;
}
}
} else {
pr_info("%s: UPDATE_SOC_VER :: OTHER_FMD_SUPPORT_BT_SOC\n",
__func__);
}
if (pwr_data->bt_chip_clk) {
ret = bt_clk_enable(pwr_data->bt_chip_clk);
if (ret < 0) {
pr_err("%s: failed to bt_chip_clk\n", __func__);
return -EINVAL;
}
pr_err("%s: Invalid SOC VERSION sent = %d\n",
__func__, fmdStruct.socFwVer);
return -EINVAL;
}
break;
}
@@ -2753,31 +2695,6 @@ int perform_fmd_operation(void)
return ret;
}
int bt_kernel_panic(char *arg) {
int ret = 0;
pr_info("%s\n", __func__);
if (copy_from_user(&CrashInfo, (char *)arg, sizeof(CrashInfo))) {
pr_err("%s: failed copy to panic reason from BT-Transport\n",
__func__);
memset(&CrashInfo, 0, sizeof(CrashInfo));
strscpy(CrashInfo. PrimaryReason,
default_crash_reason, strlen(default_crash_reason));
strscpy(CrashInfo. SecondaryReason,
default_crash_reason, strlen(default_crash_reason));
ret = -EFAULT;
}
pr_err("%s: BT kernel panic Primary reason = %s, Secondary reason = %s\n",
__func__, CrashInfo.PrimaryReason, CrashInfo.SecondaryReason);
panic("%s: BT kernel panic Primary reason = %s, Secondary reason = %s\n",
__func__, CrashInfo.PrimaryReason, CrashInfo.SecondaryReason);
return ret;
}
#ifdef CONFIG_MSM_BT_OOBS
int bt_oobs_handler(enum btpower_obs_param clk_cntrl)
{
@@ -2819,10 +2736,9 @@ static long bt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
int chipset_version = 0;
unsigned long panic_reason = 0;
unsigned short primary_reason = 0, sec_reason = 0, source_subsystem = 0;
int current_ssr_state = SUB_STATE_IDLE;
if (!pwr_data || !probe_finished) {
pr_err("%s: BTPower Probing Pending.Try Again\n", __func__);
pr_err("%s: BTPower Probing Pending.Try Again command[%d]\n", __func__, cmd);
return -EAGAIN;
}
@@ -2930,7 +2846,16 @@ static long bt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
pr_err("%s: BT_CMD_KERNEL_PANIC\n", __func__);
ret = bt_kernel_panic((char *)arg);
if (copy_from_user(&CrashInfo, (char *)arg, sizeof(CrashInfo))) {
pr_err("%s: copy to user failed\n", __func__);
ret = -EFAULT;
}
pr_err("%s: BT kernel panic Primary reason = %s, Secondary reason = %s\n",
__func__, CrashInfo.PrimaryReason, CrashInfo.SecondaryReason);
panic("%s: BT kernel panic Primary reason = %s, Secondary reason = %s\n",
__func__, CrashInfo.PrimaryReason, CrashInfo.SecondaryReason);
break;
case UWB_CMD_KERNEL_PANIC:
@@ -2948,17 +2873,6 @@ static long bt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
sec_reason, GetUwbSecondaryCrashReason(sec_reason),
source_subsystem, GetSourceSubsystemString(source_subsystem));
break;
case UWB_GET_SSR_STATE:
current_ssr_state = get_sub_state();
pr_err("%s: UWB_GET_SSR_STATE current_ssr_state:%d\n", __func__,
current_ssr_state);
if (copy_to_user((void __user *)arg, &current_ssr_state,
sizeof(current_ssr_state))) {
pr_err("%s: copy to user failed\n", __func__);
ret = -EFAULT;
}
break;
default:
return -ENOIOCTLCMD;
}
@@ -2982,6 +2896,8 @@ static int __init btpower_init(void)
{
int ret = 0;
//pr_err("btpower : %s\n", __func__);
probe_finished = false;
ret = platform_driver_register(&bt_power_driver);
if (ret) {