Merge 526d8c57fe2144ef8f7067fc002a35f6cfd6a416 on remote branch (db56eecb) · Commits · e / devices / android_kernel_oneplus_sm7250

arch/arm64/kernel/smp.c

+0 −2

Original line number	Diff line number	Diff line
		@@ -62,7 +62,6 @@
		#include <asm/system_misc.h>
		#include <soc/qcom/minidump.h>

		#include <soc/qcom/scm.h>
		#include <soc/qcom/lpm_levels.h>

		#define CREATE_TRACE_POINTS
		@@ -407,7 +406,6 @@ void __init smp_cpus_done(unsigned int max_cpus)
		setup_cpu_features();
		hyp_mode_check();
		apply_alternatives_all();
		scm_enable_mem_protection();
		mark_linear_text_alias_ro();
		}

block/blk-ioc.c

+7 −0

Original line number	Diff line number	Diff line
		@@ -87,6 +87,7 @@ static void ioc_destroy_icq(struct io_cq *icq)
		* making it impossible to determine icq_cache. Record it in @icq.
		*/
		icq->__rcu_icq_cache = et->icq_cache;
		icq->flags \|= ICQ_DESTROYED;
		call_rcu(&icq->__rcu_head, icq_free_icq_rcu);
		}

		@@ -230,15 +231,21 @@ static void __ioc_clear_queue(struct list_head *icq_list)
		{
		unsigned long flags;

		rcu_read_lock();
		while (!list_empty(icq_list)) {
		struct io_cq *icq = list_entry(icq_list->next,
		struct io_cq, q_node);
		struct io_context *ioc = icq->ioc;

		spin_lock_irqsave(&ioc->lock, flags);
		if (icq->flags & ICQ_DESTROYED) {
		spin_unlock_irqrestore(&ioc->lock, flags);
		continue;
		}
		ioc_destroy_icq(icq);
		spin_unlock_irqrestore(&ioc->lock, flags);
		}
		rcu_read_unlock();
		}

		/**

drivers/bluetooth/bluetooth-power.c

+139 −1

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0-only
		/*
		* Copyright (c) 2016-2019, The Linux Foundation. All rights reserved.
		* Copyright (c) 2016-2020, The Linux Foundation. All rights reserved.
		*/

		/*
		@@ -252,6 +252,9 @@ static int bt_configure_gpios(int on)
		{
		int rc = 0;
		int bt_reset_gpio = bt_power_pdata->bt_gpio_sys_rst;
		int bt_sw_ctrl_gpio = bt_power_pdata->bt_gpio_sw_ctrl;
		int bt_debug_gpio = bt_power_pdata->bt_gpio_debug;
		int assertDebugGpio = 0;

		if (on) {
		rc = gpio_request(bt_reset_gpio, "bt_sys_rst_n");
		@@ -267,15 +270,53 @@ static int bt_configure_gpios(int on)
		return rc;
		}
		msleep(50);
		BT_PWR_ERR("BTON:Turn Bt Off bt-reset-gpio(%d) value(%d)\n",
		bt_reset_gpio, gpio_get_value(bt_reset_gpio));
		BT_PWR_ERR("BTON:Turn Bt Off bt-sw-ctrl-gpio(%d) value(%d)\n",
		bt_sw_ctrl_gpio, gpio_get_value(bt_sw_ctrl_gpio));

		rc = gpio_direction_output(bt_reset_gpio, 1);
		if (rc) {
		BT_PWR_ERR("Unable to set direction\n");
		return rc;
		}
		msleep(50);
		/* Check if SW_CTRL is asserted */
		if (bt_sw_ctrl_gpio >= 0) {
		rc = gpio_direction_input(bt_sw_ctrl_gpio);
		if (rc) {
		BT_PWR_ERR("SWCTRL Dir Set Problem:%d\n", rc);
		} else if (!gpio_get_value(bt_sw_ctrl_gpio)) {
		/* Assert debug GPIO, if available as
		* SW_CTRL is not asserted
		*/
		if (bt_debug_gpio >= 0)
		assertDebugGpio = 1;
		}
		}
		if (assertDebugGpio) {
		rc = gpio_request(bt_debug_gpio, "bt_debug_n");
		if (rc) {
		BT_PWR_ERR("unable to request Debug Gpio\n");
		} else {
		rc = gpio_direction_output(bt_debug_gpio, 1);
		if (rc)
		BT_PWR_ERR("Prob: Set Debug-Gpio\n");
		}
		}
		BT_PWR_ERR("BTON:Turn Bt On bt-reset-gpio(%d) value(%d)\n",
		bt_reset_gpio, gpio_get_value(bt_reset_gpio));
		BT_PWR_ERR("BTON:Turn Bt On bt-sw-ctrl-gpio(%d) value(%d)\n",
		bt_sw_ctrl_gpio, gpio_get_value(bt_sw_ctrl_gpio));
		} else {
		gpio_set_value(bt_reset_gpio, 0);
		if (bt_debug_gpio >= 0)
		gpio_set_value(bt_debug_gpio, 0);
		msleep(100);
		BT_PWR_ERR("BT-OFF:bt-reset-gpio(%d) value(%d)\n",
		bt_reset_gpio, gpio_get_value(bt_reset_gpio));
		BT_PWR_ERR("BT-OFF:bt-sw-ctrl-gpio(%d) value(%d)\n",
		bt_sw_ctrl_gpio, gpio_get_value(bt_sw_ctrl_gpio));
		}

		BT_PWR_ERR("bt_gpio= %d on: %d is successful", bt_reset_gpio, on);
		@@ -391,6 +432,10 @@ static int bluetooth_power(int on)
		gpio_fail:
		if (bt_power_pdata->bt_gpio_sys_rst > 0)
		gpio_free(bt_power_pdata->bt_gpio_sys_rst);
		if (bt_power_pdata->bt_gpio_sw_ctrl > 0)
		gpio_free(bt_power_pdata->bt_gpio_sw_ctrl);
		if (bt_power_pdata->bt_gpio_debug > 0)
		gpio_free(bt_power_pdata->bt_gpio_debug);
		if (bt_power_pdata->bt_chip_clk)
		bt_clk_disable(bt_power_pdata->bt_chip_clk);
		clk_fail:
		@@ -659,6 +704,14 @@ static int bt_power_populate_dt_pinfo(struct platform_device *pdev)
		if (bt_power_pdata->bt_gpio_sys_rst < 0)
		BT_PWR_INFO("bt-reset-gpio not provided in devicetree");

		bt_power_pdata->bt_gpio_sw_ctrl =
		of_get_named_gpio(pdev->dev.of_node,
		"qca,bt-sw-ctrl-gpio", 0);

		bt_power_pdata->bt_gpio_debug =
		of_get_named_gpio(pdev->dev.of_node,
		"qca,bt-debug-gpio", 0);

		rc = bt_dt_parse_vreg_info(&pdev->dev,
		&bt_power_pdata->bt_vdd_core,
		"qca,bt-vdd-core");
		@@ -797,6 +850,7 @@ static long bt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
		{
		int ret = 0, pwr_cntrl = 0;
		int chipset_version = 0;
		long value = -1;

		switch (cmd) {
		case BT_CMD_SLIM_TEST:
		@@ -833,6 +887,90 @@ static long bt_ioctl(struct file *file, unsigned int cmd, unsigned long arg)
		soc_id = 0;
		}
		break;
		case BT_CMD_GETVAL_RESET_GPIO:
		if (bt_power_pdata->bt_gpio_sys_rst > 0) {
		value = (long)gpio_get_value(
		bt_power_pdata->bt_gpio_sys_rst);
		BT_PWR_ERR("GET_RESET_GPIO(%d) value(%d)",
		bt_power_pdata->bt_gpio_sys_rst, value);
		ret = value;
		} else {
		BT_PWR_ERR("RESET_GPIO not configured");
		ret = -EINVAL;
		}
		break;
		case BT_CMD_GETVAL_SW_CTRL_GPIO:
		if (bt_power_pdata->bt_gpio_sw_ctrl > 0) {
		value = (long)gpio_get_value(
		bt_power_pdata->bt_gpio_sw_ctrl);
		BT_PWR_ERR("GET_SWCTRL_GPIO(%d) value(%d)",
		bt_power_pdata->bt_gpio_sw_ctrl, value);
		ret = value;
		} else {
		BT_PWR_ERR("SW_CTRL_GPIO not configured");
		ret = -EINVAL;
		}
		break;
		case BT_CMD_GETVAL_VDD_AON_LDO:
		if ((bt_power_pdata->bt_vdd_aon) &&
		(bt_power_pdata->bt_vdd_aon->is_enabled) &&
		(regulator_is_enabled(
		bt_power_pdata->bt_vdd_aon->reg))) {
		value = (int)regulator_get_voltage(
		bt_power_pdata->bt_vdd_aon->reg);
		BT_PWR_ERR("GET_VDD_AON_LDO(%d) value(%d)",
		bt_power_pdata->bt_vdd_aon, value);
		ret = value;
		} else {
		BT_PWR_ERR("VDD-AON_LDO not configure/enabled");
		ret = -EINVAL;
		}
		break;
		case BT_CMD_GETVAL_VDD_DIG_LDO:
		if ((bt_power_pdata->bt_vdd_dig) &&
		(bt_power_pdata->bt_vdd_dig->is_enabled) &&
		(regulator_is_enabled(
		bt_power_pdata->bt_vdd_dig->reg))) {
		value = (int)regulator_get_voltage(
		bt_power_pdata->bt_vdd_dig->reg);
		BT_PWR_ERR("GET_VDD_DIG_LDO(%d) value(%d)",
		bt_power_pdata->bt_vdd_dig, value);
		ret = value;
		} else {
		BT_PWR_ERR("VDD-DIG-LDO not configured/enabled");
		ret = -EINVAL;
		}
		break;
		case BT_CMD_GETVAL_VDD_RFA1_LDO:
		if ((bt_power_pdata->bt_vdd_rfa1) &&
		(bt_power_pdata->bt_vdd_rfa1->is_enabled) &&
		(regulator_is_enabled(
		bt_power_pdata->bt_vdd_rfa1->reg))) {
		value = (int)regulator_get_voltage(
		bt_power_pdata->bt_vdd_rfa1->reg);
		BT_PWR_ERR("GET_VDD_RFA1_LDO(%d) value(%d)",
		bt_power_pdata->bt_vdd_rfa1, value);
		ret = value;
		} else {
		BT_PWR_ERR("VDD-RFA1-LDO not configure/enabled");
		ret = -EINVAL;
		}
		break;
		case BT_CMD_GETVAL_VDD_RFA2_LDO:
		if ((bt_power_pdata->bt_vdd_rfa2) &&
		(bt_power_pdata->bt_vdd_rfa2->is_enabled) &&
		(regulator_is_enabled(
		bt_power_pdata->bt_vdd_rfa2->reg))) {
		value = (int)regulator_get_voltage(
		bt_power_pdata->bt_vdd_rfa2->reg);
		BT_PWR_ERR("GET_VDD_RFA2_LDO(%d) value(%d)",
		bt_power_pdata->bt_vdd_rfa2, value);
		ret = value;
		} else {
		BT_PWR_ERR("VDD-RFA2-LDO not configure/enabled");
		ret = -EINVAL;
		}
		break;
		default:
		return -EINVAL;
		}

