FreeCalypso > hg > fc-tourmaline

comparison src/g23m-fad/app/app_gdd.c @ 1:fa8dc04885d8

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
src/g23m-*: import from Magnetite
author Mychaela Falconia <falcon@freecalypso.org>
date Fri, 16 Oct 2020 06:25:50 +0000
parents
children
comparison
equal deleted inserted replaced
0:4e78acac3d88 1:fa8dc04885d8
1 /*
2 +------------------------------------------------------------------------------
3 | File: app_gdd.c
4 +------------------------------------------------------------------------------
5 | Copyright 2004 Texas Instruments Berlin, AG
6 | All rights reserved.
7 |
8 | This file is confidential and a trade secret of Texas
9 | Instruments Berlin, AG
10 | The receipt of or possession of this file does not convey
11 | any rights to reproduce or disclose its contents or to
12 | manufacture, use, or sell anything it may describe, in
13 | whole, or in part, without the specific written consent of
14 | Texas Instruments Berlin, AG.
15 +-----------------------------------------------------------------------------
16 | Purpose : Test functions for testing the GDD interface -- command parser.
17 +-----------------------------------------------------------------------------
18 */
19
20
21 #define APP_GDD_C
22
23 /*==== INCLUDES =============================================================*/
24
25 #include "app_util.h"
26
27 #include <string.h> /* String functions, e. g. strncpy(). */
28 #include <ctype.h>
29 #include <stdlib.h>
30 #ifndef _SIMULATION_
31 #endif /* _SIMULATION_ */
32 #include "vsi.h" /* A lot of macros. */
33 #ifndef _SIMULATION_
34 #include "custom.h"
35 #include "gsm.h" /* A lot of macros. */
36 #include "tools.h" /* Common tools. */
37 #endif /* _SIMULATION_ */
38
39 #include "../gdd_dio/gdd.h"
40 #include "../gdd_dio/gdd_dio.h"
41 #include "../gdd_dio/dio_il_psi_stub.h" /* for DIO buffer manipulation functions */
42
43 /*==== Local defines =========================================================*/
44
45 /* Some bogus con handle */
46 #define TEST_CON_HANDLE 1
47
48 /* Max number of test connections required */
49 #define TEST_MAX_CON 4
50
51
52 /*
53 * Command handler
54 */
55
56 /* The base GDD interface functions */
57 static char *app_gdd_init(app_cmd_entry_t *, int, char * [], core_func_t) ;
58 static char *app_gdd_deinit(app_cmd_entry_t *, int, char * [], core_func_t) ;
59 static char *app_gdd_connect(app_cmd_entry_t *, int, char * [], core_func_t) ;
60 static char *app_gdd_disconnect(app_cmd_entry_t *, int, char * [], core_func_t) ;
61 static char *app_gdd_get_send_buffer(app_cmd_entry_t *, int, char * [], core_func_t) ;
62 static char *app_gdd_send_data(app_cmd_entry_t *, int, char * [], core_func_t) ;
63 static char *app_gdd_receive_data(app_cmd_entry_t *, int, char * [], core_func_t) ;
64 static char *app_gdd_sig_ready_rcv(app_cmd_entry_t *, int, char * [], core_func_t) ;
65
66 /* More complex test functions encapsulated in functions */
67 static char *app_gdd_init_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
68 static char *app_gdd_deinit_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
69 static char *app_gdd_connect_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
70 static char *app_gdd_disconnect_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
71 static char *app_gdd_get_send_buffer_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
72 static char *app_gdd_send_data_test_parms(app_cmd_entry_t *, int, char * [], core_func_t) ;
73
74 static char *app_gdd_immediate_disconnect(app_cmd_entry_t *, int, char * [], core_func_t) ;
75
76 #ifdef WIN32
77 /* This function uses psi stub functions which are only available in simulation testing */
78 static char *app_gdd_test_sig_sbuf_avail(app_cmd_entry_t *, int, char * [], core_func_t) ;
79 #endif /* WIN32 */
80
81 /*extern char *app_gdd_sys_test(app_cmd_entry_t *, int, char * [], core_func_t) ;*/
82 static char *app_gdd_test_helper_functions(app_cmd_entry_t *, int, char * [], core_func_t) ;
83
84 /*
85 * Core functions (to be called by the command handler, if applicable)
86 */
87
88 /* -- No core functions required for now */
89
90
91 /* Command handler table. */
92 static app_cmd_entry_t app_gdd_cmd_table[] = {
93 /* Commands that trigger the basic GDD API functions */
94 { "gdd_init", (cmd_handler_t)app_gdd_init, (core_func_t)0, "[BAT|APP] {HowManyCon} [NO|YES]" },
95 { "gdd_deinit", (cmd_handler_t)app_gdd_deinit, (core_func_t)0, "[BAT|APP]" },
96 { "gdd_connect", (cmd_handler_t)app_gdd_connect, (core_func_t)0, "[BAT|APP]" },
97 { "gdd_disconnect", (cmd_handler_t)app_gdd_disconnect, (core_func_t)0, "{ConNum}" },
98 { "gdd_get_send_buffer", (cmd_handler_t)app_gdd_get_send_buffer, (core_func_t)0, "{ConNum} {NumBytes}" },
99 { "gdd_test_send_data", (cmd_handler_t)app_gdd_send_data, (core_func_t)0, "{ConNum} {NumBytes}" },
100 { "gdd_test_receive_data",(cmd_handler_t)app_gdd_receive_data, (core_func_t)0, "{ConNum} {NumBytes}" },
101 { "gdd_sig_ready_rcv", (cmd_handler_t)app_gdd_sig_ready_rcv, (core_func_t)0, "{ConNum}" },
102 /* Commands that test the input parameters of the API functions.
103 These tests are to make sure that the API can handler crappy user input/parameter values. */
104 { "gdd_init_test_parms", (cmd_handler_t)app_gdd_init_test_parms, (core_func_t)0, "" },
105 { "gdd_deinit_test_parms", (cmd_handler_t)app_gdd_deinit_test_parms, (core_func_t)0, "" },
106 { "gdd_connect_test_parms", (cmd_handler_t)app_gdd_connect_test_parms, (core_func_t)0, "" },
107 { "gdd_disconnect_test_parms", (cmd_handler_t)app_gdd_disconnect_test_parms, (core_func_t)0, "" },
108 { "gdd_get_send_buffer_test_parms", (cmd_handler_t)app_gdd_get_send_buffer_test_parms, (core_func_t)0, "" },
109 { "gdd_send_data_test_parms", (cmd_handler_t)app_gdd_send_data_test_parms, (core_func_t)0, "" },
110 /* Test miscellaneous API function / combinations / special cases */
111 { "gdd_test_immediate_disconnect", (cmd_handler_t)app_gdd_immediate_disconnect, (core_func_t)0, "" },
112 #ifdef WIN32
113 { "gdd_test_sig_sbuf_avail", (cmd_handler_t)app_gdd_test_sig_sbuf_avail, (core_func_t)0, "" },
114 #endif /* WIN32 */
115 { "gdd_helper_test", (cmd_handler_t)app_gdd_test_helper_functions, (core_func_t)0, "" },
116 /* { "gdd_sys_test", app_gdd_sys_test, 0, "" }, */
117 { 0, 0, 0, 0}, /* Terminate table */
118 } ;
119
120
121 /*==== Local data ============================================================*/
122
123 #define GDD_MTU_SIZE 1500
124
125 static const T_GDD_FUNC * gdd_func = &gdd_func_dio;
126
127 static const T_GDD_DIO_CAP gdd_dio_cap = { GDD_MTU_SIZE };
128
129
130 /** Local structure for maintaining the test connections */
131 typedef struct
132 {
133 T_GDD_CON_HANDLE con_handle;
134 T_GDD_BUF * send_buf;
135 T_GDD_BUF * rcv_buf;
136 int cnt_sigtype_send_buf_available;
137 } APP_GDD_CON_TABLE_ENTRY;
138
139 static APP_GDD_CON_TABLE_ENTRY con_table[TEST_MAX_CON];
140
141 /*==== Local functions =======================================================*/
142
143
144 /** Create capabilities structure */
145 static T_GDD_CAP gdd_create_capabilities_300()
146 {
147 T_GDD_CAP cap;
148 cap.dio_cap = gdd_dio_cap;
149 return cap;
150 }
151
152
153 static void app_gdd_setup_segment(U8 * ptr, U16 size, U16 offset)
154 {
155 int i;
156 for(i=0; i < size; ++i)
157 {
158 ptr[i] = (U8)i + offset;
159 }
160 }
161
162
163 /** Setup the data bytes in provided buffer in order to create
164 * a well-defined test buffer. The test data is created according
165 * to a simple algorithm. The size is also used as an offset
166 * in the algorithm.
167 */
168 void app_gdd_setup_test_buffer(T_GDD_BUF * buf, U16 size)
169 {
170 void * tmp_buf;
171 MALLOC(tmp_buf, size);
172
173 app_gdd_setup_segment(tmp_buf, size, size);
174
175 if(gdd_write_buf(tmp_buf, size, buf) < 0)
176 {
177 TRACE_ASSERT(0);
178 }
179
180 MFREE(tmp_buf);
181 }
182
183 /** Verify the integrity of a test buffer that has been created
184 * before with the function app_gdd_setup_test_buffer().
185 *
186 * Return TRUE if two buffers are the same, FALSE otherwise */
187 BOOL app_gdd_verify_test_buffer(const T_GDD_BUF * buf, U16 size)
188 {
189 char * tmp_buf_ref;
190 char * tmp_buf_received;
191 MALLOC(tmp_buf_ref, size);
192 MALLOC(tmp_buf_received, size);
193
194 app_gdd_setup_segment((U8 *)tmp_buf_ref, size, size);
195
196 if(gdd_read_buf(buf, (U8 *)tmp_buf_received, size) < 0)
197 {
198 TRACE_ASSERT(0);
199 }
200
201 if(memcmp(tmp_buf_ref, tmp_buf_received, size))
202 {
203 return FALSE;
204 }
205
206 return TRUE;
207 }
208
209
210 /** Convert from instance string representation to the numeric instance number */
211 int get_inst_num(const char * str)
212 {
213 if(!strncmp("BAT", str, 3))
214 return GDD_INST_BAT;
215 else if(!strncmp("APP", str, 3))
216 return GDD_INST_APP;
217 else if(!strncmp("TCP", str, 3))
218 return GDD_INST_TCP;
219 else if(!strncmp("SOCK", str, 4))
220 return GDD_INST_SOCK;
221 else if(!strncmp("SOCKCFG", str, 7))
222 return GDD_INST_SOCKCFG;
223 else
224 return -1; /* invalid instance */
225 }
226
227
228 /* For Target, we must include the two DIO buffer helper functions,
229 because we don't include the PSI stub, where they reside for simulation build. */
230 #if defined (_TARGET_)
231
232 void copy_dio_buf(const T_dio_buffer * buf_in, T_dio_buffer ** buf_out)
233 {
234 int i;
235 T_dio_segment * seg_in;
236 T_dio_segment * seg_out;
237
238 TRACE_FUNCTION( "copy_dio_buf" );
239
240 /* Allocate new buffer */
241 MALLOC((*buf_out), (USHORT)sizeof(T_dio_buffer));
242 (*buf_out)->c_dio_segment = buf_in->c_dio_segment;
243 (*buf_out)->length=buf_in->length;
244
245 /* allocate segement array and copy data accross */
246 MALLOC((*buf_out)->ptr_dio_segment,(USHORT)sizeof(T_dio_segment)*buf_in->c_dio_segment);
247 memcpy((*buf_out)->ptr_dio_segment,buf_in->ptr_dio_segment,(USHORT)sizeof(T_dio_segment)*buf_in->c_dio_segment);
248 (*buf_out)->c_dio_segment = buf_in->c_dio_segment;
249
250 /* Copy each segment */
251 seg_in = buf_in->ptr_dio_segment;
252 seg_out = (*buf_out)->ptr_dio_segment;
253 for(i=0;i<buf_in->c_dio_segment;++i, ++seg_in, ++seg_out )
254 {
255 seg_out->c_data = seg_in->c_data;
256 MALLOC(seg_out->ptr_data, seg_out->c_data);
257 memcpy(seg_out->ptr_data, seg_in->ptr_data, seg_out->c_data);
258 }
259
260 TRACE_EVENT_P1("Allocated new DIO buffer %x", *buf_out);
261 }
262
263 #define TEM__GDD_DIO_MTU_SIZE_MAX 1500
264
265 void allocate_rx_dio_buf(T_dio_buffer ** buf_out)
266 {
267 const U16 segments[] = {2, TEM__GDD_DIO_MTU_SIZE_MAX};
268
269 TRACE_FUNCTION( "allocate_rx_dio_buf" );
270
271 allocate_dio_buf(buf_out, segments, 2);
272 }
273
274
275 void allocate_dio_buf(T_dio_buffer ** buf_out,
276 const U16 seg_size[], U16 num_seg)
277 {
278 int idx_seg;
279
280 TRACE_FUNCTION( "allocate_rx_dio_buf" );
281
282 /* allocate segement array and copy data accross */
283 MALLOC(*buf_out, (USHORT)sizeof(T_dio_buffer));
284 (*buf_out)->c_dio_segment = (U8)num_seg;
285 MALLOC((*buf_out)->ptr_dio_segment,(USHORT)sizeof(T_dio_segment)*(*buf_out)->c_dio_segment);
286 (*buf_out)->length = 0;
287
288 for(idx_seg=0; idx_seg<num_seg; ++idx_seg)
289 {
290 T_dio_segment * seg = &((*buf_out)->ptr_dio_segment[idx_seg]);
291 seg->c_data = seg_size[idx_seg];
292 MALLOC(seg->ptr_data, seg->c_data);
293 (*buf_out)->length += seg->c_data;
294 }
295 }
296
297 void free_dio_buf(T_dio_buffer ** buf)
298 {
299 int i;
300 T_dio_segment * seg = (*buf)->ptr_dio_segment;
301
302 TRACE_FUNCTION( "free_dio_buf" );
303
304 /* Free each segement */
305 for(i=0;i<(*buf)->c_dio_segment; ++i, ++seg)
306 {
307 if (seg->ptr_data NEQ NULL)
308 MFREE(seg->ptr_data);
309 }
310
311 /* Free segment array */
312 if ((*buf)->ptr_dio_segment NEQ NULL)
313 MFREE((*buf)->ptr_dio_segment);
314
315 /* Free the actual buffer */
316 MFREE(*buf);
317
318 (*buf) = 0;
319 }
320
321 #endif /* (_TARGET_) */
322
323
324 /*---------------------------------------------------------------------------
325 * GDD callbacks
326 *---------------------------------------------------------------------------*/
327
328 /** gdd_receive_data_cb */
329 GDD_RESULT app_gdd_receive_data_cb
330 ( T_GDD_CON_HANDLE con_handle,
331 T_GDD_BUF * buf )
332 {
333 int i;
334
335 TRACE_FUNCTION("app_gdd_receive_data_cb");
336
337 /* Search connection slot */
338 for(i = 0; i < TEST_MAX_CON; ++i)
339 {
340 if(con_table[i].con_handle EQ con_handle)
341 {
342 T_GDD_BUF * new_buf;
343
344 if(con_table[i].rcv_buf)
345 {
346 TRACE_ERROR("Receive buffer already in use");
347 return GDD_INTERNAL_ERROR;
348 }
349
350 /* Create a copy of the buffer */
351 copy_dio_buf(
352 (const T_dio_buffer *)buf,
353 (T_dio_buffer **)(&new_buf));
354
355 con_table[i].rcv_buf = new_buf;
356
357 return GDD_OK;
358 }
359 }
360
361 TRACE_ERROR("callback called with bad connection handle");
362 return GDD_INTERNAL_ERROR;
363 }
364
365 /** gdd_signal_cb */
366 GDD_RESULT app_gdd_signal_cb
367 ( T_GDD_CON_HANDLE con_handle,
368 T_GDD_SIGNAL sig )
369 {
370 int i;
371
372 TRACE_FUNCTION("app_gdd_signal_cb");
373
374 /* Search connection slot */
375 for(i = 0; i < TEST_MAX_CON; ++i)
376 {
377 if(con_table[i].con_handle EQ con_handle)
378 {
379 if(sig.sig EQ GDD_SIGTYPE_SEND_BUF_AVAILABLE)
380 {
381 ++con_table[i].cnt_sigtype_send_buf_available;
382 }
383 /* Processing of other signals goes here ... */
384
385 return GDD_OK;
386
387 }
388 }
389
390 /* In case of the connection signal, we might not have a connection slot
391 at this stage, this it is not considered an error. */
392 if( sig.sig NEQ GDD_SIGTYPE_CONNECTION_OPENED )
393 TRACE_ERROR("callback called with bad connection handle");
394
395 return GDD_INTERNAL_ERROR;
396 }
397
398
399 /*---------------------------------------------------------------------------
400 * Definition of command handler functions
401 *---------------------------------------------------------------------------*/
402
403 static char *app_gdd_init
404 (app_cmd_entry_t *cmd_entry_ptr, int argc,
405 char * argv[], core_func_t core_func)
406 {
407 GDD_RESULT result;
408 char * mem = 0;
409 int num_con = get_item(argv[2], 4, TRUE);
410 int inst_id = get_inst_num(argv[1]);
411 if(inst_id < 0)
412 {
413 TRACE_ERROR("Invalid instance specified");
414 BAT_TEST_FAILED();
415 return 0;
416 }
417
418 TRACE_FUNCTION("app_gdd_init");
419
420 if(argv[3] && !strcmp(string_to_lower(argv[3]), "YES"))
421 {
422 MALLOC(mem, num_con * GDD_DIO_SIZEOF_CONDATA);
423 }
424
425 result = gdd_func->gdd_init((T_GDD_INST_ID)inst_id, (char*)mem, (U16)num_con) ;
426 if(result != GDD_OK)
427 {
428 TRACE_ERROR("Call to gdd_init failed");
429 BAT_TEST_FAILED();
430 return 0;
431 }
432
433 BAT_TEST_PASSED();
434 return 0;
435 }
436
437 static char *app_gdd_deinit
438 (app_cmd_entry_t *cmd_entry_ptr, int argc,
439 char * argv[], core_func_t core_func)
440 {
441 GDD_RESULT result;
442 int inst_id = get_inst_num(argv[1]);
443 if(inst_id < 0)
444 {
445 TRACE_ERROR("Invalid instance specified");
446 BAT_TEST_FAILED();
447 return 0;
448 }
449
450 TRACE_FUNCTION("app_gdd_deinit");
451
452 result =(GDD_RESULT)gdd_func->gdd_deinit((T_GDD_INST_ID)inst_id) ;
453 if(result != GDD_OK)
454 {
455 TRACE_ERROR("Call to gdd_deinit failed");
456 BAT_TEST_FAILED();
457 return 0;
458 }
459
460 BAT_TEST_PASSED();
461 return 0;
462 }
463
464 static char *app_gdd_connect
465 (app_cmd_entry_t *cmd_entry_ptr, int argc,
466 char * argv[], core_func_t core_func)
467 {
468 GDD_RESULT result;
469 int i = 0;
470 const T_GDD_CAP gdd_cap = gdd_create_capabilities_300();
471 int inst_id = get_inst_num(argv[1]);
472 if(inst_id < 0)
473 {
474 TRACE_ERROR("Invalid instance specified");
475 BAT_TEST_FAILED();
476 return 0;
477 }
478
479 TRACE_FUNCTION("app_gdd_connect");
480
481
482 /* Find free slot for connection handle */
483 while(i < TEST_MAX_CON && con_table[i].con_handle != 0)
484 {
485 ++i;
486 }
487 if(i EQ TEST_MAX_CON)
488 {
489 TRACE_ERROR("No free slot for connection handle");
490 BAT_TEST_FAILED();
491 return 0;
492 }
493
494 result = gdd_func->gdd_connect
495 ((T_GDD_INST_ID)inst_id, &(con_table[i].con_handle), &gdd_cap,(T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb,(T_GDD_SIGNAL_CB) app_gdd_signal_cb);
496 if(result != GDD_OK)
497 {
498 TRACE_ERROR("Call to gdd_connect failed");
499 BAT_TEST_FAILED();
500 return 0;
501 }
502
503 BAT_TEST_PASSED();
504 return 0;
505 }
506
507 static char *app_gdd_disconnect
508 (app_cmd_entry_t *cmd_entry_ptr, int argc,
509 char * argv[], core_func_t core_func)
510 {
511 GDD_RESULT result;
512 int con_num; /* connection number -index into local static connection table */
513
514 TRACE_FUNCTION("app_gdd_disconnect");
515
516 con_num = get_item(argv[1], 0, FALSE);
517 if(con_num >= TEST_MAX_CON)
518 {
519 TRACE_ERROR("Connection number out of bounds");
520 BAT_TEST_FAILED();
521 return 0;
522 }
523 if(con_table[con_num].con_handle EQ 0)
524 {
525 TRACE_ERROR("Connection number not valid - no connection handle");
526 BAT_TEST_FAILED();
527 return 0;
528 }
529
530 result = gdd_func->gdd_disconnect(con_table[con_num].con_handle);
531 if(result != GDD_OK)
532 {
533 TRACE_ERROR("Call to gdd_disconnect failed");
534 BAT_TEST_FAILED();
535 return 0;
536 }
537
538 /* Free our application buffers which we have allocated ourselfs */
539 if(con_table[con_num].rcv_buf)
540 {
541 free_dio_buf((T_dio_buffer **)(&con_table[con_num].rcv_buf));
542 con_table[con_num].rcv_buf = 0;
543 }
544
545 con_table[con_num].con_handle = 0;
546
547 BAT_TEST_PASSED();
548 return 0;
549 }
550
551 static char *app_gdd_get_send_buffer
552 (app_cmd_entry_t *cmd_entry_ptr, int argc,
553 char * argv[], core_func_t core_func)
554 {
555 GDD_RESULT result;
556 int con_num; /* connection number -index into local static connection table */
557 int num_bytes;
558 T_GDD_BUF * buf;
559
560 TRACE_FUNCTION("app_gdd_get_send_buffer");
561
562 con_num = get_item(argv[1], 0, TRUE);
563 if(con_num >= TEST_MAX_CON)
564 {
565 TRACE_ERROR("Connection number out of bounds");
566 BAT_TEST_FAILED();
567 return 0;
568 }
569 if(con_table[con_num].con_handle EQ 0)
570 {
571 TRACE_ERROR("Connection number not valid - no connection handle");
572 BAT_TEST_FAILED();
573 return 0;
574 }
575
576 num_bytes = get_item(argv[2], 100, FALSE);
577
578 result = gdd_func->gdd_get_send_buffer(con_table[con_num].con_handle, &buf, (U16)num_bytes);
579 if(result != GDD_OK)
580 {
581 TRACE_ERROR("Call to gdd_get_send_buffer failed");
582 BAT_TEST_FAILED();
583 return 0;
584 }
585
586 con_table[con_num].send_buf = buf;
587
588 BAT_TEST_PASSED();
589 return 0;
590 }
591
592 static char *app_gdd_send_data
593 (app_cmd_entry_t *cmd_entry_ptr, int argc,
594 char * argv[], core_func_t core_func)
595 {
596 GDD_RESULT result;
597 int con_num; /* connection number -index into local static connection table */
598 int num_bytes;
599 T_GDD_BUF * buf;
600
601 TRACE_FUNCTION("app_gdd_send_data");
602
603 con_num = get_item(argv[1], 0, TRUE);
604 if(con_num >= TEST_MAX_CON)
605 {
606 TRACE_ERROR("Connection number out of bounds");
607 BAT_TEST_FAILED();
608 return 0;
609 }
610 if(con_table[con_num].con_handle EQ 0)
611 {
612 TRACE_ERROR("Connection number not valid - no connection handle");
613 BAT_TEST_FAILED();
614 return 0;
615 }
616 buf = con_table[con_num].send_buf;
617 if(buf EQ 0)
618 {
619 TRACE_ERROR("No buffer for sending");
620 BAT_TEST_FAILED();
621 return 0;
622 }
623
624 num_bytes = get_item(argv[2], 100, FALSE);
625
626 app_gdd_setup_test_buffer(buf, (U16)num_bytes);
627
628 result = gdd_func->gdd_send_data(con_table[con_num].con_handle, buf);
629 if(result != GDD_OK)
630 {
631 TRACE_ERROR("Call to gdd_get_send_buffer failed");
632 BAT_TEST_FAILED();
633 return 0;
634 }
635
636 con_table[con_num].send_buf = 0;
637
638 BAT_TEST_PASSED();
639 return 0;
640 }
641
642
643
644 static char *app_gdd_receive_data
645 (app_cmd_entry_t *cmd_entry_ptr, int argc,
646 char * argv[], core_func_t core_func)
647 {
648 int con_num; /* connection number -index into local static connection table */
649 int num_bytes;
650 T_GDD_BUF * buf;
651
652 TRACE_FUNCTION("app_gdd_receive_data");
653
654 con_num = get_item(argv[1], 0, FALSE);
655 if(con_num >= TEST_MAX_CON)
656 {
657 TRACE_ERROR("Connection number out of bounds");
658 BAT_TEST_FAILED();
659 return 0;
660 }
661 if(con_table[con_num].con_handle EQ 0)
662 {
663 TRACE_ERROR("Connection number not valid - no connection handle");
664 BAT_TEST_FAILED();
665 return 0;
666 }
667 buf = con_table[con_num].rcv_buf;
668 if(buf EQ 0)
669 {
670 TRACE_ERROR("No buffer received");
671 BAT_TEST_FAILED();
672 return 0;
673 }
674
675 num_bytes = get_item(argv[2], 100, FALSE);
676
677 /* Compare/verify the received buffer */
678 if(app_gdd_verify_test_buffer(buf, (U16)num_bytes) EQ FALSE)
679 {
680 TRACE_ERROR("Verification of received buffer failed");
681 BAT_TEST_FAILED();
682 return 0;
683 }
684
685 /* Free our application buffers which we have allocated ourselfs */
686 if(con_table[con_num].rcv_buf)
687 {
688 free_dio_buf((T_dio_buffer **)(&con_table[con_num].rcv_buf));
689 con_table[con_num].rcv_buf = 0;
690 }
691
692 BAT_TEST_PASSED();
693 return 0;
694 }
695
696
697
698 static char *app_gdd_sig_ready_rcv
699 (app_cmd_entry_t *cmd_entry_ptr, int argc,
700 char * argv[], core_func_t core_func)
701 {
702 int con_num; /* connection number -index into local static connection table */
703
704 TRACE_FUNCTION("app_gdd_sig_ready_rcv");
705
706 con_num = get_item(argv[1], 0, FALSE);
707 if(con_num >= TEST_MAX_CON)
708 {
709 TRACE_ERROR("Connection number out of bounds");
710 BAT_TEST_FAILED();
711 return 0;
712 }
713 if(con_table[con_num].con_handle EQ 0)
714 {
715 TRACE_ERROR("Connection number not valid - no connection handle");
716 BAT_TEST_FAILED();
717 return 0;
718 }
719
720 gdd_func->gdd_signal_ready_rcv(con_table[con_num].con_handle);
721
722 BAT_TEST_PASSED();
723 return 0;
724 }
725
726
727 static char *app_gdd_init_test_parms
728 (app_cmd_entry_t *cmd_entry_ptr, int argc,
729 char * argv[], core_func_t core_func)
730 {
731 GDD_RESULT result;
732
733 TRACE_FUNCTION("app_gdd_init_test_parms");
734
735 /*
736 * Test range of user ID
737 */
738 /*lint -e778*/
739 result = gdd_func->gdd_init(GDD_INST_NONE, (void *)0, (U16)4) ;
740 if(result NEQ GDD_INVALID_PARAMS)
741 {
742 TRACE_ERROR("BAD param value *NOT* detected (user = GDD_INST_BAT - 1)");
743 BAT_TEST_FAILED();
744 return 0;
745 }
746 result = gdd_func->gdd_init(GDD_NUM_INSTS, 0, 4);
747 if(result NEQ GDD_INVALID_PARAMS)
748 {
749 TRACE_ERROR("BAD param value *NOT* detected (user = GDD_NUM_INSTS)");
750 BAT_TEST_FAILED();
751 return 0;
752 }
753
754 /*
755 * Nothing to do for the mem parameter
756 * (should already have been tested before)
757 */
758
759 /*
760 * Test number of connections
761 */
762 result = gdd_func->gdd_init(GDD_INST_BAT, 0, 0);
763 if(result NEQ GDD_INVALID_PARAMS)
764 {
765 TRACE_ERROR("BAD param value *NOT* detected (num_con = 0)");
766 BAT_TEST_FAILED();
767 return 0;
768 }
769 result = gdd_func->gdd_init(GDD_INST_BAT, 0, TEST_MAX_CON+1);
770 if(result NEQ GDD_INVALID_PARAMS)
771 {
772 TRACE_ERROR("BAD param value *NOT* detected (num_con = TEST_MAX_CON+1)");
773 BAT_TEST_FAILED();
774 return 0;
775 }
776
777 BAT_TEST_PASSED();
778 return 0;
779 }
780
781 static char *app_gdd_deinit_test_parms
782 (app_cmd_entry_t *cmd_entry_ptr, int argc,
783 char * argv[], core_func_t core_func)
784 {
785 GDD_RESULT result;
786
787 TRACE_FUNCTION("app_gdd_deinit_test_parms");
788
789 /*
790 * Test range of user ID
791 */
792 result = gdd_func->gdd_deinit(GDD_INST_NONE) ; /*lint -e778*/
793 if(result NEQ GDD_INVALID_PARAMS)
794 {
795 TRACE_ERROR("BAD param value *NOT* detected (user = GDD_INST_BAT - 1)");
796 BAT_TEST_FAILED();
797 return 0;
798 }
799 result = gdd_func->gdd_deinit(GDD_NUM_INSTS);
800 if(result NEQ GDD_INVALID_PARAMS)
801 {
802 TRACE_ERROR("BAD param value *NOT* detected (user = GDD_NUM_INSTS)");
803 BAT_TEST_FAILED();
804 return 0;
805 }
806
807 BAT_TEST_PASSED();
808 return 0;
809 }
810
811 static char *app_gdd_connect_test_parms
812 (app_cmd_entry_t *cmd_entry_ptr, int argc,
813 char * argv[], core_func_t core_func)
814 {
815 GDD_RESULT result;
816 const T_GDD_CAP gdd_cap = gdd_create_capabilities_300();
817
818 TRACE_FUNCTION("app_gdd_connect_test_parms");
819
820 /*
821 * Test range of user ID
822 */
823 result = gdd_func->gdd_connect(GDD_INST_NONE, &(con_table[0].con_handle), /*lint -e778*/
824 &gdd_cap, (T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
825 if(result NEQ GDD_INVALID_PARAMS)
826 {
827 TRACE_ERROR("BAD param value *NOT* detected (user = GDD_INST_BAT - 1)");
828 BAT_TEST_FAILED();
829 return 0;
830 }
831 result = gdd_func->gdd_connect(GDD_NUM_INSTS, &(con_table[0].con_handle),
832 &gdd_cap, (T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
833 if(result NEQ GDD_INVALID_PARAMS)
834 {
835 TRACE_ERROR("BAD param value *NOT* detected (user = GDD_NUM_INSTS)");
836 BAT_TEST_FAILED();
837 return 0;
838 }
839
840 /* Test handling of con_handle = 0 */
841 result = gdd_func->gdd_connect(GDD_INST_BAT, 0,
842 &gdd_cap, (T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
843 if(result NEQ GDD_INVALID_PARAMS)
844 {
845 TRACE_ERROR("BAD param value *NOT* detected (con_handle = 0)");
846 BAT_TEST_FAILED();
847 return 0;
848 }
849
850 /* Test handling of cap = 0 */
851 result = gdd_func->gdd_connect(GDD_INST_BAT, &(con_table[0].con_handle),
852 0, (T_GDD_RECEIVE_DATA_CB)app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
853 if(result NEQ GDD_INVALID_PARAMS)
854 {
855 TRACE_ERROR("BAD param value *NOT* detected (cap = 0)");
856 BAT_TEST_FAILED();
857 return 0;
858 }
859
860 /* Test handling of rcv_cb = 0 */
861 result = gdd_func->gdd_connect(GDD_INST_BAT, &(con_table[0].con_handle),
862 &gdd_cap, 0,(T_GDD_SIGNAL_CB) app_gdd_signal_cb);
863 if(result NEQ GDD_INVALID_PARAMS)
864 {
865 TRACE_ERROR("BAD param value *NOT* detected (rcv_cb = 0)");
866 BAT_TEST_FAILED();
867 return 0;
868 }
869
870 /* Test handling of sig_cb = 0 */
871 result = gdd_func->gdd_connect(GDD_INST_BAT, &(con_table[0].con_handle),
872 &gdd_cap, app_gdd_receive_data_cb, 0);
873 if(result NEQ GDD_INVALID_PARAMS)
874 {
875 TRACE_ERROR("BAD param value *NOT* detected (sig_cb = 0)");
876 BAT_TEST_FAILED();
877 return 0;
878 }
879
880 BAT_TEST_PASSED();
881 return 0;
882 }
883
884 static char *app_gdd_disconnect_test_parms
885 (app_cmd_entry_t *cmd_entry_ptr, int argc,
886 char * argv[], core_func_t core_func)
887 {
888 GDD_RESULT result;
889
890 TRACE_FUNCTION("app_gdd_disconnect_test_parms");
891
892 /* Test handling of con_handle = 0 */
893 result = gdd_func->gdd_disconnect(0);
894 if(result NEQ GDD_INVALID_PARAMS)
895 {
896 TRACE_ERROR("BAD param value *NOT* detected (con_handle = 0)");
897 BAT_TEST_FAILED();
898 return 0;
899 }
900
901 BAT_TEST_PASSED();
902 return 0;
903 }
904
905 static char *app_gdd_get_send_buffer_test_parms
906 (app_cmd_entry_t *cmd_entry_ptr, int argc,
907 char * argv[], core_func_t core_func)
908 {
909 GDD_RESULT result;
910 T_GDD_BUF * buf;
911
912 TRACE_FUNCTION("app_gdd_get_send_buffer_test_parms");
913
914 /* Test handling of con_handle = 0 */
915 result = gdd_func->gdd_get_send_buffer(0, &buf, GDD_MTU_SIZE);
916 if(result NEQ GDD_INVALID_PARAMS)
917 {
918 TRACE_ERROR("BAD param value *NOT* detected (con_handle = 0)");
919 BAT_TEST_FAILED();
920 return 0;
921 }
922
923 /* Test handling of buf = 0 */
924 result = gdd_func->gdd_get_send_buffer(TEST_CON_HANDLE, 0, GDD_MTU_SIZE);
925 if(result NEQ GDD_INVALID_PARAMS)
926 {
927 TRACE_ERROR("BAD param value *NOT* detected (buf = 0)");
928 BAT_TEST_FAILED();
929 return 0;
930 }
931
932 /* Test handling of size = 0 */
933 result = gdd_func->gdd_get_send_buffer(TEST_CON_HANDLE, &buf, 0);
934 if(result NEQ GDD_INVALID_PARAMS)
935 {
936 TRACE_ERROR("BAD param value *NOT* detected (size = 0)");
937 BAT_TEST_FAILED();
938 return 0;
939 }
940 /* Test handling of size > GDD_MTU_SIZE */
941 result = gdd_func->gdd_get_send_buffer(TEST_CON_HANDLE, &buf, GDD_MTU_SIZE+1);
942 if(result NEQ GDD_INVALID_PARAMS)
943 {
944 TRACE_ERROR("BAD param value *NOT* detected (size = GDD_MTU_SIZE+1)");
945 BAT_TEST_FAILED();
946 return 0;
947 }
948
949 BAT_TEST_PASSED();
950 return 0;
951 }
952
953 static char *app_gdd_send_data_test_parms
954 (app_cmd_entry_t *cmd_entry_ptr, int argc,
955 char * argv[], core_func_t core_func)
956 {
957 GDD_RESULT result;
958 T_GDD_BUF buf;
959
960 TRACE_FUNCTION("app_gdd_send_data_test_parms");
961
962 /* Test handling of con_handle = 0 */
963 result = gdd_func->gdd_send_data(0, &buf);
964 if(result NEQ GDD_INVALID_PARAMS)
965 {
966 TRACE_ERROR("BAD param value *NOT* detected (con_handle = 0)");
967 BAT_TEST_FAILED();
968 return 0;
969 }
970
971 /* Test handling of buf = 0 */
972 result = gdd_func->gdd_send_data(TEST_CON_HANDLE, 0);
973 if(result NEQ GDD_INVALID_PARAMS)
974 {
975 TRACE_ERROR("BAD param value *NOT* detected (buf = 0)");
976 BAT_TEST_FAILED();
977 return 0;
978 }
979
980 BAT_TEST_PASSED();
981 return 0;
982 }
983
984
985 /*
986 * Test connect, followed by immedate disconnect without waiting for connect signal
987 */
988 static char *app_gdd_immediate_disconnect
989 (app_cmd_entry_t *cmd_entry_ptr, int argc,
990 char * argv[], core_func_t core_func)
991 {
992 GDD_RESULT result;
993 int con_idx = 0;
994
995 int user_id = get_item(argv[1], GDD_INST_BAT, TRUE);
996 const T_GDD_CAP gdd_cap = gdd_create_capabilities_300();
997
998 TRACE_FUNCTION("app_gdd_immediate_disconnect");
999
1000 /* Find free slot for connection handle */
1001 while(con_idx < TEST_MAX_CON && con_table[con_idx].con_handle != 0)
1002 {
1003 ++con_idx;
1004 }
1005 if(con_idx EQ TEST_MAX_CON)
1006 {
1007 TRACE_ERROR("No free slot for connection handle");
1008 BAT_TEST_FAILED();
1009 return 0;
1010 }
1011
1012 result = gdd_func->gdd_connect
1013 ((T_GDD_INST_ID)user_id, &(con_table[con_idx].con_handle), &gdd_cap,
1014 (T_GDD_RECEIVE_DATA_CB) app_gdd_receive_data_cb, (T_GDD_SIGNAL_CB)app_gdd_signal_cb);
1015 if(result != GDD_OK)
1016 {
1017 TRACE_ERROR("Call to gdd_connect failed");
1018 BAT_TEST_FAILED();
1019 return 0;
1020 }
1021 TRACE_EVENT_P2("Created connection, con_handle = %d (slot %d)", con_table[con_idx].con_handle, con_idx);
1022
1023 /* Don't sleep - but you might want to activate for debugging */
1024 /*vsi_t_sleep (VSI_CALLER 2000);*/
1025
1026 result = gdd_func->gdd_disconnect(con_table[con_idx].con_handle);
1027 if(result != GDD_OK)
1028 {
1029 TRACE_ERROR("Call to gdd_disconnect failed");
1030 BAT_TEST_FAILED();
1031 return 0;
1032 }
1033 TRACE_EVENT_P1("Disconnected connection, con_handle = %d", con_table[con_idx].con_handle);
1034
1035 /* Free connection slot */
1036 con_table[con_idx].con_handle = 0;
1037
1038 BAT_TEST_PASSED();
1039 return 0;
1040 }
1041
1042
1043 #ifdef WIN32
1044
1045 /*
1046 * The the correct sending of the signal GDD_SIGTYPE_SEND_BUF_AVAILABLE
1047 */
1048 static char *app_gdd_test_sig_sbuf_avail
1049 (app_cmd_entry_t *cmd_entry_ptr, int argc,
1050 char * argv[], core_func_t core_func)
1051 {
1052 GDD_RESULT result;
1053 T_GDD_BUF * buf1, * buf2, * buf3;
1054 int con_idx = 0;
1055 int user_id = get_item(argv[1], GDD_INST_BAT, TRUE);
1056 const T_GDD_CAP gdd_cap = gdd_create_capabilities_300();
1057
1058 TRACE_FUNCTION("app_gdd_test_sig_sbuf_avail");
1059
1060 /* Switch off the automatic provision of send buffers in the PSI stub */
1061 psi_stub_send_rx_buf_after_read(FALSE);
1062
1063 /* Find free slot for connection handle */
1064 while(con_idx < TEST_MAX_CON && con_table[con_idx].con_handle != 0)
1065 {
1066 ++con_idx;
1067 }
1068 if(con_idx EQ TEST_MAX_CON)
1069 {
1070 TRACE_ERROR("No free slot for connection handle");
1071 BAT_TEST_FAILED();
1072 return 0;
1073 }
1074
1075 /* Connect & disconnect */
1076 result = gdd_func->gdd_connect
1077 (user_id, &(con_table[con_idx].con_handle), &gdd_cap, app_gdd_receive_data_cb, app_gdd_signal_cb);
1078 if(result != GDD_OK)
1079 {
1080 TRACE_ERROR("Call to gdd_connect failed");
1081 BAT_TEST_FAILED();
1082 return 0;
1083 }
1084 result = gdd_func->gdd_disconnect(con_table[con_idx].con_handle);
1085 if(result != GDD_OK)
1086 {
1087 TRACE_ERROR("Call to gdd_disconnect failed");
1088 BAT_TEST_FAILED();
1089 return 0;
1090 }
1091
1092 /* Reset test counter */
1093 con_table[con_idx].cnt_sigtype_send_buf_available = 0;
1094
1095 /* Create connection */
1096 result = gdd_func->gdd_connect
1097 (user_id, &(con_table[con_idx].con_handle), &gdd_cap, app_gdd_receive_data_cb, app_gdd_signal_cb);
1098 if(result != GDD_OK)
1099 {
1100 TRACE_ERROR("Call to gdd_connect failed");
1101 BAT_TEST_FAILED();
1102 return 0;
1103 }
1104 TRACE_EVENT_P2("Created connection, con_handle = %d (slot %d)", con_table[con_idx].con_handle, con_idx);
1105
1106 /* Wait for 2 seconds to be sure that we will have the send buffer by then. */
1107 vsi_t_sleep (VSI_CALLER 2000);
1108
1109 /* Get a first send buffer */
1110 result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf1, GDD_MTU_SIZE);
1111 if(result NEQ GDD_OK)
1112 {
1113 TRACE_ERROR("Error: gdd_get_send_buffer() failed");
1114 BAT_TEST_FAILED();
1115 return 0;
1116 }
1117
1118 result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf2, GDD_MTU_SIZE);
1119 if(result NEQ GDD_NO_BUF_AVAILABLE)
1120 {
1121 TRACE_ERROR("gdd_get_send_buffer() did not fail as expected");
1122 BAT_TEST_FAILED();
1123 return 0;
1124 }
1125
1126 /* Now we send back the first buffer. */
1127 result = gdd_func->gdd_send_data(con_table[con_idx].con_handle, buf1);
1128 if(result NEQ GDD_OK)
1129 {
1130 TRACE_ERROR("gdd_send_data() failed");
1131 BAT_TEST_FAILED();
1132 return 0;
1133 }
1134
1135 /* Now we can get the second send buffer */
1136 result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf2, GDD_MTU_SIZE);
1137 if(result NEQ GDD_OK)
1138 {
1139 TRACE_ERROR("gdd_get_send_buffer failed");
1140 BAT_TEST_FAILED();
1141 return 0;
1142 }
1143
1144 /* Remove the receive buffer previously received */
1145 free_dio_buf((T_dio_buffer **)(&con_table[con_idx].rcv_buf));
1146 con_table[con_idx].rcv_buf = 0;
1147
1148 /* Now we send back the 2nd buffer buffer. */
1149 result = gdd_func->gdd_send_data(con_table[con_idx].con_handle, buf2);
1150 if(result NEQ GDD_OK)
1151 {
1152 TRACE_ERROR("gdd_send_data() failed");
1153 BAT_TEST_FAILED();
1154 return 0;
1155 }
1156
1157 /* When we try to get the third buffer, we should now fail,
1158 as we switched of automatic provision of RX buffers at the beginning */
1159 result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf3, GDD_MTU_SIZE);
1160 if(result NEQ GDD_NO_BUF_AVAILABLE)
1161 {
1162 TRACE_ERROR("gdd_get_send_buffer should have failed with GDD_NO_BUF_AVAILABLE");
1163 BAT_TEST_FAILED();
1164 return 0;
1165 }
1166
1167 /* Create a new RX buffer in the PSI stub */
1168 psi_stub_provide_rx_buf();
1169
1170 /* Now we should be able to get the new buffer */
1171 result = gdd_func->gdd_get_send_buffer(con_table[con_idx].con_handle, &buf3, GDD_MTU_SIZE);
1172 if(result NEQ GDD_OK)
1173 {
1174 TRACE_ERROR("gdd_get_send_buffer failed");
1175 BAT_TEST_FAILED();
1176 return 0;
1177 }
1178
1179 /* Two signals GDD_SIGTYPE_SEND_BUF_AVAILABLE should have been sent
1180 (one after the connection, and one when we called pst_stub_provide_rx_buf
1181 the last time) */
1182 if(con_table[con_idx].cnt_sigtype_send_buf_available NEQ 1)
1183 {
1184 TRACE_ERROR("Wrong value in cnt_sigtype_send_buf_available");
1185 BAT_TEST_FAILED();
1186 return 0;
1187 }
1188
1189 result = gdd_func->gdd_disconnect(con_table[con_idx].con_handle);
1190 if(result != GDD_OK)
1191 {
1192 TRACE_ERROR("Call to gdd_disconnect failed");
1193 BAT_TEST_FAILED();
1194 return 0;
1195 }
1196 TRACE_EVENT_P1("Disconnected connection, con_handle = %d", con_table[con_idx].con_handle);
1197
1198 /* Free connection slot */
1199 con_table[con_idx].con_handle = 0;
1200
1201 /* Switch on the automatic provision of send buffers in the PSI stub */
1202 psi_stub_send_rx_buf_after_read(TRUE);
1203
1204 BAT_TEST_PASSED();
1205 return 0;
1206 }
1207
1208 #endif /* WIN32 */
1209
1210
1211
1212 /*---------------------------------------------------------------------------
1213 * Testing helper functions.
1214 *---------------------------------------------------------------------------*/
1215
1216 static U32 test_gdd_write_buf()
1217 {
1218 T_dio_buffer * dest_buf;
1219 char src_buf[250];
1220
1221 allocate_rx_dio_buf(&dest_buf);
1222 if(dest_buf->c_dio_segment != 2)
1223 {
1224 return((U32) -1);
1225 }
1226 if(dest_buf->length < (sizeof(src_buf) + 2 /*PID*/))
1227 {
1228 return((U32) -1);
1229 }
1230
1231 app_gdd_setup_segment((U8 *)src_buf, sizeof(src_buf), 22 /* arbitrary offset */);
1232
1233 if(gdd_write_buf(( U8 *)src_buf, sizeof(src_buf), (T_GDD_BUF*)dest_buf) < 0)
1234 {
1235 return((U32) -1);
1236 }
1237
1238 if(memcmp(src_buf, dest_buf->ptr_dio_segment[1].ptr_data, sizeof(src_buf)))
1239 {
1240 return((U32) -1);
1241 }
1242
1243 return 0;
1244 }
1245
1246
1247 /*
1248 * Test the function 'gdd_read_buf()'. Return 0 if OK.
1249 */
1250 static U32 test_gdd_read_buf()
1251 {
1252 char src_buf[500];
1253 char dest_buf[500];
1254 T_dio_buffer * dio_buf;
1255
1256 /* Totol size of 502 bytes over 6 segments (incl.PID in first seg) */
1257 const U16 segments[] = {2, 15, 150, 35, 100, 200};
1258
1259 allocate_dio_buf(&dio_buf, segments, sizeof(segments)/sizeof(U16));
1260
1261 app_gdd_setup_segment((U8 *)src_buf, sizeof(src_buf), 22 /* arbitrary offset */);
1262
1263 if(gdd_write_buf((U8 *)src_buf, sizeof(src_buf), (T_GDD_BUF*)dio_buf) < 0)
1264 {
1265 return((U32)-1);
1266 }
1267
1268 if(gdd_read_buf((T_GDD_BUF*)dio_buf, (U8 *)dest_buf, sizeof(dest_buf)) < 0)
1269 {
1270 return((U32) -1);
1271 }
1272
1273 if(memcmp(src_buf, dest_buf, sizeof(src_buf)))
1274 {
1275 return((U32)-1);
1276 }
1277
1278 return 0;
1279 }
1280
1281
1282 static char *app_gdd_test_helper_functions
1283 (app_cmd_entry_t *cmd_entry_ptr, int argc,
1284 char * argv[], core_func_t core_func)
1285 {
1286 if(test_gdd_write_buf())
1287 {
1288 BAT_TEST_FAILED();
1289 }
1290 if(test_gdd_read_buf())
1291 {
1292 BAT_TEST_FAILED();
1293 }
1294
1295 BAT_TEST_PASSED();
1296 return 0;
1297 }
1298
1299
1300 /*---------------------------------------------------------------------------
1301 * Definition of core functions
1302 *---------------------------------------------------------------------------*/
1303
1304 /* -- No core functions required for now */
1305
1306
1307 /*==== Exported functions ====================================================*/
1308
1309 char *app_handle_command_gdd(char *command)
1310 {
1311 return app_handle_command(command, app_gdd_cmd_table);
1312 }
1313
1314
1315 /* EOF */