notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
clean windows line endings in libpcsxcore/plugins.c
[pcsx_rearmed.git] / libpcsxcore / plugins.c
CommitLineData
fb4bd474 1/***************************************************************************
2 * Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program; if not, write to the *
16 * Free Software Foundation, Inc., *
17 * 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA. *
18 ***************************************************************************/
19
20/*
21* Plugin library callback/access functions.
22*/
23
24#include "plugins.h"
25#include "cdriso.h"
26
27static char IsoFile[MAXPATHLEN] = "";
28static s64 cdOpenCaseTime = 0;
29
30GPUupdateLace GPU_updateLace;
31GPUinit GPU_init;
32GPUshutdown GPU_shutdown;
33GPUconfigure GPU_configure;
34GPUtest GPU_test;
35GPUabout GPU_about;
36GPUopen GPU_open;
37GPUclose GPU_close;
38GPUreadStatus GPU_readStatus;
39GPUreadData GPU_readData;
40GPUreadDataMem GPU_readDataMem;
41GPUwriteStatus GPU_writeStatus;
42GPUwriteData GPU_writeData;
43GPUwriteDataMem GPU_writeDataMem;
44GPUdmaChain GPU_dmaChain;
45GPUkeypressed GPU_keypressed;
46GPUdisplayText GPU_displayText;
47GPUmakeSnapshot GPU_makeSnapshot;
48GPUfreeze GPU_freeze;
49GPUgetScreenPic GPU_getScreenPic;
50GPUshowScreenPic GPU_showScreenPic;
51GPUclearDynarec GPU_clearDynarec;
52GPUvBlank GPU_vBlank;
53
54CDRinit CDR_init;
55CDRshutdown CDR_shutdown;
56CDRopen CDR_open;
57CDRclose CDR_close;
58CDRtest CDR_test;
59CDRgetTN CDR_getTN;
60CDRgetTD CDR_getTD;
61CDRreadTrack CDR_readTrack;
62CDRgetBuffer CDR_getBuffer;
63CDRplay CDR_play;
64CDRstop CDR_stop;
65CDRgetStatus CDR_getStatus;
66CDRgetDriveLetter CDR_getDriveLetter;
67CDRgetBufferSub CDR_getBufferSub;
68CDRconfigure CDR_configure;
69CDRabout CDR_about;
70CDRsetfilename CDR_setfilename;
71CDRreadCDDA CDR_readCDDA;
72CDRgetTE CDR_getTE;
73
74SPUconfigure SPU_configure;
75SPUabout SPU_about;
76SPUinit SPU_init;
77SPUshutdown SPU_shutdown;
78SPUtest SPU_test;
79SPUopen SPU_open;
80SPUclose SPU_close;
81SPUplaySample SPU_playSample;
82SPUwriteRegister SPU_writeRegister;
83SPUreadRegister SPU_readRegister;
84SPUwriteDMA SPU_writeDMA;
85SPUreadDMA SPU_readDMA;
86SPUwriteDMAMem SPU_writeDMAMem;
87SPUreadDMAMem SPU_readDMAMem;
88SPUplayADPCMchannel SPU_playADPCMchannel;
89SPUfreeze SPU_freeze;
90SPUregisterCallback SPU_registerCallback;
91SPUregisterScheduleCb SPU_registerScheduleCb;
92SPUasync SPU_async;
93SPUplayCDDAchannel SPU_playCDDAchannel;
94
95PADconfigure PAD1_configure;
96PADabout PAD1_about;
97PADinit PAD1_init;
98PADshutdown PAD1_shutdown;
99PADtest PAD1_test;
100PADopen PAD1_open;
101PADclose PAD1_close;
102PADquery PAD1_query;
103PADreadPort1 PAD1_readPort1;
104PADkeypressed PAD1_keypressed;
105PADstartPoll PAD1_startPoll;
106PADpoll PAD1_poll;
107PADsetSensitive PAD1_setSensitive;
108
109PADconfigure PAD2_configure;
110PADabout PAD2_about;
111PADinit PAD2_init;
112PADshutdown PAD2_shutdown;
113PADtest PAD2_test;
114PADopen PAD2_open;
115PADclose PAD2_close;
116PADquery PAD2_query;
117PADreadPort2 PAD2_readPort2;
118PADkeypressed PAD2_keypressed;
119PADstartPoll PAD2_startPoll;
120PADpoll PAD2_poll;
121PADsetSensitive PAD2_setSensitive;
122
123NETinit NET_init;
124NETshutdown NET_shutdown;
125NETopen NET_open;
126NETclose NET_close;
127NETtest NET_test;
128NETconfigure NET_configure;
129NETabout NET_about;
130NETpause NET_pause;
131NETresume NET_resume;
132NETqueryPlayer NET_queryPlayer;
133NETsendData NET_sendData;
134NETrecvData NET_recvData;
135NETsendPadData NET_sendPadData;
136NETrecvPadData NET_recvPadData;
137NETsetInfo NET_setInfo;
138NETkeypressed NET_keypressed;
139
140#ifdef ENABLE_SIO1API
141
142SIO1init SIO1_init;
143SIO1shutdown SIO1_shutdown;
144SIO1open SIO1_open;
145SIO1close SIO1_close;
146SIO1test SIO1_test;
147SIO1configure SIO1_configure;
148SIO1about SIO1_about;
149SIO1pause SIO1_pause;
150SIO1resume SIO1_resume;
151SIO1keypressed SIO1_keypressed;
152SIO1writeData8 SIO1_writeData8;
153SIO1writeData16 SIO1_writeData16;
154SIO1writeData32 SIO1_writeData32;
155SIO1writeStat16 SIO1_writeStat16;
156SIO1writeStat32 SIO1_writeStat32;
157SIO1writeMode16 SIO1_writeMode16;
158SIO1writeMode32 SIO1_writeMode32;
159SIO1writeCtrl16 SIO1_writeCtrl16;
160SIO1writeCtrl32 SIO1_writeCtrl32;
161SIO1writeBaud16 SIO1_writeBaud16;
162SIO1writeBaud32 SIO1_writeBaud32;
163SIO1readData8 SIO1_readData8;
164SIO1readData16 SIO1_readData16;
165SIO1readData32 SIO1_readData32;
166SIO1readStat16 SIO1_readStat16;
167SIO1readStat32 SIO1_readStat32;
168SIO1readMode16 SIO1_readMode16;
169SIO1readMode32 SIO1_readMode32;
170SIO1readCtrl16 SIO1_readCtrl16;
171SIO1readCtrl32 SIO1_readCtrl32;
172SIO1readBaud16 SIO1_readBaud16;
173SIO1readBaud32 SIO1_readBaud32;
174SIO1registerCallback SIO1_registerCallback;
175
176#endif
177
178static const char *err;
179
180#define CheckErr(func) { \
181 err = SysLibError(); \
182 if (err != NULL) { SysMessage(_("Error loading %s: %s"), func, err); return -1; } \
183}
184
185#define LoadSym(dest, src, name, checkerr) { \
186 dest = (src)SysLoadSym(drv, name); \
187 if (checkerr) { CheckErr(name); } else SysLibError(); \
188}
189
190void *hGPUDriver = NULL;
191
192void CALLBACK GPU__displayText(char *pText) {
193 SysPrintf("%s\n", pText);
194}
195
196long CALLBACK GPU__configure(void) { return 0; }
197long CALLBACK GPU__test(void) { return 0; }
198void CALLBACK GPU__about(void) {}
199void CALLBACK GPU__makeSnapshot(void) {}
200void CALLBACK GPU__keypressed(int key) {}
201long CALLBACK GPU__getScreenPic(unsigned char *pMem) { return -1; }
202long CALLBACK GPU__showScreenPic(unsigned char *pMem) { return -1; }
203void CALLBACK GPU__clearDynarec(void (CALLBACK *callback)(void)) {}
204void CALLBACK GPU__vBlank(int val) {}
205
206#define LoadGpuSym1(dest, name) \
207 LoadSym(GPU_##dest, GPU##dest, name, TRUE);
208
209#define LoadGpuSym0(dest, name) \
210 LoadSym(GPU_##dest, GPU##dest, name, FALSE); \
211 if (GPU_##dest == NULL) GPU_##dest = (GPU##dest) GPU__##dest;
212
213#define LoadGpuSymN(dest, name) \
214 LoadSym(GPU_##dest, GPU##dest, name, FALSE);
215
216static int LoadGPUplugin(const char *GPUdll) {
217 void *drv;
218
219 hGPUDriver = SysLoadLibrary(GPUdll);
220 if (hGPUDriver == NULL) {
221 GPU_configure = NULL;
222 SysMessage (_("Could not load GPU plugin %s!"), GPUdll); return -1;
223 }
224 drv = hGPUDriver;
225 LoadGpuSym1(init, "GPUinit");
226 LoadGpuSym1(shutdown, "GPUshutdown");
227 LoadGpuSym1(open, "GPUopen");
228 LoadGpuSym1(close, "GPUclose");
229 LoadGpuSym1(readData, "GPUreadData");
230 LoadGpuSym1(readDataMem, "GPUreadDataMem");
231 LoadGpuSym1(readStatus, "GPUreadStatus");
232 LoadGpuSym1(writeData, "GPUwriteData");
233 LoadGpuSym1(writeDataMem, "GPUwriteDataMem");
234 LoadGpuSym1(writeStatus, "GPUwriteStatus");
235 LoadGpuSym1(dmaChain, "GPUdmaChain");
236 LoadGpuSym1(updateLace, "GPUupdateLace");
237 LoadGpuSym0(keypressed, "GPUkeypressed");
238 LoadGpuSym0(displayText, "GPUdisplayText");
239 LoadGpuSym0(makeSnapshot, "GPUmakeSnapshot");
240 LoadGpuSym1(freeze, "GPUfreeze");
241 LoadGpuSym0(getScreenPic, "GPUgetScreenPic");
242 LoadGpuSym0(showScreenPic, "GPUshowScreenPic");
243 LoadGpuSym0(clearDynarec, "GPUclearDynarec");
244 LoadGpuSym0(vBlank, "GPUvBlank");
245 LoadGpuSym0(configure, "GPUconfigure");
246 LoadGpuSym0(test, "GPUtest");
247 LoadGpuSym0(about, "GPUabout");
248
249 return 0;
250}
251
252void *hCDRDriver = NULL;
253
254long CALLBACK CDR__play(unsigned char *sector) { return 0; }
255long CALLBACK CDR__stop(void) { return 0; }
256
257long CALLBACK CDR__getStatus(struct CdrStat *stat) {
258 if (cdOpenCaseTime < 0 || cdOpenCaseTime > (s64)time(NULL))
259 stat->Status = 0x10;
260 else
261 stat->Status = 0;
262
263 return 0;
264}
265
266char* CALLBACK CDR__getDriveLetter(void) { return NULL; }
267long CALLBACK CDR__configure(void) { return 0; }
268long CALLBACK CDR__test(void) { return 0; }
269void CALLBACK CDR__about(void) {}
270long CALLBACK CDR__setfilename(char*filename) { return 0; }
271
272#define LoadCdrSym1(dest, name) \
273 LoadSym(CDR_##dest, CDR##dest, name, TRUE);
274
275#define LoadCdrSym0(dest, name) \
276 LoadSym(CDR_##dest, CDR##dest, name, FALSE); \
277 if (CDR_##dest == NULL) CDR_##dest = (CDR##dest) CDR__##dest;
278
279#define LoadCdrSymN(dest, name) \
280 LoadSym(CDR_##dest, CDR##dest, name, FALSE);
281
282static int LoadCDRplugin(const char *CDRdll) {
283 void *drv;
284
285 if (CDRdll == NULL) {
286 cdrIsoInit();
287 return 0;
288 }
289
290 hCDRDriver = SysLoadLibrary(CDRdll);
291 if (hCDRDriver == NULL) {
292 CDR_configure = NULL;
293 SysMessage (_("Could not load CD-ROM plugin %s!"), CDRdll); return -1;
294 }
295 drv = hCDRDriver;
296 LoadCdrSym1(init, "CDRinit");
297 LoadCdrSym1(shutdown, "CDRshutdown");
298 LoadCdrSym1(open, "CDRopen");
299 LoadCdrSym1(close, "CDRclose");
300 LoadCdrSym1(getTN, "CDRgetTN");
301 LoadCdrSym1(getTD, "CDRgetTD");
302 LoadCdrSym1(readTrack, "CDRreadTrack");
303 LoadCdrSym1(getBuffer, "CDRgetBuffer");
304 LoadCdrSym1(getBufferSub, "CDRgetBufferSub");
305 LoadCdrSym0(play, "CDRplay");
306 LoadCdrSym0(stop, "CDRstop");
307 LoadCdrSym0(getStatus, "CDRgetStatus");
308 LoadCdrSym0(getDriveLetter, "CDRgetDriveLetter");
309 LoadCdrSym0(configure, "CDRconfigure");
310 LoadCdrSym0(test, "CDRtest");
311 LoadCdrSym0(about, "CDRabout");
312 LoadCdrSym0(setfilename, "CDRsetfilename");
313 LoadCdrSymN(readCDDA, "CDRreadCDDA");
314 LoadCdrSymN(getTE, "CDRgetTE");
315
316 return 0;
317}
318
319void *hSPUDriver = NULL;
320
321long CALLBACK SPU__configure(void) { return 0; }
322void CALLBACK SPU__about(void) {}
323long CALLBACK SPU__test(void) { return 0; }
324void CALLBACK SPU__registerScheduleCb(void (CALLBACK *cb)(unsigned int)) {}
325
326#define LoadSpuSym1(dest, name) \
327 LoadSym(SPU_##dest, SPU##dest, name, TRUE);
328
329#define LoadSpuSym0(dest, name) \
330 LoadSym(SPU_##dest, SPU##dest, name, FALSE); \
331 if (SPU_##dest == NULL) SPU_##dest = (SPU##dest) SPU__##dest;
332
333#define LoadSpuSymN(dest, name) \
334 LoadSym(SPU_##dest, SPU##dest, name, FALSE);
335
336static int LoadSPUplugin(const char *SPUdll) {
337 void *drv;
338
339 hSPUDriver = SysLoadLibrary(SPUdll);
340 if (hSPUDriver == NULL) {
341 SPU_configure = NULL;
342 SysMessage (_("Could not load SPU plugin %s!"), SPUdll); return -1;
343 }
344 drv = hSPUDriver;
345 LoadSpuSym1(init, "SPUinit");
346 LoadSpuSym1(shutdown, "SPUshutdown");
347 LoadSpuSym1(open, "SPUopen");
348 LoadSpuSym1(close, "SPUclose");
349 LoadSpuSym0(configure, "SPUconfigure");
350 LoadSpuSym0(about, "SPUabout");
351 LoadSpuSym0(test, "SPUtest");
352 LoadSpuSym1(writeRegister, "SPUwriteRegister");
353 LoadSpuSym1(readRegister, "SPUreadRegister");
354 LoadSpuSym1(writeDMA, "SPUwriteDMA");
355 LoadSpuSym1(readDMA, "SPUreadDMA");
356 LoadSpuSym1(writeDMAMem, "SPUwriteDMAMem");
357 LoadSpuSym1(readDMAMem, "SPUreadDMAMem");
358 LoadSpuSym1(playADPCMchannel, "SPUplayADPCMchannel");
359 LoadSpuSym1(freeze, "SPUfreeze");
360 LoadSpuSym1(registerCallback, "SPUregisterCallback");
361 LoadSpuSym0(registerScheduleCb, "SPUregisterScheduleCb");
362 LoadSpuSymN(async, "SPUasync");
363 LoadSpuSymN(playCDDAchannel, "SPUplayCDDAchannel");
364
365 return 0;
366}
367
368void *hPAD1Driver = NULL;
369void *hPAD2Driver = NULL;
370
371static int multitap1 = -1;
372static int multitap2 = -1;
373//Pad information, keystate, mode, config mode, vibration
52c9fcc8 374static PadDataS pad[8];
375
ef296715 376static int reqPos, respSize, req;
0b4dc26d 377static int ledStateReq44[8];
fb4bd474 378
0b4dc26d 379static unsigned char buf[256];
380static unsigned char bufMulti[34] = { 0x80, 0x5a,
fb4bd474 381 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
382 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
383 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
0b4dc26d 384 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
fb4bd474 385
386unsigned char stdpar[8] = { 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
52c9fcc8 387unsigned char multitappar[34] = { 0x80, 0x5a,
fb4bd474 388 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
389 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
390 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
391 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
392
393//response for request 44, 45, 46, 47, 4C, 4D
394static unsigned char resp45[8] = {0xF3, 0x5A, 0x01, 0x02, 0x00, 0x02, 0x01, 0x00};
395static unsigned char resp46_00[8] = {0xF3, 0x5A, 0x00, 0x00, 0x01, 0x02, 0x00, 0x0A};
396static unsigned char resp46_01[8] = {0xF3, 0x5A, 0x00, 0x00, 0x01, 0x01, 0x01, 0x14};
397static unsigned char resp47[8] = {0xF3, 0x5A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00};
398static unsigned char resp4C_00[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00};
399static unsigned char resp4C_01[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00};
400static unsigned char resp4D[8] = {0xF3, 0x5A, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF};
52c9fcc8 401
402//fixed reponse of request number 41, 48, 49, 4A, 4B, 4E, 4F
403static unsigned char resp40[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
0b4dc26d 404static unsigned char resp41[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
fb4bd474 405static unsigned char resp43[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
52c9fcc8 406static unsigned char resp44[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
407static unsigned char resp49[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
408static unsigned char resp4A[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
409static unsigned char resp4B[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
410static unsigned char resp4E[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
411static unsigned char resp4F[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
412
413// Resquest of psx core
414enum {
415 // REQUEST
416 // first call of this request for the pad, the pad is configured as an digital pad.
417 // 0x0X, 0x42, 0x0Y, 0xZZ, 0xAA, 0x00, 0x00, 0x00, 0x00
418 // X pad number (used for the multitap, first request response 0x00, 0x80, 0x5A, (8 bytes pad A), (8 bytes pad B), (8 bytes pad C), (8 bytes pad D)
419 // Y if 1 : psx request the full length response for the multitap, 3 bytes header and 4 block of 8 bytes per pad
420 // Y if 0 : psx request a pad key state
421 // ZZ rumble small motor 00-> OFF, 01 -> ON
422 // AA rumble large motor speed 0x00 -> 0xFF
423 // RESPONSE
424 // header 3 Bytes
425 // 0x00
426 // PadId -> 0x41 for digital pas, 0x73 for analog pad
427 // 0x5A mode has not change (no press on analog button on the center of pad), 0x00 the analog button have been pressed and the mode switch
428 // 6 Bytes for keystates
429 CMD_READ_DATA_AND_VIBRATE = 0x42,
430
431 // REQUEST
432 // Header
433 // 0x0N, 0x43, 0x00, XX, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
434 // XX = 00 -> Normal mode : Seconde bytes of response = padId
435 // XX = 01 -> Configuration mode : Seconde bytes of response = 0xF3
436 // RESPONSE
437 // enter in config mode example :
438 // req : 01 43 00 01 00 00 00 00 00 00
439 // res : 00 41 5A buttons state, analog states
440 // exit config mode :
441 // req : 01 43 00 00 00 00 00 00 00 00
442 // res : 00 F3 5A buttons state, analog states
443 CMD_CONFIG_MODE = 0x43,
444
445 // Set led State
446 // REQUEST
447 // 0x0N, 0x44, 0x00, VAL, SEL, 0x00, 0x00, 0x00, 0x00
448 // If sel = 2 then
449 // VAL = 00 -> OFF
450 // VAL = 01 -> ON
451 // RESPONSE
452 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
453 CMD_SET_MODE_AND_LOCK = 0x44,
454
455 // Get Analog Led state
456 // REQUEST
457 // 0x0N, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
458 // RESPONSE
459 // 0x00, 0xF3, 0x5A, 0x01, 0x02, VAL, 0x02, 0x01, 0x00
460 // VAL = 00 Led OFF
461 // VAL = 01 Led ON
462 CMD_QUERY_MODEL_AND_MODE = 0x45,
463
464 //Get Variable A
465 // REQUEST
466 // 0x0N, 0x46, 0x00, 0xXX, 0x00, 0x00, 0x00, 0x00, 0x00
467 // RESPONSE
468 // XX=00
469 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x01, 0x02, 0x00, 0x0A
470 // XX=01
471 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x01, 0x01, 0x01, 0x14
472 CMD_QUERY_ACT = 0x46,
473
474 // REQUEST
475 // 0x0N, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
476 // RESPONSE
477 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00
478 CMD_QUERY_COMB = 0x47,
479
480 // REQUEST
481 // 0x0N, 0x4C, 0x00, 0xXX, 0x00, 0x00, 0x00, 0x00, 0x00
482 // RESPONSE
483 // XX = 0
484 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00
485 // XX = 1
486 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00
487 CMD_QUERY_MODE = 0x4C,
488
489 // REQUEST
490 // 0x0N, 0x4D, 0x00, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
491 // RESPONSE
492 // 0x00, 0xF3, 0x5A, old value or
493 // AA = 01 unlock large motor (and swap VAL1 and VAL2)
494 // BB = 01 unlock large motor (default)
495 // CC, DD, EE, FF = all FF -> unlock small motor
496 //
497 // default repsonse for analog pad with 2 motor : 0x00 0xF3 0x5A 0x00 0x01 0xFF 0xFF 0xFF 0xFF
498 //
499 CMD_VIBRATION_TOGGLE = 0x4D,
500 REQ40 = 0x40,
501 REQ41 = 0x41,
502 REQ49 = 0x49,
503 REQ4A = 0x4A,
504 REQ4B = 0x4B,
505 REQ4E = 0x4E,
506 REQ4F = 0x4F
507};
508
0b4dc26d 509
510
511
512//NO MULTITAP
513
52c9fcc8 514void initBufForRequest(int padIndex, char value){
fb4bd474 515 switch (value){
516 //Pad keystate already in buffer
517 //case CMD_READ_DATA_AND_VIBRATE :
518 // break;
519 case CMD_CONFIG_MODE :
520 if (pad[padIndex].configMode == 1) {
521 memcpy(buf, resp43, 8);
522 break;
523 }
524 //else, not in config mode, pad keystate return (already in the buffer)
525 break;
526 case CMD_SET_MODE_AND_LOCK :
527 memcpy(buf, resp44, 8);
528 break;
529 case CMD_QUERY_MODEL_AND_MODE :
530 memcpy(buf, resp45, 8);
531 break;
532 case CMD_QUERY_ACT :
533 memcpy(buf, resp46_00, 8);
534 break;
535 case CMD_QUERY_COMB :
536 memcpy(buf, resp47, 8);
537 break;
538 case CMD_QUERY_MODE :
539 memcpy(buf, resp4C_00, 8);
540 break;
541 case CMD_VIBRATION_TOGGLE :
542 memcpy(buf, resp4D, 8);
543 break;
544 case REQ40 :
545 memcpy(buf, resp40, 8);
546 break;
547 case REQ41 :
548 memcpy(buf, resp41, 8);
549 break;
550 case REQ49 :
551 memcpy(buf, resp49, 8);
552 break;
553 case REQ4A :
554 memcpy(buf, resp4A, 8);
555 break;
556 case REQ4B :
557 memcpy(buf, resp4B, 8);
558 break;
559 case REQ4E :
560 memcpy(buf, resp4E, 8);
561 break;
562 case REQ4F :
563 memcpy(buf, resp4F, 8);
564 break;
52c9fcc8 565 }
0b4dc26d 566}
567
568
fb4bd474 569
570
571void reqIndex2Treatment(int padIndex, char value){
572 switch (req){
573 case CMD_CONFIG_MODE :
574 //0x43
575 if (value == 0) {
576 pad[padIndex].configMode = 0;
577 } else {
578 pad[padIndex].configMode = 1;
579 }
580 break;
581 case CMD_SET_MODE_AND_LOCK :
582 //0x44 store the led state for change mode if the next value = 0x02
583 //0x01 analog ON
584 //0x00 analog OFF
585 ledStateReq44[padIndex] = value;
586 break;
587 case CMD_QUERY_ACT :
588 //0x46
589 if (value == 1) {
590 memcpy(buf, resp46_01, 8);
591 }
592 break;
593 case CMD_QUERY_MODE :
594 if (value == 1) {
595 memcpy(buf, resp4C_01, 8);
596 }
597 break;
598 case CMD_VIBRATION_TOGGLE :
599 //0x4D
600 memcpy(buf, resp4D, 8);
601 break;
602 case CMD_READ_DATA_AND_VIBRATE:
603 //mem the vibration value for small motor;
52c9fcc8 604 pad[padIndex].Vib[0] = value;
f40e9993 605 break;
fb4bd474 606 }
607}
52c9fcc8 608
609void vibrate(int padIndex){
f40e9993 610 if (pad[padIndex].Vib[0] != pad[padIndex].VibF[0] || pad[padIndex].Vib[1] != pad[padIndex].VibF[1]) {
52c9fcc8 611 //value is different update Value and call libretro for vibration
612 pad[padIndex].VibF[0] = pad[padIndex].Vib[0];
613 pad[padIndex].VibF[1] = pad[padIndex].Vib[1];
614 plat_trigger_vibrate(padIndex, pad[padIndex].VibF[0], pad[padIndex].VibF[1]);
2ca181a9 615 //printf("vibration pad %i", padIndex);
52c9fcc8 616 }
ef296715 617}
618
ef296715 619
620
52c9fcc8 621
fb4bd474 622//Build response for 0x42 request Pad in port
623void _PADstartPoll(PadDataS *pad) {
624 switch (pad->controllerType) {
625 case PSE_PAD_TYPE_MOUSE:
626 stdpar[0] = 0x12;
627 stdpar[2] = pad->buttonStatus & 0xff;
628 stdpar[3] = pad->buttonStatus >> 8;
629 stdpar[4] = pad->moveX;
630 stdpar[5] = pad->moveY;
631 memcpy(buf, stdpar, 6);
632 respSize = 6;
633 break;
634 case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)
635 stdpar[0] = 0x23;
636 stdpar[2] = pad->buttonStatus & 0xff;
637 stdpar[3] = pad->buttonStatus >> 8;
638 stdpar[4] = pad->rightJoyX;
639 stdpar[5] = pad->rightJoyY;
640 stdpar[6] = pad->leftJoyX;
641 stdpar[7] = pad->leftJoyY;
642 memcpy(buf, stdpar, 8);
643 respSize = 8;
644 break;
645 case PSE_PAD_TYPE_ANALOGPAD: // scph1150
646 stdpar[0] = 0x73;
647 stdpar[2] = pad->buttonStatus & 0xff;
648 stdpar[3] = pad->buttonStatus >> 8;
649 stdpar[4] = pad->rightJoyX;
650 stdpar[5] = pad->rightJoyY;
651 stdpar[6] = pad->leftJoyX;
652 stdpar[7] = pad->leftJoyY;
653 memcpy(buf, stdpar, 8);
654 respSize = 8;
655 break;
656 case PSE_PAD_TYPE_ANALOGJOY: // scph1110
657 stdpar[0] = 0x53;
658 stdpar[2] = pad->buttonStatus & 0xff;
659 stdpar[3] = pad->buttonStatus >> 8;
660 stdpar[4] = pad->rightJoyX;
661 stdpar[5] = pad->rightJoyY;
662 stdpar[6] = pad->leftJoyX;
663 stdpar[7] = pad->leftJoyY;
664 memcpy(buf, stdpar, 8);
665 respSize = 8;
666 break;
667 case PSE_PAD_TYPE_STANDARD:
ef296715 668 default:
fb4bd474 669 stdpar[0] = 0x41;
670 stdpar[2] = pad->buttonStatus & 0xff;
ef296715 671 stdpar[3] = pad->buttonStatus >> 8;
672 //avoid analog value in multitap mode if change pad type in game.
673 stdpar[4] = 0xff;
674 stdpar[5] = 0xff;
675 stdpar[6] = 0xff;
fb4bd474 676 stdpar[7] = 0xff;
677 memcpy(buf, stdpar, 8);
678 respSize = 8;
679 }
680}
681
ef296715 682
683//Build response for 0x42 request Multitap in port
fb4bd474 684//Response header for multitap : 0x80, 0x5A, (Pad information port 1-2A), (Pad information port 1-2B), (Pad information port 1-2C), (Pad information port 1-2D)
685void _PADstartPollMultitap(PadDataS* padd) {
686 int i, offset;
687 for(i = 0; i < 4; i++) {
688 offset = 2 + (i * 8);
f40e9993 689 _PADstartPoll(&padd[i]);
fb4bd474 690 memcpy(multitappar+offset, stdpar, 8);
691 }
692 memcpy(bufMulti, multitappar, 34);
693 respSize = 34;
0b4dc26d 694}
fb4bd474 695
696
0b4dc26d 697unsigned char _PADpoll(int port, unsigned char value) {
f40e9993 698 if (reqPos == 0) {
0b4dc26d 699 //mem the request number
fb4bd474 700 req = value;
701 //copy the default value of request response in buffer instead of the keystate
f40e9993 702 initBufForRequest(port, value);
fb4bd474 703 }
704
705 //if no new request the pad return 0xff, for signaling connected
706 if (reqPos >= respSize) return 0xff;
707
708 switch(reqPos){
709 case 2:
710 reqIndex2Treatment(port, value);
711 break;
712 case 3:
713 switch(req) {
714 case CMD_SET_MODE_AND_LOCK :
715 //change mode on pad
716 break;
717 case CMD_READ_DATA_AND_VIBRATE:
718 //mem the vibration value for Large motor;
719 pad[port].Vib[1] = value;
0b4dc26d 720 //vibration
fb4bd474 721 vibrate(port);
722 break;
723 }
724 break;
725 }
726 return buf[reqPos++];
0b4dc26d 727}
728
729
730unsigned char _PADpollMultitap(int port, unsigned char value) {
fb4bd474 731 if (reqPos >= respSize) return 0xff;
732 return bufMulti[reqPos++];
0b4dc26d 733}
fb4bd474 734
735
736// refresh the button state on port 1.
737// int pad is not needed.
52c9fcc8 738unsigned char CALLBACK PAD1__startPoll(int pad) {
fb4bd474 739 reqPos = 0;
740 // first call the pad provide if a multitap is connected between the psx and himself
741 if (multitap1 == -1) {
e288923d 742 PadDataS padd;
fb4bd474 743 padd.requestPadIndex = 0;
744 PAD1_readPort1(&padd);
745 multitap1 = padd.portMultitap;
746 }
747 // just one pad is on port 1 : NO MULTITAP
748 if (multitap1 == 0) {
e288923d 749 PadDataS padd;
fb4bd474 750 padd.requestPadIndex = 0;
751 PAD1_readPort1(&padd);
752 _PADstartPoll(&padd);
753 } else {
754 // a multitap is plugged : refresh all pad.
755 int i;
756 PadDataS padd[4];
e288923d 757 for(i = 0; i < 4; i++) {
fb4bd474 758 padd[i].requestPadIndex = i;
759 PAD1_readPort1(&padd[i]);
52c9fcc8 760 }
fb4bd474 761 _PADstartPollMultitap(padd);
52c9fcc8 762 }
2ca181a9 763 //printf("\npad 1 : ");
fb4bd474 764 return 0x00;
765}
766
52c9fcc8 767unsigned char CALLBACK PAD1__poll(unsigned char value) {
0b4dc26d 768 char tmp;
f40e9993 769 if (multitap1 == 1) {
0b4dc26d 770 tmp = _PADpollMultitap(0, value);
f40e9993 771 } else {
0b4dc26d 772 tmp = _PADpoll(0, value);
773 }
fb4bd474 774 //printf("%2x:%2x, ",value,tmp);
775 return tmp;
776
777}
778
779
780long CALLBACK PAD1__configure(void) { return 0; }
781void CALLBACK PAD1__about(void) {}
782long CALLBACK PAD1__test(void) { return 0; }
783long CALLBACK PAD1__query(void) { return 3; }
784long CALLBACK PAD1__keypressed() { return 0; }
785
786#define LoadPad1Sym1(dest, name) \
787 LoadSym(PAD1_##dest, PAD##dest, name, TRUE);
788
789#define LoadPad1SymN(dest, name) \
790 LoadSym(PAD1_##dest, PAD##dest, name, FALSE);
791
792#define LoadPad1Sym0(dest, name) \
793 LoadSym(PAD1_##dest, PAD##dest, name, FALSE); \
794 if (PAD1_##dest == NULL) PAD1_##dest = (PAD##dest) PAD1__##dest;
795
796static int LoadPAD1plugin(const char *PAD1dll) {
797 void *drv;
798
799 hPAD1Driver = SysLoadLibrary(PAD1dll);
800 if (hPAD1Driver == NULL) {
801 PAD1_configure = NULL;
802 SysMessage (_("Could not load Controller 1 plugin %s!"), PAD1dll); return -1;
803 }
804 drv = hPAD1Driver;
805 LoadPad1Sym1(init, "PADinit");
806 LoadPad1Sym1(shutdown, "PADshutdown");
807 LoadPad1Sym1(open, "PADopen");
808 LoadPad1Sym1(close, "PADclose");
809 LoadPad1Sym0(query, "PADquery");
810 LoadPad1Sym1(readPort1, "PADreadPort1");
811 LoadPad1Sym0(configure, "PADconfigure");
812 LoadPad1Sym0(test, "PADtest");
813 LoadPad1Sym0(about, "PADabout");
814 LoadPad1Sym0(keypressed, "PADkeypressed");
815 LoadPad1Sym0(startPoll, "PADstartPoll");
816 LoadPad1Sym0(poll, "PADpoll");
817 LoadPad1SymN(setSensitive, "PADsetSensitive");
818
819 return 0;
820}
821
52c9fcc8 822unsigned char CALLBACK PAD2__startPoll(int pad) {
f40e9993
A		 823 int pad_index;
824
fb4bd474 825 reqPos = 0;
f40e9993
A		 826 if (multitap1 == 0 && (multitap2 == 0 || multitap2 == 2)) {
827 pad_index = 1;
828 } else if(multitap1 == 1 && (multitap2 == 0 || multitap2 == 2)) {
829 pad_index = 4;
830 } else {
831 pad_index = 0;
52c9fcc8 832 }
9a94e3a1 833
52c9fcc8 834 //first call the pad provide if a multitap is connected between the psx and himself
f40e9993 835 if (multitap2 == -1) {
e288923d 836 PadDataS padd;
52c9fcc8 837 padd.requestPadIndex = pad_index;
838 PAD2_readPort2(&padd);
839 multitap2 = padd.portMultitap;
840 }
fb4bd474 841
842 // just one pad is on port 1 : NO MULTITAP
f40e9993 843 if (multitap2 == 0) {
e288923d 844 PadDataS padd;
52c9fcc8 845 padd.requestPadIndex = pad_index;
fb4bd474 846 PAD2_readPort2(&padd);
847 _PADstartPoll(&padd);
848 } else {
849 // a multitap is plugged : refresh all pad.
f40e9993 850 int i;
52c9fcc8 851 PadDataS padd[4];
f40e9993 852 for(i = 0; i < 4; i++) {
52c9fcc8 853 padd[i].requestPadIndex = i+pad_index;
854 PAD2_readPort2(&padd[i]);
855 }
fb4bd474 856 _PADstartPollMultitap(padd);
52c9fcc8 857 }
2ca181a9 858 //printf("\npad 2 : ");
fb4bd474 859 return 0x00;
860}
861
862unsigned char CALLBACK PAD2__poll(unsigned char value) {
0b4dc26d 863 char tmp;
f40e9993 864 if (multitap2 == 2) {
0b4dc26d 865 tmp = _PADpollMultitap(1, value);
f40e9993 866 } else {
0b4dc26d 867 tmp = _PADpoll(1, value);
868 }
fb4bd474 869 //printf("%2x:%2x, ",value,tmp);
870 return tmp;
871}
872
873long CALLBACK PAD2__configure(void) { return 0; }
874void CALLBACK PAD2__about(void) {}
875long CALLBACK PAD2__test(void) { return 0; }
876long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }
877long CALLBACK PAD2__keypressed() { return 0; }
878
879#define LoadPad2Sym1(dest, name) \
880 LoadSym(PAD2_##dest, PAD##dest, name, TRUE);
881
882#define LoadPad2Sym0(dest, name) \
883 LoadSym(PAD2_##dest, PAD##dest, name, FALSE); \
884 if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;
885
886#define LoadPad2SymN(dest, name) \
887 LoadSym(PAD2_##dest, PAD##dest, name, FALSE);
888
889static int LoadPAD2plugin(const char *PAD2dll) {
890 void *drv;
891
892 hPAD2Driver = SysLoadLibrary(PAD2dll);
893 if (hPAD2Driver == NULL) {
894 PAD2_configure = NULL;
895 SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;
896 }
897 drv = hPAD2Driver;
898 LoadPad2Sym1(init, "PADinit");
899 LoadPad2Sym1(shutdown, "PADshutdown");
900 LoadPad2Sym1(open, "PADopen");
901 LoadPad2Sym1(close, "PADclose");
902 LoadPad2Sym0(query, "PADquery");
903 LoadPad2Sym1(readPort2, "PADreadPort2");
904 LoadPad2Sym0(configure, "PADconfigure");
905 LoadPad2Sym0(test, "PADtest");
906 LoadPad2Sym0(about, "PADabout");
907 LoadPad2Sym0(keypressed, "PADkeypressed");
908 LoadPad2Sym0(startPoll, "PADstartPoll");
909 LoadPad2Sym0(poll, "PADpoll");
910 LoadPad2SymN(setSensitive, "PADsetSensitive");
911
912 return 0;
913}
914
915void *hNETDriver = NULL;
916
917void CALLBACK NET__setInfo(netInfo *info) {}
918void CALLBACK NET__keypressed(int key) {}
919long CALLBACK NET__configure(void) { return 0; }
920long CALLBACK NET__test(void) { return 0; }
921void CALLBACK NET__about(void) {}
922
923#define LoadNetSym1(dest, name) \
924 LoadSym(NET_##dest, NET##dest, name, TRUE);
925
926#define LoadNetSymN(dest, name) \
927 LoadSym(NET_##dest, NET##dest, name, FALSE);
928
929#define LoadNetSym0(dest, name) \
930 LoadSym(NET_##dest, NET##dest, name, FALSE); \
931 if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;
932
933static int LoadNETplugin(const char *NETdll) {
934 void *drv;
935
936 hNETDriver = SysLoadLibrary(NETdll);
937 if (hNETDriver == NULL) {
938 SysMessage (_("Could not load NetPlay plugin %s!"), NETdll); return -1;
939 }
940 drv = hNETDriver;
941 LoadNetSym1(init, "NETinit");
942 LoadNetSym1(shutdown, "NETshutdown");
943 LoadNetSym1(open, "NETopen");
944 LoadNetSym1(close, "NETclose");
945 LoadNetSymN(sendData, "NETsendData");
946 LoadNetSymN(recvData, "NETrecvData");
947 LoadNetSym1(sendPadData, "NETsendPadData");
948 LoadNetSym1(recvPadData, "NETrecvPadData");
949 LoadNetSym1(queryPlayer, "NETqueryPlayer");
950 LoadNetSym1(pause, "NETpause");
951 LoadNetSym1(resume, "NETresume");
952 LoadNetSym0(setInfo, "NETsetInfo");
953 LoadNetSym0(keypressed, "NETkeypressed");
954 LoadNetSym0(configure, "NETconfigure");
955 LoadNetSym0(test, "NETtest");
956 LoadNetSym0(about, "NETabout");
957
958 return 0;
959}
960
961#ifdef ENABLE_SIO1API
962
963void *hSIO1Driver = NULL;
964
965long CALLBACK SIO1__init(void) { return 0; }
966long CALLBACK SIO1__shutdown(void) { return 0; }
967long CALLBACK SIO1__open(void) { return 0; }
968long CALLBACK SIO1__close(void) { return 0; }
969long CALLBACK SIO1__configure(void) { return 0; }
970long CALLBACK SIO1__test(void) { return 0; }
971void CALLBACK SIO1__about(void) {}
972void CALLBACK SIO1__pause(void) {}
973void CALLBACK SIO1__resume(void) {}
974long CALLBACK SIO1__keypressed(int key) { return 0; }
975void CALLBACK SIO1__writeData8(unsigned char val) {}
976void CALLBACK SIO1__writeData16(unsigned short val) {}
977void CALLBACK SIO1__writeData32(unsigned long val) {}
978void CALLBACK SIO1__writeStat16(unsigned short val) {}
979void CALLBACK SIO1__writeStat32(unsigned long val) {}
980void CALLBACK SIO1__writeMode16(unsigned short val) {}
981void CALLBACK SIO1__writeMode32(unsigned long val) {}
982void CALLBACK SIO1__writeCtrl16(unsigned short val) {}
983void CALLBACK SIO1__writeCtrl32(unsigned long val) {}
984void CALLBACK SIO1__writeBaud16(unsigned short val) {}
985void CALLBACK SIO1__writeBaud32(unsigned long val) {}
986unsigned char CALLBACK SIO1__readData8(void) { return 0; }
987unsigned short CALLBACK SIO1__readData16(void) { return 0; }
988unsigned long CALLBACK SIO1__readData32(void) { return 0; }
989unsigned short CALLBACK SIO1__readStat16(void) { return 0; }
990unsigned long CALLBACK SIO1__readStat32(void) { return 0; }
991unsigned short CALLBACK SIO1__readMode16(void) { return 0; }
992unsigned long CALLBACK SIO1__readMode32(void) { return 0; }
993unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }
994unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }
995unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }
996unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }
997void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};
998
999void CALLBACK SIO1irq(void) {
1000 psxHu32ref(0x1070) |= SWAPu32(0x100);
1001}
1002
1003#define LoadSio1Sym1(dest, name) \
1004 LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);
1005
1006#define LoadSio1SymN(dest, name) \
1007 LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);
1008
1009#define LoadSio1Sym0(dest, name) \
1010 LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \
1011 if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;
1012
1013static int LoadSIO1plugin(const char *SIO1dll) {
1014 void *drv;
1015
1016 hSIO1Driver = SysLoadLibrary(SIO1dll);
1017 if (hSIO1Driver == NULL) {
1018 SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;
1019 }
1020 drv = hSIO1Driver;
1021
1022 LoadSio1Sym0(init, "SIO1init");
1023 LoadSio1Sym0(shutdown, "SIO1shutdown");
1024 LoadSio1Sym0(open, "SIO1open");
1025 LoadSio1Sym0(close, "SIO1close");
1026 LoadSio1Sym0(pause, "SIO1pause");
1027 LoadSio1Sym0(resume, "SIO1resume");
1028 LoadSio1Sym0(keypressed, "SIO1keypressed");
1029 LoadSio1Sym0(configure, "SIO1configure");
1030 LoadSio1Sym0(test, "SIO1test");
1031 LoadSio1Sym0(about, "SIO1about");
1032 LoadSio1Sym0(writeData8, "SIO1writeData8");
1033 LoadSio1Sym0(writeData16, "SIO1writeData16");
1034 LoadSio1Sym0(writeData32, "SIO1writeData32");
1035 LoadSio1Sym0(writeStat16, "SIO1writeStat16");
1036 LoadSio1Sym0(writeStat32, "SIO1writeStat32");
1037 LoadSio1Sym0(writeMode16, "SIO1writeMode16");
1038 LoadSio1Sym0(writeMode32, "SIO1writeMode32");
1039 LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");
1040 LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");
1041 LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");
1042 LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");
1043 LoadSio1Sym0(readData16, "SIO1readData16");
1044 LoadSio1Sym0(readData32, "SIO1readData32");
1045 LoadSio1Sym0(readStat16, "SIO1readStat16");
1046 LoadSio1Sym0(readStat32, "SIO1readStat32");
1047 LoadSio1Sym0(readMode16, "SIO1readMode16");
1048 LoadSio1Sym0(readMode32, "SIO1readMode32");
1049 LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");
1050 LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");
1051 LoadSio1Sym0(readBaud16, "SIO1readBaud16");
1052 LoadSio1Sym0(readBaud32, "SIO1readBaud32");
1053 LoadSio1Sym0(registerCallback, "SIO1registerCallback");
1054
1055 return 0;
1056}
1057
1058#endif
1059
1060void CALLBACK clearDynarec(void) {
1061 psxCpu->Reset();
1062}
1063
1064int LoadPlugins() {
1065 int ret;
1066 char Plugin[MAXPATHLEN];
1067
1068 ReleasePlugins();
1069 SysLibError();
1070
1071 if (UsingIso()) {
1072 LoadCDRplugin(NULL);
1073 } else {
1074 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
1075 if (LoadCDRplugin(Plugin) == -1) return -1;
1076 }
1077
1078 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);
1079 if (LoadGPUplugin(Plugin) == -1) return -1;
1080
1081 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);
1082 if (LoadSPUplugin(Plugin) == -1) return -1;
1083
1084 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);
1085 if (LoadPAD1plugin(Plugin) == -1) return -1;
1086
1087 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);
1088 if (LoadPAD2plugin(Plugin) == -1) return -1;
1089
1090 if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)
1091 Config.UseNet = FALSE;
1092 else {
1093 Config.UseNet = TRUE;
1094 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);
1095 if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;
1096 }
1097
1098#ifdef ENABLE_SIO1API
1099 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);
1100 if (LoadSIO1plugin(Plugin) == -1) return -1;
1101#endif
1102
1103 ret = CDR_init();
1104 if (ret < 0) { SysMessage (_("Error initializing CD-ROM plugin: %d"), ret); return -1; }
1105 ret = GPU_init();
1106 if (ret < 0) { SysMessage (_("Error initializing GPU plugin: %d"), ret); return -1; }
1107 ret = SPU_init();
1108 if (ret < 0) { SysMessage (_("Error initializing SPU plugin: %d"), ret); return -1; }
1109 ret = PAD1_init(1);
1110 if (ret < 0) { SysMessage (_("Error initializing Controller 1 plugin: %d"), ret); return -1; }
1111 ret = PAD2_init(2);
1112 if (ret < 0) { SysMessage (_("Error initializing Controller 2 plugin: %d"), ret); return -1; }
1113
1114 if (Config.UseNet) {
1115 ret = NET_init();
1116 if (ret < 0) { SysMessage (_("Error initializing NetPlay plugin: %d"), ret); return -1; }
1117 }
1118
1119#ifdef ENABLE_SIO1API
1120 ret = SIO1_init();
1121 if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }
1122#endif
1123
1124 SysPrintf(_("Plugins loaded.\n"));
1125 return 0;
1126}
1127
1128void ReleasePlugins() {
1129 if (Config.UseNet) {
1130 int ret = NET_close();
1131 if (ret < 0) Config.UseNet = FALSE;
1132 }
1133 NetOpened = FALSE;
1134
1135 if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
1136 if (hGPUDriver != NULL) GPU_shutdown();
1137 if (hSPUDriver != NULL) SPU_shutdown();
1138 if (hPAD1Driver != NULL) PAD1_shutdown();
1139 if (hPAD2Driver != NULL) PAD2_shutdown();
1140
1141 if (Config.UseNet && hNETDriver != NULL) NET_shutdown();
1142
1143 if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;
1144 if (hGPUDriver != NULL) SysCloseLibrary(hGPUDriver); hGPUDriver = NULL;
1145 if (hSPUDriver != NULL) SysCloseLibrary(hSPUDriver); hSPUDriver = NULL;
1146 if (hPAD1Driver != NULL) SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL;
1147 if (hPAD2Driver != NULL) SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL;
1148
1149 if (Config.UseNet && hNETDriver != NULL) {
1150 SysCloseLibrary(hNETDriver); hNETDriver = NULL;
1151 }
1152
1153#ifdef ENABLE_SIO1API
1154 if (hSIO1Driver != NULL) {
1155 SIO1_shutdown();
1156 SysCloseLibrary(hSIO1Driver);
1157 hSIO1Driver = NULL;
1158 }
1159#endif
1160}
1161
1162// for CD swap
1163int ReloadCdromPlugin()
1164{
1165 if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
1166 if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;
1167
1168 if (UsingIso()) {
1169 LoadCDRplugin(NULL);
1170 } else {
1171 char Plugin[MAXPATHLEN];
1172 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
1173 if (LoadCDRplugin(Plugin) == -1) return -1;
1174 }
1175
1176 return CDR_init();
1177}
1178
1179void SetIsoFile(const char *filename) {
1180 if (filename == NULL) {
1181 IsoFile[0] = '\0';
1182 return;
1183 }
1184 strncpy(IsoFile, filename, MAXPATHLEN);
1185}
1186
1187const char *GetIsoFile(void) {
1188 return IsoFile;
1189}
1190
1191boolean UsingIso(void) {
1192 return (IsoFile[0] != '\0');
1193}
1194
1195void SetCdOpenCaseTime(s64 time) {
1196 cdOpenCaseTime = time;
1197}
ARM optimized PCSX fork