drivers/gud/mobicore_driver/ops.c - fp2-dev/kernel/msm - Gitiles

 /*
  * MobiCore Driver Kernel Module.
  *
  * This module is written as a Linux device driver.
  * This driver represents the command proxy on the lowest layer, from the
  * secure world to the non secure world, and vice versa.
  * This driver is located in the non secure world (Linux).
  * This driver offers IOCTL commands, for access to the secure world, and has
  * the interface from the secure world to the normal world.
  * The access to the driver is possible with a file descriptor,
  * which has to be created by the fd = open(/dev/mobicore) command.
  *
  * <-- Copyright Giesecke & Devrient GmbH 2009-2012 -->
  * <-- Copyright Trustonic Limited 2013 -->
  *
  * 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.
  */

 #include <linux/kthread.h>
 #include <linux/module.h>
 #include <linux/device.h>
 #include <linux/workqueue.h>
 #include <linux/cpu.h>

 #include "main.h"
 #include "fastcall.h"
 #include "ops.h"
 #include "mem.h"
 #include "pm.h"
 #include "debug.h"

 /* MobiCore context data */
 static struct mc_context *ctx;

 static inline long smc(union fc_generic *fc)
 {
 	/* If we request sleep yields must be filtered out as they
 	 * make no sense */
 	if (ctx->mcp)
 		if (ctx->mcp->flags.sleep_mode.SleepReq) {
 			if (fc->as_in.cmd == MC_SMC_N_YIELD)
 				return MC_FC_RET_ERR_INVALID;
 		}
 	return _smc(fc);
 }

 #ifdef MC_FASTCALL_WORKER_THREAD

 static struct task_struct *fastcall_thread;
 static DEFINE_KTHREAD_WORKER(fastcall_worker);

 struct fastcall_work {
 	struct kthread_work work;
 	void *data;
 };

 static void fastcall_work_func(struct kthread_work *work)
 {
 	struct fastcall_work *fc_work =
 		container_of(work, struct fastcall_work, work);

 #ifdef MC_CRYPTO_CLOCK_MANAGEMENT
 	mc_pm_clock_enable();
 #endif

 	smc(fc_work->data);

 #ifdef MC_CRYPTO_CLOCK_MANAGEMENT
 	mc_pm_clock_disable();
 #endif
 }

 void mc_fastcall(void *data)
 {
 	struct fastcall_work fc_work = {
 		KTHREAD_WORK_INIT(fc_work.work, fastcall_work_func),
 		.data = data,
 	};

 	queue_kthread_work(&fastcall_worker, &fc_work.work);
 	flush_kthread_work(&fc_work.work);
 }

 int mc_fastcall_init(struct mc_context *context)
 {
 	int ret = 0;

 	ctx = context;

 	fastcall_thread = kthread_create(kthread_worker_fn, &fastcall_worker,
 					 "mc_fastcall");
 	if (IS_ERR(fastcall_thread)) {
 		ret = PTR_ERR(fastcall_thread);
 		fastcall_thread = NULL;
 		MCDRV_DBG_ERROR(mcd, "cannot create fastcall wq (%d)\n", ret);
 		return ret;
 	}

 	/* this thread MUST run on CPU 0 */
 	kthread_bind(fastcall_thread, 0);
 	wake_up_process(fastcall_thread);

 	return 0;
 }

 void mc_fastcall_destroy(void)
 {
 	if (!IS_ERR_OR_NULL(fastcall_thread)) {
 		kthread_stop(fastcall_thread);
 		fastcall_thread = NULL;
 	}
 }
 #else

 struct fastcall_work_struct {
 	struct work_struct work;
 	void *data;
 };

 static void fastcall_work_func(struct work_struct *work)
 {
 	struct fastcall_work_struct *fc_work =
 		container_of(work, struct fastcall_work_struct, work);

 #ifdef MC_CRYPTO_CLOCK_MANAGEMENT
 	mc_pm_clock_enable();
 #endif

 	smc(fc_work->data);

 #ifdef MC_CRYPTO_CLOCK_MANAGEMENT
 	mc_pm_clock_disable();
 #endif
 }

 void mc_fastcall(void *data)
 {
 	struct fastcall_work_struct work = {
 		.data = data,
 	};
 	INIT_WORK(&work.work, fastcall_work_func);
 	schedule_work_on(0, &work.work);

 	flush_work(&work.work);
 }

 int mc_fastcall_init(struct mc_context *context)
 {
 	ctx = context;
 	return 0;
 };

 void mc_fastcall_destroy(void) {};
 #endif

 int mc_info(uint32_t ext_info_id, uint32_t *state, uint32_t *ext_info)
 {
 	int ret = 0;
 	union mc_fc_info fc_info;

 	MCDRV_DBG_VERBOSE(mcd, "enter\n");

 	memset(&fc_info, 0, sizeof(fc_info));
 	fc_info.as_in.cmd = MC_FC_INFO;
 	fc_info.as_in.ext_info_id = ext_info_id;

 	MCDRV_DBG(mcd, "fc_info <- cmd=0x%08x, ext_info_id=0x%08x\n",
 		  fc_info.as_in.cmd, fc_info.as_in.ext_info_id);

 	mc_fastcall(&(fc_info.as_generic));

 	MCDRV_DBG(mcd,
 		  "fc_info -> r=0x%08x ret=0x%08x state=0x%08x ext_info=0x%08x",
 		  fc_info.as_out.resp,
 		  fc_info.as_out.ret,
 		  fc_info.as_out.state,
 		  fc_info.as_out.ext_info);

 	ret = convert_fc_ret(fc_info.as_out.ret);

 	*state  = fc_info.as_out.state;
 	*ext_info = fc_info.as_out.ext_info;

 	MCDRV_DBG_VERBOSE(mcd, "exit with %d/0x%08X\n", ret, ret);

 	return ret;
 }

 /* Yield to MobiCore */
 int mc_yield(void)
 {
 	int ret = 0;
 	union fc_generic yield;

 	MCDRV_DBG_VERBOSE(mcd, "enter\n");

 	memset(&yield, 0, sizeof(yield));
 	yield.as_in.cmd = MC_SMC_N_YIELD;
 	mc_fastcall(&yield);
 	ret = convert_fc_ret(yield.as_out.ret);

 	return ret;
 }

 /* call common notify */
 int mc_nsiq(void)
 {
 	int ret = 0;
 	union fc_generic nsiq;
 	MCDRV_DBG_VERBOSE(mcd, "enter\n");

 	memset(&nsiq, 0, sizeof(nsiq));
 	nsiq.as_in.cmd = MC_SMC_N_SIQ;
 	mc_fastcall(&nsiq);
 	ret = convert_fc_ret(nsiq.as_out.ret);

 	return ret;
 }

 /* call common notify */
 int _nsiq(void)
 {
 	int ret = 0;
 	union fc_generic nsiq;
 	MCDRV_DBG_VERBOSE(mcd, "enter\n");

 	memset(&nsiq, 0, sizeof(nsiq));
 	nsiq.as_in.cmd = MC_SMC_N_SIQ;
 	_smc(&nsiq);
 	ret = convert_fc_ret(nsiq.as_out.ret);

 	return ret;
 }

 /* Call the INIT fastcall to setup MobiCore initialization */
 int mc_init(uint32_t base, uint32_t nq_offset, uint32_t nq_length,
 	uint32_t mcp_offset, uint32_t mcp_length)
 {
 	int ret = 0;
 	union mc_fc_init fc_init;

 	MCDRV_DBG_VERBOSE(mcd, "enter\n");

 	memset(&fc_init, 0, sizeof(fc_init));

 	fc_init.as_in.cmd = MC_FC_INIT;
 	/* base address of mci buffer 4KB aligned */
 	fc_init.as_in.base = base;
 	/* notification buffer start/length [16:16] [start, length] */
 	fc_init.as_in.nq_info = (nq_offset << 16) | (nq_length & 0xFFFF);
 	/* mcp buffer start/length [16:16] [start, length] */
 	fc_init.as_in.mcp_info = (mcp_offset << 16) | (mcp_length & 0xFFFF);

 	/*
 	 * Set KMOD notification queue to start of MCI
 	 * mciInfo was already set up in mmap
 	 */
 	MCDRV_DBG(mcd,
 		  "cmd=0x%08x, base=0x%08x,nq_info=0x%08x, mcp_info=0x%08x\n",
 		  fc_init.as_in.cmd, fc_init.as_in.base, fc_init.as_in.nq_info,
 		  fc_init.as_in.mcp_info);

 	mc_fastcall(&fc_init.as_generic);

 	MCDRV_DBG(mcd, "out cmd=0x%08x, ret=0x%08x\n", fc_init.as_out.resp,
 		  fc_init.as_out.ret);

 	ret = convert_fc_ret(fc_init.as_out.ret);

 	MCDRV_DBG_VERBOSE(mcd, "exit with %d/0x%08X\n", ret, ret);

 	return ret;
 }

 /* Return MobiCore driver version */
 uint32_t mc_get_version(void)
 {
 	MCDRV_DBG(mcd, "MobiCore driver version is %i.%i\n",
 		  MCDRVMODULEAPI_VERSION_MAJOR,
 		  MCDRVMODULEAPI_VERSION_MINOR);

 	return MC_VERSION(MCDRVMODULEAPI_VERSION_MAJOR,
 					MCDRVMODULEAPI_VERSION_MINOR);
 }
	/*
	* MobiCore Driver Kernel Module.
	*
	* This module is written as a Linux device driver.
	* This driver represents the command proxy on the lowest layer, from the
	* secure world to the non secure world, and vice versa.
	* This driver is located in the non secure world (Linux).
	* This driver offers IOCTL commands, for access to the secure world, and has
	* the interface from the secure world to the normal world.
	* The access to the driver is possible with a file descriptor,
	* which has to be created by the fd = open(/dev/mobicore) command.
	*
	* <-- Copyright Giesecke & Devrient GmbH 2009-2012 -->
	* <-- Copyright Trustonic Limited 2013 -->
	*
	* 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.
	*/

	#include <linux/kthread.h>
	#include <linux/module.h>
	#include <linux/device.h>
	#include <linux/workqueue.h>
	#include <linux/cpu.h>

	#include "main.h"
	#include "fastcall.h"
	#include "ops.h"
	#include "mem.h"
	#include "pm.h"
	#include "debug.h"

	/* MobiCore context data */
	static struct mc_context *ctx;

	static inline long smc(union fc_generic *fc)
	{
	/* If we request sleep yields must be filtered out as they
	* make no sense */
	if (ctx->mcp)
	if (ctx->mcp->flags.sleep_mode.SleepReq) {
	if (fc->as_in.cmd == MC_SMC_N_YIELD)
	return MC_FC_RET_ERR_INVALID;
	}
	return _smc(fc);
	}

	#ifdef MC_FASTCALL_WORKER_THREAD

	static struct task_struct *fastcall_thread;
	static DEFINE_KTHREAD_WORKER(fastcall_worker);

	struct fastcall_work {
	struct kthread_work work;
	void *data;
	};

	static void fastcall_work_func(struct kthread_work *work)
	{
	struct fastcall_work *fc_work =
	container_of(work, struct fastcall_work, work);

	#ifdef MC_CRYPTO_CLOCK_MANAGEMENT
	mc_pm_clock_enable();
	#endif

	smc(fc_work->data);

	#ifdef MC_CRYPTO_CLOCK_MANAGEMENT
	mc_pm_clock_disable();
	#endif
	}

	void mc_fastcall(void *data)
	{
	struct fastcall_work fc_work = {
	KTHREAD_WORK_INIT(fc_work.work, fastcall_work_func),
	.data = data,
	};

	queue_kthread_work(&fastcall_worker, &fc_work.work);
	flush_kthread_work(&fc_work.work);
	}

	int mc_fastcall_init(struct mc_context *context)
	{
	int ret = 0;

	ctx = context;

	fastcall_thread = kthread_create(kthread_worker_fn, &fastcall_worker,
	"mc_fastcall");
	if (IS_ERR(fastcall_thread)) {
	ret = PTR_ERR(fastcall_thread);
	fastcall_thread = NULL;
	MCDRV_DBG_ERROR(mcd, "cannot create fastcall wq (%d)\n", ret);
	return ret;
	}

	/* this thread MUST run on CPU 0 */
	kthread_bind(fastcall_thread, 0);
	wake_up_process(fastcall_thread);

	return 0;
	}

	void mc_fastcall_destroy(void)
	{
	if (!IS_ERR_OR_NULL(fastcall_thread)) {
	kthread_stop(fastcall_thread);
	fastcall_thread = NULL;
	}
	}
	#else

	struct fastcall_work_struct {
	struct work_struct work;
	void *data;
	};

	static void fastcall_work_func(struct work_struct *work)
	{
	struct fastcall_work_struct *fc_work =
	container_of(work, struct fastcall_work_struct, work);

	#ifdef MC_CRYPTO_CLOCK_MANAGEMENT
	mc_pm_clock_enable();
	#endif

	smc(fc_work->data);

	#ifdef MC_CRYPTO_CLOCK_MANAGEMENT
	mc_pm_clock_disable();
	#endif
	}

	void mc_fastcall(void *data)
	{
	struct fastcall_work_struct work = {
	.data = data,
	};
	INIT_WORK(&work.work, fastcall_work_func);
	schedule_work_on(0, &work.work);

	flush_work(&work.work);
	}

	int mc_fastcall_init(struct mc_context *context)
	{
	ctx = context;
	return 0;
	};

	void mc_fastcall_destroy(void) {};
	#endif

	int mc_info(uint32_t ext_info_id, uint32_t state, uint32_t ext_info)
	{
	int ret = 0;
	union mc_fc_info fc_info;

	MCDRV_DBG_VERBOSE(mcd, "enter\n");

	memset(&fc_info, 0, sizeof(fc_info));
	fc_info.as_in.cmd = MC_FC_INFO;
	fc_info.as_in.ext_info_id = ext_info_id;

	MCDRV_DBG(mcd, "fc_info <- cmd=0x%08x, ext_info_id=0x%08x\n",
	fc_info.as_in.cmd, fc_info.as_in.ext_info_id);

	mc_fastcall(&(fc_info.as_generic));

	MCDRV_DBG(mcd,
	"fc_info -> r=0x%08x ret=0x%08x state=0x%08x ext_info=0x%08x",
	fc_info.as_out.resp,
	fc_info.as_out.ret,
	fc_info.as_out.state,
	fc_info.as_out.ext_info);

	ret = convert_fc_ret(fc_info.as_out.ret);

	*state = fc_info.as_out.state;
	*ext_info = fc_info.as_out.ext_info;

	MCDRV_DBG_VERBOSE(mcd, "exit with %d/0x%08X\n", ret, ret);

	return ret;
	}

	/* Yield to MobiCore */
	int mc_yield(void)
	{
	int ret = 0;
	union fc_generic yield;

	MCDRV_DBG_VERBOSE(mcd, "enter\n");

	memset(&yield, 0, sizeof(yield));
	yield.as_in.cmd = MC_SMC_N_YIELD;
	mc_fastcall(&yield);
	ret = convert_fc_ret(yield.as_out.ret);

	return ret;
	}

	/* call common notify */
	int mc_nsiq(void)
	{
	int ret = 0;
	union fc_generic nsiq;
	MCDRV_DBG_VERBOSE(mcd, "enter\n");

	memset(&nsiq, 0, sizeof(nsiq));
	nsiq.as_in.cmd = MC_SMC_N_SIQ;
	mc_fastcall(&nsiq);
	ret = convert_fc_ret(nsiq.as_out.ret);

	return ret;
	}

	/* call common notify */
	int _nsiq(void)
	{
	int ret = 0;
	union fc_generic nsiq;
	MCDRV_DBG_VERBOSE(mcd, "enter\n");

	memset(&nsiq, 0, sizeof(nsiq));
	nsiq.as_in.cmd = MC_SMC_N_SIQ;
	_smc(&nsiq);
	ret = convert_fc_ret(nsiq.as_out.ret);

	return ret;
	}

	/* Call the INIT fastcall to setup MobiCore initialization */
	int mc_init(uint32_t base, uint32_t nq_offset, uint32_t nq_length,
	uint32_t mcp_offset, uint32_t mcp_length)
	{
	int ret = 0;
	union mc_fc_init fc_init;

	MCDRV_DBG_VERBOSE(mcd, "enter\n");

	memset(&fc_init, 0, sizeof(fc_init));

	fc_init.as_in.cmd = MC_FC_INIT;
	/* base address of mci buffer 4KB aligned */
	fc_init.as_in.base = base;
	/* notification buffer start/length [16:16] [start, length] */
	fc_init.as_in.nq_info = (nq_offset << 16) \| (nq_length & 0xFFFF);
	/* mcp buffer start/length [16:16] [start, length] */
	fc_init.as_in.mcp_info = (mcp_offset << 16) \| (mcp_length & 0xFFFF);

	/*
	* Set KMOD notification queue to start of MCI
	* mciInfo was already set up in mmap
	*/
	MCDRV_DBG(mcd,
	"cmd=0x%08x, base=0x%08x,nq_info=0x%08x, mcp_info=0x%08x\n",
	fc_init.as_in.cmd, fc_init.as_in.base, fc_init.as_in.nq_info,
	fc_init.as_in.mcp_info);

	mc_fastcall(&fc_init.as_generic);

	MCDRV_DBG(mcd, "out cmd=0x%08x, ret=0x%08x\n", fc_init.as_out.resp,
	fc_init.as_out.ret);

	ret = convert_fc_ret(fc_init.as_out.ret);

	MCDRV_DBG_VERBOSE(mcd, "exit with %d/0x%08X\n", ret, ret);

	return ret;
	}

	/* Return MobiCore driver version */
	uint32_t mc_get_version(void)
	{
	MCDRV_DBG(mcd, "MobiCore driver version is %i.%i\n",
	MCDRVMODULEAPI_VERSION_MAJOR,
	MCDRVMODULEAPI_VERSION_MINOR);

	return MC_VERSION(MCDRVMODULEAPI_VERSION_MAJOR,
	MCDRVMODULEAPI_VERSION_MINOR);
	}