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

Commit 52cf7a40 authored by Raghavendra Rao Ananta's avatar Raghavendra Rao Ananta
Browse files

esoc: Add IPC logging support 



Add IPC logging support for detailed tracking of events that the
esoc driver would be handling.

Change-Id: Iadb63dc946efc355de2e68d6c4890aade1a04b0c
Signed-off-by: default avatarRaghavendra Rao Ananta <rananta@codeaurora.org>
parent 664dc0bd

drivers/esoc/esoc-mdm-4x.c

+107 −5
Original line number Diff line number Diff line
@@ -55,6 +55,8 @@ static const int required_gpios[] = { 
	AP2MDM_STATUS,

};



void *ipc_log;



static void mdm_debug_gpio_show(struct mdm_ctrl *mdm)

{

	struct device *dev = mdm->dev;
@@ -83,10 +85,25 @@ static void mdm_debug_gpio_show(struct mdm_ctrl *mdm) 
			 __func__, MDM_GPIO(mdm, MDM2AP_VDDMIN));

}



static void mdm_debug_gpio_ipc_log(struct mdm_ctrl *mdm)

{

	esoc_mdm_log("MDM2AP_ERRFATAL gpio = %d\n",

			MDM_GPIO(mdm, MDM2AP_ERRFATAL));

	esoc_mdm_log("AP2MDM_ERRFATAL gpio = %d\n",

			MDM_GPIO(mdm, AP2MDM_ERRFATAL));

	esoc_mdm_log("MDM2AP_STATUS gpio = %d\n",

			MDM_GPIO(mdm, MDM2AP_STATUS));

	esoc_mdm_log("AP2MDM_STATUS gpio = %d\n",

			MDM_GPIO(mdm, AP2MDM_STATUS));

	esoc_mdm_log("AP2MDM_SOFT_RESET gpio = %d\n",

			MDM_GPIO(mdm, AP2MDM_SOFT_RESET));

}



static void mdm_enable_irqs(struct mdm_ctrl *mdm)

