arch/arm/plat-feroceon/mv_drivers_lsp/mv_cesa/cesa_dev.c

#include <linux/autoconf.h>
#include <linux/types.h>
#include <linux/time.h>
#include <linux/delay.h>
#include <linux/list.h>
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/unistd.h>
#include <linux/module.h>
#include <linux/wait.h>
#include <linux/slab.h>
#include <linux/fs.h>
#include <linux/file.h>
#include <linux/miscdevice.h>
#include <linux/version.h>
#include <asm/uaccess.h>

#include "cesa_dev.h"

#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,11)
#include <linux/syscalls.h>
#endif
#include "mvOs.h"
#include "mvCommon.h"
#include "ctrlEnv/mvCtrlEnvLib.h"
#include "cesa/mvCesa.h" 
#include "mvSysCesaApi.h"


static int debug = 1;
module_param(debug, int, 0);
MODULE_PARM_DESC(debug,
	   "Enable debug");

#ifdef CONFIG_MV_CESA_TEST

static int buf_size = 20000;
/*MODULE_PARM(buf_size, "i");*/
module_param(buf_size,int,0644);
MODULE_PARM_DESC(buf_size, "Size of each data buffer");

static int buf_num = 1;
/*MODULE_PARM(buf_num, "i");*/
module_param(buf_num,int,0644);

MODULE_PARM_DESC(buf_num, "Number of data buffers for each request");

extern void cesaTestStart(int bufNum, int bufSize);
extern void cesaTestStop(void);
extern void cesaTest(int iter, int reqSize, int checkMode);
extern void combiTest(int iter, int reqSize, int checkMode);
extern void cesaOneTest(int testIdx, int caseIdx, int iter, int reqSize, int checkMode);
extern void multiSizeTest(int idx, int checkMode, int iter, char* inputData);
extern void aesTest(int iter, int reqSize, int checkMode);
extern void desTest(int iter, int reqSize, int checkMode);
extern void tripleDesTest(int iter, int reqSize, int checkMode);
extern void mdTest(int iter, int reqSize, int checkMode);
extern void sha1Test(int iter, int reqSize, int checkMode);
extern void sha2Test(int iter, int reqSize, int checkMode);

int run_cesa_test(CESA_TEST *cesa_test)
{
	switch(cesa_test->test){
		case(MULTI):
			combiTest(cesa_test->iter, cesa_test->req_size, cesa_test->checkmode);
			break;
		case(SIZE):
                        multiSizeTest(cesa_test->req_size, cesa_test->iter, cesa_test->checkmode, NULL);
			break;
		case(SINGLE):
			cesaOneTest(cesa_test->session_id, cesa_test->data_id, cesa_test->iter, 
					cesa_test->req_size, cesa_test->checkmode);
			break;
		case(AES):
			aesTest(cesa_test->iter, cesa_test->req_size, cesa_test->checkmode);		
			break;
		case(DES):
			desTest(cesa_test->iter, cesa_test->req_size, cesa_test->checkmode);
			break;
		case(TRI_DES):
			tripleDesTest(cesa_test->iter, cesa_test->req_size, cesa_test->checkmode);
			break;
		case(MD5):
                        mdTest(cesa_test->iter, cesa_test->req_size, cesa_test->checkmode);
                        break;
		case(SHA1):
                        sha1Test(cesa_test->iter, cesa_test->req_size, cesa_test->checkmode);
                        break;
		case(SHA2):
                        sha2Test(cesa_test->iter, cesa_test->req_size, cesa_test->checkmode);
                        break;

		default:
			dprintk("%s(unknown test 0x%x)\n", __FUNCTION__, cesa_test->test);
			return -EINVAL;
	}
	return 0;
}
#endif /* CONFIG_MV_CESA_TEST */

extern void    		mvCesaDebugSAD(int mode);
extern void    		mvCesaDebugSA(short sid, int mode);
extern void    		mvCesaDebugQueue(int mode);
extern void    		mvCesaDebugStatus(void);
extern void    		mvCesaDebugSram(int mode);
extern void    		cesaTestPrintReq(int req, int offset, int size);
extern void	   	    cesaTestPrintSession(int idx);
extern void	   	    cesaTestPrintStatus(void);


