Commit 16e59467 authored by Andy Gross's avatar Andy Gross
Browse files

firmware: qcom: scm: Convert to streaming DMA APIS 



This patch converts the Qualcomm SCM driver to use the streaming DMA APIs
for communication buffers.  This is being done so that the
secure_flush_area call can be removed.  Using the DMA APIs will also make
the SCM32 symmetric to the coming SCM64 code.

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

drivers/firmware/qcom_scm-32.c

+44 −99
Original line number Diff line number Diff line
@@ -23,8 +23,7 @@ 
#include <linux/errno.h>

#include <linux/err.h>

#include <linux/qcom_scm.h>



#include <asm/cacheflush.h>

#include <linux/dma-mapping.h>



#include "qcom_scm.h"
@@ -96,44 +95,6 @@ struct qcom_scm_response { 
	__le32 is_complete;

};



/**

 * alloc_qcom_scm_command() - Allocate an SCM command

 * @cmd_size: size of the command buffer

 * @resp_size: size of the response buffer

 *

 * Allocate an SCM command, including enough room for the command

 * and response headers as well as the command and response buffers.

 *

 * Returns a valid &qcom_scm_command on success or %NULL if the allocation fails.

 */

static struct qcom_scm_command *alloc_qcom_scm_command(size_t cmd_size, size_t resp_size)

{

	struct qcom_scm_command *cmd;

	size_t len = sizeof(*cmd) + sizeof(struct qcom_scm_response) + cmd_size +

		resp_size;

	u32 offset;



	cmd = kzalloc(PAGE_ALIGN(len), GFP_KERNEL);

	if (cmd) {

		cmd->len = cpu_to_le32(len);

		offset = offsetof(struct qcom_scm_command, buf);

		cmd->buf_offset = cpu_to_le32(offset);

		cmd->resp_hdr_offset = cpu_to_le32(offset + cmd_size);

	}

	return cmd;

}



/**

 * free_qcom_scm_command() - Free an SCM command

 * @cmd: command to free

 *

 * Free an SCM command.

 */

static inline void free_qcom_scm_command(struct qcom_scm_command *cmd)

{

	kfree(cmd);

}



/**

 * qcom_scm_command_to_response() - Get a pointer to a qcom_scm_response

 * @cmd: command
@@ -192,45 +153,9 @@ static u32 smc(u32 cmd_addr) 
	return r0;

}



static int __qcom_scm_call(const struct qcom_scm_command *cmd)

{

	int ret;

	u32 cmd_addr = virt_to_phys(cmd);



	/*

	 * Flush the command buffer so that the secure world sees

	 * the correct data.

	 */

	secure_flush_area(cmd, cmd->len);



	ret = smc(cmd_addr);

	if (ret < 0)

		ret = qcom_scm_remap_error(ret);



	return ret;

}



static void qcom_scm_inv_range(unsigned long start, unsigned long end)

{

	u32 cacheline_size, ctr;



	asm volatile("mrc p15, 0, %0, c0, c0, 1" : "=r" (ctr));

	cacheline_size = 4 << ((ctr >> 16) & 0xf);



	start = round_down(start, cacheline_size);

	end = round_up(end, cacheline_size);

	outer_inv_range(start, end);

	while (start < end) {

		asm ("mcr p15, 0, %0, c7, c6, 1" : : "r" (start)

		     : "memory");

		start += cacheline_size;

	}

	dsb();

	isb();

}



/**

 * qcom_scm_call() - Send an SCM command

 * @dev: struct device

 * @svc_id: service identifier

 * @cmd_id: command identifier

 * @cmd_buf: command buffer
@@ -247,42 +172,59 @@ static void qcom_scm_inv_range(unsigned long start, unsigned long end) 
 * and response buffers is taken care of by qcom_scm_call; however, callers are

 * responsible for any other cached buffers passed over to the secure world.

 */

static int qcom_scm_call(u32 svc_id, u32 cmd_id, const void *cmd_buf,

			size_t cmd_len, void *resp_buf, size_t resp_len)

static int qcom_scm_call(struct device *dev, u32 svc_id, u32 cmd_id,

			 const void *cmd_buf, size_t cmd_len, void *resp_buf,

			 size_t resp_len)