drivers/bus/mhi/controllers/mhi_arch_qcom.c

+46 −39

Original line number	Diff line number	Diff line
		@@ -39,16 +39,18 @@ struct arch_info {
		#define DLOG "Dev->Host: "
		#define HLOG "Host: "

		#define MHI_TSYNC_LOG_PAGES (10)
		#define MHI_TSYNC_LOG_PAGES (2)

		#ifdef CONFIG_MHI_DEBUG

		#define MHI_IPC_LOG_PAGES (100)
		#define MHI_CNTRL_LOG_PAGES (25)
		enum MHI_DEBUG_LEVEL mhi_ipc_log_lvl = MHI_MSG_LVL_VERBOSE;

		#else

		#define MHI_IPC_LOG_PAGES (10)
		#define MHI_CNTRL_LOG_PAGES (5)
		enum MHI_DEBUG_LEVEL mhi_ipc_log_lvl = MHI_MSG_LVL_ERROR;

		#endif
		@@ -143,7 +145,7 @@ static void mhi_arch_pci_link_state_cb(struct msm_pcie_notify *notify)

		switch (notify->event) {
		case MSM_PCIE_EVENT_WAKEUP:
		MHI_LOG("Received MSM_PCIE_EVENT_WAKE signal\n");
		MHI_CNTRL_LOG("Received PCIE_WAKE signal\n");

		/* bring link out of d3cold */
		if (mhi_dev->powered_on) {
		@@ -152,14 +154,14 @@ static void mhi_arch_pci_link_state_cb(struct msm_pcie_notify *notify)
		}
		break;
		case MSM_PCIE_EVENT_L1SS_TIMEOUT:
		MHI_VERB("Received MSM_PCIE_EVENT_L1SS_TIMEOUT signal\n");
		MHI_VERB("Received PCIE_L1SS_TIMEOUT signal\n");

		pm_runtime_mark_last_busy(&pci_dev->dev);
		pm_request_autosuspend(&pci_dev->dev);
		break;
		case MSM_PCIE_EVENT_DRV_CONNECT:
		/* drv is connected we can suspend now */
		MHI_LOG("Received MSM_PCIE_EVENT_DRV_CONNECT signal\n");
		MHI_CNTRL_LOG("Received DRV_CONNECT signal\n");

		arch_info->drv_connected = true;

		@@ -174,7 +176,7 @@ static void mhi_arch_pci_link_state_cb(struct msm_pcie_notify *notify)
		mutex_unlock(&mhi_cntrl->pm_mutex);
		break;
		case MSM_PCIE_EVENT_DRV_DISCONNECT:
		MHI_LOG("Received MSM_PCIE_EVENT_DRV_DISCONNECT signal\n");
		MHI_CNTRL_LOG("Received DRV_DISCONNECT signal\n");

		/*
		* if link suspended bring it out of suspend and disable runtime
		@@ -184,7 +186,7 @@ static void mhi_arch_pci_link_state_cb(struct msm_pcie_notify *notify)
		pm_runtime_forbid(&pci_dev->dev);
		break;
		default:
		MHI_ERR("Unhandled event 0x%x\n", notify->event);
		MHI_CNTRL_LOG("Unhandled event 0x%x\n", notify->event);
		}
		}

		@@ -197,12 +199,12 @@ static int mhi_arch_esoc_ops_power_on(void *priv, unsigned int flags)

		mutex_lock(&mhi_cntrl->pm_mutex);
		if (mhi_dev->powered_on) {
		MHI_LOG("MHI still in active state\n");
		MHI_CNTRL_LOG("MHI still in active state\n");
		mutex_unlock(&mhi_cntrl->pm_mutex);
		return 0;
		}

		MHI_LOG("Enter: mdm_crashed:%d\n", flags & ESOC_HOOK_MDM_CRASH);
		MHI_CNTRL_LOG("Enter: mdm_crashed:%d\n", flags & ESOC_HOOK_MDM_CRASH);

		/* reset rpm state */
		pm_runtime_set_active(&pci_dev->dev);
		@@ -211,7 +213,7 @@ static int mhi_arch_esoc_ops_power_on(void *priv, unsigned int flags)
		pm_runtime_forbid(&pci_dev->dev);
		ret = pm_runtime_get_sync(&pci_dev->dev);
		if (ret < 0) {
		MHI_ERR("Error with rpm resume, ret:%d\n", ret);
		MHI_CNTRL_ERR("Error with rpm resume, ret:%d\n", ret);
		return ret;
		}

		@@ -219,7 +221,7 @@ static int mhi_arch_esoc_ops_power_on(void *priv, unsigned int flags)
		ret = msm_pcie_pm_control(MSM_PCIE_RESUME, pci_dev->bus->number,
		pci_dev, NULL, 0);
		if (ret) {
		MHI_ERR("Failed to resume pcie bus ret %d\n", ret);
		MHI_CNTRL_ERR("Failed to resume pcie bus ret %d\n", ret);
		return ret;
		}

		@@ -231,7 +233,7 @@ static void mhi_arch_link_off(struct mhi_controller *mhi_cntrl)
		struct mhi_dev *mhi_dev = mhi_controller_get_devdata(mhi_cntrl);
		struct pci_dev *pci_dev = mhi_dev->pci_dev;

		MHI_LOG("Entered\n");
		MHI_CNTRL_LOG("Entered\n");

		pci_set_power_state(pci_dev, PCI_D3hot);

		@@ -239,7 +241,7 @@ static void mhi_arch_link_off(struct mhi_controller *mhi_cntrl)
		msm_pcie_pm_control(MSM_PCIE_SUSPEND, mhi_cntrl->bus, pci_dev, NULL, 0);
		mhi_arch_set_bus_request(mhi_cntrl, 0);

		MHI_LOG("Exited\n");
		MHI_CNTRL_LOG("Exited\n");
		}

		static void mhi_arch_esoc_ops_power_off(void *priv, unsigned int flags)
		@@ -250,7 +252,7 @@ static void mhi_arch_esoc_ops_power_off(void *priv, unsigned int flags)
		struct pci_dev *pci_dev = mhi_dev->pci_dev;
		bool mdm_state = (flags & ESOC_HOOK_MDM_CRASH);

		MHI_LOG("Enter: mdm_crashed:%d\n", mdm_state);
		MHI_CNTRL_LOG("Enter: mdm_crashed:%d\n", mdm_state);

		/*
		* Abort system suspend if system is preparing to go to suspend
		@@ -266,7 +268,7 @@ static void mhi_arch_esoc_ops_power_off(void *priv, unsigned int flags)

		mutex_lock(&mhi_cntrl->pm_mutex);
		if (!mhi_dev->powered_on) {
		MHI_LOG("Not in active state\n");
		MHI_CNTRL_LOG("Not in active state\n");
		mutex_unlock(&mhi_cntrl->pm_mutex);
		pm_runtime_put_noidle(&pci_dev->dev);
		return;
		@@ -276,7 +278,7 @@ static void mhi_arch_esoc_ops_power_off(void *priv, unsigned int flags)

		pm_runtime_put_noidle(&pci_dev->dev);

		MHI_LOG("Triggering shutdown process\n");
		MHI_CNTRL_LOG("Triggering shutdown process\n");
		mhi_power_down(mhi_cntrl, !mdm_state);

		/* turn the link off */
		@@ -293,12 +295,10 @@ static void mhi_arch_esoc_ops_mdm_error(void *priv)
		{
		struct mhi_controller *mhi_cntrl = priv;

		MHI_LOG("Enter: mdm asserted\n");
		MHI_CNTRL_LOG("Enter: mdm asserted\n");

		/* transition MHI state into error state */
		mhi_control_error(mhi_cntrl);

		MHI_LOG("Exit\n");
		}

		static void mhi_bl_dl_cb(struct mhi_device *mhi_device,
		@@ -372,8 +372,9 @@ static int mhi_arch_pcie_scale_bw(struct mhi_controller *mhi_cntrl,
		/* do a bus scale vote based on gen speeds */
		mhi_arch_set_bus_request(mhi_cntrl, link_info->target_link_speed);

		MHI_VERB("bw changed to speed:0x%x width:0x%x\n",
		link_info->target_link_speed, link_info->target_link_width);
		MHI_LOG("BW changed to speed:0x%x width:0x%x\n",
		link_info->target_link_speed,
		link_info->target_link_width);

		return 0;
		}
		@@ -400,7 +401,7 @@ static int mhi_bl_probe(struct mhi_device *mhi_device,
		mhi_device->slot);

		arch_info->boot_dev = mhi_device;
		arch_info->boot_ipc_log = ipc_log_context_create(MHI_IPC_LOG_PAGES,
		arch_info->boot_ipc_log = ipc_log_context_create(MHI_CNTRL_LOG_PAGES,
		node_name, 0);
		ipc_log_string(arch_info->boot_ipc_log, HLOG
		"Entered SBL, Session ID:0x%x\n", mhi_cntrl->session_id);
		@@ -454,6 +455,12 @@ int mhi_arch_pcie_init(struct mhi_controller *mhi_cntrl)
		node, 0);
		mhi_cntrl->log_lvl = mhi_ipc_log_lvl;

		snprintf(node, sizeof(node), "mhi_cntrl_%04x_%02u.%02u.%02u",
		mhi_cntrl->dev_id, mhi_cntrl->domain, mhi_cntrl->bus,
		mhi_cntrl->slot);
		mhi_cntrl->cntrl_log_buf = ipc_log_context_create(
		MHI_CNTRL_LOG_PAGES, node, 0);

		snprintf(node, sizeof(node), "mhi_tsync_%04x_%02u.%02u.%02u",
		mhi_cntrl->dev_id, mhi_cntrl->domain, mhi_cntrl->bus,
		mhi_cntrl->slot);
		@@ -495,7 +502,8 @@ int mhi_arch_pcie_init(struct mhi_controller *mhi_cntrl)
		reg_event->notify.data = mhi_cntrl;
		ret = msm_pcie_register_event(reg_event);
		if (ret)
		MHI_LOG("Failed to reg. for link up notification\n");
		MHI_CNTRL_ERR(
		"Failed to reg. for link up notification\n");

		init_completion(&arch_info->pm_completion);

		@@ -512,7 +520,7 @@ int mhi_arch_pcie_init(struct mhi_controller *mhi_cntrl)
		arch_info->esoc_client = devm_register_esoc_client(
		&mhi_dev->pci_dev->dev, "mdm");
		if (IS_ERR_OR_NULL(arch_info->esoc_client)) {
		MHI_ERR("Failed to register esoc client\n");
		MHI_CNTRL_ERR("Failed to register esoc client\n");
		} else {
		/* register for power on/off hooks */
		struct esoc_client_hook *esoc_ops =
		@@ -530,7 +538,7 @@ int mhi_arch_pcie_init(struct mhi_controller *mhi_cntrl)
		ret = esoc_register_client_hook(arch_info->esoc_client,
		esoc_ops);
		if (ret)
		MHI_ERR("Failed to register esoc ops\n");
		MHI_CNTRL_ERR("Failed to register esoc ops\n");
		}

		/*
		@@ -581,7 +589,7 @@ static int mhi_arch_drv_suspend(struct mhi_controller *mhi_cntrl)
		link_info.target_link_width = cur_link_info->target_link_width;
		ret = mhi_arch_pcie_scale_bw(mhi_cntrl, pci_dev, &link_info);
		if (ret) {
		MHI_ERR("Failed to switch Gen1 speed\n");
		MHI_CNTRL_ERR("Failed to switch Gen1 speed\n");
		return -EBUSY;
		}

		@@ -611,7 +619,8 @@ int mhi_arch_link_suspend(struct mhi_controller *mhi_cntrl)
		struct pci_dev *pci_dev = mhi_dev->pci_dev;
		int ret = 0;

		MHI_LOG("Entered\n");
		MHI_LOG("Entered with suspend_mode:%s\n",
		TO_MHI_SUSPEND_MODE_STR(mhi_dev->suspend_mode));

		/* disable inactivity timer */
		msm_pcie_l1ss_timeout_disable(pci_dev);
		@@ -621,7 +630,8 @@ int mhi_arch_link_suspend(struct mhi_controller *mhi_cntrl)
		pci_clear_master(pci_dev);
		ret = pci_save_state(mhi_dev->pci_dev);
		if (ret) {
		MHI_ERR("Failed with pci_save_state, ret:%d\n", ret);
		MHI_CNTRL_ERR("Failed with pci_save_state, ret:%d\n",
		ret);
		goto exit_suspend;
		}

		@@ -640,6 +650,7 @@ int mhi_arch_link_suspend(struct mhi_controller *mhi_cntrl)
		break;
		case MHI_ACTIVE_STATE:
		case MHI_FAST_LINK_ON:/* keeping link on do nothing */
		default:
		break;
		}

		@@ -660,8 +671,6 @@ static int __mhi_arch_link_resume(struct mhi_controller *mhi_cntrl)
		struct mhi_link_info *cur_info = &mhi_cntrl->mhi_link_info;
		int ret;

		MHI_LOG("Entered\n");

		/* request bus scale voting based on higher gen speed */
		ret = mhi_arch_set_bus_request(mhi_cntrl,
		cur_info->target_link_speed);
		@@ -704,7 +713,8 @@ int mhi_arch_link_resume(struct mhi_controller *mhi_cntrl)
		struct mhi_link_info *cur_info = &mhi_cntrl->mhi_link_info;
		int ret = 0;

		MHI_LOG("Entered\n");
		MHI_LOG("Entered with suspend_mode:%s\n",
		TO_MHI_SUSPEND_MODE_STR(mhi_dev->suspend_mode));

		switch (mhi_dev->suspend_mode) {
		case MHI_DEFAULT_SUSPEND:
		@@ -722,26 +732,23 @@ int mhi_arch_link_resume(struct mhi_controller *mhi_cntrl)
		* only print an error here.
		*/
		if (mhi_arch_pcie_scale_bw(mhi_cntrl, pci_dev, cur_info))
		MHI_ERR(
		MHI_CNTRL_ERR(
		"Failed to honor bw request: speed:0x%x width:0x%x\n",
		cur_info->target_link_speed,
		cur_info->target_link_width);
		break;
		case MHI_ACTIVE_STATE:
		case MHI_FAST_LINK_ON:
		default:
		break;
		}

		if (ret) {
		MHI_ERR("Link training failed, ret:%d\n", ret);
		return ret;
		}

		if (!ret)
		msm_pcie_l1ss_timeout_enable(pci_dev);

		MHI_LOG("Exited\n");
		MHI_LOG("Exited with ret:%d\n", ret);

		return 0;
		return ret;
		}

		int mhi_arch_link_lpm_disable(struct mhi_controller *mhi_cntrl)

drivers/bus/mhi/controllers/mhi_qcom.c

+38 −18

Original line number	Diff line number	Diff line
		@@ -34,12 +34,19 @@ static const struct firmware_info firmware_table[] = {
		static int debug_mode;
		module_param_named(debug_mode, debug_mode, int, 0644);

		const char * const mhi_suspend_mode_str[MHI_SUSPEND_MODE_MAX] = {
		[MHI_ACTIVE_STATE] = "Active",
		[MHI_DEFAULT_SUSPEND] = "Default",
		[MHI_FAST_LINK_OFF] = "Fast Link Off",
		[MHI_FAST_LINK_ON] = "Fast Link On",
		};

		int mhi_debugfs_trigger_m0(void *data, u64 val)
		{
		struct mhi_controller *mhi_cntrl = data;
		struct mhi_dev *mhi_dev = mhi_controller_get_devdata(mhi_cntrl);

		MHI_LOG("Trigger M3 Exit\n");
		MHI_CNTRL_LOG("Trigger M3 Exit\n");
		pm_runtime_get(&mhi_dev->pci_dev->dev);
		pm_runtime_put(&mhi_dev->pci_dev->dev);

		@@ -53,7 +60,7 @@ int mhi_debugfs_trigger_m3(void *data, u64 val)
		struct mhi_controller *mhi_cntrl = data;
		struct mhi_dev *mhi_dev = mhi_controller_get_devdata(mhi_cntrl);

		MHI_LOG("Trigger M3 Entry\n");
		MHI_CNTRL_LOG("Trigger M3 Entry\n");
		pm_runtime_mark_last_busy(&mhi_dev->pci_dev->dev);
		pm_request_autosuspend(&mhi_dev->pci_dev->dev);

		@@ -92,19 +99,19 @@ static int mhi_init_pci_dev(struct mhi_controller *mhi_cntrl)
		mhi_dev->resn = MHI_PCI_BAR_NUM;
		ret = pci_assign_resource(pci_dev, mhi_dev->resn);
		if (ret) {
		MHI_ERR("Error assign pci resources, ret:%d\n", ret);
		MHI_CNTRL_ERR("Error assign pci resources, ret:%d\n", ret);
		return ret;
		}

		ret = pci_enable_device(pci_dev);
		if (ret) {
		MHI_ERR("Error enabling device, ret:%d\n", ret);
		MHI_CNTRL_ERR("Error enabling device, ret:%d\n", ret);
		goto error_enable_device;
		}

		ret = pci_request_region(pci_dev, mhi_dev->resn, "mhi");
		if (ret) {
		MHI_ERR("Error pci_request_region, ret:%d\n", ret);
		MHI_CNTRL_ERR("Error pci_request_region, ret:%d\n", ret);
		goto error_request_region;
		}

		@@ -114,14 +121,14 @@ static int mhi_init_pci_dev(struct mhi_controller *mhi_cntrl)
		len = pci_resource_len(pci_dev, mhi_dev->resn);
		mhi_cntrl->regs = ioremap_nocache(mhi_cntrl->base_addr, len);
		if (!mhi_cntrl->regs) {
		MHI_ERR("Error ioremap region\n");
		MHI_CNTRL_ERR("Error ioremap region\n");
		goto error_ioremap;
		}

		ret = pci_alloc_irq_vectors(pci_dev, mhi_cntrl->msi_required,
		mhi_cntrl->msi_required, PCI_IRQ_MSI);
		if (IS_ERR_VALUE((ulong)ret) \|\| ret < mhi_cntrl->msi_required) {
		MHI_ERR("Failed to enable MSI, ret:%d\n", ret);
		MHI_CNTRL_ERR("Failed to enable MSI, ret:%d\n", ret);
		goto error_req_msi;
		}

		@@ -395,7 +402,12 @@ static int mhi_force_suspend(struct mhi_controller *mhi_cntrl)
		struct mhi_dev *mhi_dev = mhi_controller_get_devdata(mhi_cntrl);
		int itr = DIV_ROUND_UP(mhi_cntrl->timeout_ms, delayms);

		MHI_LOG("Entered\n");
		MHI_CNTRL_LOG("Entered\n");

		if (debug_mode == MHI_DEBUG_NO_D3 \|\| debug_mode == MHI_FWIMAGE_NO_D3) {
		MHI_CNTRL_LOG("Exited due to debug mode:%d\n", debug_mode);
		return ret;
		}

		mutex_lock(&mhi_cntrl->pm_mutex);

		@@ -411,12 +423,12 @@ static int mhi_force_suspend(struct mhi_controller *mhi_cntrl)
		if (!ret \|\| ret != -EBUSY)
		break;

		MHI_LOG("MHI busy, sleeping and retry\n");
		MHI_CNTRL_LOG("MHI busy, sleeping and retry\n");
		msleep(delayms);
		}

		if (ret) {
		MHI_ERR("Force suspend ret with %d\n", ret);
		MHI_CNTRL_ERR("Force suspend ret:%d\n", ret);
		goto exit_force_suspend;
		}

		@@ -552,14 +564,14 @@ static void mhi_status_cb(struct mhi_controller *mhi_cntrl,
		pm_runtime_get(dev);
		ret = mhi_force_suspend(mhi_cntrl);
		if (!ret) {
		MHI_LOG("Attempt resume after forced suspend\n");
		MHI_CNTRL_LOG("Attempt resume after forced suspend\n");
		mhi_runtime_resume(dev);
		}
		pm_runtime_put(dev);
		mhi_arch_mission_mode_enter(mhi_cntrl);
		break;
		default:
		MHI_ERR("Unhandled cb:0x%x\n", reason);
		MHI_CNTRL_LOG("Unhandled cb:0x%x\n", reason);
		}
		}

		@@ -670,7 +682,7 @@ static struct mhi_controller mhi_register_controller(struct pci_dev pci_dev)
		bool use_s1;
		u32 addr_win[2];
		const char *iommu_dma_type;
		int ret, i;
		int ret, i, len;

		if (!of_node)
		return ERR_PTR(-ENODEV);
		@@ -746,14 +758,22 @@ static struct mhi_controller mhi_register_controller(struct pci_dev pci_dev)
		if (ret)
		goto error_register;

		for (i = 0; i < ARRAY_SIZE(firmware_table); i++) {
		len = ARRAY_SIZE(firmware_table);
		for (i = 0; i < len; i++) {
		firmware_info = firmware_table + i;

		/* debug mode always use default */
		if (!debug_mode && mhi_cntrl->dev_id == firmware_info->dev_id)
		if (mhi_cntrl->dev_id == firmware_info->dev_id)
		break;
		}

		if (debug_mode) {
		if (debug_mode <= MHI_DEBUG_D3)
		firmware_info = firmware_table + (len - 1);
		MHI_CNTRL_LOG("fw info: debug_mode:%d dev_id:%d image:%s\n",
		debug_mode, firmware_info->dev_id,
		firmware_info->fw_image);
		}

		mhi_cntrl->fw_image = firmware_info->fw_image;
		mhi_cntrl->edl_image = firmware_info->edl_image;

		@@ -773,7 +793,7 @@ static struct mhi_controller mhi_register_controller(struct pci_dev pci_dev)
		atomic_set(&mhi_cntrl->write_idx, -1);

		if (sysfs_create_group(&mhi_cntrl->mhi_dev->dev.kobj, &mhi_qcom_group))
		MHI_ERR("Error while creating the sysfs group\n");
		MHI_CNTRL_ERR("Error while creating the sysfs group\n");

		return mhi_cntrl;

		@@ -830,7 +850,7 @@ int mhi_pci_probe(struct pci_dev *pci_dev,

		pm_runtime_mark_last_busy(&pci_dev->dev);

		MHI_LOG("Return successful\n");
		MHI_CNTRL_LOG("Return successful\n");

		return 0;