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