{

	if (!mdm)

		return;

	esoc_mdm_log("Enabling the interrupts\n");

	if (mdm->irq_mask & IRQ_ERRFATAL) {

		enable_irq(mdm->errfatal_irq);

		mdm->irq_mask &= ~IRQ_ERRFATAL;
@@ -105,6 +122,7 @@ void mdm_disable_irqs(struct mdm_ctrl *mdm) 
{

	if (!mdm)

		return;

	esoc_mdm_log("Disabling the interrupts\n");

	if (!(mdm->irq_mask & IRQ_ERRFATAL)) {

		disable_irq_nosync(mdm->errfatal_irq);

		mdm->irq_mask |= IRQ_ERRFATAL;
@@ -192,6 +210,7 @@ static int mdm_cmd_exe(enum esoc_cmd cmd, struct esoc_clink *esoc) 
				esoc->clink_ops->notify(ESOC_BOOT_DONE, esoc);

			}

		}

		esoc_mdm_log("ESOC_PWR_ON: Setting AP2MDM_ERRFATAL = 0\n");

		gpio_set_value(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 0);

		mdm->init = 1;

		mdm_do_first_power_on(mdm);
@@ -206,11 +225,17 @@ static int mdm_cmd_exe(enum esoc_cmd cmd, struct esoc_clink *esoc) 
			break;

		graceful_shutdown = true;

		if (!esoc->userspace_handle_shutdown) {

			esoc_mdm_log(

			"ESOC_PWR_OFF: sending sysmon-shutdown to modem\n");

			ret = sysmon_send_shutdown(&esoc->subsys);

			if (ret) {

				esoc_mdm_log(

			"ESOC_PWR_OFF: sysmon-shutdown failed: %d\n", ret);

				dev_err(mdm->dev,

				 "sysmon shutdown fail, ret = %d\n", ret);

				graceful_shutdown = false;

				esoc_mdm_log(

			"ESOC_PWR_OFF: forcefully powering-off modem\n");

			}

		} else {

			esoc_clink_queue_request(ESOC_REQ_SEND_SHUTDOWN, esoc);
@@ -236,13 +261,19 @@ static int mdm_cmd_exe(enum esoc_cmd cmd, struct esoc_clink *esoc) 
		 * monitored by multiple mdms(might be wrongly interpreted as

		 * a primary crash).

		 */

		if (esoc->statusline_not_a_powersource == false)

		if (esoc->statusline_not_a_powersource == false) {

			esoc_mdm_log(

			"ESOC_FORCE_PWR_OFF: setting AP2MDM_STATUS = 0\n");

			gpio_set_value(MDM_GPIO(mdm, AP2MDM_STATUS), 0);

		}

		esoc_mdm_log(

		"ESOC_FORCE_PWR_OFF: Queueing request: ESOC_REQ_SHUTDOWN\n");

		esoc_clink_queue_request(ESOC_REQ_SHUTDOWN, esoc);

		mdm_power_down(mdm);

		mdm_update_gpio_configs(mdm, GPIO_UPDATE_BOOTING_CONFIG);

		break;

	case ESOC_RESET:

		esoc_mdm_log("ESOC_RESET: Resetting the modem\n");

		mdm_toggle_soft_reset(mdm, false);

		break;

	case ESOC_PREPARE_DEBUG:
@@ -252,8 +283,12 @@ static int mdm_cmd_exe(enum esoc_cmd cmd, struct esoc_clink *esoc) 
		 * an APQ crash, wait till mdm is ready for ramdumps.

		 */

		mdm->ready = false;

		esoc_mdm_log(

		"ESOC_PREPARE_DEBUG: Cancelling the status check work\n");

		cancel_delayed_work(&mdm->mdm2ap_status_check_work);

		if (!mdm->esoc->auto_boot) {

			esoc_mdm_log(

			"ESOC_PREPARE_DEBUG: setting AP2MDM_ERRFATAL = 1\n");

			gpio_set_value(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 1);

			dev_dbg(mdm->dev,

				"set ap2mdm errfatal to force reset\n");
@@ -266,6 +301,7 @@ static int mdm_cmd_exe(enum esoc_cmd cmd, struct esoc_clink *esoc) 
		if (mdm->skip_restart_for_mdm_crash)

			break;



		esoc_mdm_log("ESOC_EXE_DEBUG: Resetting the modem\n");

		mdm->debug = 1;

		mdm_toggle_soft_reset(mdm, false);

		/*
@@ -273,8 +309,12 @@ static int mdm_cmd_exe(enum esoc_cmd cmd, struct esoc_clink *esoc) 
		 * then power down the mdm and switch gpios to booting

		 * config

		 */

		esoc_mdm_log(

		"ESOC_EXE_DEBUG: Waiting for ramdumps to be collected\n");

		wait_for_completion(&mdm->debug_done);

		if (mdm->debug_fail) {

			esoc_mdm_log(

			"ESOC_EXE_DEBUG: Failed to collect the ramdumps\n");

			dev_err(mdm->dev, "unable to collect ramdumps\n");

			mdm->debug = 0;

			return -EIO;
@@ -288,11 +328,13 @@ static int mdm_cmd_exe(enum esoc_cmd cmd, struct esoc_clink *esoc) 
		 * Deassert APQ to mdm err fatal

		 * Power on the mdm

		 */

		esoc_mdm_log("ESOC_EXIT_DEBUG: Setting AP2MDM_ERRFATAL = 0\n");

		gpio_set_value(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 0);

		dev_dbg(mdm->dev, "exiting debug state after power on\n");

		mdm->get_restart_reason = true;

		break;

	default:

		esoc_mdm_log("Invalid command\n");

		return -EINVAL;

	};

	return 0;
@@ -306,7 +348,11 @@ static void mdm2ap_status_check(struct work_struct *work) 
	struct device *dev = mdm->dev;

	struct esoc_clink *esoc = mdm->esoc;



	esoc_mdm_log(

	"Powerup timer expired after images are transferred to modem\n");



	if (gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)) == 0) {

		esoc_mdm_log("MDM2AP_STATUS did not go high\n");

		dev_dbg(dev, "MDM2AP_STATUS did not go high\n");

		esoc_clink_evt_notify(ESOC_UNEXPECTED_RESET, esoc);

	}
@@ -336,14 +382,17 @@ static void mdm_get_restart_reason(struct work_struct *work) 
		ret = sysmon_get_reason(&mdm->esoc->subsys, sfr_buf,

							sizeof(sfr_buf));

		if (!ret) {

			esoc_mdm_log("restart reason is %s\n", sfr_buf);

			dev_err(dev, "mdm restart reason is %s\n", sfr_buf);

			break;

		}

		msleep(SFR_RETRY_INTERVAL);

	} while (++ntries < SFR_MAX_RETRIES);

	if (ntries == SFR_MAX_RETRIES)

	if (ntries == SFR_MAX_RETRIES) {

		esoc_mdm_log("restart reason not obtained. err: %d\n", ret);

		dev_dbg(dev, "%s: Error retrieving restart reason: %d\n",

						__func__, ret);

	}

	mdm->get_restart_reason = false;

}
@@ -355,36 +404,53 @@ static void mdm_notify(enum esoc_notify notify, struct esoc_clink *esoc) 
	struct mdm_ctrl *mdm = get_esoc_clink_data(esoc);

	struct device *dev = mdm->dev;



	esoc_mdm_log("Notification: %d\n", notify);



	switch (notify) {

	case ESOC_IMG_XFER_DONE:

		if (gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)) ==  0)

		if (gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS)) ==  0) {

			esoc_mdm_log(

		"ESOC_IMG_XFER_DONE: Begin timeout of %lu ms for modem_status\n",

			MDM2AP_STATUS_TIMEOUT_MS);

			schedule_delayed_work(&mdm->mdm2ap_status_check_work,

				msecs_to_jiffies(MDM2AP_STATUS_TIMEOUT_MS));

		}

		break;

	case ESOC_BOOT_DONE:

		esoc_mdm_log(

		"ESOC_BOOT_DONE: Sending the notification: ESOC_RUN_STATE\n");

		esoc_clink_evt_notify(ESOC_RUN_STATE, esoc);

		break;

	case ESOC_IMG_XFER_RETRY:

		esoc_mdm_log("ESOC_IMG_XFER_RETRY: Resetting the device\n");

		mdm->init = 1;

		mdm_toggle_soft_reset(mdm, false);

		break;

	case ESOC_IMG_XFER_FAIL:

		esoc_mdm_log(

		"ESOC_IMG_XFER_FAIL: Send notification: ESOC_INVALID_STATE\n");

		esoc_clink_evt_notify(ESOC_INVALID_STATE, esoc);

		break;

	case ESOC_BOOT_FAIL:

		esoc_mdm_log(

		"ESOC_BOOT_FAIL: Send notification: ESOC_INVALID_STATE\n");

		esoc_clink_evt_notify(ESOC_INVALID_STATE, esoc);

		break;

	case ESOC_PON_RETRY:

		esoc_mdm_log(

		"ESOC_PON_RETRY: Send notification: ESOC_RETRY_PON_EVT\n");

		esoc_clink_evt_notify(ESOC_RETRY_PON_EVT, esoc);

		break;

	case ESOC_UPGRADE_AVAILABLE:

		break;

	case ESOC_DEBUG_DONE:

		esoc_mdm_log("ESOC_DEBUG_DONE: Ramdumps collection done\n");

		mdm->debug_fail = false;

		mdm_update_gpio_configs(mdm, GPIO_UPDATE_BOOTING_CONFIG);

		complete(&mdm->debug_done);

		break;

	case ESOC_DEBUG_FAIL:

		esoc_mdm_log("ESOC_DEBUG_FAIL: Ramdumps collection failed\n");

		mdm->debug_fail = true;

		complete(&mdm->debug_done);

		break;