{

	int ret;

	struct qcom_scm_command *cmd;

	struct qcom_scm_response *rsp;

	unsigned long start, end;

	size_t alloc_len = sizeof(*cmd) + cmd_len + sizeof(*rsp) + resp_len;

	dma_addr_t cmd_phys;



	cmd = alloc_qcom_scm_command(cmd_len, resp_len);

	cmd = kzalloc(PAGE_ALIGN(alloc_len), GFP_KERNEL);

	if (!cmd)

		return -ENOMEM;



	cmd->len = cpu_to_le32(alloc_len);

	cmd->buf_offset = cpu_to_le32(sizeof(*cmd));

	cmd->resp_hdr_offset = cpu_to_le32(sizeof(*cmd) + cmd_len);



	cmd->id = cpu_to_le32((svc_id << 10) | cmd_id);

	if (cmd_buf)

		memcpy(qcom_scm_get_command_buffer(cmd), cmd_buf, cmd_len);



	rsp = qcom_scm_command_to_response(cmd);



	cmd_phys = dma_map_single(dev, cmd, alloc_len, DMA_TO_DEVICE);

	if (dma_mapping_error(dev, cmd_phys)) {

		kfree(cmd);

		return -ENOMEM;

	}



	mutex_lock(&qcom_scm_lock);

	ret = __qcom_scm_call(cmd);

	ret = smc(cmd_phys);

	if (ret < 0)

		ret = qcom_scm_remap_error(ret);

	mutex_unlock(&qcom_scm_lock);

	if (ret)

		goto out;



	rsp = qcom_scm_command_to_response(cmd);

	start = (unsigned long)rsp;



	do {

		qcom_scm_inv_range(start, start + sizeof(*rsp));

		dma_sync_single_for_cpu(dev, cmd_phys + sizeof(*cmd) + cmd_len,

					sizeof(*rsp), DMA_FROM_DEVICE);

	} while (!rsp->is_complete);



	end = (unsigned long)qcom_scm_get_response_buffer(rsp) + resp_len;

	qcom_scm_inv_range(start, end);



	if (resp_buf)

		memcpy(resp_buf, qcom_scm_get_response_buffer(rsp), resp_len);

	if (resp_buf) {

		dma_sync_single_for_cpu(dev, cmd_phys + sizeof(*cmd) + cmd_len +

					le32_to_cpu(rsp->buf_offset),

					resp_len, DMA_FROM_DEVICE);

		memcpy(resp_buf, qcom_scm_get_response_buffer(rsp),

		       resp_len);

	}

out:

	free_qcom_scm_command(cmd);

	dma_unmap_single(dev, cmd_phys, alloc_len, DMA_TO_DEVICE);

	kfree(cmd);

	return ret;

}
@@ -437,7 +379,8 @@ int __qcom_scm_set_cold_boot_addr(void *entry, const cpumask_t *cpus) 
 * Set the Linux entry point for the SCM to transfer control to when coming

 * out of a power down. CPU power down may be executed on cpuidle or hotplug.

 */

int __qcom_scm_set_warm_boot_addr(void *entry, const cpumask_t *cpus)

int __qcom_scm_set_warm_boot_addr(struct device *dev, void *entry,

				  const cpumask_t *cpus)

