diff options
Diffstat (limited to 'drivers/misc/sdiodev/sdio_dev_test.c')
| -rw-r--r-- | drivers/misc/sdiodev/sdio_dev_test.c | 1219 |
1 files changed, 1219 insertions, 0 deletions
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, ¶m); + + /*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, ¶m); + + 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, ¶m); + + 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, ¶m); + + 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, ¶m); + + 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, ¶m); + + 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, ¶m); + + 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, ¶m); + + 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 + + |