1 /*---------------------------------------------------------------------------*
2 Project: TwlSDK - MB - libraries
3 File: mb_fake_child.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-17#$
14 $Rev: 8556 $
15 $Author: okubata_ryoma $
16 *---------------------------------------------------------------------------*/
17
18 #include <nitro.h>
19 #include "mb_common.h"
20 #include "mb_block.h"
21 #include "mb_child.h"
22 #include "mb_private.h"
23 #include "mb_wm_base.h"
24 #include "mb_fake_child.h"
25 #include "mb_wm.h"
26
27 #define MB_FAKE_PRINT (0)
28
29 #if (MB_FAKE_PRINT == 1)
30 #define MB_FAKE_OUTPUT OS_TPrintf
31 #else
32 #define MB_FAKE_OUTPUT( ... ) ((void)0)
33 #endif
34
35 #define MY_ROUND(n, a) (((u32) (n) + (a) - 1) & ~((a) - 1))
36
37 typedef struct
38 {
39 u32 sendBuf[WM_SIZE_CHILD_SEND_BUFFER(MB_COMM_PARENT_RECV_MAX, FALSE) / sizeof(u32)] ATTRIBUTE_ALIGN(32); // Send buffer 0x400 byte
40 u32 recvBuf[WM_SIZE_CHILD_RECEIVE_BUFFER(MB_COMM_PARENT_SEND_MAX, FALSE) / sizeof(u32)] ATTRIBUTE_ALIGN(32); // Receive buffer 0xF00 byte
41 u32 sendDataBuf[WM_SIZE_CHILD_SEND_BUFFER(MB_COMM_PARENT_RECV_MAX, FALSE) / sizeof(u32)] ATTRIBUTE_ALIGN(32); // Buffer for creating send data 0x400 byte
42 WMBssDesc bssDescBuf ATTRIBUTE_ALIGN(32); // Buffer for scanning parents. Needs to be 32-byte aligned 0xC0 byte
43 WMScanParam scanParam ATTRIBUTE_ALIGN(32); // Scan parameter. Needs to be 32-byte aligned 0x20 byte
44 MBWMWork wmWork ATTRIBUTE_ALIGN(32); // Work buffer for MP communication. Needs to be 32-byte aligned
45 MBUserInfo userInfo; // User information
46 u8 _padding1[2];
47 MBFakeScanCallbackFunc scanCallback; // Callback for parent scan notification
48 MBCommCStateCallbackFunc stateCallback; // Callback for status notification
49 u32 ggid; // GGID to search
50 MbBeaconRecvStatus beaconRecvStatus; // Beacon receive status
51 BOOL scanning; // Scanning flag
52 BOOL endScanBusy; // Flag for processing scan termination
53 BOOL locking; // Locking flag
54 BOOL endFlag; // MB termination process request
55 u32 targetGgid; // GGID of binary to request
56 u16 targetFileNo; // FileNo of binary to request
57 u16 c_comm_state; // Child status
58 WMCallbackFunc verboseScanCallback; // Callback that alerts the user of the the raw WMScan notification
59 MBFakeCompareGGIDCallbackFunc compareGGIDCallback; // User-defined GGID comparison callback
60 u8 _padding2[8];
61 }
62 MBFakeWork;
63
64 SDK_COMPILER_ASSERT(sizeof(MBFakeWork) <= MB_FAKE_WORK_SIZE);
65
66
67 //============================================================================
68 // Function Prototype Declarations
69 //============================================================================
70
71 static void MBFi_EndComplete(void);
72
73 static void MBFi_CommChangeChildState(u16 state, void *arg);
74 static void MBFi_SendCallback(u16 state, void *arg);
75 static void MBFi_ErrorCallback(u16 apiid, u16 errcode, BOOL isApiError);
76
77 /* For scanning */
78 static void MBFi_StateInStartScan(void);
79 static void MBFi_StateOutStartScanParent(void *arg);
80 static void MBFi_CommBeaconRecvCallback(MbBeaconMsg msg, MBGameInfoRecvList * gInfop, int index);
81
82 static void MBFi_ScanCallback(u16 state, MBGameInfoRecvList * gInfop, int index);
83 static void MBFi_ScanErrorCallback(u16 apiid, u16 errcode);
84 static void MBFi_ScanLock(u8 *macAddr);
85 static void MBFi_ScanUnlock(void);
86 static BOOL RotateChannel(void);
87
88 static void MBFi_StateInEndScan(void);
89 static void MBFi_StateOutEndScan(void *arg);
90
91 /* For entry processes */
92 static void MBFi_WMCallback(u16 type, void *arg);
93 static void MBFi_CommChildRecvData(WMPortRecvCallback *cb);
94 static void MBFi_CommChildSendData(void);
95
96 /* For debug output */
97 #if (MB_FAKE_PRINT == 1)
98 static void MBFi_PrintMBCallbackType(u16 type);
99 static void MBFi_PrintMBCommCallbacyType(u16 type);
100 #else
101 #define MBFi_PrintMBCallbackType(a) ((void)0)
102 #define MBFi_PrintMBCommCallbackType(a) ((void)0)
103 #endif
104
105 //============================================================================
106 // Local Variable Declarations
107 //============================================================================
108
109 static vu16 mbf_initialize;
110 static MBFakeWork *mbf_work;
111
112
113
114 //============================================================================
115 // function definitions
116 //============================================================================
117
118
119 /*---------------------------------------------------------------------------*
120 Name: MB_FakeInit
121
122 Description: Initialization function of the fake multiboot child
123
124 Arguments: buf Pointer to the work area necessary for fake child.
125 The necessary size can be obtained with MB_FakeGetWorkSize().
126 user Pointer to the user information of a child
127
128 Returns: None.
129 *---------------------------------------------------------------------------*/
MB_FakeInit(void * buf,const MBUserInfo * user)130 void MB_FakeInit(void *buf, const MBUserInfo *user)
131 {
132 SDK_NULL_ASSERT(buf);
133 SDK_ASSERT(((u32)buf & 0x1F) == 0); // Checks for the 32-byte alignment
134
135 if (mbf_initialize)
136 {
137 OS_TWarning("MB_FakeInit multiply called\n");
138 return;
139 }
140 mbf_initialize = 1;
141
142 MB_FAKE_OUTPUT("MB_Fake Initialized\n");
143
144 // Buffer clear
145 MI_CpuClear8(buf, sizeof(MBFakeWork));
146
147 mbf_work = (MBFakeWork *) buf;
148 mbf_work->c_comm_state = MB_COMM_CSTATE_NONE;
149 mbf_work->verboseScanCallback = NULL;
150 mbf_work->compareGGIDCallback = NULL;
151
152 MI_CpuCopy8(user, &mbf_work->userInfo, sizeof(MBUserInfo));
153 // Sets the work buffer for receiving beacon
154 MBi_SetBeaconRecvStatusBuffer(&mbf_work->beaconRecvStatus);
155 // Initializes the game information receive status
156 MB_InitRecvGameInfoStatus();
157 // Sets the function for scan lock
158 MBi_SetScanLockFunc(MBFi_ScanLock, MBFi_ScanUnlock);
159 }
160
161
162 /*---------------------------------------------------------------------------*
163 Name: MB_FakeEnd
164
165 Description: Termination function for the fake multiboot child.
166
167 Arguments: None.
168
169 Returns: None.
170 *---------------------------------------------------------------------------*/
MB_FakeEnd(void)171 void MB_FakeEnd(void)
172 {
173 if (mbf_work->endFlag)
174 {
175 // Does not do anything if the termination process has been started
176 return;
177 }
178
179 mbf_work->endFlag = TRUE;
180
181 switch (mbf_work->c_comm_state)
182 {
183 case MB_COMM_CSTATE_NONE:
184 // End the scan if scan is being performed
185 if (mbf_work->scanning)
186 {
187 mbf_work->scanning = FALSE;
188 }
189 // End without doing anything if before starting scanning or after completing EndScan
190 else if (!mbf_work->endScanBusy)
191 {
192 MBFi_EndComplete();
193 }
194 else
195 {
196 // Wait for completion if scan termination process is being performed
197 }
198 break;
199
200 case MB_COMM_CSTATE_INIT_COMPLETE:
201 case MB_COMM_CSTATE_CONNECT:
202 case MB_COMM_CSTATE_CONNECT_FAILED:
203 case MB_COMM_CSTATE_DISCONNECTED_BY_PARENT:
204 case MB_COMM_CSTATE_REQ_REFUSED:
205 case MB_COMM_CSTATE_ERROR:
206 case MB_COMM_CSTATE_MEMBER_FULL:
207 // Reset to end.
208 MBi_WMReset();
209 break;
210
211 case MB_COMM_CSTATE_REQ_ENABLE:
212 case MB_COMM_CSTATE_DLINFO_ACCEPTED:
213 case MB_COMM_CSTATE_RECV_PROCEED:
214 case MB_COMM_CSTATE_RECV_COMPLETE:
215 // Safely end from MP in order
216 MBi_WMDisconnect();
217 break;
218
219 case MB_COMM_CSTATE_BOOTREQ_ACCEPTED:
220 // Wait for completion of disconnection
221 break;
222
223 case MB_COMM_CSTATE_BOOT_READY:
224 case MB_COMM_CSTATE_CANCELLED:
225 // End because it is already in IDLE state
226 MBFi_EndComplete();
227 break;
228
229 default:
230 OS_TPanic("MB fake child is in Illegal State\n");
231 }
232 }
233
234
235 /*---------------------------------------------------------------------------*
236 Name: MBFi_EndComplete
237
238 Description: Termination process of the fake child library
239
240 Arguments: None.
241
242 Returns: None.
243 *---------------------------------------------------------------------------*/
MBFi_EndComplete(void)244 static void MBFi_EndComplete(void)
245 {
246 mbf_initialize = 0;
247 mbf_work->endFlag = 0;
248 // Clears port callback
249 MBi_WMClearCallback();
250
251 // Notify the user of termination
252 MBFi_CommChangeChildState(MB_COMM_CSTATE_FAKE_END, NULL);
253 }
254
255
256 /*---------------------------------------------------------------------------*
257 Name: MB_FakeGetWorkSize
258
259 Description: Gets the work size necessary for the fake child library.
260
261 Arguments: None.
262
263 Returns: Size of the necessary work buffer
264 *---------------------------------------------------------------------------*/
MB_FakeGetWorkSize(void)265 u32 MB_FakeGetWorkSize(void)
266 {
267 return sizeof(MBFakeWork);
268 }
269
270
271
272 /*---------------------------------------------------------------------------*
273 Name: MB_FakeSetCStateCallback
274
275 Description: Sets the callback function to notify the state change of the fake child.
276
277 Arguments: callback Callback function to set
278
279 Returns: None.
280 *---------------------------------------------------------------------------*/
MB_FakeSetCStateCallback(MBCommCStateCallbackFunc callback)281 void MB_FakeSetCStateCallback(MBCommCStateCallbackFunc callback)
282 {
283 OSIntrMode enabled = OS_DisableInterrupts();
284
285 mbf_work->stateCallback = callback;
286
287 (void)OS_RestoreInterrupts(enabled);
288 }
289
290
291 /*---------------------------------------------------------------------------*
292 Name: MBFi_CommChangeChildState
293
294 Description: Function that changes the child state.
295 Returns the callback to the user program at the same time as the status change.
296
297 Arguments: state Status to set
298 arg Argument for the callback
299
300 Returns: None.
301 *---------------------------------------------------------------------------*/
MBFi_CommChangeChildState(u16 state,void * arg)302 static void MBFi_CommChangeChildState(u16 state, void *arg)
303 {
304 #pragma unused( arg )
305 OSIntrMode enabled;
306
307 static const char *const CSTATE_NAME_STRING[] = {
308 "MB_COMM_CSTATE_NONE",
309 "MB_COMM_CSTATE_INIT_COMPLETE",
310 "MB_COMM_CSTATE_CONNECT",
311 "MB_COMM_CSTATE_CONNECT_FAILED",
312 "MB_COMM_CSTATE_DISCONNECTED_BY_PARENT",
313 "MB_COMM_CSTATE_REQ_ENABLE",
314 "MB_COMM_CSTATE_REQ_REFUSED",
315 "MB_COMM_CSTATE_DLINFO_ACCEPTED",
316 "MB_COMM_CSTATE_RECV_PROCEED",
317 "MB_COMM_CSTATE_RECV_COMPLETE",
318 "MB_COMM_CSTATE_BOOTREQ_ACCEPTED",
319 "MB_COMM_CSTATE_BOOT_READY",
320 "MB_COMM_CSTATE_CANCELLED",
321 "MB_COMM_CSTATE_AUTHENTICATION_FAILED",
322 "MB_COMM_CSTATE_MEMBER_FULL",
323 "MB_COMM_CSTATE_GAMEINFO_VALIDATED",
324 "MB_COMM_CSTATE_GAMEINFO_INVALIDATED",
325 "MB_COMM_CSTATE_GAMEINFO_LOST",
326 "MB_COMM_CSTATE_GAMEINFO_LIST_FULL",
327 "MB_COMM_CSTATE_ERROR",
328 "MB_COMM_CSTATE_FAKE_END",
329 };
330
331 MB_FAKE_OUTPUT("state %s -> %s\n", CSTATE_NAME_STRING[mbf_work->c_comm_state],
332 CSTATE_NAME_STRING[state]);
333
334 enabled = OS_DisableInterrupts();
335 mbf_work->c_comm_state = state;
336 (void)OS_RestoreInterrupts(enabled);
337 MBFi_SendCallback(state, arg);
338 }
339
340
341 /*---------------------------------------------------------------------------*
342 Name: MBFi_SendCallback
343
344 Description: Sends callback.
345
346 Arguments: state Status of the fake child.
347 arg : Callback argument
348
349 Returns: None.
350 *---------------------------------------------------------------------------*/
MBFi_SendCallback(u16 state,void * arg)351 static inline void MBFi_SendCallback(u16 state, void *arg)
352 {
353 if (mbf_work->stateCallback == NULL)
354 {
355 return;
356 }
357 mbf_work->stateCallback(state, arg);
358 }
359
360 /*---------------------------------------------------------------------------*
361 Name: MBFi_ErrorCallback
362
363 Description: Notifies the error generation with callback.
364
365 Arguments: apiid Notifies the API that caused the error with callback.
366 errcode Notifies the error cause code with callback.
367
368 Returns: None.
369 *---------------------------------------------------------------------------*/
MBFi_ErrorCallback(u16 apiid,u16 errcode,BOOL isApiError)370 static inline void MBFi_ErrorCallback(u16 apiid, u16 errcode, BOOL isApiError)
371 {
372 MBErrorStatus cb;
373 u16 error_type;
374
375 if (mbf_work->stateCallback == NULL)
376 {
377 return;
378 }
379
380 if (isApiError)
381 {
382 // Error at the time of calling API function.
383 switch (errcode)
384 {
385 case WM_ERRCODE_INVALID_PARAM:
386 case WM_ERRCODE_FAILED:
387 case WM_ERRCODE_WM_DISABLE:
388 case WM_ERRCODE_NO_DATASET:
389 case WM_ERRCODE_FIFO_ERROR:
390 case WM_ERRCODE_TIMEOUT:
391 error_type = MB_ERRCODE_FATAL;
392 break;
393 case WM_ERRCODE_OPERATING:
394 case WM_ERRCODE_ILLEGAL_STATE:
395 case WM_ERRCODE_NO_CHILD:
396 case WM_ERRCODE_OVER_MAX_ENTRY:
397 case WM_ERRCODE_NO_ENTRY:
398 case WM_ERRCODE_INVALID_POLLBITMAP:
399 case WM_ERRCODE_NO_DATA:
400 case WM_ERRCODE_SEND_QUEUE_FULL:
401 case WM_ERRCODE_SEND_FAILED:
402 default:
403 error_type = MB_ERRCODE_WM_FAILURE;
404 break;
405 }
406 }
407 else
408 {
409 // Error at the time of callback.
410 switch (apiid)
411 {
412 case WM_APIID_INITIALIZE:
413 case WM_APIID_SET_LIFETIME:
414 case WM_APIID_SET_P_PARAM:
415 case WM_APIID_SET_BEACON_IND:
416 case WM_APIID_START_PARENT:
417 case WM_APIID_START_MP:
418 case WM_APIID_SET_MP_DATA:
419 case WM_APIID_START_DCF:
420 case WM_APIID_SET_DCF_DATA:
421 case WM_APIID_DISCONNECT:
422 case WM_APIID_START_KS:
423 /* The above errors are important to WM initialization */
424 error_type = MB_ERRCODE_FATAL;
425 break;
426 case WM_APIID_RESET:
427 case WM_APIID_END:
428 default:
429 /* Other errors are returned as callback errors */
430 error_type = MB_ERRCODE_WM_FAILURE;
431 break;
432 }
433 }
434
435 MB_FAKE_OUTPUT("MBFi_ErrorCallback apiid = 0x%x, errcode = 0x%x\n", apiid, errcode);
436 cb.errcode = error_type;
437 mbf_work->stateCallback(MB_COMM_CSTATE_ERROR, &cb);
438 }
439
440
441 //============================================================================
442 // Function for scan
443 //============================================================================
444
MB_FakeSetVerboseScanCallback(WMCallbackFunc callback)445 void MB_FakeSetVerboseScanCallback(WMCallbackFunc callback)
446 {
447 OSIntrMode enabled = OS_DisableInterrupts();
448
449 mbf_work->verboseScanCallback = callback;
450
451 (void)OS_RestoreInterrupts(enabled);
452 }
453
454 /*---------------------------------------------------------------------------*
455 Name: MB_FakeSetCompareGGIDCallback
456
457 Description: Sets the MP parent's GGID comparison callback.
458
459 Arguments: callback The GGID comparison callback function
460
461 Returns: None.
462 *---------------------------------------------------------------------------*/
MB_FakeSetCompareGGIDCallback(MBFakeCompareGGIDCallbackFunc callback)463 void MB_FakeSetCompareGGIDCallback(MBFakeCompareGGIDCallbackFunc callback)
464 {
465 OSIntrMode enabled = OS_DisableInterrupts();
466
467 mbf_work->compareGGIDCallback = callback;
468
469 (void)OS_RestoreInterrupts(enabled);
470 }
471
472 /*---------------------------------------------------------------------------*
473 Name: MB_FakeStartScanParent
474
475 Description: Starts scanning multiboot parent
476
477 Arguments: callback Function that notifies callback of parent scan
478 ggid GGID of the MB parent to search. If GGID is different, it would not be found.
479
480 Returns: None.
481 *---------------------------------------------------------------------------*/
MB_FakeStartScanParent(MBFakeScanCallbackFunc callback,u32 ggid)482 void MB_FakeStartScanParent(MBFakeScanCallbackFunc callback, u32 ggid)
483 {
484 MB_FAKE_OUTPUT("%s\n", __func__);
485
486 mbf_work->scanCallback = callback;
487 mbf_work->ggid = ggid;
488 mbf_work->scanParam.channel = 0;
489 mbf_work->scanParam.scanBuf = &mbf_work->bssDescBuf;
490 mbf_work->scanning = TRUE;
491 mbf_work->locking = FALSE;
492 mbf_work->beaconRecvStatus.nowScanTargetFlag = FALSE;
493 MBFi_StateInStartScan();
494 }
495
496 /*---------------------------------------------------------------------------*
497 Name: MBFi_StateInStartScan
498
499 Description: Issues scan command.
500
501 Arguments: None.
502
503 Returns: None.
504 *---------------------------------------------------------------------------*/
MBFi_StateInStartScan(void)505 static void MBFi_StateInStartScan(void)
506 {
507 WMErrCode result;
508
509 // Issue WM_StartScan
510 if (mbf_work->locking)
511 {
512 mbf_work->scanParam.maxChannelTime = MB_SCAN_TIME_LOCKING;
513 }
514 else
515 {
516 static const u8 ANY_PARENT[6] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
517 WM_CopyBssid(ANY_PARENT, mbf_work->scanParam.bssid);
518
519 mbf_work->scanParam.maxChannelTime = MB_SCAN_TIME_NORMAL_FOR_FAKE_CHILD;
520 // Sets a channel if it is not locked
521 if (!RotateChannel())
522 {
523 // The state which wireless is not usable
524 MBFi_ScanErrorCallback(WM_APIID_MEASURE_CHANNEL, 0);
525 return;
526 }
527 }
528
529 if (mbf_work->scanParam.channel == 0)
530 {
531 mbf_work->scanParam.channel = 1;
532 }
533 result = WM_StartScan(MBFi_StateOutStartScanParent, &mbf_work->scanParam);
534 if (result != WM_ERRCODE_OPERATING)
535 {
536 MBFi_ScanErrorCallback(WM_APIID_START_SCAN, result);
537 }
538 }
539
540 /*---------------------------------------------------------------------------*
541 Name: MBFi_StateOutStartScanParent
542
543 Description: Callback function of WM_StartScan
544
545 Arguments: arg Callback argument of WM_StartScan
546
547 Returns: None.
548 *---------------------------------------------------------------------------*/
MBFi_StateOutStartScanParent(void * arg)549 static void MBFi_StateOutStartScanParent(void *arg)
550 {
551 WMStartScanCallback *cb = (WMStartScanCallback *)arg;
552
553 if (WM_ERRCODE_SUCCESS != cb->errcode)
554 {
555 MBFi_ScanErrorCallback(WM_APIID_START_SCAN, cb->errcode);
556 return;
557 }
558
559 switch (cb->state)
560 {
561 case WM_STATECODE_SCAN_START:
562 break;
563
564 case WM_STATECODE_PARENT_FOUND:
565 // Store the parent information gotten with scan
566 {
567 /*
568 * Make a target for beacon parsing if the specified GGID matches or the user-defined comparison is returned as TRUE.
569 *
570 *
571 */
572 BOOL matched = (mbf_work->compareGGIDCallback == NULL) ?
573 (cb->gameInfo.ggid == mbf_work->ggid) :
574 (*mbf_work->compareGGIDCallback)(cb, mbf_work->ggid);
575 if (mbf_work->verboseScanCallback)
576 {
577 mbf_work->verboseScanCallback(arg);
578 }
579
580 if (matched)
581 {
582 DC_InvalidateRange(&mbf_work->bssDescBuf, WM_BSS_DESC_SIZE);
583 (void)MB_RecvGameInfoBeacon(MBFi_CommBeaconRecvCallback, cb->linkLevel,
584 &mbf_work->bssDescBuf);
585 MB_CountGameInfoLifetime(MBFi_CommBeaconRecvCallback, TRUE);
586 }
587 }
588 // don't break;
589
590 case WM_STATECODE_PARENT_NOT_FOUND:
591 /* Lifetime count of parent game information */
592 MB_CountGameInfoLifetime(MBFi_CommBeaconRecvCallback, FALSE);
593
594 if (mbf_work->scanning)
595 {
596 MBFi_StateInStartScan();
597 }
598 else
599 {
600 MBFi_StateInEndScan();
601 }
602 break;
603
604 default:
605 MBFi_ScanErrorCallback(WM_APIID_START_SCAN, WM_ERRCODE_FAILED);
606 break;
607 }
608 }
609
610
611 /*---------------------------------------------------------------------------*
612 Name: MBFi_ScanCallback
613
614 Description: Uses a callback to notify the user program about the parent
615
616
617 Arguments: state Status to notify
618 gInfop Pointer to the parent information that was found
619 index Control number of the parent managed internally
620
621 Returns: None.
622 *---------------------------------------------------------------------------*/
MBFi_ScanCallback(u16 state,MBGameInfoRecvList * gInfop,int index)623 static void MBFi_ScanCallback(u16 state, MBGameInfoRecvList * gInfop, int index)
624 {
625 MBFakeScanCallback cb;
626
627 if (mbf_work->scanCallback == NULL)
628 {
629 return;
630 }
631
632 cb.index = (u16)index;
633 if (gInfop != NULL)
634 {
635 cb.gameInfo = &gInfop->gameInfo;
636 cb.bssDesc = &gInfop->bssDesc;
637 }
638 else
639 {
640 cb.gameInfo = NULL;
641 cb.bssDesc = NULL;
642 }
643 mbf_work->scanCallback(state, &cb);
644 }
645
646 /*---------------------------------------------------------------------------*
647 Name: MBFi_ScanErrorCallback
648
649 Description: Notifies the error generation at the time of scanning with callback.
650
651 Arguments: apiid APIID that caused the error
652 errcode Error cause code
653
654 Returns: None.
655 *---------------------------------------------------------------------------*/
MBFi_ScanErrorCallback(u16 apiid,u16 errcode)656 static void MBFi_ScanErrorCallback(u16 apiid, u16 errcode)
657 {
658 MBFakeScanErrorCallback cb;
659
660 if (mbf_work->scanCallback == NULL)
661 {
662 return;
663 }
664
665 cb.apiid = apiid;
666 cb.errcode = errcode;
667 mbf_work->scanCallback(MB_FAKESCAN_API_ERROR, &cb);
668 }
669
670 /*---------------------------------------------------------------------------*
671 Name: MBFi_ScanLock
672
673 Description: Locks the parent to scan
674
675 Arguments: macAddr : MAC address of the parent to lock
676
677 Returns: None.
678 *---------------------------------------------------------------------------*/
MBFi_ScanLock(u8 * macAddr)679 static void MBFi_ScanLock(u8 *macAddr)
680 {
681 MB_FAKE_OUTPUT("Scan Locked\n");
682 mbf_work->locking = TRUE;
683 WM_CopyBssid(macAddr, mbf_work->scanParam.bssid);
684 }
685
686 /*---------------------------------------------------------------------------*
687 Name: MBFi_ScanUnlock
688
689 Description: Releases the lock of the parent to scan
690
691 Arguments: None.
692
693 Returns: None.
694 *---------------------------------------------------------------------------*/
MBFi_ScanUnlock(void)695 static void MBFi_ScanUnlock(void)
696 {
697 MB_FAKE_OUTPUT("Scan Unlocked\n");
698 mbf_work->locking = FALSE;
699 }
700
701 /*---------------------------------------------------------------------------*
702 Name: MBi_CommBeaconRecvCallback
703
704 Description: Child beacon receive callback
705
706 Arguments: msg: Beacon receive message
707 gInfop : Parent game information
708 index: Beacon index
709
710 Returns: None.
711 *---------------------------------------------------------------------------*/
MBFi_CommBeaconRecvCallback(MbBeaconMsg msg,MBGameInfoRecvList * gInfop,int index)712 static void MBFi_CommBeaconRecvCallback(MbBeaconMsg msg, MBGameInfoRecvList * gInfop, int index)
713 {
714 switch (msg)
715 {
716 case MB_BC_MSG_GINFO_VALIDATED:
717 MBFi_ScanCallback(MB_FAKESCAN_PARENT_FOUND, (void *)gInfop, index);
718 MB_FAKE_OUTPUT("Parent Info validated\n");
719 break;
720 case MB_BC_MSG_GINFO_INVALIDATED:
721 MB_FAKE_OUTPUT("Parent Info invalidate\n");
722 break;
723 case MB_BC_MSG_GINFO_LOST:
724 MBFi_ScanCallback(MB_FAKESCAN_PARENT_LOST, (void *)gInfop, index);
725 MB_FAKE_OUTPUT("Parent Info Lost\n");
726 break;
727 case MB_BC_MSG_GINFO_LIST_FULL:
728 MB_FAKE_OUTPUT("Parent List Full\n");
729 break;
730 case MB_BC_MSG_GINFO_BEACON:
731 /* Acknowledge each time existing parent beacon is detected */
732 MBFi_ScanCallback(MB_FAKESCAN_PARENT_BEACON, (void *)gInfop, index);
733 break;
734 }
735 }
736
737 /*---------------------------------------------------------------------------*
738 Name: RotateChannel
739
740 Description: Rotates channels
741
742 Arguments: None.
743
744 Returns: If an available channel was not found, this returns FALSE.
745 *---------------------------------------------------------------------------*/
RotateChannel(void)746 static BOOL RotateChannel(void)
747 {
748 u16 allowedChannel = WM_GetAllowedChannel();
749 if (allowedChannel == 0x8000 || allowedChannel == 0)
750 {
751 return FALSE;
752 }
753
754 // Rotate channels
755 mbf_work->scanParam.channel++;
756 while (TRUE)
757 {
758 mbf_work->scanParam.channel++;
759 if (mbf_work->scanParam.channel > 16)
760 {
761 mbf_work->scanParam.channel = 1;
762 }
763 if (allowedChannel & (0x0001 << (mbf_work->scanParam.channel - 1)))
764 {
765 break;
766 }
767 }
768 return TRUE;
769 }
770
771
772 /*---------------------------------------------------------------------------*
773 Name: MB_FakeEndScan
774
775 Description: End scanning for parent
776
777 Arguments: None.
778
779 Returns: None.
780 *---------------------------------------------------------------------------*/
MB_FakeEndScan(void)781 void MB_FakeEndScan(void)
782 {
783 mbf_work->scanning = FALSE;
784 mbf_work->endScanBusy = TRUE;
785 }
786
787
788 /*---------------------------------------------------------------------------*
789 Name: MBFi_StateInEndScan
790
791 Description: Issues the parent scan termination command
792
793 Arguments: None.
794
795 Returns: None.
796 *---------------------------------------------------------------------------*/
MBFi_StateInEndScan(void)797 static void MBFi_StateInEndScan(void)
798 {
799 WMErrCode result;
800
801 result = WM_EndScan(MBFi_StateOutEndScan);
802 if (result != WM_ERRCODE_OPERATING)
803 {
804 MBFi_ScanErrorCallback(WM_APIID_END_SCAN, result);
805 }
806 }
807
808 /*---------------------------------------------------------------------------*
809 Name: MBFi_StateOutEndScan
810
811 Description: Parent scanning termination callback
812
813 Arguments: arg Callback argument of WM_EndScan
814
815 Returns: None.
816 *---------------------------------------------------------------------------*/
MBFi_StateOutEndScan(void * arg)817 static void MBFi_StateOutEndScan(void *arg)
818 {
819 WMCallback *cb = (WMCallback *)arg;
820
821 if (cb->errcode != WM_ERRCODE_SUCCESS)
822 {
823 MBFi_ScanErrorCallback(WM_APIID_END_SCAN, cb->errcode);
824 return;
825 }
826 mbf_work->endScanBusy = FALSE;
827
828 if (mbf_work->endFlag)
829 {
830 MBFi_EndComplete();
831 return;
832 }
833
834 MBFi_ScanCallback(MB_FAKESCAN_END_SCAN, NULL, 0);
835
836 }
837
838
839
840 //============================================================================
841 // Process for entering to parent
842 //============================================================================
843
844 /*---------------------------------------------------------------------------*
845 Name: MB_FakeEntryToParent
846
847 Description: Starts the entry to the parent
848
849 Arguments: index Gives internal control number of the parent for the entry as an argument.
850 For this argument, you should pass the "index" obtained with the MB_FakeStartScanParent callback.
851
852
853 Returns: TRUE if the index of the argument is valid.
854 FALSE if it is not valid.
855 *---------------------------------------------------------------------------*/
MB_FakeEntryToParent(u16 index)856 BOOL MB_FakeEntryToParent(u16 index)
857 {
858 MBGameInfoRecvList *info;
859
860 info = MB_GetGameInfoRecvList(index);
861
862 if (info == NULL)
863 {
864 return FALSE;
865 }
866 mbf_work->targetGgid = info->gameInfo.ggid;
867 mbf_work->targetFileNo = info->gameInfo.fileNo;
868
869 MBi_WMSetBuffer(&mbf_work->wmWork);
870 MBi_WMSetCallback(MBFi_WMCallback);
871 MBFi_CommChangeChildState(MB_COMM_CSTATE_INIT_COMPLETE, NULL);
872 MI_CpuCopy8(&info->bssDesc, &mbf_work->bssDescBuf, sizeof(WMBssDesc));
873 MBi_WMStartConnect(&mbf_work->bssDescBuf);
874
875 return TRUE;
876 }
877
878
879 /*---------------------------------------------------------------------------*
880 Name: MBFi_WMCallback
881
882 Description: Callback function of MP communication
883
884 Arguments: type The callback type
885 arg : Callback argument
886
887 Returns: None.
888 *---------------------------------------------------------------------------*/
MBFi_WMCallback(u16 type,void * arg)889 static void MBFi_WMCallback(u16 type, void *arg)
890 {
891 #pragma unused( arg )
892
893 switch (type)
894 {
895 //--------------------------------------------
896 // Notification of connection failure to parent
897 case MB_CALLBACK_CONNECT_FAILED:
898 MBFi_CommChangeChildState(MB_COMM_CSTATE_CONNECT_FAILED, NULL);
899 break;
900 //--------------------------------------------
901 // Notification of connection to parent complete
902 case MB_CALLBACK_CONNECTED_TO_PARENT:
903 MB_FAKE_OUTPUT("connect to parent\n");
904 MBFi_CommChangeChildState(MB_COMM_CSTATE_CONNECT, arg);
905 MBi_ChildStartMP((u16 *)mbf_work->sendBuf, (u16 *)mbf_work->recvBuf);
906 break;
907 //--------------------------------------------
908 // Notification of disconnection from parent
909 case MB_CALLBACK_DISCONNECTED_FROM_PARENT:
910 MBFi_CommChangeChildState(MB_COMM_CSTATE_DISCONNECTED_BY_PARENT, arg);
911 break;
912 //--------------------------------------------
913 // Notify that the MP communication started
914 case MB_CALLBACK_MP_STARTED:
915 break;
916 //-----------------------------
917 // Notify that data send is possible
918 case MB_CALLBACK_MP_SEND_ENABLE:
919 {
920 // Send data setting process
921 MBFi_CommChildSendData();
922 }
923 break;
924 //-----------------------------
925 // Notify that data receive is possible
926 case MB_CALLBACK_MP_CHILD_RECV:
927 {
928 MBFi_CommChildRecvData((WMPortRecvCallback *)arg);
929 }
930 break;
931 //-----------------------------
932 // Notify that the disconnection from the child is completed.
933 case MB_CALLBACK_DISCONNECT_COMPLETE:
934 if (mbf_work->c_comm_state == MB_COMM_CSTATE_BOOTREQ_ACCEPTED)
935 {
936 // If it is after the boot request is received, it changes into the boot complete status
937 MBFi_CommChangeChildState(MB_COMM_CSTATE_BOOT_READY, NULL);
938 }
939 else
940 {
941 // If it is before the boot request is received, it changes into the cancel status
942 MBFi_CommChangeChildState(MB_COMM_CSTATE_CANCELLED, NULL);
943 }
944 if (mbf_work->endFlag)
945 {
946 MBFi_EndComplete();
947 }
948 break;
949 //------------------------------
950 // MP communication notification
951 case MB_CALLBACK_MP_CHILD_SENT:
952 case MB_CALLBACK_MP_CHILD_SENT_TIMEOUT:
953 case MB_CALLBACK_MP_CHILD_SENT_ERR:
954 // Process is not necessary because this is only notifying the communication condition of MP level.
955 break;
956 //------------------------------
957 // Handles error
958 case MB_CALLBACK_API_ERROR:
959 {
960 MBErrorCallback *cb = (MBErrorCallback *) arg;
961
962 MBFi_ErrorCallback(cb->apiid, cb->errcode, TRUE);
963 if (mbf_work->endFlag)
964 {
965 MBi_WMReset();
966 }
967 }
968 break;
969 case MB_CALLBACK_ERROR:
970 {
971 MBErrorCallback *cb = (MBErrorCallback *) arg;
972
973 MBFi_ErrorCallback(cb->apiid, cb->errcode, FALSE);
974 if (mbf_work->endFlag)
975 {
976 MBi_WMReset();
977 }
978 }
979 break;
980 default:
981 break;
982 }
983 }
984
985
986 /*---------------------------------------------------------------------------*
987 Name: MBFi_CommChildRecvData
988
989 Description: Process for receiving data from a parent
990
991 Arguments: cb Callback argument of the port callback
992
993 Returns: None.
994 *---------------------------------------------------------------------------*/
MBFi_CommChildRecvData(WMPortRecvCallback * cb)995 static void MBFi_CommChildRecvData(WMPortRecvCallback *cb)
996 {
997 MBCommParentBlockHeader hd;
998
999 // Header parsing
1000 (void)MBi_SetRecvBufferFromParent(&hd, (u8 *)cb->data);
1001
1002 // MBFi_PrintMBCommCallbacyType( hd.type );
1003
1004 switch (hd.type) // State transition depending on receive block type
1005 {
1006 case MB_COMM_TYPE_PARENT_SENDSTART:
1007 // Send start message from parent
1008 if (mbf_work->c_comm_state == MB_COMM_CSTATE_CONNECT)
1009 {
1010 MB_FAKE_OUTPUT("Allowd to request file from parent!\n");
1011 MBFi_CommChangeChildState(MB_COMM_CSTATE_REQ_ENABLE, NULL);
1012 }
1013 break;
1014
1015 case MB_COMM_TYPE_PARENT_KICKREQ: // Kick message from parent
1016 if (mbf_work->c_comm_state == MB_COMM_CSTATE_REQ_ENABLE)
1017 {
1018 MBFi_CommChangeChildState(MB_COMM_CSTATE_REQ_REFUSED, NULL);
1019 }
1020 break;
1021
1022 case MB_COMM_TYPE_PARENT_MEMBER_FULL: // Message from parent regarding excessive number of members
1023 if (mbf_work->c_comm_state == MB_COMM_CSTATE_REQ_ENABLE)
1024 {
1025 MBFi_CommChangeChildState(MB_COMM_CSTATE_MEMBER_FULL, NULL);
1026 }
1027 break;
1028
1029 case MB_COMM_TYPE_PARENT_DL_FILEINFO:
1030 // Receive MbDownloadFileInfoHeader
1031 if (mbf_work->c_comm_state == MB_COMM_CSTATE_REQ_ENABLE)
1032 {
1033 /* Pass the received MbDownloadFileInfo as an argument. */
1034 MBFi_CommChangeChildState(MB_COMM_CSTATE_DLINFO_ACCEPTED, NULL);
1035 }
1036
1037 break;
1038
1039 case MB_COMM_TYPE_PARENT_DATA:
1040 /* Receive block data */
1041 if (mbf_work->c_comm_state == MB_COMM_CSTATE_DLINFO_ACCEPTED)
1042 {
1043 MBFi_CommChangeChildState(MB_COMM_CSTATE_RECV_PROCEED, NULL);
1044 }
1045
1046 if (mbf_work->c_comm_state == MB_COMM_CSTATE_RECV_PROCEED)
1047 {
1048 MBFi_CommChangeChildState(MB_COMM_CSTATE_RECV_COMPLETE, NULL); // Receive complete
1049 }
1050 break;
1051
1052 case MB_COMM_TYPE_PARENT_BOOTREQ:
1053 if (mbf_work->c_comm_state == MB_COMM_CSTATE_RECV_COMPLETE)
1054 {
1055 MBFi_CommChangeChildState(MB_COMM_CSTATE_BOOTREQ_ACCEPTED, NULL);
1056 }
1057 else if (mbf_work->c_comm_state == MB_COMM_CSTATE_BOOTREQ_ACCEPTED)
1058 {
1059 MBi_WMDisconnect(); // End communication
1060 }
1061 break;
1062 default:
1063 break;
1064 }
1065
1066 return;
1067 }
1068
1069
1070
1071 /*---------------------------------------------------------------------------*
1072 Name: MBi_CommChildSendData
1073
1074 Description: Sends child data.
1075
1076 Arguments: None.
1077
1078 Returns: None.
1079 *---------------------------------------------------------------------------*/
1080
MBFi_CommChildSendData(void)1081 static void MBFi_CommChildSendData(void)
1082 {
1083 MBCommChildBlockHeader hd;
1084 WMErrCode errcode = WM_ERRCODE_SUCCESS;
1085 u16 pollbmp = 0xffff;
1086
1087 switch (mbf_work->c_comm_state)
1088 {
1089 case MB_COMM_CSTATE_REQ_ENABLE:
1090 {
1091 MBCommRequestData req_data;
1092 u8 *databuf;
1093
1094 req_data.ggid = mbf_work->targetGgid;
1095 req_data.version = MB_IPL_VERSION;
1096 req_data.fileid = (u8)mbf_work->targetFileNo;
1097 MI_CpuCopy8(&mbf_work->userInfo, &req_data.userinfo, sizeof(MBUserInfo));
1098
1099 hd.type = MB_COMM_TYPE_CHILD_FILEREQ;
1100 hd.req_data.piece = MBi_SendRequestDataPiece(hd.req_data.data, &req_data);
1101 databuf = MBi_MakeChildSendBuffer(&hd, (u8 *)mbf_work->sendDataBuf);
1102 if (databuf == NULL)
1103 {
1104 return;
1105 }
1106 errcode = MBi_MPSendToParent(MB_COMM_CHILD_HEADER_SIZE, pollbmp, mbf_work->sendDataBuf);
1107 }
1108 break;
1109
1110 case MB_COMM_CSTATE_DLINFO_ACCEPTED:
1111 // DownloadInfo reception message
1112 hd.type = MB_COMM_TYPE_CHILD_ACCEPT_FILEINFO;
1113 (void)MBi_MakeChildSendBuffer(&hd, (u8 *)mbf_work->sendDataBuf);
1114 errcode = MBi_MPSendToParent(MB_COMM_CHILD_HEADER_SIZE, pollbmp, mbf_work->sendDataBuf);
1115 break;
1116
1117 case MB_COMM_CSTATE_RECV_PROCEED:
1118 break;
1119
1120 case MB_COMM_CSTATE_RECV_COMPLETE:
1121 // Block transfer stop message (send continues until BOOTREQ comes from parent)
1122 hd.type = MB_COMM_TYPE_CHILD_STOPREQ;
1123 (void)MBi_MakeChildSendBuffer(&hd, (u8 *)mbf_work->sendDataBuf);
1124 errcode = MBi_MPSendToParent(MB_COMM_CHILD_HEADER_SIZE, pollbmp, mbf_work->sendDataBuf);
1125 break;
1126
1127 case MB_COMM_CSTATE_BOOTREQ_ACCEPTED:
1128 hd.type = MB_COMM_TYPE_CHILD_BOOTREQ_ACCEPTED;
1129 (void)MBi_MakeChildSendBuffer(&hd, (u8 *)mbf_work->sendDataBuf);
1130 errcode = MBi_MPSendToParent(MB_COMM_CHILD_HEADER_SIZE, pollbmp, mbf_work->sendDataBuf);
1131 break;
1132 default:
1133 // Send DUMMY MP to establish MP communication
1134 hd.type = MB_COMM_TYPE_DUMMY;
1135 (void)MBi_MakeChildSendBuffer(&hd, (u8 *)mbf_work->sendDataBuf);
1136 errcode = MBi_MPSendToParent(MB_COMM_CHILD_HEADER_SIZE, pollbmp, mbf_work->sendDataBuf);
1137 break;
1138
1139 }
1140 }
1141
1142
1143 /*---------------------------------------------------------------------------*
1144 Name: MB_FakeGetParentGameInfo
1145
1146 Description: Gets the game information of the parent from the parent list
1147
1148 Arguments: index Parent index
1149 pGameInfo Pointer to the region that gets the parent information
1150
1151 Returns: TRUE if the index of a valid parent.
1152 FALSE if the index of an invalid parent.
1153 *---------------------------------------------------------------------------*/
MB_FakeGetParentGameInfo(u16 index,MBGameInfo * pGameInfo)1154 BOOL MB_FakeGetParentGameInfo(u16 index, MBGameInfo *pGameInfo)
1155 {
1156 MBGameInfoRecvList *parentInfo;
1157 OSIntrMode enabled;
1158
1159 if (index >= MB_GAME_INFO_RECV_LIST_NUM)
1160 {
1161 return FALSE;
1162 }
1163
1164 enabled = OS_DisableInterrupts();
1165
1166 parentInfo = MB_GetGameInfoRecvList(index);
1167 if (parentInfo == NULL)
1168 {
1169 (void)OS_RestoreInterrupts(enabled);
1170 return FALSE;
1171 }
1172 MI_CpuCopy8(&parentInfo->gameInfo, pGameInfo, sizeof(MBGameInfo));
1173 (void)OS_RestoreInterrupts(enabled);
1174 return TRUE;
1175 }
1176
1177
1178 /*---------------------------------------------------------------------------*
1179 Name: MB_FakeGetParentBssDesc
1180
1181 Description: Gets the BssDesc of the parent from the parent list.
1182
1183 Arguments: index Parent index
1184 pBssDesc Pointer to the region that obtains the parent information
1185
1186 Returns: TRUE if the index of a valid parent.
1187 FALSE if the index of an invalid parent.
1188 *---------------------------------------------------------------------------*/
MB_FakeGetParentBssDesc(u16 index,WMBssDesc * pBssDesc)1189 BOOL MB_FakeGetParentBssDesc(u16 index, WMBssDesc *pBssDesc)
1190 {
1191 MBGameInfoRecvList *parentInfo;
1192 OSIntrMode enabled;
1193
1194 if (index >= MB_GAME_INFO_RECV_LIST_NUM)
1195 {
1196 return FALSE;
1197 }
1198
1199 enabled = OS_DisableInterrupts();
1200
1201 parentInfo = MB_GetGameInfoRecvList(index);
1202 if (parentInfo == NULL)
1203 {
1204 (void)OS_RestoreInterrupts(enabled);
1205 return FALSE;
1206 }
1207 MI_CpuCopy8(&parentInfo->bssDesc, pBssDesc, sizeof(WMBssDesc));
1208 (void)OS_RestoreInterrupts(enabled);
1209 return TRUE;
1210 }
1211
1212
1213 /*---------------------------------------------------------------------------*
1214 Name: MB_FakeReadParentBssDesc
1215
1216 Description: Gets the information for WM_StartConnect function based on the parent BssDesc of the parent list.
1217
1218 Arguments: index Parent index
1219 pBssDesc Pointer to the region that obtains the parent information
1220 parent_max_size Maximum send size of the MP parent
1221 child_max_size Maximum send size of the MP child
1222 ks_flag Flag for setting key sharing
1223 cs_flag Flag for setting continuous transfer
1224
1225 Returns: TRUE if the index of a valid parent.
1226 FALSE if the index of an invalid parent.
1227 *---------------------------------------------------------------------------*/
MB_FakeReadParentBssDesc(u16 index,WMBssDesc * pBssDesc,u16 parent_max_size,u16 child_max_size,BOOL ks_flag,BOOL cs_flag)1228 BOOL MB_FakeReadParentBssDesc(u16 index, WMBssDesc *pBssDesc, u16 parent_max_size,
1229 u16 child_max_size, BOOL ks_flag, BOOL cs_flag)
1230 {
1231 BOOL result;
1232
1233 SDK_NULL_ASSERT(pBssDesc);
1234
1235 result = MB_FakeGetParentBssDesc(index, pBssDesc);
1236
1237 if (!result)
1238 {
1239 return FALSE;
1240 }
1241
1242 pBssDesc->gameInfoLength = 0x10;
1243 pBssDesc->gameInfo.userGameInfoLength = 0;
1244 pBssDesc->gameInfo.parentMaxSize = parent_max_size;
1245 pBssDesc->gameInfo.childMaxSize = child_max_size;
1246 pBssDesc->gameInfo.attribute = (u8)((ks_flag ? WM_ATTR_FLAG_KS : 0) |
1247 (cs_flag ? WM_ATTR_FLAG_CS : 0) | WM_ATTR_FLAG_ENTRY);
1248 return TRUE;
1249 }
1250
1251
1252
1253 #if (MB_FAKE_PRINT == 1)
1254
1255 /*---------------------------------------------------------------------------*
1256 Name: MBFi_PrintMBCallbackType
1257
1258 Description: Debug outputs the callback type from MB_WM
1259
1260 Arguments: type The callback type
1261
1262 Returns: None.
1263 *---------------------------------------------------------------------------*/
MBFi_PrintMBCallbackType(u16 type)1264 static void MBFi_PrintMBCallbackType(u16 type)
1265 {
1266 #pragma unused( type )
1267 static const char *const CALLBACK_NAME[] = {
1268 "MB_CALLBACK_CHILD_CONNECTED",
1269 "MB_CALLBACK_CHILD_DISCONNECTED",
1270 "MB_CALLBACK_MP_PARENT_SENT",
1271 "MB_CALLBACK_MP_PARENT_RECV",
1272 "MB_CALLBACK_PARENT_FOUND",
1273 "MB_CALLBACK_PARENT_NOT_FOUND",
1274 "MB_CALLBACK_CONNECTED_TO_PARENT",
1275 "MB_CALLBACK_DISCONNECTED",
1276 "MB_CALLBACK_MP_CHILD_SENT",
1277 "MB_CALLBACK_MP_CHILD_RECV",
1278 "MB_CALLBACK_DISCONNECTED_FROM_PARENT",
1279 "MB_CALLBACK_CONNECT_FAILED",
1280 "MB_CALLBACK_DCF_CHILD_SENT",
1281 "MB_CALLBACK_DCF_CHILD_SENT_ERR",
1282 "MB_CALLBACK_DCF_CHILD_RECV",
1283 "MB_CALLBACK_DISCONNECT_COMPLETE",
1284 "MB_CALLBACK_DISCONNECT_FAILED",
1285 "MB_CALLBACK_END_COMPLETE",
1286 "MB_CALLBACK_MP_CHILD_SENT_ERR",
1287 "MB_CALLBACK_MP_PARENT_SENT_ERR",
1288 "MB_CALLBACK_MP_STARTED",
1289 "MB_CALLBACK_INIT_COMPLETE",
1290 "MB_CALLBACK_END_MP_COMPLETE",
1291 "MB_CALLBACK_SET_GAMEINFO_COMPLETE",
1292 "MB_CALLBACK_SET_GAMEINFO_FAILED",
1293 "MB_CALLBACK_MP_SEND_ENABLE",
1294 "MB_CALLBACK_PARENT_STARTED",
1295 "MB_CALLBACK_BEACON_LOST",
1296 "MB_CALLBACK_BEACON_SENT",
1297 "MB_CALLBACK_BEACON_RECV",
1298 "MB_CALLBACK_MP_SEND_DISABLE",
1299 "MB_CALLBACK_DISASSOCIATE",
1300 "MB_CALLBACK_REASSOCIATE",
1301 "MB_CALLBACK_AUTHENTICATE",
1302 "MB_CALLBACK_SET_LIFETIME",
1303 "MB_CALLBACK_DCF_STARTED",
1304 "MB_CALLBACK_DCF_SENT",
1305 "MB_CALLBACK_DCF_SENT_ERR",
1306 "MB_CALLBACK_DCF_RECV",
1307 "MB_CALLBACK_DCF_END",
1308 "MB_CALLBACK_MPACK_IND",
1309 "MB_CALLBACK_MP_CHILD_SENT_TIMEOUT",
1310 "MB_CALLBACK_SEND_QUEUE_FULL_ERR",
1311 "MB_CALLBACK_API_ERROR",
1312 "MB_CALLBACK_ERROR",
1313 };
1314
1315 MB_FAKE_OUTPUT("RecvCallback %s\n", CALLBACK_NAME[type]);
1316 }
1317
1318 /*---------------------------------------------------------------------------*
1319 Name: MBFi_PrintMBCommCallbacyType
1320
1321 Description: Debug outputs the message type of the packet from a parent
1322
1323 Arguments: type Message type
1324
1325 Returns: None.
1326 *---------------------------------------------------------------------------*/
MBFi_PrintMBCommCallbacyType(u16 type)1327 static void MBFi_PrintMBCommCallbacyType(u16 type)
1328 {
1329 #pragma unused( type )
1330 static const char *const MB_TYPE_STRING[] = {
1331 "MB_COMM_TYPE_DUMMY", // 0
1332 "MB_COMM_TYPE_PARENT_SENDSTART", // 1
1333 "MB_COMM_TYPE_PARENT_KICKREQ", // 2
1334 "MB_COMM_TYPE_PARENT_DL_FILEINFO", // 3
1335 "MB_COMM_TYPE_PARENT_DATA", // 4
1336 "MB_COMM_TYPE_PARENT_BOOTREQ", // 5
1337 "MB_COMM_TYPE_PARENT_MEMBER_FULL", // 6
1338 "MB_COMM_TYPE_CHILD_FILEREQ", // 7
1339 "MB_COMM_TYPE_CHILD_ACCEPT_FILEINFO", // 8
1340 "MB_COMM_TYPE_CHILD_CONTINUE", // 9
1341 "MB_COMM_TYPE_CHILD_STOPREQ", // 10
1342 "MB_COMM_TYPE_CHILD_BOOTREQ_ACCEPTED", // 11
1343 };
1344
1345 MB_FAKE_OUTPUT("RECV %s\n", MB_TYPE_STRING[type]);
1346 }
1347
1348 #endif
1349