1 /*---------------------------------------------------------------------------*
2 Project: TwlSDK - WM - demos - wmDEMOlib
3 File: wm_lib.c
4
5 Copyright 2007-2008 Nintendo. All rights reserved.
6
7 These coded instructions, statements, and computer programs contain
8 proprietary information of Nintendo of America Inc. and/or Nintendo
9 Company Ltd., and are protected by Federal copyright law. They may
10 not be disclosed to third parties or copied or duplicated in any form,
11 in whole or in part, without the prior written consent of Nintendo.
12
13 $Date:: 2008-09-18#$
14 $Rev: 8573 $
15 $Author: okubata_ryoma $
16 *---------------------------------------------------------------------------*/
17
18 // 2005/05/26 update by terui@nintendo
19 #include <nitro/wm.h>
20 #include "wm_lib.h"
21 #include <stdlib.h>
22 #include <string.h>
23
24 void mprintf(const char *fmt, ...);
25
26 #undef WMLIB_DEBUG // Debugging output
27
28 #define CAM_LIFE_TIME 40
29 #define FRAME_LIFE_TIME 5
30 #define TABLE_NO 0xffff
31
32 #undef NO_LIFETIME
33
34 #define STARTCONNECT_EX_TEST 1 // StartConnectEx test
35
36 static BOOL WM_lib_auto_flag = FALSE;
37 static BOOL WM_lib_mp_dcf_parallel = FALSE;
38
39
40 static WM_lib_param *param = NULL; // Pointer to parameter structure
41
42 static void WM_lib_mp_parent_callback(void *arg); // MP parent mode callback
43 static void WM_lib_mp_child_callback(void *arg); // MP child mode callback
44 static void WM_lib_dcf_child_callback(void *arg); // DCF child mode callback
45 static void WM_lib_dummy(void *arg); // Dummy callback
46 static void changeScanChannel(WMscanParam *param); // Scan channel change function
47
48 static void (*callback_ptr) (void *arg);
49
50 static const u8 test_ssid[WM_SIZE_CHILD_SSID] = "TEST SSID\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; // 24Byte
51
52 #if 0
53 #define CHK_ERRCODE(x,y) if ( x != WM_ERRCODE_OPERATING && \
54 x != WM_ERRCODE_SUCCESS) \
55 { \
56 param->callback( WM_TYPE_ERROR, y); \
57 }
58 #else
59 static void check_WMAPI_errcode(u16 apiid, int errcode);
60 #endif
61
conv_errcode(int errcode)62 static inline int conv_errcode(int errcode)
63 {
64 return (errcode == WM_ERRCODE_OPERATING) ? WM_ERRCODE_SUCCESS : errcode;
65 }
66
67 static WMscanParam scanParam ATTRIBUTE_ALIGN(32);
68 static WMscanExParam scanExParam ATTRIBUTE_ALIGN(32);
69 static u16 scanning_flag = 0;
70
71 static BOOL WM_lib_change_scan_channel_flag = TRUE;
72
73 static u16 maxChannelTime_org;
74
75 //--------------------------------------------------------
76 // WM automatic parent child registration feature flag ON
WM_lib_set_auto(BOOL flag)77 void WM_lib_set_auto(BOOL flag)
78 {
79 WM_lib_auto_flag = flag;
80 }
WM_lib_set_mp_dcf_parallel(BOOL flag)81 void WM_lib_set_mp_dcf_parallel(BOOL flag)
82 {
83 WM_lib_mp_dcf_parallel = flag;
84 }
85
86 // Configure MaxScanTime
WM_lib_set_max_scan_time(u16 time)87 void WM_lib_set_max_scan_time(u16 time)
88 {
89 scanParam.maxChannelTime = time;
90 maxChannelTime_org = time;
91 }
92
93 // Get MaxScanTime
WM_lib_get_max_scan_time(void)94 u16 WM_lib_get_max_scan_time(void)
95 {
96 return scanParam.maxChannelTime;
97 }
98
99 // Configure ScanChannel
WM_lib_set_channel(u16 channel)100 void WM_lib_set_channel(u16 channel)
101 {
102 if (channel == 0)
103 {
104 WM_lib_set_scan_channel_seek(TRUE);
105 scanParam.channel = 1;
106 }
107 else
108 {
109 WM_lib_set_scan_channel_seek(FALSE);
110 scanParam.channel = channel;
111 }
112 }
113
114 // MacAddress configuration used in MacAddress (BSSID) filtering during Scan
WM_lib_set_scanBssid(u8 * bssid)115 void WM_lib_set_scanBssid(u8 *bssid)
116 {
117 MI_CpuCopy8(bssid, scanParam.bssid, WM_SIZE_MACADDR);
118 }
119
120 //-------------------------------------------------------------
121 // Parameter configuration function for StartScanEx
122
123 // Configure maxChannelTime for ScanEx
WM_lib_set_scanEx_maxChannelTime(u16 time)124 void WM_lib_set_scanEx_maxChannelTime(u16 time)
125 {
126 scanExParam.maxChannelTime = time;
127 maxChannelTime_org = time;
128 }
129
130 // Get maxChannelTime for ScanEx
WM_lib_get_scanEx_maxChannelTime(void)131 u16 WM_lib_get_scanEx_maxChannelTime(void)
132 {
133 return scanExParam.maxChannelTime;
134 }
135
136 // Channel configuration for ScanEx
WM_lib_set_scanEx_channelList(u16 channelList)137 void WM_lib_set_scanEx_channelList(u16 channelList)
138 {
139 // Be aware that channel is a bitmap
140 // If 0x1041, channels 1, 7, and 13
141 WM_lib_set_scan_channel_seek(FALSE);
142 scanExParam.channelList = channelList;
143 }
144
145 // Get Channel for ScanEx
WM_lib_get_scanEx_channelList(void)146 u16 WM_lib_get_scanEx_channelList(void)
147 {
148 return scanExParam.channelList;
149 }
150
151 // ScanType (passive or active) configuration for ScanEx
WM_lib_set_scanEx_scanType(u16 scanType)152 void WM_lib_set_scanEx_scanType(u16 scanType)
153 {
154 scanExParam.scanType = scanType;
155 }
156
157 // Get ScanType (passive or active) for ScanEx
158 // WM_SCANTYPE_ACTIVE(0), WM_SCANTYPE_PASSIVE(1)
WM_lib_get_scanEx_scanType(void)159 u16 WM_lib_get_scanEx_scanType(void)
160 {
161 return scanExParam.scanType;
162 }
163
164 // SSID filtering (SSID length) configuration for ScanEx
WM_lib_set_scanEx_ssidLength(u16 ssidLength)165 void WM_lib_set_scanEx_ssidLength(u16 ssidLength)
166 {
167 scanExParam.ssidLength = ssidLength;
168 }
169
170 // SSID configuration used in SSID filtering for ScanEx
WM_lib_set_scanEx_ssid(u8 * ssid)171 void WM_lib_set_scanEx_ssid(u8 *ssid)
172 {
173 if (ssid == NULL)
174 {
175 MI_CpuClear8(scanExParam.ssid, WM_SIZE_SSID);
176 }
177 else
178 {
179 MI_CpuCopy8(ssid, scanExParam.ssid, WM_SIZE_SSID);
180 }
181 }
182
183 // MacAddress configuration used in MacAddress(BSSID) filtering for ScanEx
WM_lib_set_scanEx_bssid(u8 * bssid)184 void WM_lib_set_scanEx_bssid(u8 *bssid)
185 {
186 MI_CpuCopy8(bssid, scanExParam.bssid, WM_SIZE_MACADDR);
187 }
188
189
190 //--------------------------------------------------------
191 // WM initialization process
WM_lib_Init(WM_lib_param * para)192 int WM_lib_Init(WM_lib_param * para)
193 {
194 int errcode;
195 param = para;
196
197 param->mpStarted = 0;
198 param->mpBusy = 0;
199 param->child_bitmap = 0;
200 param->currentTgid = 0;
201
202 param->endReq = 0;
203 WM_lib_mp_dcf_parallel = FALSE;
204
205 switch (param->mode)
206 {
207 case WM_MODE_MP_PARENT:
208 callback_ptr = WM_lib_mp_parent_callback;
209 break;
210 case WM_MODE_MP_CHILD:
211 callback_ptr = WM_lib_mp_child_callback;
212 break;
213 case WM_MODE_INFRASTRUCTURE:
214 callback_ptr = WM_lib_dcf_child_callback;
215 break;
216 default:
217 callback_ptr = WM_lib_dummy;
218 return WM_ERRCODE_FAILED;
219 }
220
221 do
222 {
223 errcode = WM_Initialize(param->wmBuf, callback_ptr, WM_DMA_NO);
224 }
225 while (errcode == WM_ERRCODE_WM_DISABLE);
226 if (errcode != WM_ERRCODE_OPERATING)
227 {
228 return WM_ERRCODE_FAILED;
229 }
230 else
231 {
232 return WM_SetIndCallback(callback_ptr);
233 }
234 }
235
236 //=================================================================
237 // Dummy callback
WM_lib_dummy(void * arg)238 static void WM_lib_dummy(void *arg)
239 {
240 WMCallback *buf = (WMCallback *)arg;
241 }
242
243 //=================================================================
244 // MP parent callback
WM_lib_mp_parent_callback(void * arg)245 void WM_lib_mp_parent_callback(void *arg)
246 {
247 int errcode;
248 WMCallback *buf = (WMCallback *)arg;
249
250 switch (buf->apiid)
251 {
252 case WM_APIID_START_PARENT:
253 {
254 WMstartParentCallback *callback = (WMstartParentCallback *)arg;
255
256 #ifdef WMLIB_DEBUG
257 OS_Printf("StartParent callback\n");
258 OS_Printf(" state:%d\n", callback->state);
259 #endif
260
261 if (WM_ERRCODE_SUCCESS == callback->errcode)
262 {
263 switch (callback->state)
264 {
265 case WM_STATECODE_PARENT_START:
266 param->callback(WM_TYPE_PARENT_STARTED, arg);
267 break;
268
269 case WM_STATECODE_CONNECTED:
270 errcode = WM_ReadStatus(param->statusBuf);
271 check_WMAPI_errcode(WM_APIID_READ_STATUS, errcode);
272
273 // Load status
274 param->child_bitmap = param->statusBuf->child_bitmap;
275
276 if (WM_lib_auto_flag == TRUE)
277 {
278 wm_lib_add_child_list(callback);
279 }
280
281 param->callback(WM_TYPE_CHILD_CONNECTED, arg);
282
283 if (param->statusBuf->mp_flag == 0) // If MP has not been started, start MP
284 {
285 errcode = WM_StartMPEx(WM_lib_mp_parent_callback, param->recvBuf, param->recvBufSize, param->sendBuf, param->sendBufSize, (u16)(param->contSend ? 0 : 1), 0, FALSE, FALSE, param->no_retry, // Default is FALSE
286 param->contSend ? TRUE : FALSE // ignoreFatalError
287 );
288
289 check_WMAPI_errcode(WM_APIID_START_MP, errcode);
290 }
291 // MP send-enabled callback
292 if (TRUE == WM_lib_CheckMPSend())
293 {
294 param->callback(WM_TYPE_MP_SEND_ENABLE, NULL);
295 }
296 break;
297
298 case WM_STATECODE_DISCONNECTED:
299 errcode = WM_ReadStatus(param->statusBuf); // Load status
300 check_WMAPI_errcode(WM_APIID_READ_STATUS, errcode);
301
302 param->child_bitmap = param->statusBuf->child_bitmap;
303
304 if (WM_lib_auto_flag == TRUE)
305 {
306 wm_lib_delete_child_list(callback);
307 }
308 param->callback(WM_TYPE_CHILD_DISCONNECTED, arg);
309 break;
310
311 case WM_STATECODE_DISCONNECTED_FROM_MYSELF:
312 // Does nothing if the unit disconnects from itself
313 break;
314
315 case WM_STATECODE_BEACON_SENT: // Send a notification that beacon transmission completed
316 param->callback(WM_TYPE_BEACON_SENT, arg);
317 break;
318
319 default:
320 param->callback(WM_TYPE_ERROR, arg);
321 break;
322 }
323 }
324 else
325 {
326 param->callback(WM_TYPE_ERROR, arg);
327 }
328 }
329 break;
330
331 case WM_APIID_SET_LIFETIME:
332 {
333 if (WM_ERRCODE_SUCCESS == buf->errcode)
334 {
335 param->callback(WM_TYPE_SET_LIFETIME, arg);
336
337 // Issue API
338 errcode = WM_SetParentParameter(WM_lib_mp_parent_callback, param->parentParam);
339 check_WMAPI_errcode(WM_APIID_SET_P_PARAM, errcode);
340 }
341 else
342 {
343 param->callback(WM_TYPE_ERROR, arg);
344 }
345 }
346 break;
347
348 case WM_APIID_START_MP:
349 {
350 // An error code does not get returned here
351 WMstartMPCallback *callback = (WMstartMPCallback *)arg;
352
353 #ifdef WMLIB_DEBUG
354 OS_Printf("StartMP callback\n");
355 OS_Printf(" state:%d\n", callback->state);
356 #endif
357 switch (callback->state)
358 {
359 case WM_STATECODE_MP_START:
360 param->mpStarted = 1; // Set the flag that indicates MP has started
361 param->callback(WM_TYPE_MP_STARTED, arg);
362
363 if (param->keySharing == 1)
364 {
365 // Start KeySharing
366 errcode = WM_StartKeySharing(param->ksBuf, WM_PORT_KEYSHARING);
367 check_WMAPI_errcode(WM_APIID_START_KS, errcode);
368 if (TRUE == WM_lib_CheckMPSend())
369 param->callback(WM_TYPE_MP_SEND_ENABLE, NULL);
370 }
371 else
372 {
373 // MP send-enabled callback
374 if (TRUE == WM_lib_CheckMPSend())
375 {
376 param->callback(WM_TYPE_MP_SEND_ENABLE, NULL);
377 if (WM_lib_mp_dcf_parallel == TRUE)
378 {
379 errcode =
380 WM_StartDCF(WM_lib_mp_parent_callback, param->dcfBuf,
381 param->dcfBufSize);
382 check_WMAPI_errcode(WM_APIID_START_DCF, errcode);
383 }
384 }
385 }
386 break;
387
388 case WM_STATECODE_MPEND_IND:
389 // MP receive callback
390 param->callback(WM_TYPE_MP_PARENT_RECV, (void *)(callback->recvBuf));
391 break;
392
393 default:
394 param->callback(WM_TYPE_ERROR, arg);
395 break;
396 }
397 break;
398 }
399 break;
400
401 case WM_APIID_START_DCF:
402 if (WM_ERRCODE_SUCCESS == buf->errcode)
403 {
404 #if 0
405 #define WM_TYPE_DCF_STARTED
406 #define WM_TYPE_DCF_SENT
407 #define WM_TYPE_DCF_SENT_ERR
408 #define WM_TYPE_DCF_RECV
409 #define WM_TYPE_DCF_END
410 #endif
411 param->callback(WM_TYPE_DCF_STARTED, arg);
412 }
413 else
414 {
415 param->callback(WM_TYPE_ERROR, arg);
416 }
417 break;
418
419 case WM_APIID_SET_MP_DATA:
420 {
421 param->mpBusy = 0;
422
423 if (buf->errcode == WM_ERRCODE_SUCCESS)
424 {
425 param->callback(WM_TYPE_MP_PARENT_SENT, arg);
426 param->callback(WM_TYPE_MP_SEND_ENABLE, NULL); // Allow the next transmission
427 }
428 else if (buf->errcode == WM_ERRCODE_SEND_QUEUE_FULL)
429 {
430 param->callback(WM_TYPE_SEND_QUEUE_FULL_ERR, arg);
431 }
432 else
433 {
434 param->callback(WM_TYPE_MP_PARENT_SENT_ERR, arg);
435 param->callback(WM_TYPE_MP_SEND_ENABLE, NULL); // Allow the next transmission
436 }
437 }
438 break;
439
440 case WM_APIID_INITIALIZE:
441 {
442 if (WM_ERRCODE_SUCCESS == buf->errcode)
443 {
444 errcode = WM_ReadStatus(param->statusBuf);
445 check_WMAPI_errcode(WM_APIID_READ_STATUS, errcode);
446 // Load status
447 // Issue API
448 errcode = WM_SetIndCallback(WM_lib_mp_parent_callback);
449 check_WMAPI_errcode(WM_APIID_INDICATION, errcode);
450 #ifdef NO_LIFETIME
451 errcode =
452 WM_SetLifeTime(WM_lib_mp_parent_callback, TABLE_NO, 0xffff, 0xffff, 0xffff);
453 #else
454 errcode =
455 WM_SetLifeTime(WM_lib_mp_parent_callback, TABLE_NO, CAM_LIFE_TIME,
456 FRAME_LIFE_TIME, CAM_LIFE_TIME);
457 #endif
458 check_WMAPI_errcode(WM_APIID_SET_LIFETIME, errcode);
459 }
460 else
461 {
462 param->callback(WM_TYPE_ERROR, arg);
463 }
464 }
465 break;
466
467 #if 1
468 case WM_APIID_SET_P_PARAM:
469 {
470 param->callback(WM_TYPE_INIT_COMPLETE, arg);
471 // An error code does not get returned here
472 errcode = WM_SetBeaconIndication(WM_lib_mp_parent_callback, 1 /* 1:ON, 0:OFF */ );
473 check_WMAPI_errcode(WM_APIID_SET_BEACON_IND, errcode);
474 }
475 break;
476 // Check whether or not to cause Beacon Send/Recv Indication to be issued
477 case WM_APIID_SET_BEACON_IND:
478 {
479 if (WM_ERRCODE_SUCCESS == buf->errcode)
480 {
481 errcode = WM_StartParent(WM_lib_mp_parent_callback);
482 check_WMAPI_errcode(WM_APIID_START_PARENT, errcode);
483 }
484 else
485 {
486 param->callback(WM_TYPE_ERROR, arg);
487 }
488 }
489 break;
490 #else
491 case WM_APIID_SET_P_PARAM:
492 {
493 param->callback(WM_TYPE_INIT_COMPLETE, arg);
494 // An error code does not get returned here
495 errcode = WM_StartParent(WM_lib_mp_parent_callback);
496 check_WMAPI_errcode(WM_APIID_START_PARENT, errcode);
497 }
498 break;
499 #endif
500
501 case WM_APIID_RESET:
502 {
503 #ifdef WMLIB_DEBUG
504 OS_Printf("Reset callback\n");
505 OS_Printf(" errcode:%d\n", buf->errcode);
506 #endif
507 if (buf->errcode == WM_ERRCODE_SUCCESS)
508 {
509 errcode = WM_End(WM_lib_mp_parent_callback);
510 check_WMAPI_errcode(WM_APIID_END, errcode);
511 }
512 else
513 {
514 param->endReq = 0;
515 param->callback(WM_TYPE_ERROR, arg);
516 }
517 }
518 break;
519
520 case WM_APIID_END:
521 {
522 param->endReq = 0;
523 if (buf->errcode == WM_ERRCODE_SUCCESS)
524 {
525 param->callback(WM_TYPE_END_COMPLETE, arg);
526 }
527 else
528 {
529 param->callback(WM_TYPE_ERROR, arg);
530 }
531 }
532 break;
533
534 case WM_APIID_DISCONNECT:
535 {
536 WMDisconnectCallback *cb = (WMDisconnectCallback *)buf;
537 #ifdef WMLIB_DEBUG
538 OS_Printf("Disconnect callback\n");
539 OS_Printf(" cb->errcode = %d\n", cb->errcode);
540 OS_Printf(" cb->wlCmdID = %d\n", cb->wlCmdID);
541 OS_Printf(" cb->wlResult = %d\n", cb->wlResult);
542 OS_Printf(" cb->tryBitmap = %d\n", cb->tryBitmap);
543 OS_Printf(" cb->disconnectedBitmap = %d\n", cb->disconnectedBitmap);
544 #endif
545 if (buf->errcode == WM_ERRCODE_SUCCESS)
546 {
547 // Update child information
548 errcode = WM_ReadStatus(param->statusBuf);
549 check_WMAPI_errcode(WM_APIID_READ_STATUS, errcode);
550 param->child_bitmap = param->statusBuf->child_bitmap;
551
552 if (WM_lib_auto_flag == TRUE)
553 {
554 wm_lib_delete_child_list((WMstartParentCallback *)arg);
555 }
556 param->callback(WM_TYPE_DISCONNECT_COMPLETE, arg);
557 }
558 else
559 {
560 param->callback(WM_TYPE_DISCONNECT_FAILED, arg);
561 }
562 }
563 break;
564
565 case WM_APIID_SET_GAMEINFO:
566 {
567 if (buf->errcode == WM_ERRCODE_SUCCESS)
568 {
569 param->callback(WM_TYPE_SET_GAMEINFO_COMPLETE, arg);
570 }
571 else
572 {
573 param->callback(WM_TYPE_ERROR, arg);
574 }
575 }
576 break;
577
578 case WM_APIID_END_MP:
579 {
580 param->callback(WM_TYPE_END_MP_COMPLETE, arg);
581 }
582 break;
583
584 case WM_APIID_INDICATION:
585 {
586 WMindCallback *cb = (WMindCallback *)arg;
587 switch (cb->state)
588 {
589 case WM_STATECODE_BEACON_RECV: // Indicate beacon received
590 param->callback(WM_TYPE_BEACON_RECV, arg);
591 break;
592 case WM_STATECODE_DISASSOCIATE: // Indicate disconnection
593 param->callback(WM_TYPE_DISASSOCIATE, arg);
594 break;
595 case WM_STATECODE_REASSOCIATE: // Indicate reconnection
596 param->callback(WM_TYPE_REASSOCIATE, arg);
597 break;
598 case WM_STATECODE_AUTHENTICATE: // Indicate confirmed authentication
599 param->callback(WM_TYPE_AUTHENTICATE, arg);
600 break;
601 }
602 }
603 break;
604
605 default:
606 param->callback(WM_TYPE_ERROR, arg);
607 break;
608
609 }
610 }
611
612 //=================================================================
613 // MP child callback
WM_lib_mp_child_callback(void * arg)614 void WM_lib_mp_child_callback(void *arg)
615 {
616 WMCallback *buf = (WMCallback *)arg;
617 int errcode;
618
619 switch (buf->apiid)
620 {
621 //---------------------------------------------------------------
622 case WM_APIID_INITIALIZE:
623 {
624 if (WM_ERRCODE_SUCCESS == buf->errcode)
625 {
626 #ifdef WMLIB_DEBUG
627 OS_TPrintf("mp C: WM_Initialize callback\n");
628 #endif
629 param->callback(WM_TYPE_INIT_COMPLETE, arg);
630 {
631 errcode = WM_ReadStatus(param->statusBuf); // Load status
632 check_WMAPI_errcode(WM_APIID_READ_STATUS, errcode);
633
634 // Issue API
635 errcode = WM_SetIndCallback(WM_lib_mp_child_callback);
636 check_WMAPI_errcode(WM_APIID_INDICATION, errcode);
637 #ifdef NO_LIFETIME
638 errcode =
639 WM_SetLifeTime(WM_lib_mp_child_callback, TABLE_NO, 0xffff, 0xffff, 0xffff);
640 #else
641 errcode =
642 WM_SetLifeTime(WM_lib_mp_child_callback, TABLE_NO, CAM_LIFE_TIME,
643 FRAME_LIFE_TIME, CAM_LIFE_TIME);
644 #endif
645 check_WMAPI_errcode(WM_APIID_SET_LIFETIME, errcode);
646 }
647 }
648 else
649 {
650 param->callback(WM_TYPE_ERROR, arg);
651 }
652 }
653 break;
654
655 //---------------------------------------------------------------
656 case WM_APIID_SET_LIFETIME:
657 {
658 #ifdef WMLIB_DEBUG
659 OS_TPrintf("mp C: WM_SetLifeTime callback\n");
660 #endif
661 if (WM_ERRCODE_SUCCESS == buf->errcode)
662 {
663 param->callback(WM_TYPE_SET_LIFETIME, arg);
664
665 // Issue WM_StartScan
666 if (param->scanExFlag == TRUE)
667 {
668 // When using WM_StartScanEx
669 scanExParam.scanBuf = param->parentInfoBuf;
670 scanExParam.scanBufSize = param->parentInfoBufSize;
671
672 if (scanExParam.maxChannelTime == 0)
673 WM_lib_set_scanEx_maxChannelTime(200);
674
675 scanExParam.bssid[0] = 0xff;
676 scanExParam.bssid[1] = 0xff;
677 scanExParam.bssid[2] = 0xff;
678 scanExParam.bssid[3] = 0xff;
679 scanExParam.bssid[4] = 0xff;
680 scanExParam.bssid[5] = 0xff;
681
682 scanning_flag = 1;
683 errcode = WM_StartScanEx(WM_lib_mp_child_callback, &scanExParam);
684 check_WMAPI_errcode(WM_APIID_START_SCAN_EX, errcode);
685 }
686 else
687 {
688 // When using WM_StartScan
689 scanParam.scanBuf = param->parentInfoBuf;
690
691 if (scanParam.channel == 0)
692 scanParam.channel = 1;
693 if (scanParam.maxChannelTime == 0)
694 WM_lib_set_max_scan_time(200);
695
696 scanParam.bssid[0] = 0xff;
697 scanParam.bssid[1] = 0xff;
698 scanParam.bssid[2] = 0xff;
699 scanParam.bssid[3] = 0xff;
700 scanParam.bssid[4] = 0xff;
701 scanParam.bssid[5] = 0xff;
702
703 scanning_flag = 1;
704 errcode = WM_StartScan(WM_lib_mp_child_callback, &scanParam);
705 check_WMAPI_errcode(WM_APIID_START_SCAN, errcode);
706 }
707 }
708 else
709 {
710 param->callback(WM_TYPE_ERROR, arg);
711 }
712 }
713 break;
714
715 //---------------------------------------------------------------
716 case WM_APIID_START_SCAN:
717 {
718 WMstartScanCallback *callback = (WMstartScanCallback *)arg;
719
720 #ifdef WMLIB_DEBUG
721 OS_TPrintf("mp C: WM_StartScan callback\n");
722 #endif
723 if (WM_ERRCODE_SUCCESS == callback->errcode)
724 {
725 switch (callback->state)
726 {
727 case WM_STATECODE_SCAN_START:
728 break;
729
730 case WM_STATECODE_PARENT_FOUND:
731 if (WM_lib_auto_flag)
732 { // When using wm_tool.c automation
733 if (WM_IsValidGameInfo
734 (&((WMstartScanCallback *)arg)->gameInfo,
735 ((WMstartScanCallback *)arg)->gameInfoLength))
736 {
737 wm_lib_add_parent_list((WMstartScanCallback *)arg);
738 }
739 }
740
741 param->callback(WM_TYPE_PARENT_FOUND, arg);
742 if (scanning_flag == 1)
743 {
744 if (WM_lib_change_scan_channel_flag == TRUE)
745 changeScanChannel(&scanParam);
746
747 errcode = WM_StartScan(WM_lib_mp_child_callback, &scanParam);
748 check_WMAPI_errcode(WM_APIID_START_SCAN, errcode);
749 }
750 break;
751
752 case WM_STATECODE_PARENT_NOT_FOUND:
753 if (WM_lib_auto_flag)
754 { // When using wm_tool.c automation
755 wm_lib_delete_parent_list((WMstartScanCallback *)arg);
756 }
757 param->callback(WM_TYPE_PARENT_NOT_FOUND, arg);
758 if (scanning_flag == 1)
759 {
760 if (WM_lib_change_scan_channel_flag == TRUE)
761 changeScanChannel(&scanParam);
762
763 errcode = WM_StartScan(WM_lib_mp_child_callback, &scanParam);
764 check_WMAPI_errcode(WM_APIID_START_SCAN, errcode);
765 }
766 break;
767
768 default:
769 param->callback(WM_TYPE_ERROR, arg);
770 break;
771 }
772 }
773 else
774 {
775 param->callback(WM_TYPE_ERROR, arg);
776 }
777 }
778 break;
779
780 //---------------------------------------------------------------
781 case WM_APIID_START_SCAN_EX:
782 {
783 WMstartScanExCallback *callback = (WMstartScanExCallback *)arg;
784
785 #ifdef WMLIB_DEBUG
786 OS_TPrintf("mp C: WM_StartScanEx callback\n");
787 #endif
788 if (WM_ERRCODE_SUCCESS == callback->errcode)
789 {
790 switch (callback->state)
791 {
792 case WM_STATECODE_SCAN_START:
793 break;
794
795 case WM_STATECODE_PARENT_FOUND:
796 if (WM_lib_auto_flag)
797 { // When using wm_tool.c automation
798 WMBssDesc *p_bssDesc;
799 u16 bssDescCount;
800 int i;
801
802 bssDescCount = ((WMStartScanExCallback *)arg)->bssDescCount;
803 for (i = 0; i < bssDescCount; ++i)
804 {
805 p_bssDesc = ((WMStartScanExCallback *)arg)->bssDesc[i];
806
807 if (WM_IsValidGameInfo(&p_bssDesc->gameInfo, p_bssDesc->gameInfoLength))
808 {
809 wm_lib_add_parent_listEx((WMstartScanExCallback *)arg);
810 }
811 }
812 }
813
814 param->callback(WM_TYPE_PARENT_FOUND, arg);
815 if (scanning_flag == 1)
816 {
817 errcode = WM_StartScanEx(WM_lib_mp_child_callback, &scanExParam);
818 check_WMAPI_errcode(WM_APIID_START_SCAN_EX, errcode);
819 }
820 break;
821
822 case WM_STATECODE_PARENT_NOT_FOUND:
823 param->callback(WM_TYPE_PARENT_NOT_FOUND, arg);
824 if (scanning_flag == 1)
825 {
826 errcode = WM_StartScanEx(WM_lib_mp_child_callback, &scanExParam);
827 check_WMAPI_errcode(WM_APIID_START_SCAN_EX, errcode);
828 }
829 break;
830
831 default:
832 param->callback(WM_TYPE_ERROR, arg);
833 break;
834 }
835 }
836 else
837 {
838 param->callback(WM_TYPE_ERROR, arg);
839 }
840 }
841 break;
842
843 //---------------------------------------------------------------
844 case WM_APIID_END_SCAN:
845 {
846 if (WM_ERRCODE_SUCCESS == buf->errcode)
847 {
848 errcode = WM_StartConnect(WM_lib_mp_child_callback, param->pInfo, test_ssid);
849 //errcode = WM_StartConnect( WM_lib_mp_child_callback, param->pInfo, NULL );
850 check_WMAPI_errcode(WM_APIID_START_CONNECT, errcode);
851 }
852 else
853 {
854 param->callback(WM_TYPE_ERROR, arg);
855 }
856 }
857 break;
858
859 //---------------------------------------------------------------
860 case WM_APIID_START_CONNECT:
861 {
862 WMstartConnectCallback *callback = (WMstartConnectCallback *)arg;
863
864 if (callback->errcode == WM_ERRCODE_SUCCESS)
865 {
866 switch (callback->state)
867 {
868 case WM_STATECODE_CONNECT_START:
869 break;
870
871 case WM_STATECODE_CONNECTED:
872 if (WM_lib_auto_flag == TRUE)
873 {
874 wm_lib_set_my_aid(callback->aid);
875 }
876 param->callback(WM_TYPE_CONNECTED_TO_PARENT, arg);
877 param->child_bitmap = 1;
878 #if 0
879 OS_Printf("WM_GetMPReceiveBufferSize:%d\n", WM_GetMPReceiveBufferSize());
880
881 OS_Printf("WM_GetMPSendBufferSize :%d\n", WM_GetMPSendBufferSize());
882 #endif
883 errcode = WM_StartMPEx(WM_lib_mp_child_callback, param->recvBuf, param->recvBufSize, param->sendBuf, param->sendBufSize, (u16)(param->contSend ? 0 : 1), 0, FALSE, FALSE, param->no_retry, // Default is FALSE
884 param->contSend ? TRUE : FALSE // ignoreFatalError
885 );
886
887
888 check_WMAPI_errcode(WM_APIID_START_MP, errcode);
889 break;
890
891 case WM_STATECODE_DISCONNECTED:
892 param->callback(WM_TYPE_DISCONNECTED_FROM_PARENT, arg);
893 param->child_bitmap = 0;
894 break;
895
896 case WM_STATECODE_DISCONNECTED_FROM_MYSELF:
897 // Does nothing if the unit disconnects from itself
898 break;
899
900 case WM_STATECODE_BEACON_LOST:
901 param->callback(WM_TYPE_BEACON_LOST, arg);
902 break;
903
904 default:
905 param->callback(WM_TYPE_ERROR, arg);
906 break;
907 }
908 }
909 else
910 {
911 // Error notification by a callback
912 if (WM_lib_auto_flag == TRUE)
913 {
914 wm_lib_parent_found_count_reset();
915 }
916 param->callback(WM_TYPE_CONNECT_FAILED, arg);
917 }
918 }
919 break;
920
921 //---------------------------------------------------------------
922 case WM_APIID_START_MP:
923 {
924 WMstartMPCallback *callback = (WMstartMPCallback *)arg;
925
926 switch (callback->state)
927 {
928 case WM_STATECODE_MP_START:
929 param->mpStarted = 1; // Set the flag that indicates MP has started
930 param->callback(WM_TYPE_MP_STARTED, arg);
931
932 if (param->keySharing == 1)
933 {
934 // Start KeySharing
935 errcode = WM_StartKeySharing(param->ksBuf, WM_PORT_KEYSHARING);
936 check_WMAPI_errcode(WM_APIID_START_KS, errcode);
937 if (TRUE == WM_lib_CheckMPSend())
938 param->callback(WM_TYPE_MP_SEND_ENABLE, NULL);
939 }
940 else
941 {
942 // MP send-enabled callback
943 if (TRUE == WM_lib_CheckMPSend())
944 {
945 param->callback(WM_TYPE_MP_SEND_ENABLE, NULL);
946 if (WM_lib_mp_dcf_parallel == TRUE)
947 {
948 errcode =
949 WM_StartDCF(WM_lib_mp_child_callback, param->dcfBuf,
950 param->dcfBufSize);
951 check_WMAPI_errcode(WM_APIID_START_DCF, errcode);
952 }
953 }
954 }
955 break;
956
957 case WM_STATECODE_MP_IND:
958 if (callback->errcode == WM_ERRCODE_INVALID_POLLBITMAP)
959 {
960 // Although not polled itself, send notification because the MP frame was received
961 param->callback(WM_TYPE_MP_CHILD_RECV, (void *)(callback->recvBuf));
962 }
963 else
964 {
965 param->callback(WM_TYPE_MP_CHILD_RECV, (void *)(callback->recvBuf));
966 }
967 break;
968
969 case WM_STATECODE_MPACK_IND:
970 break;
971
972 default:
973 param->callback(WM_TYPE_ERROR, arg);
974 break;
975 }
976 }
977 break;
978
979 //---------------------------------------------------------------
980 case WM_APIID_START_DCF:
981 if (WM_ERRCODE_SUCCESS == buf->errcode)
982 {
983 param->callback(WM_TYPE_DCF_STARTED, arg);
984 }
985 else
986 {
987 param->callback(WM_TYPE_ERROR, arg);
988 }
989 break;
990
991 //---------------------------------------------------------------
992 case WM_APIID_SET_MP_DATA:
993 {
994 param->mpBusy = 0;
995
996 if (buf->errcode == WM_ERRCODE_SUCCESS)
997 {
998 param->callback(WM_TYPE_MP_CHILD_SENT, arg);
999 }
1000 else if (buf->errcode == WM_ERRCODE_TIMEOUT)
1001 {
1002 param->callback(WM_TYPE_MP_CHILD_SENT_TIMEOUT, arg);
1003 }
1004 else
1005 {
1006 param->callback(WM_TYPE_MP_CHILD_SENT_ERR, arg);
1007 }
1008
1009 // Allow the next transmission
1010 param->callback(WM_TYPE_MP_SEND_ENABLE, NULL);
1011 }
1012 break;
1013
1014 //---------------------------------------------------------------
1015 case WM_APIID_RESET:
1016 {
1017 if (buf->errcode == WM_ERRCODE_SUCCESS)
1018 {
1019 errcode = WM_End(WM_lib_mp_child_callback);
1020 check_WMAPI_errcode(WM_APIID_END, errcode);
1021 }
1022 else
1023 {
1024 param->endReq = 0;
1025 param->callback(WM_TYPE_ERROR, arg);
1026 }
1027 }
1028 break;
1029
1030 //---------------------------------------------------------------
1031 case WM_APIID_END:
1032 {
1033 param->endReq = 0;
1034 if (buf->errcode == WM_ERRCODE_SUCCESS)
1035 {
1036 param->callback(WM_TYPE_END_COMPLETE, arg);
1037 }
1038 else
1039 {
1040 param->callback(WM_TYPE_ERROR, arg);
1041 }
1042 }
1043 break;
1044
1045 //---------------------------------------------------------------
1046 case WM_APIID_INDICATION:
1047 {
1048 WMindCallback *cb = (WMindCallback *)arg;
1049 switch (cb->state)
1050 {
1051 case WM_STATECODE_BEACON_RECV: // Indicate beacon received
1052 {
1053 static u16 flag = 0; // Prevents WM_lib_End2 from being issued twice, if this point is reached twice in a row
1054 WMBeaconRecvIndCallback *callback = (WMBeaconRecvIndCallback *)arg;
1055 if ((param->currentTgid != 0) && (callback->gameInfo.tgid != param->currentTgid)
1056 && (callback->wmstate == WM_STATE_MP_CHILD))
1057 {
1058 if (flag == 0)
1059 {
1060 int errcode;
1061 flag = 1;
1062 errcode = WM_lib_End();
1063 check_WMAPI_errcode(WM_APIID_END, errcode);
1064 }
1065 }
1066 else
1067 {
1068 flag = 0;
1069 }
1070 param->callback(WM_TYPE_BEACON_RECV, arg);
1071 }
1072 break;
1073 case WM_STATECODE_DISASSOCIATE: // Indicate disconnection
1074 param->callback(WM_TYPE_DISASSOCIATE, arg);
1075 break;
1076 case WM_STATECODE_REASSOCIATE: // Indicate reconnection
1077 param->callback(WM_TYPE_REASSOCIATE, arg);
1078 break;
1079 case WM_STATECODE_AUTHENTICATE: // Indicate confirmed authentication
1080 param->callback(WM_TYPE_AUTHENTICATE, arg);
1081 break;
1082 }
1083 }
1084 break;
1085
1086 default:
1087 param->callback(WM_TYPE_ERROR, arg);
1088 break;
1089 }
1090 }
1091
1092 //========================================================================================
1093
1094 //=================================================================
1095 // DCF child callback
WM_lib_dcf_child_callback(void * arg)1096 void WM_lib_dcf_child_callback(void *arg)
1097 {
1098 WMCallback *buf = (WMCallback *)arg;
1099 int errcode;
1100
1101 switch (buf->apiid)
1102 {
1103 //---------------------------------------------------------------
1104 case WM_APIID_INITIALIZE:
1105 {
1106 if (WM_ERRCODE_SUCCESS == buf->errcode)
1107 {
1108 #ifdef WMLIB_DEBUG
1109 OS_TPrintf("dcf: WM_Initialize callback\n");
1110 #endif
1111 param->callback(WM_TYPE_INIT_COMPLETE, arg);
1112
1113 errcode =
1114 WM_SetLifeTime(WM_lib_dcf_child_callback, TABLE_NO, 0xffff, 0xffff, 0xffff);
1115 check_WMAPI_errcode(WM_APIID_SET_LIFETIME, errcode);
1116 }
1117 else
1118 {
1119 param->callback(WM_TYPE_ERROR, arg);
1120 }
1121 }
1122 break;
1123
1124 //---------------------------------------------------------------
1125 case WM_APIID_SET_LIFETIME:
1126 {
1127 if (WM_ERRCODE_SUCCESS == buf->errcode)
1128 {
1129 #ifdef WMLIB_DEBUG
1130 OS_TPrintf("dcf: WM_SetLifeTime callback\n");
1131 #endif
1132
1133 errcode = WM_SetWEPKeyEx(WM_lib_dcf_child_callback, param->wepMode,
1134 param->wepKeyId, param->wepKey);
1135 check_WMAPI_errcode(WM_APIID_SET_WEPKEY_EX, errcode);
1136 }
1137 else
1138 {
1139 param->callback(WM_TYPE_ERROR, arg);
1140 }
1141 }
1142 break;
1143
1144 //---------------------------------------------------------------
1145 case WM_APIID_SET_WEPKEY:
1146 case WM_APIID_SET_WEPKEY_EX:
1147 {
1148 #ifdef WMLIB_DEBUG
1149 OS_TPrintf("dcf: WM_SetWEPKey(Ex) callback\n");
1150 #endif
1151 if (WM_ERRCODE_SUCCESS == buf->errcode)
1152 {
1153 // Load status
1154 errcode = WM_ReadStatus(param->statusBuf);
1155 check_WMAPI_errcode(WM_APIID_READ_STATUS, errcode);
1156
1157 // Issue WM_SetIncCallback
1158 errcode = WM_SetIndCallback(WM_lib_dcf_child_callback);
1159 check_WMAPI_errcode(WM_APIID_INDICATION, errcode);
1160
1161 // Scan start
1162 if (param->scanExFlag == TRUE)
1163 {
1164 // When using WM_StartScanEx
1165 scanExParam.scanBuf = param->parentInfoBuf;
1166 scanExParam.scanBufSize = param->parentInfoBufSize;
1167
1168 if (scanExParam.maxChannelTime == 0)
1169 WM_lib_set_scanEx_maxChannelTime(200);
1170
1171 scanExParam.bssid[0] = 0xff;
1172 scanExParam.bssid[1] = 0xff;
1173 scanExParam.bssid[2] = 0xff;
1174 scanExParam.bssid[3] = 0xff;
1175 scanExParam.bssid[4] = 0xff;
1176 scanExParam.bssid[5] = 0xff;
1177
1178 scanning_flag = 1;
1179
1180 #ifdef WMLIB_DEBUG
1181 OS_TPrintf("dcf: WM_StartScanEx\n");
1182 #endif
1183 // Issue WM_StartScanEx
1184 errcode = WM_StartScanEx(WM_lib_dcf_child_callback, &scanExParam);
1185 check_WMAPI_errcode(WM_APIID_START_SCAN_EX, errcode);
1186 }
1187 else
1188 {
1189 // When using WM_StartScan
1190 scanParam.scanBuf = param->parentInfoBuf;
1191
1192 if (scanParam.channel == 0)
1193 scanParam.channel = 1;
1194 if (scanParam.maxChannelTime == 0)
1195 WM_lib_set_max_scan_time(200);
1196
1197 scanExParam.bssid[0] = 0xff;
1198 scanExParam.bssid[1] = 0xff;
1199 scanExParam.bssid[2] = 0xff;
1200 scanExParam.bssid[3] = 0xff;
1201 scanExParam.bssid[4] = 0xff;
1202 scanExParam.bssid[5] = 0xff;
1203
1204 scanning_flag = 1;
1205
1206 #ifdef WMLIB_DEBUG
1207 OS_TPrintf("dcf: WMi_StartScan\n");
1208 #endif
1209 // Issue WM_StartScan
1210 errcode = WM_StartScan(WM_lib_dcf_child_callback, &scanParam);
1211 check_WMAPI_errcode(WM_APIID_START_SCAN, errcode);
1212 }
1213 }
1214 }
1215 break;
1216
1217
1218 //---------------------------------------------------------------
1219 case WM_APIID_START_SCAN:
1220 {
1221 WMstartScanCallback *callback = (WMstartScanCallback *)arg;
1222
1223 #ifdef WMLIB_DEBUG
1224 OS_TPrintf("dcf: WMi_StartScan callback ");
1225 #endif
1226 if (WM_ERRCODE_SUCCESS == callback->errcode)
1227 {
1228 switch (callback->state)
1229 {
1230 case WM_STATECODE_SCAN_START:
1231 #ifdef WMLIB_DEBUG
1232 OS_TPrintf("start\n");
1233 #endif
1234 break;
1235
1236 case WM_STATECODE_PARENT_FOUND:
1237 #ifdef WMLIB_DEBUG
1238 OS_TPrintf("found\n");
1239 #endif
1240 param->callback(WM_TYPE_PARENT_FOUND, arg);
1241 if (scanning_flag == 1)
1242 {
1243 if (WM_lib_change_scan_channel_flag == TRUE)
1244 changeScanChannel(&scanParam);
1245
1246 errcode = WM_StartScan(WM_lib_dcf_child_callback, &scanParam);
1247
1248 check_WMAPI_errcode(WM_APIID_START_SCAN, errcode);
1249 }
1250 break;
1251
1252 case WM_STATECODE_PARENT_NOT_FOUND:
1253 #ifdef WMLIB_DEBUG
1254 OS_TPrintf("not found\n");
1255 #endif
1256 param->callback(WM_TYPE_PARENT_NOT_FOUND, arg);
1257 if (scanning_flag == 1)
1258 {
1259 if (WM_lib_change_scan_channel_flag == TRUE)
1260 changeScanChannel(&scanParam);
1261
1262 errcode = WM_StartScan(WM_lib_dcf_child_callback, &scanParam);
1263
1264 check_WMAPI_errcode(WM_APIID_START_SCAN, errcode);
1265 }
1266 break;
1267
1268 default:
1269 #ifdef WMLIB_DEBUG
1270 OS_TPrintf("error\n");
1271 #endif
1272 param->callback(WM_TYPE_ERROR, arg);
1273 break;
1274 }
1275 }
1276 }
1277 break;
1278
1279 //---------------------------------------------------------------
1280 case WM_APIID_START_SCAN_EX:
1281 {
1282 WMstartScanExCallback *callback = (WMstartScanExCallback *)arg;
1283
1284 #ifdef WMLIB_DEBUG
1285 OS_TPrintf("dcf: WMi_StartScanEx callback ");
1286 #endif
1287 if (WM_ERRCODE_SUCCESS == callback->errcode)
1288 {
1289 switch (callback->state)
1290 {
1291 case WM_STATECODE_SCAN_START:
1292 #ifdef WMLIB_DEBUG
1293 OS_TPrintf("start\n");
1294 #endif
1295 break;
1296
1297 case WM_STATECODE_PARENT_FOUND:
1298 #ifdef WMLIB_DEBUG
1299 OS_TPrintf("found\n");
1300 #endif
1301 param->callback(WM_TYPE_PARENT_FOUND, arg);
1302 if (scanning_flag == 1)
1303 {
1304 errcode = WM_StartScanEx(WM_lib_dcf_child_callback, &scanExParam);
1305 check_WMAPI_errcode(WM_APIID_START_SCAN_EX, errcode);
1306 }
1307 break;
1308
1309 case WM_STATECODE_PARENT_NOT_FOUND:
1310 #ifdef WMLIB_DEBUG
1311 OS_TPrintf("not found\n");
1312 #endif
1313 param->callback(WM_TYPE_PARENT_NOT_FOUND, arg);
1314 if (scanning_flag == 1)
1315 {
1316 errcode = WM_StartScanEx(WM_lib_dcf_child_callback, &scanExParam);
1317 check_WMAPI_errcode(WM_APIID_START_SCAN_EX, errcode);
1318 }
1319 break;
1320
1321 default:
1322 #ifdef WMLIB_DEBUG
1323 OS_TPrintf("error\n");
1324 #endif
1325 param->callback(WM_TYPE_ERROR, arg);
1326 break;
1327 }
1328 }
1329 }
1330 break;
1331
1332 //---------------------------------------------------------------
1333 case WM_APIID_END_SCAN:
1334 {
1335 switch (buf->errcode)
1336 {
1337 case WM_ERRCODE_SUCCESS:
1338 #ifdef STARTCONNECT_EX_TEST
1339 errcode = WM_StartConnectEx(WM_lib_dcf_child_callback, param->pInfo, NULL,
1340 FALSE, param->authMode);
1341 #else
1342 errcode = WM_StartConnect(WM_lib_dcf_child_callback, param->pInfo, NULL);
1343 #endif
1344 check_WMAPI_errcode(WM_APIID_START_CONNECT, errcode);
1345 break;
1346
1347 default:
1348 param->callback(WM_TYPE_ERROR, arg);
1349 break;
1350 }
1351 }
1352 break;
1353
1354 //---------------------------------------------------------------
1355 case WM_APIID_START_CONNECT:
1356 {
1357 WMstartConnectCallback *callback = (WMstartConnectCallback *)arg;
1358
1359 if (callback->errcode == WM_ERRCODE_SUCCESS)
1360 {
1361 switch (callback->state)
1362 {
1363 case WM_STATECODE_CONNECT_START:
1364 break;
1365
1366 case WM_STATECODE_CONNECTED:
1367 param->callback(WM_TYPE_CONNECTED_TO_PARENT, arg);
1368 errcode =
1369 WM_StartDCF(WM_lib_dcf_child_callback, param->dcfBuf, param->dcfBufSize);
1370 check_WMAPI_errcode(WM_APIID_START_DCF, errcode);
1371 break;
1372
1373 case WM_STATECODE_DISCONNECTED:
1374 param->callback(WM_TYPE_DISCONNECTED_FROM_PARENT, arg);
1375 break;
1376
1377 case WM_STATECODE_DISCONNECTED_FROM_MYSELF:
1378 // Does nothing if the unit disconnects from itself
1379 break;
1380
1381 default:
1382 param->callback(WM_TYPE_ERROR, arg);
1383 break;
1384 }
1385 }
1386 else
1387 {
1388 // Error notification by a callback
1389 param->callback(WM_TYPE_CONNECT_FAILED, arg);
1390 }
1391 }
1392 break;
1393
1394 //---------------------------------------------------------------
1395 case WM_APIID_START_DCF:
1396 {
1397 WMstartDCFCallback *callback = (WMstartDCFCallback *)arg;
1398
1399 if (callback->errcode == WM_ERRCODE_SUCCESS)
1400 {
1401 switch (callback->state)
1402 {
1403 case WM_STATECODE_DCF_START:
1404 break;
1405
1406 case WM_STATECODE_DCF_IND:
1407 param->callback(WM_TYPE_DCF_CHILD_RECV, callback->recvBuf);
1408 break;
1409
1410 default:
1411 param->callback(WM_TYPE_ERROR, arg);
1412 break;
1413 }
1414 }
1415 }
1416 break;
1417
1418 //---------------------------------------------------------------
1419 case WM_APIID_RESET:
1420 {
1421 if (buf->errcode == WM_ERRCODE_SUCCESS)
1422 {
1423 errcode = WM_End(WM_lib_dcf_child_callback);
1424 check_WMAPI_errcode(WM_APIID_END, errcode);
1425 }
1426 else
1427 {
1428 param->endReq = 0;
1429 param->callback(WM_TYPE_ERROR, arg);
1430 }
1431 }
1432 break;
1433
1434 //---------------------------------------------------------------
1435 case WM_APIID_END:
1436 {
1437 param->endReq = 0;
1438 if (buf->errcode == WM_ERRCODE_SUCCESS)
1439 {
1440 param->callback(WM_TYPE_END_COMPLETE, arg);
1441 }
1442 }
1443 break;
1444
1445 //---------------------------------------------------------------
1446 case WM_APIID_SET_DCF_DATA:
1447 {
1448 if (buf->errcode == WM_ERRCODE_SUCCESS)
1449 {
1450 param->callback(WM_TYPE_DCF_CHILD_SENT, arg);
1451 }
1452 else
1453 {
1454 param->callback(WM_TYPE_DCF_CHILD_SENT_ERR, arg);
1455 }
1456 }
1457 break;
1458
1459 //---------------------------------------------------------------
1460 case WM_APIID_INDICATION:
1461 {
1462 }
1463 break;
1464
1465 default:
1466 param->callback(WM_TYPE_ERROR, arg);
1467 break;
1468 }
1469 }
1470
1471
1472
1473
1474 //========================================================================================
1475
1476 //--------------------------------------------------------
1477 // WM_lib termination request
WM_lib_End(void)1478 int WM_lib_End(void)
1479 {
1480 int errcode;
1481
1482 if (param == NULL)
1483 return WM_ERRCODE_FAILED;
1484
1485 /* Do nothing if the End request has already been sent */
1486 if (param->endReq == 0)
1487 {
1488 scanning_flag = 0;
1489 param->endReq = 1;
1490 errcode = WM_Reset(callback_ptr);
1491 return conv_errcode(errcode);
1492 }
1493
1494 return WM_ERRCODE_FAILED;
1495
1496 }
1497
1498 //--------------------------------------------------------
1499 // WM_lib MP data send request
WM_lib_SetMPDataEX(u16 * data,u16 size,u16 pollbitmap)1500 int WM_lib_SetMPDataEX(u16 *data, u16 size, u16 pollbitmap)
1501 {
1502 int errcode;
1503
1504 if (param == NULL)
1505 return WM_ERRCODE_FAILED;
1506
1507 // MP data cannot be transmitted before MP has started, during a MP send request, or after a end request is issued
1508 if ((param->mpStarted == 0) || (param->mpBusy == 1) || (param->endReq == 1))
1509 return WM_ERRCODE_FAILED;
1510
1511 // Enable the MP data transmit request in progress flag
1512 param->mpBusy = 1;
1513
1514 switch (param->mode)
1515 {
1516 case WM_MODE_MP_PARENT:
1517 if (0 == param->contSend)
1518 {
1519 errcode = WM_SetMPData(WM_lib_mp_parent_callback, data, size, 1000, pollbitmap);
1520 }
1521 else
1522 {
1523 errcode = WM_SetMPData(WM_lib_mp_parent_callback, data, size, 0, pollbitmap);
1524 }
1525 if (errcode == WM_ERRCODE_OPERATING)
1526 {
1527 }
1528
1529 if (errcode != WM_ERRCODE_SUCCESS)
1530 param->mpBusy = 0;
1531 return conv_errcode(errcode);
1532
1533 case WM_MODE_MP_CHILD:
1534 errcode = WM_SetMPData(WM_lib_mp_child_callback, data, size, 0, pollbitmap);
1535 if (errcode == WM_ERRCODE_OPERATING)
1536 {
1537 }
1538 if (errcode != WM_ERRCODE_SUCCESS)
1539 param->mpBusy = 0;
1540 return conv_errcode(errcode);
1541
1542 default:
1543 return WM_ERRCODE_FAILED;
1544 }
1545 }
1546
WM_lib_SetMPData(u16 * data,u16 size)1547 int WM_lib_SetMPData(u16 *data, u16 size)
1548 {
1549 return WM_lib_SetMPDataEX(data, size, 0xffff);
1550 }
1551
1552
1553 //--------------------------------------------------------
1554 // WM_lib DCF data transmission request
WM_lib_SetDCFData(const u8 * destAdr,u16 * data,u16 size)1555 int WM_lib_SetDCFData(const u8 *destAdr, u16 *data, u16 size)
1556 {
1557 int errcode;
1558 errcode = WM_SetDCFData(WM_lib_dcf_child_callback, destAdr, data, size);
1559 return conv_errcode(errcode);
1560 }
1561
1562
1563
1564 //--------------------------------------------------------
1565 // WM_lib connection request
WM_lib_ConnectToParent(WMbssDesc * pInfo)1566 int WM_lib_ConnectToParent(WMbssDesc *pInfo)
1567 {
1568 int errcode;
1569 WMGameInfo *pGameInfo = (WMGameInfo *)&(pInfo->gameInfo);
1570
1571 if (param == NULL)
1572 return WM_ERRCODE_FAILED;
1573
1574 param->pInfo = pInfo;
1575 param->currentTgid = pGameInfo->tgid;
1576
1577 scanning_flag = 0;
1578
1579 errcode = WM_EndScan(callback_ptr);
1580 return conv_errcode(errcode);
1581 }
1582
1583 //--------------------------------------------------------
1584 // WM_lib disconnection request
WM_lib_Disconnect(u16 aid)1585 int WM_lib_Disconnect(u16 aid)
1586 {
1587 int errcode;
1588
1589 if (param == NULL)
1590 return WM_ERRCODE_FAILED;
1591
1592 errcode = WM_Disconnect(callback_ptr, aid);
1593 if (errcode != WM_ERRCODE_OPERATING)
1594 param->callback(WM_TYPE_DISCONNECT_FAILED, 0);
1595 return conv_errcode(errcode);
1596 }
1597
1598 //--------------------------------------------------------
1599 // WM_lib GameInfo configuration request
WM_lib_SetGameInfo(u16 * userGameInfo,u16 size,u32 ggid,u16 tgid)1600 int WM_lib_SetGameInfo(u16 *userGameInfo, u16 size, u32 ggid, u16 tgid)
1601 {
1602 int errcode;
1603 u8 attribute;
1604 if (param == NULL)
1605 return WM_ERRCODE_FAILED;
1606
1607 param->parentParam->userGameInfo = userGameInfo;
1608 param->parentParam->userGameInfoLength = size;
1609 param->parentParam->ggid = ggid;
1610 param->parentParam->tgid = tgid;
1611
1612 attribute = (u8)(((param->parentParam->entryFlag) ? WM_ATTR_FLAG_ENTRY : 0) | // entryFlag lowest bit
1613 ((param->parentParam->multiBootFlag) ? WM_ATTR_FLAG_MB : 0) | // multiBootFlag second bit
1614 ((param->parentParam->KS_Flag) ? WM_ATTR_FLAG_KS : 0) | // KS_Flag third bit
1615 ((param->parentParam->CS_Flag) ? WM_ATTR_FLAG_CS : 0) // CS_Flag fourth bit
1616 );
1617
1618
1619 // Actually, userGameInfo and parentParam are both updated
1620 // errcode = WM_SetGameInfo( callback_ptr, param->parentParam );
1621 errcode = WM_SetGameInfo(callback_ptr,
1622 param->parentParam->userGameInfo,
1623 param->parentParam->userGameInfoLength,
1624 param->parentParam->ggid, param->parentParam->tgid, attribute);
1625
1626 if (errcode != WM_ERRCODE_OPERATING)
1627 param->callback(WM_TYPE_SET_GAMEINFO_FAILED, 0);
1628 return conv_errcode(errcode);
1629 }
1630
1631
1632 //--------------------------------------------------------
1633 // Check WM_lib MP send enable
WM_lib_CheckMPSend(void)1634 BOOL WM_lib_CheckMPSend(void)
1635 {
1636 if (param == NULL)
1637 return WM_ERRCODE_FAILED;
1638
1639 if ((param->mpStarted == 1) && (param->mpBusy == 0) &&
1640 (param->endReq == 0) && (param->child_bitmap != 0))
1641 return TRUE;
1642 else
1643 return FALSE;
1644 }
1645
1646 //--------------------------------------------------------
1647 // WM_lib keyset get function
WM_lib_GetKeySet(WMkeySet * keySet)1648 int WM_lib_GetKeySet(WMkeySet *keySet)
1649 {
1650 if (TRUE == WM_lib_CheckMPSend())
1651 return WM_GetKeySet(param->ksBuf, keySet);
1652 else
1653 return 0xffff;
1654 }
1655
1656 //--------------------------------------------------------
WM_lib_CurrentScanChannel(void)1657 u16 WM_lib_CurrentScanChannel(void)
1658 {
1659 return scanParam.channel;
1660 }
1661
1662
1663 //--------------------------------------------------------
1664 // ScanChannel change function
changeScanChannel(WMscanParam * param)1665 static void changeScanChannel(WMscanParam *param)
1666 {
1667 switch (param->channel)
1668 {
1669 case 1:
1670 param->channel = 7;
1671 break;
1672
1673 case 7:
1674 param->channel = 13;
1675 break;
1676
1677 case 13:
1678 param->channel = 1;
1679 break;
1680
1681 default:
1682 param->channel = 1;
1683 break;
1684 }
1685 }
1686
1687
WM_lib_set_scan_channel_seek(BOOL flag)1688 void WM_lib_set_scan_channel_seek(BOOL flag)
1689 {
1690 WM_lib_change_scan_channel_flag = flag;
1691 }
1692
1693
WM_lib_set_bssid(u16 bssid0,u16 bssid1,u16 bssid2)1694 void WM_lib_set_bssid(u16 bssid0, u16 bssid1, u16 bssid2)
1695 {
1696 /* Strictly prohibited to change the order */
1697 scanParam.bssid[0] = (u8)(bssid0 & 0x00ff);
1698 scanParam.bssid[1] = (u8)(bssid0 >> 8);
1699 scanParam.bssid[2] = (u8)(bssid1 & 0x00ff);
1700 scanParam.bssid[3] = (u8)(bssid1 >> 8);
1701 scanParam.bssid[4] = (u8)(bssid2 & 0x00ff);
1702 scanParam.bssid[5] = (u8)(bssid2 >> 8);
1703 }
1704
WM_lib_get_mp_parent_callback_ptr(void)1705 void *WM_lib_get_mp_parent_callback_ptr(void)
1706 {
1707 return &WM_lib_mp_parent_callback;
1708 }
1709
WM_lib_get_mp_child_callback_ptr(void)1710 void *WM_lib_get_mp_child_callback_ptr(void)
1711 {
1712 return &WM_lib_mp_child_callback;
1713 }
1714
1715 //-----------------------------------------------------------------------------------
1716 // Convert rate_rssi to a four-tier RSSI value
WM_lib_CalcRSSI(u16 rate_rssi,u16 aid)1717 u16 WM_lib_CalcRSSI(u16 rate_rssi, u16 aid)
1718 {
1719 u16 rssi;
1720 u16 i;
1721 static u16 bufCounter[16] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
1722 static u16 rssiBuf[16][16] = {
1723 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1724 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1725 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1726 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1727
1728 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1729 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1730 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1731 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1732
1733 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1734 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1735 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1736 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1737
1738 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1739 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1740 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
1741 {0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
1742 };
1743
1744 rssi = (u16)(rate_rssi >> 8);
1745 //��������������������������������������������������
1746 //| RSSI (Upper 6bits) | LNA| rsv |
1747 //��������������������������������������������������
1748 rssi &= ~0x0001; // Clear rsv, just in case
1749 if (rssi & 0x0002)
1750 {
1751 rssi >>= 2;
1752 }
1753 else
1754 {
1755 rssi >>= 2;
1756 rssi += 25;
1757 }
1758
1759 // Calculate the average for the last 16 times
1760 rssiBuf[aid][bufCounter[aid]] = rssi;
1761 if (++bufCounter[aid] == 16)
1762 bufCounter[aid] = 0;
1763
1764 rssi = 0;
1765 for (i = 0; i < 16; ++i)
1766 rssi += rssiBuf[aid][i];
1767
1768 rssi >>= 4;
1769
1770 // Return as four-tier RSSI value
1771 if (rssi < 8)
1772 return 0;
1773 else if (rssi < 20)
1774 return 1;
1775 else if (rssi < 36)
1776 return 2;
1777 else
1778 return 3;
1779 }
1780
1781
1782 // Check WM_API's returned value
check_WMAPI_errcode(u16 apiid,int errcode)1783 static void check_WMAPI_errcode(u16 apiid, int errcode)
1784 {
1785 u16 arg[2];
1786
1787 if (errcode != WM_ERRCODE_OPERATING && errcode != WM_ERRCODE_SUCCESS)
1788 {
1789 arg[0] = apiid;
1790 arg[1] = (u16)errcode;
1791 param->callback(WM_TYPE_API_ERROR, arg);
1792 }
1793 }
1794
1795
1796 /*---------------------------------------------------------------------------*
1797 End of file
1798 *---------------------------------------------------------------------------*/
1799