372fdd001ee8d83d40c55b07aba9c173e21d9394
[pcsx_rearmed.git] / libpcsxcore / plugins.c
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
27 static char IsoFile[MAXPATHLEN] = "";\r
28 static s64 cdOpenCaseTime = 0;\r
29 \r
30 GPUupdateLace         GPU_updateLace;\r
31 GPUinit               GPU_init;\r
32 GPUshutdown           GPU_shutdown; \r
33 GPUconfigure          GPU_configure;\r
34 GPUtest               GPU_test;\r
35 GPUabout              GPU_about;\r
36 GPUopen               GPU_open;\r
37 GPUclose              GPU_close;\r
38 GPUreadStatus         GPU_readStatus;\r
39 GPUreadData           GPU_readData;\r
40 GPUreadDataMem        GPU_readDataMem;\r
41 GPUwriteStatus        GPU_writeStatus; \r
42 GPUwriteData          GPU_writeData;\r
43 GPUwriteDataMem       GPU_writeDataMem;\r
44 GPUdmaChain           GPU_dmaChain;\r
45 GPUkeypressed         GPU_keypressed;\r
46 GPUdisplayText        GPU_displayText;\r
47 GPUmakeSnapshot       GPU_makeSnapshot;\r
48 GPUfreeze             GPU_freeze;\r
49 GPUgetScreenPic       GPU_getScreenPic;\r
50 GPUshowScreenPic      GPU_showScreenPic;\r
51 GPUclearDynarec       GPU_clearDynarec;\r
52 GPUvBlank             GPU_vBlank;\r
53 \r
54 CDRinit               CDR_init;\r
55 CDRshutdown           CDR_shutdown;\r
56 CDRopen               CDR_open;\r
57 CDRclose              CDR_close; \r
58 CDRtest               CDR_test;\r
59 CDRgetTN              CDR_getTN;\r
60 CDRgetTD              CDR_getTD;\r
61 CDRreadTrack          CDR_readTrack;\r
62 CDRgetBuffer          CDR_getBuffer;\r
63 CDRplay               CDR_play;\r
64 CDRstop               CDR_stop;\r
65 CDRgetStatus          CDR_getStatus;\r
66 CDRgetDriveLetter     CDR_getDriveLetter;\r
67 CDRgetBufferSub       CDR_getBufferSub;\r
68 CDRconfigure          CDR_configure;\r
69 CDRabout              CDR_about;\r
70 CDRsetfilename        CDR_setfilename;\r
71 CDRreadCDDA           CDR_readCDDA;\r
72 CDRgetTE              CDR_getTE;\r
73 \r
74 SPUconfigure          SPU_configure;\r
75 SPUabout              SPU_about;\r
76 SPUinit               SPU_init;\r
77 SPUshutdown           SPU_shutdown;\r
78 SPUtest               SPU_test;\r
79 SPUopen               SPU_open;\r
80 SPUclose              SPU_close;\r
81 SPUplaySample         SPU_playSample;\r
82 SPUwriteRegister      SPU_writeRegister;\r
83 SPUreadRegister       SPU_readRegister;\r
84 SPUwriteDMA           SPU_writeDMA;\r
85 SPUreadDMA            SPU_readDMA;\r
86 SPUwriteDMAMem        SPU_writeDMAMem;\r
87 SPUreadDMAMem         SPU_readDMAMem;\r
88 SPUplayADPCMchannel   SPU_playADPCMchannel;\r
89 SPUfreeze             SPU_freeze;\r
90 SPUregisterCallback   SPU_registerCallback;\r
91 SPUregisterScheduleCb SPU_registerScheduleCb;\r
92 SPUasync              SPU_async;\r
93 SPUplayCDDAchannel    SPU_playCDDAchannel;\r
94 \r
95 PADconfigure          PAD1_configure;\r
96 PADabout              PAD1_about;\r
97 PADinit               PAD1_init;\r
98 PADshutdown           PAD1_shutdown;\r
99 PADtest               PAD1_test;\r
100 PADopen               PAD1_open;\r
101 PADclose              PAD1_close;\r
102 PADquery              PAD1_query;\r
103 PADreadPort1          PAD1_readPort1;\r
104 PADkeypressed         PAD1_keypressed;\r
105 PADstartPoll          PAD1_startPoll;\r
106 PADpoll               PAD1_poll;\r
107 PADsetSensitive       PAD1_setSensitive;\r
108 \r
109 PADconfigure          PAD2_configure;\r
110 PADabout              PAD2_about;\r
111 PADinit               PAD2_init;\r
112 PADshutdown           PAD2_shutdown;\r
113 PADtest               PAD2_test;\r
114 PADopen               PAD2_open;\r
115 PADclose              PAD2_close;\r
116 PADquery              PAD2_query;\r
117 PADreadPort2          PAD2_readPort2;\r
118 PADkeypressed         PAD2_keypressed;\r
119 PADstartPoll          PAD2_startPoll;\r
120 PADpoll               PAD2_poll;\r
121 PADsetSensitive       PAD2_setSensitive;\r
122 \r
123 NETinit               NET_init;\r
124 NETshutdown           NET_shutdown;\r
125 NETopen               NET_open;\r
126 NETclose              NET_close; \r
127 NETtest               NET_test;\r
128 NETconfigure          NET_configure;\r
129 NETabout              NET_about;\r
130 NETpause              NET_pause;\r
131 NETresume             NET_resume;\r
132 NETqueryPlayer        NET_queryPlayer;\r
133 NETsendData           NET_sendData;\r
134 NETrecvData           NET_recvData;\r
135 NETsendPadData        NET_sendPadData;\r
136 NETrecvPadData        NET_recvPadData;\r
137 NETsetInfo            NET_setInfo;\r
138 NETkeypressed         NET_keypressed;\r
139 \r
140 #ifdef ENABLE_SIO1API\r
141 \r
142 SIO1init              SIO1_init;\r
143 SIO1shutdown          SIO1_shutdown;\r
144 SIO1open              SIO1_open;\r
145 SIO1close             SIO1_close; \r
146 SIO1test              SIO1_test;\r
147 SIO1configure         SIO1_configure;\r
148 SIO1about             SIO1_about;\r
149 SIO1pause             SIO1_pause;\r
150 SIO1resume            SIO1_resume;\r
151 SIO1keypressed        SIO1_keypressed;\r
152 SIO1writeData8        SIO1_writeData8;\r
153 SIO1writeData16       SIO1_writeData16;\r
154 SIO1writeData32       SIO1_writeData32;\r
155 SIO1writeStat16       SIO1_writeStat16;\r
156 SIO1writeStat32       SIO1_writeStat32;\r
157 SIO1writeMode16       SIO1_writeMode16;\r
158 SIO1writeMode32       SIO1_writeMode32;\r
159 SIO1writeCtrl16       SIO1_writeCtrl16;\r
160 SIO1writeCtrl32       SIO1_writeCtrl32;\r
161 SIO1writeBaud16       SIO1_writeBaud16;\r
162 SIO1writeBaud32       SIO1_writeBaud32;\r
163 SIO1readData8         SIO1_readData8;\r
164 SIO1readData16        SIO1_readData16;\r
165 SIO1readData32        SIO1_readData32;\r
166 SIO1readStat16        SIO1_readStat16;\r
167 SIO1readStat32        SIO1_readStat32;\r
168 SIO1readMode16        SIO1_readMode16;\r
169 SIO1readMode32        SIO1_readMode32;\r
170 SIO1readCtrl16        SIO1_readCtrl16;\r
171 SIO1readCtrl32        SIO1_readCtrl32;\r
172 SIO1readBaud16        SIO1_readBaud16;\r
173 SIO1readBaud32        SIO1_readBaud32;\r
174 SIO1registerCallback  SIO1_registerCallback;\r
175 \r
176 #endif\r
177 \r
178 static 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
190 void *hGPUDriver = NULL;\r
191 \r
192 void CALLBACK GPU__displayText(char *pText) {\r
193         SysPrintf("%s\n", pText);\r
194 }\r
195 \r
196 long CALLBACK GPU__configure(void) { return 0; }\r
197 long CALLBACK GPU__test(void) { return 0; }\r
198 void CALLBACK GPU__about(void) {}\r
199 void CALLBACK GPU__makeSnapshot(void) {}\r
200 void CALLBACK GPU__keypressed(int key) {}\r
201 long CALLBACK GPU__getScreenPic(unsigned char *pMem) { return -1; }\r
202 long CALLBACK GPU__showScreenPic(unsigned char *pMem) { return -1; }\r
203 void CALLBACK GPU__clearDynarec(void (CALLBACK *callback)(void)) {}\r
204 void CALLBACK GPU__vBlank(int val) {}\r
205 \r
206 #define LoadGpuSym1(dest, name) \\r
207         LoadSym(GPU_##dest, GPU##dest, name, TRUE);\r
208 \r
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
216 static 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
252 void *hCDRDriver = NULL;\r
253 \r
254 long CALLBACK CDR__play(unsigned char *sector) { return 0; }\r
255 long CALLBACK CDR__stop(void) { return 0; }\r
256 \r
257 long 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
266 char* CALLBACK CDR__getDriveLetter(void) { return NULL; }\r
267 long CALLBACK CDR__configure(void) { return 0; }\r
268 long CALLBACK CDR__test(void) { return 0; }\r
269 void CALLBACK CDR__about(void) {}\r
270 long 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
282 static 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
319 void *hSPUDriver = NULL;\r
320 \r
321 long CALLBACK SPU__configure(void) { return 0; }\r
322 void CALLBACK SPU__about(void) {}\r
323 long CALLBACK SPU__test(void) { return 0; }\r
324 void CALLBACK SPU__registerScheduleCb(void (CALLBACK *cb)(unsigned int)) {}\r
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
336 static 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
361         LoadSpuSym0(registerScheduleCb, "SPUregisterScheduleCb");\r
362         LoadSpuSymN(async, "SPUasync");\r
363         LoadSpuSymN(playCDDAchannel, "SPUplayCDDAchannel");\r
364 \r
365         return 0;\r
366 }\r
367 \r
368 void *hPAD1Driver = NULL;\r
369 void *hPAD2Driver = NULL;\r
370 \r
371 static unsigned char buf[256];\r
372 unsigned char stdpar[10] = { 0x00, 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };\r
373 unsigned char mousepar[8] = { 0x00, 0x12, 0x5a, 0xff, 0xff, 0xff, 0xff };\r
374 unsigned char analogpar[9] = { 0x00, 0xff, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };\r
375 unsigned char multitappar[35] = { 0x00, 0x80, 0x5a, 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
376                                                                                                         0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
377                                                                                                         0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
378                                                                                                         0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};\r
379 \r
380 static int bufcount, bufc;\r
381 \r
382 //PadDataS padd1, padd2;\r
383 unsigned char _PADstartPollPort1(PadDataS padd[4]) {\r
384         int i=0;\r
385         int decallage=2;\r
386     bufc = 0;\r
387     PadDataS pad;\r
388     for(i=0;i<4;i++){\r
389         decallage = 2 + (i*8);\r
390         pad = padd[i];\r
391                 switch (pad.controllerType) {\r
392                         case PSE_PAD_TYPE_MOUSE:\r
393                                 multitappar[decallage+1] = 0x12;\r
394                                 multitappar[decallage+2] = 0x5a;\r
395                                 multitappar[decallage+3] = pad.buttonStatus & 0xff;\r
396                                 multitappar[decallage+4] = pad.buttonStatus >> 8;\r
397                                 multitappar[decallage+5] = pad.moveX;\r
398                                 multitappar[decallage+6] = pad.moveY;\r
399 \r
400                                 break;\r
401                         case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)\r
402                                 multitappar[decallage+1] = 0x23;\r
403                                 multitappar[decallage+2] = 0x5a;\r
404                                 multitappar[decallage+3] = pad.buttonStatus & 0xff;\r
405                                 multitappar[decallage+4] = pad.buttonStatus >> 8;\r
406                                 multitappar[decallage+5] = pad.rightJoyX;\r
407                                 multitappar[decallage+6] = pad.rightJoyY;\r
408                                 multitappar[decallage+7] = pad.leftJoyX;\r
409                                 multitappar[decallage+8] = pad.leftJoyY;\r
410 \r
411                                 break;\r
412                         case PSE_PAD_TYPE_ANALOGPAD: // scph1150\r
413                                 multitappar[decallage+1] = 0x73;\r
414                                 multitappar[decallage+2] = 0x5a;\r
415                                 multitappar[decallage+3] = pad.buttonStatus & 0xff;\r
416                                 multitappar[decallage+4] = pad.buttonStatus >> 8;\r
417                                 multitappar[decallage+5] = pad.rightJoyX;\r
418                                 multitappar[decallage+6] = pad.rightJoyY;\r
419                                 multitappar[decallage+7] = pad.leftJoyX;\r
420                                 multitappar[decallage+8] = pad.leftJoyY;\r
421 \r
422                                 break;\r
423                         case PSE_PAD_TYPE_ANALOGJOY: // scph1110\r
424                                 multitappar[decallage+1] = 0x53;\r
425                                 multitappar[decallage+2] = 0x5a;\r
426                                 multitappar[decallage+3] = pad.buttonStatus & 0xff;\r
427                                 multitappar[decallage+4] = pad.buttonStatus >> 8;\r
428                                 multitappar[decallage+5] = pad.rightJoyX;\r
429                                 multitappar[decallage+6] = pad.rightJoyY;\r
430                                 multitappar[decallage+7] = pad.leftJoyX;\r
431                                 multitappar[decallage+8] = pad.leftJoyY;\r
432 \r
433                                 break;\r
434                         case PSE_PAD_TYPE_STANDARD:\r
435                         default:\r
436                                 multitappar[decallage+1] = 0x41;\r
437                                 multitappar[decallage+2] = 0x5a;\r
438                                 multitappar[decallage+3] = pad.buttonStatus & 0xff;\r
439                                 multitappar[decallage+4] = pad.buttonStatus >> 8;\r
440                 }\r
441     }\r
442 \r
443     memcpy(buf, multitappar, 35);\r
444     bufcount = 34;\r
445 \r
446     return buf[bufc++];\r
447 }\r
448 \r
449 unsigned char _PADstartPoll(PadDataS *pad) {\r
450 \r
451     bufc = 0;\r
452 \r
453     switch (pad->controllerType) {\r
454         case PSE_PAD_TYPE_MOUSE:\r
455             mousepar[3] = pad->buttonStatus & 0xff;\r
456             mousepar[4] = pad->buttonStatus >> 8;\r
457             mousepar[5] = pad->moveX;\r
458             mousepar[6] = pad->moveY;\r
459 \r
460             memcpy(buf, mousepar, 7);\r
461             bufcount = 6;\r
462             break;\r
463         case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)\r
464             analogpar[1] = 0x23;\r
465             analogpar[3] = pad->buttonStatus & 0xff;\r
466             analogpar[4] = pad->buttonStatus >> 8;\r
467             analogpar[5] = pad->rightJoyX;\r
468             analogpar[6] = pad->rightJoyY;\r
469             analogpar[7] = pad->leftJoyX;\r
470             analogpar[8] = pad->leftJoyY;\r
471 \r
472             memcpy(buf, analogpar, 9);\r
473             bufcount = 8;\r
474             break;\r
475         case PSE_PAD_TYPE_ANALOGPAD: // scph1150\r
476             analogpar[1] = 0x73;\r
477             analogpar[3] = pad->buttonStatus & 0xff;\r
478             analogpar[4] = pad->buttonStatus >> 8;\r
479             analogpar[5] = pad->rightJoyX;\r
480             analogpar[6] = pad->rightJoyY;\r
481             analogpar[7] = pad->leftJoyX;\r
482             analogpar[8] = pad->leftJoyY;\r
483 \r
484             memcpy(buf, analogpar, 9);\r
485             bufcount = 8;\r
486             break;\r
487         case PSE_PAD_TYPE_ANALOGJOY: // scph1110\r
488             analogpar[1] = 0x53;\r
489             analogpar[3] = pad->buttonStatus & 0xff;\r
490             analogpar[4] = pad->buttonStatus >> 8;\r
491             analogpar[5] = pad->rightJoyX;\r
492             analogpar[6] = pad->rightJoyY;\r
493             analogpar[7] = pad->leftJoyX;\r
494             analogpar[8] = pad->leftJoyY;\r
495 \r
496             memcpy(buf, analogpar, 9);\r
497             bufcount = 8;\r
498             break;\r
499         case PSE_PAD_TYPE_STANDARD:\r
500         default:\r
501             stdpar[3] = pad->buttonStatus & 0xff;\r
502             stdpar[4] = pad->buttonStatus >> 8;\r
503                 memcpy(buf, stdpar, 5);\r
504                 bufcount = 4;\r
505     }\r
506 \r
507     return buf[bufc++];\r
508 }\r
509 \r
510 unsigned char _PADpoll(unsigned char value) {\r
511         if (bufc > bufcount) return 0;\r
512     return buf[bufc++];\r
513 }\r
514 \r
515 // rafraichissement de l'état des boutons sur port 1,\r
516 // int pad dans le code d'origine ne sert a rien...\r
517 unsigned char CALLBACK PAD1__startPoll(int pad) {\r
518         int i=0;\r
519         PadDataS padd[4];\r
520         for(i=0;i<4;i++){\r
521                 PAD1_readPort1(&padd[i],i);\r
522         }\r
523         return _PADstartPollPort1(padd);\r
524 }\r
525 \r
526 unsigned char CALLBACK PAD1__poll(unsigned char value) {\r
527 \r
528 //      if(value !=0){\r
529 //              int i;\r
530 //              printf("%2x  %c\n", value, value);\r
531 //              for (i = 0; i < 35; i++) {\r
532 //                printf("%2x", buf[i]);\r
533 //              }\r
534 //              printf("\n");\r
535 //              }\r
536 \r
537         if(value==42){\r
538                 unsigned char bufmultitap[256];\r
539             memcpy(bufmultitap, multitappar, 3);\r
540             bufcount = 2;\r
541             return bufmultitap[bufc++];\r
542         }else{\r
543                 return _PADpoll(value);\r
544         }\r
545 }\r
546 \r
547 long CALLBACK PAD1__configure(void) { return 0; }\r
548 void CALLBACK PAD1__about(void) {}\r
549 long CALLBACK PAD1__test(void) { return 0; }\r
550 long CALLBACK PAD1__query(void) {\r
551         printf("PAD1__query");\r
552         return 3; }\r
553 long CALLBACK PAD1__keypressed() { return 0; }\r
554 \r
555 #define LoadPad1Sym1(dest, name) \\r
556         LoadSym(PAD1_##dest, PAD##dest, name, TRUE);\r
557 \r
558 #define LoadPad1SymN(dest, name) \\r
559         LoadSym(PAD1_##dest, PAD##dest, name, FALSE);\r
560 \r
561 #define LoadPad1Sym0(dest, name) \\r
562         LoadSym(PAD1_##dest, PAD##dest, name, FALSE); \\r
563         if (PAD1_##dest == NULL) PAD1_##dest = (PAD##dest) PAD1__##dest;\r
564 \r
565 static int LoadPAD1plugin(const char *PAD1dll) {\r
566         void *drv;\r
567 \r
568         hPAD1Driver = SysLoadLibrary(PAD1dll);\r
569         if (hPAD1Driver == NULL) {\r
570                 PAD1_configure = NULL;\r
571                 SysMessage (_("Could not load Controller 1 plugin %s!"), PAD1dll); return -1;\r
572         }\r
573         drv = hPAD1Driver;\r
574         LoadPad1Sym1(init, "PADinit");\r
575         LoadPad1Sym1(shutdown, "PADshutdown");\r
576         LoadPad1Sym1(open, "PADopen");\r
577         LoadPad1Sym1(close, "PADclose");\r
578         LoadPad1Sym0(query, "PADquery");\r
579         LoadPad1Sym1(readPort1, "PADreadPort1");\r
580         LoadPad1Sym0(configure, "PADconfigure");\r
581         LoadPad1Sym0(test, "PADtest");\r
582         LoadPad1Sym0(about, "PADabout");\r
583         LoadPad1Sym0(keypressed, "PADkeypressed");\r
584         LoadPad1Sym0(startPoll, "PADstartPoll");\r
585         LoadPad1Sym0(poll, "PADpoll");\r
586         LoadPad1SymN(setSensitive, "PADsetSensitive");\r
587 \r
588         return 0;\r
589 }\r
590 \r
591 unsigned char CALLBACK PAD2__startPoll(int pad) {\r
592         PadDataS padd;\r
593 \r
594         PAD2_readPort2(&padd);\r
595     \r
596         return _PADstartPoll(&padd);\r
597 }\r
598 \r
599 unsigned char CALLBACK PAD2__poll(unsigned char value) {\r
600         return _PADpoll(value);\r
601 }\r
602 \r
603 long CALLBACK PAD2__configure(void) { return 0; }\r
604 void CALLBACK PAD2__about(void) {}\r
605 long CALLBACK PAD2__test(void) { return 0; }\r
606 long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }\r
607 long CALLBACK PAD2__keypressed() { return 0; }\r
608 \r
609 #define LoadPad2Sym1(dest, name) \\r
610         LoadSym(PAD2_##dest, PAD##dest, name, TRUE);\r
611 \r
612 #define LoadPad2Sym0(dest, name) \\r
613         LoadSym(PAD2_##dest, PAD##dest, name, FALSE); \\r
614         if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;\r
615 \r
616 #define LoadPad2SymN(dest, name) \\r
617         LoadSym(PAD2_##dest, PAD##dest, name, FALSE);\r
618 \r
619 static int LoadPAD2plugin(const char *PAD2dll) {\r
620         void *drv;\r
621 \r
622         hPAD2Driver = SysLoadLibrary(PAD2dll);\r
623         if (hPAD2Driver == NULL) {\r
624                 PAD2_configure = NULL;\r
625                 SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;\r
626         }\r
627         drv = hPAD2Driver;\r
628         LoadPad2Sym1(init, "PADinit");\r
629         LoadPad2Sym1(shutdown, "PADshutdown");\r
630         LoadPad2Sym1(open, "PADopen");\r
631         LoadPad2Sym1(close, "PADclose");\r
632         LoadPad2Sym0(query, "PADquery");\r
633         LoadPad2Sym1(readPort2, "PADreadPort2");\r
634         LoadPad2Sym0(configure, "PADconfigure");\r
635         LoadPad2Sym0(test, "PADtest");\r
636         LoadPad2Sym0(about, "PADabout");\r
637         LoadPad2Sym0(keypressed, "PADkeypressed");\r
638         LoadPad2Sym0(startPoll, "PADstartPoll");\r
639         LoadPad2Sym0(poll, "PADpoll");\r
640         LoadPad2SymN(setSensitive, "PADsetSensitive");\r
641 \r
642         return 0;\r
643 }\r
644 \r
645 void *hNETDriver = NULL;\r
646 \r
647 void CALLBACK NET__setInfo(netInfo *info) {}\r
648 void CALLBACK NET__keypressed(int key) {}\r
649 long CALLBACK NET__configure(void) { return 0; }\r
650 long CALLBACK NET__test(void) { return 0; }\r
651 void CALLBACK NET__about(void) {}\r
652 \r
653 #define LoadNetSym1(dest, name) \\r
654         LoadSym(NET_##dest, NET##dest, name, TRUE);\r
655 \r
656 #define LoadNetSymN(dest, name) \\r
657         LoadSym(NET_##dest, NET##dest, name, FALSE);\r
658 \r
659 #define LoadNetSym0(dest, name) \\r
660         LoadSym(NET_##dest, NET##dest, name, FALSE); \\r
661         if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;\r
662 \r
663 static int LoadNETplugin(const char *NETdll) {\r
664         void *drv;\r
665 \r
666         hNETDriver = SysLoadLibrary(NETdll);\r
667         if (hNETDriver == NULL) {\r
668                 SysMessage (_("Could not load NetPlay plugin %s!"), NETdll); return -1;\r
669         }\r
670         drv = hNETDriver;\r
671         LoadNetSym1(init, "NETinit");\r
672         LoadNetSym1(shutdown, "NETshutdown");\r
673         LoadNetSym1(open, "NETopen");\r
674         LoadNetSym1(close, "NETclose");\r
675         LoadNetSymN(sendData, "NETsendData");\r
676         LoadNetSymN(recvData, "NETrecvData");\r
677         LoadNetSym1(sendPadData, "NETsendPadData");\r
678         LoadNetSym1(recvPadData, "NETrecvPadData");\r
679         LoadNetSym1(queryPlayer, "NETqueryPlayer");\r
680         LoadNetSym1(pause, "NETpause");\r
681         LoadNetSym1(resume, "NETresume");\r
682         LoadNetSym0(setInfo, "NETsetInfo");\r
683         LoadNetSym0(keypressed, "NETkeypressed");\r
684         LoadNetSym0(configure, "NETconfigure");\r
685         LoadNetSym0(test, "NETtest");\r
686         LoadNetSym0(about, "NETabout");\r
687 \r
688         return 0;\r
689 }\r
690 \r
691 #ifdef ENABLE_SIO1API\r
692 \r
693 void *hSIO1Driver = NULL;\r
694 \r
695 long CALLBACK SIO1__init(void) { return 0; }\r
696 long CALLBACK SIO1__shutdown(void) { return 0; }\r
697 long CALLBACK SIO1__open(void) { return 0; }\r
698 long CALLBACK SIO1__close(void) { return 0; }\r
699 long CALLBACK SIO1__configure(void) { return 0; }\r
700 long CALLBACK SIO1__test(void) { return 0; }\r
701 void CALLBACK SIO1__about(void) {}\r
702 void CALLBACK SIO1__pause(void) {}\r
703 void CALLBACK SIO1__resume(void) {}\r
704 long CALLBACK SIO1__keypressed(int key) { return 0; }\r
705 void CALLBACK SIO1__writeData8(unsigned char val) {}\r
706 void CALLBACK SIO1__writeData16(unsigned short val) {}\r
707 void CALLBACK SIO1__writeData32(unsigned long val) {}\r
708 void CALLBACK SIO1__writeStat16(unsigned short val) {}\r
709 void CALLBACK SIO1__writeStat32(unsigned long val) {}\r
710 void CALLBACK SIO1__writeMode16(unsigned short val) {}\r
711 void CALLBACK SIO1__writeMode32(unsigned long val) {}\r
712 void CALLBACK SIO1__writeCtrl16(unsigned short val) {}\r
713 void CALLBACK SIO1__writeCtrl32(unsigned long val) {}\r
714 void CALLBACK SIO1__writeBaud16(unsigned short val) {}\r
715 void CALLBACK SIO1__writeBaud32(unsigned long val) {}\r
716 unsigned char CALLBACK SIO1__readData8(void) { return 0; }\r
717 unsigned short CALLBACK SIO1__readData16(void) { return 0; }\r
718 unsigned long CALLBACK SIO1__readData32(void) { return 0; }\r
719 unsigned short CALLBACK SIO1__readStat16(void) { return 0; }\r
720 unsigned long CALLBACK SIO1__readStat32(void) { return 0; }\r
721 unsigned short CALLBACK SIO1__readMode16(void) { return 0; }\r
722 unsigned long CALLBACK SIO1__readMode32(void) { return 0; }\r
723 unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }\r
724 unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }\r
725 unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }\r
726 unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }\r
727 void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};\r
728 \r
729 void CALLBACK SIO1irq(void) {\r
730     psxHu32ref(0x1070) |= SWAPu32(0x100);\r
731 }\r
732 \r
733 #define LoadSio1Sym1(dest, name) \\r
734     LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);\r
735 \r
736 #define LoadSio1SymN(dest, name) \\r
737     LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);\r
738 \r
739 #define LoadSio1Sym0(dest, name) \\r
740     LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \\r
741     if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;\r
742 \r
743 static int LoadSIO1plugin(const char *SIO1dll) {\r
744     void *drv;\r
745 \r
746     hSIO1Driver = SysLoadLibrary(SIO1dll);\r
747     if (hSIO1Driver == NULL) {\r
748         SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;\r
749     }\r
750     drv = hSIO1Driver;\r
751 \r
752     LoadSio1Sym0(init, "SIO1init");\r
753     LoadSio1Sym0(shutdown, "SIO1shutdown");\r
754     LoadSio1Sym0(open, "SIO1open");\r
755     LoadSio1Sym0(close, "SIO1close");\r
756     LoadSio1Sym0(pause, "SIO1pause");\r
757     LoadSio1Sym0(resume, "SIO1resume");\r
758     LoadSio1Sym0(keypressed, "SIO1keypressed");\r
759     LoadSio1Sym0(configure, "SIO1configure");\r
760     LoadSio1Sym0(test, "SIO1test");\r
761     LoadSio1Sym0(about, "SIO1about");\r
762     LoadSio1Sym0(writeData8, "SIO1writeData8");\r
763     LoadSio1Sym0(writeData16, "SIO1writeData16");\r
764     LoadSio1Sym0(writeData32, "SIO1writeData32");\r
765     LoadSio1Sym0(writeStat16, "SIO1writeStat16");\r
766     LoadSio1Sym0(writeStat32, "SIO1writeStat32");\r
767     LoadSio1Sym0(writeMode16, "SIO1writeMode16");\r
768     LoadSio1Sym0(writeMode32, "SIO1writeMode32");\r
769     LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");\r
770     LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");\r
771     LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");\r
772     LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");\r
773     LoadSio1Sym0(readData16, "SIO1readData16");\r
774     LoadSio1Sym0(readData32, "SIO1readData32");\r
775     LoadSio1Sym0(readStat16, "SIO1readStat16");\r
776     LoadSio1Sym0(readStat32, "SIO1readStat32");\r
777     LoadSio1Sym0(readMode16, "SIO1readMode16");\r
778     LoadSio1Sym0(readMode32, "SIO1readMode32");\r
779     LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");\r
780     LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");\r
781     LoadSio1Sym0(readBaud16, "SIO1readBaud16");\r
782     LoadSio1Sym0(readBaud32, "SIO1readBaud32");\r
783     LoadSio1Sym0(registerCallback, "SIO1registerCallback");\r
784 \r
785     return 0;\r
786 }\r
787 \r
788 #endif\r
789 \r
790 void CALLBACK clearDynarec(void) {\r
791         psxCpu->Reset();\r
792 }\r
793 \r
794 int LoadPlugins() {\r
795         int ret;\r
796         char Plugin[MAXPATHLEN];\r
797 \r
798         ReleasePlugins();\r
799         SysLibError();\r
800 \r
801         if (UsingIso()) {\r
802                 LoadCDRplugin(NULL);\r
803         } else {\r
804                 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);\r
805                 if (LoadCDRplugin(Plugin) == -1) return -1;\r
806         }\r
807 \r
808         sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);\r
809         if (LoadGPUplugin(Plugin) == -1) return -1;\r
810 \r
811         sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);\r
812         if (LoadSPUplugin(Plugin) == -1) return -1;\r
813 \r
814         sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);\r
815         if (LoadPAD1plugin(Plugin) == -1) return -1;\r
816 \r
817         sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);\r
818         if (LoadPAD2plugin(Plugin) == -1) return -1;\r
819 \r
820         if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)\r
821                 Config.UseNet = FALSE;\r
822         else {\r
823                 Config.UseNet = TRUE;\r
824                 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);\r
825                 if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;\r
826         }\r
827 \r
828 #ifdef ENABLE_SIO1API\r
829         sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);\r
830         if (LoadSIO1plugin(Plugin) == -1) return -1;\r
831 #endif\r
832 \r
833         ret = CDR_init();\r
834         if (ret < 0) { SysMessage (_("Error initializing CD-ROM plugin: %d"), ret); return -1; }\r
835         ret = GPU_init();\r
836         if (ret < 0) { SysMessage (_("Error initializing GPU plugin: %d"), ret); return -1; }\r
837         ret = SPU_init();\r
838         if (ret < 0) { SysMessage (_("Error initializing SPU plugin: %d"), ret); return -1; }\r
839         ret = PAD1_init(1);\r
840         if (ret < 0) { SysMessage (_("Error initializing Controller 1 plugin: %d"), ret); return -1; }\r
841         ret = PAD2_init(2);\r
842         if (ret < 0) { SysMessage (_("Error initializing Controller 2 plugin: %d"), ret); return -1; }\r
843 \r
844         if (Config.UseNet) {\r
845                 ret = NET_init();\r
846                 if (ret < 0) { SysMessage (_("Error initializing NetPlay plugin: %d"), ret); return -1; }\r
847         }\r
848 \r
849 #ifdef ENABLE_SIO1API\r
850         ret = SIO1_init();\r
851         if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }\r
852 #endif\r
853 \r
854         SysPrintf(_("Plugins loaded.\n"));\r
855         return 0;\r
856 }\r
857 \r
858 void ReleasePlugins() {\r
859         if (Config.UseNet) {\r
860                 int ret = NET_close();\r
861                 if (ret < 0) Config.UseNet = FALSE;\r
862         }\r
863         NetOpened = FALSE;\r
864 \r
865         if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();\r
866         if (hGPUDriver != NULL) GPU_shutdown();\r
867         if (hSPUDriver != NULL) SPU_shutdown();\r
868         if (hPAD1Driver != NULL) PAD1_shutdown();\r
869         if (hPAD2Driver != NULL) PAD2_shutdown();\r
870 \r
871         if (Config.UseNet && hNETDriver != NULL) NET_shutdown(); \r
872 \r
873         if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;\r
874         if (hGPUDriver != NULL) SysCloseLibrary(hGPUDriver); hGPUDriver = NULL;\r
875         if (hSPUDriver != NULL) SysCloseLibrary(hSPUDriver); hSPUDriver = NULL;\r
876         if (hPAD1Driver != NULL) SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL;\r
877         if (hPAD2Driver != NULL) SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL;\r
878 \r
879         if (Config.UseNet && hNETDriver != NULL) {\r
880                 SysCloseLibrary(hNETDriver); hNETDriver = NULL;\r
881         }\r
882 \r
883 #ifdef ENABLE_SIO1API\r
884         if (hSIO1Driver != NULL) {\r
885                 SIO1_shutdown();\r
886                 SysCloseLibrary(hSIO1Driver);\r
887                 hSIO1Driver = NULL;\r
888         }\r
889 #endif\r
890 }\r
891 \r
892 // for CD swap\r
893 int ReloadCdromPlugin()\r
894 {\r
895         if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();\r
896         if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;\r
897 \r
898         if (UsingIso()) {\r
899                 LoadCDRplugin(NULL);\r
900         } else {\r
901                 char Plugin[MAXPATHLEN];\r
902                 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);\r
903                 if (LoadCDRplugin(Plugin) == -1) return -1;\r
904         }\r
905 \r
906         return CDR_init();\r
907 }\r
908 \r
909 void SetIsoFile(const char *filename) {\r
910         if (filename == NULL) {\r
911                 IsoFile[0] = '\0';\r
912                 return;\r
913         }\r
914         strncpy(IsoFile, filename, MAXPATHLEN);\r
915 }\r
916 \r
917 const char *GetIsoFile(void) {\r
918         return IsoFile;\r
919 }\r
920 \r
921 boolean UsingIso(void) {\r
922         return (IsoFile[0] != '\0');\r
923 }\r
924 \r
925 void SetCdOpenCaseTime(s64 time) {\r
926         cdOpenCaseTime = time;\r
927 }\r