arch/arm/mach-msm/pil-mba.c - kernel/msm - Gitiles

 /*
  * Copyright (c) 2012, Code Aurora Forum. All rights reserved.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 2 and
  * only version 2 as published by the Free Software Foundation.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  */

 #include <linux/init.h>
 #include <linux/module.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
 #include <linux/iopoll.h>
 #include <linux/ioport.h>
 #include <linux/elf.h>
 #include <linux/delay.h>
 #include <linux/sched.h>
 #include <linux/clk.h>
 #include <linux/err.h>
 #include <linux/of.h>

 #include "peripheral-loader.h"

 #define RMB_MBA_COMMAND			0x08
 #define RMB_MBA_STATUS			0x0C
 #define RMB_PMI_META_DATA		0x10
 #define RMB_PMI_CODE_START		0x14
 #define RMB_PMI_CODE_LENGTH		0x18

 #define CMD_META_DATA_READY		0x1
 #define CMD_LOAD_READY			0x2

 #define STATUS_META_DATA_AUTH_SUCCESS	0x3
 #define STATUS_AUTH_COMPLETE		0x4

 #define AUTH_TIMEOUT_US			10000000
 #define PROXY_TIMEOUT_MS		10000
 #define POLL_INTERVAL_US		50

 struct mba_data {
 	void __iomem *reg_base;
 	void __iomem *metadata_base;
 	unsigned long metadata_phys;
 	struct pil_device *pil;
 	struct clk *xo;
 	u32 img_length;
 };

 static int pil_mba_make_proxy_votes(struct pil_desc *pil)
 {
 	int ret;
 	struct mba_data *drv = dev_get_drvdata(pil->dev);

 	ret = clk_prepare_enable(drv->xo);
 	if (ret) {
 		dev_err(pil->dev, "Failed to enable XO\n");
 		return ret;
 	}
 	return 0;
 }

 static void pil_mba_remove_proxy_votes(struct pil_desc *pil)
 {
 	struct mba_data *drv = dev_get_drvdata(pil->dev);
 	clk_disable_unprepare(drv->xo);
 }

 static int pil_mba_init_image(struct pil_desc *pil,
 			      const u8 *metadata, size_t size)
 {
 	struct mba_data *drv = dev_get_drvdata(pil->dev);
 	s32 status;
 	int ret;

 	/* Copy metadata to assigned shared buffer location */
 	memcpy(drv->metadata_base, metadata, size);

 	/* Initialize length counter to 0 */
 	writel_relaxed(0, drv->reg_base + RMB_PMI_CODE_LENGTH);
 	drv->img_length = 0;

 	/* Pass address of meta-data to the MBA and perform authentication */
 	writel_relaxed(drv->metadata_phys, drv->reg_base + RMB_PMI_META_DATA);
 	writel_relaxed(CMD_META_DATA_READY, drv->reg_base + RMB_MBA_COMMAND);
 	ret = readl_poll_timeout(drv->reg_base + RMB_MBA_STATUS, status,
 		status == STATUS_META_DATA_AUTH_SUCCESS || status < 0,
 		POLL_INTERVAL_US, AUTH_TIMEOUT_US);
 	if (ret) {
 		dev_err(pil->dev, "MBA authentication timed out\n");
 	} else if (status < 0) {
 		dev_err(pil->dev, "MBA returned error %d\n", status);
 		ret = -EINVAL;
 	}

 	return ret;
 }

 static int pil_mba_verify_blob(struct pil_desc *pil, u32 phy_addr,
 			       size_t size)
 {
 	struct mba_data *drv = dev_get_drvdata(pil->dev);
 	s32 status;

 	/* Begin image authentication */
 	if (drv->img_length == 0) {
 		writel_relaxed(phy_addr, drv->reg_base + RMB_PMI_CODE_START);
 		writel_relaxed(CMD_LOAD_READY, drv->reg_base + RMB_MBA_COMMAND);
 	}
 	/* Increment length counter */
 	drv->img_length += size;
 	writel_relaxed(drv->img_length, drv->reg_base + RMB_PMI_CODE_LENGTH);

 	status = readl_relaxed(drv->reg_base + RMB_MBA_STATUS);
 	if (status < 0) {
 		dev_err(pil->dev, "MBA returned error %d\n", status);
 		return -EINVAL;
 	}

 	return 0;
 }

 static int pil_mba_auth(struct pil_desc *pil)
 {
 	struct mba_data *drv = dev_get_drvdata(pil->dev);
 	int ret;
 	s32 status;

 	/* Wait for all segments to be authenticated or an error to occur */
 	ret = readl_poll_timeout(drv->reg_base + RMB_MBA_STATUS, status,
 			status == STATUS_AUTH_COMPLETE || status < 0,
 			50, AUTH_TIMEOUT_US);
 	if (ret) {
 		dev_err(pil->dev, "MBA authentication timed out\n");
 	} else if (status < 0) {
 		dev_err(pil->dev, "MBA returned error %d\n", status);
 		ret = -EINVAL;
 	}

 	return ret;
 }

 static int pil_mba_shutdown(struct pil_desc *pil)
 {
 	return 0;
 }

 static struct pil_reset_ops pil_mba_ops = {
 	.init_image = pil_mba_init_image,
 	.proxy_vote = pil_mba_make_proxy_votes,
 	.proxy_unvote = pil_mba_remove_proxy_votes,
 	.verify_blob = pil_mba_verify_blob,
 	.auth_and_reset = pil_mba_auth,
 	.shutdown = pil_mba_shutdown,
 };

 static int __devinit pil_mba_driver_probe(struct platform_device *pdev)
 {
 	struct mba_data *drv;
 	struct resource *res;
 	struct pil_desc *desc;
 	int ret;

 	drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);
 	if (!drv)
 		return -ENOMEM;
 	platform_set_drvdata(pdev, drv);

 	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
 	if (!res)
 		return -EINVAL;
 	drv->reg_base = devm_ioremap(&pdev->dev, res->start,
 				     resource_size(res));
 	if (!drv->reg_base)
 		return -ENOMEM;

 	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
 	if (res) {
 		drv->metadata_base = devm_ioremap(&pdev->dev, res->start,
 						  resource_size(res));
 		if (!drv->metadata_base)
 			return -ENOMEM;
 		drv->metadata_phys = res->start;
 	}

 	desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL);
 	if (!drv)
 		return -ENOMEM;

 	ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name",
 				      &desc->name);
 	if (ret)
 		return ret;

 	of_property_read_string(pdev->dev.of_node, "qcom,depends-on",
 				      &desc->depends_on);

 	drv->xo = devm_clk_get(&pdev->dev, "xo");
 	if (IS_ERR(drv->xo))
 		return PTR_ERR(drv->xo);

 	desc->dev = &pdev->dev;
 	desc->ops = &pil_mba_ops;
 	desc->owner = THIS_MODULE;
 	desc->proxy_timeout = PROXY_TIMEOUT_MS;

 	drv->pil = msm_pil_register(desc);
 	if (IS_ERR(drv->pil))
 		return PTR_ERR(drv->pil);

 	return 0;
 }

 static int __devexit pil_mba_driver_exit(struct platform_device *pdev)
 {
 	struct mba_data *drv = platform_get_drvdata(pdev);
 	msm_pil_unregister(drv->pil);
 	return 0;
 }

 static struct of_device_id mba_match_table[] = {
 	{ .compatible = "qcom,pil-mba" },
 	{}
 };

 struct platform_driver pil_mba_driver = {
 	.probe = pil_mba_driver_probe,
 	.remove = __devexit_p(pil_mba_driver_exit),
 	.driver = {
 		.name = "pil-mba",
 		.of_match_table = mba_match_table,
 		.owner = THIS_MODULE,
 	},
 };

 static int __init pil_mba_init(void)
 {
 	return platform_driver_register(&pil_mba_driver);
 }
 module_init(pil_mba_init);

 static void __exit pil_mba_exit(void)
 {
 	platform_driver_unregister(&pil_mba_driver);
 }
 module_exit(pil_mba_exit);

 MODULE_DESCRIPTION("Support for modem boot using the Modem Boot Authenticator");
 MODULE_LICENSE("GPL v2");
	/*
	* Copyright (c) 2012, Code Aurora Forum. All rights reserved.
	*
	* This program is free software; you can redistribute it and/or modify
	* it under the terms of the GNU General Public License version 2 and
	* only version 2 as published by the Free Software Foundation.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	* GNU General Public License for more details.
	*/

	#include <linux/init.h>
	#include <linux/module.h>
	#include <linux/platform_device.h>
	#include <linux/io.h>
	#include <linux/iopoll.h>
	#include <linux/ioport.h>
	#include <linux/elf.h>
	#include <linux/delay.h>
	#include <linux/sched.h>
	#include <linux/clk.h>
	#include <linux/err.h>
	#include <linux/of.h>

	#include "peripheral-loader.h"

	#define RMB_MBA_COMMAND 0x08
	#define RMB_MBA_STATUS 0x0C
	#define RMB_PMI_META_DATA 0x10
	#define RMB_PMI_CODE_START 0x14
	#define RMB_PMI_CODE_LENGTH 0x18

	#define CMD_META_DATA_READY 0x1
	#define CMD_LOAD_READY 0x2

	#define STATUS_META_DATA_AUTH_SUCCESS 0x3
	#define STATUS_AUTH_COMPLETE 0x4

	#define AUTH_TIMEOUT_US 10000000
	#define PROXY_TIMEOUT_MS 10000
	#define POLL_INTERVAL_US 50

	struct mba_data {
	void __iomem *reg_base;
	void __iomem *metadata_base;
	unsigned long metadata_phys;
	struct pil_device *pil;
	struct clk *xo;
	u32 img_length;
	};

	static int pil_mba_make_proxy_votes(struct pil_desc *pil)
	{
	int ret;
	struct mba_data *drv = dev_get_drvdata(pil->dev);

	ret = clk_prepare_enable(drv->xo);
	if (ret) {
	dev_err(pil->dev, "Failed to enable XO\n");
	return ret;
	}
	return 0;
	}

	static void pil_mba_remove_proxy_votes(struct pil_desc *pil)
	{
	struct mba_data *drv = dev_get_drvdata(pil->dev);
	clk_disable_unprepare(drv->xo);
	}

	static int pil_mba_init_image(struct pil_desc *pil,
	const u8 *metadata, size_t size)
	{
	struct mba_data *drv = dev_get_drvdata(pil->dev);
	s32 status;
	int ret;

	/* Copy metadata to assigned shared buffer location */
	memcpy(drv->metadata_base, metadata, size);

	/* Initialize length counter to 0 */
	writel_relaxed(0, drv->reg_base + RMB_PMI_CODE_LENGTH);
	drv->img_length = 0;

	/* Pass address of meta-data to the MBA and perform authentication */
	writel_relaxed(drv->metadata_phys, drv->reg_base + RMB_PMI_META_DATA);
	writel_relaxed(CMD_META_DATA_READY, drv->reg_base + RMB_MBA_COMMAND);
	ret = readl_poll_timeout(drv->reg_base + RMB_MBA_STATUS, status,
	status == STATUS_META_DATA_AUTH_SUCCESS \|\| status < 0,
	POLL_INTERVAL_US, AUTH_TIMEOUT_US);
	if (ret) {
	dev_err(pil->dev, "MBA authentication timed out\n");
	} else if (status < 0) {
	dev_err(pil->dev, "MBA returned error %d\n", status);
	ret = -EINVAL;
	}

	return ret;
	}

	static int pil_mba_verify_blob(struct pil_desc *pil, u32 phy_addr,
	size_t size)
	{
	struct mba_data *drv = dev_get_drvdata(pil->dev);
	s32 status;

	/* Begin image authentication */
	if (drv->img_length == 0) {
	writel_relaxed(phy_addr, drv->reg_base + RMB_PMI_CODE_START);
	writel_relaxed(CMD_LOAD_READY, drv->reg_base + RMB_MBA_COMMAND);
	}
	/* Increment length counter */
	drv->img_length += size;
	writel_relaxed(drv->img_length, drv->reg_base + RMB_PMI_CODE_LENGTH);

	status = readl_relaxed(drv->reg_base + RMB_MBA_STATUS);
	if (status < 0) {
	dev_err(pil->dev, "MBA returned error %d\n", status);
	return -EINVAL;
	}

	return 0;
	}

	static int pil_mba_auth(struct pil_desc *pil)
	{
	struct mba_data *drv = dev_get_drvdata(pil->dev);
	int ret;
	s32 status;

	/* Wait for all segments to be authenticated or an error to occur */
	ret = readl_poll_timeout(drv->reg_base + RMB_MBA_STATUS, status,
	status == STATUS_AUTH_COMPLETE \|\| status < 0,
	50, AUTH_TIMEOUT_US);
	if (ret) {
	dev_err(pil->dev, "MBA authentication timed out\n");
	} else if (status < 0) {
	dev_err(pil->dev, "MBA returned error %d\n", status);
	ret = -EINVAL;
	}

	return ret;
	}

	static int pil_mba_shutdown(struct pil_desc *pil)
	{
	return 0;
	}

	static struct pil_reset_ops pil_mba_ops = {
	.init_image = pil_mba_init_image,
	.proxy_vote = pil_mba_make_proxy_votes,
	.proxy_unvote = pil_mba_remove_proxy_votes,
	.verify_blob = pil_mba_verify_blob,
	.auth_and_reset = pil_mba_auth,
	.shutdown = pil_mba_shutdown,
	};

	static int __devinit pil_mba_driver_probe(struct platform_device *pdev)
	{
	struct mba_data *drv;
	struct resource *res;
	struct pil_desc *desc;
	int ret;

	drv = devm_kzalloc(&pdev->dev, sizeof(*drv), GFP_KERNEL);
	if (!drv)
	return -ENOMEM;
	platform_set_drvdata(pdev, drv);

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (!res)
	return -EINVAL;
	drv->reg_base = devm_ioremap(&pdev->dev, res->start,
	resource_size(res));
	if (!drv->reg_base)
	return -ENOMEM;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 1);
	if (res) {
	drv->metadata_base = devm_ioremap(&pdev->dev, res->start,
	resource_size(res));
	if (!drv->metadata_base)
	return -ENOMEM;
	drv->metadata_phys = res->start;
	}

	desc = devm_kzalloc(&pdev->dev, sizeof(*desc), GFP_KERNEL);
	if (!drv)
	return -ENOMEM;

	ret = of_property_read_string(pdev->dev.of_node, "qcom,firmware-name",
	&desc->name);
	if (ret)
	return ret;

	of_property_read_string(pdev->dev.of_node, "qcom,depends-on",
	&desc->depends_on);

	drv->xo = devm_clk_get(&pdev->dev, "xo");
	if (IS_ERR(drv->xo))
	return PTR_ERR(drv->xo);

	desc->dev = &pdev->dev;
	desc->ops = &pil_mba_ops;
	desc->owner = THIS_MODULE;
	desc->proxy_timeout = PROXY_TIMEOUT_MS;

	drv->pil = msm_pil_register(desc);
	if (IS_ERR(drv->pil))
	return PTR_ERR(drv->pil);

	return 0;
	}

	static int __devexit pil_mba_driver_exit(struct platform_device *pdev)
	{
	struct mba_data *drv = platform_get_drvdata(pdev);
	msm_pil_unregister(drv->pil);
	return 0;
	}

	static struct of_device_id mba_match_table[] = {
	{ .compatible = "qcom,pil-mba" },
	{}
	};

	struct platform_driver pil_mba_driver = {
	.probe = pil_mba_driver_probe,
	.remove = __devexit_p(pil_mba_driver_exit),
	.driver = {
	.name = "pil-mba",
	.of_match_table = mba_match_table,
	.owner = THIS_MODULE,
	},
	};

	static int __init pil_mba_init(void)
	{
	return platform_driver_register(&pil_mba_driver);
	}
	module_init(pil_mba_init);

	static void __exit pil_mba_exit(void)
	{
	platform_driver_unregister(&pil_mba_driver);
	}
	module_exit(pil_mba_exit);

	MODULE_DESCRIPTION("Support for modem boot using the Modem Boot Authenticator");
	MODULE_LICENSE("GPL v2");