← Back to branch summary

~registry/dolphin-emu/triforce

« back to all changes in this revision

Viewing changes to Source/Core/Core/Src/HW/AMBaseboard.cpp

  • Committer: Sérgio Benjamim
  • Date: 2015-02-13 05:54:40 UTC
  • Revision ID: sergio_br2@yahoo.com.br-20150213055440-ey2rt3sjpy27km78
Dolphin Triforce branch from code.google, commit b957980 (4.0-315).

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/Core/Core/Src/HW/AMBaseboard.cpp
 
1
// Copyright 2013 Dolphin Emulator Project
 
2
// Licensed under GPLv2
 
3
// Refer to the license.txt file included.
 
4
 
 
5
#include "Common.h" // Common
 
6
#include "ChunkFile.h"
 
7
#include "../ConfigManager.h"
 
8
#include "../CoreTiming.h"
 
9
#include "../HW/SystemTimers.h"
 
10
#include "Memmap.h"
 
11
#include "DVDInterface.h"
 
12
 
 
13
#include "AMBaseboard.h"
 
14
 
 
15
namespace AMBaseboard
 
16
{
 
17
 
 
18
static File::IOFile             *m_netcfg;
 
19
static File::IOFile             *m_netctrl;
 
20
static File::IOFile             *m_dimm;
 
21
 
 
22
static u32 m_controllertype;
 
23
 
 
24
static unsigned char media_buffer[0x60];
 
25
static unsigned char network_command_buffer[0x200];
 
26
 
 
27
static inline void PrintMBBuffer( u32 Address )
 
28
{
 
29
        NOTICE_LOG(DVDINTERFACE, "GC-AM: %08x %08x %08x %08x",  Memory::Read_U32(Address),
 
30
                                                                                                                        Memory::Read_U32(Address+4),
 
31
                                                                                                                        Memory::Read_U32(Address+8),
 
32
                                                                                                                        Memory::Read_U32(Address+12) );
 
33
        NOTICE_LOG(DVDINTERFACE, "GC-AM: %08x %08x %08x %08x",  Memory::Read_U32(Address+16),
 
34
                                                                                                                        Memory::Read_U32(Address+20),
 
35
                                                                                                                        Memory::Read_U32(Address+24),
 
36
                                                                                                                        Memory::Read_U32(Address+28) );
 
37
}
 
38
 
 
39
void Init( void )
 
40
{
 
41
        u32 gameid;
 
42
        memset( media_buffer, 0, sizeof(media_buffer) );
 
43
 
 
44
        //Convert game ID into hex
 
45
        sscanf( SConfig::GetInstance().m_LocalCoreStartupParameter.GetUniqueID().c_str(), "%s", &gameid );
 
46
 
 
47
        // This is checking for the real game IDs (not those people made up) (See boot.id within the game)
 
48
        switch(Common::swap32(gameid))
 
49
        {
 
50
                // SBGE - F-ZERO AX
 
51
                case 0x53424745:                
 
52
                        m_controllertype = 1;
 
53
                        break;
 
54
                // SBLJ - VIRTUA STRIKER 4 Ver.2006
 
55
                case 0x53424C4A:
 
56
                // SBHJ - VIRTUA STRIKER 4 VER.A
 
57
                case 0x5342484A:        
 
58
                // SBJJ - VIRTUA STRIKER 4
 
59
                case 0x53424A4A:        
 
60
                // SBEJ - Virtua Striker 2002
 
61
                case 0x5342454A:                
 
62
                        m_controllertype = 2;
 
63
                        break;
 
64
                // SBKJ - MARIOKART ARCADE GP
 
65
                case 0x53424B4A:
 
66
                // SBNJ - MARIOKART ARCADE GP2
 
67
                case 0x53424E4A:                
 
68
                        m_controllertype = 3;
 
69
                        break;
 
70
                default:
 
71
                //      PanicAlertT("Unknown game ID, using default controls.");
 
72
                        m_controllertype = 3;
 
73
                        break;
 
74
        }
 
75
 
 
76
        std::string netcfg_Filename( File::GetUserPath(D_TRIUSER_IDX) + "trinetcfg.bin" );
 
77
        if( File::Exists( netcfg_Filename ) )
 
78
        {
 
79
                m_netcfg = new File::IOFile( netcfg_Filename, "rb+" );
 
80
        }
 
81
        else
 
82
        {
 
83
                m_netcfg = new File::IOFile( netcfg_Filename, "wb+" );
 
84
        }
 
85
        
 
86
        std::string netctrl_Filename( File::GetUserPath(D_TRIUSER_IDX) +  "trinetctrl.bin" );
 
87
        if( File::Exists( netctrl_Filename ) )
 
88
        {
 
89
                m_netctrl = new File::IOFile( netctrl_Filename, "rb+" );
 
90
        }
 
91
        else
 
92
        {
 
93
                m_netctrl = new File::IOFile( netctrl_Filename, "wb+" );
 
94
        }
 
95
 
 
96
        std::string dimm_Filename( File::GetUserPath(D_TRIUSER_IDX) + "tridimm_" + SConfig::GetInstance().m_LocalCoreStartupParameter.GetUniqueID() + ".bin" );
 
97
        if( File::Exists( dimm_Filename ) )
 
98
        {
 
99
                m_dimm = new File::IOFile( dimm_Filename, "rb+" );              
 
100
        }
 
101
        else
 
102
        {
 
103
                m_dimm = new File::IOFile( dimm_Filename, "wb+" );
 
104
        }
 
105
}
 
106
u32 ExecuteCommand( u32 Command, u32 Length, u32 Address, u32 Offset )
 
107
{
 
108
        NOTICE_LOG(DVDINTERFACE, "GCAM: %08x %08x DMA=addr:%08x,len:%08x",
 
109
                Command, Offset, Address, Length);
 
110
 
 
111
        switch(Command>>24)
 
112
        {
 
113
                // Inquiry
 
114
                case 0x12:
 
115
                        return 0x21000000;
 
116
                        break;
 
117
                // Read
 
118
                case 0xA8:
 
119
                        if( (Offset & 0x8FFF0000) == 0x80000000 )
 
120
                        {
 
121
                                switch(Offset)
 
122
                                {
 
123
                                // Media board status (1)
 
124
                                case 0x80000000:
 
125
                                        Memory::Write_U16( Common::swap16( 0x0100 ), Address );
 
126
                                        break;
 
127
                                // Media board status (2)
 
128
                                case 0x80000020:
 
129
                                        memset( Memory::GetPointer(Address), 0, Length );
 
130
                                        break;
 
131
                                // Media board status (3)
 
132
                                case 0x80000040:
 
133
                                        memset( Memory::GetPointer(Address), 0xFFFFFFFF, Length );
 
134
                                        // DIMM size (512MB)
 
135
                                        Memory::Write_U32( Common::swap32( 0x20000000 ), Address );
 
136
                                        // GCAM signature
 
137
                                        Memory::Write_U32( 0x4743414D, Address+4 );
 
138
                                        break;
 
139
                                // Firmware status (1)
 
140
                                case 0x80000120:
 
141
                                        Memory::Write_U32( Common::swap32( (u32)0x00000001 ), Address );
 
142
                                        break;
 
143
                                // Firmware status (2)
 
144
                                case 0x80000140:
 
145
                                        Memory::Write_U32( Common::swap32( (u32)0x00000001 ), Address );
 
146
                                        break;
 
147
                                default:
 
148
                                        PrintMBBuffer(Address);
 
149
                                        PanicAlertT("Unhandled Media Board Read");
 
150
                                        break;
 
151
                                }
 
152
                                return 0;
 
153
                        }
 
154
                        // Network configuration
 
155
                        if( (Offset == 0x00000000) && (Length == 0x80) )
 
156
                        {
 
157
                                m_netcfg->Seek( 0, SEEK_SET );
 
158
                                m_netcfg->ReadBytes( Memory::GetPointer(Address), Length );
 
159
                                return 0;
 
160
                        }
 
161
                        // DIMM memory (3MB)
 
162
                        if( (Offset >= 0x1F000000) && (Offset <= 0x1F300000) )
 
163
                        {
 
164
                                u32 dimmoffset = Offset - 0x1F000000;
 
165
                                m_dimm->Seek( dimmoffset, SEEK_SET );
 
166
                                m_dimm->ReadBytes( Memory::GetPointer(Address), Length );
 
167
                                return 0;
 
168
                        }
 
169
                        // DIMM command
 
170
                        if( (Offset >= 0x1F900000) && (Offset <= 0x1F90003F) )
 
171
                        {
 
172
                                u32 dimmoffset = Offset - 0x1F900000;
 
173
                                memcpy( Memory::GetPointer(Address), media_buffer + dimmoffset, Length );
 
174
                                
 
175
                                NOTICE_LOG(DVDINTERFACE, "GC-AM: Read MEDIA BOARD COMM AREA (%08x)", dimmoffset );
 
176
                                PrintMBBuffer(Address);
 
177
                                return 0;
 
178
                        }
 
179
                        // Network command
 
180
                        if( (Offset >= 0x1F800200) && (Offset <= 0x1F8003FF) )
 
181
                        {
 
182
                                memcpy( Memory::GetPointer(Address), network_command_buffer, Length );           
 
183
                                return 0;
 
184
                        }
 
185
                        // DIMM command
 
186
                        if( (Offset >= 0x84000000) && (Offset <= 0x8400005F) )
 
187
                        {
 
188
                                u32 dimmoffset = Offset - 0x84000000;
 
189
                                memcpy( Memory::GetPointer(Address), media_buffer + dimmoffset, Length );
 
190
                                
 
191
                                NOTICE_LOG(DVDINTERFACE, "GC-AM: Read MEDIA BOARD COMM AREA (%08x)", dimmoffset );
 
192
                                PrintMBBuffer(Address);
 
193
                                return 0;
 
194
                        }
 
195
                        // DIMM memory (8MB)
 
196
                        if( (Offset >= 0xFF000000) && (Offset <= 0xFF800000) )
 
197
                        {
 
198
                                u32 dimmoffset = Offset - 0xFF000000;
 
199
                                m_dimm->Seek( dimmoffset, SEEK_SET );
 
200
                                m_dimm->ReadBytes( Memory::GetPointer(Address), Length );
 
201
                                return 0;
 
202
                        }
 
203
                        // Network control
 
204
                        if( (Offset == 0xFFFF0000) && (Length == 0x20) )
 
205
                        {
 
206
                                m_netctrl->Seek( 0, SEEK_SET );
 
207
                                m_netctrl->ReadBytes( Memory::GetPointer(Address), Length );
 
208
                                return 0;
 
209
                        }
 
210
                        // Max GC disc offset
 
211
                        if( Offset >= 0x57058000 )
 
212
                        {
 
213
                                PanicAlertT("Unhandled Media Board Read");
 
214
                        }
 
215
                        if( !DVDInterface::DVDRead( Offset, Address, Length) )
 
216
                        {
 
217
                                PanicAlertT("Can't read from DVD_Plugin - DVD-Interface: Fatal Error");
 
218
                        }
 
219
                        break;
 
220
                // Write
 
221
                case 0xAA:
 
222
                        // Network configuration
 
223
                        if( (Offset == 0x00000000) && (Length == 0x80) )
 
224
                        {
 
225
                                m_netcfg->Seek( 0, SEEK_SET );
 
226
                                m_netcfg->WriteBytes( Memory::GetPointer(Address), Length );
 
227
                                return 0;
 
228
                        }
 
229
                        // Backup memory (8MB)
 
230
                        if( (Offset >= 0x000006A0) && (Offset <= 0x00800000) )
 
231
                        {
 
232
                                m_dimm->Seek( Offset, SEEK_SET );
 
233
                                m_dimm->WriteBytes( Memory::GetPointer(Address), Length );
 
234
                                return 0;
 
235
                        }
 
236
                        // DIMM memory (3MB)
 
237
                        if( (Offset >= 0x1F000000) && (Offset <= 0x1F300000) )
 
238
                        {
 
239
                                u32 dimmoffset = Offset - 0x1F000000;
 
240
                                m_dimm->Seek( dimmoffset, SEEK_SET );
 
241
                                m_dimm->WriteBytes( Memory::GetPointer(Address), Length );
 
242
                                return 0;
 
243
                        }
 
244
                        // Network command
 
245
                        if( (Offset >= 0x1F800200) && (Offset <= 0x1F8003FF) )
 
246
                        {
 
247
                                memcpy( network_command_buffer, Memory::GetPointer(Address), Length );           
 
248
                                return 0;
 
249
                        }
 
250
                        // DIMM command
 
251
                        if( (Offset >= 0x1F900000) && (Offset <= 0x1F90003F) )
 
252
                        {
 
253
                                u32 dimmoffset = Offset - 0x1F900000;
 
254
                                memcpy( media_buffer + dimmoffset, Memory::GetPointer(Address), Length );
 
255
                                
 
256
                                ERROR_LOG(DVDINTERFACE, "GC-AM: Write MEDIA BOARD COMM AREA (%08x)", dimmoffset );
 
257
                                PrintMBBuffer(Address);
 
258
                                return 0;
 
259
                        }
 
260
                        // DIMM command
 
261
                        if( (Offset >= 0x84000000) && (Offset <= 0x8400005F) )
 
262
                        {
 
263
                                u32 dimmoffset = Offset - 0x84000000;
 
264
                                memcpy( media_buffer + dimmoffset, Memory::GetPointer(Address), Length );
 
265
 
 
266
                                if( dimmoffset == 0x40 )
 
267
                                {
 
268
                                        ERROR_LOG(DVDINTERFACE, "GC-AM: EXECUTE (%03x)", *(u16*)(media_buffer+0x22) );
 
269
                                }
 
270
                                
 
271
                                ERROR_LOG(DVDINTERFACE, "GC-AM: Write MEDIA BOARD COMM AREA (%08x)", dimmoffset );
 
272
                                PrintMBBuffer(Address);
 
273
                                return 0;
 
274
                        }
 
275
                        // DIMM memory (8MB)
 
276
                        if( (Offset >= 0xFF000000) && (Offset <= 0xFF800000) )
 
277
                        {
 
278
                                u32 dimmoffset = Offset - 0xFF000000;
 
279
                                m_dimm->Seek( dimmoffset, SEEK_SET );
 
280
                                m_dimm->WriteBytes( Memory::GetPointer(Address), Length );
 
281
                                return 0;
 
282
                        }
 
283
                        // Network control
 
284
                        if( (Offset == 0xFFFF0000) && (Length == 0x20) )
 
285
                        {
 
286
                                m_netctrl->Seek( 0, SEEK_SET );
 
287
                                m_netctrl->WriteBytes( Memory::GetPointer(Address), Length );
 
288
                                return 0;
 
289
                        }
 
290
                        // Max GC disc offset
 
291
                        if( Offset >= 0x57058000 )
 
292
                        {
 
293
                                PrintMBBuffer(Address);
 
294
                                PanicAlertT("Unhandled Media Board Write");
 
295
                        }
 
296
                        break;
 
297
                // Execute
 
298
                case 0xAB:
 
299
 
 
300
                        if( (Offset == 0) && (Length == 0) )
 
301
                        {
 
302
                                memset( media_buffer, 0, 0x20 );
 
303
 
 
304
                                media_buffer[0] = media_buffer[0x20];
 
305
 
 
306
                                // Command
 
307
                                *(u16*)(media_buffer+2) = *(u16*)(media_buffer+0x22) | 0x8000;
 
308
                                
 
309
                                NOTICE_LOG(DVDINTERFACE, "GCAM: Execute command:%03X", *(u16*)(media_buffer+0x22) );
 
310
 
 
311
                                switch(*(u16*)(media_buffer+0x22))
 
312
                                {
 
313
                                        // ?
 
314
                                        case 0x000:
 
315
                                                *(u32*)(media_buffer+4) = 1;
 
316
                                                break;
 
317
                                        // DIMM size
 
318
                                        case 0x001:
 
319
                                                *(u32*)(media_buffer+4) = 0x20000000;
 
320
                                                break;
 
321
                                        // Media board status
 
322
                                        /*
 
323
                                        0x00: "Initializing media board. Please wait.."
 
324
                                        0x01: "Checking network. Please wait..." 
 
325
                                        0x02: "Found a system disc. Insert a game disc"
 
326
                                        0x03: "Testing a game program. %d%%"
 
327
                                        0x04: "Loading a game program. %d%%"
 
328
                                        0x05: go
 
329
                                        0x06: error xx
 
330
                                        */
 
331
                                        case 0x100:
 
332
                                                // Status
 
333
                                                *(u32*)(media_buffer+4) = 5;
 
334
                                                // Progress in %
 
335
                                                *(u32*)(media_buffer+8) = 100;
 
336
                                                break;
 
337
                                        // Media board version: 3.03
 
338
                                        case 0x101:
 
339
                                                // Version
 
340
                                                *(u16*)(media_buffer+4) = Common::swap16(0x0303);
 
341
                                                // Unknown
 
342
                                                *(u16*)(media_buffer+6) = Common::swap16(0x0100);
 
343
                                                *(u32*)(media_buffer+8)= 1;
 
344
                                                *(u32*)(media_buffer+16)= 0xFFFFFFFF;
 
345
                                                break;
 
346
                                        // System flags
 
347
                                        case 0x102:
 
348
                                                // 1: GD-ROM                                    
 
349
                                                media_buffer[4] = 1;
 
350
                                                media_buffer[5] = 0;
 
351
                                                // enable development mode (Sega Boot)
 
352
                                                media_buffer[6] = 1;
 
353
                                                // Only used when inquiry 0x29
 
354
                                                /*
 
355
                                                        0: NAND/MASK BOARD(HDD)
 
356
                                                        1: NAND/MASK BOARD(MASK)
 
357
                                                        2: NAND/MASK BOARD(NAND)
 
358
                                                        3: NAND/MASK BOARD(NAND)
 
359
                                                        4: DIMM BOARD (TYPE 3)
 
360
                                                        5: DIMM BOARD (TYPE 3)
 
361
                                                        6: DIMM BOARD (TYPE 3)
 
362
                                                        7: N/A
 
363
                                                        8: Unknown
 
364
                                                */
 
365
                                                //media_buffer[7] = 0;
 
366
                                                break;
 
367
                                        // Media board serial
 
368
                                        case 0x103:
 
369
                                                memcpy(media_buffer + 4, "A89E27A50364511", 15);
 
370
                                                break;
 
371
                                        case 0x104:
 
372
                                                media_buffer[4] = 1;
 
373
                                                break;
 
374
                                        // Hardware test
 
375
                                        case 0x301:
 
376
                                                // Test type
 
377
                                                /*
 
378
                                                        0x01: Media board
 
379
                                                        0x04: Network
 
380
                                                */
 
381
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x301: (%08X)", *(u32*)(media_buffer+0x24) );
 
382
 
 
383
                                                //Pointer to a memory address that is directly displayed on screen as a string
 
384
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
385
 
 
386
                                                // On real system it shows the status about the DIMM/GD-ROM here
 
387
                                                // We just show "TEST OK"
 
388
                                                Memory::Write_U32( 0x54534554, *(u32*)(media_buffer+0x28) );
 
389
                                                Memory::Write_U32( 0x004B4F20, *(u32*)(media_buffer+0x28)+4 );
 
390
 
 
391
                                                *(u32*)(media_buffer+0x04) = *(u32*)(media_buffer+0x24);
 
392
                                                break;
 
393
                                        case 0x401:
 
394
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x401: (%08X)", *(u32*)(media_buffer+0x24) );
 
395
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
396
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x2C) );
 
397
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x30) );
 
398
                                                break;
 
399
                                        case 0x403:
 
400
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x403: (%08X)", *(u32*)(media_buffer+0x24) );
 
401
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
402
                                                media_buffer[4] = 1;
 
403
                                                break;
 
404
                                        case 0x404:
 
405
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x404: (%08X)", *(u32*)(media_buffer+0x2C) );
 
406
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x30) );
 