@@ -392,9 +458,13 @@ static void mdm_notify(enum esoc_notify notify, struct esoc_clink *esoc) 
		mdm_disable_irqs(mdm);

		status_down = false;

		dev_dbg(dev, "signal apq err fatal for graceful restart\n");

		esoc_mdm_log(

		"ESOC_PRIMARY_CRASH: Setting AP2MDM_ERRFATAL = 1\n");

		gpio_set_value(MDM_GPIO(mdm, AP2MDM_ERRFATAL), 1);

		if (esoc->primary)

			break;

		esoc_mdm_log(

		"ESOC_PRIMARY_CRASH: Waiting for MDM2AP_STATUS to go LOW\n");

		timeout = local_clock();

		do_div(timeout, NSEC_PER_MSEC);

		timeout += MDM_MODEM_TIMEOUT;
@@ -409,6 +479,8 @@ static void mdm_notify(enum esoc_notify notify, struct esoc_clink *esoc) 
		} while (!time_after64(now, timeout));



		if (!status_down) {

			esoc_mdm_log(

	"ESOC_PRIMARY_CRASH: MDM2AP_STATUS didn't go LOW. Resetting modem\n");

			dev_err(mdm->dev, "%s MDM2AP status did not go low\n",

								__func__);

			mdm_toggle_soft_reset(mdm, true);
@@ -418,6 +490,8 @@ static void mdm_notify(enum esoc_notify notify, struct esoc_clink *esoc) 
		mdm_disable_irqs(mdm);

		mdm->debug = 0;

		mdm->ready = false;

		esoc_mdm_log(

		"ESOC_PRIMARY_REBOOT: Powering down the modem\n");

		mdm_power_down(mdm);

		break;

	};
@@ -435,6 +509,7 @@ static irqreturn_t mdm_errfatal(int irq, void *dev_id) 
	if (!mdm->ready)

		goto mdm_pwroff_irq;

	esoc = mdm->esoc;

	esoc_mdm_log("MDM2AP_ERRFATAL IRQ received!\n");

	dev_err(dev, "%s: mdm sent errfatal interrupt\n",

					__func__);

	subsys_set_crash_status(esoc->subsys_dev, true);
@@ -442,6 +517,8 @@ static irqreturn_t mdm_errfatal(int irq, void *dev_id) 
	esoc_clink_evt_notify(ESOC_ERR_FATAL, esoc);

	return IRQ_HANDLED;

mdm_pwroff_irq:

	esoc_mdm_log(

	"MDM2AP_ERRFATAL IRQ received before modem booted. Ignoring.\n");

	dev_info(dev, "errfatal irq when in pwroff\n");

