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

Commit d0f6fa7b authored by Andy Gross's avatar Andy Gross
Browse files

firmware: qcom: scm: Convert SCM to platform driver 



This patch converts the Qualcomm SCM firmware driver into a platform
driver.  It also adds clock management for firmware calls which require
clocks to be enabled during the duration of their execution.  Rate
setting of the core clock is also in place for higher performance.

Signed-off-by: default avatarAndy Gross <andy.gross@linaro.org>
Acked-by: default avatarBjorn Andersson <bjorn.andersson@linaro.org>
Reviewed-by: default avatarStephen Boyd <sboyd@codeaurora.org>
parent 0ff50d60

drivers/firmware/qcom_scm.c

+165 −9
Original line number Diff line number Diff line
@@ -10,19 +10,61 @@ 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 * GNU General Public License for more details.

 *

 * You should have received a copy of the GNU General Public License

 * along with this program; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA

 * 02110-1301, USA.

 */



#include <linux/platform_device.h>

#include <linux/module.h>

#include <linux/cpumask.h>

#include <linux/export.h>

#include <linux/types.h>

#include <linux/qcom_scm.h>

#include <linux/of.h>

#include <linux/of_platform.h>

#include <linux/clk.h>



#include "qcom_scm.h"



struct qcom_scm {

	struct device *dev;

	struct clk *core_clk;

	struct clk *iface_clk;

	struct clk *bus_clk;

};



static struct qcom_scm *__scm;



static int qcom_scm_clk_enable(void)

{

	int ret;



	ret = clk_prepare_enable(__scm->core_clk);

	if (ret)

		goto bail;



	ret = clk_prepare_enable(__scm->iface_clk);

	if (ret)

		goto disable_core;



	ret = clk_prepare_enable(__scm->bus_clk);

	if (ret)

		goto disable_iface;



	return 0;



disable_iface:

	clk_disable_unprepare(__scm->iface_clk);

disable_core:

	clk_disable_unprepare(__scm->core_clk);

bail:

	return ret;

}



static void qcom_scm_clk_disable(void)

{

	clk_disable_unprepare(__scm->core_clk);

	clk_disable_unprepare(__scm->iface_clk);

	clk_disable_unprepare(__scm->bus_clk);

}



/**

 * qcom_scm_set_cold_boot_addr() - Set the cold boot address for cpus

 * @entry: Entry point function for the cpus
@@ -72,12 +114,17 @@ EXPORT_SYMBOL(qcom_scm_cpu_power_down); 
 */

bool qcom_scm_hdcp_available(void)

{

	int ret;

	int ret = qcom_scm_clk_enable();



	if (ret)

		return ret;



	ret = __qcom_scm_is_call_available(QCOM_SCM_SVC_HDCP,

						QCOM_SCM_CMD_HDCP);



	return (ret > 0) ? true : false;

	qcom_scm_clk_disable();



	return ret > 0 ? true : false;

}

EXPORT_SYMBOL(qcom_scm_hdcp_available);
@@ -91,6 +138,115 @@ EXPORT_SYMBOL(qcom_scm_hdcp_available); 
 */

int qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt, u32 *resp)

{

	return __qcom_scm_hdcp_req(req, req_cnt, resp);

	int ret = qcom_scm_clk_enable();



	if (ret)

		return ret;



	ret = __qcom_scm_hdcp_req(req, req_cnt, resp);

	qcom_scm_clk_disable();

	return ret;

}

EXPORT_SYMBOL(qcom_scm_hdcp_req);



static int qcom_scm_probe(struct platform_device *pdev)

{

	struct qcom_scm *scm;

	int ret;



	scm = devm_kzalloc(&pdev->dev, sizeof(*scm), GFP_KERNEL);

	if (!scm)

		return -ENOMEM;



	scm->core_clk = devm_clk_get(&pdev->dev, "core");

	if (IS_ERR(scm->core_clk)) {

		if (PTR_ERR(scm->core_clk) == -EPROBE_DEFER)

			return PTR_ERR(scm->core_clk);



		scm->core_clk = NULL;

	}



	if (of_device_is_compatible(pdev->dev.of_node, "qcom,scm")) {

		scm->iface_clk = devm_clk_get(&pdev->dev, "iface");

		if (IS_ERR(scm->iface_clk)) {

			if (PTR_ERR(scm->iface_clk) != -EPROBE_DEFER)

				dev_err(&pdev->dev, "failed to acquire iface clk\n");

			return PTR_ERR(scm->iface_clk);

		}



		scm->bus_clk = devm_clk_get(&pdev->dev, "bus");

		if (IS_ERR(scm->bus_clk)) {

			if (PTR_ERR(scm->bus_clk) != -EPROBE_DEFER)

				dev_err(&pdev->dev, "failed to acquire bus clk\n");

			return PTR_ERR(scm->bus_clk);

		}

	}



	/* vote for max clk rate for highest performance */

	ret = clk_set_rate(scm->core_clk, INT_MAX);

	if (ret)

		return ret;



	__scm = scm;

	__scm->dev = &pdev->dev;



	return 0;

}



static const struct of_device_id qcom_scm_dt_match[] = {

	{ .compatible = "qcom,scm-apq8064",},

	{ .compatible = "qcom,scm-msm8660",},

	{ .compatible = "qcom,scm-msm8960",},

	{ .compatible = "qcom,scm",},

	{}

};



MODULE_DEVICE_TABLE(of, qcom_scm_dt_match);



static struct platform_driver qcom_scm_driver = {

	.driver = {

		.name	= "qcom_scm",

		.of_match_table = qcom_scm_dt_match,

	},

	.probe = qcom_scm_probe,

};



static int __init qcom_scm_init(void)

{

	struct device_node *np, *fw_np;

	int ret;



	fw_np = of_find_node_by_name(NULL, "firmware");



	if (!fw_np)

		return -ENODEV;



	np = of_find_matching_node(fw_np, qcom_scm_dt_match);



	if (!np) {

		of_node_put(fw_np);

		return -ENODEV;

	}



	of_node_put(np);



	ret = of_platform_populate(fw_np, qcom_scm_dt_match, NULL, NULL);



	of_node_put(fw_np);



	if (ret)

		return ret;



	return platform_driver_register(&qcom_scm_driver);

}



arch_initcall(qcom_scm_init);



static void __exit qcom_scm_exit(void)

{

	platform_driver_unregister(&qcom_scm_driver);

}

module_exit(qcom_scm_exit);



MODULE_DESCRIPTION("Qualcomm SCM driver");

MODULE_LICENSE("GPL v2");