407
                                                break;
 
408
                                        case 0x408:
 
409
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x408: (%08X)", *(u32*)(media_buffer+0x24) );
 
410
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
411
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x2C) );
 
412
                                                break;
 
413
                                        case 0x40B:
 
414
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x40B: (%08X)", *(u32*)(media_buffer+0x24) );
 
415
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
416
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x2C) );
 
417
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x30) );
 
418
                                                break;
 
419
                                        case 0x40C:
 
420
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x40C: (%08X)", *(u32*)(media_buffer+0x24) );
 
421
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
422
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x2C) );
 
423
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x30) );
 
424
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x34) );
 
425
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x38) );
 
426
                                                break;
 
427
                                        case 0x40E:
 
428
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x40E: (%08X)", *(u32*)(media_buffer+0x28) );
 
429
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x2C) );
 
430
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x30) );
 
431
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x34) );
 
432
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x38) );
 
433
                                                break;
 
434
                                        case 0x410:
 
435
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x410: (%08X)", *(u32*)(media_buffer+0x28) );
 
436
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x2C) );
 
437
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x30) );
 
438
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x34) );
 
439
                                                break;
 
440
                                        case 0x411:
 
441
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x411: (%08X)", *(u32*)(media_buffer+0x24) );
 
442
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
443
 
 
444
                                                *(u32*)(media_buffer+4) = 0x46;
 
