projects / GitHub / mt8127 / android_kernel_alcatel_ttab.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
import PULS_20160108
[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / misc / mediatek / eemcs / eemcs_fs_ut.c
1 /*******************************************************************************
2 * Filename:
3 * ---------
4 * eemcs_fs_ut.c
5 *
6 * Project:
7 * --------
8 * MOLY
9 *
10 * Description:
11 * ------------
12 * Implements the CCCI FS unit test functions
13 *
14 * Author:
15 * -------
16 *
17 * ==========================================================================
18 * $Log$
19 *
20 * 07 03 2013 ian.cheng
21 * [ALPS00837674] [LTE_MD] EEMCS ALPS.JB5.82LTE.DEV migration
22 * [eemcs migration]
23 *
24 * 05 27 2013 ian.cheng
25 * [ALPS00741900] [EEMCS] Modify device major number to 183
26 * 1. update eemcs major number to 183
27 * 2. fix typo of CCCI_CHNNEL_T
28 *
29 * 04 28 2013 ian.cheng
30 * [ALPS00612780] [EEMCS] Submit EEMCS to ALPS.JB2.MT6582.MT6290.BSP.DEV
31 * 1. merge mediatek/kernel/drivers/eemcs to dev branch
32 * 2. merge mdediatek/kernel/drivers/net/lte_hdrv_em to dev branch
33 *
34 ****************************************************************************/
35
36 #include <linux/module.h>
37 #include <linux/limits.h>
38 #include <linux/nls.h>
39 #include <linux/wait.h>
40
41 #include "eemcs_kal.h"
42 #include "eemcs_ccci.h"
43 #include "eemcs_debug.h"
44 #include "eemcs_char.h"
45 #include "eemcs_file_ops.h"
46 #include "eemcs_fs_ut.h"
47
48
49 #ifdef _EEMCS_FS_UT
50 //=============================================================================
51 // CCCI FS Definition
52 //=============================================================================
53 #define FS_CCCI_EXCEPT_MAX_RETRY 7
54 #define FS_CCCI_MAX_RETRY 0xFFFF
55 #define FS_CCCI_REQ_BUFFER_NUM 5 // support concurrently request
56 #define FS_CCCI_MAX_ARG_NUM 6 // max parameter number
57 #define FS_CCCI_MAX_DATA_REQUEST 0x4000 // 16 KB
58 // FS_MAX_BUF_SIZE : argc + arg(0~5).len + arg(1~5).data + 16KB data
59 #define FS_CCCI_MAX_BUF_SIZE (FS_CCCI_MAX_DATA_REQUEST + 12 * sizeof(unsigned int))
60 #define FS_CCCI_API_RESP_ID 0xFFFF0000
61
62 #define MD_ROOT_DIR "Z:"
63 #define DSP_ROOT_DIR "Y:"
64 #define FS_ROOT_DIR "/data/nvram/md1"
65 #define FS_DSP_ROOT_DIR "/system/etc/firmware"
66
67 #define MAX_FS_PKT_BYTE (0x1000 - 128)
68 #define CCCI_FS_REQ_SEND_AGAIN 0x80000000
69 #define CCCI_FS_PEER_REQ_SEND_AGAIN(_p) (((((CCCI_BUFF_T*)(_p))->data[0] & CCCI_FS_REQ_SEND_AGAIN) != 0)? 1: 0)
70
71 //=============================================================================
72 // Parameters for APIs, sync with eemcs_fsd
73 //=============================================================================
74
75 /* FS_GetDrive Parameter */
76 #define FS_NO_ALT_DRIVE 0x00000001
77 #define FS_ONLY_ALT_SERIAL 0x00000002
78 #define FS_DRIVE_I_SYSTEM 0x00000004
79 #define FS_DRIVE_V_NORMAL 0x00000008
80 #define FS_DRIVE_V_REMOVABLE 0x00000010
81 #define FS_DRIVE_V_EXTERNAL 0x00000020
82 #define FS_DRIVE_V_SIMPLUS 0x00000040
83 #define FS_DRIVE_I_SYSTEM_DSP 0x00000080
84
85 /* FS_Move, FS_Count, FS_GetFolderSize, FS_XDelete, FS_XFindReset (Sorting) Parameter and Flag Passing */
86 #define FS_MOVE_COPY 0x00000001
87 #define FS_MOVE_KILL 0x00000002
88
89 #define FS_FILE_TYPE 0x00000004 // Recursive Type API Common, Public
90 #define FS_DIR_TYPE 0x00000008 // Recursive Type API Common, Public
91 #define FS_RECURSIVE_TYPE 0x00000010 // Recursive Type API Common, Public
92
93 /* FS_Open Parameter */
94 #define FS_READ_WRITE 0x00000000L
95 #define FS_READ_ONLY 0x00000100L
96 #define FS_OPEN_SHARED 0x00000200L
97 #define FS_OPEN_NO_DIR 0x00000400L
98 #define FS_OPEN_DIR 0x00000800L
99 #define FS_CREATE 0x00010000L
100 #define FS_CREATE_ALWAYS 0x00020000L
101 #define FS_COMMITTED 0x01000000L
102 #define FS_CACHE_DATA 0x02000000L
103 #define FS_LAZY_DATA 0x04000000L
104 #define FS_NONBLOCK_MODE 0x10000000L
105 #define FS_PROTECTION_MODE 0x20000000L
106
107 /* Quota Management */
108 #define FS_QMAX_NO_LIMIT 0xf1f2f3f4 //~3.8GB
109 #define FS_COUNT_IN_BYTE 0x00000001
110 #define FS_COUNT_IN_CLUSTER 0x00000002
111
112 /* --------------------- FS ERROR CODE ---------------------- */
113 #define FS_NO_ERROR 0
114 #define FS_ERROR_RESERVED -1
115 #define FS_PARAM_ERROR -2
116 #define FS_INVALID_FILENAME -3
117 #define FS_DRIVE_NOT_FOUND -4
118 #define FS_TOO_MANY_FILES -5
119 #define FS_NO_MORE_FILES -6
120 #define FS_WRONG_MEDIA -7
121 #define FS_INVALID_FILE_SYSTEM -8
122 #define FS_FILE_NOT_FOUND -9
123 #define FS_INVALID_FILE_HANDLE -10
124 #define FS_UNSUPPORTED_DEVICE -11
125 #define FS_UNSUPPORTED_DRIVER_FUNCTION -12
126 #define FS_CORRUPTED_PARTITION_TABLE -13
127 #define FS_TOO_MANY_DRIVES -14
128 #define FS_INVALID_FILE_POS -15
129 #define FS_ACCESS_DENIED -16
130 #define FS_STRING_BUFFER_TOO_SAMLL -17
131 #define FS_GENERAL_FAILURE -18
132 #define FS_PATH_NOT_FOUND -19
133 #define FS_FAT_ALLOC_ERROR -20
134 #define FS_ROOT_DIR_FULL -21
135 #define FS_DISK_FULL -22
136 #define FS_TIMEOUT -23
137 #define FS_BAD_SECTOR -24
138 #define FS_DATA_ERROR -25
139 #define FS_MEDIA_CHANGED -26
140 #define FS_SECTOR_NOT_FOUND -27
141 #define FS_ADDRESS_MARK_NOT_FOUND -28
142 #define FS_DRIVE_NOT_READY -29
143 #define FS_WRITE_PROTECTION -30
144 #define FS_DMA_OVERRUN -31
145 #define FS_CRC_ERROR -32
146 #define FS_DEVICE_RESOURCE_ERROR -33
147 #define FS_INVALID_SECTOR_SIZE -34
148 #define FS_OUT_OF_BUFFERS -35
149 #define FS_FILE_EXISTS -36
150 #define FS_LONG_FILE_POS -37
151 #define FS_FILE_TOO_LARGE -38
152 #define FS_BAD_DIR_ENTRY -39
153 #define FS_ATTR_CONFLICT -40
154 #define FS_CHECKDISK_RETRY -41
155 #define FS_LACK_OF_PROTECTION_SPACE -42
156 #define FS_SYSTEM_CRASH -43
157 #define FS_FAIL_GET_MEM -44
158 #define FS_READ_ONLY_ERROR -45
159 #define FS_DEVICE_BUSY -46
160 #define FS_ABORTED_ERROR -47
161 #define FS_QUOTA_OVER_DISK_SPACE -48
162 #define FS_PATH_OVER_LEN_ERROR -49
163 #define FS_APP_QUOTA_FULL -50
164 #define FS_VF_MAP_ERROR -51
165 #define FS_DEVICE_EXPORTED_ERROR -52
166 #define FS_DISK_FRAGMENT -53
167 #define FS_DIRCACHE_EXPIRED -54
168 #define FS_QUOTA_USAGE_WARNING -55
169
170 #define FS_MSDC_MOUNT_ERROR -100
171 #define FS_MSDC_READ_SECTOR_ERROR -101
172 #define FS_MSDC_WRITE_SECTOR_ERROR -102
173 #define FS_MSDC_DISCARD_SECTOR_ERROR -103
174 #define FS_MSDC_PRESENT_NOT_READY -104
175 #define FS_MSDC_NOT_PRESENT -105
176
177 #define FS_EXTERNAL_DEVICE_NOT_PRESENT -106
178 #define FS_HIGH_LEVEL_FORMAT_ERROR -107
179
180 #define FS_FLASH_MOUNT_ERROR -120
181 #define FS_FLASH_ERASE_BUSY -121
182 #define FS_NAND_DEVICE_NOT_SUPPORTED -122
183 #define FS_FLASH_OTP_UNKNOWERR -123
184 #define FS_FLASH_OTP_OVERSCOPE -124
185 #define FS_FLASH_OTP_WRITEFAIL -125
186 #define FS_FDM_VERSION_MISMATCH -126
187 #define FS_FLASH_OTP_LOCK_ALREADY -127
188 #define FS_FDM_FORMAT_ERROR -128
189
190 #define FS_LOCK_MUTEX_FAIL -141
191 #define FS_NO_NONBLOCKMODE -142
192 #define FS_NO_PROTECTIONMODE -143
193
194 #define FS_INTERRUPT_BY_SIGNAL -512
195
196
197 typedef struct {
198 __packed char FileName[8];
199 __packed char Extension[3];
200 __packed char Attributes;
201 __packed char NTReserved;
202 __packed char CreateTimeTenthSecond;
203 __packed int CreateDateTime;
204 __packed unsigned short LastAccessDate;
205 __packed unsigned short FirstClusterHi;
206 __packed int DateTime;
207 __packed unsigned short FirstCluster;
208 __packed unsigned int FileSize;
209 // FS_FileOpenHint members (!Note that RTFDOSDirEntry structure is not changed!)
210 unsigned int Cluster;
211 unsigned int Index;
212 unsigned int Stamp;
213 unsigned int Drive;
214 unsigned int SerialNumber;
215 } FS_DOSDirEntry;
216
217 //=============================================================================
218 // FS UT Definition
219 //=============================================================================
220
221 #define FS_UT_TEST_FILE_DIR "/data/app"
222 #define FS_UT_1K_FILE "fs_ut_1k.dat"
223 #define FS_UT_2K_FILE "fs_ut_2k.dat"
224 #define FS_UT_4K_FILE "fs_ut_4k.dat"
225 #define FS_UT_6K_FILE "fs_ut_6k.dat"
226 #define FS_UT_8K_FILE "fs_ut_8k.dat"
227 #define FS_UT_10K_FILE "fs_ut_10k.dat"
228 #define FS_UT_12K_FILE "fs_ut_12k.dat"
229 #define FS_UT_14K_FILE "fs_ut_14k.dat"
230 #define FS_UT_16K_FILE "fs_ut_16k.dat"
231 #define FS_UT_PORT_INDEX (1)
232
233 //#define _EEMCS_FS_UT_DBG_PKT // Debug Incomming and Outgoing Command Buffer
234
235 #ifdef _EEMCS_FS_UT_DBG_PKT
236 #define dump_data_to_file(file,data,size) save_data_to_file
237 #else
238 #define dump_data_to_file(file,data,size)
239 #endif
240
241
242 //=============================================================================
243 // Type Definition
244 //=============================================================================
245
246 /* Drive enumeration for testing */
247 typedef enum EEMCS_FS_TEST_DRV_e {
248 DRV_MD = 0,
249 DRV_MD_DSP,
250 DRV_CNT,
251 } EEMCS_FS_TEST_DRV;
252
253 /* FS Operation ID */
254 typedef enum
255 {
256 FS_CCCI_OP_PEEK = 0, // peek the content in FS_REQ_BUF
257 FS_CCCI_OP_OPEN = 0x1001,
258 FS_CCCI_OP_SEEK,
259 FS_CCCI_OP_READ,
260 FS_CCCI_OP_WRITE,
261 FS_CCCI_OP_CLOSE,
262 FS_CCCI_OP_CLOSEALL,
263 FS_CCCI_OP_CREATEDIR,
264 FS_CCCI_OP_REMOVEDIR,
265 FS_CCCI_OP_GETFILESIZE,
266 FS_CCCI_OP_GETFOLDERSIZE,
267 FS_CCCI_OP_RENAME,
268 FS_CCCI_OP_MOVE,
269 FS_CCCI_OP_COUNT,
270 FS_CCCI_OP_GETDISKINFO,
271 FS_CCCI_OP_DELETE,
272 FS_CCCI_OP_GETATTRIBUTES,
273 FS_CCCI_OP_OPENHINT,
274 FS_CCCI_OP_FINDFIRST,
275 FS_CCCI_OP_FINDNEXT,
276 FS_CCCI_OP_FINDCLOSE,
277 FS_CCCI_OP_LOCKFAT,
278 FS_CCCI_OP_UNLOCKALL,
279 FS_CCCI_OP_SHUTDOWN,
280 FS_CCCI_OP_XDELETE,
281 FS_CCCI_OP_CLEARDISKFLAG,
282 FS_CCCI_OP_GETDRIVE,
283 FS_CCCI_OP_GETCLUSTERSIZE,
284 FS_CCCI_OP_SETDISKFLAG,
285 FS_CCCI_OP_OTPWRITE,
286 FS_CCCI_OP_OTPREAD,
287 FS_CCCI_OP_OTPQUERYLENGTH,
288 FS_CCCI_OP_OTPLOCK,
289 FS_CCCI_OP_RESTORE = 0x1021,
290 /* Following are for FS UT only */
291 FS_CCCI_OP_REPEAT_START,
292 FS_CCCI_OP_REPEAT_END,
293 } FS_CCCI_OP_ID_T;
294
295 /* Enumeration of receiving buffer status */
296 typedef enum EEMCS_FS_BUFF_STATUS_e {
297 CCCI_FS_BUFF_IDLE = 0, // current port is not waiting for more data
298 CCCI_FS_BUFF_WAIT // current port is waiting for more data to come in
299 } EEMCS_FS_BUFF_STATUS;
300
301 typedef struct FS_CCCI_LV_STRUC {
302 KAL_UINT32 len;
303 void *val;
304 } FS_CCCI_LV_T;
305
306 typedef struct CCCI_FS_PARA {
307 KAL_INT32 index; // port index
308 KAL_UINT32 op_id; // FS_CCCI_OP_ID_T
309 FS_CCCI_LV_T *pLV_in; // [IN] CCCI_FS local variable
310 KAL_UINT32 LV_in_para_cnt; // [IN] parameter count in LV
311 FS_CCCI_LV_T *pLV_out; // [OUT] CCCI_FS local variable
312 KAL_UINT32 LV_out_para_cnt; // [OUT] parameter count in LV
313 } CCCI_FS_PARA_T;
314
315 typedef struct FS_STREAMBUFFER_st {
316 CCCI_BUFF_T ccci_header;
317 KAL_UINT32 fs_operationID;
318 KAL_UINT8 buffer[FS_CCCI_MAX_BUF_SIZE];
319 } FS_STREAMBUFFER;
320
321 typedef struct EEMCS_FS_UT_SET_st {
322 /* FS UT Variables */
323 volatile KAL_INT32 ut_port_index; // the port indicator currently in operation
324 KAL_UINT32 test_case_idx; // test case indicator currently in progress
325 KAL_UINT32 ftest_idx; // test file indicator currently in operation
326 KAL_UINT32 drive_idx; // test drive indicator currently in operation
327 KAL_INT32 fhandle; // file handle currently in use
328 KAL_INT32 find_handle; // find handle currently in use
329 KAL_UINT32 fs_write_total; // data in bytes currently write to AP
330 KAL_UINT32 loop_start; // start indicator of loop to do file test
331 KAL_UINT32 loop_end; // end indicator of loop to do file test
332
333 /* FS request buffer FS_REQ_BUF[FS_CCCI_REQ_BUFFER_NUM][FS_CCCI_MAX_BUF_SIZE] */
334 FS_STREAMBUFFER FS_REQ_BUF[FS_CCCI_REQ_BUFFER_NUM];
335 /* use to identify the current hwo rgpd count, ccci_fs_buff_status */
336 KAL_UINT32 ccci_fs_buff_state[FS_CCCI_REQ_BUFFER_NUM];
337 /* recording the current buffer offset in FS_REQ_BUF */
338 KAL_UINT32 ccci_fs_buff_offset[FS_CCCI_REQ_BUFFER_NUM];
339 } EEMCS_FS_UT_SET;
340
341 /* Drive information for testing */
342 typedef struct EEMCS_FS_TEST_DRIVE_st {
343 KAL_UINT32 id; // Drvie enumeration defined in EEMCS_FS_TEST_DRV
344 char drive[NAME_MAX]; // Drvie name in modem side
345 char fs_root[NAME_MAX]; // File system path mapped in AP side
346 KAL_UINT32 type; // Drive type defined in modem side
347 } EEMCS_FS_TEST_DRIVE;
348
349 /* File information for testing */
350 typedef struct EEMCS_FS_TEST_FILE_st {
351 char name[NAME_MAX]; // File name
352 KAL_UINT32 size; // File size
353 } EEMCS_FS_TEST_FILE;
354
355 /* Test case information for testing */
356 typedef struct EEMCS_FS_TEST_CASE_st {
357 KAL_UINT32 index; // Test case index
358 KAL_UINT32 op_id; // Operation ID
359 char reserved[NAME_MAX]; // Reserved part for different purpose
360 } EEMCS_FS_TEST_CASE;
361
362
363 //=============================================================================
364 // Global Variables
365 //=============================================================================
366
367 EEMCS_FS_UT_SET g_eemcs_fs_ut;
368
369 /* Drive list for FS UT */
370 const static EEMCS_FS_TEST_DRIVE g_test_drive[] = {
371 { DRV_MD, MD_ROOT_DIR, FS_ROOT_DIR, FS_DRIVE_I_SYSTEM },
372 { DRV_MD_DSP, DSP_ROOT_DIR, FS_DSP_ROOT_DIR, FS_DRIVE_I_SYSTEM_DSP }
373 };
374 #define EEMCS_FS_TEST_DRV_CNT sizeof(g_test_drive)/sizeof(g_test_drive[0])
375
376 /* File list for FS UT */
377 const static EEMCS_FS_TEST_FILE g_test_file[] = {
378 { FS_UT_1K_FILE, 1 * 1024 },
379 { FS_UT_2K_FILE, 2 * 1024 },
380 { FS_UT_4K_FILE, 4 * 1024 },
381 { FS_UT_6K_FILE, 6 * 1024 },
382 { FS_UT_8K_FILE, 8 * 1024 },
383 { FS_UT_10K_FILE, 10 * 1024, },
384 { FS_UT_12K_FILE, 12 * 1024, },
385 { FS_UT_14K_FILE, 14 * 1024, },
386 { FS_UT_16K_FILE, 16 * 1024, }
387 };
388 #define EEMCS_FS_TEST_FILE_CNT sizeof(g_test_file)/sizeof(g_test_file[0])
389
390 /* Command list for FS UT */
391 EEMCS_FS_TEST_CASE g_test_case[] = {
392 { 0, FS_CCCI_OP_GETDRIVE, "" },
393 { 0, FS_CCCI_OP_GETCLUSTERSIZE, "" },
394 { 0, FS_CCCI_OP_CREATEDIR, "fsut_dir" }, // directory to be created
395 { 0, FS_CCCI_OP_CREATEDIR, "fsut_dir/lv2_dir" }, // directory to be created
396 { 0, FS_CCCI_OP_REMOVEDIR, "fsut_dir/lv2_dir" }, // directory to be removed
397 { 0, FS_CCCI_OP_CREATEDIR, "fsut_dir/lv2_dir" }, // directory to be created
398
399 { 0, FS_CCCI_OP_REPEAT_START, "" },
400 { 0, FS_CCCI_OP_OPEN, "" },
401 { 0, FS_CCCI_OP_WRITE, "" },
402 { 0, FS_CCCI_OP_GETFILESIZE, "" },
403 { 0, FS_CCCI_OP_CLOSE, "" },
404 { 0, FS_CCCI_OP_OPEN, "" },
405 { 0, FS_CCCI_OP_READ, "" },
406 { 0, FS_CCCI_OP_CLOSE, "" },
407 { 0, FS_CCCI_OP_MOVE, "fsut_dir/lv2_dir" }, // destination directory for the files to move to
408 { 0, FS_CCCI_OP_RENAME, "renamed_" }, // prefix of the renamed file name
409 { 0, FS_CCCI_OP_DELETE, "renamed_" }, // prefix of the file name to delete
410 { 0, FS_CCCI_OP_REPEAT_END, "" },
411
412 { 0, FS_CCCI_OP_GETFOLDERSIZE, "fsut_dir/lv2_dir" }, // directory to get size
413 { 0, FS_CCCI_OP_COUNT, "fsut_dir/lv2_dir" }, // directory to get file number
414 { 0, FS_CCCI_OP_FINDFIRST, "fsut_dir/lv2_dir/fs_ut_*" },// pattern to find
415 { 0, FS_CCCI_OP_FINDNEXT, "" },
416 { 0, FS_CCCI_OP_FINDCLOSE, "" },
417 { 0, FS_CCCI_OP_XDELETE, "fsut_dir" }, // directory to be removed
418 };
419 #define EEMCS_FS_TEST_CASE_CNT sizeof(g_test_case)/sizeof(g_test_case[0])
420
421 /* Global variables to keep incomming and outgoing arguments */
422 FS_CCCI_LV_T g_LV_in[FS_CCCI_MAX_ARG_NUM];
423 FS_CCCI_LV_T g_LV_out[FS_CCCI_MAX_ARG_NUM];
424 KAL_UINT32 g_LV_in_num = 0;
425 KAL_UINT32 g_LV_out_num = 0;
426 CCCI_FS_PARA_T g_ccci_fs_paras;
427
428 /* Command debug indicator */
429 static volatile KAL_UINT32 op_read_cnt = 0; // Indicator of FS_CCCI_OP_READ
430 static volatile KAL_UINT32 md2ap_cmd_cnt = 0; // Indicator of MD to AP commands
431 static volatile KAL_UINT32 ap2md_cmd_cnt = 0; // Indicator of AP to MD commands
432
433
434 //=============================================================================
435 // Forward Declaration
436 //=============================================================================
437
438 KAL_INT32 eemcs_fs_ut_send_cmd(void);
439
440
441 //=============================================================================
442 // Implemenataion
443 //=============================================================================
444
445 /*
446 * @brief Generate a file with test data
447 * @param
448 * file [in] The file name with full path
449 * size [in] The file size you want
450 * @return
451 * KAL_SUCCESS is returned indicates success;
452 * KAL_FAIL otherwise.
453 */
454 KAL_INT32 gen_ap_random_file(char *file, KAL_UINT32 size)
455 {
456 struct file *fp = NULL;
457 KAL_UINT32 i = 0;
458 char data = 0;
459 int ret = 0;
460 DEBUG_LOG_FUNCTION_ENTRY;
461
462 fp = file_open(file, O_RDWR | O_CREAT, 0777);
463 if (fp == NULL) {
464 DBGLOG(FSUT, ERR, "[FSUT] Failed to generate test file %s", file);
465 DEBUG_LOG_FUNCTION_LEAVE;
466 return KAL_FAIL;
467 }
468
469 do {
470 for (i = 0; i < size; i++) {
471 ret = file_write(fp, &data, sizeof(char));
472 if (ret <= 0) {
473 DBGLOG(FSUT, ERR, "[FSUT] Failed to write to file (%d) !!", i);
474 }
475 data++;
476 }
477 } while(0);
478 file_close(fp);
479 DEBUG_LOG_FUNCTION_LEAVE;
480 return KAL_SUCCESS;
481 }
482
483 /*
484 * @brief Get data from a file
485 * @param
486 * file [in] The file name with full path
487 * size [in] The data size you want to get from the file
488 * @return
489 * A non-null data pointer is returned indicates success;
490 * NULL otherwise.
491 */
492 void *get_file_data(char *file, KAL_UINT32 size)
493 {
494 void *data = NULL;
495 struct file *fp = NULL;
496 KAL_INT32 result = KAL_FAIL;
497 DEBUG_LOG_FUNCTION_ENTRY;
498
499 KAL_ASSERT(file != NULL);
500 /* Open test file */
501 fp = file_open(file, O_RDONLY, 0777);
502 if (fp == NULL) {
503 DBGLOG(FSUT, ERR, "[FSUT] Failed to open test file %s", file);
504 goto _open_fail;
505 }
506 /* Allocate memory to store data */
507 data = kmalloc(size, GFP_KERNEL);
508 if (data == NULL) {
509 DBGLOG(FSUT, ERR, "[FSUT] Failed to allocate memory");
510 goto _alloc_fail;
511 }
512 result = file_read(fp, data, size);
513 if (result != size) {
514 DBGLOG(FSUT, ERR, "[FSUT] Failed to read test file (%d)", result);
515 goto _read_fail;
516 }
517 goto _ok;
518
519 _read_fail:
520 kfree(data);
521 _alloc_fail:
522 _ok:
523 file_close(fp);
524 _open_fail:
525 DEBUG_LOG_FUNCTION_LEAVE;
526 return data;
527 }
528
529 /*
530 * @brief Get data from the test file
531 * @param
532 * index [in] The file index in global variable g_test_file
533 * @return
534 * A non-NULL data pointer is returned indicates success;
535 * NULL otherwise.
536 */
537 void *get_test_file_data(KAL_UINT32 index)
538 {
539 char src[NAME_MAX] = {0};
540
541 sprintf(src, "%s/%s", FS_UT_TEST_FILE_DIR, g_test_file[index].name);
542 return get_file_data(src, g_test_file[index].size);
543 }
544
545 /*
546 * @brief Destroy file data
547 * @param
548 * data [in] A data pointer returned from get_file_data()
549 * @return
550 * None
551 */
552 void destroy_file_data(void *data)
553 {
554 DEBUG_LOG_FUNCTION_ENTRY;
555 if (data != NULL) {
556 kfree(data);
557 }
558 DEBUG_LOG_FUNCTION_LEAVE;
559 }
560
561 static int FS_ConvWcsToCs(const wchar_t* strScr, char* strDst, unsigned int src_length)
562 {
563 char *ptr;
564 int length;
565
566 length = 0;
567 ptr = (char *) strScr;
568
569 while (length < src_length) {
570 if (ptr[length * 2] == '\\') {
571 strDst[length] = '/';
572 } else {
573 strDst[length] = ptr[length * 2];
574 }
575
576 length++;
577
578 if (ptr[length * 2] == 0) {
579 strDst[length] = '\0';
580 break;
581 }
582 }
583
584 return length;
585 }
586
587 /*
588 * @brief Convert char string to wide char string
589 * @param
590 * strSrc [in] Source char string to be converted
591 * strDst [out] The converted wide char string
592 * length [in] Length of source char string
593 * @return
594 * The length of source char string have been converted
595 */
596 static int FS_ConvCsToWcs(const char* strSrc, wchar_t* strDst, unsigned int src_length)
597 {
598 char *ptr;
599 unsigned int length;
600
601 length = 0;
602 ptr = (char *)strDst;
603
604 while (length < src_length) {
605 if (strSrc[length] == '/') {
606 ptr[length * 2] = '\\';
607 ptr[length * 2 + 1] = 0;
608 } else {
609 ptr[length * 2] = strSrc[length];
610 ptr[length * 2 + 1] = 0;
611 }
612 length++;
613
614 if (strSrc[length] == '\0') {
615 ptr[length * 2] = 0;
616 ptr[length * 2 + 1] = 0;
617 break;
618 }
619 }
620
621 if(length == src_length) {
622 ptr[(length-1) * 2] = 0;
623 ptr[(length-1) * 2 + 1] = 0;
624 length -= 1;
625 }
626
627 return length;
628 }
629
630 /*
631 * @brief Calculate the length of wide char string
632 * @param
633 * str [in] Source wide char string
634 * @return
635 * The length of source wide char string
636 */
637 static int FS_WcsLen(const wchar_t *str)
638 {
639 KAL_UINT16 *ptr = NULL;
640 int len = 0;
641
642 ptr = (KAL_UINT16*)str;
643 while (*ptr++ != 0)
644 len++;
645 return len;
646 }
647
648 /*
649 * @brief Allocate a sk buffer and initial it's FS header fields
650 * @param
651 * size [in] Size in bytes to allocate
652 * stream [in] FS header structure for reference
653 * again [in] Send again indicator
654 * @return
655 * A pointer to the allocated sk buffer indicates success.
656 * Otherwise NULL is returned.
657 */
658 struct sk_buff *eemcs_ut_alloc_skb(KAL_UINT32 size, FS_STREAMBUFFER *stream, KAL_UINT8 again)
659 {
660 struct sk_buff *new_skb = NULL;
661 FS_STREAMBUFFER *header = NULL;
662 DEBUG_LOG_FUNCTION_ENTRY;
663
664 KAL_ASSERT(size > 0);
665 KAL_ASSERT(stream != NULL);
666
667 new_skb = dev_alloc_skb(size);
668 if (new_skb == NULL) {
669 DBGLOG(FSUT, ERR, "[FSUT] Failed to alloc skb !!");
670 goto _fail;
671 }
672 header = (FS_STREAMBUFFER *)skb_put(new_skb, size);
673 memset(new_skb->data, 0, size);
674 DBGLOG(FSUT, DBG, "[FSUT] eemcs_ut_alloc_skb() new_skb(0x%p, 0x%p) size = %d",
675 new_skb, new_skb->data, new_skb->len);
676 // Assign send again indicator
677 if (again) {
678 header->ccci_header.data[0] = stream->ccci_header.data[0] | CCCI_FS_REQ_SEND_AGAIN;
679 } else {
680 header->ccci_header.data[0] = stream->ccci_header.data[0] & ~CCCI_FS_REQ_SEND_AGAIN;
681 }
682 KAL_ASSERT(size <= stream->ccci_header.data[1]);
683 //header->ccci_header.data[1] = stream->ccci_header.data[1];
684 header->ccci_header.data[1] = size;
685 header->ccci_header.reserved = stream->ccci_header.reserved;
686 header->ccci_header.channel = stream->ccci_header.channel;
687 // Assign OP ID
688 header->fs_operationID = stream->fs_operationID;
689
690 DEBUG_LOG_FUNCTION_LEAVE;
691 return new_skb;
692 _fail:
693 DEBUG_LOG_FUNCTION_LEAVE;
694 return NULL;
695 }
696
697 /*
698 * @brief Dump FS header information to standard output
699 * @param
700 * data [in] A pointer to the data buffer containing FS header
701 * @return
702 * None
703 */
704 void dump_fs_stream_header(void *data)
705 {
706 FS_STREAMBUFFER *stream = NULL;
707
708 KAL_ASSERT(data != NULL);
709 stream = (FS_STREAMBUFFER *)data;
710 DBGLOG(FSUT, DBG, "[DUMP] data[0] = 0x%X, data[1] = 0x%X, channel = 0x%X, reserved = 0x%X, op = 0x%X",
711 stream->ccci_header.data[0], stream->ccci_header.data[1],
712 stream->ccci_header.channel, stream->ccci_header.reserved,
713 stream->fs_operationID);
714 }
715
716 /*
717 * @brief
718 * Simulating MD sending a FS command to AP.
719 * This function will allocate a sk buffer, format its data buffer to
720 * FS commands format, then callback to CCCI CHAR layer directly.
721 * @param
722 * None
723 * @return
724 * This function will return KAL_SUCCESS always.
725 */
726 KAL_INT32 eemcs_fs_ut_send_skb(void)
727 {
728 FS_STREAMBUFFER *stream = NULL;
729 KAL_UINT32 pkt_cnt = 0;
730 KAL_UINT8 *pBuff = NULL; // pointer to data payload of FS buffer
731 KAL_UINT32 data_to_send = 0; // data size of each packet to send (excluding CCCI header and OP ID)
732 KAL_UINT32 data_sent = 0; // size of sent payload of FS buffer
733 KAL_UINT32 op_id = 0; // operation id
734 KAL_UINT32 total_len = 0; // total FS buffer length
735 KAL_UINT32 data_len = 0; // total FS buffer length excluding CCCI header and OP ID
736 KAL_UINT8 *skb_ptr = NULL;
737 struct sk_buff *new_skb = NULL;
738 char cmd_file[NAME_MAX] = {0};
739 char pkt_file[NAME_MAX] = {0};
740 DEBUG_LOG_FUNCTION_ENTRY;
741
742
743 stream = &g_eemcs_fs_ut.FS_REQ_BUF[g_ccci_fs_paras.index];
744 KAL_ASSERT(stream != NULL);
745 pBuff = stream->buffer;
746 op_id = stream->fs_operationID;
747 total_len = stream->ccci_header.data[1];
748 // data length excluding CCCI header and OP ID
749 data_len = total_len - sizeof(CCCI_BUFF_T) - sizeof(KAL_UINT32);
750
751 sprintf(cmd_file, "%s/fs_ut_md2ap_%03d.dat", FS_UT_TEST_FILE_DIR, md2ap_cmd_cnt++);
752 dump_data_to_file(cmd_file, (char *)stream, total_len);
753
754 /* No fragment is needed */
755 if (total_len <= MAX_FS_PKT_BYTE) {
756 sprintf(pkt_file, "%s/fs_ut_md2ap_%03d_pkt_%d.dat", FS_UT_TEST_FILE_DIR, md2ap_cmd_cnt, pkt_cnt);
757 DBGLOG(FSUT, DBG, "[FSUT] Small packet, no fragment.");
758
759 // Allocate a new skb to do transmission
760 new_skb = eemcs_ut_alloc_skb(total_len, (FS_STREAMBUFFER *)stream, 0);
761 KAL_ASSERT(new_skb != NULL);
762 skb_ptr = (KAL_UINT8 *)new_skb->data;
763 dump_fs_stream_header((void *)skb_ptr);
764 // Skip CCCI header and OP ID
765 skb_ptr += sizeof(CCCI_BUFF_T) + sizeof(KAL_UINT32);
766 // Copy from local buffer to skb
767 memcpy(skb_ptr, pBuff, data_len);
768 dump_data_to_file(pkt_file, (char *)(skb_ptr - sizeof(CCCI_BUFF_T) - sizeof(KAL_UINT32)), total_len);
769 eemcs_fs_ut_callback(new_skb, 0);
770 } else {
771 /* Data fragment is needed */
772 DBGLOG(FSUT, DBG, "[FSUT] Big packet, need fragment.");
773
774 while ((data_sent + sizeof(CCCI_BUFF_T) + sizeof(KAL_UINT32)) < total_len) {
775 memset(pkt_file, 0, NAME_MAX);
776 sprintf(pkt_file, "%s/fs_ut_md2ap_%03d_pkt_%d.dat", FS_UT_TEST_FILE_DIR, md2ap_cmd_cnt, pkt_cnt);
777 /* Each packet includes CCCI header, OP id, and data */
778 /* Moret than 2 packets to send */
779 if (data_len - data_sent > (MAX_FS_PKT_BYTE - sizeof(CCCI_BUFF_T) - sizeof(KAL_UINT32))) {
780 data_to_send = MAX_FS_PKT_BYTE - sizeof(CCCI_BUFF_T) - sizeof(KAL_UINT32);
781 // Prepare skb buffer
782 new_skb = eemcs_ut_alloc_skb(MAX_FS_PKT_BYTE, (FS_STREAMBUFFER *)stream, 1);
783 KAL_ASSERT(new_skb != NULL);
784 skb_ptr = (KAL_UINT8 *)new_skb->data;
785 dump_fs_stream_header((void *)skb_ptr);
786 // Skip CCCI header and OP ID
787 skb_ptr += sizeof(CCCI_BUFF_T) + sizeof(KAL_UINT32);
788 KAL_ASSERT(((CCCI_BUFF_T*)new_skb->data)->data[1] == MAX_FS_PKT_BYTE);
789 } else {
790 /* The last packet */
791 data_to_send = data_len - data_sent;
792 // Prepare skb buffer, size = CCCI header + OP ID + remaining data
793 new_skb = eemcs_ut_alloc_skb(sizeof(CCCI_BUFF_T) + sizeof(KAL_UINT32) + data_to_send, (FS_STREAMBUFFER *)stream, 0);
794 KAL_ASSERT(new_skb != NULL);
795 skb_ptr = (KAL_UINT8 *)new_skb->data;
796 dump_fs_stream_header((void *)skb_ptr);
797 // Skip CCCI header and OP ID
798 skb_ptr += sizeof(CCCI_BUFF_T) + sizeof(KAL_UINT32);
799 KAL_ASSERT(((CCCI_BUFF_T*)new_skb->data)->data[1] == (sizeof(CCCI_BUFF_T) + sizeof(KAL_UINT32) + data_to_send));
800 }
801 // Copy from local buffer to skb, data only
802 memcpy(skb_ptr, pBuff, data_to_send);
803 dump_data_to_file(pkt_file, (char *)(skb_ptr - sizeof(CCCI_BUFF_T) - sizeof(KAL_UINT32)), data_to_send + sizeof(CCCI_BUFF_T) - sizeof(KAL_UINT32));
804 DBGLOG(FSUT, DBG, "[FSUT] MD send packet %d with %d bytes", pkt_cnt, ((CCCI_BUFF_T*)new_skb->data)->data[1]);
805 data_sent += data_to_send;
806 pBuff += data_to_send;
807 pkt_cnt++;
808 eemcs_fs_ut_callback(new_skb, 0);
809 };
810 }
811 DEBUG_LOG_FUNCTION_LEAVE;
812 return KAL_SUCCESS;
813 }
814
815 /*
816 * @brief
817 * Store arguments information to the big buffer(g_eemcs_fs_ut.FS_REQ_BUF) for transmission
818 * @param
819 * index [in] Port index currently in use
820 * op [in] Operation ID currently in progress
821 * pLV [in] A structure containing arguments information
822 * num [in] Number to arguments
823 * @return
824 * This function will return KAL_SUCCESS always.
825 */
826 KAL_INT32 ccci_fs_put_buff(KAL_INT32 index, KAL_UINT32 op, FS_CCCI_LV_T *pLV, KAL_UINT32 num)
827 {
828 FS_STREAMBUFFER *fs_buf = NULL;
829 KAL_UINT8 *ptr;
830 KAL_UINT32 *argc;
831 KAL_UINT32 i;
832 FS_CCCI_LV_T *p_curr_lv_t = NULL; // pointer of current local variable struct
833 KAL_UINT32 curr_v_len; // current variable length
834 KAL_UINT32 total_len = 0; // total variable length
835 DEBUG_LOG_FUNCTION_ENTRY;
836
837 // fs_buf = CCCI_FS internal buffer
838 fs_buf = &g_eemcs_fs_ut.FS_REQ_BUF[index];
839 memset(fs_buf, 0, sizeof(FS_STREAMBUFFER));
840
841 // Assign operation id
842 fs_buf->fs_operationID = op;
843 total_len += sizeof(fs_buf->fs_operationID);
844
845 // ptr = buffer pointer;
846 ptr = fs_buf->buffer;
847
848 // Set the number of parameters
849 argc = (KAL_UINT32 *)ptr;
850 *argc = num;
851 ptr += sizeof(KAL_UINT32);
852 total_len += sizeof(KAL_UINT32);
853
854 // Set each parameter of pLV[i]
855 for (i = 0; i < num; i++) {
856 p_curr_lv_t = (FS_CCCI_LV_T *)ptr;
857
858 // Set the data length
859 p_curr_lv_t->len = pLV[i].len;
860 // adjusted to be 4-byte aligned
861 curr_v_len = ((pLV[i].len + 3) >> 2) << 2;
862 DBGLOG(FSUT, DBG, "[FSUT] Copy LV[%d]. real length = %d, aligned length = %d", i, pLV[i].len, curr_v_len);
863
864 // memcpy the data into CCCI_FS buffer
865 memcpy(&(p_curr_lv_t->val), pLV[i].val, pLV[i].len);
866
867 // Update the total_len
868 total_len += curr_v_len;
869 total_len += sizeof(p_curr_lv_t->len); // additional KAL_UINT32 is for p_curr_lv_t->len
870
871 // Move ptr to next LV
872 ptr += sizeof(p_curr_lv_t->len) + curr_v_len;
873 }
874
875 total_len += sizeof(CCCI_BUFF_T);
876 fs_buf->ccci_header.data[0] = g_eemcs_fs_ut.FS_REQ_BUF[index].ccci_header.data[0];
877 fs_buf->ccci_header.data[1] = total_len;
878 fs_buf->ccci_header.channel = CH_FS_RX;
879 fs_buf->ccci_header.reserved = index;
880 DBGLOG(FSUT, DBG, "[FSUT] ccci_fs_put_buff() %d args, total_len = %d, op = 0x%X, port_id = %d",
881 *argc, fs_buf->ccci_header.data[1], fs_buf->fs_operationID, fs_buf->ccci_header.reserved);
882
883 DEBUG_LOG_FUNCTION_LEAVE;
884 return KAL_SUCCESS;
885 }
886
887 /*
888 * @brief
889 * Parsing big buffer(g_eemcs_fs_ut.FS_REQ_BUF) and store arguments information
890 * to a arguments structure
891 * @param
892 * index [in] Port index currently in use
893 * op [in] Operation ID currently in progress
894 * pLV [out] A structure to store argument information
895 * num [in] Number to arguments
896 * @return
897 * This function will return KAL_SUCCESS always.
898 */
899 KAL_INT32 ccci_fs_get_buff(KAL_INT32 index, KAL_UINT32 op, FS_CCCI_LV_T *pLV, KAL_UINT32 *num)
900 {
901 KAL_UINT32 i, no_copy = 0;
902 FS_STREAMBUFFER *fs_buf;
903 KAL_UINT8 *ptr;
904 FS_CCCI_LV_T *pTmp;
905 DEBUG_LOG_FUNCTION_ENTRY;
906
907 fs_buf = &g_eemcs_fs_ut.FS_REQ_BUF[index];
908
909 if (op && (fs_buf->fs_operationID != (FS_CCCI_API_RESP_ID | op))) {
910 DBGLOG(FSUT, ERR, "[FSUT] fs_buf->fs_operationID = 0x%X, op = 0x%X", fs_buf->fs_operationID, op);
911 KAL_ASSERT(0);
912 }
913
914 ptr = fs_buf->buffer;
915
916 // entry count
917 pTmp = (FS_CCCI_LV_T *)ptr;
918 if (op) {
919 if (*num != pTmp->len){
920 KAL_ASSERT(0);
921 }
922 } else {
923 *num = pTmp->len;
924 no_copy = 1;
925 }
926
927 // bypass the arguments number
928 ptr += sizeof(KAL_UINT32);
929 for (i = 0; i < *num; i++) {
930 pTmp = (FS_CCCI_LV_T *)ptr;
931 if (op && (pLV[i].len < pTmp->len)) {
932 KAL_ASSERT(0);
933 }
934
935 pLV[i].len = pTmp->len;
936 if (no_copy) {
937 pLV[i].val = (void *)(ptr + sizeof(KAL_UINT32));
938 } else {
939 memcpy(pLV[i].val, ptr + sizeof(KAL_UINT32), pLV[i].len);
940 }
941
942 // adjusted to be 4-byte aligned
943 ptr += sizeof(KAL_UINT32) + (((pTmp->len + 3) >> 2) << 2);
944 }
945 DEBUG_LOG_FUNCTION_LEAVE;
946 return KAL_SUCCESS;
947 }
948
949 /*
950 * @brief Wrapper function for all operations
951 * @param
952 * fs_para [in] A structure containing arguments information
953 * @return
954 * This function will return KAL_SUCCESS always.
955 */
956 static KAL_UINT32 CCCI_FS_OP_Wrapper(CCCI_FS_PARA_T* fs_para)
957 {
958 KAL_INT32 ret;
959 DEBUG_LOG_FUNCTION_ENTRY;
960
961 ret = ccci_fs_put_buff(fs_para->index, fs_para->op_id, fs_para->pLV_in, fs_para->LV_in_para_cnt);
962 if (KAL_SUCCESS != ret){
963 DBGLOG(FSUT, ERR, "[FSUT] Failed to prepare MD FS command");
964 DEBUG_LOG_FUNCTION_LEAVE;
965 return KAL_FAIL;
966 }
967 eemcs_fs_ut_send_skb();
968 DEBUG_LOG_FUNCTION_LEAVE;
969 return KAL_SUCCESS;
970 }
971
972 /*
973 * @brief Reset gobal arguments structures
974 * @param
975 * None
976 * @return
977 * None
978 */
979 void eemcs_fs_ut_reset_args(void)
980 {
981 memset(g_LV_in, 0, sizeof(FS_CCCI_LV_T) * FS_CCCI_MAX_ARG_NUM);
982 memset(g_LV_out, 0, sizeof(FS_CCCI_LV_T) * FS_CCCI_MAX_ARG_NUM);
983 g_LV_in_num = 0;
984 g_LV_out_num = 0;
985 memset(&g_ccci_fs_paras, 0, sizeof(CCCI_FS_PARA_T));
986 }
987
988 /*
989 * @brief Get drive name
990 * @param
991 * type [in] Drive type
992 * serial [in] Drive type serial
993 * alt_mask [in] Drvie mask
994 * @return
995 * This function will return KAL_SUCCESS always.
996 */
997 KAL_INT32 eemcs_fs_ut_getdrive(KAL_UINT32 type, KAL_UINT32 serial, KAL_UINT32 alt_mask)
998 {
999 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1000 KAL_INT32 ret;
1001 DEBUG_LOG_FUNCTION_ENTRY;
1002
1003 eemcs_fs_ut_reset_args();
1004 /* AP CCCI FS input parameters */
1005 // type
1006 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1007 g_LV_in[g_LV_in_num++].val = (void *)&type;
1008 // serial
1009 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1010 g_LV_in[g_LV_in_num++].val = (void *)&serial;
1011 // alt_mask
1012 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1013 g_LV_in[g_LV_in_num++].val = (void *)&alt_mask;
1014
1015 /* AP CCCI FS output value */
1016 // return code
1017 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1018 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1019
1020 g_ccci_fs_paras.index = index;
1021 g_ccci_fs_paras.op_id = FS_CCCI_OP_GETDRIVE;
1022 g_ccci_fs_paras.pLV_in = g_LV_in;
1023 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1024 g_ccci_fs_paras.pLV_out = g_LV_out;
1025 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1026
1027 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1028
1029 DEBUG_LOG_FUNCTION_LEAVE;
1030 return ret;
1031 }
1032
1033 /*
1034 * @brief Get cluster size of a specified drive
1035 * @param
1036 * drive_index [in] Drive name
1037 * @return
1038 * This function will return KAL_SUCCESS always.
1039 */
1040 KAL_INT32 eemcs_fs_ut_getclustersize(KAL_UINT32 drive_index)
1041 {
1042 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1043 KAL_INT32 ret;
1044 DEBUG_LOG_FUNCTION_ENTRY;
1045
1046 eemcs_fs_ut_reset_args();
1047 /* AP CCCI FS input parameters */
1048 // drive index
1049 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1050 g_LV_in[g_LV_in_num++].val = (void *)&drive_index;
1051 /* AP CCCI FS output value */
1052 // return code
1053 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1054 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1055
1056 g_ccci_fs_paras.index = index;
1057 g_ccci_fs_paras.op_id = FS_CCCI_OP_GETCLUSTERSIZE;
1058 g_ccci_fs_paras.pLV_in = g_LV_in;
1059 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1060 g_ccci_fs_paras.pLV_out = g_LV_out;
1061 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1062
1063 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1064
1065 DEBUG_LOG_FUNCTION_LEAVE;
1066 return ret;
1067 }
1068
1069 /*
1070 * @brief Create a directory
1071 * @param
1072 * dir_path [in] Pull path of a directory
1073 * @return
1074 * This function will return KAL_SUCCESS always.
1075 */
1076 KAL_INT32 eemcs_fs_ut_createdir(const wchar_t *dir_path)
1077 {
1078 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1079 KAL_INT32 ret;
1080 DEBUG_LOG_FUNCTION_ENTRY;
1081
1082 eemcs_fs_ut_reset_args();
1083 /* AP CCCI FS input parameters */
1084 // directory name of full path
1085 g_LV_in[g_LV_in_num].len = (FS_WcsLen(dir_path) * sizeof(wchar_t)) + sizeof(wchar_t);
1086 g_LV_in[g_LV_in_num++].val = (void *)dir_path;
1087 /* AP CCCI FS output value */
1088 // return code
1089 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1090 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1091
1092 g_ccci_fs_paras.index = index;
1093 g_ccci_fs_paras.op_id = FS_CCCI_OP_CREATEDIR;
1094 g_ccci_fs_paras.pLV_in = g_LV_in;
1095 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1096 g_ccci_fs_paras.pLV_out = g_LV_out;
1097 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1098
1099 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1100
1101 DEBUG_LOG_FUNCTION_LEAVE;
1102 return ret;
1103 }
1104
1105 /*
1106 * @brief Delete a directory
1107 * @param
1108 * dir_path [in] Pull path of a directory
1109 * @return
1110 * This function will return KAL_SUCCESS always.
1111 */
1112 KAL_INT32 eemcs_fs_ut_removedir(const wchar_t *dir_name)
1113 {
1114 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1115 KAL_INT32 ret;
1116 DEBUG_LOG_FUNCTION_ENTRY;
1117
1118 eemcs_fs_ut_reset_args();
1119 /* AP CCCI FS input parameters */
1120 // directory name with full path
1121 g_LV_in[g_LV_in_num].len = (FS_WcsLen(dir_name) * sizeof(wchar_t)) + sizeof(wchar_t);
1122 g_LV_in[g_LV_in_num++].val = (void *)dir_name;
1123 /* AP CCCI FS output value */
1124 // return code
1125 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1126 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1127
1128 g_ccci_fs_paras.index = index;
1129 g_ccci_fs_paras.op_id = FS_CCCI_OP_REMOVEDIR;
1130 g_ccci_fs_paras.pLV_in = g_LV_in;
1131 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1132 g_ccci_fs_paras.pLV_out = g_LV_out;
1133 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1134
1135 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1136
1137 DEBUG_LOG_FUNCTION_LEAVE;
1138 return ret;
1139 }
1140
1141 /*
1142 * @brief Open a file
1143 * @param
1144 * file_path [in] A file full path to be opened
1145 * flags [in] Flags to open the file
1146 * @return
1147 * This function will return KAL_SUCCESS always.
1148 */
1149 KAL_INT32 eemcs_fs_ut_open(wchar_t *file_path, KAL_UINT32 flags)
1150 {
1151 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1152 KAL_INT32 ret;
1153 DEBUG_LOG_FUNCTION_ENTRY;
1154
1155 eemcs_fs_ut_reset_args();
1156 /* AP CCCI FS input parameters */
1157 // full path of file name
1158 g_LV_in[g_LV_in_num].len = (FS_WcsLen(file_path) * sizeof(wchar_t)) + sizeof(wchar_t);
1159 g_LV_in[g_LV_in_num++].val = (void *)file_path;
1160 // flags
1161 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1162 g_LV_in[g_LV_in_num++].val = (void *)&flags;
1163 /* AP CCCI FS output value */
1164 /*
1165 * 1st KAL_UINT32 : number of arguments
1166 * 2nd KAL_UINT32 : g_LV_out[0].len
1167 * 3rd KAL_UINT32 : g_LV_out[0].val <-- Store file handle here
1168 */
1169 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1170
1171 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1172
1173 g_ccci_fs_paras.index = index;
1174 g_ccci_fs_paras.op_id = FS_CCCI_OP_OPEN;
1175 g_ccci_fs_paras.pLV_in = g_LV_in;
1176 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1177 g_ccci_fs_paras.pLV_out = g_LV_out;
1178 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1179 DBGLOG(FSUT, DBG, "[FSUT] eemcs_fs_ut_open() Port %d try to open a file", index);
1180
1181 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1182
1183 DEBUG_LOG_FUNCTION_LEAVE;
1184 return ret;
1185 }
1186
1187 /*
1188 * @brief Close a file
1189 * @param
1190 * fhandle [in] The file handle returned from eemcs_fs_ut_open()
1191 * @return
1192 * This function will return KAL_SUCCESS always.
1193 */
1194 KAL_INT32 eemcs_fs_ut_close(KAL_UINT32 fhandle)
1195 {
1196 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1197 KAL_INT32 ret;
1198 DEBUG_LOG_FUNCTION_ENTRY;
1199
1200 eemcs_fs_ut_reset_args();
1201 /* AP CCCI FS input parameters */
1202 // file handle
1203 g_LV_in[g_LV_in_num].len = sizeof(fhandle);
1204 g_LV_in[g_LV_in_num++].val = (void *)&fhandle;
1205 /* AP CCCI FS outout parameters */
1206 /*
1207 * 1st KAL_UINT32 : number of arguments
1208 * 2nd KAL_UINT32 : g_LV_out[0].len
1209 * 3rd KAL_UINT32 : g_LV_out[0].val <-- Store return code here
1210 */
1211 // return code
1212 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1213 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1214
1215 g_ccci_fs_paras.index = index;
1216 g_ccci_fs_paras.op_id = FS_CCCI_OP_CLOSE;
1217 g_ccci_fs_paras.pLV_in = g_LV_in;
1218 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1219 g_ccci_fs_paras.pLV_out = g_LV_out;
1220 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1221 DBGLOG(FSUT, DBG, "[FSUT] eemcs_fs_ut_close() Port %d close file %d", index, fhandle);
1222
1223 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1224
1225 DEBUG_LOG_FUNCTION_LEAVE;
1226 return KAL_SUCCESS;
1227 }
1228
1229 /*
1230 * @brief Write data to a file
1231 * @param
1232 * fhandle [in] The file handle returned from eemcs_fs_ut_open()
1233 * data [in] Data to write
1234 * size [in] Size of data
1235 * written [out] The size in bytes have been written to file
1236 * @return
1237 * This function will return KAL_SUCCESS always.
1238 */
1239 KAL_INT32 eemcs_fs_ut_write(KAL_UINT32 fhandle, void *data, KAL_UINT32 size, KAL_UINT32 *written)
1240 {
1241 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1242 KAL_INT32 ret;
1243 DEBUG_LOG_FUNCTION_ENTRY;
1244
1245 eemcs_fs_ut_reset_args();
1246 /* AP CCCI FS input parameters */
1247 // file handle
1248 g_LV_in[g_LV_in_num].len = sizeof(fhandle);
1249 g_LV_in[g_LV_in_num++].val = (void *)&fhandle;
1250 // data pointer
1251 g_LV_in[g_LV_in_num].len = size;
1252 g_LV_in[g_LV_in_num++].val = data;
1253 // data size
1254 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1255 g_LV_in[g_LV_in_num++].val = (void *)&size;
1256 /* AP CCCI FS outout parameters */
1257 /*
1258 * 1st KAL_UINT32 : number of arguments
1259 * 2nd KAL_UINT32 : g_LV_out[0].len
1260 * 3rd KAL_UINT32 : g_LV_out[0].val <-- Store return code here
1261 * 4th KAL_UINT32 : g_LV_out[1].len
1262 * 5th KAL_UINT32 : g_LV_out[1].val <-- Store written bytes here, we ignore "written" parameter
1263 */
1264 // return code
1265 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1266 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1267 // written bytes
1268 g_LV_out[g_LV_out_num].len = sizeof(KAL_UINT32);
1269 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (4 * sizeof(KAL_UINT32)));
1270
1271 g_ccci_fs_paras.index = index;
1272 g_ccci_fs_paras.op_id = FS_CCCI_OP_WRITE;
1273 g_ccci_fs_paras.pLV_in = g_LV_in;
1274 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1275 g_ccci_fs_paras.pLV_out = g_LV_out;
1276 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1277 DBGLOG(FSUT, DBG, "[FSUT] eemcs_fs_ut_write() Port %d write %d bytes of data to file %d", index, size, fhandle);
1278
1279 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1280
1281 DEBUG_LOG_FUNCTION_LEAVE;
1282 return KAL_SUCCESS;
1283 }
1284
1285 /*
1286 * @brief Get the size of a file
1287 * @param
1288 * fhandle [in] The file handle returned from eemcs_fs_ut_open()
1289 * size [out] Size of the file
1290 * @return
1291 * This function will return KAL_SUCCESS always.
1292 */
1293 KAL_INT32 eemcs_fs_ut_get_file_size(KAL_UINT32 fhandle, KAL_UINT32 *size)
1294 {
1295 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1296 KAL_INT32 ret;
1297
1298 eemcs_fs_ut_reset_args();
1299 /* AP CCCI FS input parameters */
1300 // file handle
1301 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1302 g_LV_in[g_LV_in_num++].val = (void *)&fhandle;
1303 /*
1304 * AP CCCI FS output value
1305 * 1st KAL_UINT32 : number of arguments
1306 * 2nd KAL_UINT32 : g_LV_out[0].len
1307 * 3rd KAL_UINT32 : g_LV_out[0].val <-- Store return code here
1308 * 4th KAL_UINT32 : g_LV_out[1].len
1309 * 5th KAL_UINT32 : g_LV_out[1].val <-- Store file size here, we ignore "size" parameter
1310 */
1311 /* AP CCCI FS output parameters */
1312 // return code
1313 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1314 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1315 // returned file size
1316 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1317 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (4 * sizeof(KAL_UINT32)));
1318
1319 g_ccci_fs_paras.index = index;
1320 g_ccci_fs_paras.op_id = FS_CCCI_OP_GETFILESIZE;
1321 g_ccci_fs_paras.pLV_in = g_LV_in;
1322 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1323 g_ccci_fs_paras.pLV_out = g_LV_out;
1324 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1325 DBGLOG(FSUT, DBG, "[FSUT] eemcs_fs_ut_file_size() Port %d get file size of file %d", index, fhandle);
1326
1327 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1328
1329 DEBUG_LOG_FUNCTION_LEAVE;
1330 return KAL_SUCCESS;
1331 }
1332
1333 /*
1334 * @brief Read data from a file
1335 * @param
1336 * fhandle [in] The file handle returned from eemcs_fs_ut_open()
1337 * data [out] A data buffer to store read data
1338 * size [in] Size to read from the file
1339 * read [out] The actual size read from the file
1340 * @return
1341 * This function will return KAL_SUCCESS always.
1342 */
1343 KAL_INT32 eemcs_fs_ut_read(KAL_UINT32 fhandle, void *data, KAL_UINT32 size, KAL_UINT32 *read)
1344 {
1345 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1346 KAL_INT32 ret;
1347
1348 eemcs_fs_ut_reset_args();
1349 /* AP CCCI FS input parameters */
1350 // file handle
1351 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1352 g_LV_in[g_LV_in_num++].val = (void *)&fhandle;
1353 // data size
1354 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1355 g_LV_in[g_LV_in_num++].val = (void *)&size;
1356 /*
1357 * AP CCCI FS output value
1358 * 1st KAL_UINT32 : number of arguments
1359 * 2nd KAL_UINT32 : g_LV_out[0].len
1360 * 3rd KAL_UINT32 : g_LV_out[0].val <-- Store return code here
1361 * 4th KAL_UINT32 : g_LV_out[1].len
1362 * 5th KAL_UINT32 : g_LV_out[1].val <-- Store read size here, we ignore "read" parameter
1363 * 6th KAL_UINT32 : g_LV_out[2].len
1364 * 7th KAL_UINT32 : g_LV_out[2].val <-- Store read data here, we ignore "data" parameter
1365 */
1366 // return code
1367 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1368 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1369 // read bytes
1370 g_LV_out[g_LV_out_num].len = sizeof(KAL_UINT32);
1371 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (4 * sizeof(KAL_UINT32)));
1372 // data pointer
1373 g_LV_out[g_LV_out_num].len = size;
1374 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (6 * sizeof(KAL_UINT32)));;
1375
1376 g_ccci_fs_paras.index = index;
1377 g_ccci_fs_paras.op_id = FS_CCCI_OP_READ;
1378 g_ccci_fs_paras.pLV_in = g_LV_in;
1379 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1380 g_ccci_fs_paras.pLV_out = g_LV_out;
1381 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1382 DBGLOG(FSUT, DBG, "[FSUT] eemcs_fs_ut_read() Port %d read %d bytes of data from file %d",
1383 index, size, fhandle);
1384
1385 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1386
1387 DEBUG_LOG_FUNCTION_LEAVE;
1388 return KAL_SUCCESS;
1389 }
1390
1391 /*
1392 * @brief Move a file to another path
1393 * @param
1394 * src [in] Source path of file
1395 * dst [in] Destination path of ile
1396 * flags [in] Options of move command
1397 * @return
1398 * This function will return KAL_SUCCESS always.
1399 */
1400 KAL_INT32 eemcs_fs_ut_move(const wchar_t *src, const wchar_t *dst, KAL_UINT32 flags)
1401 {
1402 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1403 KAL_INT32 ret;
1404
1405 eemcs_fs_ut_reset_args();
1406 /* AP CCCI FS input parameters */
1407 // source path
1408 g_LV_in[g_LV_in_num].len = (FS_WcsLen(src) * sizeof(wchar_t)) + sizeof(wchar_t);
1409 g_LV_in[g_LV_in_num++].val = (void *)src;
1410 // destination path
1411 g_LV_in[g_LV_in_num].len = (FS_WcsLen(dst) * sizeof(wchar_t)) + sizeof(wchar_t);
1412 g_LV_in[g_LV_in_num++].val = (void *)dst;
1413 // flags
1414 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1415 g_LV_in[g_LV_in_num++].val = (void *)&flags;
1416 /* AP CCCI FS output value */
1417 // return code
1418 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1419 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1420
1421 g_ccci_fs_paras.index = index;
1422 g_ccci_fs_paras.op_id = FS_CCCI_OP_MOVE;
1423 g_ccci_fs_paras.pLV_in = g_LV_in;
1424 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1425 g_ccci_fs_paras.pLV_out = g_LV_out;
1426 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1427
1428 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1429
1430 DEBUG_LOG_FUNCTION_LEAVE;
1431 return KAL_SUCCESS;
1432 }
1433
1434 /*
1435 * @brief Rename a file
1436 * @param
1437 * old_name [in] Original name of file
1438 * new_name [in] New name of ile
1439 * @return
1440 * This function will return KAL_SUCCESS always.
1441 */
1442 KAL_INT32 eemcs_fs_ut_rename(const wchar_t *old_name, const wchar_t* new_name)
1443 {
1444 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1445 KAL_INT32 ret;
1446
1447 eemcs_fs_ut_reset_args();
1448 /* AP CCCI FS input parameters */
1449 // old file name
1450 g_LV_in[g_LV_in_num].len = (FS_WcsLen(old_name) * sizeof(wchar_t)) + sizeof(wchar_t);
1451 g_LV_in[g_LV_in_num++].val = (void *)old_name;
1452 // new file name
1453 g_LV_in[g_LV_in_num].len = (FS_WcsLen(new_name) * sizeof(wchar_t)) + sizeof(wchar_t);
1454 g_LV_in[g_LV_in_num++].val = (void *)new_name;
1455 /* AP CCCI FS output value */
1456 // return code
1457 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1458 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1459
1460 g_ccci_fs_paras.index = index;
1461 g_ccci_fs_paras.op_id = FS_CCCI_OP_RENAME;
1462 g_ccci_fs_paras.pLV_in = g_LV_in;
1463 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1464 g_ccci_fs_paras.pLV_out = g_LV_out;
1465 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1466
1467 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1468
1469 DEBUG_LOG_FUNCTION_LEAVE;
1470 return KAL_SUCCESS;
1471 }
1472
1473 /*
1474 * @brief Delete a file
1475 * @param
1476 * file_name [in] Full path of a file
1477 * @return
1478 * This function will return KAL_SUCCESS always.
1479 */
1480 KAL_INT32 eemcs_fs_ut_delete(const wchar_t *file_name)
1481 {
1482 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1483 KAL_INT32 ret;
1484
1485 eemcs_fs_ut_reset_args();
1486 /* AP CCCI FS input parameters */
1487 // file name
1488 g_LV_in[g_LV_in_num].len = (FS_WcsLen(file_name) * sizeof(wchar_t)) + sizeof(wchar_t);
1489 g_LV_in[g_LV_in_num++].val = (void *)file_name;
1490 /* AP CCCI FS output value */
1491 // return code
1492 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1493 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1494
1495 g_ccci_fs_paras.index = index;
1496 g_ccci_fs_paras.op_id = FS_CCCI_OP_DELETE;
1497 g_ccci_fs_paras.pLV_in = g_LV_in;
1498 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1499 g_ccci_fs_paras.pLV_out = g_LV_out;
1500 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1501
1502 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1503
1504 DEBUG_LOG_FUNCTION_LEAVE;
1505 return KAL_SUCCESS;
1506 }
1507
1508 /*
1509 * @brief Get size of a filder
1510 * @param
1511 * src [in] Full path of folder
1512 * flags [in] Options of GETFOLDERSIZE command.
1513 * @return
1514 * This function will return KAL_SUCCESS always.
1515 */
1516 KAL_INT32 eemcs_fs_ut_getfoldersize(const wchar_t *dir, KAL_UINT32 flags)
1517 {
1518 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1519 KAL_INT32 ret;
1520
1521 eemcs_fs_ut_reset_args();
1522 /* AP CCCI FS input parameters */
1523 // directory name
1524 g_LV_in[g_LV_in_num].len = (FS_WcsLen(dir) * sizeof(wchar_t)) + sizeof(wchar_t);
1525 g_LV_in[g_LV_in_num++].val = (void *)dir;
1526 // flags
1527 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1528 g_LV_in[g_LV_in_num++].val = (void *)&flags;
1529 /* AP CCCI FS output value */
1530 // return code
1531 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1532 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1533
1534 g_ccci_fs_paras.index = index;
1535 g_ccci_fs_paras.op_id = FS_CCCI_OP_GETFOLDERSIZE;
1536 g_ccci_fs_paras.pLV_in = g_LV_in;
1537 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1538 g_ccci_fs_paras.pLV_out = g_LV_out;
1539 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1540
1541 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1542
1543 DEBUG_LOG_FUNCTION_LEAVE;
1544 return KAL_SUCCESS;
1545 }
1546
1547 /*
1548 * @brief Count file/folder number of a specified folder
1549 * @param
1550 * dir_path [in] Full path of a folder
1551 * @return
1552 * This function will return KAL_SUCCESS always.
1553 */
1554 KAL_INT32 eemcs_fs_ut_count(const wchar_t *dir_path, KAL_UINT32 flags)
1555 {
1556 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1557 KAL_INT32 ret;
1558
1559 eemcs_fs_ut_reset_args();
1560 /* AP CCCI FS input parameters */
1561 // full path of directory
1562 g_LV_in[g_LV_in_num].len = (FS_WcsLen(dir_path) * sizeof(wchar_t)) + sizeof(wchar_t);
1563 g_LV_in[g_LV_in_num++].val = (void *)dir_path;
1564 // Flag
1565 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1566 g_LV_in[g_LV_in_num++].val = (void *)&flags;
1567 /* AP CCCI FS output value */
1568 // return code
1569 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1570 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1571
1572 g_ccci_fs_paras.index = index;
1573 g_ccci_fs_paras.op_id = FS_CCCI_OP_COUNT;
1574 g_ccci_fs_paras.pLV_in = g_LV_in;
1575 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1576 g_ccci_fs_paras.pLV_out = g_LV_out;
1577 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1578
1579 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1580
1581 DEBUG_LOG_FUNCTION_LEAVE;
1582 return KAL_SUCCESS;
1583 }
1584
1585 /*
1586 * @brief Delete a folder
1587 * @param
1588 * dir_path [in] Full path of a folder
1589 * flags [in] Options of XDELETE command
1590 * @return
1591 * This function will return KAL_SUCCESS always.
1592 */
1593 KAL_INT32 eemcs_fs_ut_xdelete(const wchar_t *dir_path, KAL_UINT32 flags)
1594 {
1595 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1596 KAL_INT32 ret;
1597
1598 eemcs_fs_ut_reset_args();
1599 /* AP CCCI FS input parameters */
1600 // full path of folder name
1601 g_LV_in[g_LV_in_num].len = (FS_WcsLen(dir_path) * sizeof(wchar_t)) + sizeof(wchar_t);
1602 g_LV_in[g_LV_in_num++].val = (void *)dir_path;
1603 // Flag
1604 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1605 g_LV_in[g_LV_in_num++].val = (void *)&flags;
1606
1607 /* AP CCCI FS output value */
1608 // return code
1609 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1610 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1611
1612 g_ccci_fs_paras.index = index;
1613 g_ccci_fs_paras.op_id = FS_CCCI_OP_XDELETE;
1614 g_ccci_fs_paras.pLV_in = g_LV_in;
1615 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1616 g_ccci_fs_paras.pLV_out = g_LV_out;
1617 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1618
1619 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1620
1621 DEBUG_LOG_FUNCTION_LEAVE;
1622 return KAL_SUCCESS;
1623 }
1624
1625 KAL_INT32 eemcs_fs_ut_findfirst(const wchar_t* pattern, KAL_UINT8 attr, KAL_UINT8 attr_mask, FS_DOSDirEntry * file_info, wchar_t* file_name, KAL_UINT32 max_length)
1626 {
1627 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1628 KAL_INT32 ret;
1629 KAL_INT32 MaxLength_nonWCHAR = max_length/2 -1;
1630 KAL_UINT32 aligned_entry_size = 0;
1631
1632 eemcs_fs_ut_reset_args();
1633 /* AP CCCI FS input parameters */
1634 // pattern to find
1635 g_LV_in[g_LV_in_num].len = (FS_WcsLen(pattern) * sizeof(wchar_t)) + sizeof(wchar_t);
1636 g_LV_in[g_LV_in_num++].val = (void *)pattern;
1637 // attribute
1638 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT8);
1639 g_LV_in[g_LV_in_num++].val = (void *)&attr;
1640 // attribute mask
1641 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT8);
1642 g_LV_in[g_LV_in_num++].val = (void *)&attr_mask;
1643 // max. length //AP return length = (MaxLength+1)*2; !!! for WCHAR !!!!
1644 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1645 //LV_in[LV_in_num++].val = (void *)&MaxLength;
1646 g_LV_in[g_LV_in_num++].val = (void *)&MaxLength_nonWCHAR;
1647
1648 /* AP CCCI FS output value */
1649 // return code
1650 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1651 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1652 // file information
1653 g_LV_out[g_LV_out_num].len = sizeof(FS_DOSDirEntry);
1654 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (4 * sizeof(KAL_UINT32)));
1655 // file name
1656 aligned_entry_size = ((sizeof(FS_DOSDirEntry) + 3) >> 2) << 2;
1657 g_LV_out[g_LV_out_num].len = max_length;
1658 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (5 * sizeof(KAL_UINT32)) + aligned_entry_size);
1659
1660 g_ccci_fs_paras.index = index;
1661 g_ccci_fs_paras.op_id = FS_CCCI_OP_FINDFIRST;
1662 g_ccci_fs_paras.pLV_in = g_LV_in;
1663 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1664 g_ccci_fs_paras.pLV_out = g_LV_out;
1665 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1666
1667 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1668
1669 DEBUG_LOG_FUNCTION_LEAVE;
1670 return KAL_SUCCESS;
1671 }
1672
1673 KAL_INT32 eemcs_fs_ut_findnext(KAL_UINT32 handle, FS_DOSDirEntry *file_info, wchar_t *file_name, KAL_UINT32 max_length)
1674 {
1675 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1676 KAL_INT32 ret;
1677 KAL_INT32 MaxLength_nonWCHAR = max_length/2 -1;
1678 KAL_UINT32 aligned_entry_size = 0;
1679
1680 eemcs_fs_ut_reset_args();
1681 /* AP CCCI FS input parameters */
1682 // file handle returned from eemcs_fs_ut_findfirst
1683 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1684 g_LV_in[g_LV_in_num++].val = (void *)&handle;
1685 // MaxLength //AP return length = (MaxLength+1)*2; !!! for WCHAR !!!!
1686 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1687 //LV_in[LV_in_num++].val = (void *)&MaxLength;
1688 g_LV_in[g_LV_in_num++].val = (void *)&MaxLength_nonWCHAR;
1689
1690 /* AP CCCI FS output value */
1691 // return code
1692 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1693 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1694 // file information
1695 g_LV_out[g_LV_out_num].len = sizeof(FS_DOSDirEntry);
1696 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (4 * sizeof(KAL_UINT32)));
1697 // file name
1698 aligned_entry_size = ((sizeof(FS_DOSDirEntry) + 3) >> 2) << 2;
1699 g_LV_out[g_LV_out_num].len = max_length;
1700 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (5 * sizeof(KAL_UINT32)) + aligned_entry_size);
1701
1702 g_ccci_fs_paras.index = index;
1703 g_ccci_fs_paras.op_id = FS_CCCI_OP_FINDNEXT;
1704 g_ccci_fs_paras.pLV_in = g_LV_in;
1705 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1706 g_ccci_fs_paras.pLV_out = g_LV_out;
1707 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1708
1709 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1710
1711 DEBUG_LOG_FUNCTION_LEAVE;
1712 return KAL_SUCCESS;
1713 }
1714
1715 KAL_INT32 eemcs_fs_ut_findclose(KAL_UINT32 handle)
1716 {
1717 KAL_INT32 index = g_eemcs_fs_ut.ut_port_index;
1718 KAL_INT32 ret;
1719
1720 eemcs_fs_ut_reset_args();
1721 /* AP CCCI FS input parameters */
1722 // File Handle
1723 g_LV_in[g_LV_in_num].len = sizeof(KAL_UINT32);
1724 g_LV_in[g_LV_in_num++].val = (void *)&handle;
1725
1726 /* AP CCCI FS output value */
1727 // return code
1728 g_LV_out[g_LV_out_num].len = sizeof(KAL_INT32);
1729 g_LV_out[g_LV_out_num++].val = (void *)(g_eemcs_fs_ut.FS_REQ_BUF[index].buffer + (2 * sizeof(KAL_UINT32)));
1730
1731 g_ccci_fs_paras.index = index;
1732 g_ccci_fs_paras.op_id = FS_CCCI_OP_CLOSE;
1733 g_ccci_fs_paras.pLV_in = g_LV_in;
1734 g_ccci_fs_paras.LV_in_para_cnt = g_LV_in_num;
1735 g_ccci_fs_paras.pLV_out = g_LV_out;
1736 g_ccci_fs_paras.LV_out_para_cnt = g_LV_out_num;
1737
1738 ret = CCCI_FS_OP_Wrapper(&g_ccci_fs_paras);
1739
1740 DEBUG_LOG_FUNCTION_LEAVE;
1741 return KAL_SUCCESS;
1742 }
1743
1744 /*
1745 * @brief The handler after receiving ACK commands from AP
1746 * @param
1747 * None
1748 * @return
1749 * KAL_SUCCESS indicates the ACK command is handled correctly.
1750 * KAL_FAIL indicates the ACK command is not supported.
1751 */
1752 KAL_INT32 eemcs_fs_ut_ul_handler(void)
1753 {
1754 KAL_UINT32 op_id = g_ccci_fs_paras.op_id;
1755 DEBUG_LOG_FUNCTION_ENTRY;
1756
1757 switch (op_id) {
1758 case FS_CCCI_OP_GETDRIVE:
1759 {
1760 char drv_name = *((KAL_UINT32*)g_LV_out[0].val);
1761 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_GETDRIVE. Drive = %c", drv_name);
1762 if (g_test_drive[g_eemcs_fs_ut.drive_idx].drive[0] == drv_name)
1763 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_GETDRIVE [PASS] ^_^");
1764 else
1765 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_GETDRIVE [FAIL] @_@");
1766 break;
1767 }
1768 case FS_CCCI_OP_GETCLUSTERSIZE:
1769 {
1770 KAL_UINT32 size = *((KAL_UINT32*)g_LV_out[0].val);
1771
1772 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_GETCLUSTERSIZE. Cluster Size = %d", size);
1773 if (size > 0)
1774 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_GETCLUSTERSIZE [PASS] ^_^");
1775 else
1776 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_GETCLUSTERSIZE [FAIL] @_@");
1777 break;
1778 }
1779 case FS_CCCI_OP_CREATEDIR:
1780 {
1781 struct file *fp = NULL;
1782 KAL_INT32 ret = *((KAL_UINT32*)g_LV_out[0].val);
1783 char dir[NAME_MAX] = {0};
1784
1785 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_CREATEDIR. Return Code = %d", ret);
1786 if (ret == FS_NO_ERROR) {
1787 sprintf(dir, "%s/%s",
1788 g_test_drive[g_eemcs_fs_ut.drive_idx].fs_root,
1789 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
1790 if ((fp = file_open(dir, O_RDONLY, 0777)) != NULL) {
1791 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_CREATEDIR [PASS] ^_^");
1792 file_close(fp);
1793 } else {
1794 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_CREATEDIR [FAIL] @_@");
1795 DBGLOG(FSUT, TRA, "[FSUT] ==> Folder doesn't exist !!");
1796 }
1797 }
1798 else
1799 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_CREATEDIR [FAIL] @_@");
1800 break;
1801 }
1802 case FS_CCCI_OP_REMOVEDIR:
1803 {
1804 struct file *fp = NULL;
1805 KAL_INT32 ret = *((KAL_UINT32*)g_LV_out[0].val);
1806 char dir[NAME_MAX] = {0};
1807
1808 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_REMOVEDIR. Return Code = %d", ret);
1809 if (ret == FS_NO_ERROR) {
1810 sprintf(dir, "%s/%s",
1811 g_test_drive[g_eemcs_fs_ut.drive_idx].fs_root,
1812 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
1813 if ((fp = file_open(dir, O_RDONLY, 0777)) == NULL) {
1814 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_REMOVEDIR [PASS] ^_^");
1815 } else {
1816 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_REMOVEDIR [FAIL] @_@");
1817 DBGLOG(FSUT, ERR, "[FSUT] ==> Folder still exist !!");
1818 }
1819 }
1820 else
1821 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_CREATEDIR [FAIL] @_@");
1822 break;
1823 }
1824 case FS_CCCI_OP_OPEN:
1825 {
1826 g_eemcs_fs_ut.fhandle = *((KAL_UINT32*)g_LV_out[0].val);
1827 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_OPEN. Handle Index = %d", g_eemcs_fs_ut.fhandle);
1828 /*
1829 * Check file handle value
1830 */
1831 if (g_eemcs_fs_ut.fhandle >= 1)
1832 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_OPEN [PASS] ^_^");
1833 else
1834 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_OPEN [FAIL] @_@");
1835 break;
1836 }
1837 case FS_CCCI_OP_WRITE:
1838 {
1839 KAL_INT32 ret = *((KAL_UINT32*)(g_LV_out[0].val));
1840 KAL_UINT32 written = *((KAL_UINT32*)(g_LV_out[1].val));
1841 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_WRITE. Return Code = %d, Written = %d",
1842 ret, written);
1843 if (ret == FS_NO_ERROR)
1844 g_eemcs_fs_ut.fs_write_total += written;
1845 /*
1846 * Compare file content with source file
1847 */
1848 if (g_eemcs_fs_ut.fs_write_total == g_test_file[g_eemcs_fs_ut.ftest_idx].size) {
1849 char dst[NAME_MAX] = {0};
1850 void *src_data = NULL;
1851 void *dst_data = NULL;
1852
1853 /* Get source file data */
1854 src_data = get_test_file_data(g_eemcs_fs_ut.ftest_idx);
1855 KAL_ASSERT(src_data != NULL);
1856 /* Get OP_WRITE file data */
1857 sprintf(dst, "%s/%s",
1858 g_test_drive[g_eemcs_fs_ut.drive_idx].fs_root,
1859 g_test_file[g_eemcs_fs_ut.ftest_idx].name);
1860 dst_data = get_file_data(dst, g_eemcs_fs_ut.fs_write_total);
1861 KAL_ASSERT(dst_data != NULL);
1862 /* Compare */
1863 if (memcmp(src_data, dst_data, g_eemcs_fs_ut.fs_write_total) == 0)
1864 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_WRITE [PASS] ^_^");
1865 else
1866 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_WRITE [FAIL] @_@");
1867 destroy_file_data(src_data);
1868 destroy_file_data(dst_data);
1869 g_eemcs_fs_ut.fs_write_total = 0;
1870 break;
1871 } else
1872 goto _wait;
1873 }
1874 case FS_CCCI_OP_GETFILESIZE:
1875 {
1876 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_GETFILESIZE. Return Code = %d, File Size = %d",
1877 *((KAL_UINT32*)(g_LV_out[0].val)),
1878 *((KAL_UINT32*)(g_LV_out[1].val)));
1879 /*
1880 * Compare file size with source file
1881 */
1882 if (g_test_file[g_eemcs_fs_ut.ftest_idx].size == *((KAL_UINT32*)(g_LV_out[1].val)))
1883 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_GETFILESIZE [PASS] ^_^");
1884 else
1885 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_GETFILESIZE [FAIL] @_@");
1886 break;
1887 }
1888 case FS_CCCI_OP_READ:
1889 {
1890 void *src_data = NULL;
1891 char op_read[NAME_MAX] = {0};
1892
1893 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_READ. Return Code = %d, Read = %d, Data = 0x%p",
1894 *((KAL_UINT32*)(g_LV_out[0].val)),
1895 *((KAL_UINT32*)(g_LV_out[1].val)),
1896 g_LV_out[2].val);
1897 /*
1898 * Compare read data with source file
1899 */
1900 if (*((KAL_UINT32*)(g_LV_out[1].val)) == g_test_file[g_eemcs_fs_ut.ftest_idx].size) {
1901 src_data = get_test_file_data(g_eemcs_fs_ut.ftest_idx);
1902 KAL_ASSERT(src_data);
1903 if (memcmp(src_data, g_LV_out[2].val, *((KAL_UINT32*)(g_LV_out[1].val))) == 0)
1904 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_READ [PASS] ^_^");
1905 else {
1906 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_READ [FAIL] @_@");
1907 sprintf(op_read, "%s/fs_ut_op_read_%03d.dat", FS_UT_TEST_FILE_DIR, op_read_cnt++);
1908 dump_data_to_file(op_read, g_LV_out[2].val, *((KAL_UINT32*)(g_LV_out[1].val)));
1909 }
1910 destroy_file_data(src_data);
1911 } else {
1912 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_READ FAIL @_@");
1913 }
1914 break;
1915 }
1916 case FS_CCCI_OP_CLOSE:
1917 {
1918 KAL_INT32 ret = *((KAL_UINT32*)(g_LV_out[0].val));
1919
1920 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_CLOSE. Return Code = %d", ret);
1921 if (ret == FS_NO_ERROR)
1922 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_CLOSE [PASS] ^_^");
1923 else
1924 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_CLOSE [FAIL] @_@");
1925 break;
1926 }
1927 case FS_CCCI_OP_MOVE:
1928 {
1929 KAL_INT32 ret = *((KAL_UINT32*)(g_LV_out[0].val));
1930
1931 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_MOVE. Return Code = %d", ret);
1932 if (ret == FS_NO_ERROR) {
1933 char csSrc[NAME_MAX] = {0};
1934 char csDst[NAME_MAX] = {0};
1935 char *srcData = NULL;
1936 char *dstData = NULL;
1937
1938 // Prepare source file path
1939 sprintf(csSrc, "%s/%s", g_test_drive[g_eemcs_fs_ut.drive_idx].fs_root, g_test_file[g_eemcs_fs_ut.ftest_idx].name);
1940 // Prepare destination file path
1941 sprintf(csDst, "%s/%s/%s",
1942 g_test_drive[g_eemcs_fs_ut.drive_idx].fs_root,
1943 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved,
1944 g_test_file[g_eemcs_fs_ut.ftest_idx].name);
1945 srcData = get_file_data(csSrc, g_test_file[g_eemcs_fs_ut.ftest_idx].size);
1946 KAL_ASSERT(srcData);
1947 dstData = get_file_data(csDst, g_test_file[g_eemcs_fs_ut.ftest_idx].size);
1948 KAL_ASSERT(dstData);
1949 if (memcmp(srcData, dstData, g_test_file[g_eemcs_fs_ut.ftest_idx].size) == 0)
1950 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_MOVE [PASS] ^_^");
1951 else
1952 DBGLOG(FSUT, TRA, "[FSUT] ==> Data of destination file is incorrect !!");
1953 } else
1954 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_MOVE [FAIL] @_@");
1955 break;
1956 }
1957 case FS_CCCI_OP_RENAME:
1958 {
1959 struct file *fp = NULL;
1960 KAL_INT32 ret = *((KAL_UINT32*)(g_LV_out[0].val));
1961
1962 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_RENAME. Return Code = %d", ret);
1963 if (ret == FS_NO_ERROR) {
1964 char csRenamed[NAME_MAX] = {0};
1965
1966 // Prepare renamed file name
1967 sprintf(csRenamed, "%s/%s%s",
1968 g_test_drive[g_eemcs_fs_ut.drive_idx].fs_root,
1969 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved,
1970 g_test_file[g_eemcs_fs_ut.ftest_idx].name);
1971 if ((fp = file_open(csRenamed, O_RDONLY, 0777)) != NULL) {
1972 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_RENAME [PASS] ^_^");
1973 file_close(fp);
1974 } else
1975 DBGLOG(FSUT, TRA, "[FSUT] ==> File doesn't exist !!");
1976 } else
1977 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_RENAME [FAIL] @_@");
1978 break;
1979 }
1980 case FS_CCCI_OP_DELETE:
1981 {
1982 struct file *fp = NULL;
1983 KAL_INT32 ret = *((KAL_UINT32*)(g_LV_out[0].val));
1984
1985 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_DELETE. Return Code = %d", ret);
1986 if (ret == FS_NO_ERROR) {
1987 char csDeleted[NAME_MAX] = {0};
1988
1989 // Prepare renamed file name
1990 sprintf(csDeleted, "%s/%s%s",
1991 g_test_drive[g_eemcs_fs_ut.drive_idx].fs_root,
1992 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved,
1993 g_test_file[g_eemcs_fs_ut.ftest_idx].name);
1994 if ((fp = file_open(csDeleted, O_RDONLY, 0777)) == NULL) {
1995 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_DELETE [PASS] ^_^");
1996 } else
1997 DBGLOG(FSUT, TRA, "[FSUT] ==> File still exist !!");
1998 } else
1999 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_DELETE [FAIL] @_@");
2000 break;
2001 }
2002 case FS_CCCI_OP_GETFOLDERSIZE:
2003 {
2004 KAL_INT32 ret = *((KAL_UINT32*)(g_LV_out[0].val));
2005
2006 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_GETFOLDERSIZE. Cluster Size = %d", ret);
2007 if (ret >= 0)
2008 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_GETFOLDERSIZE [PASS] ^_^");
2009 else
2010 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_GETFOLDERSIZE [FAIL] @_@");
2011 break;
2012 }
2013 case FS_CCCI_OP_COUNT:
2014 {
2015 KAL_INT32 ret = *((KAL_UINT32*)(g_LV_out[0].val));
2016
2017 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_COUNT. Fild Count = %d", ret);
2018 if (ret == EEMCS_FS_TEST_FILE_CNT)
2019 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_COUNT [PASS] ^_^");
2020 else
2021 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_COUNT [FAIL] @_@");
2022 break;
2023 }
2024 case FS_CCCI_OP_XDELETE:
2025 {
2026 struct file *fp = NULL;
2027 KAL_INT32 ret = *((KAL_UINT32*)g_LV_out[0].val);
2028 char dir[NAME_MAX] = {0};
2029
2030 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_XDELETE. Deleted = %d", ret);
2031 if (ret >= 0) {
2032 sprintf(dir, "%s/%s",
2033 g_test_drive[g_eemcs_fs_ut.drive_idx].fs_root,
2034 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
2035 if ((fp = file_open(dir, O_RDONLY, 0777)) == NULL) {
2036 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_XDELETE [PASS] ^_^");
2037 } else {
2038 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_XDELETE [FAIL] @_@");
2039 DBGLOG(FSUT, ERR, "[FSUT] ==> Folder still exist !!");
2040 }
2041 }
2042 else
2043 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_XDELETE [FAIL] @_@");
2044 break;
2045 }
2046 case FS_CCCI_OP_FINDFIRST:
2047 {
2048 char found[NAME_MAX] = {0};
2049
2050 g_eemcs_fs_ut.find_handle = *((KAL_UINT32*)g_LV_out[0].val);
2051 FS_ConvWcsToCs(g_LV_out[2].val, found, g_LV_out[2].len);
2052 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_FINDFIRST. Handle = %d, Found = %s",
2053 g_eemcs_fs_ut.find_handle, found);
2054 if (g_eemcs_fs_ut.find_handle >= 1)
2055 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_FINDFIRST [PASS] ^_^");
2056 else
2057 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_FINDFIRST [FAIL] @_@");
2058 break;
2059 }
2060 case FS_CCCI_OP_FINDNEXT:
2061 {
2062 KAL_INT32 ret = *((KAL_UINT32*)g_LV_out[0].val);
2063 char found[NAME_MAX] = {0};
2064
2065 FS_ConvWcsToCs(g_LV_out[2].val, found, g_LV_out[2].len);
2066 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_FINDNEXT. Return Code = %d, Found = %s",
2067 ret, found);
2068 if (ret == FS_NO_ERROR)
2069 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_FINDNEXT [PASS] ^_^");
2070 else
2071 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_FINDNEXT [FAIL] @_@");
2072 break;
2073 }
2074 case FS_CCCI_OP_FINDCLOSE:
2075 {
2076 KAL_INT32 ret = *((KAL_UINT32*)g_LV_out[0].val);
2077
2078 DBGLOG(FSUT, TRA, "[FSUT] ---------- ACK FS_CCCI_OP_FINDCLOSE. Return Code = %d", ret);
2079 if (ret == FS_NO_ERROR)
2080 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS_CCCI_OP_FINDCLOSE [PASS] ^_^");
2081 else
2082 DBGLOG(FSUT, TRA, "[FSUT] !!!!!!!!!! FS_CCCI_OP_FINDCLOSE [FAIL] @_@");
2083 break;
2084 }
2085
2086 default:
2087 DBGLOG(FSUT, ERR, "[FSUT] Error ACK OP ID %d", op_id);
2088 goto _fail;
2089 }
2090 g_eemcs_fs_ut.test_case_idx++;
2091 eemcs_fs_ut_send_cmd();
2092 _wait:
2093 DEBUG_LOG_FUNCTION_LEAVE;
2094 return KAL_SUCCESS;
2095 _fail:
2096 DEBUG_LOG_FUNCTION_LEAVE;
2097 return KAL_FAIL;
2098 }
2099
2100 void dump_fsd_skb_data(void *data)
2101 {
2102 FS_STREAMBUFFER *stream = NULL;
2103 CCCI_BUFF_T *ccci_h = NULL;
2104
2105 stream = (FS_STREAMBUFFER *)data;
2106 ccci_h = (CCCI_BUFF_T*)&stream->ccci_header;
2107
2108 DBGLOG(FSUT, DBG, "[FSUT][SKB] Stream Header = 0x%p", stream);
2109 DBGLOG(FSUT, DBG, "[FSUT][SKB] CCCI Header = 0x%p", ccci_h);
2110 DBGLOG(FSUT, DBG, "[FSUT][SKB] OP ID = 0x%p", &stream->fs_operationID);
2111 DBGLOG(FSUT, DBG, "[FSUT][SKB] Argc = 0x%p", &stream->buffer[0]);
2112
2113 DBGLOG(FSUT, DBG, "[FSUT][SKB] CCCI_H(0x%X)(0x%X)(0x%X)(0x%X)",
2114 ccci_h->data[0], ccci_h->data[1], ccci_h->channel, ccci_h->reserved);
2115 DBGLOG(FSUT, DBG, "[FSUT][SKB] OP ID = 0x%X", stream->fs_operationID);
2116 DBGLOG(FSUT, DBG, "[FSUT][SKB] %d Arguments", *((KAL_UINT32*)stream->buffer));
2117 }
2118
2119 /*
2120 * @brief
2121 * A function for FS UT.
2122 * This function receives sk buffer containing FS commands from AP.
2123 * @param
2124 * chn [in] Incomming channel of FS commands.
2125 * skb [in] A sk buffer containing FS commands.
2126 * @return
2127 * This function return KAL_SUCCESS always.
2128 */
2129 KAL_INT32 eemcs_fs_ut_UL_write_skb_to_swq(CCCI_CHANNEL_T chn, struct sk_buff *skb)
2130 {
2131 FS_STREAMBUFFER *stream = NULL;
2132 CCCI_BUFF_T *p_buff = NULL;
2133 KAL_INT32 port_index = 0;
2134 void *p_ccci_fs_buff;
2135 void *copy_src = NULL;
2136 void *copy_dst = NULL;
2137 KAL_UINT32 copy_size = 0;
2138 char src_file[NAME_MAX] = {0};
2139 char dst_file[NAME_MAX] = {0};
2140 DEBUG_LOG_FUNCTION_ENTRY;
2141
2142
2143 KAL_ASSERT(chn == CH_FS_TX);
2144 KAL_ASSERT(skb != NULL);
2145 dump_fs_stream_header((void *)skb->data);
2146
2147 stream = (FS_STREAMBUFFER *)skb->data;
2148 p_buff = &stream->ccci_header;
2149 port_index = p_buff->reserved;
2150 dump_fsd_skb_data((void*)stream);
2151
2152 p_ccci_fs_buff = (void*)(&g_eemcs_fs_ut.FS_REQ_BUF[port_index]);
2153 /******************************************
2154 *
2155 * FSM description for re-sent mechanism
2156 * (ccci_fs_buff_state == CCCI_FS_BUFF_IDLE) ==> initial status & end status
2157 * (ccci_fs_buff_state == CCCI_FS_BUFF_WAIT) ==> need to receive again
2158 *
2159 ******************************************/
2160 sprintf(src_file, "%s/fs_ut_ap2md_src_%03d.dat", FS_UT_TEST_FILE_DIR, ap2md_cmd_cnt);
2161 sprintf(dst_file, "%s/fs_ut_ap2md_dst_%03d.dat", FS_UT_TEST_FILE_DIR, ap2md_cmd_cnt++);
2162 if (!CCCI_FS_PEER_REQ_SEND_AGAIN(p_buff)) {
2163 if (g_eemcs_fs_ut.ccci_fs_buff_state[port_index] == CCCI_FS_BUFF_IDLE) {
2164 /* copy data memory and CCCI header */
2165 copy_src = p_buff;
2166 copy_dst = p_ccci_fs_buff;
2167 copy_size = p_buff->data[1];
2168 DBGLOG(FSUT, DBG, "[FSUT][1] Port %d copy %d bytes from 0x%p to 0x%p",
2169 port_index, copy_size, copy_src, copy_dst);
2170 memcpy(copy_dst, copy_src, copy_size);
2171 dump_data_to_file(src_file, copy_src, copy_size);
2172 dump_data_to_file(dst_file, copy_dst, copy_size);
2173 } else if (g_eemcs_fs_ut.ccci_fs_buff_state[port_index] == CCCI_FS_BUFF_WAIT) {
2174 /* copy data memory and NULL, excluding CCCI header, OP id */
2175 copy_src = stream->buffer;
2176 copy_dst = p_ccci_fs_buff + g_eemcs_fs_ut.ccci_fs_buff_offset[port_index];
2177 copy_size = p_buff->data[1] - sizeof(CCCI_BUFF_T) - sizeof(KAL_UINT32);
2178 DBGLOG(FSUT, DBG, "[FSUT][2] Port %d copy %d bytes from 0x%p to 0x%p (offset %d from 0x%p)",
2179 port_index, copy_size, copy_src, copy_dst,
2180 g_eemcs_fs_ut.ccci_fs_buff_offset[port_index], p_ccci_fs_buff);
2181 memcpy(copy_dst, copy_src, copy_size);
2182 dump_data_to_file(src_file, copy_src, copy_size);
2183 dump_data_to_file(dst_file, copy_dst, copy_size);
2184 /* update CCCI header info */
2185 copy_src = p_buff;
2186 copy_dst = p_ccci_fs_buff;
2187 copy_size = sizeof(CCCI_BUFF_T);
2188 DBGLOG(FSUT, DBG, "[FSUT][3] Port %d copy %d bytes from 0x%p to 0x%p",
2189 port_index, copy_size, copy_src, copy_dst);
2190 memcpy(copy_dst, copy_src, copy_size);
2191 sprintf(src_file, "%s/fs_ut_ap2md_src_%03d.dat", FS_UT_TEST_FILE_DIR, ap2md_cmd_cnt);
2192 sprintf(dst_file, "%s/fs_ut_ap2md_dst_%03d.dat", FS_UT_TEST_FILE_DIR, ap2md_cmd_cnt++);
2193 dump_data_to_file(src_file, copy_src, copy_size);
2194 dump_data_to_file(dst_file, copy_dst, copy_size);
2195 } else {
2196 /* No such ccci_fs_buff_state state */
2197 KAL_ASSERT(0);
2198 }
2199 g_eemcs_fs_ut.ccci_fs_buff_state[port_index] = CCCI_FS_BUFF_IDLE;
2200 g_eemcs_fs_ut.ccci_fs_buff_offset[port_index] = 0;
2201 } else {
2202 if (g_eemcs_fs_ut.ccci_fs_buff_state[port_index] == CCCI_FS_BUFF_IDLE) {
2203 /* only "OP id" and "data" size and "CCCI header" */
2204 copy_src = p_buff;
2205 copy_dst = p_ccci_fs_buff;
2206 copy_size = p_buff->data[1];
2207 DBGLOG(FSUT, DBG, "[FSUT][4] Port %d copy %d bytes from 0x%p to 0x%p",
2208 port_index, copy_size, copy_src, copy_dst);
2209 memcpy(copy_dst, copy_src, copy_size);
2210 g_eemcs_fs_ut.ccci_fs_buff_offset[port_index] += copy_size;
2211 dump_data_to_file(src_file, copy_src, copy_size);
2212 dump_data_to_file(dst_file, copy_dst, copy_size);
2213 } else if (g_eemcs_fs_ut.ccci_fs_buff_state[port_index] == CCCI_FS_BUFF_WAIT) {
2214 /* only "data" size, excluding CCCI header and OP id */
2215 copy_src = (void*)&stream->buffer[0];
2216 copy_dst = p_ccci_fs_buff + g_eemcs_fs_ut.ccci_fs_buff_offset[port_index];
2217 copy_size = p_buff->data[1] - sizeof(CCCI_BUFF_T) - sizeof(KAL_UINT32);
2218 DBGLOG(FSUT, DBG, "[FSUT][5] Port %d copy %d bytes from 0x%p to 0x%p (offset %d from 0x%p)",
2219 port_index, copy_size, copy_src, copy_dst,
2220 g_eemcs_fs_ut.ccci_fs_buff_offset[port_index], p_ccci_fs_buff);
2221 memcpy(copy_dst, copy_src, copy_size);
2222 g_eemcs_fs_ut.ccci_fs_buff_offset[port_index] += copy_size;
2223 dump_data_to_file(src_file, copy_src, copy_size);
2224 dump_data_to_file(dst_file, copy_dst, copy_size);
2225 } else {
2226 /* No such ccci_fs_buff_state state */
2227 KAL_ASSERT(0);
2228 }
2229 g_eemcs_fs_ut.ccci_fs_buff_state[port_index] = CCCI_FS_BUFF_WAIT;
2230 }
2231
2232 if (g_eemcs_fs_ut.ccci_fs_buff_state[port_index] == CCCI_FS_BUFF_IDLE) {
2233 DBGLOG(FSUT, DBG, "[FSUT] Port %d packet is receiving done ...", port_index);
2234 dump_fs_stream_header(p_ccci_fs_buff);
2235 // Use ccci_fs_get_buffer to decode data
2236 ccci_fs_get_buff(port_index, g_ccci_fs_paras.op_id, g_ccci_fs_paras.pLV_out, &g_ccci_fs_paras.LV_out_para_cnt);
2237 // Get what your want from argument list
2238 eemcs_fs_ut_ul_handler();
2239 } else {
2240 DBGLOG(FSUT, DBG, "[FSUT] Port %d is still waiting ...", port_index);
2241 }
2242
2243 DEBUG_LOG_FUNCTION_LEAVE;
2244 return KAL_SUCCESS;
2245 }
2246
2247 /*
2248 * @brief A function to simulate MD sending a FS operation to AP
2249 * @param
2250 * None
2251 * @return
2252 * KAL_SUCCESS indicates UT is in progress correctly.
2253 * KAL_FAIL indicates UT is something wrong.
2254 */
2255 KAL_INT32 eemcs_fs_ut_send_cmd(void)
2256 {
2257 EEMCS_FS_TEST_CASE *test_case = NULL;
2258 char csSrc[NAME_MAX] = {0};
2259 char csDst[NAME_MAX] = {0};
2260 wchar_t wcsSrc[NAME_MAX] = {0};
2261 wchar_t wcsDst[NAME_MAX] = {0};
2262 DEBUG_LOG_FUNCTION_ENTRY;
2263
2264 _repeat:
2265 /* All commands are tested */
2266 if (g_eemcs_fs_ut.test_case_idx >= EEMCS_FS_TEST_CASE_CNT) {
2267 /* All file are tested */
2268 if (g_eemcs_fs_ut.ftest_idx >= EEMCS_FS_TEST_FILE_CNT - 1) {
2269 /* All drive are tested */
2270 if (g_eemcs_fs_ut.drive_idx >= EEMCS_FS_TEST_DRV_CNT - 1) {
2271 DBGLOG(FSUT, TRA, "[FSUT] ++++++++++ FS UT DONE !!! ++++++++++");
2272 goto _ok;
2273 } else {
2274 /* Test next drive */
2275 g_eemcs_fs_ut.test_case_idx = 0;
2276 g_eemcs_fs_ut.ftest_idx = 0;
2277 g_eemcs_fs_ut.drive_idx++;
2278 DBGLOG(FSUT, TRA, "[FSUT] Test next drive (%s)",
2279 g_test_drive[g_eemcs_fs_ut.drive_idx].drive);
2280 }
2281 } else {
2282 /* Test next file */
2283 g_eemcs_fs_ut.test_case_idx = 0;
2284 g_eemcs_fs_ut.ftest_idx++;
2285 DBGLOG(FSUT, TRA, "[FSUT] Test next file (%s\\%s)",
2286 g_test_drive[g_eemcs_fs_ut.drive_idx].drive,
2287 g_test_file[g_eemcs_fs_ut.ftest_idx].name);
2288 }
2289 }
2290
2291 test_case = &g_test_case[g_eemcs_fs_ut.test_case_idx];
2292 switch (test_case->op_id) {
2293 case FS_CCCI_OP_REPEAT_START:
2294 {
2295 g_eemcs_fs_ut.test_case_idx++;
2296 goto _repeat;
2297 break;
2298 }
2299 case FS_CCCI_OP_REPEAT_END:
2300 {
2301 if (g_eemcs_fs_ut.ftest_idx < EEMCS_FS_TEST_FILE_CNT - 1) {
2302 g_eemcs_fs_ut.test_case_idx = g_eemcs_fs_ut.loop_start;
2303 g_eemcs_fs_ut.ftest_idx++;
2304 DBGLOG(FSUT, DBG, "[FSUT] Repeat to test next file ...");
2305 goto _repeat;
2306 } else {
2307 g_eemcs_fs_ut.test_case_idx++;
2308 goto _repeat;
2309 }
2310 }
2311 case FS_CCCI_OP_GETDRIVE:
2312 {
2313 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_GETDRIVE");
2314 eemcs_fs_ut_getdrive(g_test_drive[g_eemcs_fs_ut.drive_idx].type,
2315 2, FS_DRIVE_V_REMOVABLE | g_test_drive[g_eemcs_fs_ut.drive_idx].type);
2316 break;
2317 }
2318 case FS_CCCI_OP_GETCLUSTERSIZE:
2319 {
2320 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_GETCLUSTERSIZE");
2321 eemcs_fs_ut_getclustersize(g_test_drive[g_eemcs_fs_ut.drive_idx].drive[0]);
2322 break;
2323 }
2324 case FS_CCCI_OP_CREATEDIR:
2325 {
2326 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_CREATEDIR");
2327 sprintf(csSrc, "%s/%s", g_test_drive[g_eemcs_fs_ut.drive_idx].drive, g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
2328 DBGLOG(FSUT, TRA, "[FSUT] Create Directory %s", csSrc);
2329 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2330 eemcs_fs_ut_createdir(wcsSrc);
2331 break;
2332 }
2333 case FS_CCCI_OP_REMOVEDIR:
2334 {
2335 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_REMOVEDIR");
2336 sprintf(csSrc, "%s/%s", g_test_drive[g_eemcs_fs_ut.drive_idx].drive, g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
2337 DBGLOG(FSUT, TRA, "[FSUT] Remove Directory %s", csSrc);
2338 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2339 eemcs_fs_ut_removedir(wcsSrc);
2340 break;
2341 }
2342 case FS_CCCI_OP_OPEN:
2343 {
2344 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_OPEN");
2345 sprintf(csSrc, "%s/%s", g_test_drive[g_eemcs_fs_ut.drive_idx].drive, g_test_file[g_eemcs_fs_ut.ftest_idx].name);
2346 DBGLOG(FSUT, TRA, "[FSUT] Test File %s", csSrc);
2347 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2348 eemcs_fs_ut_open(wcsSrc, FS_CREATE);
2349 break;
2350 }
2351 case FS_CCCI_OP_WRITE:
2352 {
2353 void *data = NULL;
2354
2355 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_WRITE");
2356 sprintf(csSrc, "%s/%s", FS_UT_TEST_FILE_DIR, g_test_file[g_eemcs_fs_ut.ftest_idx].name);
2357 data = get_file_data(csSrc, g_test_file[g_eemcs_fs_ut.ftest_idx].size);
2358 KAL_ASSERT(data != NULL);
2359 eemcs_fs_ut_write(g_eemcs_fs_ut.fhandle, data, g_test_file[g_eemcs_fs_ut.ftest_idx].size, NULL);
2360 destroy_file_data(data);
2361 break;
2362 }
2363 case FS_CCCI_OP_GETFILESIZE:
2364 {
2365 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_GETFILESIZE");
2366 eemcs_fs_ut_get_file_size(g_eemcs_fs_ut.fhandle, NULL);
2367 break;
2368 }
2369 case FS_CCCI_OP_READ:
2370 {
2371 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_READ");
2372 eemcs_fs_ut_read(g_eemcs_fs_ut.fhandle, NULL, g_test_file[g_eemcs_fs_ut.ftest_idx].size, NULL);
2373 break;
2374 }
2375 case FS_CCCI_OP_CLOSE:
2376 {
2377 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_CLOSE");
2378 eemcs_fs_ut_close(g_eemcs_fs_ut.fhandle);
2379 break;
2380 }
2381 case FS_CCCI_OP_MOVE:
2382 {
2383 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_MOVE");
2384 sprintf(csSrc, "%s/%s", g_test_drive[g_eemcs_fs_ut.drive_idx].drive, g_test_file[g_eemcs_fs_ut.ftest_idx].name);
2385 sprintf(csDst, "%s/%s/%s",
2386 g_test_drive[g_eemcs_fs_ut.drive_idx].drive,
2387 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved,
2388 g_test_file[g_eemcs_fs_ut.ftest_idx].name);
2389 DBGLOG(FSUT, TRA, "[FSUT] Move file from %s to %s", csSrc, csDst);
2390 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2391 FS_ConvCsToWcs(csDst, wcsDst, NAME_MAX);
2392 eemcs_fs_ut_move(wcsSrc, wcsDst, FS_MOVE_COPY);
2393 break;
2394 }
2395 case FS_CCCI_OP_RENAME:
2396 {
2397 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_RENAME");
2398 // Prepare file path
2399 sprintf(csSrc, "%s/%s", g_test_drive[g_eemcs_fs_ut.drive_idx].drive, g_test_file[g_eemcs_fs_ut.ftest_idx].name);
2400 sprintf(csDst, "%s/%s%s",
2401 g_test_drive[g_eemcs_fs_ut.drive_idx].drive,
2402 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved,
2403 g_test_file[g_eemcs_fs_ut.ftest_idx].name);
2404 DBGLOG(FSUT, TRA, "[FSUT] Rename from %s to %s", csSrc, csDst);
2405 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2406 FS_ConvCsToWcs(csDst, wcsDst, NAME_MAX);
2407 eemcs_fs_ut_rename(wcsSrc, wcsDst);
2408 break;
2409 }
2410 case FS_CCCI_OP_DELETE:
2411 {
2412 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_DELETE");
2413 // Prepare file path
2414 sprintf(csSrc, "%s/%s%s",
2415 g_test_drive[g_eemcs_fs_ut.drive_idx].drive,
2416 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved,
2417 g_test_file[g_eemcs_fs_ut.ftest_idx].name);
2418 DBGLOG(FSUT, TRA, "[FSUT] Delete file %s", csSrc);
2419 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2420 eemcs_fs_ut_delete(wcsSrc);
2421 break;
2422 }
2423 case FS_CCCI_OP_GETFOLDERSIZE:
2424 {
2425 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_GETFOLDERSIZE");
2426 // Prepare folder path
2427 sprintf(csSrc, "%s/%s",
2428 g_test_drive[g_eemcs_fs_ut.drive_idx].drive,
2429 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
2430 DBGLOG(FSUT, TRA, "[FSUT] Get size of folder %s", csSrc);
2431 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2432 eemcs_fs_ut_getfoldersize(wcsSrc, FS_COUNT_IN_CLUSTER);
2433 break;
2434 }
2435 case FS_CCCI_OP_COUNT:
2436 {
2437 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_COUNT");
2438 sprintf(csSrc, "%s/%s",
2439 g_test_drive[g_eemcs_fs_ut.drive_idx].drive,
2440 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
2441 DBGLOG(FSUT, TRA, "[FSUT] Get count of folder %s", csSrc);
2442 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2443 eemcs_fs_ut_count(wcsSrc, FS_FILE_TYPE);
2444 break;
2445 }
2446 case FS_CCCI_OP_XDELETE:
2447 {
2448 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_XDELETE");
2449 sprintf(csSrc, "%s/%s",
2450 g_test_drive[g_eemcs_fs_ut.drive_idx].drive,
2451 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
2452 DBGLOG(FSUT, TRA, "[FSUT] Delete folder %s recursively", csSrc);
2453 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2454 eemcs_fs_ut_xdelete(wcsSrc, FS_FILE_TYPE|FS_DIR_TYPE|FS_RECURSIVE_TYPE);
2455 break;
2456 }
2457 case FS_CCCI_OP_FINDFIRST:
2458 {
2459 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_FINDFIRST");
2460 sprintf(csSrc, "%s/%s",
2461 g_test_drive[g_eemcs_fs_ut.drive_idx].drive,
2462 g_test_case[g_eemcs_fs_ut.test_case_idx].reserved);
2463 DBGLOG(FSUT, TRA, "[FSUT] Find pattern %s", csSrc);
2464 FS_ConvCsToWcs(csSrc, wcsSrc, NAME_MAX);
2465 eemcs_fs_ut_findfirst(wcsSrc, 0, 0, NULL, NULL, NAME_MAX);
2466 break;
2467 }
2468 case FS_CCCI_OP_FINDNEXT:
2469 {
2470 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_FINDNEXT");
2471 eemcs_fs_ut_findnext(g_eemcs_fs_ut.find_handle, NULL, NULL, NAME_MAX);
2472 break;
2473 }
2474 case FS_CCCI_OP_FINDCLOSE:
2475 {
2476 DBGLOG(FSUT, TRA, "[FSUT] ====> IN FS_CCCI_OP_FINDCLOSE");
2477 eemcs_fs_ut_findclose(g_eemcs_fs_ut.find_handle);
2478 break;
2479 }
2480 default:
2481 DBGLOG(FSUT, ERR, "[FSUT] !!!!> Error FS UT Test Case Index %d", g_eemcs_fs_ut.test_case_idx);
2482 goto _fail;
2483 }
2484 _ok:
2485 DEBUG_LOG_FUNCTION_LEAVE;
2486 return KAL_SUCCESS;
2487 _fail:
2488 DEBUG_LOG_FUNCTION_LEAVE;
2489 return KAL_FAIL;
2490 }
2491
2492 KAL_INT32 eemcs_fs_ut_init(void)
2493 {
2494 #ifdef _EEMCS_FS_UT
2495 KAL_UINT32 i = 0;
2496 char file_name[NAME_MAX] = {0};
2497 DEBUG_LOG_FUNCTION_ENTRY;
2498
2499 memset(&g_eemcs_fs_ut, 0, sizeof(EEMCS_FS_UT_SET));
2500 g_eemcs_fs_ut.ut_port_index = FS_UT_PORT_INDEX;
2501 /* Initialize buffer status */
2502 for (i = 0; i < FS_CCCI_REQ_BUFFER_NUM; i++) {
2503 g_eemcs_fs_ut.ccci_fs_buff_offset[i] = 0;
2504 g_eemcs_fs_ut.ccci_fs_buff_state[i] = CCCI_FS_BUFF_IDLE;
2505 }
2506 /* Find start and end indicator of repeat commands */
2507 for (i = 0; i < EEMCS_FS_TEST_CASE_CNT; i++) {
2508 g_test_case[i].index =i;
2509 if (g_test_case[i].op_id == FS_CCCI_OP_REPEAT_START)
2510 g_eemcs_fs_ut.loop_start = i;
2511 if (g_test_case[i].op_id == FS_CCCI_OP_REPEAT_END)
2512 g_eemcs_fs_ut.loop_end = i;
2513 }
2514 /* Generate test binary file */
2515 for (i = 0; i < EEMCS_FS_TEST_FILE_CNT; i++) {
2516 sprintf(file_name, "%s/%s", FS_UT_TEST_FILE_DIR, g_test_file[i].name);
2517 if (gen_ap_random_file(file_name, g_test_file[i].size) == KAL_FAIL) {
2518 eemcs_fs_ut_exit();
2519 goto _fail;
2520 }
2521 }
2522 DEBUG_LOG_FUNCTION_LEAVE;
2523 return KAL_SUCCESS;
2524 _fail:
2525 DEBUG_LOG_FUNCTION_LEAVE;
2526 return KAL_FAIL;
2527 #else
2528 DEBUG_LOG_FUNCTION_ENTRY;
2529 DEBUG_LOG_FUNCTION_LEAVE;
2530 return KAL_SUCCESS;
2531 #endif
2532 }
2533
2534 KAL_INT32 eemcs_fs_ut_exit(void)
2535 {
2536 #ifdef _EEMCS_FS_UT
2537 int ret = 0;
2538 KAL_UINT32 i = 0;
2539 char file_name[NAME_MAX] = {0};
2540 DEBUG_LOG_FUNCTION_ENTRY;
2541
2542 for (i = 0; i < EEMCS_FS_TEST_FILE_CNT; i++) {
2543 sprintf(file_name, "%s/%s", FS_UT_TEST_FILE_DIR, g_test_file[i].name);
2544 ret = remove_file(file_name);
2545 if (ret != 0) {
2546 DBGLOG(FSUT, ERR, "[FSUT] Failed to remove file %s", file_name);
2547 }
2548 }
2549 DEBUG_LOG_FUNCTION_LEAVE;
2550 return KAL_SUCCESS;
2551 #else
2552 DEBUG_LOG_FUNCTION_ENTRY;
2553 DEBUG_LOG_FUNCTION_LEAVE;
2554 return KAL_SUCCESS;
2555 #endif
2556 }
2557
2558
2559 /*
2560 * @brief Trigger FS UT procedure
2561 * @param
2562 * None
2563 * @return
2564 * None
2565 */
2566 void eemcs_fs_ut_trigger(void)
2567 {
2568 KAL_INT32 ut_port_index = 0;
2569 KAL_UINT32 loop_start = 0;
2570 KAL_UINT32 loop_end = 0;
2571
2572 /* Reset some variables */
2573 // Keep port index
2574 ut_port_index = g_eemcs_fs_ut.ut_port_index;
2575 loop_start = g_eemcs_fs_ut.loop_start;
2576 loop_end = g_eemcs_fs_ut.loop_end;
2577 memset(&g_eemcs_fs_ut, 0, sizeof(EEMCS_FS_UT_SET));
2578 g_eemcs_fs_ut.ut_port_index = ut_port_index;
2579 g_eemcs_fs_ut.loop_start = loop_start;
2580 g_eemcs_fs_ut.loop_end = loop_end;
2581 eemcs_fs_ut_reset_args();
2582 /* Trigger FS UT to run */
2583 eemcs_fs_ut_send_cmd();
2584 }
2585
2586 /*
2587 * @brief Set the port index to be tested
2588 * @param
2589 * index [in] Port index
2590 * @return
2591 * KAL_SUCCESS if port index is set correctly;
2592 * KAL_FAIL otherwise.
2593 */
2594 KAL_INT32 eemcs_fs_ut_set_index(KAL_UINT32 index)
2595 {
2596 if (index >=0 && index < 5) {
2597 g_eemcs_fs_ut.ut_port_index = index;
2598 return KAL_SUCCESS;
2599 } else {
2600 DBGLOG(FSUT, ERR, "[FSUT] %d is an invalid index !!", index);
2601 return KAL_FAIL;
2602 }
2603 }
2604
2605 /*
2606 * @brief Return the port index currently in use.
2607 * @param
2608 * None
2609 * @return
2610 * The port index currently in use.
2611 */
2612 KAL_UINT32 eemcs_fs_ut_get_index(void)
2613 {
2614 return g_eemcs_fs_ut.ut_port_index;
2615 }
2616
2617 /*
2618 * @brief Display information about FS UT
2619 * @param
2620 * None
2621 * @return
2622 * None
2623 */
2624 void eemcs_fs_ut_dump(void)
2625 {
2626 printk("[FSUT] g_eemcs_fs_ut.test_case_idx = %d\r\n", g_eemcs_fs_ut.test_case_idx);
2627 printk("[FSUT] g_eemcs_fs_ut.ftest_idx = %d\r\n", g_eemcs_fs_ut.ftest_idx);
2628 printk("[FSUT] g_eemcs_fs_ut.fs_write_total = %d\r\n", g_eemcs_fs_ut.fs_write_total);
2629 printk("[FSUT] g_eemcs_fs_ut.ut_port_index = %d\r\n", g_eemcs_fs_ut.ut_port_index);
2630 printk("[FSUT] g_eemcs_fs_ut.loop_start = %d\r\n", g_eemcs_fs_ut.loop_start);
2631 printk("[FSUT] g_eemcs_fs_ut.loop_end = %d\r\n", g_eemcs_fs_ut.loop_end);
2632 }
2633 #endif //_EEMCS_FS_UT
kernel source for telekom puls (alcatel/mediatek)