{

	int ret;

	int flags = 0;
@@ -463,7 +406,7 @@ int __qcom_scm_set_warm_boot_addr(void *entry, const cpumask_t *cpus) 


	cmd.addr = cpu_to_le32(virt_to_phys(entry));

	cmd.flags = cpu_to_le32(flags);

	ret = qcom_scm_call(QCOM_SCM_SVC_BOOT, QCOM_SCM_BOOT_ADDR,

	ret = qcom_scm_call(dev, QCOM_SCM_SVC_BOOT, QCOM_SCM_BOOT_ADDR,

			    &cmd, sizeof(cmd), NULL, 0);

	if (!ret) {

		for_each_cpu(cpu, cpus)
@@ -487,25 +430,27 @@ void __qcom_scm_cpu_power_down(u32 flags) 
			flags & QCOM_SCM_FLUSH_FLAG_MASK);

}



int __qcom_scm_is_call_available(u32 svc_id, u32 cmd_id)

int __qcom_scm_is_call_available(struct device *dev, u32 svc_id, u32 cmd_id)

{

	int ret;

	__le32 svc_cmd = cpu_to_le32((svc_id << 10) | cmd_id);

	__le32 ret_val = 0;



	ret = qcom_scm_call(QCOM_SCM_SVC_INFO, QCOM_IS_CALL_AVAIL_CMD, &svc_cmd,

			sizeof(svc_cmd), &ret_val, sizeof(ret_val));

	ret = qcom_scm_call(dev, QCOM_SCM_SVC_INFO, QCOM_IS_CALL_AVAIL_CMD,

			    &svc_cmd, sizeof(svc_cmd), &ret_val,

			    sizeof(ret_val));

	if (ret)

		return ret;



	return le32_to_cpu(ret_val);

}



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

int __qcom_scm_hdcp_req(struct device *dev, struct qcom_scm_hdcp_req *req,

			u32 req_cnt, u32 *resp)

{

	if (req_cnt > QCOM_SCM_HDCP_MAX_REQ_CNT)

		return -ERANGE;



	return qcom_scm_call(QCOM_SCM_SVC_HDCP, QCOM_SCM_CMD_HDCP,

	return qcom_scm_call(dev, QCOM_SCM_SVC_HDCP, QCOM_SCM_CMD_HDCP,

		req, req_cnt * sizeof(*req), resp, sizeof(*resp));

}

drivers/firmware/qcom_scm.c

+3 −3
Original line number Diff line number Diff line
@@ -89,7 +89,7 @@ EXPORT_SYMBOL(qcom_scm_set_cold_boot_addr); 
 */

int qcom_scm_set_warm_boot_addr(void *entry, const cpumask_t *cpus)

{

	return __qcom_scm_set_warm_boot_addr(entry, cpus);

	return __qcom_scm_set_warm_boot_addr(__scm->dev, entry, cpus);

}

EXPORT_SYMBOL(qcom_scm_set_warm_boot_addr);
@@ -119,7 +119,7 @@ bool qcom_scm_hdcp_available(void) 
	if (ret)

		return ret;



	ret = __qcom_scm_is_call_available(QCOM_SCM_SVC_HDCP,

	ret = __qcom_scm_is_call_available(__scm->dev, QCOM_SCM_SVC_HDCP,

						QCOM_SCM_CMD_HDCP);



	qcom_scm_clk_disable();
@@ -143,7 +143,7 @@ int qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt, u32 *resp) 
	if (ret)

		return ret;



	ret = __qcom_scm_hdcp_req(req, req_cnt, resp);

	ret = __qcom_scm_hdcp_req(__scm->dev, req, req_cnt, resp);

	qcom_scm_clk_disable();

	return ret;

}

drivers/firmware/qcom_scm.h

+6 −4
Original line number Diff line number Diff line
@@ -19,7 +19,8 @@ 
#define QCOM_SCM_FLAG_HLOS		0x01

#define QCOM_SCM_FLAG_COLDBOOT_MC	0x02

#define QCOM_SCM_FLAG_WARMBOOT_MC	0x04

extern int __qcom_scm_set_warm_boot_addr(void *entry, const cpumask_t *cpus);

extern int __qcom_scm_set_warm_boot_addr(struct device *dev, void *entry,

		const cpumask_t *cpus);

extern int __qcom_scm_set_cold_boot_addr(void *entry, const cpumask_t *cpus);



#define QCOM_SCM_CMD_TERMINATE_PC	0x2
@@ -29,12 +30,13 @@ extern void __qcom_scm_cpu_power_down(u32 flags); 


#define QCOM_SCM_SVC_INFO		0x6

#define QCOM_IS_CALL_AVAIL_CMD		0x1

extern int __qcom_scm_is_call_available(u32 svc_id, u32 cmd_id);

extern int __qcom_scm_is_call_available(struct device *dev, u32 svc_id,

		u32 cmd_id);



#define QCOM_SCM_SVC_HDCP		0x11

#define QCOM_SCM_CMD_HDCP		0x01

extern int __qcom_scm_hdcp_req(struct qcom_scm_hdcp_req *req, u32 req_cnt,

		u32 *resp);

extern int __qcom_scm_hdcp_req(struct device *dev,

		struct qcom_scm_hdcp_req *req, u32 req_cnt, u32 *resp);



/* common error codes */

#define QCOM_SCM_ENOMEM		-5

CRA Git | Maintained and supported by SUSTech CRA and CCSE