445
                                                break;
 
446
                                        // Set IP
 
447
                                        case 0x415:
 
448
                                        {
 
449
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x415: (%08X)", *(u32*)(media_buffer+0x24) );
 
450
                                                // Address of string
 
451
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
452
                                                // Length of string
 
453
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x2C) );
 
454
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x30) );
 
455
 
 
456
                                                u32 offset = *(u32*)(media_buffer+0x28) - 0x1F800200;                                           
 
457
                                                NOTICE_LOG(DVDINTERFACE, "GC-AM: Set IP:%s", (char*)(network_command_buffer+offset) );
 
458
                                                break;
 
459
                                        }
 
460
                                        case 0x601:
 
461
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x601");
 
462
                                                break;
 
463
                                        case 0x606:
 
464
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x606: (%04X)", *(u16*)(media_buffer+0x24) );
 
465
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%04X)", *(u16*)(media_buffer+0x26) );
 
466
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%02X)", *( u8*)(media_buffer+0x28) );
 
467
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%02X)", *( u8*)(media_buffer+0x29) );
 
468
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%04X)", *(u16*)(media_buffer+0x2A) );
 
469
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x2C) );
 
470
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x30) );
 
471
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x34) );
 
472
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x38) );
 
473
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x3C) );
 
474
                                                break;
 
