From 8e4bff4cab0ddac6060645b0715210484d02ff40 Mon Sep 17 00:00:00 2001
From: Yuval Adam <_@yuv.al>
Date: Wed, 30 Aug 2017 08:25:59 +0000
Subject: Initial file dump from open source release

---
 drivers/misc/sdiodev/sdio_dev_test.c | 1219 ++++++++++++++++++++++++++++++++++
 1 file changed, 1219 insertions(+)
 create mode 100644 drivers/misc/sdiodev/sdio_dev_test.c

(limited to 'drivers/misc/sdiodev/sdio_dev_test.c')

diff --git a/drivers/misc/sdiodev/sdio_dev_test.c b/drivers/misc/sdiodev/sdio_dev_test.c
new file mode 100644
index 00000000..31385b0a
--- /dev/null
+++ b/drivers/misc/sdiodev/sdio_dev_test.c
@@ -0,0 +1,1219 @@
+/*
+ * Copyright (C) 2013 Spreadtrum Communications Inc.
+ *
+ * Filename : sdio_dev_test.c
+ * Abstract : This file is a implementation for itm sipc command/event function
+ *
+ * Authors	: gaole.zhang
+ *
+ *
+ * This software is licensed under the terms of the GNU General Public
+ * License version 2, as published by the Free Software Foundation, and
+ * may be copied, distributed, and modified under those terms.
+
+ * 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 "sdio_dev.h"
+
+
+#if defined(SDIO_TEST_CASE1)
+
+#define SEND_BUF_LEN 1024//SDIO_TEST_CASE1
+
+char *data_send_ptr[17] = {0};
+
+
+static void test_sdio_send_func(int chn,int senddatalen,void* data_buf)
+{
+
+	uint32 chndatalen,ret;
+
+	char *tmp = (char*)data_buf;
+	
+	//SDIOTRAN_ERR("\nrun to test_sdio_send_func,senddatalen is %d!!!\n",senddatalen);
+	SDIOTRAN_ERR("entry");
+
+
+
+	set_marlin_wakeup(chn,1);
+
+
+
+	if(!sdio_dev_chn_idle(chn))
+	{
+		SDIOTRAN_ERR("send chn active,can't send right now,chn is %d!!!",chn);
+		return;
+	}	
+
+
+	chndatalen = sdio_dev_get_chn_datalen(chn);
+	if(senddatalen > chndatalen)
+	{
+		SDIOTRAN_ERR("channel %d chndatalen is =%d,senddatalen is =%d, can't send!!",chn,chndatalen,senddatalen);
+		return;
+	}
+	
+	SDIOTRAN_ERR("ap chn %d send len %d data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",chn,senddatalen,\
+		tmp[0],\
+		tmp[1],\
+		tmp[2],\
+		tmp[3], \
+		tmp[101], \
+		tmp[102], \
+		tmp[103], \
+		tmp[104], \
+		tmp[230], \
+		tmp[231], \
+		tmp[232], \
+		tmp[233] \
+		);
+
+	sdio_dev_write(chn,data_buf,senddatalen);
+	set_marlin_sleep(chn,1);
+
+
+}
+
+
+
+static int gaole_test_thread(void *data)
+{
+	int i,j,k;
+
+	struct sched_param param = {.sched_priority = 90};
+
+	/*set the thread as a real time thread, and its priority is 90*/
+	sched_setscheduler(current, SCHED_RR, &param);
+	
+	/*for(i=0;i<16;i++){
+
+		data_send_ptr[i] = kmalloc(SEND_BUF_LEN,GFP_KERNEL);
+		if (NULL == data_send_ptr[i])
+		{
+			SDIOTRAN_ERR("kmalloc send buf%d err!!!",i);
+			return -1;
+		}
+		
+		SDIOTRAN_DEBUG("kmalloc send buf%d ok!!!",i);
+
+		for(j=0,k=0;j<SEND_BUF_LEN;j++,k++)
+			*(data_send_ptr[i]+j) = ((k+i)<=255?(k+i):(k=0,k+i));
+	
+	}*/
+	set_blklen(512);
+
+	while(1)
+	{
+	
+	/*
+		for(j=0;j<8;j++)
+		{
+			set_blklen(32<<j);
+			for(i=0;i<9;i++)
+			{	
+				if(((32<<j)<<i) > 8192)
+					break;
+				
+				test_sdio_send_func(j,(32<<j)<<i,data_send_ptr[1]);
+			}		
+		}
+	*/
+		
+	/*
+		for(j=1;j<128;j++)
+			test_sdio_send_func(0,j,data_send_ptr[1]);
+		break;
+		
+		msleep(1000);
+		test_sdio_send_func(0,64,data_send_ptr[1]);
+		test_sdio_send_func(0,128,data_send_ptr[1]);
+		test_sdio_send_func(0,192,data_send_ptr[1]);
+	*/
+		
+
+
+	
+		/*if test CASE3 please unmark msleep func and modify sleep time,
+		CP side need not  to change*/
+		//msleep(1000);	
+	
+		for(i=0;i<16;i++)
+		{
+			msleep(1000);
+			for(j=0;j<2;j++)
+			{	
+				msleep(1000);
+				test_sdio_send_func(i,0x200<<j,data_send_ptr[i]);
+			}
+
+			SDIOTRAN_ERR("chn %d test finish!!!",i);
+		}
+		
+		SDIOTRAN_ERR("sdio test write finish!!!");	
+		break;
+	}	
+	
+	return 0;
+}
+
+void gaole_creat_test(void)
+{
+	struct task_struct * task;
+	int i,j,k;
+	for(i=0;i<16;i++){
+	
+			data_send_ptr[i] = kmalloc(SEND_BUF_LEN,GFP_KERNEL);
+			if (NULL == data_send_ptr[i])
+			{
+				SDIOTRAN_ERR("kmalloc send buf%d err!!!",i);
+				return -1;
+			}
+			
+			SDIOTRAN_DEBUG("kmalloc send buf%d ok!!!",i);
+	
+			for(j=0,k=0;j<SEND_BUF_LEN;j++,k++)
+				*(data_send_ptr[i]+j) = ((k+i)<=255?(k+i):(k=0,k+i));
+		
+		}
+
+	task = kthread_create(gaole_test_thread, NULL, "GaoleTest");
+	if(0 != task)
+		wake_up_process(task);
+}
+
+
+#endif//SDIO_TEST_CASE1
+
+#if defined(SDIO_TEST_CASE2)
+
+#define RECV_BUF_LEN 1024//SDIO_TEST_CASE2
+
+char *data_recv_ptr[17] = {0};
+
+int invalid_num = 0;
+
+static int active_chn = 0;
+static int last_chn = 1;
+static int dummy_recv = 0;
+
+static int read_datalen = 0;
+
+void test_sdio_recv_func(void)
+{
+	int i,j;
+	SDIOTRAN_DEBUG("entry");
+
+	if((active_chn = sdio_dev_get_read_chn()) == -1)
+	{
+		invalid_num++;
+		return;
+	}
+	
+	if(last_chn == active_chn)
+	{		
+		dummy_recv++;
+	}
+	else
+	{
+		last_chn = active_chn;
+		dummy_recv--;
+	}
+
+	for(j=0;j<RECV_BUF_LEN;j++)
+		*(data_recv_ptr[active_chn]+j) = 0;
+
+	sdio_dev_read(active_chn,(data_recv_ptr[active_chn]+10),&read_datalen);
+	
+	SDIOTRAN_ERR("ap recv: active_chn is %d!!!",active_chn);
+	SDIOTRAN_ERR("ap recv: read_datalen is 0x%x!!!",read_datalen);
+
+	SDIOTRAN_ERR("ap recv data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",\
+		*((data_recv_ptr[active_chn]+10)+read_datalen-9),\
+		*((data_recv_ptr[active_chn]+10)+read_datalen-8),\
+		*((data_recv_ptr[active_chn]+10)+read_datalen-7),\
+		*((data_recv_ptr[active_chn]+10)+read_datalen-6), \
+		*((data_recv_ptr[active_chn]+10)+read_datalen-5), \
+		*((data_recv_ptr[active_chn]+10)+read_datalen-4), \
+		*((data_recv_ptr[active_chn]+10)+read_datalen-3), \
+		*((data_recv_ptr[active_chn]+10)+read_datalen-2), \
+		*((data_recv_ptr[active_chn]+10)+read_datalen-1), \
+		*((data_recv_ptr[active_chn]+10)+read_datalen), \
+		*((data_recv_ptr[active_chn]+10)+read_datalen+1), \
+		*((data_recv_ptr[active_chn]+10)+read_datalen+2) \
+		);
+
+	active_chn = 0;
+	read_datalen = 0;
+}
+
+static int gaole_test_thread(void *data)
+{
+	int i,j;
+
+	struct sched_param param = {.sched_priority = 90};
+
+	/*set the thread as a real time thread, and its priority is 90*/
+	sched_setscheduler(current, SCHED_RR, &param);
+
+	for(i=0;i<16;i++){
+
+		data_recv_ptr[i] = kmalloc(RECV_BUF_LEN,GFP_KERNEL);
+		if (NULL == data_recv_ptr[i])
+		{
+			SDIOTRAN_ERR("kmalloc recv buf%d err!!!",i);
+			return -1;
+		}
+		
+		SDIOTRAN_DEBUG("kmalloc recv buf%d ok!!!",i);
+
+		for(j=0;j<RECV_BUF_LEN;j++)
+			*(data_recv_ptr[i]+j) = 0;
+	
+	}
+	
+	set_blklen(512); 
+
+	while(1)
+	{
+
+		test_sdio_recv_func();
+
+		
+		if(dummy_recv > 50)
+			break;
+		
+		if(invalid_num > 50)
+			break;
+	}	
+	
+	return 0;
+}
+
+void gaole_creat_test(void)
+{
+	struct task_struct * task;
+
+	task = kthread_create(gaole_test_thread, NULL, "GaoleTest");
+	if(0 != task)
+		wake_up_process(task);
+}
+
+
+
+#endif//SDIO_TEST_CASE2
+
+
+
+#if defined(SDIO_TEST_CASE4)
+
+#define BUF_LEN 1024//SDIO_TEST_CASE4
+
+char *data_ptr[10] = {0};
+
+bool continue_send = 1;
+
+static int test_send_chn = 0;
+
+
+
+static void test_sdio_send_func(int chn,void* data_buf)
+{
+
+	uint32 datalen;
+
+	char *tmp = (char*)data_buf;
+	
+	//SDIOTRAN_ERR("\nrun to test_sdio_send_func!!!\n");
+
+	while(!sdio_dev_chn_idle(chn));	
+
+	while(1)
+	{
+		datalen = sdio_dev_get_chn_datalen(chn);
+		if(datalen)
+		{
+			SDIOTRAN_ERR("channel %d len is =%d!!!",chn,datalen);
+			break;
+		}
+		else
+			SDIOTRAN_ERR("channel %d len is =%d!!!",chn,datalen);
+
+	}
+	
+	SDIOTRAN_ERR("ap %d send data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",chn,\
+		tmp[0],\
+		tmp[1],\
+		tmp[2],\
+		tmp[3], \
+		tmp[101], \
+		tmp[102], \
+		tmp[103], \
+		tmp[104], \
+		tmp[230], \
+		tmp[231], \
+		tmp[232], \
+		tmp[233] \
+		);
+
+	sdio_dev_write(chn,data_buf,datalen);
+
+}
+
+void case4_workq_handler(void)
+{
+	int i;
+	
+	int read_chn = 0;
+	int datalen = 0;
+
+	read_chn = sdio_dev_get_read_chn();
+	
+	if(-1 == read_chn)
+		return;
+	
+
+	SDIOTRAN_DEBUG("ap recv: active_chn is %d!!!",read_chn);
+	
+
+	for(i=0;i<BUF_LEN;i++)
+		*(data_ptr[read_chn-7]+i) = 0;
+
+
+	sdio_dev_read(read_chn,data_ptr[read_chn-7],&datalen);
+	
+	SDIOTRAN_ERR("ap recv chn %d data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",read_chn,\
+		*(data_ptr[read_chn-7]+0),\
+		*(data_ptr[read_chn-7]+1),\
+		*(data_ptr[read_chn-7]+2),\
+		*(data_ptr[read_chn-7]+3), \
+		*(data_ptr[read_chn-7]+100), \
+		*(data_ptr[read_chn-7]+101), \
+		*(data_ptr[read_chn-7]+102), \
+		*(data_ptr[read_chn-7]+103), \
+		*(data_ptr[read_chn-7]+230), \
+		*(data_ptr[read_chn-7]+231), \
+		*(data_ptr[read_chn-7]+232), \
+		*(data_ptr[read_chn-7]+233) \
+		);	
+	
+	continue_send = 1;
+}
+
+
+
+
+static int gaole_test_thread(void *data)
+{
+	int i,j,k;
+
+	struct sched_param param = {.sched_priority = 90};
+
+	/*set the thread as a real time thread, and its priority is 90*/
+	sched_setscheduler(current, SCHED_RR, &param);
+	
+	for(i=0;i<10;i++){
+
+		data_ptr[i] = kmalloc(BUF_LEN,GFP_KERNEL);
+		if (NULL == data_ptr[i])
+		{
+			SDIOTRAN_ERR("kmalloc send buf%d err!!!",i);
+			return -1;
+		}
+		
+		SDIOTRAN_DEBUG("kmalloc send buf%d ok!!!",i);
+
+		for(j=0;j<BUF_LEN;j++)
+			*(data_ptr[i]+j) = 0;
+	
+	}
+	
+	for(j=0,k=0;j<BUF_LEN;j++,k++)
+		*(data_ptr[0]+j) = (k<=255?k:(k=0,k));
+
+	while(1)
+	{
+
+		if(1 == continue_send)
+		{
+			continue_send = 0;
+			test_sdio_send_func(test_send_chn,data_ptr[test_send_chn]);
+			
+
+			test_send_chn++;
+			if(8 == test_send_chn)
+			{
+				test_send_chn = 0;				
+			}
+		}
+		else
+			msleep(1);
+	}	
+	return 0;
+}
+
+
+void gaole_creat_test(void)
+{
+	struct task_struct * task;
+
+	task = kthread_create(gaole_test_thread, NULL, "GaoleTest");
+	if(0 != task)
+		wake_up_process(task);
+}
+
+
+#endif//SDIO_TEST_CASE4
+
+
+#if defined(SDIO_TEST_CASE5)
+
+#define TEST_BUF_LEN 8192 //SDIO_TEST_CASE5
+
+#define TEST_SEND_CHN 0
+
+char *data_test_ptr[17] = {0};
+
+
+int active_chn = 0;
+int read_datalen = 0;
+
+void case5_workq_handler(void)
+{
+	int i;
+	
+	active_chn = 0;
+	read_datalen = 0;
+
+	active_chn = sdio_dev_get_read_chn();
+	
+	if(-1 == active_chn)
+		return;
+	
+	SDIOTRAN_DEBUG("ap recv: active_chn is %d!!!",active_chn);
+	
+
+	for(i=0;i<TEST_BUF_LEN;i++)
+		*(data_test_ptr[active_chn]+i) = 0;
+
+
+	sdio_dev_read(active_chn,data_test_ptr[active_chn],&read_datalen);
+	
+	SDIOTRAN_ERR("ap recv chn %d data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",active_chn,\
+		*(data_test_ptr[active_chn]+0),\
+		*(data_test_ptr[active_chn]+1),\
+		*(data_test_ptr[active_chn]+2),\
+		*(data_test_ptr[active_chn]+3), \
+		*(data_test_ptr[active_chn]+100), \
+		*(data_test_ptr[active_chn]+101), \
+		*(data_test_ptr[active_chn]+102), \
+		*(data_test_ptr[active_chn]+103), \
+		*(data_test_ptr[active_chn]+230), \
+		*(data_test_ptr[active_chn]+231), \
+		*(data_test_ptr[active_chn]+232), \
+		*(data_test_ptr[active_chn]+233) \
+		);
+}
+
+
+static void test_sdio_send_func(void)
+{
+
+	uint32 datalen;
+	
+	SDIOTRAN_ERR("entry");
+
+	while(!sdio_dev_chn_idle(TEST_SEND_CHN));	
+
+	while(1)
+	{
+		datalen = sdio_dev_get_chn_datalen(TEST_SEND_CHN);
+		if(datalen)
+		{
+			SDIOTRAN_ERR("channel %d len is =%d!!!",TEST_SEND_CHN,datalen);
+			break;
+		}
+		else
+			SDIOTRAN_ERR("channel %d len is =%d!!!",TEST_SEND_CHN,datalen);
+
+	}
+	
+	SDIOTRAN_ERR("ap send data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",\
+		*(data_test_ptr[active_chn]+0),\
+		*(data_test_ptr[active_chn]+1),\
+		*(data_test_ptr[active_chn]+2),\
+		*(data_test_ptr[active_chn]+3), \
+		*(data_test_ptr[active_chn]+100), \
+		*(data_test_ptr[active_chn]+101), \
+		*(data_test_ptr[active_chn]+102), \
+		*(data_test_ptr[active_chn]+103), \
+		*(data_test_ptr[active_chn]+230), \
+		*(data_test_ptr[active_chn]+231), \
+		*(data_test_ptr[active_chn]+232), \
+		*(data_test_ptr[active_chn]+233)\
+		);
+
+	sdio_dev_write(TEST_SEND_CHN,data_test_ptr[active_chn],datalen);
+
+}
+
+
+static int gaole_test_thread(void *data)
+{
+	int i,j;
+
+	struct sched_param param = {.sched_priority = 90};
+
+	/*set the thread as a real time thread, and its priority is 90*/
+	sched_setscheduler(current, SCHED_RR, &param);
+
+	for(i=0;i<16;i++){
+
+		data_test_ptr[i] = kmalloc(TEST_BUF_LEN,GFP_KERNEL);
+		if (NULL == data_test_ptr[i])
+		{
+			SDIOTRAN_ERR("kmalloc buf%d err!!!",i);
+			return -1;
+		}
+		
+		SDIOTRAN_ERR("kmalloc buf%d ok!!!",i);
+
+
+	
+	}
+
+	while(1)
+	{
+		msleep(10);
+		
+		for(i=0,j=0;i<TEST_BUF_LEN;i++,j++)
+			*(data_test_ptr[0]+i) = (j<=255?j:(j=0,j));		
+	
+		test_sdio_send_func();
+		
+		break;
+	}	
+	
+	return 0;
+}
+
+void gaole_creat_test(void)
+{
+	struct task_struct * task;
+
+	task = kthread_create(gaole_test_thread, NULL, "GaoleTest");
+	if(0 != task)
+		wake_up_process(task);
+}
+#endif//SDIO_TEST_CASE5
+
+#if defined(SDIO_TEST_CASE6)
+
+#define BUF_LEN 1024//SDIO_TEST_CASE6
+
+char *data_ptr[10] = {0};
+
+bool continue_send = 0;
+
+static int test_send_chn = 0;
+
+static void test_sdio_send_func(int chn,void* data_buf)
+{
+
+	uint32 datalen;
+uint32 ret;
+	char *tmp = (char*)data_buf;
+	
+	//SDIOTRAN_ERR("\nrun to test_sdio_send_func!!!\n");
+
+	set_marlin_wakeup(chn,1);
+
+	while(!sdio_dev_chn_idle(chn));	
+
+	while(1)
+	{
+		datalen = sdio_dev_get_chn_datalen(chn);
+		if(datalen)
+		{
+			SDIOTRAN_ERR("channel %d len is =%d!!",chn,datalen);
+			break;
+		}
+		else
+			SDIOTRAN_ERR("channel %d len is =%d!!",chn,datalen);
+
+	}
+	
+	SDIOTRAN_ERR("ap %d send data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",chn,\
+		tmp[0],\
+		tmp[1],\
+		tmp[2],\
+		tmp[3], \
+		tmp[101], \
+		tmp[102], \
+		tmp[103], \
+		tmp[104], \
+		tmp[230], \
+		tmp[231], \
+		tmp[232], \
+		tmp[233] \
+		);
+
+	sdio_dev_write(chn,data_buf,datalen);
+	set_marlin_sleep(chn,1);
+
+
+}
+
+void case6_workq_handler(void)
+{
+	int i;
+	
+	int read_chn = 0;
+	int datalen = 0;
+
+	read_chn = sdio_dev_get_read_chn();
+	
+	if(-1 == read_chn)
+		return;	
+	
+
+	SDIOTRAN_ERR("ap recv: active_chn is %d!!!",read_chn);
+
+
+	for(i=0;i<BUF_LEN;i++)
+		*(data_ptr[read_chn-8]+i) = 0;
+
+
+	sdio_dev_read(read_chn,data_ptr[read_chn-8],&datalen);
+	
+	SDIOTRAN_ERR("ap recv chn %d data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",read_chn,\
+		*(data_ptr[read_chn-8]+0),\
+		*(data_ptr[read_chn-8]+1),\
+		*(data_ptr[read_chn-8]+2),\
+		*(data_ptr[read_chn-8]+3), \
+		*(data_ptr[read_chn-8]+100), \
+		*(data_ptr[read_chn-8]+101), \
+		*(data_ptr[read_chn-8]+102), \
+		*(data_ptr[read_chn-8]+103), \
+		*(data_ptr[read_chn-8]+230), \
+		*(data_ptr[read_chn-8]+231), \
+		*(data_ptr[read_chn-8]+232), \
+		*(data_ptr[read_chn-8]+233) \
+		);	
+	
+	continue_send = 1;
+}
+
+
+
+
+static int gaole_test_thread(void *data)
+{
+	int i,j,k;
+
+	struct sched_param param = {.sched_priority = 90};
+
+	/*set the thread as a real time thread, and its priority is 90*/
+	sched_setscheduler(current, SCHED_RR, &param);
+	
+	for(i=0;i<10;i++){
+
+		data_ptr[i] = kmalloc(BUF_LEN,GFP_KERNEL);
+		if (NULL == data_ptr[i])
+		{
+			SDIOTRAN_ERR("kmalloc send buf%d err!!!",i);
+			return -1;
+		}
+		
+		SDIOTRAN_DEBUG("kmalloc send buf%d ok!!!",i);
+
+		for(j=0;j<BUF_LEN;j++)
+			*(data_ptr[i]+j) = 0;
+	
+	}
+	
+	for(j=0,k=0;j<BUF_LEN;j++,k++)
+		*(data_ptr[0]+j) = (k<=255?k:(k=0,k));
+
+	while(1)
+	{
+		if(1 == continue_send)
+		{
+			continue_send = 0;
+			msleep(1000);
+			test_sdio_send_func(test_send_chn,data_ptr[test_send_chn]);
+			
+
+			test_send_chn++;
+			if(8 == test_send_chn)
+			{
+				test_send_chn = 0;				
+			}
+		}
+		else
+			msleep(1);
+	}	
+	return 0;
+}
+
+
+void gaole_creat_test(void)
+{
+	struct task_struct * task;
+
+	task = kthread_create(gaole_test_thread, NULL, "GaoleTest");
+	if(0 != task)
+		wake_up_process(task);
+}
+
+#endif//SDIO_TEST_CASE6
+
+#if defined(SDIO_TEST_CASE7)//test speed
+
+#define SEND_BUF_LEN 1024 //SDIO_TEST_CASE7
+
+char *data_send_ptr[17] = {0};
+
+
+static void test_sdio_send_func(int chn,void* data_buf)
+{
+
+	uint32 datalen;
+
+	char *tmp = (char*)data_buf;
+	
+	//SDIOTRAN_ERR("\nrun to test_sdio_send_func!!!\n");
+
+	while(!sdio_dev_chn_idle(chn));	
+
+	while(1)
+	{
+		datalen = sdio_dev_get_chn_datalen(chn);
+		if(datalen)
+		{
+			//SDIOTRAN_ERR("channel %d len is =%d!!\r\n",chn,datalen);
+			break;
+		}
+		else
+			;//SDIOTRAN_ERR("channel %d len is =%d!!\r\n",chn,datalen);
+
+	}
+	/*
+	SDIOTRAN_ERR("\nap send data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!\n",\
+		tmp[0],\
+		tmp[1],\
+		tmp[2],\
+		tmp[3], \
+		tmp[101], \
+		tmp[102], \
+		tmp[103], \
+		tmp[104], \
+		tmp[230], \
+		tmp[231], \
+		tmp[232], \
+		tmp[233] \
+		);*/
+
+	sdio_dev_write(chn,data_buf,datalen);
+
+}
+
+
+
+static int gaole_test_thread(void *data)
+{
+	int i,j,k;
+	
+	static struct timeval start_time;
+	static struct timeval stop_time;
+	static signed long long elapsed_time;
+
+	struct sched_param param = {.sched_priority = 90};
+
+	/*set the thread as a real time thread, and its priority is 90*/
+	sched_setscheduler(current, SCHED_RR, &param);
+	
+	for(i=0;i<16;i++){
+
+		data_send_ptr[i] = kmalloc(SEND_BUF_LEN,GFP_KERNEL);
+		if (NULL == data_send_ptr[i])
+		{
+			SDIOTRAN_ERR("kmalloc send buf%d err!!!",i);
+			return -1;
+		}
+		
+		SDIOTRAN_DEBUG("kmalloc send buf%d ok!!!",i);
+
+		for(j=0,k=0;j<SEND_BUF_LEN;j++,k++)
+			*(data_send_ptr[i]+j) = ((k+i)<=255?(k+i):(k=0,k+i));
+	
+	}
+	//set_blklen(1); 
+
+
+	while(1)
+	{
+		for(i=0;i<16;i++)
+		{
+			do_gettimeofday(&start_time);
+			
+			for(j=0;j<100;j++)
+				test_sdio_send_func(i,data_send_ptr[i]);
+
+			do_gettimeofday(&stop_time);
+			elapsed_time = timeval_to_ns(&stop_time) - timeval_to_ns(&start_time);
+			SDIOTRAN_ERR("Chn %d test elapsed_time is %lld!!!",i,elapsed_time);
+			elapsed_time = 0;
+		}
+		break;
+		
+		SDIOTRAN_ERR("sdio test write finish!!!");		
+	}	
+	
+	return 0;
+}
+
+void gaole_creat_test(void)
+{
+	struct task_struct * task;
+
+	task = kthread_create(gaole_test_thread, NULL, "GaoleTest");
+	if(0 != task)
+		wake_up_process(task);
+}
+
+
+#endif//SDIO_TEST_CASE7
+
+#if defined(SDIO_TEST_CASE8)
+
+#define TEST_BUF_LEN 8192 //SDIO_TEST_CASE8
+
+char *data_test_ptr = NULL;
+
+static int gaole_test_count = 0;
+
+static struct timeval start_time;
+static struct timeval stop_time;
+static signed long long elapsed_time;
+
+static int last_chn = 0;
+bool stop_test = 0;
+
+void test_sdio_recv_func(void)
+{
+	int i;	
+	int read_chn = 0;
+	int datalen = 0;
+
+
+
+	//SDIOTRAN_ERR("\nap recv: active_chn is 0x%x!!!\n",active_chn);
+	
+
+	if(last_chn != read_chn)
+	{
+		last_chn = read_chn;
+		gaole_test_count = 0;
+
+	}
+	gaole_test_count ++;
+	
+		
+
+	//SDIOTRAN_ERR("\nap recv: read_datalen is 0x%x!!!\n",read_datalen);
+
+	//for(i=0;i<TEST_BUF_LEN;i++)
+	//	data_test_ptr[i] = 0;
+
+	sdio_dev_read(read_chn,data_test_ptr,&datalen);
+
+	if(1 == gaole_test_count)
+		do_gettimeofday(&start_time);	
+
+	
+	if(100 == gaole_test_count)
+	{
+		do_gettimeofday(&stop_time);
+		elapsed_time = timeval_to_ns(&stop_time) - timeval_to_ns(&start_time);
+		SDIOTRAN_ERR("Chn %d test elapsed_time is %lld!!!",read_chn,elapsed_time);
+
+		elapsed_time = 0;
+		if(15 == read_chn)
+			stop_test = 1;
+	}
+	/*
+	SDIOTRAN_ERR("\ncase7:ap recv data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!\n",\
+		data_test_ptr[0],\
+		data_test_ptr[1],\
+		data_test_ptr[2],\
+		data_test_ptr[3], \
+		data_test_ptr[101], \
+		data_test_ptr[102], \
+		data_test_ptr[103], \
+		data_test_ptr[104], \
+		data_test_ptr[251], \
+		data_test_ptr[252], \
+		data_test_ptr[253], \
+		data_test_ptr[254] \
+		);*/
+}
+
+
+static void test_sdio_send_func(void)
+{
+
+	uint32 datalen;
+	
+	SDIOTRAN_ERR("entry");
+
+	while(!sdio_dev_chn_idle(0));	
+
+	while(1)
+	{
+		datalen = sdio_dev_get_chn_datalen(0);
+		if(datalen)
+		{
+			SDIOTRAN_ERR("channel %d len is =%d!!",0,datalen);
+			break;
+		}
+		else
+			SDIOTRAN_ERR("channel %d len is =%d!!",0,datalen);
+
+	}
+	
+	SDIOTRAN_ERR("ap send data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",\
+		data_test_ptr[0],\
+		data_test_ptr[1],\
+		data_test_ptr[2],\
+		data_test_ptr[3], \
+		data_test_ptr[101], \
+		data_test_ptr[102], \
+		data_test_ptr[103], \
+		data_test_ptr[104], \
+		data_test_ptr[251], \
+		data_test_ptr[252], \
+		data_test_ptr[253], \
+		data_test_ptr[254] \
+		);
+
+	sdio_dev_write(0,data_test_ptr,datalen);
+
+}
+
+
+static int gaole_test_thread(void *data)
+{
+	int i,j;
+
+	struct sched_param param = {.sched_priority = 90};
+
+	/*set the thread as a real time thread, and its priority is 90*/
+	sched_setscheduler(current, SCHED_RR, &param);
+
+	data_test_ptr = kmalloc(TEST_BUF_LEN,GFP_KERNEL);
+	if (NULL == data_test_ptr)
+	{
+		SDIOTRAN_ERR("kmalloc send buf err!!!");
+		return -1;
+	}
+	
+	SDIOTRAN_DEBUG("kmalloc send buf ok!!!");
+
+	for(i=0,j=0;i<TEST_BUF_LEN;i++,j++)
+		data_test_ptr[i] = (j<=255?j:(j=0,j));	
+
+	test_sdio_send_func();
+
+
+	while(1)
+	{
+		test_sdio_recv_func();
+		
+		if(1 == stop_test)
+			break;		
+	}	
+	
+	return 0;
+}
+
+void gaole_creat_test(void)
+{
+	struct task_struct * task;
+
+	task = kthread_create(gaole_test_thread, NULL, "GaoleTest");
+	if(0 != task)
+		wake_up_process(task);
+}
+
+
+#endif//SDIO_TEST_CASE8
+
+
+#if defined(SDIO_TEST_CASE9)
+
+#define TEST_BUF_LEN 8192 //SDIO_TEST_CASE9
+
+#define TEST_SEND_CHN 0
+
+
+char *data_test_ptr = NULL;
+
+
+int active_chn = 0;
+int read_datalen = 0;
+static int gaole_test_count = 0;
+
+static struct timeval start_time;
+static struct timeval stop_time;
+static signed long long elapsed_time;
+
+static int last_chn = 0;
+
+void case9_workq_handler(void)
+{
+	int i;
+	
+	active_chn = 0;
+	read_datalen = 0;
+
+	active_chn = sdio_dev_get_read_chn();
+	//SDIOTRAN_ERR("\nap recv: active_chn is 0x%x!!!\n",active_chn);
+	
+	if(-1 == active_chn)
+		return;
+
+	if(last_chn != active_chn)
+	{
+		last_chn = active_chn;
+		gaole_test_count = 0;
+
+	}
+	gaole_test_count ++;
+	
+	
+
+	//SDIOTRAN_ERR("\nap recv: read_datalen is 0x%x!!!\n",read_datalen);
+
+	//for(i=0;i<TEST_BUF_LEN;i++)
+	//	data_test_ptr[i] = 0;
+
+	sdio_dev_read(active_chn,data_test_ptr,&read_datalen);
+
+	if(2 == gaole_test_count)
+		do_gettimeofday(&start_time);	
+
+	
+	if(101 == gaole_test_count)
+	{
+		do_gettimeofday(&stop_time);
+		elapsed_time = timeval_to_ns(&stop_time) - timeval_to_ns(&start_time);
+		SDIOTRAN_ERR("Chn %d test elapsed_time is %lld!!!",active_chn,elapsed_time);
+		elapsed_time = 0;
+	}
+	/*
+	SDIOTRAN_ERR("\ncase7:ap recv data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!\n",\
+		data_test_ptr[0],\
+		data_test_ptr[1],\
+		data_test_ptr[2],\
+		data_test_ptr[3], \
+		data_test_ptr[101], \
+		data_test_ptr[102], \
+		data_test_ptr[103], \
+		data_test_ptr[104], \
+		data_test_ptr[251], \
+		data_test_ptr[252], \
+		data_test_ptr[253], \
+		data_test_ptr[254] \
+		);*/
+}
+
+
+static void test_sdio_send_func(void)
+{
+
+	uint32 datalen;
+	
+	SDIOTRAN_ERR("entry");
+
+	while(!sdio_dev_chn_idle(TEST_SEND_CHN));	
+
+	while(1)
+	{
+		datalen = sdio_dev_get_chn_datalen(TEST_SEND_CHN);
+		if(datalen)
+		{
+			SDIOTRAN_ERR("channel %d len is =%d!!",TEST_SEND_CHN,datalen);
+			break;
+		}
+		else
+			SDIOTRAN_ERR("channel %d len is =%d!!",TEST_SEND_CHN,datalen);
+
+	}
+	
+	SDIOTRAN_ERR("ap send data: %d,%d,%d,%d  %d,%d,%d,%d  %d,%d,%d,%d!!!",\
+		data_test_ptr[0],\
+		data_test_ptr[1],\
+		data_test_ptr[2],\
+		data_test_ptr[3], \
+		data_test_ptr[101], \
+		data_test_ptr[102], \
+		data_test_ptr[103], \
+		data_test_ptr[104], \
+		data_test_ptr[251], \
+		data_test_ptr[252], \
+		data_test_ptr[253], \
+		data_test_ptr[254] \
+		);
+
+	sdio_dev_write(TEST_SEND_CHN,data_test_ptr,datalen);
+
+}
+
+
+static int gaole_test_thread(void *data)
+{
+	int i,j;
+
+	struct sched_param param = {.sched_priority = 90};
+
+	/*set the thread as a real time thread, and its priority is 90*/
+	sched_setscheduler(current, SCHED_RR, &param);
+
+	data_test_ptr = kmalloc(TEST_BUF_LEN,GFP_KERNEL);
+	if (NULL == data_test_ptr)
+	{
+		SDIOTRAN_ERR("kmalloc send buf err!!!");
+		return -1;
+	}
+	
+	SDIOTRAN_DEBUG("kmalloc send buf ok!!!");
+
+	for(i=0,j=0;i<TEST_BUF_LEN;i++,j++)
+		data_test_ptr[i] = (j<=255?j:(j=0,j));	
+
+
+	while(1)
+	{
+		msleep(10);
+		test_sdio_send_func();
+		break;
+	}	
+	
+	return 0;
+}
+
+void gaole_creat_test(void)
+{
+	struct task_struct * task;
+
+	task = kthread_create(gaole_test_thread, NULL, "GaoleTest");
+	if(0 != task)
+		wake_up_process(task);
+}
+#endif//SDIO_TEST_CASE9
+
+
-- 
cgit v1.3.1