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

Commit 051fb70f authored by Bjorn Andersson's avatar Bjorn Andersson Committed by Bjorn Andersson
Browse files

remoteproc: qcom: Driver for the self-authenticating Hexagon v5 



This driver supports bringing the Q6V5 out of reset, load and drive
the self-authenticating boot loader and use this to load the mdt and
subsequent bXX files.

Signed-off-by: default avatarBjorn Andersson <bjorn.andersson@sonymobile.com>
Acked-by: default avatarSrinivas Kandagatla <srinivas.kandagatla@linaro.org>
Signed-off-by: default avatarBjorn Andersson <bjorn.andersson@linaro.org>
parent 3b76df4b

drivers/remoteproc/Kconfig

+14 −0
Original line number Diff line number Diff line
@@ -77,6 +77,20 @@ config DA8XX_REMOTEPROC 
	  It's safe to say n here if you're not interested in multimedia

	  offloading.



config QCOM_MDT_LOADER

	tristate



config QCOM_Q6V5_PIL

	tristate "Qualcomm Hexagon V5 Peripherial Image Loader"

	depends on OF && ARCH_QCOM

	depends on QCOM_SMEM

	select MFD_SYSCON

	select QCOM_MDT_LOADER

	select REMOTEPROC

	help

	  Say y here to support the Qualcomm Peripherial Image Loader for the

	  Hexagon V5 based remote processors.



config ST_REMOTEPROC

	tristate "ST remoteproc support"

	depends on ARCH_STI

drivers/remoteproc/Makefile

+2 −0
Original line number Diff line number Diff line
@@ -11,4 +11,6 @@ obj-$(CONFIG_OMAP_REMOTEPROC) += omap_remoteproc.o 
obj-$(CONFIG_STE_MODEM_RPROC)	 	+= ste_modem_rproc.o

obj-$(CONFIG_WKUP_M3_RPROC)		+= wkup_m3_rproc.o

obj-$(CONFIG_DA8XX_REMOTEPROC)		+= da8xx_remoteproc.o

obj-$(CONFIG_QCOM_MDT_LOADER)		+= qcom_mdt_loader.o

obj-$(CONFIG_QCOM_Q6V5_PIL)		+= qcom_q6v5_pil.o

obj-$(CONFIG_ST_REMOTEPROC)		+= st_remoteproc.o

drivers/remoteproc/qcom_mdt_loader.c

0 → 100644
+179 −0
Original line number Diff line number Diff line 
/*

 * Qualcomm Peripheral Image Loader

 *

 * Copyright (C) 2016 Linaro Ltd

 * Copyright (C) 2015 Sony Mobile Communications Inc

 * Copyright (c) 2012-2013, The Linux Foundation. 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 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/elf.h>

#include <linux/firmware.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/remoteproc.h>

#include <linux/slab.h>



#include "remoteproc_internal.h"

#include "qcom_mdt_loader.h"



/**

 * qcom_mdt_find_rsc_table() - provide dummy resource table for remoteproc

 * @rproc:	remoteproc handle

 * @fw:		firmware header

 * @tablesz:	outgoing size of the table

 *

 * Returns a dummy table.

 */

struct resource_table *qcom_mdt_find_rsc_table(struct rproc *rproc,

					       const struct firmware *fw,

					       int *tablesz)

{

	static struct resource_table table = { .ver = 1, };



	*tablesz = sizeof(table);

	return &table;

}

EXPORT_SYMBOL_GPL(qcom_mdt_find_rsc_table);



/**

 * qcom_mdt_parse() - extract useful parameters from the mdt header

 * @fw:		firmware handle

 * @fw_addr:	optional reference for base of the firmware's memory region

 * @fw_size:	optional reference for size of the firmware's memory region

 * @fw_relocate: optional reference for flagging if the firmware is relocatable

 *

 * Returns 0 on success, negative errno otherwise.

 */

int qcom_mdt_parse(const struct firmware *fw, phys_addr_t *fw_addr,

		   size_t *fw_size, bool *fw_relocate)

