notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
fix compilation error
[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;
377static int ledStateReq44[8];\r
29f3675b 378\r
e288923d 379static unsigned char buf[256];\r
52c9fcc8 380unsigned char stdpar[8] = { 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};\r
381unsigned char multitappar[34] = { 0x80, 0x5a,
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,\r
385 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};\r
386 \r
387//response for request 44, 45, 46, 47, 4C, 4D\r
388static unsigned char resp45[8] = {0xF3, 0x5A, 0x01, 0x02, 0x00, 0x02, 0x01, 0x00};\r
389static unsigned char resp46_00[8] = {0xF3, 0x5A, 0x00, 0x00, 0x01, 0x02, 0x00, 0x0A};\r
390static unsigned char resp46_01[8] = {0xF3, 0x5A, 0x00, 0x00, 0x01, 0x01, 0x01, 0x14};\r
391static unsigned char resp47[8] = {0xF3, 0x5A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00};\r
392static unsigned char resp4C_00[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00};\r
393static unsigned char resp4C_01[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00};\r
394static unsigned char resp4D[8] = {0xF3, 0x5A, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF};\r
395
396//fixed reponse of request number 41, 48, 49, 4A, 4B, 4E, 4F
397static unsigned char resp40[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
398static unsigned char resp41[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};\r
399static unsigned char resp44[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
400static unsigned char resp49[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
401static unsigned char resp4A[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
402static unsigned char resp4B[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
403static unsigned char resp4E[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
404static unsigned char resp4F[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
405
406// Resquest of psx core
407enum {
408 // REQUEST
409 // first call of this request for the pad, the pad is configured as an digital pad.
410 // 0x0X, 0x42, 0x0Y, 0xZZ, 0xAA, 0x00, 0x00, 0x00, 0x00
411 // 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)
412 // Y if 1 : psx request the full length response for the multitap, 3 bytes header and 4 block of 8 bytes per pad
413 // Y if 0 : psx request a pad key state
414 // ZZ rumble small motor 00-> OFF, 01 -> ON
415 // AA rumble large motor speed 0x00 -> 0xFF
416 // RESPONSE
417 // header 3 Bytes
418 // 0x00
419 // PadId -> 0x41 for digital pas, 0x73 for analog pad
420 // 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
421 // 6 Bytes for keystates
422 CMD_READ_DATA_AND_VIBRATE = 0x42,
423
424 // REQUEST
425 // Header
426 // 0x0N, 0x43, 0x00, XX, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
427 // XX = 00 -> Normal mode : Seconde bytes of response = padId
428 // XX = 01 -> Configuration mode : Seconde bytes of response = 0xF3
429 // RESPONSE
430 // enter in config mode example :
431 // req : 01 43 00 01 00 00 00 00 00 00
432 // res : 00 41 5A buttons state, analog states
433 // exit config mode :
434 // req : 01 43 00 00 00 00 00 00 00 00
435 // res : 00 F3 5A buttons state, analog states
436 CMD_CONFIG_MODE = 0x43,
437
438 // Set led State
439 // REQUEST
440 // 0x0N, 0x44, 0x00, VAL, SEL, 0x00, 0x00, 0x00, 0x00
441 // If sel = 2 then
442 // VAL = 00 -> OFF
443 // VAL = 01 -> ON
444 // RESPONSE
445 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
446 CMD_SET_MODE_AND_LOCK = 0x44,
447
448 // Get Analog Led state
449 // REQUEST
450 // 0x0N, 0x45, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
451 // RESPONSE
452 // 0x00, 0xF3, 0x5A, 0x01, 0x02, VAL, 0x02, 0x01, 0x00
453 // VAL = 00 Led OFF
454 // VAL = 01 Led ON
455 CMD_QUERY_MODEL_AND_MODE = 0x45,
456
457 //Get Variable A
458 // REQUEST
459 // 0x0N, 0x46, 0x00, 0xXX, 0x00, 0x00, 0x00, 0x00, 0x00
460 // RESPONSE
461 // XX=00
462 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x01, 0x02, 0x00, 0x0A
463 // XX=01
464 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x01, 0x01, 0x01, 0x14
465 CMD_QUERY_ACT = 0x46,
466
467 // REQUEST
468 // 0x0N, 0x47, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
469 // RESPONSE
470 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00
471 CMD_QUERY_COMB = 0x47,
472
473 // REQUEST
474 // 0x0N, 0x4C, 0x00, 0xXX, 0x00, 0x00, 0x00, 0x00, 0x00
475 // RESPONSE
476 // XX = 0
477 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00
478 // XX = 1
479 // 0x00, 0xF3, 0x5A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00
480 CMD_QUERY_MODE = 0x4C,
481
482 // REQUEST
483 // 0x0N, 0x4D, 0x00, 0xAA, 0xBB, 0xCC, 0xDD, 0xEE, 0xFF
484 // RESPONSE
485 // 0x00, 0xF3, 0x5A, old value or
486 // AA = 01 unlock large motor (and swap VAL1 and VAL2)
487 // BB = 01 unlock large motor (default)
488 // CC, DD, EE, FF = all FF -> unlock small motor
489 //
490 // default repsonse for analog pad with 2 motor : 0x00 0xF3 0x5A 0x00 0x01 0xFF 0xFF 0xFF 0xFF
491 //
492 CMD_VIBRATION_TOGGLE = 0x4D,
493 REQ40 = 0x40,
494 REQ41 = 0x41,
495 REQ49 = 0x49,
496 REQ4A = 0x4A,
497 REQ4B = 0x4B,
498 REQ4E = 0x4E,
499 REQ4F = 0x4F
500};
501
502void initBufForRequest(int padIndex, char value){
503 switch (value){\r
504 //Pad keystate already in buffer\r
505 //case CMD_READ_DATA_AND_VIBRATE :\r
506 // break;\r
507 case CMD_CONFIG_MODE :\r
b1fa8177 508 if(pad[padIndex].configMode == 1){\r
52c9fcc8 509 buf[0] = 0xF3;
510 buf[1] = 0x53;\r
511 }\r
512 //else, not in config mode, pad keystate return (already in the buffer)\r
513 break;\r
514 case CMD_SET_MODE_AND_LOCK :\r
515 memcpy(buf, resp44, 8);\r
516 break;\r
517 case CMD_QUERY_MODEL_AND_MODE :\r
518 memcpy(buf, resp45, 8);\r
519 break;\r
520 case CMD_QUERY_ACT :\r
521 memcpy(buf, resp46_00, 8);\r
522 break;\r
523 case CMD_QUERY_COMB :\r
524 memcpy(buf, resp47, 8);\r
525 break;\r
526 case CMD_QUERY_MODE :\r
527 memcpy(buf, resp4C_00, 8);\r
528 break;\r
529 case CMD_VIBRATION_TOGGLE :\r
530 memcpy(buf, resp4D, 8);\r
531 break;\r
532 case REQ40 :\r
533 memcpy(buf, resp40, 8);\r
534 break;\r
535 case REQ41 :\r
536 memcpy(buf, resp41, 8);\r
537 break;\r
538 case REQ49 :\r
539 memcpy(buf, resp49, 8);\r
540 break;\r
541 case REQ4A :\r
542 memcpy(buf, resp4A, 8);\r
543 break;\r
544 case REQ4B :\r
545 memcpy(buf, resp4B, 8);\r
546 break;\r
547 case REQ4E :\r
548 memcpy(buf, resp4E, 8);\r
549 break;\r
550 case REQ4F :\r
551 memcpy(buf, resp4F, 8);\r
552 break;\r
553 }
554}\r
555\r
556void reqIndex2Treatment(int padIndex, char value){\r
557 switch (value){\r
558 case CMD_CONFIG_MODE :\r
559 //0x43\r
560 if(value == 0){\r
b1fa8177 561 pad[padIndex].configMode = 0;\r
52c9fcc8 562 }else{\r
b1fa8177 563 pad->configMode = 1;\r
52c9fcc8 564 }\r
565 break;\r
566 case CMD_SET_MODE_AND_LOCK :\r
567 //0x44 store the led state for change mode if the next value = 0x02\r
568 //0x01 analog ON\r
569 //0x00 analog OFF\r
ef296715 570 ledStateReq44[padIndex] = value;\r
52c9fcc8 571 break;\r
572 case CMD_QUERY_ACT :\r
573 //0x46\r
574 if(value==1){\r
575 memcpy(buf, resp46_01, 8);\r
576 }\r
577 break;\r
578 \r
579 case CMD_QUERY_MODE :\r
580 if(value==1){\r
581 memcpy(buf, resp4C_01, 8);\r
582 }\r
583 break;\r
584 case CMD_VIBRATION_TOGGLE :\r
585 //0x4D\r
586 memcpy(buf, resp4D, 8);\r
587 break;\r
588 case CMD_READ_DATA_AND_VIBRATE:\r
589 //mem the vibration value for small motor;\r
590 pad[padIndex].Vib[0] = value;
591 }\r
592}\r
593
594void vibrate(int padIndex){
595 if(pad[padIndex].Vib[0] != pad[padIndex].VibF[0] || pad[padIndex].Vib[1] != pad[padIndex].VibF[1]){
596 //value is different update Value and call libretro for vibration
597 pad[padIndex].VibF[0] = pad[padIndex].Vib[0];
598 pad[padIndex].VibF[1] = pad[padIndex].Vib[1];
599 plat_trigger_vibrate(padIndex, pad[padIndex].VibF[0], pad[padIndex].VibF[1]);
600 printf("new value for vibration pad %i", padIndex);
601 }
ef296715 602}
603
604//OLD FUNCTION -> DELETE if working
605//Build response for 0x42 request Multitap in port
606//void _PADstartPollMultitap(PadDataS padd[4]) {
607// int i = 0;
608// int offset = 2;
609// PadDataS pad;
610// for(i = 0; i < 4; i++) {
611// offset = 2 + (i * 8);
612// pad = padd[i];
613// switch (pad.controllerType) {
614// case PSE_PAD_TYPE_MOUSE:
615// multitappar[offset] = 0x12;
616// multitappar[offset + 1] = 0x5a;
617// multitappar[offset + 2] = pad.buttonStatus & 0xff;
618// multitappar[offset + 3] = pad.buttonStatus >> 8;
619// multitappar[offset + 4] = pad.moveX;
620// multitappar[offset + 5] = pad.moveY;
621//
622// break;
623// case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)
624// multitappar[offset] = 0x23;
625// multitappar[offset + 1] = 0x5a;
626// multitappar[offset + 2] = pad.buttonStatus & 0xff;
627// multitappar[offset + 3] = pad.buttonStatus >> 8;
628// multitappar[offset + 4] = pad.rightJoyX;
629// multitappar[offset + 5] = pad.rightJoyY;
630// multitappar[offset + 6] = pad.leftJoyX;
631// multitappar[offset + 7] = pad.leftJoyY;
632//
633// break;
634// case PSE_PAD_TYPE_ANALOGPAD: // scph1150
635// multitappar[offset] = 0x73;
636// multitappar[offset + 1] = 0x5a;
637// multitappar[offset + 2] = pad.buttonStatus & 0xff;
638// multitappar[offset + 3] = pad.buttonStatus >> 8;
639// multitappar[offset + 4] = pad.rightJoyX;
640// multitappar[offset + 5] = pad.rightJoyY;
641// multitappar[offset + 6] = pad.leftJoyX;
642// multitappar[offset + 7] = pad.leftJoyY;
643//
644// break;
645// case PSE_PAD_TYPE_ANALOGJOY: // scph1110
646// multitappar[offset] = 0x53;
647// multitappar[offset + 1] = 0x5a;
648// multitappar[offset + 2] = pad.buttonStatus & 0xff;
649// multitappar[offset + 3] = pad.buttonStatus >> 8;
650// multitappar[offset + 4] = pad.rightJoyX;
651// multitappar[offset + 5] = pad.rightJoyY;
652// multitappar[offset + 6] = pad.leftJoyX;
653// multitappar[offset + 7] = pad.leftJoyY;
654//
655// break;
656// case PSE_PAD_TYPE_STANDARD:
657// default:
658// multitappar[offset] = 0x41;
659// multitappar[offset + 1] = 0x5a;
660// multitappar[offset + 2] = pad.buttonStatus & 0xff;
661// multitappar[offset + 3] = pad.buttonStatus >> 8;
662// }
663// }
664// memcpy(buf, multitappar, 34);
665// respSize = 34;
666//}
667
668
52c9fcc8 669
670//Build response for 0x42 request Pad in port\r
671void _PADstartPoll(PadDataS *pad) {\r
ef79bbde
P		 672 switch (pad->controllerType) {\r
673 case PSE_PAD_TYPE_MOUSE:\r
52c9fcc8 674 stdpar[0] = 0x12;\r
675 stdpar[2] = pad->buttonStatus & 0xff;\r
676 stdpar[3] = pad->buttonStatus >> 8;\r
677 stdpar[4] = pad->moveX;\r
678 stdpar[5] = pad->moveY;\r
679 memcpy(buf, stdpar, 6);\r
680 respSize = 6;\r
ef79bbde
P		 681 break;\r
682 case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)\r
52c9fcc8 683 stdpar[0] = 0x23;\r
684 stdpar[2] = pad->buttonStatus & 0xff;\r
685 stdpar[3] = pad->buttonStatus >> 8;\r
686 stdpar[4] = pad->rightJoyX;\r
687 stdpar[5] = pad->rightJoyY;\r
688 stdpar[6] = pad->leftJoyX;\r
689 stdpar[7] = pad->leftJoyY;\r
690 memcpy(buf, stdpar, 8);\r
691 respSize = 8;\r
ef79bbde
P		 692 break;\r
693 case PSE_PAD_TYPE_ANALOGPAD: // scph1150\r
52c9fcc8 694 stdpar[0] = 0x73;\r
695 stdpar[2] = pad->buttonStatus & 0xff;\r
696 stdpar[3] = pad->buttonStatus >> 8;\r
697 stdpar[4] = pad->rightJoyX;\r
698 stdpar[5] = pad->rightJoyY;\r
699 stdpar[6] = pad->leftJoyX;\r
700 stdpar[7] = pad->leftJoyY;\r
701 memcpy(buf, stdpar, 8);\r
702 respSize = 8;\r
ef79bbde
P		 703 break;\r
704 case PSE_PAD_TYPE_ANALOGJOY: // scph1110\r
52c9fcc8 705 stdpar[0] = 0x53;\r
706 stdpar[2] = pad->buttonStatus & 0xff;\r
707 stdpar[3] = pad->buttonStatus >> 8;\r
708 stdpar[4] = pad->rightJoyX;\r
709 stdpar[5] = pad->rightJoyY;\r
710 stdpar[6] = pad->leftJoyX;\r
711 stdpar[7] = pad->leftJoyY;\r
712 memcpy(buf, stdpar, 8);\r
713 respSize = 8;\r
ef79bbde
P		 714 break;\r
715 case PSE_PAD_TYPE_STANDARD:\r
ef296715 716 default:
717 stdpar[0] = 0x41;\r
52c9fcc8 718 stdpar[2] = pad->buttonStatus & 0xff;\r
ef296715 719 stdpar[3] = pad->buttonStatus >> 8;
720 //avoid analog value in multitap mode if change pad type in game.
721 stdpar[4] = 0xff;
722 stdpar[5] = 0xff;
723 stdpar[6] = 0xff;
724 stdpar[7] = 0xff;\r
52c9fcc8 725 memcpy(buf, stdpar, 4);\r
726 respSize = 8;\r
ef79bbde 727 }\r
ef79bbde
P		 728}\r
729\r
ef296715 730
731//Build response for 0x42 request Multitap in port
732//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
733void _PADstartPollMultitap(PadDataS padd[4]) {\r
734 int i = 0;\r
735 int offset = 2;\r
736 PadDataS pad;\r
737 for(i = 0; i < 4; i++) {\r
738 offset = 2 + (i * 8);\r
739 pad = padd[i];\r
740 _PADstartPoll(&pad);
741 memcpy(multitappar+offset, stdpar,pad.controllerType == PSE_PAD_TYPE_STANDARD ?4 : 8);\r
742 }\r
743 memcpy(buf, multitappar, 34);\r
744 respSize = 34;\r
745}\r
52c9fcc8 746\r
747unsigned char _PADpoll(int padIndex, unsigned char value) {
748 \r
749 //If no multitap on the port, we made the full implementation of dualshock protocol\r
750 if(multitap1 == 0){
751 if(reqPos==0){
752 //mem the request number
753 req = value;\r
754 //copy the default value of request response in buffer instead of the keystate\r
755 initBufForRequest(padIndex,value);
756 }\r
757 \r
758 //if no new request the pad return 0xff, for signaling connected\r
759 if ( reqPos >= respSize) return 0xff;\r
760 \r
761 switch(reqPos){\r
762 case 2:\r
763 reqIndex2Treatment(padIndex, value);\r
764 break;\r
765 case 3:\r
766 switch(req) {\r
767 case CMD_SET_MODE_AND_LOCK :\r
768 //change mode on pad\r
769 break;\r
770 case CMD_READ_DATA_AND_VIBRATE:\r
771 //mem the vibration value for Large motor;\r
772 pad[padIndex].Vib[1] = value;\r
773 //vibration
774 vibrate(padIndex);\r
775 break;\r
776 \r
777 break;\r
778 }\r
ef296715 779 }
52c9fcc8 780 }\r
781 return buf[reqPos++];\r
ef79bbde
P		 782}\r
783\r
3b1a5e21 784// refresh the button state on port 1.\r
785// int pad is not needed.\r
52c9fcc8 786unsigned char CALLBACK PAD1__startPoll(int pad) {
787 reqPos = 0;\r
3b1a5e21 788 // first call the pad provide if a multitap is connected between the psx and himself\r
52c9fcc8 789 if(multitap1 == -1){\r
e288923d 790 PadDataS padd;
791 padd.requestPadIndex = 0;\r
792 PAD1_readPort1(&padd);\r
29f3675b 793 multitap1 = padd.portMultitap;\r
794 }\r
795 // just one pad is on port 1 : NO MULTITAP\r
52c9fcc8 796 if (multitap1 == 0){\r
e288923d 797 PadDataS padd;
798 padd.requestPadIndex = 0;\r
799 PAD1_readPort1(&padd);\r
52c9fcc8 800 _PADstartPoll(&padd);\r
3b1a5e21 801 } else {\r
802 // a multitap is plugged : refresh all pad.\r
29f3675b 803 int i=0;\r
804 PadDataS padd[4];\r
e288923d 805 for(i = 0; i < 4; i++) {
806 padd[i].requestPadIndex = i;\r
807 PAD1_readPort1(&padd[i]);\r
52c9fcc8 808 }
809 _PADstartPollMultitap(padd);\r
810 }
811 printf("\n");
812 return 0x00;\r
ef79bbde
P		 813}\r
814\r
52c9fcc8 815unsigned char CALLBACK PAD1__poll(unsigned char value) {
816 char tmp = _PADpoll(0, value);
ef296715 817 printf("%2x:%2x, ",value,tmp);\r
52c9fcc8 818 return tmp;\r
819 \r
ef79bbde
P		 820}\r
821\r
52c9fcc8 822\r
ef79bbde
P		 823long CALLBACK PAD1__configure(void) { return 0; }\r
824void CALLBACK PAD1__about(void) {}\r
825long CALLBACK PAD1__test(void) { return 0; }\r
29f3675b 826long CALLBACK PAD1__query(void) { return 3; }\r
ef79bbde
P		 827long CALLBACK PAD1__keypressed() { return 0; }\r
828\r
829#define LoadPad1Sym1(dest, name) \\r
830 LoadSym(PAD1_##dest, PAD##dest, name, TRUE);\r
831\r
832#define LoadPad1SymN(dest, name) \\r
833 LoadSym(PAD1_##dest, PAD##dest, name, FALSE);\r
834\r
835#define LoadPad1Sym0(dest, name) \\r
836 LoadSym(PAD1_##dest, PAD##dest, name, FALSE); \\r
837 if (PAD1_##dest == NULL) PAD1_##dest = (PAD##dest) PAD1__##dest;\r
838\r
839static int LoadPAD1plugin(const char *PAD1dll) {\r
840 void *drv;\r
841\r
842 hPAD1Driver = SysLoadLibrary(PAD1dll);\r
843 if (hPAD1Driver == NULL) {\r
844 PAD1_configure = NULL;\r
845 SysMessage (_("Could not load Controller 1 plugin %s!"), PAD1dll); return -1;\r
846 }\r
847 drv = hPAD1Driver;\r
848 LoadPad1Sym1(init, "PADinit");\r
849 LoadPad1Sym1(shutdown, "PADshutdown");\r
850 LoadPad1Sym1(open, "PADopen");\r
851 LoadPad1Sym1(close, "PADclose");\r
852 LoadPad1Sym0(query, "PADquery");\r
853 LoadPad1Sym1(readPort1, "PADreadPort1");\r
854 LoadPad1Sym0(configure, "PADconfigure");\r
855 LoadPad1Sym0(test, "PADtest");\r
856 LoadPad1Sym0(about, "PADabout");\r
857 LoadPad1Sym0(keypressed, "PADkeypressed");\r
858 LoadPad1Sym0(startPoll, "PADstartPoll");\r
859 LoadPad1Sym0(poll, "PADpoll");\r
860 LoadPad1SymN(setSensitive, "PADsetSensitive");\r
861\r
862 return 0;\r
863}\r
864\r
52c9fcc8 865unsigned char CALLBACK PAD2__startPoll(int pad) {
866 reqPos = 0;\r
867 int pad_index = 0;
868 if(multitap1 == 1){
869 pad_index+=4;
870 }else{
871 pad_index=1;
872 }
873 //first call the pad provide if a multitap is connected between the psx and himself
874 if(multitap2 == -1){
e288923d 875 PadDataS padd;
52c9fcc8 876 padd.requestPadIndex = pad_index;
877 PAD2_readPort2(&padd);
878 multitap2 = padd.portMultitap;
879 }
880 \r
881 // just one pad is on port 1 : NO MULTITAP\r
882 if (multitap2 == 0){
e288923d 883 PadDataS padd;
52c9fcc8 884 padd.requestPadIndex = pad_index;
e288923d 885 PAD2_readPort2(&padd);\r
52c9fcc8 886 _PADstartPoll(&padd);\r
887 } else {\r
888 // a multitap is plugged : refresh all pad.\r
889 //a multitap is plugged : refresh all pad.
890 int i=0;
891 PadDataS padd[4];
e288923d 892 for(i=0;i<4;i++){
52c9fcc8 893 padd[i].requestPadIndex = i+pad_index;
894 PAD2_readPort2(&padd[i]);
895 }
896 _PADstartPollMultitap(padd);\r
897 }
898 return 0x00;\r
ef79bbde
P		 899}\r
900\r
901unsigned char CALLBACK PAD2__poll(unsigned char value) {\r
52c9fcc8 902 return _PADpoll(1,value);\r
ef79bbde
P		 903}\r
904\r
905long CALLBACK PAD2__configure(void) { return 0; }\r
906void CALLBACK PAD2__about(void) {}\r
907long CALLBACK PAD2__test(void) { return 0; }\r
908long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }\r
909long CALLBACK PAD2__keypressed() { return 0; }\r
910\r
911#define LoadPad2Sym1(dest, name) \\r
912 LoadSym(PAD2_##dest, PAD##dest, name, TRUE);\r
913\r
914#define LoadPad2Sym0(dest, name) \\r
915 LoadSym(PAD2_##dest, PAD##dest, name, FALSE); \\r
916 if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;\r
917\r
918#define LoadPad2SymN(dest, name) \\r
919 LoadSym(PAD2_##dest, PAD##dest, name, FALSE);\r
920\r
921static int LoadPAD2plugin(const char *PAD2dll) {\r
922 void *drv;\r
923\r
924 hPAD2Driver = SysLoadLibrary(PAD2dll);\r
925 if (hPAD2Driver == NULL) {\r
926 PAD2_configure = NULL;\r
927 SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;\r
928 }\r
929 drv = hPAD2Driver;\r
930 LoadPad2Sym1(init, "PADinit");\r
931 LoadPad2Sym1(shutdown, "PADshutdown");\r
932 LoadPad2Sym1(open, "PADopen");\r
933 LoadPad2Sym1(close, "PADclose");\r
934 LoadPad2Sym0(query, "PADquery");\r
935 LoadPad2Sym1(readPort2, "PADreadPort2");\r
936 LoadPad2Sym0(configure, "PADconfigure");\r
937 LoadPad2Sym0(test, "PADtest");\r
938 LoadPad2Sym0(about, "PADabout");\r
939 LoadPad2Sym0(keypressed, "PADkeypressed");\r
940 LoadPad2Sym0(startPoll, "PADstartPoll");\r
941 LoadPad2Sym0(poll, "PADpoll");\r
942 LoadPad2SymN(setSensitive, "PADsetSensitive");\r
943\r
944 return 0;\r
945}\r
946\r
947void *hNETDriver = NULL;\r
948\r
949void CALLBACK NET__setInfo(netInfo *info) {}\r
950void CALLBACK NET__keypressed(int key) {}\r
951long CALLBACK NET__configure(void) { return 0; }\r
952long CALLBACK NET__test(void) { return 0; }\r
953void CALLBACK NET__about(void) {}\r
954\r
955#define LoadNetSym1(dest, name) \\r
956 LoadSym(NET_##dest, NET##dest, name, TRUE);\r
957\r
958#define LoadNetSymN(dest, name) \\r
959 LoadSym(NET_##dest, NET##dest, name, FALSE);\r
960\r
961#define LoadNetSym0(dest, name) \\r
962 LoadSym(NET_##dest, NET##dest, name, FALSE); \\r
963 if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;\r
964\r
965static int LoadNETplugin(const char *NETdll) {\r
966 void *drv;\r
967\r
968 hNETDriver = SysLoadLibrary(NETdll);\r
969 if (hNETDriver == NULL) {\r
970 SysMessage (_("Could not load NetPlay plugin %s!"), NETdll); return -1;\r
971 }\r
972 drv = hNETDriver;\r
973 LoadNetSym1(init, "NETinit");\r
974 LoadNetSym1(shutdown, "NETshutdown");\r
975 LoadNetSym1(open, "NETopen");\r
976 LoadNetSym1(close, "NETclose");\r
977 LoadNetSymN(sendData, "NETsendData");\r
978 LoadNetSymN(recvData, "NETrecvData");\r
979 LoadNetSym1(sendPadData, "NETsendPadData");\r
980 LoadNetSym1(recvPadData, "NETrecvPadData");\r
981 LoadNetSym1(queryPlayer, "NETqueryPlayer");\r
982 LoadNetSym1(pause, "NETpause");\r
983 LoadNetSym1(resume, "NETresume");\r
984 LoadNetSym0(setInfo, "NETsetInfo");\r
985 LoadNetSym0(keypressed, "NETkeypressed");\r
986 LoadNetSym0(configure, "NETconfigure");\r
987 LoadNetSym0(test, "NETtest");\r
988 LoadNetSym0(about, "NETabout");\r
989\r
990 return 0;\r
991}\r
992\r
993#ifdef ENABLE_SIO1API\r
994\r
995void *hSIO1Driver = NULL;\r
996\r
997long CALLBACK SIO1__init(void) { return 0; }\r
998long CALLBACK SIO1__shutdown(void) { return 0; }\r
999long CALLBACK SIO1__open(void) { return 0; }\r
1000long CALLBACK SIO1__close(void) { return 0; }\r
1001long CALLBACK SIO1__configure(void) { return 0; }\r
1002long CALLBACK SIO1__test(void) { return 0; }\r
1003void CALLBACK SIO1__about(void) {}\r
1004void CALLBACK SIO1__pause(void) {}\r
1005void CALLBACK SIO1__resume(void) {}\r
1006long CALLBACK SIO1__keypressed(int key) { return 0; }\r
1007void CALLBACK SIO1__writeData8(unsigned char val) {}\r
1008void CALLBACK SIO1__writeData16(unsigned short val) {}\r
1009void CALLBACK SIO1__writeData32(unsigned long val) {}\r
1010void CALLBACK SIO1__writeStat16(unsigned short val) {}\r
1011void CALLBACK SIO1__writeStat32(unsigned long val) {}\r
1012void CALLBACK SIO1__writeMode16(unsigned short val) {}\r
1013void CALLBACK SIO1__writeMode32(unsigned long val) {}\r
1014void CALLBACK SIO1__writeCtrl16(unsigned short val) {}\r
1015void CALLBACK SIO1__writeCtrl32(unsigned long val) {}\r
1016void CALLBACK SIO1__writeBaud16(unsigned short val) {}\r
1017void CALLBACK SIO1__writeBaud32(unsigned long val) {}\r
1018unsigned char CALLBACK SIO1__readData8(void) { return 0; }\r
1019unsigned short CALLBACK SIO1__readData16(void) { return 0; }\r
1020unsigned long CALLBACK SIO1__readData32(void) { return 0; }\r
1021unsigned short CALLBACK SIO1__readStat16(void) { return 0; }\r
1022unsigned long CALLBACK SIO1__readStat32(void) { return 0; }\r
1023unsigned short CALLBACK SIO1__readMode16(void) { return 0; }\r
1024unsigned long CALLBACK SIO1__readMode32(void) { return 0; }\r
1025unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }\r
1026unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }\r
1027unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }\r
1028unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }\r
1029void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};\r
1030\r
1031void CALLBACK SIO1irq(void) {\r
1032 psxHu32ref(0x1070) |= SWAPu32(0x100);\r
1033}\r
1034\r
1035#define LoadSio1Sym1(dest, name) \\r
1036 LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);\r
1037\r
1038#define LoadSio1SymN(dest, name) \\r
1039 LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);\r
1040\r
1041#define LoadSio1Sym0(dest, name) \\r
1042 LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \\r
1043 if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;\r
1044\r
1045static int LoadSIO1plugin(const char *SIO1dll) {\r
1046 void *drv;\r
1047\r
1048 hSIO1Driver = SysLoadLibrary(SIO1dll);\r
1049 if (hSIO1Driver == NULL) {\r
1050 SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;\r
1051 }\r
1052 drv = hSIO1Driver;\r
1053\r
1054 LoadSio1Sym0(init, "SIO1init");\r
1055 LoadSio1Sym0(shutdown, "SIO1shutdown");\r
1056 LoadSio1Sym0(open, "SIO1open");\r
1057 LoadSio1Sym0(close, "SIO1close");\r
1058 LoadSio1Sym0(pause, "SIO1pause");\r
1059 LoadSio1Sym0(resume, "SIO1resume");\r
1060 LoadSio1Sym0(keypressed, "SIO1keypressed");\r
1061 LoadSio1Sym0(configure, "SIO1configure");\r
1062 LoadSio1Sym0(test, "SIO1test");\r
1063 LoadSio1Sym0(about, "SIO1about");\r
1064 LoadSio1Sym0(writeData8, "SIO1writeData8");\r
1065 LoadSio1Sym0(writeData16, "SIO1writeData16");\r
1066 LoadSio1Sym0(writeData32, "SIO1writeData32");\r
1067 LoadSio1Sym0(writeStat16, "SIO1writeStat16");\r
1068 LoadSio1Sym0(writeStat32, "SIO1writeStat32");\r
1069 LoadSio1Sym0(writeMode16, "SIO1writeMode16");\r
1070 LoadSio1Sym0(writeMode32, "SIO1writeMode32");\r
1071 LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");\r
1072 LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");\r
1073 LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");\r
1074 LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");\r
1075 LoadSio1Sym0(readData16, "SIO1readData16");\r
1076 LoadSio1Sym0(readData32, "SIO1readData32");\r
1077 LoadSio1Sym0(readStat16, "SIO1readStat16");\r
1078 LoadSio1Sym0(readStat32, "SIO1readStat32");\r
1079 LoadSio1Sym0(readMode16, "SIO1readMode16");\r
1080 LoadSio1Sym0(readMode32, "SIO1readMode32");\r
1081 LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");\r
1082 LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");\r
1083 LoadSio1Sym0(readBaud16, "SIO1readBaud16");\r
1084 LoadSio1Sym0(readBaud32, "SIO1readBaud32");\r
1085 LoadSio1Sym0(registerCallback, "SIO1registerCallback");\r
1086\r
1087 return 0;\r
1088}\r
1089\r
1090#endif\r
1091\r
1092void CALLBACK clearDynarec(void) {\r
1093 psxCpu->Reset();\r
1094}\r
1095\r
1096int LoadPlugins() {\r
1097 int ret;\r
1098 char Plugin[MAXPATHLEN];\r
1099\r
1100 ReleasePlugins();\r
b2058a5b 1101 SysLibError();\r
ef79bbde
P		 1102\r
1103 if (UsingIso()) {\r
1104 LoadCDRplugin(NULL);\r
1105 } else {\r
1106 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);\r
1107 if (LoadCDRplugin(Plugin) == -1) return -1;\r
1108 }\r
1109\r
1110 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);\r
1111 if (LoadGPUplugin(Plugin) == -1) return -1;\r
1112\r
1113 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);\r
1114 if (LoadSPUplugin(Plugin) == -1) return -1;\r
1115\r
1116 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);\r
1117 if (LoadPAD1plugin(Plugin) == -1) return -1;\r
1118\r
1119 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);\r
1120 if (LoadPAD2plugin(Plugin) == -1) return -1;\r
1121\r
1122 if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)\r
1123 Config.UseNet = FALSE;\r
1124 else {\r
1125 Config.UseNet = TRUE;\r
1126 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);\r
1127 if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;\r
1128 }\r
1129\r
1130#ifdef ENABLE_SIO1API\r
1131 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);\r
1132 if (LoadSIO1plugin(Plugin) == -1) return -1;\r
1133#endif\r
1134\r
1135 ret = CDR_init();\r
1136 if (ret < 0) { SysMessage (_("Error initializing CD-ROM plugin: %d"), ret); return -1; }\r
1137 ret = GPU_init();\r
1138 if (ret < 0) { SysMessage (_("Error initializing GPU plugin: %d"), ret); return -1; }\r
1139 ret = SPU_init();\r
1140 if (ret < 0) { SysMessage (_("Error initializing SPU plugin: %d"), ret); return -1; }\r
1141 ret = PAD1_init(1);\r
1142 if (ret < 0) { SysMessage (_("Error initializing Controller 1 plugin: %d"), ret); return -1; }\r
1143 ret = PAD2_init(2);\r
1144 if (ret < 0) { SysMessage (_("Error initializing Controller 2 plugin: %d"), ret); return -1; }\r
1145\r
1146 if (Config.UseNet) {\r
1147 ret = NET_init();\r
1148 if (ret < 0) { SysMessage (_("Error initializing NetPlay plugin: %d"), ret); return -1; }\r
1149 }\r
1150\r
1151#ifdef ENABLE_SIO1API\r
1152 ret = SIO1_init();\r
1153 if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }\r
1154#endif\r
1155\r
1156 SysPrintf(_("Plugins loaded.\n"));\r
1157 return 0;\r
1158}\r
1159\r
1160void ReleasePlugins() {\r
1161 if (Config.UseNet) {\r
1162 int ret = NET_close();\r
1163 if (ret < 0) Config.UseNet = FALSE;\r
1164 }\r
1165 NetOpened = FALSE;\r
1166\r
1167 if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();\r
1168 if (hGPUDriver != NULL) GPU_shutdown();\r
1169 if (hSPUDriver != NULL) SPU_shutdown();\r
1170 if (hPAD1Driver != NULL) PAD1_shutdown();\r
1171 if (hPAD2Driver != NULL) PAD2_shutdown();\r
1172\r
1173 if (Config.UseNet && hNETDriver != NULL) NET_shutdown(); \r
1174\r
1175 if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;\r
1176 if (hGPUDriver != NULL) SysCloseLibrary(hGPUDriver); hGPUDriver = NULL;\r
1177 if (hSPUDriver != NULL) SysCloseLibrary(hSPUDriver); hSPUDriver = NULL;\r
1178 if (hPAD1Driver != NULL) SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL;\r
1179 if (hPAD2Driver != NULL) SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL;\r
1180\r
1181 if (Config.UseNet && hNETDriver != NULL) {\r
1182 SysCloseLibrary(hNETDriver); hNETDriver = NULL;\r
1183 }\r
1184\r
1185#ifdef ENABLE_SIO1API\r
1186 if (hSIO1Driver != NULL) {\r
1187 SIO1_shutdown();\r
1188 SysCloseLibrary(hSIO1Driver);\r
1189 hSIO1Driver = NULL;\r
1190 }\r
1191#endif\r
1192}\r
1193\r
1df403c5 1194// for CD swap\r
1195int ReloadCdromPlugin()\r
1196{\r
1197 if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();\r
1198 if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;\r
1199\r
1200 if (UsingIso()) {\r
1201 LoadCDRplugin(NULL);\r
1202 } else {\r
1203 char Plugin[MAXPATHLEN];\r
1204 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);\r
1205 if (LoadCDRplugin(Plugin) == -1) return -1;\r
1206 }\r
1207\r
1208 return CDR_init();\r
1209}\r
1210\r
ef79bbde
P		 1211void SetIsoFile(const char *filename) {\r
1212 if (filename == NULL) {\r
1213 IsoFile[0] = '\0';\r
1214 return;\r
1215 }\r
1216 strncpy(IsoFile, filename, MAXPATHLEN);\r
1217}\r
1218\r
1219const char *GetIsoFile(void) {\r
1220 return IsoFile;\r
1221}\r
1222\r
1223boolean UsingIso(void) {\r
1224 return (IsoFile[0] != '\0');\r
1225}\r
1226\r
1227void SetCdOpenCaseTime(s64 time) {\r
1228 cdOpenCaseTime = time;\r
1229}\r
ARM optimized PCSX fork