clean windows line endings in libpcsxcore/plugins.c
authoraliaspider <aliaspider@gmail.com>
Thu, 2 Mar 2017 08:31:49 +0000 (09:31 +0100)
committeraliaspider <aliaspider@gmail.com>
Thu, 2 Mar 2017 08:31:49 +0000 (09:31 +0100)
libpcsxcore/plugins.c

index 4937975..c27ce4f 100644 (file)
-/***************************************************************************\r
- *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team              *\r
- *                                                                         *\r
- *   This program is free software; you can redistribute it and/or modify  *\r
- *   it under the terms of the GNU General Public License as published by  *\r
- *   the Free Software Foundation; either version 2 of the License, or     *\r
- *   (at your option) any later version.                                   *\r
- *                                                                         *\r
- *   This program is distributed in the hope that it will be useful,       *\r
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *\r
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *\r
- *   GNU General Public License for more details.                          *\r
- *                                                                         *\r
- *   You should have received a copy of the GNU General Public License     *\r
- *   along with this program; if not, write to the                         *\r
- *   Free Software Foundation, Inc.,                                       *\r
- *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *\r
- ***************************************************************************/\r
-\r
-/*\r
-* Plugin library callback/access functions.\r
-*/\r
-\r
-#include "plugins.h"\r
-#include "cdriso.h"\r
-\r
-static char IsoFile[MAXPATHLEN] = "";\r
-static s64 cdOpenCaseTime = 0;\r
-\r
-GPUupdateLace         GPU_updateLace;\r
-GPUinit               GPU_init;\r
-GPUshutdown           GPU_shutdown; \r
-GPUconfigure          GPU_configure;\r
-GPUtest               GPU_test;\r
-GPUabout              GPU_about;\r
-GPUopen               GPU_open;\r
-GPUclose              GPU_close;\r
-GPUreadStatus         GPU_readStatus;\r
-GPUreadData           GPU_readData;\r
-GPUreadDataMem        GPU_readDataMem;\r
-GPUwriteStatus        GPU_writeStatus; \r
-GPUwriteData          GPU_writeData;\r
-GPUwriteDataMem       GPU_writeDataMem;\r
-GPUdmaChain           GPU_dmaChain;\r
-GPUkeypressed         GPU_keypressed;\r
-GPUdisplayText        GPU_displayText;\r
-GPUmakeSnapshot       GPU_makeSnapshot;\r
-GPUfreeze             GPU_freeze;\r
-GPUgetScreenPic       GPU_getScreenPic;\r
-GPUshowScreenPic      GPU_showScreenPic;\r
-GPUclearDynarec       GPU_clearDynarec;\r
-GPUvBlank             GPU_vBlank;\r
-\r
-CDRinit               CDR_init;\r
-CDRshutdown           CDR_shutdown;\r
-CDRopen               CDR_open;\r
-CDRclose              CDR_close; \r
-CDRtest               CDR_test;\r
-CDRgetTN              CDR_getTN;\r
-CDRgetTD              CDR_getTD;\r
-CDRreadTrack          CDR_readTrack;\r
-CDRgetBuffer          CDR_getBuffer;\r
-CDRplay               CDR_play;\r
-CDRstop               CDR_stop;\r
-CDRgetStatus          CDR_getStatus;\r
-CDRgetDriveLetter     CDR_getDriveLetter;\r
-CDRgetBufferSub       CDR_getBufferSub;\r
-CDRconfigure          CDR_configure;\r
-CDRabout              CDR_about;\r
-CDRsetfilename        CDR_setfilename;\r
-CDRreadCDDA           CDR_readCDDA;\r
-CDRgetTE              CDR_getTE;\r
-\r
-SPUconfigure          SPU_configure;\r
-SPUabout              SPU_about;\r
-SPUinit               SPU_init;\r
-SPUshutdown           SPU_shutdown;\r
-SPUtest               SPU_test;\r
-SPUopen               SPU_open;\r
-SPUclose              SPU_close;\r
-SPUplaySample         SPU_playSample;\r
-SPUwriteRegister      SPU_writeRegister;\r
-SPUreadRegister       SPU_readRegister;\r
-SPUwriteDMA           SPU_writeDMA;\r
-SPUreadDMA            SPU_readDMA;\r
-SPUwriteDMAMem        SPU_writeDMAMem;\r
-SPUreadDMAMem         SPU_readDMAMem;\r
-SPUplayADPCMchannel   SPU_playADPCMchannel;\r
-SPUfreeze             SPU_freeze;\r
-SPUregisterCallback   SPU_registerCallback;\r
-SPUregisterScheduleCb SPU_registerScheduleCb;\r
-SPUasync              SPU_async;\r
-SPUplayCDDAchannel    SPU_playCDDAchannel;\r
-\r
-PADconfigure          PAD1_configure;\r
-PADabout              PAD1_about;\r
-PADinit               PAD1_init;\r
-PADshutdown           PAD1_shutdown;\r
-PADtest               PAD1_test;\r
-PADopen               PAD1_open;\r
-PADclose              PAD1_close;\r
-PADquery              PAD1_query;\r
-PADreadPort1          PAD1_readPort1;\r
-PADkeypressed         PAD1_keypressed;\r
-PADstartPoll          PAD1_startPoll;\r
-PADpoll               PAD1_poll;\r
-PADsetSensitive       PAD1_setSensitive;\r
-\r
-PADconfigure          PAD2_configure;\r
-PADabout              PAD2_about;\r
-PADinit               PAD2_init;\r
-PADshutdown           PAD2_shutdown;\r
-PADtest               PAD2_test;\r
-PADopen               PAD2_open;\r
-PADclose              PAD2_close;\r
-PADquery              PAD2_query;\r
-PADreadPort2          PAD2_readPort2;\r
-PADkeypressed         PAD2_keypressed;\r
-PADstartPoll          PAD2_startPoll;\r
-PADpoll               PAD2_poll;\r
-PADsetSensitive       PAD2_setSensitive;\r
-\r
-NETinit               NET_init;\r
-NETshutdown           NET_shutdown;\r
-NETopen               NET_open;\r
-NETclose              NET_close; \r
-NETtest               NET_test;\r
-NETconfigure          NET_configure;\r
-NETabout              NET_about;\r
-NETpause              NET_pause;\r
-NETresume             NET_resume;\r
-NETqueryPlayer        NET_queryPlayer;\r
-NETsendData           NET_sendData;\r
-NETrecvData           NET_recvData;\r
-NETsendPadData        NET_sendPadData;\r
-NETrecvPadData        NET_recvPadData;\r
-NETsetInfo            NET_setInfo;\r
-NETkeypressed         NET_keypressed;\r
-\r
-#ifdef ENABLE_SIO1API\r
-\r
-SIO1init              SIO1_init;\r
-SIO1shutdown          SIO1_shutdown;\r
-SIO1open              SIO1_open;\r
-SIO1close             SIO1_close; \r
-SIO1test              SIO1_test;\r
-SIO1configure         SIO1_configure;\r
-SIO1about             SIO1_about;\r
-SIO1pause             SIO1_pause;\r
-SIO1resume            SIO1_resume;\r
-SIO1keypressed        SIO1_keypressed;\r
-SIO1writeData8        SIO1_writeData8;\r
-SIO1writeData16       SIO1_writeData16;\r
-SIO1writeData32       SIO1_writeData32;\r
-SIO1writeStat16       SIO1_writeStat16;\r
-SIO1writeStat32       SIO1_writeStat32;\r
-SIO1writeMode16       SIO1_writeMode16;\r
-SIO1writeMode32       SIO1_writeMode32;\r
-SIO1writeCtrl16       SIO1_writeCtrl16;\r
-SIO1writeCtrl32       SIO1_writeCtrl32;\r
-SIO1writeBaud16       SIO1_writeBaud16;\r
-SIO1writeBaud32       SIO1_writeBaud32;\r
-SIO1readData8         SIO1_readData8;\r
-SIO1readData16        SIO1_readData16;\r
-SIO1readData32        SIO1_readData32;\r
-SIO1readStat16        SIO1_readStat16;\r
-SIO1readStat32        SIO1_readStat32;\r
-SIO1readMode16        SIO1_readMode16;\r
-SIO1readMode32        SIO1_readMode32;\r
-SIO1readCtrl16        SIO1_readCtrl16;\r
-SIO1readCtrl32        SIO1_readCtrl32;\r
-SIO1readBaud16        SIO1_readBaud16;\r
-SIO1readBaud32        SIO1_readBaud32;\r
-SIO1registerCallback  SIO1_registerCallback;\r
-\r
-#endif\r
-\r
-static const char *err;\r
-\r
-#define CheckErr(func) { \\r
-       err = SysLibError(); \\r
-       if (err != NULL) { SysMessage(_("Error loading %s: %s"), func, err); return -1; } \\r
-}\r
-\r
-#define LoadSym(dest, src, name, checkerr) { \\r
-       dest = (src)SysLoadSym(drv, name); \\r
-       if (checkerr) { CheckErr(name); } else SysLibError(); \\r
-}\r
-\r
-void *hGPUDriver = NULL;\r
-\r
-void CALLBACK GPU__displayText(char *pText) {\r
-       SysPrintf("%s\n", pText);\r
-}\r
-\r
-long CALLBACK GPU__configure(void) { return 0; }\r
-long CALLBACK GPU__test(void) { return 0; }\r
-void CALLBACK GPU__about(void) {}\r
-void CALLBACK GPU__makeSnapshot(void) {}\r
-void CALLBACK GPU__keypressed(int key) {}\r
-long CALLBACK GPU__getScreenPic(unsigned char *pMem) { return -1; }\r
-long CALLBACK GPU__showScreenPic(unsigned char *pMem) { return -1; }\r
-void CALLBACK GPU__clearDynarec(void (CALLBACK *callback)(void)) {}\r
-void CALLBACK GPU__vBlank(int val) {}\r
-\r
-#define LoadGpuSym1(dest, name) \\r
-       LoadSym(GPU_##dest, GPU##dest, name, TRUE);\r
-
-#define LoadGpuSym0(dest, name) \\r
-       LoadSym(GPU_##dest, GPU##dest, name, FALSE); \\r
-       if (GPU_##dest == NULL) GPU_##dest = (GPU##dest) GPU__##dest;\r
-\r
-#define LoadGpuSymN(dest, name) \\r
-       LoadSym(GPU_##dest, GPU##dest, name, FALSE);\r
-\r
-static int LoadGPUplugin(const char *GPUdll) {\r
-       void *drv;\r
-\r
-       hGPUDriver = SysLoadLibrary(GPUdll);\r
-       if (hGPUDriver == NULL) { \r
-               GPU_configure = NULL;\r
-               SysMessage (_("Could not load GPU plugin %s!"), GPUdll); return -1; \r
-       }\r
-       drv = hGPUDriver;\r
-       LoadGpuSym1(init, "GPUinit");\r
-       LoadGpuSym1(shutdown, "GPUshutdown");\r
-       LoadGpuSym1(open, "GPUopen");\r
-       LoadGpuSym1(close, "GPUclose");\r
-       LoadGpuSym1(readData, "GPUreadData");\r
-       LoadGpuSym1(readDataMem, "GPUreadDataMem");\r
-       LoadGpuSym1(readStatus, "GPUreadStatus");\r
-       LoadGpuSym1(writeData, "GPUwriteData");\r
-       LoadGpuSym1(writeDataMem, "GPUwriteDataMem");\r
-       LoadGpuSym1(writeStatus, "GPUwriteStatus");\r
-       LoadGpuSym1(dmaChain, "GPUdmaChain");\r
-       LoadGpuSym1(updateLace, "GPUupdateLace");\r
-       LoadGpuSym0(keypressed, "GPUkeypressed");\r
-       LoadGpuSym0(displayText, "GPUdisplayText");\r
-       LoadGpuSym0(makeSnapshot, "GPUmakeSnapshot");\r
-       LoadGpuSym1(freeze, "GPUfreeze");\r
-       LoadGpuSym0(getScreenPic, "GPUgetScreenPic");\r
-       LoadGpuSym0(showScreenPic, "GPUshowScreenPic");\r
-       LoadGpuSym0(clearDynarec, "GPUclearDynarec");\r
-    LoadGpuSym0(vBlank, "GPUvBlank");\r
-       LoadGpuSym0(configure, "GPUconfigure");\r
-       LoadGpuSym0(test, "GPUtest");\r
-       LoadGpuSym0(about, "GPUabout");\r
-\r
-       return 0;\r
-}\r
-\r
-void *hCDRDriver = NULL;\r
-\r
-long CALLBACK CDR__play(unsigned char *sector) { return 0; }\r
-long CALLBACK CDR__stop(void) { return 0; }\r
-\r
-long CALLBACK CDR__getStatus(struct CdrStat *stat) {\r
-       if (cdOpenCaseTime < 0 || cdOpenCaseTime > (s64)time(NULL))\r
-               stat->Status = 0x10;\r
-       else\r
-               stat->Status = 0;\r
-\r
-       return 0;\r
-}\r
-\r
-char* CALLBACK CDR__getDriveLetter(void) { return NULL; }\r
-long CALLBACK CDR__configure(void) { return 0; }\r
-long CALLBACK CDR__test(void) { return 0; }\r
-void CALLBACK CDR__about(void) {}\r
-long CALLBACK CDR__setfilename(char*filename) { return 0; }\r
-\r
-#define LoadCdrSym1(dest, name) \\r
-       LoadSym(CDR_##dest, CDR##dest, name, TRUE);\r
-\r
-#define LoadCdrSym0(dest, name) \\r
-       LoadSym(CDR_##dest, CDR##dest, name, FALSE); \\r
-       if (CDR_##dest == NULL) CDR_##dest = (CDR##dest) CDR__##dest;\r
-\r
-#define LoadCdrSymN(dest, name) \\r
-       LoadSym(CDR_##dest, CDR##dest, name, FALSE);\r
-\r
-static int LoadCDRplugin(const char *CDRdll) {\r
-       void *drv;\r
-\r
-       if (CDRdll == NULL) {\r
-               cdrIsoInit();\r
-               return 0;\r
-       }\r
-\r
-       hCDRDriver = SysLoadLibrary(CDRdll);\r
-       if (hCDRDriver == NULL) {\r
-               CDR_configure = NULL;\r
-               SysMessage (_("Could not load CD-ROM plugin %s!"), CDRdll);  return -1;\r
-       }\r
-       drv = hCDRDriver;\r
-       LoadCdrSym1(init, "CDRinit");\r
-       LoadCdrSym1(shutdown, "CDRshutdown");\r
-       LoadCdrSym1(open, "CDRopen");\r
-       LoadCdrSym1(close, "CDRclose");\r
-       LoadCdrSym1(getTN, "CDRgetTN");\r
-       LoadCdrSym1(getTD, "CDRgetTD");\r
-       LoadCdrSym1(readTrack, "CDRreadTrack");\r
-       LoadCdrSym1(getBuffer, "CDRgetBuffer");\r
-       LoadCdrSym1(getBufferSub, "CDRgetBufferSub");\r
-       LoadCdrSym0(play, "CDRplay");\r
-       LoadCdrSym0(stop, "CDRstop");\r
-       LoadCdrSym0(getStatus, "CDRgetStatus");\r
-       LoadCdrSym0(getDriveLetter, "CDRgetDriveLetter");\r
-       LoadCdrSym0(configure, "CDRconfigure");\r
-       LoadCdrSym0(test, "CDRtest");\r
-       LoadCdrSym0(about, "CDRabout");\r
-       LoadCdrSym0(setfilename, "CDRsetfilename");\r
-       LoadCdrSymN(readCDDA, "CDRreadCDDA");\r
-       LoadCdrSymN(getTE, "CDRgetTE");\r
-\r
-       return 0;\r
-}\r
-\r
-void *hSPUDriver = NULL;\r
-\r
-long CALLBACK SPU__configure(void) { return 0; }\r
-void CALLBACK SPU__about(void) {}\r
-long CALLBACK SPU__test(void) { return 0; }\r
-void CALLBACK SPU__registerScheduleCb(void (CALLBACK *cb)(unsigned int)) {}\r
-\r
-#define LoadSpuSym1(dest, name) \\r
-       LoadSym(SPU_##dest, SPU##dest, name, TRUE);\r
-\r
-#define LoadSpuSym0(dest, name) \\r
-       LoadSym(SPU_##dest, SPU##dest, name, FALSE); \\r
-       if (SPU_##dest == NULL) SPU_##dest = (SPU##dest) SPU__##dest;\r
-\r
-#define LoadSpuSymN(dest, name) \\r
-       LoadSym(SPU_##dest, SPU##dest, name, FALSE);\r
-\r
-static int LoadSPUplugin(const char *SPUdll) {\r
-       void *drv;\r
-\r
-       hSPUDriver = SysLoadLibrary(SPUdll);\r
-       if (hSPUDriver == NULL) {\r
-               SPU_configure = NULL;\r
-               SysMessage (_("Could not load SPU plugin %s!"), SPUdll); return -1;\r
-       }\r
-       drv = hSPUDriver;\r
-       LoadSpuSym1(init, "SPUinit");\r
-       LoadSpuSym1(shutdown, "SPUshutdown");\r
-       LoadSpuSym1(open, "SPUopen");\r
-       LoadSpuSym1(close, "SPUclose");\r
-       LoadSpuSym0(configure, "SPUconfigure");\r
-       LoadSpuSym0(about, "SPUabout");\r
-       LoadSpuSym0(test, "SPUtest");\r
-       LoadSpuSym1(writeRegister, "SPUwriteRegister");\r
-       LoadSpuSym1(readRegister, "SPUreadRegister");           \r
-       LoadSpuSym1(writeDMA, "SPUwriteDMA");\r
-       LoadSpuSym1(readDMA, "SPUreadDMA");\r
-       LoadSpuSym1(writeDMAMem, "SPUwriteDMAMem");\r
-       LoadSpuSym1(readDMAMem, "SPUreadDMAMem");\r
-       LoadSpuSym1(playADPCMchannel, "SPUplayADPCMchannel");\r
-       LoadSpuSym1(freeze, "SPUfreeze");\r
-       LoadSpuSym1(registerCallback, "SPUregisterCallback");\r
-       LoadSpuSym0(registerScheduleCb, "SPUregisterScheduleCb");\r
-       LoadSpuSymN(async, "SPUasync");\r
-       LoadSpuSymN(playCDDAchannel, "SPUplayCDDAchannel");\r
-\r
-       return 0;\r
-}\r
-\r
-void *hPAD1Driver = NULL;\r
-void *hPAD2Driver = NULL;\r
-\r
-static int multitap1 = -1;\r
-static int multitap2 = -1;\r
-//Pad information, keystate, mode, config mode, vibration\r
+/***************************************************************************
+ *   Copyright (C) 2007 Ryan Schultz, PCSX-df Team, PCSX team              *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the GNU General Public License as published by  *
+ *   the Free Software Foundation; either version 2 of the License, or     *
+ *   (at your option) any later version.                                   *
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
+ *   GNU General Public License for more details.                          *
+ *                                                                         *
+ *   You should have received a copy of the GNU General Public License     *
+ *   along with this program; if not, write to the                         *
+ *   Free Software Foundation, Inc.,                                       *
+ *   51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA.           *
+ ***************************************************************************/
+
+/*
+* Plugin library callback/access functions.
+*/
+
+#include "plugins.h"
+#include "cdriso.h"
+
+static char IsoFile[MAXPATHLEN] = "";
+static s64 cdOpenCaseTime = 0;
+
+GPUupdateLace         GPU_updateLace;
+GPUinit               GPU_init;
+GPUshutdown           GPU_shutdown; 
+GPUconfigure          GPU_configure;
+GPUtest               GPU_test;
+GPUabout              GPU_about;
+GPUopen               GPU_open;
+GPUclose              GPU_close;
+GPUreadStatus         GPU_readStatus;
+GPUreadData           GPU_readData;
+GPUreadDataMem        GPU_readDataMem;
+GPUwriteStatus        GPU_writeStatus; 
+GPUwriteData          GPU_writeData;
+GPUwriteDataMem       GPU_writeDataMem;
+GPUdmaChain           GPU_dmaChain;
+GPUkeypressed         GPU_keypressed;
+GPUdisplayText        GPU_displayText;
+GPUmakeSnapshot       GPU_makeSnapshot;
+GPUfreeze             GPU_freeze;
+GPUgetScreenPic       GPU_getScreenPic;
+GPUshowScreenPic      GPU_showScreenPic;
+GPUclearDynarec       GPU_clearDynarec;
+GPUvBlank             GPU_vBlank;
+
+CDRinit               CDR_init;
+CDRshutdown           CDR_shutdown;
+CDRopen               CDR_open;
+CDRclose              CDR_close; 
+CDRtest               CDR_test;
+CDRgetTN              CDR_getTN;
+CDRgetTD              CDR_getTD;
+CDRreadTrack          CDR_readTrack;
+CDRgetBuffer          CDR_getBuffer;
+CDRplay               CDR_play;
+CDRstop               CDR_stop;
+CDRgetStatus          CDR_getStatus;
+CDRgetDriveLetter     CDR_getDriveLetter;
+CDRgetBufferSub       CDR_getBufferSub;
+CDRconfigure          CDR_configure;
+CDRabout              CDR_about;
+CDRsetfilename        CDR_setfilename;
+CDRreadCDDA           CDR_readCDDA;
+CDRgetTE              CDR_getTE;
+
+SPUconfigure          SPU_configure;
+SPUabout              SPU_about;
+SPUinit               SPU_init;
+SPUshutdown           SPU_shutdown;
+SPUtest               SPU_test;
+SPUopen               SPU_open;
+SPUclose              SPU_close;
+SPUplaySample         SPU_playSample;
+SPUwriteRegister      SPU_writeRegister;
+SPUreadRegister       SPU_readRegister;
+SPUwriteDMA           SPU_writeDMA;
+SPUreadDMA            SPU_readDMA;
+SPUwriteDMAMem        SPU_writeDMAMem;
+SPUreadDMAMem         SPU_readDMAMem;
+SPUplayADPCMchannel   SPU_playADPCMchannel;
+SPUfreeze             SPU_freeze;
+SPUregisterCallback   SPU_registerCallback;
+SPUregisterScheduleCb SPU_registerScheduleCb;
+SPUasync              SPU_async;
+SPUplayCDDAchannel    SPU_playCDDAchannel;
+
+PADconfigure          PAD1_configure;
+PADabout              PAD1_about;
+PADinit               PAD1_init;
+PADshutdown           PAD1_shutdown;
+PADtest               PAD1_test;
+PADopen               PAD1_open;
+PADclose              PAD1_close;
+PADquery              PAD1_query;
+PADreadPort1          PAD1_readPort1;
+PADkeypressed         PAD1_keypressed;
+PADstartPoll          PAD1_startPoll;
+PADpoll               PAD1_poll;
+PADsetSensitive       PAD1_setSensitive;
+
+PADconfigure          PAD2_configure;
+PADabout              PAD2_about;
+PADinit               PAD2_init;
+PADshutdown           PAD2_shutdown;
+PADtest               PAD2_test;
+PADopen               PAD2_open;
+PADclose              PAD2_close;
+PADquery              PAD2_query;
+PADreadPort2          PAD2_readPort2;
+PADkeypressed         PAD2_keypressed;
+PADstartPoll          PAD2_startPoll;
+PADpoll               PAD2_poll;
+PADsetSensitive       PAD2_setSensitive;
+
+NETinit               NET_init;
+NETshutdown           NET_shutdown;
+NETopen               NET_open;
+NETclose              NET_close; 
+NETtest               NET_test;
+NETconfigure          NET_configure;
+NETabout              NET_about;
+NETpause              NET_pause;
+NETresume             NET_resume;
+NETqueryPlayer        NET_queryPlayer;
+NETsendData           NET_sendData;
+NETrecvData           NET_recvData;
+NETsendPadData        NET_sendPadData;
+NETrecvPadData        NET_recvPadData;
+NETsetInfo            NET_setInfo;
+NETkeypressed         NET_keypressed;
+
+#ifdef ENABLE_SIO1API
+
+SIO1init              SIO1_init;
+SIO1shutdown          SIO1_shutdown;
+SIO1open              SIO1_open;
+SIO1close             SIO1_close; 
+SIO1test              SIO1_test;
+SIO1configure         SIO1_configure;
+SIO1about             SIO1_about;
+SIO1pause             SIO1_pause;
+SIO1resume            SIO1_resume;
+SIO1keypressed        SIO1_keypressed;
+SIO1writeData8        SIO1_writeData8;
+SIO1writeData16       SIO1_writeData16;
+SIO1writeData32       SIO1_writeData32;
+SIO1writeStat16       SIO1_writeStat16;
+SIO1writeStat32       SIO1_writeStat32;
+SIO1writeMode16       SIO1_writeMode16;
+SIO1writeMode32       SIO1_writeMode32;
+SIO1writeCtrl16       SIO1_writeCtrl16;
+SIO1writeCtrl32       SIO1_writeCtrl32;
+SIO1writeBaud16       SIO1_writeBaud16;
+SIO1writeBaud32       SIO1_writeBaud32;
+SIO1readData8         SIO1_readData8;
+SIO1readData16        SIO1_readData16;
+SIO1readData32        SIO1_readData32;
+SIO1readStat16        SIO1_readStat16;
+SIO1readStat32        SIO1_readStat32;
+SIO1readMode16        SIO1_readMode16;
+SIO1readMode32        SIO1_readMode32;
+SIO1readCtrl16        SIO1_readCtrl16;
+SIO1readCtrl32        SIO1_readCtrl32;
+SIO1readBaud16        SIO1_readBaud16;
+SIO1readBaud32        SIO1_readBaud32;
+SIO1registerCallback  SIO1_registerCallback;
+
+#endif
+
+static const char *err;
+
+#define CheckErr(func) { \
+       err = SysLibError(); \
+       if (err != NULL) { SysMessage(_("Error loading %s: %s"), func, err); return -1; } \
+}
+
+#define LoadSym(dest, src, name, checkerr) { \
+       dest = (src)SysLoadSym(drv, name); \
+       if (checkerr) { CheckErr(name); } else SysLibError(); \
+}
+
+void *hGPUDriver = NULL;
+
+void CALLBACK GPU__displayText(char *pText) {
+       SysPrintf("%s\n", pText);
+}
+
+long CALLBACK GPU__configure(void) { return 0; }
+long CALLBACK GPU__test(void) { return 0; }
+void CALLBACK GPU__about(void) {}
+void CALLBACK GPU__makeSnapshot(void) {}
+void CALLBACK GPU__keypressed(int key) {}
+long CALLBACK GPU__getScreenPic(unsigned char *pMem) { return -1; }
+long CALLBACK GPU__showScreenPic(unsigned char *pMem) { return -1; }
+void CALLBACK GPU__clearDynarec(void (CALLBACK *callback)(void)) {}
+void CALLBACK GPU__vBlank(int val) {}
+
+#define LoadGpuSym1(dest, name) \
+       LoadSym(GPU_##dest, GPU##dest, name, TRUE);
+
+#define LoadGpuSym0(dest, name) \
+       LoadSym(GPU_##dest, GPU##dest, name, FALSE); \
+       if (GPU_##dest == NULL) GPU_##dest = (GPU##dest) GPU__##dest;
+
+#define LoadGpuSymN(dest, name) \
+       LoadSym(GPU_##dest, GPU##dest, name, FALSE);
+
+static int LoadGPUplugin(const char *GPUdll) {
+       void *drv;
+
+       hGPUDriver = SysLoadLibrary(GPUdll);
+       if (hGPUDriver == NULL) { 
+               GPU_configure = NULL;
+               SysMessage (_("Could not load GPU plugin %s!"), GPUdll); return -1; 
+       }
+       drv = hGPUDriver;
+       LoadGpuSym1(init, "GPUinit");
+       LoadGpuSym1(shutdown, "GPUshutdown");
+       LoadGpuSym1(open, "GPUopen");
+       LoadGpuSym1(close, "GPUclose");
+       LoadGpuSym1(readData, "GPUreadData");
+       LoadGpuSym1(readDataMem, "GPUreadDataMem");
+       LoadGpuSym1(readStatus, "GPUreadStatus");
+       LoadGpuSym1(writeData, "GPUwriteData");
+       LoadGpuSym1(writeDataMem, "GPUwriteDataMem");
+       LoadGpuSym1(writeStatus, "GPUwriteStatus");
+       LoadGpuSym1(dmaChain, "GPUdmaChain");
+       LoadGpuSym1(updateLace, "GPUupdateLace");
+       LoadGpuSym0(keypressed, "GPUkeypressed");
+       LoadGpuSym0(displayText, "GPUdisplayText");
+       LoadGpuSym0(makeSnapshot, "GPUmakeSnapshot");
+       LoadGpuSym1(freeze, "GPUfreeze");
+       LoadGpuSym0(getScreenPic, "GPUgetScreenPic");
+       LoadGpuSym0(showScreenPic, "GPUshowScreenPic");
+       LoadGpuSym0(clearDynarec, "GPUclearDynarec");
+    LoadGpuSym0(vBlank, "GPUvBlank");
+       LoadGpuSym0(configure, "GPUconfigure");
+       LoadGpuSym0(test, "GPUtest");
+       LoadGpuSym0(about, "GPUabout");
+
+       return 0;
+}
+
+void *hCDRDriver = NULL;
+
+long CALLBACK CDR__play(unsigned char *sector) { return 0; }
+long CALLBACK CDR__stop(void) { return 0; }
+
+long CALLBACK CDR__getStatus(struct CdrStat *stat) {
+       if (cdOpenCaseTime < 0 || cdOpenCaseTime > (s64)time(NULL))
+               stat->Status = 0x10;
+       else
+               stat->Status = 0;
+
+       return 0;
+}
+
+char* CALLBACK CDR__getDriveLetter(void) { return NULL; }
+long CALLBACK CDR__configure(void) { return 0; }
+long CALLBACK CDR__test(void) { return 0; }
+void CALLBACK CDR__about(void) {}
+long CALLBACK CDR__setfilename(char*filename) { return 0; }
+
+#define LoadCdrSym1(dest, name) \
+       LoadSym(CDR_##dest, CDR##dest, name, TRUE);
+
+#define LoadCdrSym0(dest, name) \
+       LoadSym(CDR_##dest, CDR##dest, name, FALSE); \
+       if (CDR_##dest == NULL) CDR_##dest = (CDR##dest) CDR__##dest;
+
+#define LoadCdrSymN(dest, name) \
+       LoadSym(CDR_##dest, CDR##dest, name, FALSE);
+
+static int LoadCDRplugin(const char *CDRdll) {
+       void *drv;
+
+       if (CDRdll == NULL) {
+               cdrIsoInit();
+               return 0;
+       }
+
+       hCDRDriver = SysLoadLibrary(CDRdll);
+       if (hCDRDriver == NULL) {
+               CDR_configure = NULL;
+               SysMessage (_("Could not load CD-ROM plugin %s!"), CDRdll);  return -1;
+       }
+       drv = hCDRDriver;
+       LoadCdrSym1(init, "CDRinit");
+       LoadCdrSym1(shutdown, "CDRshutdown");
+       LoadCdrSym1(open, "CDRopen");
+       LoadCdrSym1(close, "CDRclose");
+       LoadCdrSym1(getTN, "CDRgetTN");
+       LoadCdrSym1(getTD, "CDRgetTD");
+       LoadCdrSym1(readTrack, "CDRreadTrack");
+       LoadCdrSym1(getBuffer, "CDRgetBuffer");
+       LoadCdrSym1(getBufferSub, "CDRgetBufferSub");
+       LoadCdrSym0(play, "CDRplay");
+       LoadCdrSym0(stop, "CDRstop");
+       LoadCdrSym0(getStatus, "CDRgetStatus");
+       LoadCdrSym0(getDriveLetter, "CDRgetDriveLetter");
+       LoadCdrSym0(configure, "CDRconfigure");
+       LoadCdrSym0(test, "CDRtest");
+       LoadCdrSym0(about, "CDRabout");
+       LoadCdrSym0(setfilename, "CDRsetfilename");
+       LoadCdrSymN(readCDDA, "CDRreadCDDA");
+       LoadCdrSymN(getTE, "CDRgetTE");
+
+       return 0;
+}
+
+void *hSPUDriver = NULL;
+
+long CALLBACK SPU__configure(void) { return 0; }
+void CALLBACK SPU__about(void) {}
+long CALLBACK SPU__test(void) { return 0; }
+void CALLBACK SPU__registerScheduleCb(void (CALLBACK *cb)(unsigned int)) {}
+
+#define LoadSpuSym1(dest, name) \
+       LoadSym(SPU_##dest, SPU##dest, name, TRUE);
+
+#define LoadSpuSym0(dest, name) \
+       LoadSym(SPU_##dest, SPU##dest, name, FALSE); \
+       if (SPU_##dest == NULL) SPU_##dest = (SPU##dest) SPU__##dest;
+
+#define LoadSpuSymN(dest, name) \
+       LoadSym(SPU_##dest, SPU##dest, name, FALSE);
+
+static int LoadSPUplugin(const char *SPUdll) {
+       void *drv;
+
+       hSPUDriver = SysLoadLibrary(SPUdll);
+       if (hSPUDriver == NULL) {
+               SPU_configure = NULL;
+               SysMessage (_("Could not load SPU plugin %s!"), SPUdll); return -1;
+       }
+       drv = hSPUDriver;
+       LoadSpuSym1(init, "SPUinit");
+       LoadSpuSym1(shutdown, "SPUshutdown");
+       LoadSpuSym1(open, "SPUopen");
+       LoadSpuSym1(close, "SPUclose");
+       LoadSpuSym0(configure, "SPUconfigure");
+       LoadSpuSym0(about, "SPUabout");
+       LoadSpuSym0(test, "SPUtest");
+       LoadSpuSym1(writeRegister, "SPUwriteRegister");
+       LoadSpuSym1(readRegister, "SPUreadRegister");           
+       LoadSpuSym1(writeDMA, "SPUwriteDMA");
+       LoadSpuSym1(readDMA, "SPUreadDMA");
+       LoadSpuSym1(writeDMAMem, "SPUwriteDMAMem");
+       LoadSpuSym1(readDMAMem, "SPUreadDMAMem");
+       LoadSpuSym1(playADPCMchannel, "SPUplayADPCMchannel");
+       LoadSpuSym1(freeze, "SPUfreeze");
+       LoadSpuSym1(registerCallback, "SPUregisterCallback");
+       LoadSpuSym0(registerScheduleCb, "SPUregisterScheduleCb");
+       LoadSpuSymN(async, "SPUasync");
+       LoadSpuSymN(playCDDAchannel, "SPUplayCDDAchannel");
+
+       return 0;
+}
+
+void *hPAD1Driver = NULL;
+void *hPAD2Driver = NULL;
+
+static int multitap1 = -1;
+static int multitap2 = -1;
+//Pad information, keystate, mode, config mode, vibration
 static PadDataS pad[8];
 
 static int reqPos, respSize, req;
 static int ledStateReq44[8];
-\r
+
 static unsigned char buf[256];
 static unsigned char bufMulti[34] = { 0x80, 0x5a, 
-                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
-                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
-                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
+                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
                                                                        0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
-                                                                       \r
-unsigned char stdpar[8] = { 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};\r
+                                                                       
+unsigned char stdpar[8] = { 0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
 unsigned char multitappar[34] = { 0x80, 0x5a, 
-                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
-                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
-                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,\r
-                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};\r
-                                                                       \r
-//response for request 44, 45, 46, 47, 4C, 4D\r
-static unsigned char resp45[8]    = {0xF3, 0x5A, 0x01, 0x02, 0x00, 0x02, 0x01, 0x00};\r
-static unsigned char resp46_00[8] = {0xF3, 0x5A, 0x00, 0x00, 0x01, 0x02, 0x00, 0x0A};\r
-static unsigned char resp46_01[8] = {0xF3, 0x5A, 0x00, 0x00, 0x01, 0x01, 0x01, 0x14};\r
-static unsigned char resp47[8]    = {0xF3, 0x5A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00};\r
-static unsigned char resp4C_00[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00};\r
-static unsigned char resp4C_01[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00};\r
-static unsigned char resp4D[8]    = {0xF3, 0x5A, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF};\r
+                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+                                                                       0x41, 0x5a, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff};
+                                                                       
+//response for request 44, 45, 46, 47, 4C, 4D
+static unsigned char resp45[8]    = {0xF3, 0x5A, 0x01, 0x02, 0x00, 0x02, 0x01, 0x00};
+static unsigned char resp46_00[8] = {0xF3, 0x5A, 0x00, 0x00, 0x01, 0x02, 0x00, 0x0A};
+static unsigned char resp46_01[8] = {0xF3, 0x5A, 0x00, 0x00, 0x01, 0x01, 0x01, 0x14};
+static unsigned char resp47[8]    = {0xF3, 0x5A, 0x00, 0x00, 0x02, 0x00, 0x01, 0x00};
+static unsigned char resp4C_00[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00};
+static unsigned char resp4C_01[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x07, 0x00, 0x00};
+static unsigned char resp4D[8]    = {0xF3, 0x5A, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF};
 
 //fixed reponse of request number 41, 48, 49, 4A, 4B, 4E, 4F
 static unsigned char resp40[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 static unsigned char resp41[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
-static unsigned char resp43[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};\r
+static unsigned char resp43[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 static unsigned char resp44[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 static unsigned char resp49[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 static unsigned char resp4A[8] = {0xF3, 0x5A, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
@@ -512,99 +512,99 @@ enum {
 //NO MULTITAP
 
 void initBufForRequest(int padIndex, char value){
-       switch (value){\r
-               //Pad keystate already in buffer\r
-               //case CMD_READ_DATA_AND_VIBRATE :\r
-               //      break;\r
-               case CMD_CONFIG_MODE :\r
-                       if (pad[padIndex].configMode == 1) {\r
-                               memcpy(buf, resp43, 8);\r
-                               break;\r
-                       }\r
-                       //else, not in config mode, pad keystate return (already in the buffer)\r
-                       break;\r
-               case CMD_SET_MODE_AND_LOCK :\r
-                       memcpy(buf, resp44, 8);\r
-                       break;\r
-               case CMD_QUERY_MODEL_AND_MODE :\r
-                       memcpy(buf, resp45, 8);\r
-                       break;\r
-               case CMD_QUERY_ACT :\r
-                       memcpy(buf, resp46_00, 8);\r
-                       break;\r
-               case CMD_QUERY_COMB :\r
-                       memcpy(buf, resp47, 8);\r
-                       break;\r
-               case CMD_QUERY_MODE :\r
-                       memcpy(buf, resp4C_00, 8);\r
-                       break;\r
-               case CMD_VIBRATION_TOGGLE :\r
-                       memcpy(buf, resp4D, 8);\r
-                       break;\r
-               case REQ40 :\r
-                       memcpy(buf, resp40, 8);\r
-                       break;\r
-               case REQ41 :\r
-                       memcpy(buf, resp41, 8);\r
-                       break;\r
-               case REQ49 :\r
-                       memcpy(buf, resp49, 8);\r
-                       break;\r
-               case REQ4A :\r
-                       memcpy(buf, resp4A, 8);\r
-                       break;\r
-               case REQ4B :\r
-                       memcpy(buf, resp4B, 8);\r
-                       break;\r
-               case REQ4E :\r
-                       memcpy(buf, resp4E, 8);\r
-                       break;\r
-               case REQ4F :\r
-                       memcpy(buf, resp4F, 8);\r
-                       break;\r
+       switch (value){
+               //Pad keystate already in buffer
+               //case CMD_READ_DATA_AND_VIBRATE :
+               //      break;
+               case CMD_CONFIG_MODE :
+                       if (pad[padIndex].configMode == 1) {
+                               memcpy(buf, resp43, 8);
+                               break;
+                       }
+                       //else, not in config mode, pad keystate return (already in the buffer)
+                       break;
+               case CMD_SET_MODE_AND_LOCK :
+                       memcpy(buf, resp44, 8);
+                       break;
+               case CMD_QUERY_MODEL_AND_MODE :
+                       memcpy(buf, resp45, 8);
+                       break;
+               case CMD_QUERY_ACT :
+                       memcpy(buf, resp46_00, 8);
+                       break;
+               case CMD_QUERY_COMB :
+                       memcpy(buf, resp47, 8);
+                       break;
+               case CMD_QUERY_MODE :
+                       memcpy(buf, resp4C_00, 8);
+                       break;
+               case CMD_VIBRATION_TOGGLE :
+                       memcpy(buf, resp4D, 8);
+                       break;
+               case REQ40 :
+                       memcpy(buf, resp40, 8);
+                       break;
+               case REQ41 :
+                       memcpy(buf, resp41, 8);
+                       break;
+               case REQ49 :
+                       memcpy(buf, resp49, 8);
+                       break;
+               case REQ4A :
+                       memcpy(buf, resp4A, 8);
+                       break;
+               case REQ4B :
+                       memcpy(buf, resp4B, 8);
+                       break;
+               case REQ4E :
+                       memcpy(buf, resp4E, 8);
+                       break;
+               case REQ4F :
+                       memcpy(buf, resp4F, 8);
+                       break;
        }
 }
 
 
-\r
-\r
-void reqIndex2Treatment(int padIndex, char value){\r
-       switch (req){\r
-               case CMD_CONFIG_MODE :\r
-                       //0x43\r
-                       if (value == 0) {\r
-                               pad[padIndex].configMode = 0;\r
-                       } else {\r
-                               pad[padIndex].configMode = 1;\r
-                       }\r
-                       break;\r
-               case CMD_SET_MODE_AND_LOCK :\r
-                       //0x44 store the led state for change mode if the next value = 0x02\r
-                       //0x01 analog ON\r
-                       //0x00 analog OFF\r
-                       ledStateReq44[padIndex] = value;\r
-                       break;\r
-               case CMD_QUERY_ACT :\r
-                       //0x46\r
-                       if (value == 1) {\r
-                               memcpy(buf, resp46_01, 8);\r
-                       }\r
-                       break;\r
-               case CMD_QUERY_MODE :\r
-                       if (value == 1) {\r
-                               memcpy(buf, resp4C_01, 8);\r
-                       }\r
-                       break;\r
-               case CMD_VIBRATION_TOGGLE :\r
-                       //0x4D\r
-                       memcpy(buf, resp4D, 8);\r
-                       break;\r
-               case CMD_READ_DATA_AND_VIBRATE:\r
-                       //mem the vibration value for small motor;\r
+
+
+void reqIndex2Treatment(int padIndex, char value){
+       switch (req){
+               case CMD_CONFIG_MODE :
+                       //0x43
+                       if (value == 0) {
+                               pad[padIndex].configMode = 0;
+                       } else {
+                               pad[padIndex].configMode = 1;
+                       }
+                       break;
+               case CMD_SET_MODE_AND_LOCK :
+                       //0x44 store the led state for change mode if the next value = 0x02
+                       //0x01 analog ON
+                       //0x00 analog OFF
+                       ledStateReq44[padIndex] = value;
+                       break;
+               case CMD_QUERY_ACT :
+                       //0x46
+                       if (value == 1) {
+                               memcpy(buf, resp46_01, 8);
+                       }
+                       break;
+               case CMD_QUERY_MODE :
+                       if (value == 1) {
+                               memcpy(buf, resp4C_01, 8);
+                       }
+                       break;
+               case CMD_VIBRATION_TOGGLE :
+                       //0x4D
+                       memcpy(buf, resp4D, 8);
+                       break;
+               case CMD_READ_DATA_AND_VIBRATE:
+                       //mem the vibration value for small motor;
                        pad[padIndex].Vib[0] = value;
                        break;
-       }\r
-}\r
+       }
+}
        
 void vibrate(int padIndex){
        if (pad[padIndex].Vib[0] != pad[padIndex].VibF[0] || pad[padIndex].Vib[1] != pad[padIndex].VibF[1]) {
@@ -619,151 +619,151 @@ void vibrate(int padIndex){
 
 
 
-//Build response for 0x42 request Pad in port\r
-void _PADstartPoll(PadDataS *pad) {\r
-    switch (pad->controllerType) {\r
-        case PSE_PAD_TYPE_MOUSE:\r
-                       stdpar[0] = 0x12;\r
-            stdpar[2] = pad->buttonStatus & 0xff;\r
-            stdpar[3] = pad->buttonStatus >> 8;\r
-            stdpar[4] = pad->moveX;\r
-            stdpar[5] = pad->moveY;\r
-            memcpy(buf, stdpar, 6);\r
-            respSize = 6;\r
-            break;\r
-        case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)\r
-            stdpar[0] = 0x23;\r
-            stdpar[2] = pad->buttonStatus & 0xff;\r
-            stdpar[3] = pad->buttonStatus >> 8;\r
-            stdpar[4] = pad->rightJoyX;\r
-            stdpar[5] = pad->rightJoyY;\r
-            stdpar[6] = pad->leftJoyX;\r
-            stdpar[7] = pad->leftJoyY;\r
-            memcpy(buf, stdpar, 8);\r
-            respSize = 8;\r
-            break;\r
-        case PSE_PAD_TYPE_ANALOGPAD: // scph1150\r
-            stdpar[0] = 0x73;\r
-            stdpar[2] = pad->buttonStatus & 0xff;\r
-            stdpar[3] = pad->buttonStatus >> 8;\r
-            stdpar[4] = pad->rightJoyX;\r
-            stdpar[5] = pad->rightJoyY;\r
-            stdpar[6] = pad->leftJoyX;\r
-            stdpar[7] = pad->leftJoyY;\r
-            memcpy(buf, stdpar, 8);\r
-            respSize = 8;\r
-            break;\r
-        case PSE_PAD_TYPE_ANALOGJOY: // scph1110\r
-            stdpar[0] = 0x53;\r
-            stdpar[2] = pad->buttonStatus & 0xff;\r
-            stdpar[3] = pad->buttonStatus >> 8;\r
-            stdpar[4] = pad->rightJoyX;\r
-            stdpar[5] = pad->rightJoyY;\r
-            stdpar[6] = pad->leftJoyX;\r
-            stdpar[7] = pad->leftJoyY;\r
-            memcpy(buf, stdpar, 8);\r
-            respSize = 8;\r
-            break;\r
-        case PSE_PAD_TYPE_STANDARD:\r
+//Build response for 0x42 request Pad in port
+void _PADstartPoll(PadDataS *pad) {
+    switch (pad->controllerType) {
+        case PSE_PAD_TYPE_MOUSE:
+                       stdpar[0] = 0x12;
+            stdpar[2] = pad->buttonStatus & 0xff;
+            stdpar[3] = pad->buttonStatus >> 8;
+            stdpar[4] = pad->moveX;
+            stdpar[5] = pad->moveY;
+            memcpy(buf, stdpar, 6);
+            respSize = 6;
+            break;
+        case PSE_PAD_TYPE_NEGCON: // npc101/npc104(slph00001/slph00069)
+            stdpar[0] = 0x23;
+            stdpar[2] = pad->buttonStatus & 0xff;
+            stdpar[3] = pad->buttonStatus >> 8;
+            stdpar[4] = pad->rightJoyX;
+            stdpar[5] = pad->rightJoyY;
+            stdpar[6] = pad->leftJoyX;
+            stdpar[7] = pad->leftJoyY;
+            memcpy(buf, stdpar, 8);
+            respSize = 8;
+            break;
+        case PSE_PAD_TYPE_ANALOGPAD: // scph1150
+            stdpar[0] = 0x73;
+            stdpar[2] = pad->buttonStatus & 0xff;
+            stdpar[3] = pad->buttonStatus >> 8;
+            stdpar[4] = pad->rightJoyX;
+            stdpar[5] = pad->rightJoyY;
+            stdpar[6] = pad->leftJoyX;
+            stdpar[7] = pad->leftJoyY;
+            memcpy(buf, stdpar, 8);
+            respSize = 8;
+            break;
+        case PSE_PAD_TYPE_ANALOGJOY: // scph1110
+            stdpar[0] = 0x53;
+            stdpar[2] = pad->buttonStatus & 0xff;
+            stdpar[3] = pad->buttonStatus >> 8;
+            stdpar[4] = pad->rightJoyX;
+            stdpar[5] = pad->rightJoyY;
+            stdpar[6] = pad->leftJoyX;
+            stdpar[7] = pad->leftJoyY;
+            memcpy(buf, stdpar, 8);
+            respSize = 8;
+            break;
+        case PSE_PAD_TYPE_STANDARD:
         default:
-               stdpar[0] = 0x41;\r
-            stdpar[2] = pad->buttonStatus & 0xff;\r
+               stdpar[0] = 0x41;
+            stdpar[2] = pad->buttonStatus & 0xff;
             stdpar[3] = pad->buttonStatus >> 8;
             //avoid analog value in multitap mode if change pad type in game.
             stdpar[4] = 0xff;
             stdpar[5] = 0xff;
             stdpar[6] = 0xff;
-            stdpar[7] = 0xff;\r
-               memcpy(buf, stdpar, 8);\r
-               respSize = 8;\r
-    }\r
-}\r
-\r
+            stdpar[7] = 0xff;
+               memcpy(buf, stdpar, 8);
+               respSize = 8;
+    }
+}
+
 
 //Build response for 0x42 request Multitap in port
-//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
-void _PADstartPollMultitap(PadDataS* padd) {\r
-    int i, offset;\r
-    for(i = 0; i < 4; i++) {\r
-       offset = 2 + (i * 8);\r
+//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)
+void _PADstartPollMultitap(PadDataS* padd) {
+    int i, offset;
+    for(i = 0; i < 4; i++) {
+       offset = 2 + (i * 8);
        _PADstartPoll(&padd[i]);
-       memcpy(multitappar+offset, stdpar, 8);\r
-    }\r
-    memcpy(bufMulti, multitappar, 34);\r
-    respSize = 34;\r
+       memcpy(multitappar+offset, stdpar, 8);
+    }
+    memcpy(bufMulti, multitappar, 34);
+    respSize = 34;
 }
-\r
-\r
+
+
 unsigned char _PADpoll(int port, unsigned char value) {
        if (reqPos == 0) {
                //mem the request number
-               req = value;\r
-               //copy the default value of request response in buffer instead of the keystate\r
+               req = value;
+               //copy the default value of request response in buffer instead of the keystate
                initBufForRequest(port, value);
-       }\r
-       \r
-       //if no new request the pad return 0xff, for signaling connected\r
-       if (reqPos >= respSize) return 0xff;\r
-       \r
-       switch(reqPos){\r
-               case 2:\r
-                       reqIndex2Treatment(port, value);\r
-               break;\r
-               case 3:\r
-                       switch(req) {\r
-                               case CMD_SET_MODE_AND_LOCK :\r
-                                       //change mode on pad\r
-                               break;\r
-                               case CMD_READ_DATA_AND_VIBRATE:\r
-                               //mem the vibration value for Large motor;\r
-                               pad[port].Vib[1] = value;\r
+       }
+       
+       //if no new request the pad return 0xff, for signaling connected
+       if (reqPos >= respSize) return 0xff;
+       
+       switch(reqPos){
+               case 2:
+                       reqIndex2Treatment(port, value);
+               break;
+               case 3:
+                       switch(req) {
+                               case CMD_SET_MODE_AND_LOCK :
+                                       //change mode on pad
+                               break;
+                               case CMD_READ_DATA_AND_VIBRATE:
+                               //mem the vibration value for Large motor;
+                               pad[port].Vib[1] = value;
                                //vibration
-                               vibrate(port);\r
-                               break;\r
-                       }\r
-               break;\r
-       }\r
-       return buf[reqPos++];\r
+                               vibrate(port);
+                               break;
+                       }
+               break;
+       }
+       return buf[reqPos++];
 }
 
 
 unsigned char _PADpollMultitap(int port, unsigned char value) {
-       if (reqPos >= respSize) return 0xff;\r
-       return bufMulti[reqPos++];\r
+       if (reqPos >= respSize) return 0xff;
+       return bufMulti[reqPos++];
 }
-\r
-\r
-// refresh the button state on port 1.\r
-// int pad is not needed.\r
+
+
+// refresh the button state on port 1.
+// int pad is not needed.
 unsigned char CALLBACK PAD1__startPoll(int pad) {
-       reqPos = 0;\r
-       // first call the pad provide if a multitap is connected between the psx and himself\r
-       if (multitap1 == -1) {\r
+       reqPos = 0;
+       // first call the pad provide if a multitap is connected between the psx and himself
+       if (multitap1 == -1) {
                PadDataS padd;
-               padd.requestPadIndex = 0;\r
-               PAD1_readPort1(&padd);\r
-               multitap1 = padd.portMultitap;\r
-       }\r
-       // just one pad is on port 1 : NO MULTITAP\r
-       if (multitap1 == 0) {\r
+               padd.requestPadIndex = 0;
+               PAD1_readPort1(&padd);
+               multitap1 = padd.portMultitap;
+       }
+       // just one pad is on port 1 : NO MULTITAP
+       if (multitap1 == 0) {
                PadDataS padd;
-               padd.requestPadIndex = 0;\r
-               PAD1_readPort1(&padd);\r
-               _PADstartPoll(&padd);\r
-       } else {\r
-               // a multitap is plugged : refresh all pad.\r
-               int i;\r
-               PadDataS padd[4];\r
+               padd.requestPadIndex = 0;
+               PAD1_readPort1(&padd);
+               _PADstartPoll(&padd);
+       } else {
+               // a multitap is plugged : refresh all pad.
+               int i;
+               PadDataS padd[4];
                for(i = 0; i < 4; i++) {
-                       padd[i].requestPadIndex = i;\r
-                       PAD1_readPort1(&padd[i]);\r
+                       padd[i].requestPadIndex = i;
+                       PAD1_readPort1(&padd[i]);
                }
-               _PADstartPollMultitap(padd);\r
+               _PADstartPollMultitap(padd);
        }
        //printf("\npad 1 : ");
-       return 0x00;\r
-}\r
-\r
+       return 0x00;
+}
+
 unsigned char CALLBACK PAD1__poll(unsigned char value) {
        char tmp;
        if (multitap1 == 1) {
@@ -771,58 +771,58 @@ unsigned char CALLBACK PAD1__poll(unsigned char value) {
        } else {
                tmp = _PADpoll(0, value);
        }
-       //printf("%2x:%2x, ",value,tmp);\r
-       return tmp;\r
-       \r
-}\r
-\r
-\r
-long CALLBACK PAD1__configure(void) { return 0; }\r
-void CALLBACK PAD1__about(void) {}\r
-long CALLBACK PAD1__test(void) { return 0; }\r
-long CALLBACK PAD1__query(void) { return 3; }\r
-long CALLBACK PAD1__keypressed() { return 0; }\r
-\r
-#define LoadPad1Sym1(dest, name) \\r
-       LoadSym(PAD1_##dest, PAD##dest, name, TRUE);\r
-\r
-#define LoadPad1SymN(dest, name) \\r
-       LoadSym(PAD1_##dest, PAD##dest, name, FALSE);\r
-\r
-#define LoadPad1Sym0(dest, name) \\r
-       LoadSym(PAD1_##dest, PAD##dest, name, FALSE); \\r
-       if (PAD1_##dest == NULL) PAD1_##dest = (PAD##dest) PAD1__##dest;\r
-\r
-static int LoadPAD1plugin(const char *PAD1dll) {\r
-       void *drv;\r
-\r
-       hPAD1Driver = SysLoadLibrary(PAD1dll);\r
-       if (hPAD1Driver == NULL) {\r
-               PAD1_configure = NULL;\r
-               SysMessage (_("Could not load Controller 1 plugin %s!"), PAD1dll); return -1;\r
-       }\r
-       drv = hPAD1Driver;\r
-       LoadPad1Sym1(init, "PADinit");\r
-       LoadPad1Sym1(shutdown, "PADshutdown");\r
-       LoadPad1Sym1(open, "PADopen");\r
-       LoadPad1Sym1(close, "PADclose");\r
-       LoadPad1Sym0(query, "PADquery");\r
-       LoadPad1Sym1(readPort1, "PADreadPort1");\r
-       LoadPad1Sym0(configure, "PADconfigure");\r
-       LoadPad1Sym0(test, "PADtest");\r
-       LoadPad1Sym0(about, "PADabout");\r
-       LoadPad1Sym0(keypressed, "PADkeypressed");\r
-       LoadPad1Sym0(startPoll, "PADstartPoll");\r
-       LoadPad1Sym0(poll, "PADpoll");\r
-       LoadPad1SymN(setSensitive, "PADsetSensitive");\r
-\r
-       return 0;\r
-}\r
-\r
+       //printf("%2x:%2x, ",value,tmp);
+       return tmp;
+       
+}
+
+
+long CALLBACK PAD1__configure(void) { return 0; }
+void CALLBACK PAD1__about(void) {}
+long CALLBACK PAD1__test(void) { return 0; }
+long CALLBACK PAD1__query(void) { return 3; }
+long CALLBACK PAD1__keypressed() { return 0; }
+
+#define LoadPad1Sym1(dest, name) \
+       LoadSym(PAD1_##dest, PAD##dest, name, TRUE);
+
+#define LoadPad1SymN(dest, name) \
+       LoadSym(PAD1_##dest, PAD##dest, name, FALSE);
+
+#define LoadPad1Sym0(dest, name) \
+       LoadSym(PAD1_##dest, PAD##dest, name, FALSE); \
+       if (PAD1_##dest == NULL) PAD1_##dest = (PAD##dest) PAD1__##dest;
+
+static int LoadPAD1plugin(const char *PAD1dll) {
+       void *drv;
+
+       hPAD1Driver = SysLoadLibrary(PAD1dll);
+       if (hPAD1Driver == NULL) {
+               PAD1_configure = NULL;
+               SysMessage (_("Could not load Controller 1 plugin %s!"), PAD1dll); return -1;
+       }
+       drv = hPAD1Driver;
+       LoadPad1Sym1(init, "PADinit");
+       LoadPad1Sym1(shutdown, "PADshutdown");
+       LoadPad1Sym1(open, "PADopen");
+       LoadPad1Sym1(close, "PADclose");
+       LoadPad1Sym0(query, "PADquery");
+       LoadPad1Sym1(readPort1, "PADreadPort1");
+       LoadPad1Sym0(configure, "PADconfigure");
+       LoadPad1Sym0(test, "PADtest");
+       LoadPad1Sym0(about, "PADabout");
+       LoadPad1Sym0(keypressed, "PADkeypressed");
+       LoadPad1Sym0(startPoll, "PADstartPoll");
+       LoadPad1Sym0(poll, "PADpoll");
+       LoadPad1SymN(setSensitive, "PADsetSensitive");
+
+       return 0;
+}
+
 unsigned char CALLBACK PAD2__startPoll(int pad) {
        int pad_index;
 
-       reqPos = 0;\r
+       reqPos = 0;
        if (multitap1 == 0 && (multitap2 == 0 || multitap2 == 2)) {
                pad_index = 1;
        } else if(multitap1 == 1 && (multitap2 == 0 || multitap2 == 2)) {
@@ -838,360 +838,360 @@ unsigned char CALLBACK PAD2__startPoll(int pad) {
                PAD2_readPort2(&padd);
                multitap2 = padd.portMultitap;
        }
-       \r
-       // just one pad is on port 1 : NO MULTITAP\r
+       
+       // just one pad is on port 1 : NO MULTITAP
        if (multitap2 == 0) {
                PadDataS padd;
                padd.requestPadIndex = pad_index;
-               PAD2_readPort2(&padd);\r
-               _PADstartPoll(&padd);\r
-       } else {\r
-               // a multitap is plugged : refresh all pad.\r
+               PAD2_readPort2(&padd);
+               _PADstartPoll(&padd);
+       } else {
+               // a multitap is plugged : refresh all pad.
                int i;
                PadDataS padd[4];
                for(i = 0; i < 4; i++) {
                        padd[i].requestPadIndex = i+pad_index;
                        PAD2_readPort2(&padd[i]);
                }
-               _PADstartPollMultitap(padd);\r
+               _PADstartPollMultitap(padd);
        }
        //printf("\npad 2 : ");
-       return 0x00;\r
-}\r
-\r
-unsigned char CALLBACK PAD2__poll(unsigned char value) {\r
+       return 0x00;
+}
+
+unsigned char CALLBACK PAD2__poll(unsigned char value) {
        char tmp;
        if (multitap2 == 2) {
                tmp = _PADpollMultitap(1, value);
        } else {
                tmp = _PADpoll(1, value);
        }
-       //printf("%2x:%2x, ",value,tmp);\r
-       return tmp;\r
-}\r
-\r
-long CALLBACK PAD2__configure(void) { return 0; }\r
-void CALLBACK PAD2__about(void) {}\r
-long CALLBACK PAD2__test(void) { return 0; }\r
-long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }\r
-long CALLBACK PAD2__keypressed() { return 0; }\r
-\r
-#define LoadPad2Sym1(dest, name) \\r
-       LoadSym(PAD2_##dest, PAD##dest, name, TRUE);\r
-\r
-#define LoadPad2Sym0(dest, name) \\r
-       LoadSym(PAD2_##dest, PAD##dest, name, FALSE); \\r
-       if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;\r
-\r
-#define LoadPad2SymN(dest, name) \\r
-       LoadSym(PAD2_##dest, PAD##dest, name, FALSE);\r
-\r
-static int LoadPAD2plugin(const char *PAD2dll) {\r
-       void *drv;\r
-\r
-       hPAD2Driver = SysLoadLibrary(PAD2dll);\r
-       if (hPAD2Driver == NULL) {\r
-               PAD2_configure = NULL;\r
-               SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;\r
-       }\r
-       drv = hPAD2Driver;\r
-       LoadPad2Sym1(init, "PADinit");\r
-       LoadPad2Sym1(shutdown, "PADshutdown");\r
-       LoadPad2Sym1(open, "PADopen");\r
-       LoadPad2Sym1(close, "PADclose");\r
-       LoadPad2Sym0(query, "PADquery");\r
-       LoadPad2Sym1(readPort2, "PADreadPort2");\r
-       LoadPad2Sym0(configure, "PADconfigure");\r
-       LoadPad2Sym0(test, "PADtest");\r
-       LoadPad2Sym0(about, "PADabout");\r
-       LoadPad2Sym0(keypressed, "PADkeypressed");\r
-       LoadPad2Sym0(startPoll, "PADstartPoll");\r
-       LoadPad2Sym0(poll, "PADpoll");\r
-       LoadPad2SymN(setSensitive, "PADsetSensitive");\r
-\r
-       return 0;\r
-}\r
-\r
-void *hNETDriver = NULL;\r
-\r
-void CALLBACK NET__setInfo(netInfo *info) {}\r
-void CALLBACK NET__keypressed(int key) {}\r
-long CALLBACK NET__configure(void) { return 0; }\r
-long CALLBACK NET__test(void) { return 0; }\r
-void CALLBACK NET__about(void) {}\r
-\r
-#define LoadNetSym1(dest, name) \\r
-       LoadSym(NET_##dest, NET##dest, name, TRUE);\r
-\r
-#define LoadNetSymN(dest, name) \\r
-       LoadSym(NET_##dest, NET##dest, name, FALSE);\r
-\r
-#define LoadNetSym0(dest, name) \\r
-       LoadSym(NET_##dest, NET##dest, name, FALSE); \\r
-       if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;\r
-\r
-static int LoadNETplugin(const char *NETdll) {\r
-       void *drv;\r
-\r
-       hNETDriver = SysLoadLibrary(NETdll);\r
-       if (hNETDriver == NULL) {\r
-               SysMessage (_("Could not load NetPlay plugin %s!"), NETdll); return -1;\r
-       }\r
-       drv = hNETDriver;\r
-       LoadNetSym1(init, "NETinit");\r
-       LoadNetSym1(shutdown, "NETshutdown");\r
-       LoadNetSym1(open, "NETopen");\r
-       LoadNetSym1(close, "NETclose");\r
-       LoadNetSymN(sendData, "NETsendData");\r
-       LoadNetSymN(recvData, "NETrecvData");\r
-       LoadNetSym1(sendPadData, "NETsendPadData");\r
-       LoadNetSym1(recvPadData, "NETrecvPadData");\r
-       LoadNetSym1(queryPlayer, "NETqueryPlayer");\r
-       LoadNetSym1(pause, "NETpause");\r
-       LoadNetSym1(resume, "NETresume");\r
-       LoadNetSym0(setInfo, "NETsetInfo");\r
-       LoadNetSym0(keypressed, "NETkeypressed");\r
-       LoadNetSym0(configure, "NETconfigure");\r
-       LoadNetSym0(test, "NETtest");\r
-       LoadNetSym0(about, "NETabout");\r
-\r
-       return 0;\r
-}\r
-\r
-#ifdef ENABLE_SIO1API\r
-\r
-void *hSIO1Driver = NULL;\r
-\r
-long CALLBACK SIO1__init(void) { return 0; }\r
-long CALLBACK SIO1__shutdown(void) { return 0; }\r
-long CALLBACK SIO1__open(void) { return 0; }\r
-long CALLBACK SIO1__close(void) { return 0; }\r
-long CALLBACK SIO1__configure(void) { return 0; }\r
-long CALLBACK SIO1__test(void) { return 0; }\r
-void CALLBACK SIO1__about(void) {}\r
-void CALLBACK SIO1__pause(void) {}\r
-void CALLBACK SIO1__resume(void) {}\r
-long CALLBACK SIO1__keypressed(int key) { return 0; }\r
-void CALLBACK SIO1__writeData8(unsigned char val) {}\r
-void CALLBACK SIO1__writeData16(unsigned short val) {}\r
-void CALLBACK SIO1__writeData32(unsigned long val) {}\r
-void CALLBACK SIO1__writeStat16(unsigned short val) {}\r
-void CALLBACK SIO1__writeStat32(unsigned long val) {}\r
-void CALLBACK SIO1__writeMode16(unsigned short val) {}\r
-void CALLBACK SIO1__writeMode32(unsigned long val) {}\r
-void CALLBACK SIO1__writeCtrl16(unsigned short val) {}\r
-void CALLBACK SIO1__writeCtrl32(unsigned long val) {}\r
-void CALLBACK SIO1__writeBaud16(unsigned short val) {}\r
-void CALLBACK SIO1__writeBaud32(unsigned long val) {}\r
-unsigned char CALLBACK SIO1__readData8(void) { return 0; }\r
-unsigned short CALLBACK SIO1__readData16(void) { return 0; }\r
-unsigned long CALLBACK SIO1__readData32(void) { return 0; }\r
-unsigned short CALLBACK SIO1__readStat16(void) { return 0; }\r
-unsigned long CALLBACK SIO1__readStat32(void) { return 0; }\r
-unsigned short CALLBACK SIO1__readMode16(void) { return 0; }\r
-unsigned long CALLBACK SIO1__readMode32(void) { return 0; }\r
-unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }\r
-unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }\r
-unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }\r
-unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }\r
-void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};\r
-\r
-void CALLBACK SIO1irq(void) {\r
-    psxHu32ref(0x1070) |= SWAPu32(0x100);\r
-}\r
-\r
-#define LoadSio1Sym1(dest, name) \\r
-    LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);\r
-\r
-#define LoadSio1SymN(dest, name) \\r
-    LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);\r
-\r
-#define LoadSio1Sym0(dest, name) \\r
-    LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \\r
-    if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;\r
-\r
-static int LoadSIO1plugin(const char *SIO1dll) {\r
-    void *drv;\r
-\r
-    hSIO1Driver = SysLoadLibrary(SIO1dll);\r
-    if (hSIO1Driver == NULL) {\r
-        SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;\r
-    }\r
-    drv = hSIO1Driver;\r
-\r
-    LoadSio1Sym0(init, "SIO1init");\r
-    LoadSio1Sym0(shutdown, "SIO1shutdown");\r
-    LoadSio1Sym0(open, "SIO1open");\r
-    LoadSio1Sym0(close, "SIO1close");\r
-    LoadSio1Sym0(pause, "SIO1pause");\r
-    LoadSio1Sym0(resume, "SIO1resume");\r
-    LoadSio1Sym0(keypressed, "SIO1keypressed");\r
-    LoadSio1Sym0(configure, "SIO1configure");\r
-    LoadSio1Sym0(test, "SIO1test");\r
-    LoadSio1Sym0(about, "SIO1about");\r
-    LoadSio1Sym0(writeData8, "SIO1writeData8");\r
-    LoadSio1Sym0(writeData16, "SIO1writeData16");\r
-    LoadSio1Sym0(writeData32, "SIO1writeData32");\r
-    LoadSio1Sym0(writeStat16, "SIO1writeStat16");\r
-    LoadSio1Sym0(writeStat32, "SIO1writeStat32");\r
-    LoadSio1Sym0(writeMode16, "SIO1writeMode16");\r
-    LoadSio1Sym0(writeMode32, "SIO1writeMode32");\r
-    LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");\r
-    LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");\r
-    LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");\r
-    LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");\r
-    LoadSio1Sym0(readData16, "SIO1readData16");\r
-    LoadSio1Sym0(readData32, "SIO1readData32");\r
-    LoadSio1Sym0(readStat16, "SIO1readStat16");\r
-    LoadSio1Sym0(readStat32, "SIO1readStat32");\r
-    LoadSio1Sym0(readMode16, "SIO1readMode16");\r
-    LoadSio1Sym0(readMode32, "SIO1readMode32");\r
-    LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");\r
-    LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");\r
-    LoadSio1Sym0(readBaud16, "SIO1readBaud16");\r
-    LoadSio1Sym0(readBaud32, "SIO1readBaud32");\r
-    LoadSio1Sym0(registerCallback, "SIO1registerCallback");\r
-\r
-    return 0;\r
-}\r
-\r
-#endif\r
-\r
-void CALLBACK clearDynarec(void) {\r
-       psxCpu->Reset();\r
-}\r
-\r
-int LoadPlugins() {\r
-       int ret;\r
-       char Plugin[MAXPATHLEN];\r
-\r
-       ReleasePlugins();\r
-       SysLibError();\r
-\r
-       if (UsingIso()) {\r
-               LoadCDRplugin(NULL);\r
-       } else {\r
-               sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);\r
-               if (LoadCDRplugin(Plugin) == -1) return -1;\r
-       }\r
-\r
-       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);\r
-       if (LoadGPUplugin(Plugin) == -1) return -1;\r
-\r
-       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);\r
-       if (LoadSPUplugin(Plugin) == -1) return -1;\r
-\r
-       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);\r
-       if (LoadPAD1plugin(Plugin) == -1) return -1;\r
-\r
-       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);\r
-       if (LoadPAD2plugin(Plugin) == -1) return -1;\r
-\r
-       if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)\r
-               Config.UseNet = FALSE;\r
-       else {\r
-               Config.UseNet = TRUE;\r
-               sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);\r
-               if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;\r
-       }\r
-\r
-#ifdef ENABLE_SIO1API\r
-       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);\r
-       if (LoadSIO1plugin(Plugin) == -1) return -1;\r
-#endif\r
-\r
-       ret = CDR_init();\r
-       if (ret < 0) { SysMessage (_("Error initializing CD-ROM plugin: %d"), ret); return -1; }\r
-       ret = GPU_init();\r
-       if (ret < 0) { SysMessage (_("Error initializing GPU plugin: %d"), ret); return -1; }\r
-       ret = SPU_init();\r
-       if (ret < 0) { SysMessage (_("Error initializing SPU plugin: %d"), ret); return -1; }\r
-       ret = PAD1_init(1);\r
-       if (ret < 0) { SysMessage (_("Error initializing Controller 1 plugin: %d"), ret); return -1; }\r
-       ret = PAD2_init(2);\r
-       if (ret < 0) { SysMessage (_("Error initializing Controller 2 plugin: %d"), ret); return -1; }\r
-\r
-       if (Config.UseNet) {\r
-               ret = NET_init();\r
-               if (ret < 0) { SysMessage (_("Error initializing NetPlay plugin: %d"), ret); return -1; }\r
-       }\r
-\r
-#ifdef ENABLE_SIO1API\r
-       ret = SIO1_init();\r
-       if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }\r
-#endif\r
-\r
-       SysPrintf(_("Plugins loaded.\n"));\r
-       return 0;\r
-}\r
-\r
-void ReleasePlugins() {\r
-       if (Config.UseNet) {\r
-               int ret = NET_close();\r
-               if (ret < 0) Config.UseNet = FALSE;\r
-       }\r
-       NetOpened = FALSE;\r
-\r
-       if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();\r
-       if (hGPUDriver != NULL) GPU_shutdown();\r
-       if (hSPUDriver != NULL) SPU_shutdown();\r
-       if (hPAD1Driver != NULL) PAD1_shutdown();\r
-       if (hPAD2Driver != NULL) PAD2_shutdown();\r
-\r
-       if (Config.UseNet && hNETDriver != NULL) NET_shutdown(); \r
-\r
-       if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;\r
-       if (hGPUDriver != NULL) SysCloseLibrary(hGPUDriver); hGPUDriver = NULL;\r
-       if (hSPUDriver != NULL) SysCloseLibrary(hSPUDriver); hSPUDriver = NULL;\r
-       if (hPAD1Driver != NULL) SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL;\r
-       if (hPAD2Driver != NULL) SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL;\r
-\r
-       if (Config.UseNet && hNETDriver != NULL) {\r
-               SysCloseLibrary(hNETDriver); hNETDriver = NULL;\r
-       }\r
-\r
-#ifdef ENABLE_SIO1API\r
-       if (hSIO1Driver != NULL) {\r
-               SIO1_shutdown();\r
-               SysCloseLibrary(hSIO1Driver);\r
-               hSIO1Driver = NULL;\r
-       }\r
-#endif\r
-}\r
-\r
-// for CD swap\r
-int ReloadCdromPlugin()\r
-{\r
-       if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();\r
-       if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;\r
-\r
-       if (UsingIso()) {\r
-               LoadCDRplugin(NULL);\r
-       } else {\r
-               char Plugin[MAXPATHLEN];\r
-               sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);\r
-               if (LoadCDRplugin(Plugin) == -1) return -1;\r
-       }\r
-\r
-       return CDR_init();\r
-}\r
-\r
-void SetIsoFile(const char *filename) {\r
-       if (filename == NULL) {\r
-               IsoFile[0] = '\0';\r
-               return;\r
-       }\r
-       strncpy(IsoFile, filename, MAXPATHLEN);\r
-}\r
-\r
-const char *GetIsoFile(void) {\r
-       return IsoFile;\r
-}\r
-\r
-boolean UsingIso(void) {\r
-       return (IsoFile[0] != '\0');\r
-}\r
-\r
-void SetCdOpenCaseTime(s64 time) {\r
-       cdOpenCaseTime = time;\r
-}\r
+       //printf("%2x:%2x, ",value,tmp);
+       return tmp;
+}
+
+long CALLBACK PAD2__configure(void) { return 0; }
+void CALLBACK PAD2__about(void) {}
+long CALLBACK PAD2__test(void) { return 0; }
+long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }
+long CALLBACK PAD2__keypressed() { return 0; }
+
+#define LoadPad2Sym1(dest, name) \
+       LoadSym(PAD2_##dest, PAD##dest, name, TRUE);
+
+#define LoadPad2Sym0(dest, name) \
+       LoadSym(PAD2_##dest, PAD##dest, name, FALSE); \
+       if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;
+
+#define LoadPad2SymN(dest, name) \
+       LoadSym(PAD2_##dest, PAD##dest, name, FALSE);
+
+static int LoadPAD2plugin(const char *PAD2dll) {
+       void *drv;
+
+       hPAD2Driver = SysLoadLibrary(PAD2dll);
+       if (hPAD2Driver == NULL) {
+               PAD2_configure = NULL;
+               SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;
+       }
+       drv = hPAD2Driver;
+       LoadPad2Sym1(init, "PADinit");
+       LoadPad2Sym1(shutdown, "PADshutdown");
+       LoadPad2Sym1(open, "PADopen");
+       LoadPad2Sym1(close, "PADclose");
+       LoadPad2Sym0(query, "PADquery");
+       LoadPad2Sym1(readPort2, "PADreadPort2");
+       LoadPad2Sym0(configure, "PADconfigure");
+       LoadPad2Sym0(test, "PADtest");
+       LoadPad2Sym0(about, "PADabout");
+       LoadPad2Sym0(keypressed, "PADkeypressed");
+       LoadPad2Sym0(startPoll, "PADstartPoll");
+       LoadPad2Sym0(poll, "PADpoll");
+       LoadPad2SymN(setSensitive, "PADsetSensitive");
+
+       return 0;
+}
+
+void *hNETDriver = NULL;
+
+void CALLBACK NET__setInfo(netInfo *info) {}
+void CALLBACK NET__keypressed(int key) {}
+long CALLBACK NET__configure(void) { return 0; }
+long CALLBACK NET__test(void) { return 0; }
+void CALLBACK NET__about(void) {}
+
+#define LoadNetSym1(dest, name) \
+       LoadSym(NET_##dest, NET##dest, name, TRUE);
+
+#define LoadNetSymN(dest, name) \
+       LoadSym(NET_##dest, NET##dest, name, FALSE);
+
+#define LoadNetSym0(dest, name) \
+       LoadSym(NET_##dest, NET##dest, name, FALSE); \
+       if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;
+
+static int LoadNETplugin(const char *NETdll) {
+       void *drv;
+
+       hNETDriver = SysLoadLibrary(NETdll);
+       if (hNETDriver == NULL) {
+               SysMessage (_("Could not load NetPlay plugin %s!"), NETdll); return -1;
+       }
+       drv = hNETDriver;
+       LoadNetSym1(init, "NETinit");
+       LoadNetSym1(shutdown, "NETshutdown");
+       LoadNetSym1(open, "NETopen");
+       LoadNetSym1(close, "NETclose");
+       LoadNetSymN(sendData, "NETsendData");
+       LoadNetSymN(recvData, "NETrecvData");
+       LoadNetSym1(sendPadData, "NETsendPadData");
+       LoadNetSym1(recvPadData, "NETrecvPadData");
+       LoadNetSym1(queryPlayer, "NETqueryPlayer");
+       LoadNetSym1(pause, "NETpause");
+       LoadNetSym1(resume, "NETresume");
+       LoadNetSym0(setInfo, "NETsetInfo");
+       LoadNetSym0(keypressed, "NETkeypressed");
+       LoadNetSym0(configure, "NETconfigure");
+       LoadNetSym0(test, "NETtest");
+       LoadNetSym0(about, "NETabout");
+
+       return 0;
+}
+
+#ifdef ENABLE_SIO1API
+
+void *hSIO1Driver = NULL;
+
+long CALLBACK SIO1__init(void) { return 0; }
+long CALLBACK SIO1__shutdown(void) { return 0; }
+long CALLBACK SIO1__open(void) { return 0; }
+long CALLBACK SIO1__close(void) { return 0; }
+long CALLBACK SIO1__configure(void) { return 0; }
+long CALLBACK SIO1__test(void) { return 0; }
+void CALLBACK SIO1__about(void) {}
+void CALLBACK SIO1__pause(void) {}
+void CALLBACK SIO1__resume(void) {}
+long CALLBACK SIO1__keypressed(int key) { return 0; }
+void CALLBACK SIO1__writeData8(unsigned char val) {}
+void CALLBACK SIO1__writeData16(unsigned short val) {}
+void CALLBACK SIO1__writeData32(unsigned long val) {}
+void CALLBACK SIO1__writeStat16(unsigned short val) {}
+void CALLBACK SIO1__writeStat32(unsigned long val) {}
+void CALLBACK SIO1__writeMode16(unsigned short val) {}
+void CALLBACK SIO1__writeMode32(unsigned long val) {}
+void CALLBACK SIO1__writeCtrl16(unsigned short val) {}
+void CALLBACK SIO1__writeCtrl32(unsigned long val) {}
+void CALLBACK SIO1__writeBaud16(unsigned short val) {}
+void CALLBACK SIO1__writeBaud32(unsigned long val) {}
+unsigned char CALLBACK SIO1__readData8(void) { return 0; }
+unsigned short CALLBACK SIO1__readData16(void) { return 0; }
+unsigned long CALLBACK SIO1__readData32(void) { return 0; }
+unsigned short CALLBACK SIO1__readStat16(void) { return 0; }
+unsigned long CALLBACK SIO1__readStat32(void) { return 0; }
+unsigned short CALLBACK SIO1__readMode16(void) { return 0; }
+unsigned long CALLBACK SIO1__readMode32(void) { return 0; }
+unsigned short CALLBACK SIO1__readCtrl16(void) { return 0; }
+unsigned long CALLBACK SIO1__readCtrl32(void) { return 0; }
+unsigned short CALLBACK SIO1__readBaud16(void) { return 0; }
+unsigned long CALLBACK SIO1__readBaud32(void) { return 0; }
+void CALLBACK SIO1__registerCallback(void (CALLBACK *callback)(void)) {};
+
+void CALLBACK SIO1irq(void) {
+    psxHu32ref(0x1070) |= SWAPu32(0x100);
+}
+
+#define LoadSio1Sym1(dest, name) \
+    LoadSym(SIO1_##dest, SIO1##dest, name, TRUE);
+
+#define LoadSio1SymN(dest, name) \
+    LoadSym(SIO1_##dest, SIO1##dest, name, FALSE);
+
+#define LoadSio1Sym0(dest, name) \
+    LoadSym(SIO1_##dest, SIO1##dest, name, FALSE); \
+    if (SIO1_##dest == NULL) SIO1_##dest = (SIO1##dest) SIO1__##dest;
+
+static int LoadSIO1plugin(const char *SIO1dll) {
+    void *drv;
+
+    hSIO1Driver = SysLoadLibrary(SIO1dll);
+    if (hSIO1Driver == NULL) {
+        SysMessage (_("Could not load SIO1 plugin %s!"), SIO1dll); return -1;
+    }
+    drv = hSIO1Driver;
+
+    LoadSio1Sym0(init, "SIO1init");
+    LoadSio1Sym0(shutdown, "SIO1shutdown");
+    LoadSio1Sym0(open, "SIO1open");
+    LoadSio1Sym0(close, "SIO1close");
+    LoadSio1Sym0(pause, "SIO1pause");
+    LoadSio1Sym0(resume, "SIO1resume");
+    LoadSio1Sym0(keypressed, "SIO1keypressed");
+    LoadSio1Sym0(configure, "SIO1configure");
+    LoadSio1Sym0(test, "SIO1test");
+    LoadSio1Sym0(about, "SIO1about");
+    LoadSio1Sym0(writeData8, "SIO1writeData8");
+    LoadSio1Sym0(writeData16, "SIO1writeData16");
+    LoadSio1Sym0(writeData32, "SIO1writeData32");
+    LoadSio1Sym0(writeStat16, "SIO1writeStat16");
+    LoadSio1Sym0(writeStat32, "SIO1writeStat32");
+    LoadSio1Sym0(writeMode16, "SIO1writeMode16");
+    LoadSio1Sym0(writeMode32, "SIO1writeMode32");
+    LoadSio1Sym0(writeCtrl16, "SIO1writeCtrl16");
+    LoadSio1Sym0(writeCtrl32, "SIO1writeCtrl32");
+    LoadSio1Sym0(writeBaud16, "SIO1writeBaud16");
+    LoadSio1Sym0(writeBaud32, "SIO1writeBaud32");
+    LoadSio1Sym0(readData16, "SIO1readData16");
+    LoadSio1Sym0(readData32, "SIO1readData32");
+    LoadSio1Sym0(readStat16, "SIO1readStat16");
+    LoadSio1Sym0(readStat32, "SIO1readStat32");
+    LoadSio1Sym0(readMode16, "SIO1readMode16");
+    LoadSio1Sym0(readMode32, "SIO1readMode32");
+    LoadSio1Sym0(readCtrl16, "SIO1readCtrl16");
+    LoadSio1Sym0(readCtrl32, "SIO1readCtrl32");
+    LoadSio1Sym0(readBaud16, "SIO1readBaud16");
+    LoadSio1Sym0(readBaud32, "SIO1readBaud32");
+    LoadSio1Sym0(registerCallback, "SIO1registerCallback");
+
+    return 0;
+}
+
+#endif
+
+void CALLBACK clearDynarec(void) {
+       psxCpu->Reset();
+}
+
+int LoadPlugins() {
+       int ret;
+       char Plugin[MAXPATHLEN];
+
+       ReleasePlugins();
+       SysLibError();
+
+       if (UsingIso()) {
+               LoadCDRplugin(NULL);
+       } else {
+               sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
+               if (LoadCDRplugin(Plugin) == -1) return -1;
+       }
+
+       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);
+       if (LoadGPUplugin(Plugin) == -1) return -1;
+
+       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);
+       if (LoadSPUplugin(Plugin) == -1) return -1;
+
+       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);
+       if (LoadPAD1plugin(Plugin) == -1) return -1;
+
+       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);
+       if (LoadPAD2plugin(Plugin) == -1) return -1;
+
+       if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)
+               Config.UseNet = FALSE;
+       else {
+               Config.UseNet = TRUE;
+               sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);
+               if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;
+       }
+
+#ifdef ENABLE_SIO1API
+       sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);
+       if (LoadSIO1plugin(Plugin) == -1) return -1;
+#endif
+
+       ret = CDR_init();
+       if (ret < 0) { SysMessage (_("Error initializing CD-ROM plugin: %d"), ret); return -1; }
+       ret = GPU_init();
+       if (ret < 0) { SysMessage (_("Error initializing GPU plugin: %d"), ret); return -1; }
+       ret = SPU_init();
+       if (ret < 0) { SysMessage (_("Error initializing SPU plugin: %d"), ret); return -1; }
+       ret = PAD1_init(1);
+       if (ret < 0) { SysMessage (_("Error initializing Controller 1 plugin: %d"), ret); return -1; }
+       ret = PAD2_init(2);
+       if (ret < 0) { SysMessage (_("Error initializing Controller 2 plugin: %d"), ret); return -1; }
+
+       if (Config.UseNet) {
+               ret = NET_init();
+               if (ret < 0) { SysMessage (_("Error initializing NetPlay plugin: %d"), ret); return -1; }
+       }
+
+#ifdef ENABLE_SIO1API
+       ret = SIO1_init();
+       if (ret < 0) { SysMessage (_("Error initializing SIO1 plugin: %d"), ret); return -1; }
+#endif
+
+       SysPrintf(_("Plugins loaded.\n"));
+       return 0;
+}
+
+void ReleasePlugins() {
+       if (Config.UseNet) {
+               int ret = NET_close();
+               if (ret < 0) Config.UseNet = FALSE;
+       }
+       NetOpened = FALSE;
+
+       if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
+       if (hGPUDriver != NULL) GPU_shutdown();
+       if (hSPUDriver != NULL) SPU_shutdown();
+       if (hPAD1Driver != NULL) PAD1_shutdown();
+       if (hPAD2Driver != NULL) PAD2_shutdown();
+
+       if (Config.UseNet && hNETDriver != NULL) NET_shutdown(); 
+
+       if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;
+       if (hGPUDriver != NULL) SysCloseLibrary(hGPUDriver); hGPUDriver = NULL;
+       if (hSPUDriver != NULL) SysCloseLibrary(hSPUDriver); hSPUDriver = NULL;
+       if (hPAD1Driver != NULL) SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL;
+       if (hPAD2Driver != NULL) SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL;
+
+       if (Config.UseNet && hNETDriver != NULL) {
+               SysCloseLibrary(hNETDriver); hNETDriver = NULL;
+       }
+
+#ifdef ENABLE_SIO1API
+       if (hSIO1Driver != NULL) {
+               SIO1_shutdown();
+               SysCloseLibrary(hSIO1Driver);
+               hSIO1Driver = NULL;
+       }
+#endif
+}
+
+// for CD swap
+int ReloadCdromPlugin()
+{
+       if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
+       if (hCDRDriver != NULL) SysCloseLibrary(hCDRDriver); hCDRDriver = NULL;
+
+       if (UsingIso()) {
+               LoadCDRplugin(NULL);
+       } else {
+               char Plugin[MAXPATHLEN];
+               sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
+               if (LoadCDRplugin(Plugin) == -1) return -1;
+       }
+
+       return CDR_init();
+}
+
+void SetIsoFile(const char *filename) {
+       if (filename == NULL) {
+               IsoFile[0] = '\0';
+               return;
+       }
+       strncpy(IsoFile, filename, MAXPATHLEN);
+}
+
+const char *GetIsoFile(void) {
+       return IsoFile;
+}
+
+boolean UsingIso(void) {
+       return (IsoFile[0] != '\0');
+}
+
+void SetCdOpenCaseTime(s64 time) {
+       cdOpenCaseTime = time;
+}