{

	const struct elf32_phdr *phdrs;

	const struct elf32_phdr *phdr;

	const struct elf32_hdr *ehdr;

	phys_addr_t min_addr = (phys_addr_t)ULLONG_MAX;

	phys_addr_t max_addr = 0;

	bool relocate = false;

	int i;



	ehdr = (struct elf32_hdr *)fw->data;

	phdrs = (struct elf32_phdr *)(ehdr + 1);



	for (i = 0; i < ehdr->e_phnum; i++) {

		phdr = &phdrs[i];



		if (phdr->p_type != PT_LOAD)

			continue;



		if ((phdr->p_flags & QCOM_MDT_TYPE_MASK) == QCOM_MDT_TYPE_HASH)

			continue;



		if (!phdr->p_memsz)

			continue;



		if (phdr->p_flags & QCOM_MDT_RELOCATABLE)

			relocate = true;



		if (phdr->p_paddr < min_addr)

			min_addr = phdr->p_paddr;



		if (phdr->p_paddr + phdr->p_memsz > max_addr)

			max_addr = ALIGN(phdr->p_paddr + phdr->p_memsz, SZ_4K);

	}



	if (fw_addr)

		*fw_addr = min_addr;

	if (fw_size)

		*fw_size = max_addr - min_addr;

	if (fw_relocate)

		*fw_relocate = relocate;



	return 0;

}

EXPORT_SYMBOL_GPL(qcom_mdt_parse);



/**

 * qcom_mdt_load() - load the firmware which header is defined in fw

 * @rproc:	rproc handle

 * @fw:		frimware object for the header

 * @firmware:	filename of the firmware, for building .bXX names

 *

 * Returns 0 on success, negative errno otherwise.

 */

int qcom_mdt_load(struct rproc *rproc,

		  const struct firmware *fw,

		  const char *firmware)

{

	const struct elf32_phdr *phdrs;

	const struct elf32_phdr *phdr;

	const struct elf32_hdr *ehdr;

	size_t fw_name_len;

	char *fw_name;

	void *ptr;

	int ret;

	int i;



	ehdr = (struct elf32_hdr *)fw->data;

	phdrs = (struct elf32_phdr *)(ehdr + 1);



	fw_name_len = strlen(firmware);

	if (fw_name_len <= 4)

		return -EINVAL;



	fw_name = kstrdup(firmware, GFP_KERNEL);

	if (!fw_name)

		return -ENOMEM;



	for (i = 0; i < ehdr->e_phnum; i++) {

		phdr = &phdrs[i];



		if (phdr->p_type != PT_LOAD)

			continue;



		if ((phdr->p_flags & QCOM_MDT_TYPE_MASK) == QCOM_MDT_TYPE_HASH)

			continue;



		if (!phdr->p_memsz)

			continue;



		ptr = rproc_da_to_va(rproc, phdr->p_paddr, phdr->p_memsz);

		if (!ptr) {

			dev_err(&rproc->dev, "segment outside memory range\n");

			ret = -EINVAL;

			break;

		}



		if (phdr->p_filesz) {

			sprintf(fw_name + fw_name_len - 3, "b%02d", i);

			ret = request_firmware(&fw, fw_name, &rproc->dev);

			if (ret) {

				dev_err(&rproc->dev, "failed to load %s\n",

					fw_name);

				break;

			}



			memcpy(ptr, fw->data, fw->size);



			release_firmware(fw);

		}



		if (phdr->p_memsz > phdr->p_filesz)

			memset(ptr + phdr->p_filesz, 0, phdr->p_memsz - phdr->p_filesz);

	}



	kfree(fw_name);



	return ret;

}

EXPORT_SYMBOL_GPL(qcom_mdt_load);



MODULE_DESCRIPTION("Firmware parser for Qualcomm MDT format");

MODULE_LICENSE("GPL v2");

drivers/remoteproc/qcom_mdt_loader.h

0 → 100644
+13 −0
Original line number Diff line number Diff line 
#ifndef __QCOM_MDT_LOADER_H__

#define __QCOM_MDT_LOADER_H__



#define QCOM_MDT_TYPE_MASK	(7 << 24)

#define QCOM_MDT_TYPE_HASH	(2 << 24)

#define QCOM_MDT_RELOCATABLE	BIT(27)



struct resource_table * qcom_mdt_find_rsc_table(struct rproc *rproc, const struct firmware *fw, int *tablesz);

int qcom_mdt_load(struct rproc *rproc, const struct firmware *fw, const char *fw_name);



int qcom_mdt_parse(const struct firmware *fw, phys_addr_t *fw_addr, size_t *fw_size, bool *fw_relocate);



#endif