xref: /OK3568_Linux_fs/external/rk_pcba_test/echo_emmc_test.c (revision 4882a59341e53eb6f0b4789bf948001014eff981)
1*4882a593Smuzhiyun /*
2*4882a593Smuzhiyun  *  emmc_test.c  --  emmc test application
3*4882a593Smuzhiyun  *
4*4882a593Smuzhiyun  *  Copyright (c) 2017 Rockchip Electronics Co. Ltd.
5*4882a593Smuzhiyun  *  Author: Panzhenzhuan Wang <randy.wang@rock-chips.com>
6*4882a593Smuzhiyun  *
7*4882a593Smuzhiyun  * Licensed under the Apache License, Version 2.0 (the "License");
8*4882a593Smuzhiyun  * you may not use this file except in compliance with the License.
9*4882a593Smuzhiyun  * You may obtain a copy of the License at
10*4882a593Smuzhiyun  *
11*4882a593Smuzhiyun  * 	 http://www.apache.org/licenses/LICENSE-2.0
12*4882a593Smuzhiyun  *
13*4882a593Smuzhiyun  * Unless required by applicable law or agreed to in writing, software
14*4882a593Smuzhiyun  * distributed under the License is distributed on an "AS IS" BASIS,
15*4882a593Smuzhiyun  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16*4882a593Smuzhiyun  * See the License for the specific language governing permissions and
17*4882a593Smuzhiyun  * limitations under the License.
18*4882a593Smuzhiyun  */
19*4882a593Smuzhiyun 
20*4882a593Smuzhiyun #include <stdio.h>
21*4882a593Smuzhiyun #include <string.h>
22*4882a593Smuzhiyun #include <stdlib.h>
23*4882a593Smuzhiyun 
24*4882a593Smuzhiyun #include <sys/types.h>
25*4882a593Smuzhiyun #include <sys/stat.h>
26*4882a593Smuzhiyun #include <fcntl.h>
27*4882a593Smuzhiyun #include "unistd.h"
28*4882a593Smuzhiyun 
29*4882a593Smuzhiyun #include "emmc_test.h"
30*4882a593Smuzhiyun 
31*4882a593Smuzhiyun #define LOG_TAG "emmc_test"
32*4882a593Smuzhiyun #include "common.h"
33*4882a593Smuzhiyun 
34*4882a593Smuzhiyun 
35*4882a593Smuzhiyun #ifdef PCBA_PX3SE
36*4882a593Smuzhiyun #define EMMCPATH "/sys/bus/mmc/devices/mmc0:1234/block/mmcblk0/size"
37*4882a593Smuzhiyun #elif defined PCBA_356X
38*4882a593Smuzhiyun #define EMMCPATH "/sys/bus/mmc/devices/mmc2:0001/block/mmcblk2/size"
39*4882a593Smuzhiyun #else
40*4882a593Smuzhiyun #define EMMCPATH "/sys/bus/mmc/devices/mmc0:0001/block/mmcblk0/size"
41*4882a593Smuzhiyun #endif
42*4882a593Smuzhiyun 
43*4882a593Smuzhiyun #define READ_DDR_COMMAND "cat /proc/zoneinfo | busybox grep present | \
44*4882a593Smuzhiyun busybox awk 'BEGIN{a=0}{a+=$2}END{print a}'"
45*4882a593Smuzhiyun 
46*4882a593Smuzhiyun #define RKNAND_TEST_CMD "cat /proc/rknand > %s"
47*4882a593Smuzhiyun #define RKNAND_TEST_FILE "/tmp/rknand_test.txt"
48*4882a593Smuzhiyun 
49*4882a593Smuzhiyun 
50*4882a593Smuzhiyun /* for emmc  */
readFromFile(const char * path,char * emmcsize_char,size_t size)51*4882a593Smuzhiyun static int readFromFile(const char *path, char *emmcsize_char, size_t size)
52*4882a593Smuzhiyun {
53*4882a593Smuzhiyun 	if (!path)
54*4882a593Smuzhiyun 		return -1;
55*4882a593Smuzhiyun 
56*4882a593Smuzhiyun 	int fd = open(path, O_RDONLY|O_NOCTTY|O_NDELAY, 0);
57*4882a593Smuzhiyun 	if (fd == -1) {
58*4882a593Smuzhiyun 		printf("open '%s' failed!\n", path);
59*4882a593Smuzhiyun 		return -1;
60*4882a593Smuzhiyun 	}
61*4882a593Smuzhiyun 	ssize_t count = read(fd, emmcsize_char, size);
62*4882a593Smuzhiyun 
63*4882a593Smuzhiyun 	if (count > 0) {
64*4882a593Smuzhiyun 		while (count > 0 && emmcsize_char[count-1] == '\n')
65*4882a593Smuzhiyun 			count--;
66*4882a593Smuzhiyun 			emmcsize_char[count] = '\0';
67*4882a593Smuzhiyun 	} else {
68*4882a593Smuzhiyun 		emmcsize_char[0] = '\0';
69*4882a593Smuzhiyun 	}
70*4882a593Smuzhiyun 	close(fd);
71*4882a593Smuzhiyun 	return count;
72*4882a593Smuzhiyun }
73*4882a593Smuzhiyun 
get_emmc_size(char * size_data)74*4882a593Smuzhiyun int get_emmc_size(char *size_data)
75*4882a593Smuzhiyun {
76*4882a593Smuzhiyun     int count;
77*4882a593Smuzhiyun     int emmc_size=1;
78*4882a593Smuzhiyun     double size = (double)(atoi(size_data))/2/1024/1024;
79*4882a593Smuzhiyun 
80*4882a593Smuzhiyun     if (size > 0 && size <= 1)  /*1 GB */
81*4882a593Smuzhiyun         return 1;
82*4882a593Smuzhiyun     for (count = 1; count < 10; count++)
83*4882a593Smuzhiyun     {
84*4882a593Smuzhiyun         if ((size > emmc_size) && (size <= emmc_size*2))   /*2 - 512 GB*/
85*4882a593Smuzhiyun             return emmc_size*2;
86*4882a593Smuzhiyun 
87*4882a593Smuzhiyun         emmc_size *=2;
88*4882a593Smuzhiyun     }
89*4882a593Smuzhiyun     return -1;
90*4882a593Smuzhiyun }
91*4882a593Smuzhiyun 
92*4882a593Smuzhiyun #ifdef PCBA_PX3SE//emmc
emmc_test(void * argv)93*4882a593Smuzhiyun void *emmc_test(void *argv)
94*4882a593Smuzhiyun {
95*4882a593Smuzhiyun 	int emmc_ret = 0;
96*4882a593Smuzhiyun 	char emmcsize_char[20];
97*4882a593Smuzhiyun 	int emmc_size = 0;
98*4882a593Smuzhiyun 
99*4882a593Smuzhiyun 	int ddr_ret = 0;
100*4882a593Smuzhiyun 	char ddrsize_char[20];
101*4882a593Smuzhiyun 	int ddr_size = 0;
102*4882a593Smuzhiyun 	char cmd[128];
103*4882a593Smuzhiyun 
104*4882a593Smuzhiyun     printf("=======  emmc test starting   ========\n");
105*4882a593Smuzhiyun     //sprintf(cmd,"aplay %s/emmc_test_start.wav",AUDIO_PATH);
106*4882a593Smuzhiyun     //system(cmd);
107*4882a593Smuzhiyun     //system("aplay /data/test/emmc_test_start.wav");
108*4882a593Smuzhiyun 	/* For emmc */
109*4882a593Smuzhiyun 	memset(emmcsize_char, 0, sizeof(emmcsize_char));
110*4882a593Smuzhiyun 	emmc_ret = readFromFile(EMMCPATH, emmcsize_char, sizeof(emmcsize_char));
111*4882a593Smuzhiyun 
112*4882a593Smuzhiyun 	printf("readFromFile effective bytes is %d \n",emmc_ret);
113*4882a593Smuzhiyun 	if (emmc_ret >= 0) {  /*read back normal*/
114*4882a593Smuzhiyun 		emmc_size = get_emmc_size(emmcsize_char);
115*4882a593Smuzhiyun 		if(emmc_size < 0){
116*4882a593Smuzhiyun             emmc_ret = -1;
117*4882a593Smuzhiyun             goto fail;
118*4882a593Smuzhiyun         }
119*4882a593Smuzhiyun 		printf("=======  emmc_size is: %d GB ========\n",emmc_size);
120*4882a593Smuzhiyun 		if (EMMC_CAPACITY != emmc_size)
121*4882a593Smuzhiyun         {
122*4882a593Smuzhiyun             goto fail;
123*4882a593Smuzhiyun         }
124*4882a593Smuzhiyun 	}
125*4882a593Smuzhiyun 	else
126*4882a593Smuzhiyun 	{
127*4882a593Smuzhiyun 	    goto fail;
128*4882a593Smuzhiyun 	}
129*4882a593Smuzhiyun 	printf("=======  emmc_test success  ========\n");
130*4882a593Smuzhiyun 
131*4882a593Smuzhiyun 	return (void*)emmc_ret;
132*4882a593Smuzhiyun fail:
133*4882a593Smuzhiyun     printf("=======  emmc_test failed  ========\n");
134*4882a593Smuzhiyun 
135*4882a593Smuzhiyun     return (void*)emmc_ret;
136*4882a593Smuzhiyun }
137*4882a593Smuzhiyun #endif
138*4882a593Smuzhiyun 
139*4882a593Smuzhiyun #ifdef PCBA_3308
emmc_test(void * argv)140*4882a593Smuzhiyun void *emmc_test(void *argv)
141*4882a593Smuzhiyun {
142*4882a593Smuzhiyun     char cmd[128];
143*4882a593Smuzhiyun     char buf[128];
144*4882a593Smuzhiyun     FILE *fp;
145*4882a593Smuzhiyun 	int emmc_ret = -1;
146*4882a593Smuzhiyun 
147*4882a593Smuzhiyun     printf("=======  emmc test starting   ========\n");
148*4882a593Smuzhiyun 
149*4882a593Smuzhiyun     sprintf(cmd,RKNAND_TEST_CMD,RKNAND_TEST_FILE);
150*4882a593Smuzhiyun     system(cmd);
151*4882a593Smuzhiyun     printf("cmd is: %s.\n",cmd);
152*4882a593Smuzhiyun     sleep(1);
153*4882a593Smuzhiyun 
154*4882a593Smuzhiyun     fp = fopen(RKNAND_TEST_FILE, "r");
155*4882a593Smuzhiyun     if (!fp)
156*4882a593Smuzhiyun     {
157*4882a593Smuzhiyun         printf("%s fopen err:%s\n",__func__,strerror(errno));
158*4882a593Smuzhiyun         return (void*)-1;
159*4882a593Smuzhiyun     }
160*4882a593Smuzhiyun 
161*4882a593Smuzhiyun     while(!feof(fp))
162*4882a593Smuzhiyun     {
163*4882a593Smuzhiyun         fgets(buf,sizeof(buf),fp);
164*4882a593Smuzhiyun          if(strstr(buf,"Device Capacity: 256 MB")!=NULL)
165*4882a593Smuzhiyun          {
166*4882a593Smuzhiyun              emmc_ret = 0;
167*4882a593Smuzhiyun              break;
168*4882a593Smuzhiyun          }
169*4882a593Smuzhiyun     }
170*4882a593Smuzhiyun     fclose(fp);
171*4882a593Smuzhiyun     remove(RKNAND_TEST_FILE);
172*4882a593Smuzhiyun 
173*4882a593Smuzhiyun     printf("\n=================== function :%s finish======================\n",__func__);
174*4882a593Smuzhiyun     return (void*)emmc_ret;
175*4882a593Smuzhiyun }
176*4882a593Smuzhiyun #endif
177*4882a593Smuzhiyun 
178*4882a593Smuzhiyun #ifdef PCBA_1808
179*4882a593Smuzhiyun // TODO: add 1808 emmc test code here.
emmc_test(void * argv)180*4882a593Smuzhiyun void *emmc_test(void *argv)
181*4882a593Smuzhiyun {
182*4882a593Smuzhiyun     return 0;
183*4882a593Smuzhiyun }
184*4882a593Smuzhiyun 
185*4882a593Smuzhiyun #endif
186*4882a593Smuzhiyun 
187*4882a593Smuzhiyun #ifdef PCBA_3326
188*4882a593Smuzhiyun // TODO: add 3326 emmc test code here.
emmc_test(void * argv)189*4882a593Smuzhiyun void *emmc_test(void *argv)
190*4882a593Smuzhiyun {
191*4882a593Smuzhiyun     return 0;
192*4882a593Smuzhiyun }
193*4882a593Smuzhiyun 
194*4882a593Smuzhiyun #endif
195*4882a593Smuzhiyun 
196*4882a593Smuzhiyun #ifdef PCBA_PX30
197*4882a593Smuzhiyun // TODO: add PX30 emmc test code here.
emmc_test(void * argv)198*4882a593Smuzhiyun void *emmc_test(void *argv)
199*4882a593Smuzhiyun {
200*4882a593Smuzhiyun     return 0;
201*4882a593Smuzhiyun }
202*4882a593Smuzhiyun #endif
203*4882a593Smuzhiyun 
204*4882a593Smuzhiyun #ifdef PCBA_3288
205*4882a593Smuzhiyun // TODO: add 3288 emmc test code here.
emmc_test(void * argv)206*4882a593Smuzhiyun void *emmc_test(void *argv)
207*4882a593Smuzhiyun {
208*4882a593Smuzhiyun     return 0;
209*4882a593Smuzhiyun }
210*4882a593Smuzhiyun #endif
211*4882a593Smuzhiyun 
212*4882a593Smuzhiyun #ifdef PCBA_3328
213*4882a593Smuzhiyun // TODO: add 3328 emmc test code here.
emmc_test(void * argv)214*4882a593Smuzhiyun void *emmc_test(void *argv)
215*4882a593Smuzhiyun {
216*4882a593Smuzhiyun     return 0;
217*4882a593Smuzhiyun }
218*4882a593Smuzhiyun #endif
219*4882a593Smuzhiyun 
220*4882a593Smuzhiyun #ifdef PCBA_3399
221*4882a593Smuzhiyun // TODO: add 3399 emmc test code here.
emmc_test(void * argv)222*4882a593Smuzhiyun void *emmc_test(void *argv)
223*4882a593Smuzhiyun {
224*4882a593Smuzhiyun     return 0;
225*4882a593Smuzhiyun }
226*4882a593Smuzhiyun 
227*4882a593Smuzhiyun #endif
228*4882a593Smuzhiyun 
229*4882a593Smuzhiyun #ifdef PCBA_3399PRO
230*4882a593Smuzhiyun // TODO: add 3399PRO emmc test code here.
emmc_test(void * argv)231*4882a593Smuzhiyun void *emmc_test(void *argv)
232*4882a593Smuzhiyun {
233*4882a593Smuzhiyun     return 0;
234*4882a593Smuzhiyun }
235*4882a593Smuzhiyun #endif
236*4882a593Smuzhiyun 
237*4882a593Smuzhiyun #ifdef PCBA_1126_1109
238*4882a593Smuzhiyun // TODO: add rv1126/1109 emmc test code here.
emmc_test(void * argv)239*4882a593Smuzhiyun void *emmc_test(void *argv)
240*4882a593Smuzhiyun {
241*4882a593Smuzhiyun     return 0;
242*4882a593Smuzhiyun }
243*4882a593Smuzhiyun #endif
244*4882a593Smuzhiyun 
245*4882a593Smuzhiyun #ifdef PCBA_356X
246*4882a593Smuzhiyun // TODO: add 356X emmc test code here.
emmc_test(void * argv)247*4882a593Smuzhiyun void *emmc_test(void *argv)
248*4882a593Smuzhiyun {
249*4882a593Smuzhiyun 	int emmc_ret = 0;
250*4882a593Smuzhiyun 	char emmcsize_char[20];
251*4882a593Smuzhiyun 	int emmc_size = 0;
252*4882a593Smuzhiyun 
253*4882a593Smuzhiyun 	int ddr_ret = 0;
254*4882a593Smuzhiyun 	char ddrsize_char[20];
255*4882a593Smuzhiyun 	int ddr_size = 0;
256*4882a593Smuzhiyun 	char cmd[128];
257*4882a593Smuzhiyun 
258*4882a593Smuzhiyun     printf("=======  emmc test starting   ========\n");
259*4882a593Smuzhiyun     //sprintf(cmd,"aplay %s/emmc_test_start.wav",AUDIO_PATH);
260*4882a593Smuzhiyun     //system(cmd);
261*4882a593Smuzhiyun     //system("aplay /data/test/emmc_test_start.wav");
262*4882a593Smuzhiyun 	/* For emmc */
263*4882a593Smuzhiyun 	memset(emmcsize_char, 0, sizeof(emmcsize_char));
264*4882a593Smuzhiyun 	emmc_ret = readFromFile(EMMCPATH, emmcsize_char, sizeof(emmcsize_char));
265*4882a593Smuzhiyun 
266*4882a593Smuzhiyun 	printf("readFromFile effective bytes is %d \n",emmc_ret);
267*4882a593Smuzhiyun 	if (emmc_ret >= 0) {  /*read back normal*/
268*4882a593Smuzhiyun 		emmc_size = get_emmc_size(emmcsize_char);
269*4882a593Smuzhiyun 		if(emmc_size < 0){
270*4882a593Smuzhiyun             emmc_ret = -1;
271*4882a593Smuzhiyun             goto fail;
272*4882a593Smuzhiyun         }
273*4882a593Smuzhiyun 		printf("=======  emmc_size is: %d GB ========\n",emmc_size);
274*4882a593Smuzhiyun 		if (EMMC_CAPACITY != emmc_size)
275*4882a593Smuzhiyun         {
276*4882a593Smuzhiyun             goto fail;
277*4882a593Smuzhiyun         }
278*4882a593Smuzhiyun 	}
279*4882a593Smuzhiyun 	else
280*4882a593Smuzhiyun 	{
281*4882a593Smuzhiyun 	    goto fail;
282*4882a593Smuzhiyun 	}
283*4882a593Smuzhiyun 	printf("=======  emmc_test success  ========\n");
284*4882a593Smuzhiyun 
285*4882a593Smuzhiyun 	return (void*)emmc_ret;
286*4882a593Smuzhiyun fail:
287*4882a593Smuzhiyun     printf("=======  emmc_test failed  ========\n");
288*4882a593Smuzhiyun 
289*4882a593Smuzhiyun     return (void*)emmc_ret;
290*4882a593Smuzhiyun }
291*4882a593Smuzhiyun #endif
292*4882a593Smuzhiyun 
293*4882a593Smuzhiyun #ifdef PCBA_3588
294*4882a593Smuzhiyun // TODO: add 3588 emmc test code here.
emmc_test(void * argv)295*4882a593Smuzhiyun void *emmc_test(void *argv)
296*4882a593Smuzhiyun {
297*4882a593Smuzhiyun     return 0;
298*4882a593Smuzhiyun }
299*4882a593Smuzhiyun #endif
300*4882a593Smuzhiyun 
main(int argc,char * argv[])301*4882a593Smuzhiyun int main(int argc, char *argv[])
302*4882a593Smuzhiyun {
303*4882a593Smuzhiyun     int test_flag = 0,err_code = 0;
304*4882a593Smuzhiyun     char buf[COMMAND_VALUESIZE] = "emmc_test";
305*4882a593Smuzhiyun     char result[COMMAND_VALUESIZE] = RESULT_PASS;
306*4882a593Smuzhiyun     test_flag = (int)emmc_test(argv[0]);
307*4882a593Smuzhiyun     if(test_flag < 0)
308*4882a593Smuzhiyun     {
309*4882a593Smuzhiyun         strcpy(result,RESULT_FAIL);
310*4882a593Smuzhiyun         err_code = EMMC_PROC_ERR;
311*4882a593Smuzhiyun     }
312*4882a593Smuzhiyun     send_msg_to_server(buf, result, err_code);
313*4882a593Smuzhiyun }
314