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