notaz.gp2x.de / pcsx_rearmed.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
refactor some code + bug fix
[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]);
0b4dc26d 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 }
0b4dc26d 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 }
ef296715 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;
0b4dc26d 829 if(multitap2 == 2){
830 pad_index += 4;
52c9fcc8 831 }else{
0b4dc26d 832 pad_index = 1;
52c9fcc8 833 }
834 //first call the pad provide if a multitap is connected between the psx and himself
835 if(multitap2 == -1){
e288923d 836 PadDataS padd;
52c9fcc8 837 padd.requestPadIndex = pad_index;
838 PAD2_readPort2(&padd);
839 multitap2 = padd.portMultitap;
840 }
841 \r
842 // just one pad is on port 1 : NO MULTITAP\r
843 if (multitap2 == 0){
e288923d 844 PadDataS padd;
52c9fcc8 845 padd.requestPadIndex = pad_index;
e288923d 846 PAD2_readPort2(&padd);\r
52c9fcc8 847 _PADstartPoll(&padd);\r
848 } else {\r
849 // a multitap is plugged : refresh all pad.\r
850 //a multitap is plugged : refresh all pad.
851 int i=0;
852 PadDataS padd[4];
e288923d 853 for(i=0;i<4;i++){
52c9fcc8 854 padd[i].requestPadIndex = i+pad_index;
855 PAD2_readPort2(&padd[i]);
856 }
857 _PADstartPollMultitap(padd);\r
858 }
0b4dc26d 859 printf("\npad 2 : ");
52c9fcc8 860 return 0x00;\r
ef79bbde
P		 861}\r
862\r
863unsigned char CALLBACK PAD2__poll(unsigned char value) {\r
0b4dc26d 864 char tmp;
865 if(multitap2 == 2){
866 tmp = _PADpollMultitap(1, value);
867 }else{
868 tmp = _PADpoll(1, value);
869 }
870 printf("%2x:%2x, ",value,tmp);\r
871 return tmp;\r
ef79bbde
P		 872}\r
873\r
874long CALLBACK PAD2__configure(void) { return 0; }\r
875void CALLBACK PAD2__about(void) {}\r
876long CALLBACK PAD2__test(void) { return 0; }\r
877long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }\r
878long CALLBACK PAD2__keypressed() { return 0; }\r
879\r
880#define LoadPad2Sym1(dest, name) \\r
881 LoadSym(PAD2_##dest, PAD##dest, name, TRUE);\r
882\r
883#define LoadPad2Sym0(dest, name) \\r
884 LoadSym(PAD2_##dest, PAD##dest, name, FALSE); \\r
885 if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;\r
886\r
887#define LoadPad2SymN(dest, name) \\r
888 LoadSym(PAD2_##dest, PAD##dest, name, FALSE);\r
889\r
890static int LoadPAD2plugin(const char *PAD2dll) {\r
891 void *drv;\r
892\r
893 hPAD2Driver = SysLoadLibrary(PAD2dll);\r
894 if (hPAD2Driver == NULL) {\r
895 PAD2_configure = NULL;\r
896 SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;\r
897 }\r
898 drv = hPAD2Driver;\r
899 LoadPad2Sym1(init, "PADinit");\r
900 LoadPad2Sym1(shutdown, "PADshutdown");\r
901 LoadPad2Sym1(open, "PADopen");\r
902 LoadPad2Sym1(close, "PADclose");\r
903 LoadPad2Sym0(query, "PADquery");\r
904 LoadPad2Sym1(readPort2, "PADreadPort2");\r
905 LoadPad2Sym0(configure, "PADconfigure");\r
906 LoadPad2Sym0(test, "PADtest");\r
907 LoadPad2Sym0(about, "PADabout");\r
908 LoadPad2Sym0(keypressed, "PADkeypressed");\r
909 LoadPad2Sym0(startPoll, "PADstartPoll");\r
910 LoadPad2Sym0(poll, "PADpoll");\r
911 LoadPad2SymN(setSensitive, "PADsetSensitive");\r
912\r
913 return 0;\r
914}\r
915\r
916void *hNETDriver = NULL;\r
917\r
918void CALLBACK NET__setInfo(netInfo *info) {}\r
919void CALLBACK NET__keypressed(int key) {}\r
920long CALLBACK NET__configure(void) { return 0; }\r
921long CALLBACK NET__test(void) { return 0; }\r
922void CALLBACK NET__about(void) {}\r
923\r
924#define LoadNetSym1(dest, name) \\r
925 LoadSym(NET_##dest, NET##dest, name, TRUE);\r
926\r
927#define LoadNetSymN(dest, name) \\r
928 LoadSym(NET_##dest, NET##dest, name, FALSE);\r
929\r
930#define LoadNetSym0(dest, name) \\r
931 LoadSym(NET_##dest, NET##dest, name, FALSE); \\r
932 if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;\r
933\r
934static int LoadNETplugin(const char *NETdll) {\r
935 void *drv;\r
936\r
937 hNETDriver = SysLoadLibrary(NETdll);\r
938 if (hNETDriver == NULL) {\r
939 SysMessage (_("Could not load NetPlay plugin %s!"), NETdll); return -1;\r
940 }\r
941 drv = hNETDriver;\r
942 LoadNetSym1(init, "NETinit");\r
943 LoadNetSym1(shutdown, "NETshutdown");\r
944 LoadNetSym1(open, "NETopen");\r
945 LoadNetSym1(close, "NETclose");\r
946 LoadNetSymN(sendData, "NETsendData");\r
947 LoadNetSymN(recvData, "NETrecvData");\r
948 LoadNetSym1(sendPadData, "NETsendPadData");\r
949 LoadNetSym1(recvPadData, "NETrecvPadData");\r
950 LoadNetSym1(queryPlayer, "NETqueryPlayer");\r
951 LoadNetSym1(pause, "NETpause");\r
952 LoadNetSym1(resume, "NETresume");\r
953 LoadNetSym0(setInfo, "NETsetInfo");\r
954 LoadNetSym0(keypressed, "NETkeypressed");\r
955 LoadNetSym0(configure, "NETconfigure");\r
956 LoadNetSym0(test, "NETtest");\r
957 LoadNetSym0(about, "NETabout");\r
958\r
959 return 0;\r
960}\r
961\r
962#ifdef ENABLE_SIO1API\r
963\r
964void *hSIO1Driver = NULL;\r
965\r
966long CALLBACK SIO1__init(void) { return 0; }\r
967long CALLBACK SIO1__shutdown(void) { return 0; }\r
968long CALLBACK SIO1__open(void) { return 0; }\r
969long CALLBACK SIO1__close(void) { return 0; }\r
970long CALLBACK SIO1__configure(void) { return 0; }\r
971long CALLBACK SIO1__test(void) { return 0; }\r
972void CALLBACK SIO1__about(void) {}\r
973void CALLBACK SIO1__pause(void) {}\r
974void CALLBACK SIO1__resume(void) {}\r
975long CALLBACK SIO1__keypressed(int key) { return 0; }\r
976void CALLBACK SIO1__writeData8(unsigned char val) {}\r
977void CALLBACK SIO1__writeData16(unsigned short val) {}\r
978void CALLBACK SIO1__writeData32(unsigned long val) {}\r
979void CALLBACK SIO1__writeStat16(unsigned short val) {}\r
980void CALLBACK SIO1__writeStat32(unsigned long val) {}\r
981void CALLBACK SIO1__writeMode16(unsigned short val) {}\r
982void CALLBACK SIO1__writeMode32(unsigned long val) {}\r
983void CALLBACK SIO1__writeCtrl16(unsigned short val) {}\r
984void CALLBACK SIO1__writeCtrl32(unsigned long val) {}\r
985void CALLBACK SIO1__writeBaud16(unsigned short val) {}\r
986void CALLBACK SIO1__writeBaud32(unsigned long val) {}\r
987unsigned char CALLBACK SIO1__readData8(void) { return 0; }\r
988unsigned short CALLBACK SIO1__readData16(void) { return 0; }\r
989unsigned long CALLBACK SIO1__readData32(void) { return 0; }\r
990unsigned short CALLBACK SIO1__readStat16(void) { return 0; }\r
991unsigned long CALLBACK SIO1__readStat32(void) { return 0; }\r
992unsigned short CALLBACK SIO1__readMode16(void) { return 0; }\r
993unsigned long CALLBACK SIO1__readMode32(void) { return 0; }\r
994unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }\r
995unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }\r
996unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }\r
997unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }\r
998void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};\r
999\r
1000void CALLBACK SIO1irq(void) {\r
1001 psxHu32ref(0x1070) |= SWAPu32(0x100);\r
1002}\r
1003\r
1004#define LoadSio1Sym1(dest, name) \\r
1005 LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);\r
1006\r
1007#define LoadSio1SymN(dest, name) \\r
1008 LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);\r
1009\r
1010#define LoadSio1Sym0(dest, name) \\r
1011 LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \\r
1012 if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;\r
1013\r
1014static int LoadSIO1plugin(const char *SIO1dll) {\r
1015 void *drv;\r
1016\r
1017 hSIO1Driver = SysLoadLibrary(SIO1dll);\r
1018 if (hSIO1Driver == NULL) {\r
1019 SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;\r
1020 }\r
1021 drv = hSIO1Driver;\r
1022\r
1023 LoadSio1Sym0(init, "SIO1init");\r
1024 LoadSio1Sym0(shutdown, "SIO1shutdown");\r
1025 LoadSio1Sym0(open, "SIO1open");\r
1026 LoadSio1Sym0(close, "SIO1close");\r
1027 LoadSio1Sym0(pause, "SIO1pause");\r
1028 LoadSio1Sym0(resume, "SIO1resume");\r
1029 LoadSio1Sym0(keypressed, "SIO1keypressed");\r
1030 LoadSio1Sym0(configure, "SIO1configure");\r
1031 LoadSio1Sym0(test, "SIO1test");\r
1032 LoadSio1Sym0(about, "SIO1about");\r
1033 LoadSio1Sym0(writeData8, "SIO1writeData8");\r
1034 LoadSio1Sym0(writeData16, "SIO1writeData16");\r
1035 LoadSio1Sym0(writeData32, "SIO1writeData32");\r
1036 LoadSio1Sym0(writeStat16, "SIO1writeStat16");\r
1037 LoadSio1Sym0(writeStat32, "SIO1writeStat32");\r
1038 LoadSio1Sym0(writeMode16, "SIO1writeMode16");\r
1039 LoadSio1Sym0(writeMode32, "SIO1writeMode32");\r
1040 LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");\r
1041 LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");\r
1042 LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");\r
1043 LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");\r
1044 LoadSio1Sym0(readData16, "SIO1readData16");\r
1045 LoadSio1Sym0(readData32, "SIO1readData32");\r
1046 LoadSio1Sym0(readStat16, "SIO1readStat16");\r
1047 LoadSio1Sym0(readStat32, "SIO1readStat32");\r
1048 LoadSio1Sym0(readMode16, "SIO1readMode16");\r
1049 LoadSio1Sym0(readMode32, "SIO1readMode32");\r
1050 LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");\r
1051 LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");\r
1052 LoadSio1Sym0(readBaud16, "SIO1readBaud16");\r
1053 LoadSio1Sym0(readBaud32, "SIO1readBaud32");\r
1054 LoadSio1Sym0(registerCallback, "SIO1registerCallback");\r
1055\r
1056 return 0;\r
1057}\r
1058\r
1059#endif\r
1060\r
1061void CALLBACK clearDynarec(void) {\r
1062 psxCpu->Reset();\r
1063}\r
1064\r
1065int LoadPlugins() {\r
1066 int ret;\r
1067 char Plugin[MAXPATHLEN];\r
1068\r
1069 ReleasePlugins();\r
b2058a5b 1070 SysLibError();\r
ef79bbde
P		 1071\r
1072 if (UsingIso()) {\r
1073 LoadCDRplugin(NULL);\r
1074 } else {\r
1075 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);\r
1076 if (LoadCDRplugin(Plugin) == -1) return -1;\r
1077 }\r
1078\r
1079 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);\r
1080 if (LoadGPUplugin(Plugin) == -1) return -1;\r
1081\r
1082 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);\r
1083 if (LoadSPUplugin(Plugin) == -1) return -1;\r
1084\r
1085 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);\r
1086 if (LoadPAD1plugin(Plugin) == -1) return -1;\r
1087\r
1088 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);\r
1089 if (LoadPAD2plugin(Plugin) == -1) return -1;\r
1090\r
1091 if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)\r
1092 Config.UseNet = FALSE;\r
1093 else {\r
1094 Config.UseNet = TRUE;\r
1095 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);\r
1096 if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;\r
1097 }\r
1098\r
1099#ifdef ENABLE_SIO1API\r
1100 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);\r
1101 if (LoadSIO1plugin(Plugin) == -1) return -1;\r
1102#endif\r
1103\r
1104 ret = CDR_init();\r
1105 if (ret < 0) { SysMessage (_("Error initializing CD-ROM plugin: %d"), ret); return -1; }\r
1106 ret = GPU_init();\r
1107 if (ret < 0) { SysMessage (_("Error initializing GPU plugin: %d"), ret); return -1; }\r
1108 ret = SPU_init();\r
1109 if (ret < 0) { SysMessage (_("Error initializing SPU plugin: %d"), ret); return -1; }\r
1110 ret = PAD1_init(1);\r
1111 if (ret < 0) { SysMessage (_("Error initializing Controller 1 plugin: %d"), ret); return -1; }\r
1112 ret = PAD2_init(2);\r
1113 if (ret < 0) { SysMessage (_("Error initializing Controller 2 plugin: %d"), ret); return -1; }\r
1114\r
1115 if (Config.UseNet) {\r
1116 ret = NET_init();\r
1117 if (ret < 0) { SysMessage (_("Error initializing NetPlay plugin: %d"), ret); return -1; }\r
1118 }\r
1119\r
1120#ifdef ENABLE_SIO1API\r
1121 ret = SIO1_init();\r
1122 if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }\r
1123#endif\r
1124\r
1125 SysPrintf(_("Plugins loaded.\n"));\r
1126 return 0;\r
1127}\r
1128\r
1129void ReleasePlugins() {\r
1130 if (Config.UseNet) {\r
1131 int ret = NET_close();\r
1132 if (ret < 0) Config.UseNet = FALSE;\r
1133 }\r
1134 NetOpened = FALSE;\r
1135\r
1136 if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();\r
1137 if (hGPUDriver != NULL) GPU_shutdown();\r
1138 if (hSPUDriver != NULL) SPU_shutdown();\r
1139 if (hPAD1Driver != NULL) PAD1_shutdown();\r
1140 if (hPAD2Driver != NULL) PAD2_shutdown();\r
1141\r
1142 if (Config.UseNet && hNETDriver != NULL) NET_shutdown(); \r
1143\r
1144 if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;\r
1145 if (hGPUDriver != NULL) SysCloseLibrary(hGPUDriver); hGPUDriver = NULL;\r
1146 if (hSPUDriver != NULL) SysCloseLibrary(hSPUDriver); hSPUDriver = NULL;\r
1147 if (hPAD1Driver != NULL) SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL;\r
1148 if (hPAD2Driver != NULL) SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL;\r
1149\r
1150 if (Config.UseNet && hNETDriver != NULL) {\r
1151 SysCloseLibrary(hNETDriver); hNETDriver = NULL;\r
1152 }\r
1153\r
1154#ifdef ENABLE_SIO1API\r
1155 if (hSIO1Driver != NULL) {\r
1156 SIO1_shutdown();\r
1157 SysCloseLibrary(hSIO1Driver);\r
1158 hSIO1Driver = NULL;\r
1159 }\r
1160#endif\r
1161}\r
1162\r
1df403c5 1163// for CD swap\r
1164int ReloadCdromPlugin()\r
1165{\r
1166 if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();\r
1167 if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;\r
1168\r
1169 if (UsingIso()) {\r
1170 LoadCDRplugin(NULL);\r
1171 } else {\r
1172 char Plugin[MAXPATHLEN];\r
1173 sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);\r
1174 if (LoadCDRplugin(Plugin) == -1) return -1;\r
1175 }\r
1176\r
1177 return CDR_init();\r
1178}\r
1179\r
ef79bbde
P		 1180void SetIsoFile(const char *filename) {\r
1181 if (filename == NULL) {\r
1182 IsoFile[0] = '\0';\r
1183 return;\r
1184 }\r
1185 strncpy(IsoFile, filename, MAXPATHLEN);\r
1186}\r
1187\r
1188const char *GetIsoFile(void) {\r
1189 return IsoFile;\r
1190}\r
1191\r
1192boolean UsingIso(void) {\r
1193 return (IsoFile[0] != '\0');\r
1194}\r
1195\r
1196void SetCdOpenCaseTime(s64 time) {\r
1197 cdOpenCaseTime = time;\r
1198}\r
ARM optimized PCSX fork