int run_cesa_debug(CESA_DEBUG *cesa_debug)
{
	int error = 0;
	switch(cesa_debug->debug){
		case(STATUS):
			mvCesaDebugStatus();
			break;
		case(QUEUE):
			mvCesaDebugQueue(cesa_debug->mode);
			break;
		case(SA):
			mvCesaDebugSA(cesa_debug->index, cesa_debug->mode);
			break;
		case(SRAM):
			mvCesaDebugSram(cesa_debug->mode);
			break;
		case(SAD):
			mvCesaDebugSAD(cesa_debug->mode);
			break;

#ifdef CONFIG_MV_CESA_TEST
		case(TST_REQ):
			cesaTestPrintReq(cesa_debug->index, 0, cesa_debug->size);
			break;
		case(TST_SES):
			cesaTestPrintSession(cesa_debug->index);
			break;
        case(TST_STATS):
            cesaTestPrintStatus();
            break;
#endif /* CONFIG_MV_CESA_TEST */

		default:
			dprintk("%s(unknown debug 0x%x)\n", __FUNCTION__, cesa_debug->debug);
			error = EINVAL;
			break;

	}

	return(-error);
}


static int
cesadev_ioctl(
	struct inode *inode,
	struct file *filp,
	unsigned int cmd,
	unsigned long arg)
{	
	CESA_DEBUG cesa_debug;
	u32 error = 0;

	dprintk("%s: cmd=0x%x, CIOCDEBUG=0x%x, CIOCTEST=0x%x\n", 
                __FUNCTION__, cmd, CIOCDEBUG, CIOCTEST);

	switch (cmd) {
	case CIOCDEBUG:
		if(copy_from_user(&cesa_debug, (void*)arg, sizeof(CESA_DEBUG)))
				error = -EFAULT;
		dprintk("%s(CIOCDEBUG): debug %d index %d mode %d size %d\n", 
			__FUNCTION__, cesa_debug.debug, cesa_debug.index, cesa_debug.mode, cesa_debug.size);
		error = run_cesa_debug(&cesa_debug);
		break;

#ifdef CONFIG_MV_CESA_TEST
    case CIOCTEST:
		{
		CESA_TEST cesa_test;

		if(copy_from_user(&cesa_test, (void*)arg, sizeof(CESA_TEST)))
			error = -EFAULT;
		dprintk("%s(CIOCTEST): test %d iter %d req_size %d checkmode %d sess_id %d data_id %d \n", 
			__FUNCTION__, cesa_test.test, cesa_test.iter, cesa_test.req_size, cesa_test.checkmode,
			cesa_test.session_id, cesa_test.data_id );
		error = run_cesa_test(&cesa_test);
		}
		break;
#endif /* CONFIG_MV_CESA_TEST */

	default:
		dprintk("%s (unknown ioctl 0x%x)\n", __FUNCTION__, cmd);
		error = EINVAL;
		break;
	}
	return(-error);
}


static int
cesadev_open(struct inode *inode, struct file *filp)
{
	dprintk("%s()\n", __FUNCTION__);
	return(0);
}

static int
cesadev_release(struct inode *inode, struct file *filp)
{
	dprintk("%s()\n", __FUNCTION__);
	return(0);
}


static struct file_operations cesadev_fops = {
	.owner = THIS_MODULE,
	.open = cesadev_open,
	.release = cesadev_release,
	.ioctl = cesadev_ioctl,
};

static struct miscdevice cesadev = {
	.minor = CESADEV_MINOR,
	.name = "cesa",
	.fops = &cesadev_fops,
};

static int __init
cesadev_init(void)
{
	int rc;

	if (mvCtrlPwrClckGet(CESA_UNIT_ID, 0) == MV_FALSE)
		return 0;

#if defined(CONFIG_MV78200) || defined(CONFIG_MV632X)
	if (MV_FALSE == mvSocUnitIsMappedToThisCpu(CESA))
	{
		dprintk("CESA is not mapped to this CPU\n");
		return -ENODEV;
	}		
#endif

#ifdef CONFIG_MV_CESA_TEST
    cesaTestStart(buf_num, buf_size);
#endif

	dprintk("%s(%p)\n", __FUNCTION__, cesadev_init);
	rc = misc_register(&cesadev);
	if (rc) {
		printk(KERN_ERR "cesadev: registration of /dev/cesadev failed\n");
		return(rc);
	}
	return(0);
}

static void __exit
cesadev_exit(void)
{
#ifdef CONFIG_MV_CESA_TEST
	cesaTestStop();
#endif
	dprintk("%s()\n", __FUNCTION__);
	misc_deregister(&cesadev);
}

module_init(cesadev_init);
module_exit(cesadev_exit);

MODULE_LICENSE("GPL");
MODULE_AUTHOR("Ronen Shitrit");
MODULE_DESCRIPTION("Cesadev (user interface to CESA)");