no_mdm_irq:

	return IRQ_HANDLED;
@@ -458,15 +535,19 @@ static irqreturn_t mdm_status_change(int irq, void *dev_id) 
		return IRQ_HANDLED;

	dev = mdm->dev;

	esoc = mdm->esoc;

	esoc_mdm_log("MDM2AP_STATUS IRQ received!\n");

	/*

	 * On auto boot devices, there is a possibility of receiving

	 * status change interrupt before esoc_clink structure is

	 * initialized. Ignore them.

	 */

	if (!esoc)

	if (!esoc) {

		esoc_mdm_log("Unexpected IRQ. Ignoring.\n");

		return IRQ_HANDLED;

	}

	value = gpio_get_value(MDM_GPIO(mdm, MDM2AP_STATUS));

	if (value == 0 && mdm->ready) {

		esoc_mdm_log("Unexpected reset of external modem\n");

		dev_err(dev, "unexpected reset external modem\n");

		subsys_set_crash_status(esoc->subsys_dev, true);

		esoc_clink_evt_notify(ESOC_UNEXPECTED_RESET, esoc);
@@ -478,6 +559,8 @@ static irqreturn_t mdm_status_change(int irq, void *dev_id) 
		if (esoc->auto_boot && mdm->ready)

			return IRQ_HANDLED;



		esoc_mdm_log(

		"Modem ready. Cancelling the the status_check work\n");

		cancel_delayed_work(&mdm->mdm2ap_status_check_work);

		dev_dbg(dev, "status = 1: mdm is now ready\n");

		mdm->ready = true;
@@ -887,30 +970,35 @@ static int sdx50m_setup_hw(struct mdm_ctrl *mdm, 


	ret = mdm_dt_parse_gpios(mdm);

	if (ret) {

		esoc_mdm_log("Failed to parse DT gpios\n");

		dev_err(mdm->dev, "Failed to parse DT gpios\n");

		goto err_destroy_wrkq;

	}



	ret = mdm_pon_dt_init(mdm);

	if (ret) {

		esoc_mdm_log("Failed to parse PON DT gpios\n");

		dev_err(mdm->dev, "Failed to parse PON DT gpio\n");

		goto err_destroy_wrkq;

	}



	ret = mdm_pinctrl_init(mdm);

	if (ret) {

		esoc_mdm_log("Failed to init pinctrl\n");

		dev_err(mdm->dev, "Failed to init pinctrl\n");

		goto err_destroy_wrkq;

	}



	ret = mdm_pon_setup(mdm);

	if (ret) {

		esoc_mdm_log("Failed to setup PON\n");

		dev_err(mdm->dev, "Failed to setup PON\n");

		goto err_destroy_wrkq;

	}



	ret = mdm_configure_ipc(mdm, pdev);

	if (ret) {

		esoc_mdm_log("Failed to configure the ipc\n");

		dev_err(mdm->dev, "Failed to configure the ipc\n");

		goto err_release_ipc;

	}
@@ -935,10 +1023,12 @@ static int sdx50m_setup_hw(struct mdm_ctrl *mdm, 


	ret = esoc_clink_register(esoc);

	if (ret) {

		esoc_mdm_log("esoc registration failed\n");

		dev_err(mdm->dev, "esoc registration failed\n");

		goto err_free_irq;

	}

	dev_dbg(mdm->dev, "esoc registration done\n");

	esoc_mdm_log("Done configuring the GPIOs and esoc registration\n");



	init_completion(&mdm->debug_done);

	INIT_WORK(&mdm->mdm_status_work, mdm_status_fn);
@@ -949,6 +1039,8 @@ static int sdx50m_setup_hw(struct mdm_ctrl *mdm, 
	mdm->esoc = esoc;

	mdm->init = 0;



	mdm_debug_gpio_ipc_log(mdm);



	return 0;



err_free_irq:
@@ -994,6 +1086,7 @@ static int mdm_probe(struct platform_device *pdev) 
	const struct mdm_ops *mdm_ops;

	struct device_node *node = pdev->dev.of_node;

	struct mdm_ctrl *mdm;

	int ret;



	match = of_match_node(mdm_dt_match, node);

	if (IS_ERR_OR_NULL(match))
@@ -1002,7 +1095,16 @@ static int mdm_probe(struct platform_device *pdev) 
	mdm = devm_kzalloc(&pdev->dev, sizeof(*mdm), GFP_KERNEL);

	if (IS_ERR_OR_NULL(mdm))

		return PTR_ERR(mdm);

	return mdm_ops->config_hw(mdm, mdm_ops, pdev);



	ipc_log = ipc_log_context_create(ESOC_MDM_IPC_PAGES, "esoc-mdm", 0);

	if (!ipc_log)

		dev_err(&pdev->dev, "Failed to setup IPC logging\n");



	ret = mdm_ops->config_hw(mdm, mdm_ops, pdev);

	if (ret)

		ipc_log_context_destroy(ipc_log);



	return ret;

}



static struct platform_driver mdm_driver = {

drivers/esoc/esoc-mdm-drv.c

+72 −2
Original line number Diff line number Diff line
@@ -82,6 +82,8 @@ static int esoc_msm_restart_handler(struct notifier_block *nb, 
	if (action == SYS_RESTART) {

		if (mdm_dbg_stall_notify(ESOC_PRIMARY_REBOOT))

			return NOTIFY_OK;

		esoc_mdm_log(

			"Reboot notifier: Notifying esoc of cold reboot\n");

		dev_dbg(&esoc_clink->dev, "Notifying esoc of cold reboot\n");

		clink_ops->notify(ESOC_PRIMARY_REBOOT, esoc_clink);

	}
@@ -91,23 +93,35 @@ static void mdm_handle_clink_evt(enum esoc_evt evt, 
					struct esoc_eng *eng)

{

	struct mdm_drv *mdm_drv = to_mdm_drv(eng);

	bool unexpected_state = false;



	switch (evt) {

	case ESOC_INVALID_STATE:

		esoc_mdm_log(

		"ESOC_INVALID_STATE: Calling complete with state: PON_FAIL\n");

		mdm_drv->pon_state = PON_FAIL;

		complete(&mdm_drv->pon_done);

		break;

	case ESOC_RUN_STATE:

		esoc_mdm_log(

		"ESOC_RUN_STATE: Calling complete with state: PON_SUCCESS\n");

		mdm_drv->pon_state = PON_SUCCESS;

		mdm_drv->mode = RUN,

		complete(&mdm_drv->pon_done);

		break;

	case ESOC_RETRY_PON_EVT:

		esoc_mdm_log(

		"ESOC_RETRY_PON_EVT: Calling complete with state: PON_RETRY\n");

		mdm_drv->pon_state = PON_RETRY;

		complete(&mdm_drv->pon_done);

		break;

	case ESOC_UNEXPECTED_RESET:

		esoc_mdm_log("evt_state: ESOC_UNEXPECTED_RESET\n");

		unexpected_state = true;

	case ESOC_ERR_FATAL:

		if (!unexpected_state)

			esoc_mdm_log("evt_state: ESOC_ERR_FATAL\n");



		/*

		 * Modem can crash while we are waiting for pon_done during

		 * a subsystem_get(). Setting mode to CRASH will prevent a
@@ -115,12 +129,20 @@ static void mdm_handle_clink_evt(enum esoc_evt evt, 
		 * this by seting mode to CRASH only if device was up and

		 * running.

		 */

		if (mdm_drv->mode == CRASH)

			esoc_mdm_log(

			"Modem in crash state already. Ignoring.\n");

		if (mdm_drv->mode != RUN)

			esoc_mdm_log("Modem not up. Ignoring.\n");

		if (mdm_drv->mode == CRASH || mdm_drv->mode != RUN)

			return;

		mdm_drv->mode = CRASH;

		esoc_mdm_log("Starting SSR work\n");

		queue_work(mdm_drv->mdm_queue, &mdm_drv->ssr_work);

		break;

	case ESOC_REQ_ENG_ON:

		esoc_mdm_log(

		"evt_state: ESOC_REQ_ENG_ON; Registered a req engine\n");

		complete(&mdm_drv->req_eng_wait);

		break;

	default:
@@ -145,6 +167,8 @@ static void esoc_client_link_power_on(struct esoc_clink *esoc_clink, 
	struct esoc_client_hook *client_hook;



	dev_dbg(&esoc_clink->dev, "Calling power_on hooks\n");

	esoc_mdm_log(

	"Calling power_on hooks with crash state: %d\n", mdm_crashed);



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

		client_hook = esoc_clink->client_hook[i];
@@ -161,6 +185,8 @@ static void esoc_client_link_power_off(struct esoc_clink *esoc_clink, 
	struct esoc_client_hook *client_hook;



	dev_dbg(&esoc_clink->dev, "Calling power_off hooks\n");

	esoc_mdm_log(

	"Calling power_off hooks with crash state: %d\n", mdm_crashed);



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

		client_hook = esoc_clink->client_hook[i];
@@ -179,6 +205,8 @@ static void mdm_crash_shutdown(const struct subsys_desc *mdm_subsys) 
								subsys);

	const struct esoc_clink_ops * const clink_ops = esoc_clink->clink_ops;



	esoc_mdm_log("MDM crashed notification from SSR\n");



	if (mdm_dbg_stall_notify(ESOC_PRIMARY_CRASH))

		return;

	clink_ops->notify(ESOC_PRIMARY_CRASH, esoc_clink);
@@ -193,7 +221,10 @@ static int mdm_subsys_shutdown(const struct subsys_desc *crashed_subsys, 
	struct mdm_drv *mdm_drv = esoc_get_drv_data(esoc_clink);

	const struct esoc_clink_ops * const clink_ops = esoc_clink->clink_ops;



	esoc_mdm_log("Shutdown request from SSR\n");



	if (mdm_drv->mode == CRASH || mdm_drv->mode == PEER_CRASH) {

		esoc_mdm_log("Shutdown in crash mode\n");

		if (mdm_dbg_stall_cmd(ESOC_PREPARE_DEBUG))

			/* We want to mask debug command.

			 * In this case return success
@@ -204,18 +235,23 @@ static int mdm_subsys_shutdown(const struct subsys_desc *crashed_subsys, 
		esoc_clink_queue_request(ESOC_REQ_CRASH_SHUTDOWN, esoc_clink);

		esoc_client_link_power_off(esoc_clink, true);



		esoc_mdm_log("Executing the ESOC_PREPARE_DEBUG command\n");

		ret = clink_ops->cmd_exe(ESOC_PREPARE_DEBUG,

							esoc_clink);

		if (ret) {

			esoc_mdm_log("ESOC_PREPARE_DEBUG command failed\n");

			dev_err(&esoc_clink->dev, "failed to enter debug\n");

			return ret;

		}

		mdm_drv->mode = IN_DEBUG;

	} else if (!force_stop) {

		if (esoc_clink->subsys.sysmon_shutdown_ret)

		esoc_mdm_log("Graceful shutdown mode\n");

		if (esoc_clink->subsys.sysmon_shutdown_ret) {

			esoc_mdm_log(

			"Executing the ESOC_FORCE_PWR_OFF command\n");

			ret = clink_ops->cmd_exe(ESOC_FORCE_PWR_OFF,

							esoc_clink);

		else {

		} else {

			if (mdm_dbg_stall_cmd(ESOC_PWR_OFF))

				/* Since power off command is masked

				 * we return success, and leave the state
@@ -223,9 +259,12 @@ static int mdm_subsys_shutdown(const struct subsys_desc *crashed_subsys, 
				 */

				return 0;

			dev_dbg(&esoc_clink->dev, "Sending sysmon-shutdown\n");

			esoc_mdm_log("Executing the ESOC_PWR_OFF command\n");

			ret = clink_ops->cmd_exe(ESOC_PWR_OFF, esoc_clink);

		}

		if (ret) {

			esoc_mdm_log(

			"Executing the ESOC_PWR_OFF command failed\n");

			dev_err(&esoc_clink->dev, "failed to exe power off\n");

			return ret;

		}
@@ -234,6 +273,7 @@ static int mdm_subsys_shutdown(const struct subsys_desc *crashed_subsys, 
		clink_ops->cmd_exe(ESOC_FORCE_PWR_OFF, esoc_clink);

		mdm_drv->mode = PWR_OFF;

	}

	esoc_mdm_log("Shutdown completed\n");

	return 0;

}
@@ -242,6 +282,8 @@ static void mdm_subsys_retry_powerup_cleanup(struct esoc_clink *esoc_clink) 
	struct mdm_ctrl *mdm = get_esoc_clink_data(esoc_clink);

	struct mdm_drv *mdm_drv = esoc_get_drv_data(esoc_clink);



	esoc_mdm_log("Doing cleanup\n");



	esoc_client_link_power_off(esoc_clink, false);

	mdm_disable_irqs(mdm);

	mdm_drv->pon_state = PON_INIT;
@@ -257,6 +299,7 @@ static int mdm_handle_boot_fail(struct esoc_clink *esoc_clink, u8 *pon_trial) 
	switch (boot_fail_action) {

	case BOOT_FAIL_ACTION_RETRY:

		mdm_subsys_retry_powerup_cleanup(esoc_clink);

		esoc_mdm_log("Request to retry a warm reset\n");

		(*pon_trial)++;

		break;

	/*
@@ -266,17 +309,21 @@ static int mdm_handle_boot_fail(struct esoc_clink *esoc_clink, u8 *pon_trial) 
	 */

	case BOOT_FAIL_ACTION_COLD_RESET:

		mdm_subsys_retry_powerup_cleanup(esoc_clink);

		esoc_mdm_log("Doing cold reset by power-down and warm reset\n");

		(*pon_trial)++;

		mdm_power_down(mdm);

		break;

	case BOOT_FAIL_ACTION_PANIC:

		esoc_mdm_log("Calling panic!!\n");

		panic("Panic requested on external modem boot failure\n");

		break;

	case BOOT_FAIL_ACTION_NOP:

		esoc_mdm_log("Leaving the modem in its curent state\n");

		return -EIO;

	case BOOT_FAIL_ACTION_SHUTDOWN:

	default:

		mdm_subsys_retry_powerup_cleanup(esoc_clink);

		esoc_mdm_log("Shutdown the modem and quit\n");

		mdm_power_down(mdm);

		return -EIO;

	}
@@ -295,30 +342,43 @@ static int mdm_subsys_powerup(const struct subsys_desc *crashed_subsys) 
	int timeout = INT_MAX;

	u8 pon_trial = 1;



	esoc_mdm_log("Powerup request from SSR\n");



	do {

		esoc_mdm_log("Boot trial: %d\n", pon_trial);

		if (!esoc_clink->auto_boot &&

			!esoc_req_eng_enabled(esoc_clink)) {

			esoc_mdm_log("Wait for req eng registration\n");

			dev_dbg(&esoc_clink->dev,

					"Wait for req eng registration\n");

			wait_for_completion(&mdm_drv->req_eng_wait);

		}

		esoc_mdm_log("Req eng available\n");

		if (mdm_drv->mode == PWR_OFF) {

			esoc_mdm_log("In normal power-on mode\n");

			if (mdm_dbg_stall_cmd(ESOC_PWR_ON))

				return -EBUSY;

			esoc_mdm_log("Executing the ESOC_PWR_ON command\n");

			ret = clink_ops->cmd_exe(ESOC_PWR_ON, esoc_clink);

			if (ret) {

				esoc_mdm_log("ESOC_PWR_ON command failed\n");

				dev_err(&esoc_clink->dev, "pwr on fail\n");

				return ret;

			}

			esoc_client_link_power_on(esoc_clink, false);

		} else if (mdm_drv->mode == IN_DEBUG) {

			esoc_mdm_log("In SSR power-on mode\n");

			esoc_mdm_log("Executing the ESOC_EXIT_DEBUG command\n");

			ret = clink_ops->cmd_exe(ESOC_EXIT_DEBUG, esoc_clink);

			if (ret) {

				esoc_mdm_log(

				"ESOC_EXIT_DEBUG command failed\n");

				dev_err(&esoc_clink->dev,

						"cannot exit debug mode\n");

				return ret;

			}

			mdm_drv->mode = PWR_OFF;

			esoc_mdm_log("Executing the ESOC_PWR_ON command\n");

			ret = clink_ops->cmd_exe(ESOC_PWR_ON, esoc_clink);

			if (ret) {

				dev_err(&esoc_clink->dev, "pwr on fail\n");
@@ -336,13 +396,18 @@ static int mdm_subsys_powerup(const struct subsys_desc *crashed_subsys) 
		 */

		if (esoc_clink->auto_boot)

			timeout = 10 * HZ;

		esoc_mdm_log(

		"Modem turned-on. Waiting for pon_done notification..\n");

		ret = wait_for_completion_timeout(&mdm_drv->pon_done, timeout);

		if (mdm_drv->pon_state == PON_FAIL || ret <= 0) {

			dev_err(&esoc_clink->dev, "booting failed\n");

			esoc_mdm_log("booting failed\n");

			ret = mdm_handle_boot_fail(esoc_clink, &pon_trial);

			if (ret)

				return ret;

		} else if (mdm_drv->pon_state == PON_RETRY) {

			esoc_mdm_log(

			"Boot failed. Doing cleanup and attempting to retry\n");

			pon_trial++;

			mdm_subsys_retry_powerup_cleanup(esoc_clink);

		} else if (mdm_drv->pon_state == PON_SUCCESS) {
@@ -362,9 +427,14 @@ static int mdm_subsys_ramdumps(int want_dumps, 
								subsys);

	const struct esoc_clink_ops * const clink_ops = esoc_clink->clink_ops;



	esoc_mdm_log("Ramdumps called from SSR\n");



	if (want_dumps) {

		esoc_mdm_log("Executing the ESOC_EXE_DEBUG command\n");

		ret = clink_ops->cmd_exe(ESOC_EXE_DEBUG, esoc_clink);

		if (ret) {

			esoc_mdm_log(

			"Failed executing the ESOC_EXE_DEBUG command\n");

			dev_err(&esoc_clink->dev, "debugging failed\n");

			return ret;

		}

drivers/esoc/esoc-mdm-pon.c

+19 −1
Original line number Diff line number Diff line
@@ -51,6 +51,11 @@ static int sdx50m_toggle_soft_reset(struct mdm_ctrl *mdm, bool atomic) 
		soft_reset_direction_assert = 1;

		soft_reset_direction_de_assert = 0;

	}



	esoc_mdm_log("RESET GPIO value (before doing a reset): %d\n",

			gpio_get_value(MDM_GPIO(mdm, AP2MDM_SOFT_RESET)));

	esoc_mdm_log("Setting AP2MDM_SOFT_RESET = %d\n",

				soft_reset_direction_assert);

	gpio_direction_output(MDM_GPIO(mdm, AP2MDM_SOFT_RESET),

			soft_reset_direction_assert);

	/*
@@ -64,6 +69,9 @@ static int sdx50m_toggle_soft_reset(struct mdm_ctrl *mdm, bool atomic) 
		 * panic handler, which has to executed atomically.

		 */

		mdelay(100);



	esoc_mdm_log("Setting AP2MDM_SOFT_RESET = %d\n",

				soft_reset_direction_de_assert);

	gpio_direction_output(MDM_GPIO(mdm, AP2MDM_SOFT_RESET),

			soft_reset_direction_de_assert);

	return 0;
@@ -75,6 +83,7 @@ static int mdm4x_do_first_power_on(struct mdm_ctrl *mdm) 
	int pblrdy;

	struct device *dev = mdm->dev;



	esoc_mdm_log("Powering on modem for the first time\n");

	dev_dbg(dev, "Powering on modem for the first time\n");

	if (mdm->esoc->auto_boot)

		return 0;
@@ -82,6 +91,7 @@ static int mdm4x_do_first_power_on(struct mdm_ctrl *mdm) 
	mdm_toggle_soft_reset(mdm, false);

	/* Add a delay to allow PON sequence to complete*/

	msleep(150);

	esoc_mdm_log("Setting AP2MDM_STATUS = 1\n");

	gpio_direction_output(MDM_GPIO(mdm, AP2MDM_STATUS), 1);

	if (gpio_is_valid(MDM_GPIO(mdm, MDM2AP_PBLRDY))) {

		for (i = 0; i  < MDM_PBLRDY_CNT; i++) {
@@ -98,8 +108,10 @@ static int mdm4x_do_first_power_on(struct mdm_ctrl *mdm) 
	 * Send request for image. Let userspace confirm establishment of

	 * link to external modem.

	 */

	else

	else {

		esoc_mdm_log("Queueing the request: ESOC_REQ_IMG\n");

		esoc_clink_queue_request(ESOC_REQ_IMG, mdm->esoc);

	}

	return 0;

}
@@ -134,6 +146,7 @@ static int sdx50m_power_down(struct mdm_ctrl *mdm) 
	struct device *dev = mdm->dev;

	int soft_reset_direction = mdm->soft_reset_inverted ? 1 : 0;

	/* Assert the soft reset line whether mdm2ap_status went low or not */

	esoc_mdm_log("Setting AP2MDM_SOFT_RESET = %d\n", soft_reset_direction);

	gpio_direction_output(MDM_GPIO(mdm, AP2MDM_SOFT_RESET),

					soft_reset_direction);

	dev_dbg(dev, "Doing a hard reset\n");
@@ -152,6 +165,7 @@ static int sdx50m_power_down(struct mdm_ctrl *mdm) 
static void mdm9x55_cold_reset(struct mdm_ctrl *mdm)

{

	dev_dbg(mdm->dev, "Triggering mdm cold reset");



	gpio_direction_output(MDM_GPIO(mdm, AP2MDM_SOFT_RESET),

			!!mdm->soft_reset_inverted);
@@ -168,6 +182,8 @@ static void mdm9x55_cold_reset(struct mdm_ctrl *mdm) 
static void sdx50m_cold_reset(struct mdm_ctrl *mdm)

{

	dev_dbg(mdm->dev, "Triggering mdm cold reset");

	esoc_mdm_log("Setting AP2MDM_SOFT_RESET = %d\n",

					!!mdm->soft_reset_inverted);

	gpio_direction_output(MDM_GPIO(mdm, AP2MDM_SOFT_RESET),

			!!mdm->soft_reset_inverted);
@@ -177,6 +193,8 @@ static void sdx50m_cold_reset(struct mdm_ctrl *mdm) 
	 */

	mdelay(600);



	esoc_mdm_log("Setting AP2MDM_SOFT_RESET = %d\n",

					!!mdm->soft_reset_inverted);

	gpio_direction_output(MDM_GPIO(mdm, AP2MDM_SOFT_RESET),

			!mdm->soft_reset_inverted);

}

drivers/esoc/esoc.h

+12 −0
Original line number Diff line number Diff line
@@ -23,6 +23,18 @@ 
#include <linux/spinlock.h>

#include <soc/qcom/subsystem_restart.h>

#include <soc/qcom/subsystem_notif.h>

#include <linux/ipc_logging.h>



#define ESOC_MDM_IPC_PAGES	10



extern void *ipc_log;



#define esoc_mdm_log(__msg, ...) \

do { \

	if (ipc_log) \

		ipc_log_string(ipc_log, \

			"[%s]: "__msg, __func__, ##__VA_ARGS__); \

} while (0)



#define ESOC_DEV_MAX		4

#define ESOC_NAME_LEN		20

drivers/esoc/esoc_dev.c

+58 −8

File changed.

Preview size limit exceeded, changes collapsed.