notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix build
[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;
1b944575 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;
1b944575 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;
fb4bd474 52GPUvBlank GPU_vBlank;
53
54CDRinit CDR_init;
55CDRshutdown CDR_shutdown;
56CDRopen CDR_open;
1b944575 57CDRclose CDR_close;
fb4bd474 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;
1b944575 126NETclose NET_close;
fb4bd474 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;
1b944575 145SIO1close SIO1_close;
fb4bd474 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; }
fb4bd474 203void CALLBACK GPU__vBlank(int val) {}
204
205#define LoadGpuSym1(dest, name) \
206 LoadSym(GPU_##dest, GPU##dest, name, TRUE);
207
208#define LoadGpuSym0(dest, name) \
209 LoadSym(GPU_##dest, GPU##dest, name, FALSE); \
210 if (GPU_##dest == NULL) GPU_##dest = (GPU##dest) GPU__##dest;
211
212#define LoadGpuSymN(dest, name) \
213 LoadSym(GPU_##dest, GPU##dest, name, FALSE);
214
215static int LoadGPUplugin(const char *GPUdll) {
216 void *drv;
217
218 hGPUDriver = SysLoadLibrary(GPUdll);
1b944575 219 if (hGPUDriver == NULL) {
fb4bd474 220 GPU_configure = NULL;
1b944575 221 SysMessage (_("Could not load GPU plugin %s!"), GPUdll); return -1;
fb4bd474 222 }
223 drv = hGPUDriver;
224 LoadGpuSym1(init, "GPUinit");
225 LoadGpuSym1(shutdown, "GPUshutdown");
226 LoadGpuSym1(open, "GPUopen");
227 LoadGpuSym1(close, "GPUclose");
228 LoadGpuSym1(readData, "GPUreadData");
229 LoadGpuSym1(readDataMem, "GPUreadDataMem");
230 LoadGpuSym1(readStatus, "GPUreadStatus");
231 LoadGpuSym1(writeData, "GPUwriteData");
232 LoadGpuSym1(writeDataMem, "GPUwriteDataMem");
233 LoadGpuSym1(writeStatus, "GPUwriteStatus");
234 LoadGpuSym1(dmaChain, "GPUdmaChain");
235 LoadGpuSym1(updateLace, "GPUupdateLace");
236 LoadGpuSym0(keypressed, "GPUkeypressed");
237 LoadGpuSym0(displayText, "GPUdisplayText");
238 LoadGpuSym0(makeSnapshot, "GPUmakeSnapshot");
239 LoadGpuSym1(freeze, "GPUfreeze");
240 LoadGpuSym0(getScreenPic, "GPUgetScreenPic");
241 LoadGpuSym0(showScreenPic, "GPUshowScreenPic");
b17ff6df 242 LoadGpuSym0(vBlank, "GPUvBlank");
fb4bd474 243 LoadGpuSym0(configure, "GPUconfigure");
244 LoadGpuSym0(test, "GPUtest");
245 LoadGpuSym0(about, "GPUabout");
246
247 return 0;
248}
249
250void *hCDRDriver = NULL;
251
252long CALLBACK CDR__play(unsigned char *sector) { return 0; }
253long CALLBACK CDR__stop(void) { return 0; }
254
255long CALLBACK CDR__getStatus(struct CdrStat *stat) {
256 if (cdOpenCaseTime < 0 || cdOpenCaseTime > (s64)time(NULL))
257 stat->Status = 0x10;
258 else
259 stat->Status = 0;
260
261 return 0;
262}
263
264char* CALLBACK CDR__getDriveLetter(void) { return NULL; }
265long CALLBACK CDR__configure(void) { return 0; }
266long CALLBACK CDR__test(void) { return 0; }
267void CALLBACK CDR__about(void) {}
268long CALLBACK CDR__setfilename(char*filename) { return 0; }
269
270#define LoadCdrSym1(dest, name) \
271 LoadSym(CDR_##dest, CDR##dest, name, TRUE);
272
273#define LoadCdrSym0(dest, name) \
274 LoadSym(CDR_##dest, CDR##dest, name, FALSE); \
275 if (CDR_##dest == NULL) CDR_##dest = (CDR##dest) CDR__##dest;
276
277#define LoadCdrSymN(dest, name) \
278 LoadSym(CDR_##dest, CDR##dest, name, FALSE);
279
280static int LoadCDRplugin(const char *CDRdll) {
281 void *drv;
282
283 if (CDRdll == NULL) {
284 cdrIsoInit();
285 return 0;
286 }
287
288 hCDRDriver = SysLoadLibrary(CDRdll);
289 if (hCDRDriver == NULL) {
290 CDR_configure = NULL;
291 SysMessage (_("Could not load CD-ROM plugin %s!"), CDRdll); return -1;
292 }
293 drv = hCDRDriver;
294 LoadCdrSym1(init, "CDRinit");
295 LoadCdrSym1(shutdown, "CDRshutdown");
296 LoadCdrSym1(open, "CDRopen");
297 LoadCdrSym1(close, "CDRclose");
298 LoadCdrSym1(getTN, "CDRgetTN");
299 LoadCdrSym1(getTD, "CDRgetTD");
300 LoadCdrSym1(readTrack, "CDRreadTrack");
301 LoadCdrSym1(getBuffer, "CDRgetBuffer");
302 LoadCdrSym1(getBufferSub, "CDRgetBufferSub");
303 LoadCdrSym0(play, "CDRplay");
304 LoadCdrSym0(stop, "CDRstop");
305 LoadCdrSym0(getStatus, "CDRgetStatus");
306 LoadCdrSym0(getDriveLetter, "CDRgetDriveLetter");
307 LoadCdrSym0(configure, "CDRconfigure");
308 LoadCdrSym0(test, "CDRtest");
309 LoadCdrSym0(about, "CDRabout");
310 LoadCdrSym0(setfilename, "CDRsetfilename");
311 LoadCdrSymN(readCDDA, "CDRreadCDDA");
312 LoadCdrSymN(getTE, "CDRgetTE");
313
314 return 0;
315}
316
317void *hSPUDriver = NULL;
318
319long CALLBACK SPU__configure(void) { return 0; }
320void CALLBACK SPU__about(void) {}
321long CALLBACK SPU__test(void) { return 0; }
322void CALLBACK SPU__registerScheduleCb(void (CALLBACK *cb)(unsigned int)) {}
323
324#define LoadSpuSym1(dest, name) \
325 LoadSym(SPU_##dest, SPU##dest, name, TRUE);
326
327#define LoadSpuSym0(dest, name) \
328 LoadSym(SPU_##dest, SPU##dest, name, FALSE); \
329 if (SPU_##dest == NULL) SPU_##dest = (SPU##dest) SPU__##dest;
330
331#define LoadSpuSymN(dest, name) \
332 LoadSym(SPU_##dest, SPU##dest, name, FALSE);
333
334static int LoadSPUplugin(const char *SPUdll) {
335 void *drv;
336
337 hSPUDriver = SysLoadLibrary(SPUdll);
338 if (hSPUDriver == NULL) {
339 SPU_configure = NULL;
340 SysMessage (_("Could not load SPU plugin %s!"), SPUdll); return -1;
341 }
342 drv = hSPUDriver;
343 LoadSpuSym1(init, "SPUinit");
344 LoadSpuSym1(shutdown, "SPUshutdown");
345 LoadSpuSym1(open, "SPUopen");
346 LoadSpuSym1(close, "SPUclose");
347 LoadSpuSym0(configure, "SPUconfigure");
348 LoadSpuSym0(about, "SPUabout");
349 LoadSpuSym0(test, "SPUtest");
350 LoadSpuSym1(writeRegister, "SPUwriteRegister");
1b944575 351 LoadSpuSym1(readRegister, "SPUreadRegister");
fb4bd474 352 LoadSpuSym1(writeDMA, "SPUwriteDMA");
353 LoadSpuSym1(readDMA, "SPUreadDMA");
354 LoadSpuSym1(writeDMAMem, "SPUwriteDMAMem");
355 LoadSpuSym1(readDMAMem, "SPUreadDMAMem");
356 LoadSpuSym1(playADPCMchannel, "SPUplayADPCMchannel");
357 LoadSpuSym1(freeze, "SPUfreeze");
358 LoadSpuSym1(registerCallback, "SPUregisterCallback");
359 LoadSpuSym0(registerScheduleCb, "SPUregisterScheduleCb");
360 LoadSpuSymN(async, "SPUasync");
361 LoadSpuSymN(playCDDAchannel, "SPUplayCDDAchannel");
362
363 return 0;
364}
365
8822f8b1 366extern int in_type[8];
367
fb4bd474 368void *hPAD1Driver = NULL;
369void *hPAD2Driver = NULL;
370
5ced3945 371static int multitap1;
372static int multitap2;
fb4bd474 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];
8822f8b1 378static int PadMode[8]; /* 0 : digital 1: analog */
fb4bd474 379
0b4dc26d 380static unsigned char buf[256];
1b944575 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};
1b944575 386
fb4bd474 387unsigned char stdpar[8] = { 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
1b944575 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};
1b944575 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
1b944575 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,
1b944575 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
1b944575 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
1b944575 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,
1b944575 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,
1b944575 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,
1b944575 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,
1b944575 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,
1b944575 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,
1b944575 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);
8822f8b1 532 buf[4] = PadMode[padIndex];
fb4bd474 533 break;
534 case CMD_QUERY_ACT :
535 memcpy(buf, resp46_00, 8);
536 break;
537 case CMD_QUERY_COMB :
538 memcpy(buf, resp47, 8);
539 break;
540 case CMD_QUERY_MODE :
541 memcpy(buf, resp4C_00, 8);
542 break;
543 case CMD_VIBRATION_TOGGLE :
544 memcpy(buf, resp4D, 8);
545 break;
546 case REQ40 :
547 memcpy(buf, resp40, 8);
548 break;
549 case REQ41 :
550 memcpy(buf, resp41, 8);
551 break;
552 case REQ49 :
553 memcpy(buf, resp49, 8);
554 break;
555 case REQ4A :
556 memcpy(buf, resp4A, 8);
557 break;
558 case REQ4B :
559 memcpy(buf, resp4B, 8);
560 break;
561 case REQ4E :
562 memcpy(buf, resp4E, 8);
563 break;
564 case REQ4F :
565 memcpy(buf, resp4F, 8);
566 break;
52c9fcc8 567 }
0b4dc26d 568}
569
ff787a95 570
571
572
573void reqIndex2Treatment(int padIndex, char value){
574 switch (req){
fb4bd474 575 case CMD_CONFIG_MODE :
576 //0x43
577 if (value == 0) {
578 pad[padIndex].configMode = 0;
579 } else {
580 pad[padIndex].configMode = 1;
581 }
582 break;
583 case CMD_SET_MODE_AND_LOCK :
584 //0x44 store the led state for change mode if the next value = 0x02
585 //0x01 analog ON
586 //0x00 analog OFF
587 ledStateReq44[padIndex] = value;
8822f8b1 588 PadMode[padIndex] = value;
fb4bd474 589 break;
590 case CMD_QUERY_ACT :
591 //0x46
592 if (value == 1) {
593 memcpy(buf, resp46_01, 8);
594 }
595 break;
596 case CMD_QUERY_MODE :
597 if (value == 1) {
598 memcpy(buf, resp4C_01, 8);
599 }
600 break;
601 case CMD_VIBRATION_TOGGLE :
602 //0x4D
603 memcpy(buf, resp4D, 8);
604 break;
605 case CMD_READ_DATA_AND_VIBRATE:
606 //mem the vibration value for small motor;
52c9fcc8 607 pad[padIndex].Vib[0] = value;
f40e9993 608 break;
fb4bd474 609 }
610}
1b944575 611
ff787a95 612void vibrate(int padIndex){
f40e9993 613 if (pad[padIndex].Vib[0] != pad[padIndex].VibF[0] || pad[padIndex].Vib[1] != pad[padIndex].VibF[1]) {
52c9fcc8 614 //value is different update Value and call libretro for vibration
615 pad[padIndex].VibF[0] = pad[padIndex].Vib[0];
616 pad[padIndex].VibF[1] = pad[padIndex].Vib[1];
617 plat_trigger_vibrate(padIndex, pad[padIndex].VibF[0], pad[padIndex].VibF[1]);
2ca181a9 618 //printf("vibration pad %i", padIndex);
52c9fcc8 619 }
ef296715 620}
621
ff787a95 622
623
624
fb4bd474 625//Build response for 0x42 request Pad in port
626void _PADstartPoll(PadDataS *pad) {
b17ff6df 627 switch (pad->controllerType) {
628 case PSE_PAD_TYPE_MOUSE:
fb4bd474 629 stdpar[0] = 0x12;
d526ed8c 630 stdpar[1] = 0x5a;
b17ff6df 631 stdpar[2] = pad->buttonStatus & 0xff;
632 stdpar[3] = pad->buttonStatus >> 8;
633 stdpar[4] = pad->moveX;
634 stdpar[5] = pad->moveY;
635 memcpy(buf, stdpar, 6);
636 respSize = 6;
637 break;
638 case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)
639 stdpar[0] = 0x23;
d526ed8c 640 stdpar[1] = 0x5a;
b17ff6df 641 stdpar[2] = pad->buttonStatus & 0xff;
642 stdpar[3] = pad->buttonStatus >> 8;
643 stdpar[4] = pad->rightJoyX;
644 stdpar[5] = pad->rightJoyY;
645 stdpar[6] = pad->leftJoyX;
646 stdpar[7] = pad->leftJoyY;
647 memcpy(buf, stdpar, 8);
648 respSize = 8;
649 break;
5ced3945 650 case PSE_PAD_TYPE_GUNCON: // GUNCON - gun controller SLPH-00034 from Namco
b17ff6df 651 stdpar[0] = 0x63;
652 stdpar[1] = 0x5a;
653 stdpar[2] = pad->buttonStatus & 0xff;
654 stdpar[3] = pad->buttonStatus >> 8;
655
656 //This code assumes an X resolution of 256 and a Y resolution of 240
657 int xres = 256;
658 int yres = 240;
659
660 //The code wants an input range for x and y of 0-1023 we passed in -32767 -> 32767
661 int absX = (pad->absoluteX / 64) + 512;
662 int absY = (pad->absoluteY / 64) + 512;
663
a901d519
S		 664 if (absX == 65536 || absY == 65536) {
665 stdpar[4] = 0x01;
666 stdpar[5] = 0x00;
667 stdpar[6] = 0x0A;
668 stdpar[7] = 0x00;
669 }
670 else {
671 stdpar[4] = 0x5a - (xres - 256) / 3 + (((xres - 256) / 3 + 356) * absX >> 10);
672 stdpar[5] = (0x5a - (xres - 256) / 3 + (((xres - 256) / 3 + 356) * absX >> 10)) >> 8;
673 stdpar[6] = 0x20 + (yres * absY >> 10);
674 stdpar[7] = (0x20 + (yres * absY >> 10)) >> 8;
b17ff6df 675 }
676
677 memcpy(buf, stdpar, 8);
678 respSize = 8;
679 break;
680 case PSE_PAD_TYPE_ANALOGPAD: // scph1150
681 stdpar[0] = 0x73;
d526ed8c 682 stdpar[1] = 0x5a;
b17ff6df 683 stdpar[2] = pad->buttonStatus & 0xff;
684 stdpar[3] = pad->buttonStatus >> 8;
685 stdpar[4] = pad->rightJoyX;
686 stdpar[5] = pad->rightJoyY;
687 stdpar[6] = pad->leftJoyX;
688 stdpar[7] = pad->leftJoyY;
689 memcpy(buf, stdpar, 8);
690 respSize = 8;
691 break;
692 case PSE_PAD_TYPE_ANALOGJOY: // scph1110
693 stdpar[0] = 0x53;
d526ed8c 694 stdpar[1] = 0x5a;
b17ff6df 695 stdpar[2] = pad->buttonStatus & 0xff;
696 stdpar[3] = pad->buttonStatus >> 8;
697 stdpar[4] = pad->rightJoyX;
698 stdpar[5] = pad->rightJoyY;
699 stdpar[6] = pad->leftJoyX;
700 stdpar[7] = pad->leftJoyY;
701 memcpy(buf, stdpar, 8);
702 respSize = 8;
703 break;
704 case PSE_PAD_TYPE_STANDARD:
b17ff6df 705 stdpar[0] = 0x41;
d526ed8c 706 stdpar[1] = 0x5a;
b17ff6df 707 stdpar[2] = pad->buttonStatus & 0xff;
708 stdpar[3] = pad->buttonStatus >> 8;
709 //avoid analog value in multitap mode if change pad type in game.
710 stdpar[4] = 0xff;
711 stdpar[5] = 0xff;
712 stdpar[6] = 0xff;
713 stdpar[7] = 0xff;
714 memcpy(buf, stdpar, 8);
715 respSize = 8;
d526ed8c 716 break;
717 default:
718 stdpar[0] = 0xff;
719 stdpar[1] = 0xff;
720 stdpar[2] = 0xff;
721 stdpar[3] = 0xff;
722 stdpar[4] = 0xff;
723 stdpar[5] = 0xff;
724 stdpar[6] = 0xff;
725 stdpar[7] = 0xff;
726 memcpy(buf, stdpar, 8);
727 respSize = 8;
728 break;
b17ff6df 729 }
fb4bd474 730}
731
ff787a95 732
ef296715 733//Build response for 0x42 request Multitap in port
fb4bd474 734//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)
735void _PADstartPollMultitap(PadDataS* padd) {
b17ff6df 736 int i, offset;
737 for(i = 0; i < 4; i++) {
738 offset = 2 + (i * 8);
ff787a95 739 _PADstartPoll(&padd[i]);
740 memcpy(multitappar+offset, stdpar, 8);
b17ff6df 741 }
742 memcpy(bufMulti, multitappar, 34);
743 respSize = 34;
0b4dc26d 744}
fb4bd474 745
ff787a95 746
0b4dc26d 747unsigned char _PADpoll(int port, unsigned char value) {
f40e9993 748 if (reqPos == 0) {
0b4dc26d 749 //mem the request number
fb4bd474 750 req = value;
1b944575 751
8822f8b1 752 // Don't enable Analog/Vibration for a standard pad
4c7a462e 753 if (in_type[port] == PSE_PAD_TYPE_STANDARD ||
754 in_type[port] == PSE_PAD_TYPE_NEGCON) {
8822f8b1 755 ; // Pad keystate already in buffer
756 }
757 else
758 {
759 //copy the default value of request response in buffer instead of the keystate
760 initBufForRequest(port, value);
761 }
fb4bd474 762 }
1b944575 763
fb4bd474 764 //if no new request the pad return 0xff, for signaling connected
5b568098 765 if (reqPos >= respSize)
766 return 0xff;
1b944575 767
ff787a95 768 switch(reqPos){
fb4bd474 769 case 2:
770 reqIndex2Treatment(port, value);
771 break;
772 case 3:
773 switch(req) {
774 case CMD_SET_MODE_AND_LOCK :
775 //change mode on pad
776 break;
777 case CMD_READ_DATA_AND_VIBRATE:
778 //mem the vibration value for Large motor;
779 pad[port].Vib[1] = value;
4c7a462e 780
4bbae293 781 if (in_type[port] != PSE_PAD_TYPE_ANALOGPAD)
4c7a462e 782 break;
783
0b4dc26d 784 //vibration
4c7a462e 785 vibrate(port);
fb4bd474 786 break;
787 }
788 break;
789 }
790 return buf[reqPos++];
0b4dc26d 791}
792
0e06fdad 793
ff787a95 794unsigned char _PADpollMultitap(int port, unsigned char value) {
795 if (reqPos >= respSize) return 0xff;
fb4bd474 796 return bufMulti[reqPos++];
0b4dc26d 797}
fb4bd474 798
ff787a95 799
fb4bd474 800// refresh the button state on port 1.
801// int pad is not needed.
52c9fcc8 802unsigned char CALLBACK PAD1__startPoll(int pad) {
fb4bd474 803 reqPos = 0;
804 // first call the pad provide if a multitap is connected between the psx and himself
fb4bd474 805 // just one pad is on port 1 : NO MULTITAP
806 if (multitap1 == 0) {
e288923d 807 PadDataS padd;
fb4bd474 808 padd.requestPadIndex = 0;
809 PAD1_readPort1(&padd);
810 _PADstartPoll(&padd);
811 } else {
812 // a multitap is plugged : refresh all pad.
813 int i;
814 PadDataS padd[4];
e288923d 815 for(i = 0; i < 4; i++) {
fb4bd474 816 padd[i].requestPadIndex = i;
817 PAD1_readPort1(&padd[i]);
52c9fcc8 818 }
fb4bd474 819 _PADstartPollMultitap(padd);
52c9fcc8 820 }
2ca181a9 821 //printf("\npad 1 : ");
fb4bd474 822 return 0x00;
823}
824
52c9fcc8 825unsigned char CALLBACK PAD1__poll(unsigned char value) {
0b4dc26d 826 char tmp;
f40e9993 827 if (multitap1 == 1) {
0b4dc26d 828 tmp = _PADpollMultitap(0, value);
f40e9993 829 } else {
0b4dc26d 830 tmp = _PADpoll(0, value);
831 }
fb4bd474 832 //printf("%2x:%2x, ",value,tmp);
833 return tmp;
1b944575 834
0e06fdad 835}
fb4bd474 836
ff787a95 837
fb4bd474 838long CALLBACK PAD1__configure(void) { return 0; }
839void CALLBACK PAD1__about(void) {}
840long CALLBACK PAD1__test(void) { return 0; }
841long CALLBACK PAD1__query(void) { return 3; }
842long CALLBACK PAD1__keypressed() { return 0; }
843
844#define LoadPad1Sym1(dest, name) \
845 LoadSym(PAD1_##dest, PAD##dest, name, TRUE);
846
847#define LoadPad1SymN(dest, name) \
848 LoadSym(PAD1_##dest, PAD##dest, name, FALSE);
849
850#define LoadPad1Sym0(dest, name) \
851 LoadSym(PAD1_##dest, PAD##dest, name, FALSE); \
852 if (PAD1_##dest == NULL) PAD1_##dest = (PAD##dest) PAD1__##dest;
853
854static int LoadPAD1plugin(const char *PAD1dll) {
5ced3945 855 PadDataS padd;
fb4bd474 856 void *drv;
857
858 hPAD1Driver = SysLoadLibrary(PAD1dll);
859 if (hPAD1Driver == NULL) {
860 PAD1_configure = NULL;
861 SysMessage (_("Could not load Controller 1 plugin %s!"), PAD1dll); return -1;
862 }
863 drv = hPAD1Driver;
864 LoadPad1Sym1(init, "PADinit");
865 LoadPad1Sym1(shutdown, "PADshutdown");
866 LoadPad1Sym1(open, "PADopen");
867 LoadPad1Sym1(close, "PADclose");
868 LoadPad1Sym0(query, "PADquery");
869 LoadPad1Sym1(readPort1, "PADreadPort1");
870 LoadPad1Sym0(configure, "PADconfigure");
871 LoadPad1Sym0(test, "PADtest");
872 LoadPad1Sym0(about, "PADabout");
873 LoadPad1Sym0(keypressed, "PADkeypressed");
874 LoadPad1Sym0(startPoll, "PADstartPoll");
875 LoadPad1Sym0(poll, "PADpoll");
876 LoadPad1SymN(setSensitive, "PADsetSensitive");
877
5ced3945 878 padd.requestPadIndex = 0;
879 PAD1_readPort1(&padd);
880 multitap1 = padd.portMultitap;
881
fb4bd474 882 return 0;
883}
884
52c9fcc8 885unsigned char CALLBACK PAD2__startPoll(int pad) {
f40e9993
A		 886 int pad_index;
887
fb4bd474 888 reqPos = 0;
f40e9993
A		 889 if (multitap1 == 0 && (multitap2 == 0 || multitap2 == 2)) {
890 pad_index = 1;
891 } else if(multitap1 == 1 && (multitap2 == 0 || multitap2 == 2)) {
892 pad_index = 4;
893 } else {
894 pad_index = 0;
52c9fcc8 895 }
9a94e3a1 896
fb4bd474 897 // just one pad is on port 1 : NO MULTITAP
f40e9993 898 if (multitap2 == 0) {
e288923d 899 PadDataS padd;
52c9fcc8 900 padd.requestPadIndex = pad_index;
fb4bd474 901 PAD2_readPort2(&padd);
902 _PADstartPoll(&padd);
903 } else {
904 // a multitap is plugged : refresh all pad.
f40e9993 905 int i;
52c9fcc8 906 PadDataS padd[4];
f40e9993 907 for(i = 0; i < 4; i++) {
52c9fcc8 908 padd[i].requestPadIndex = i+pad_index;
909 PAD2_readPort2(&padd[i]);
910 }
fb4bd474 911 _PADstartPollMultitap(padd);
52c9fcc8 912 }
2ca181a9 913 //printf("\npad 2 : ");
fb4bd474 914 return 0x00;
915}
916
917unsigned char CALLBACK PAD2__poll(unsigned char value) {
0b4dc26d 918 char tmp;
f40e9993 919 if (multitap2 == 2) {
0b4dc26d 920 tmp = _PADpollMultitap(1, value);
f40e9993 921 } else {
0b4dc26d 922 tmp = _PADpoll(1, value);
923 }
fb4bd474 924 //printf("%2x:%2x, ",value,tmp);
925 return tmp;
926}
927
928long CALLBACK PAD2__configure(void) { return 0; }
929void CALLBACK PAD2__about(void) {}
930long CALLBACK PAD2__test(void) { return 0; }
931long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }
932long CALLBACK PAD2__keypressed() { return 0; }
933
934#define LoadPad2Sym1(dest, name) \
935 LoadSym(PAD2_##dest, PAD##dest, name, TRUE);
936
937#define LoadPad2Sym0(dest, name) \
938 LoadSym(PAD2_##dest, PAD##dest, name, FALSE); \
939 if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;
940
941#define LoadPad2SymN(dest, name) \
942 LoadSym(PAD2_##dest, PAD##dest, name, FALSE);
943
944static int LoadPAD2plugin(const char *PAD2dll) {
5ced3945 945 PadDataS padd;
fb4bd474 946 void *drv;
947
948 hPAD2Driver = SysLoadLibrary(PAD2dll);
949 if (hPAD2Driver == NULL) {
950 PAD2_configure = NULL;
951 SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;
952 }
953 drv = hPAD2Driver;
954 LoadPad2Sym1(init, "PADinit");
955 LoadPad2Sym1(shutdown, "PADshutdown");
956 LoadPad2Sym1(open, "PADopen");
957 LoadPad2Sym1(close, "PADclose");
958 LoadPad2Sym0(query, "PADquery");
959 LoadPad2Sym1(readPort2, "PADreadPort2");
960 LoadPad2Sym0(configure, "PADconfigure");
961 LoadPad2Sym0(test, "PADtest");
962 LoadPad2Sym0(about, "PADabout");
963 LoadPad2Sym0(keypressed, "PADkeypressed");
964 LoadPad2Sym0(startPoll, "PADstartPoll");
965 LoadPad2Sym0(poll, "PADpoll");
966 LoadPad2SymN(setSensitive, "PADsetSensitive");
967
5ced3945 968 padd.requestPadIndex = 0;
969 PAD2_readPort2(&padd);
970 multitap2 = padd.portMultitap;
971
fb4bd474 972 return 0;
973}
974
975void *hNETDriver = NULL;
976
977void CALLBACK NET__setInfo(netInfo *info) {}
978void CALLBACK NET__keypressed(int key) {}
979long CALLBACK NET__configure(void) { return 0; }
980long CALLBACK NET__test(void) { return 0; }
981void CALLBACK NET__about(void) {}
982
983#define LoadNetSym1(dest, name) \
984 LoadSym(NET_##dest, NET##dest, name, TRUE);
985
986#define LoadNetSymN(dest, name) \
987 LoadSym(NET_##dest, NET##dest, name, FALSE);
988
989#define LoadNetSym0(dest, name) \
990 LoadSym(NET_##dest, NET##dest, name, FALSE); \
991 if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;
992
993static int LoadNETplugin(const char *NETdll) {
994 void *drv;
995
996 hNETDriver = SysLoadLibrary(NETdll);
997 if (hNETDriver == NULL) {
998 SysMessage (_("Could not load NetPlay plugin %s!"), NETdll); return -1;
999 }
1000 drv = hNETDriver;
1001 LoadNetSym1(init, "NETinit");
1002 LoadNetSym1(shutdown, "NETshutdown");
1003 LoadNetSym1(open, "NETopen");
1004 LoadNetSym1(close, "NETclose");
1005 LoadNetSymN(sendData, "NETsendData");
1006 LoadNetSymN(recvData, "NETrecvData");
1007 LoadNetSym1(sendPadData, "NETsendPadData");
1008 LoadNetSym1(recvPadData, "NETrecvPadData");
1009 LoadNetSym1(queryPlayer, "NETqueryPlayer");
1010 LoadNetSym1(pause, "NETpause");
1011 LoadNetSym1(resume, "NETresume");
1012 LoadNetSym0(setInfo, "NETsetInfo");
1013 LoadNetSym0(keypressed, "NETkeypressed");
1014 LoadNetSym0(configure, "NETconfigure");
1015 LoadNetSym0(test, "NETtest");
1016 LoadNetSym0(about, "NETabout");
1017
1018 return 0;
1019}
1020
1021#ifdef ENABLE_SIO1API
1022
1023void *hSIO1Driver = NULL;
1024
1025long CALLBACK SIO1__init(void) { return 0; }
1026long CALLBACK SIO1__shutdown(void) { return 0; }
1027long CALLBACK SIO1__open(void) { return 0; }
1028long CALLBACK SIO1__close(void) { return 0; }
1029long CALLBACK SIO1__configure(void) { return 0; }
1030long CALLBACK SIO1__test(void) { return 0; }
1031void CALLBACK SIO1__about(void) {}
1032void CALLBACK SIO1__pause(void) {}
1033void CALLBACK SIO1__resume(void) {}
1034long CALLBACK SIO1__keypressed(int key) { return 0; }
1035void CALLBACK SIO1__writeData8(unsigned char val) {}
1036void CALLBACK SIO1__writeData16(unsigned short val) {}
1037void CALLBACK SIO1__writeData32(unsigned long val) {}
1038void CALLBACK SIO1__writeStat16(unsigned short val) {}
1039void CALLBACK SIO1__writeStat32(unsigned long val) {}
1040void CALLBACK SIO1__writeMode16(unsigned short val) {}
1041void CALLBACK SIO1__writeMode32(unsigned long val) {}
1042void CALLBACK SIO1__writeCtrl16(unsigned short val) {}
1043void CALLBACK SIO1__writeCtrl32(unsigned long val) {}
1044void CALLBACK SIO1__writeBaud16(unsigned short val) {}
1045void CALLBACK SIO1__writeBaud32(unsigned long val) {}
1046unsigned char CALLBACK SIO1__readData8(void) { return 0; }
1047unsigned short CALLBACK SIO1__readData16(void) { return 0; }
1048unsigned long CALLBACK SIO1__readData32(void) { return 0; }
1049unsigned short CALLBACK SIO1__readStat16(void) { return 0; }
1050unsigned long CALLBACK SIO1__readStat32(void) { return 0; }
1051unsigned short CALLBACK SIO1__readMode16(void) { return 0; }
1052unsigned long CALLBACK SIO1__readMode32(void) { return 0; }
1053unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }
1054unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }
1055unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }
1056unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }
1057void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};
1058
1059void CALLBACK SIO1irq(void) {
b17ff6df 1060 psxHu32ref(0x1070) |= SWAPu32(0x100);
fb4bd474 1061}
1062
1063#define LoadSio1Sym1(dest, name) \
b17ff6df 1064 LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);
fb4bd474 1065
1066#define LoadSio1SymN(dest, name) \
b17ff6df 1067 LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);
fb4bd474 1068
1069#define LoadSio1Sym0(dest, name) \
b17ff6df 1070 LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \
1071 if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;
fb4bd474 1072
1073static int LoadSIO1plugin(const char *SIO1dll) {
b17ff6df 1074 void *drv;
1075
1076 hSIO1Driver = SysLoadLibrary(SIO1dll);
1077 if (hSIO1Driver == NULL) {
1078 SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;
1079 }
1080 drv = hSIO1Driver;
1081
1082 LoadSio1Sym0(init, "SIO1init");
1083 LoadSio1Sym0(shutdown, "SIO1shutdown");
1084 LoadSio1Sym0(open, "SIO1open");
1085 LoadSio1Sym0(close, "SIO1close");
1086 LoadSio1Sym0(pause, "SIO1pause");
1087 LoadSio1Sym0(resume, "SIO1resume");
1088 LoadSio1Sym0(keypressed, "SIO1keypressed");
1089 LoadSio1Sym0(configure, "SIO1configure");
1090 LoadSio1Sym0(test, "SIO1test");
1091 LoadSio1Sym0(about, "SIO1about");
1092 LoadSio1Sym0(writeData8, "SIO1writeData8");
1093 LoadSio1Sym0(writeData16, "SIO1writeData16");
1094 LoadSio1Sym0(writeData32, "SIO1writeData32");
1095 LoadSio1Sym0(writeStat16, "SIO1writeStat16");
1096 LoadSio1Sym0(writeStat32, "SIO1writeStat32");
1097 LoadSio1Sym0(writeMode16, "SIO1writeMode16");
1098 LoadSio1Sym0(writeMode32, "SIO1writeMode32");
1099 LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");
1100 LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");
1101 LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");
1102 LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");
1103 LoadSio1Sym0(readData16, "SIO1readData16");
1104 LoadSio1Sym0(readData32, "SIO1readData32");
1105 LoadSio1Sym0(readStat16, "SIO1readStat16");
1106 LoadSio1Sym0(readStat32, "SIO1readStat32");
1107 LoadSio1Sym0(readMode16, "SIO1readMode16");
1108 LoadSio1Sym0(readMode32, "SIO1readMode32");
1109 LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");
1110 LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");
1111 LoadSio1Sym0(readBaud16, "SIO1readBaud16");
1112 LoadSio1Sym0(readBaud32, "SIO1readBaud32");
1113 LoadSio1Sym0(registerCallback, "SIO1registerCallback");
1114
1115 return 0;
fb4bd474 1116}
1117
1118#endif
1119
fb4bd474 1120int LoadPlugins() {
1121 int ret;
13fab97c 1122 char Plugin[MAXPATHLEN * 2];
fb4bd474 1123
1124 ReleasePlugins();
1125 SysLibError();
1126
1127 if (UsingIso()) {
1128 LoadCDRplugin(NULL);
1129 } else {
1130 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
1131 if (LoadCDRplugin(Plugin) == -1) return -1;
1132 }
1133
1134 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);
1135 if (LoadGPUplugin(Plugin) == -1) return -1;
1136
1137 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);
1138 if (LoadSPUplugin(Plugin) == -1) return -1;
1139
1140 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);
1141 if (LoadPAD1plugin(Plugin) == -1) return -1;
1142
1143 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);
1144 if (LoadPAD2plugin(Plugin) == -1) return -1;
1145
1146 if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)
1147 Config.UseNet = FALSE;
1148 else {
1149 Config.UseNet = TRUE;
1150 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);
1151 if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;
1152 }
1153
1154#ifdef ENABLE_SIO1API
1155 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);
1156 if (LoadSIO1plugin(Plugin) == -1) return -1;
1157#endif
1158
1159 ret = CDR_init();
1160 if (ret < 0) { SysMessage (_("Error initializing CD-ROM plugin: %d"), ret); return -1; }
1161 ret = GPU_init();
1162 if (ret < 0) { SysMessage (_("Error initializing GPU plugin: %d"), ret); return -1; }
1163 ret = SPU_init();
1164 if (ret < 0) { SysMessage (_("Error initializing SPU plugin: %d"), ret); return -1; }
1165 ret = PAD1_init(1);
1166 if (ret < 0) { SysMessage (_("Error initializing Controller 1 plugin: %d"), ret); return -1; }
1167 ret = PAD2_init(2);
1168 if (ret < 0) { SysMessage (_("Error initializing Controller 2 plugin: %d"), ret); return -1; }
1169
1170 if (Config.UseNet) {
1171 ret = NET_init();
1172 if (ret < 0) { SysMessage (_("Error initializing NetPlay plugin: %d"), ret); return -1; }
1173 }
1174
1175#ifdef ENABLE_SIO1API
1176 ret = SIO1_init();
1177 if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }
1178#endif
1179
1180 SysPrintf(_("Plugins loaded.\n"));
1181 return 0;
1182}
1183
1184void ReleasePlugins() {
1185 if (Config.UseNet) {
1186 int ret = NET_close();
1187 if (ret < 0) Config.UseNet = FALSE;
1188 }
1189 NetOpened = FALSE;
1190
1191 if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
1192 if (hGPUDriver != NULL) GPU_shutdown();
1193 if (hSPUDriver != NULL) SPU_shutdown();
1194 if (hPAD1Driver != NULL) PAD1_shutdown();
1195 if (hPAD2Driver != NULL) PAD2_shutdown();
1196
1b944575 1197 if (Config.UseNet && hNETDriver != NULL) NET_shutdown();
fb4bd474 1198
cf4334ed 1199 if (hCDRDriver != NULL) { SysCloseLibrary(hCDRDriver); hCDRDriver = NULL; }
1200 if (hGPUDriver != NULL) { SysCloseLibrary(hGPUDriver); hGPUDriver = NULL; }
1201 if (hSPUDriver != NULL) { SysCloseLibrary(hSPUDriver); hSPUDriver = NULL; }
1202 if (hPAD1Driver != NULL) { SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL; }
1203 if (hPAD2Driver != NULL) { SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL; }
fb4bd474 1204
1205 if (Config.UseNet && hNETDriver != NULL) {
1206 SysCloseLibrary(hNETDriver); hNETDriver = NULL;
1207 }
1208
1209#ifdef ENABLE_SIO1API
1210 if (hSIO1Driver != NULL) {
1211 SIO1_shutdown();
1212 SysCloseLibrary(hSIO1Driver);
1213 hSIO1Driver = NULL;
1214 }
1215#endif
1216}
1217
1218// for CD swap
1219int ReloadCdromPlugin()
1220{
1221 if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
cf4334ed 1222 if (hCDRDriver != NULL) { SysCloseLibrary(hCDRDriver); hCDRDriver = NULL; }
fb4bd474 1223
1224 if (UsingIso()) {
1225 LoadCDRplugin(NULL);
1226 } else {
13fab97c 1227 char Plugin[MAXPATHLEN * 2];
fb4bd474 1228 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
1229 if (LoadCDRplugin(Plugin) == -1) return -1;
1230 }
1231
1232 return CDR_init();
1233}
1234
1235void SetIsoFile(const char *filename) {
1236 if (filename == NULL) {
1237 IsoFile[0] = '\0';
1238 return;
1239 }
e6f1e7f7 1240 strncpy(IsoFile, filename, MAXPATHLEN - 1);
fb4bd474 1241}
1242
1243const char *GetIsoFile(void) {
1244 return IsoFile;
1245}
1246
1247boolean UsingIso(void) {
1248 return (IsoFile[0] != '\0');
1249}
1250
1251void SetCdOpenCaseTime(s64 time) {
1252 cdOpenCaseTime = time;
1253}
ARM optimized PCSX fork