475
                                        case 0x607:
 
476
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x607: (%04X)", *(u16*)(media_buffer+0x24) );
 
477
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%04X)", *(u16*)(media_buffer+0x26) );
 
478
                                                ERROR_LOG(DVDINTERFACE, "GC-AM:        (%08X)", *(u32*)(media_buffer+0x28) );
 
479
                                                break;
 
480
                                        case 0x614:
 
481
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: 0x601");
 
482
                                                break;
 
483
                                        default:
 
484
                                                ERROR_LOG(DVDINTERFACE, "GC-AM: execute buffer UNKNOWN:%03X", *(u16*)(media_buffer+0x22) );
 
485
                                                break;
 
486
                                        }
 
487
 
 
488
                                memset( media_buffer + 0x20, 0, 0x20 );
 
489
                                return 0x66556677;
 
490
                        }
 
491
 
 
492
                        PanicAlertT("Unhandled Media Board Execute");
 
493
                        break;
 
494
        }
 
495
 
 
496
        return 0;
 
497
}
 
498
u32 GetControllerType( void )
 
499
{
 
500
        return m_controllertype;
 
501
}
 
502
void Shutdown( void )
 
503
{
 
504
        m_netcfg->Close();
 
505
        m_netctrl->Close();
 
506
        m_dimm->Close();
 
507
}
 
508
 
 
509
}