diff --git a/ee/rpc/Makefile b/ee/rpc/Makefile index f61e991f7cb3..031a8fbe8b3c 100644 --- a/ee/rpc/Makefile +++ b/ee/rpc/Makefile @@ -17,7 +17,6 @@ SUBDIRS += memorycard SUBDIRS += mouse SUBDIRS += multitap SUBDIRS += pad -SUBDIRS += padx SUBDIRS += poweroff SUBDIRS += ps2snd SUBDIRS += remote diff --git a/ee/rpc/pad/Makefile b/ee/rpc/pad/Makefile index 91ef6eaa45b7..b608726b0c49 100644 --- a/ee/rpc/pad/Makefile +++ b/ee/rpc/pad/Makefile @@ -6,6 +6,8 @@ # Licenced under Academic Free License version 2.0 # Review ps2sdk README & LICENSE files for further details. +EE_LIB_ALTNAMES ?= libpadx.a + EE_OBJS = libpad.o erl-support.o include $(PS2SDKSRC)/Defs.make diff --git a/ee/rpc/pad/include/libpad.h b/ee/rpc/pad/include/libpad.h index 2e3af6fe4970..8b209c5249d8 100644 --- a/ee/rpc/pad/include/libpad.h +++ b/ee/rpc/pad/include/libpad.h @@ -240,20 +240,20 @@ extern int padSetButtonInfo(int port, int slot, int buttonInfo); * If padInfoAct(port, slot, -1, 0) != 0, the controller has actuators * (i think ;) ) */ -extern unsigned char padInfoAct(int port, int slot, int word, int byte); +extern unsigned char padInfoAct(int port, int slot, int actuator, int cmd); /** Initalise actuators. On dual shock controller: * act_align[0] = 0 enables 'small' engine * act_align[1] = 1 enables 'big' engine * set act_align[2-5] to 0xff (disable) */ -extern int padSetActAlign(int port, int slot, const char act_align[6]); +extern int padSetActAlign(int port, int slot, const char actAlign[6]); /** Set actuator status on dual shock controller, * act_align[0] = 0/1 turns off/on 'small' engine * act_align[1] = 0-255 sets 'big' engine speed */ -extern int padSetActDirect(int port, int slot, char act_align[6]); +extern int padSetActDirect(int port, int slot, const char actAlign[6]); /** Returns whether the device at port,slot is connected (1 = connected) * Appears to have been removed very early during the PS2's lifetime. diff --git a/ee/rpc/pad/samples/Makefile b/ee/rpc/pad/samples/Makefile index 72df63b0accd..f019aa7bdfa1 100644 --- a/ee/rpc/pad/samples/Makefile +++ b/ee/rpc/pad/samples/Makefile @@ -2,11 +2,11 @@ # ____| | ____| | | |____| # | ___| |____ ___| ____| | \ PS2DEV Open Source Project. #----------------------------------------------------------------------- -# Copyright 2001-2004, ps2dev - http://www.ps2dev.org +# Copyright ps2dev - http://www.ps2dev.org # Licenced under Academic Free License version 2.0 # Review ps2sdk README & LICENSE files for further details. -SAMPLE_DIR = rpc/pad +SUBDIRS = pad padx include $(PS2SDKSRC)/Defs.make -include $(PS2SDKSRC)/samples/Rules.samples +include $(PS2SDKSRC)/Rules.make diff --git a/ee/rpc/padx/Makefile b/ee/rpc/pad/samples/pad/Makefile similarity index 72% rename from ee/rpc/padx/Makefile rename to ee/rpc/pad/samples/pad/Makefile index 3140e644bc35..72df63b0accd 100644 --- a/ee/rpc/padx/Makefile +++ b/ee/rpc/pad/samples/pad/Makefile @@ -6,9 +6,7 @@ # Licenced under Academic Free License version 2.0 # Review ps2sdk README & LICENSE files for further details. -EE_SRC_DIR = $(PS2SDKSRC)/ee/rpc/pad/src/ -EE_INC_DIR = $(PS2SDKSRC)/ee/rpc/pad/include/ +SAMPLE_DIR = rpc/pad -EE_CFLAGS += -D_XPAD - -include $(PS2SDKSRC)/ee/rpc/pad/Makefile +include $(PS2SDKSRC)/Defs.make +include $(PS2SDKSRC)/samples/Rules.samples diff --git a/ee/rpc/pad/samples/Makefile.sample b/ee/rpc/pad/samples/pad/Makefile.sample similarity index 100% rename from ee/rpc/pad/samples/Makefile.sample rename to ee/rpc/pad/samples/pad/Makefile.sample diff --git a/ee/rpc/pad/samples/pad.c b/ee/rpc/pad/samples/pad/pad.c similarity index 100% rename from ee/rpc/pad/samples/pad.c rename to ee/rpc/pad/samples/pad/pad.c diff --git a/ee/rpc/padx/samples/Makefile b/ee/rpc/pad/samples/padx/Makefile similarity index 100% rename from ee/rpc/padx/samples/Makefile rename to ee/rpc/pad/samples/padx/Makefile diff --git a/ee/rpc/padx/samples/Makefile.sample b/ee/rpc/pad/samples/padx/Makefile.sample similarity index 100% rename from ee/rpc/padx/samples/Makefile.sample rename to ee/rpc/pad/samples/padx/Makefile.sample diff --git a/ee/rpc/padx/samples/padx.c b/ee/rpc/pad/samples/padx/padx.c similarity index 100% rename from ee/rpc/padx/samples/padx.c rename to ee/rpc/pad/samples/padx/padx.c diff --git a/ee/rpc/pad/src/libpad.c b/ee/rpc/pad/src/libpad.c index 5d61d41ca3f8..f5277d0e7c27 100644 --- a/ee/rpc/pad/src/libpad.c +++ b/ee/rpc/pad/src/libpad.c @@ -27,64 +27,51 @@ * Defines */ -#ifdef _XPAD -#define PAD_BIND_RPC_ID1 0x80000100 -#define PAD_BIND_RPC_ID2 0x80000101 - -#define PAD_RPCCMD_OPEN 0x01 -#define PAD_RPCCMD_SET_MMODE 0x06 -#define PAD_RPCCMD_SET_ACTDIR 0x07 -#define PAD_RPCCMD_SET_ACTALIGN 0x08 -#define PAD_RPCCMD_GET_BTNMASK 0x09 -#define PAD_RPCCMD_SET_BTNINFO 0x0A -#define PAD_RPCCMD_SET_VREF 0x0B -#define PAD_RPCCMD_GET_PORTMAX 0x0C -#define PAD_RPCCMD_GET_SLOTMAX 0x0D -#define PAD_RPCCMD_CLOSE 0x0E -#define PAD_RPCCMD_END 0x0F -#define PAD_RPCCMD_INIT 0x10 -#define PAD_RPCCMD_GET_MODVER 0x12 -#else -#define PAD_BIND_RPC_ID1 0x8000010f -#define PAD_BIND_RPC_ID2 0x8000011f - -#define PAD_RPCCMD_OPEN 0x80000100 -#define PAD_RPCCMD_INFO_ACT 0x80000102 -#define PAD_RPCCMD_INFO_COMB 0x80000103 -#define PAD_RPCCMD_INFO_MODE 0x80000104 -#define PAD_RPCCMD_SET_MMODE 0x80000105 -#define PAD_RPCCMD_SET_ACTDIR 0x80000106 -#define PAD_RPCCMD_SET_ACTALIGN 0x80000107 -#define PAD_RPCCMD_GET_BTNMASK 0x80000108 -#define PAD_RPCCMD_SET_BTNINFO 0x80000109 -#define PAD_RPCCMD_SET_VREF 0x8000010a -#define PAD_RPCCMD_GET_PORTMAX 0x8000010b -#define PAD_RPCCMD_GET_SLOTMAX 0x8000010c -#define PAD_RPCCMD_CLOSE 0x8000010d -#define PAD_RPCCMD_END 0x8000010e -#define PAD_RPCCMD_INIT 0x00000100 -#endif +#define PAD_BIND_RPC_ID1_NEW 0x80000100 +#define PAD_BIND_RPC_ID2_NEW 0x80000101 + +#define PAD_BIND_RPC_ID1_OLD 0x8000010f +#define PAD_BIND_RPC_ID2_OLD 0x8000011f + +#define PAD_RPCCMD_OPEN_NEW 0x01 +#define PAD_RPCCMD_SET_MMODE_NEW 0x06 +#define PAD_RPCCMD_SET_ACTDIR_NEW 0x07 +#define PAD_RPCCMD_SET_ACTALIGN_NEW 0x08 +#define PAD_RPCCMD_GET_BTNMASK_NEW 0x09 +#define PAD_RPCCMD_SET_BTNINFO_NEW 0x0A +#define PAD_RPCCMD_SET_VREF_NEW 0x0B +#define PAD_RPCCMD_GET_PORTMAX_NEW 0x0C +#define PAD_RPCCMD_GET_SLOTMAX_NEW 0x0D +#define PAD_RPCCMD_CLOSE_NEW 0x0E +#define PAD_RPCCMD_END_NEW 0x0F +#define PAD_RPCCMD_INIT 0x10 +#define PAD_RPCCMD_GET_MODVER 0x12 + +#define PAD_RPCCMD_OPEN_OLD 0x80000100 +#define PAD_RPCCMD_INFO_ACT 0x80000102 +#define PAD_RPCCMD_INFO_COMB_OLD 0x80000103 +#define PAD_RPCCMD_INFO_MODE 0x80000104 +#define PAD_RPCCMD_SET_MMODE_OLD 0x80000105 +#define PAD_RPCCMD_SET_ACTDIR_OLD 0x80000106 +#define PAD_RPCCMD_SET_ACTALIGN_OLD 0x80000107 +#define PAD_RPCCMD_GET_BTNMASK_OLD 0x80000108 +#define PAD_RPCCMD_SET_BTNINFO_OLD 0x80000109 +#define PAD_RPCCMD_SET_VREF_OLD 0x8000010a +#define PAD_RPCCMD_GET_PORTMAX_OLD 0x8000010b +#define PAD_RPCCMD_GET_SLOTMAX_OLD 0x8000010c +#define PAD_RPCCMD_CLOSE_OLD 0x8000010d +#define PAD_RPCCMD_END_OLD 0x8000010e /* * Types */ -struct pad_state -{ - int open; - unsigned int port; - unsigned int slot; - struct pad_data *padData; - unsigned char *padBuf; -}; - -#ifdef _XPAD -struct pad_data +struct pad_data_new { u8 data[32]; u32 actDirData[2]; u32 actAlignData[2]; - u8 actData[32]; + u8 actData[8][4]; u16 modeTable[4]; u32 frame; u32 findPadRetries; @@ -109,44 +96,69 @@ struct pad_data u8 padding[11]; }; -struct open_slot +// rom0:padman has only 64 byte of pad data +struct pad_data_old { u32 frame; - u32 openSlots[2]; - u8 padding[116]; -}; -#else -// rom0:padman has only 64 byte of pad data -struct pad_data -{ - unsigned int frame; - unsigned char state; - unsigned char reqState; - unsigned char ok; - unsigned char unkn7; - unsigned char data[32]; - unsigned int length; - unsigned char request; + u8 state; + u8 reqState; + u8 ok; + u8 unkn7; + u8 data[32]; + u32 length; + u8 request; /** CTP=1/no config; CTP=2/config, acts... */ - unsigned char CTP; + u8 CTP; /** 1, 2 or 3 */ - unsigned char model; + u8 model; /** the data in the buffer is already corrected */ - unsigned char correction; - unsigned char errorCount; - unsigned char unk49[15]; + u8 correction; + u8 errorCount; + u8 unk49[15]; +}; + +union pad_data_u +{ + struct pad_data_old oldPadData[2]; + struct pad_data_new newPadData[2]; +}; + +struct pad_state +{ + int open; + unsigned int port; + unsigned int slot; + union pad_data_u *padData; + unsigned char *padBuf; +}; + +struct open_slot +{ + u32 frame; + u32 openSlots[2]; + u8 padding[116]; }; -#endif extern int _iop_reboot_count; /* * Pad variables etc. */ -static const char padStateString[8][16] = {"DISCONNECT", "FINDPAD", - "FINDCTP1", "", "", "EXECCMD", - "STABLE", "ERROR"}; -static const char padReqStateString[3][16] = {"COMPLETE", "FAILED", "BUSY"}; +static const char *padStateString[] = { + "DISCONNECT", + "FINDPAD", + "FINDCTP1", + "", + "", + "EXECCMD", + "STABLE", + "ERROR", +}; +static const char *padReqStateString[] = { + "COMPLETE", + "FAILED", + "BUSY", +}; static int padInitialised = 0; @@ -154,13 +166,11 @@ static int padInitialised = 0; static SifRpcClientData_t padsif[2] __attribute__((aligned(64))); static union { s32 command; -#ifdef _XPAD struct { s32 command; s32 unused[3]; void *statBuf; } padInitArgs; -#endif struct { s32 unknown[3]; s32 result; @@ -219,28 +229,20 @@ static union { struct { s32 command; s32 port, slot; -#ifndef _XPAD s32 actuator; s32 act_cmd; } padInfoActArgs; struct { s32 command; s32 port, slot; -#endif s8 align[6]; } padActDirAlignArgs; char buffer[128]; } -#ifdef _XPAD buffer __attribute__((aligned(64))); -#else -buffer __attribute__((aligned(16))); -#endif /** Port state data */ -#ifdef _XPAD static struct open_slot openSlot[2] __attribute__((aligned(64))); -#endif static struct pad_state PadState[2][8]; @@ -249,23 +251,28 @@ static struct pad_state PadState[2][8]; */ /** Common helper */ -static struct pad_data* -padGetDmaStr(int port, int slot) +static struct pad_data_new* +padGetDmaStrNew(int port, int slot) { - struct pad_data *pdata; + struct pad_data_new *pdata; - pdata = PadState[port][slot].padData; + pdata = PadState[port][slot].padData->newPadData; SyncDCache(pdata, (u8 *)pdata + 256); - if(pdata[0].frame < pdata[1].frame) { - return &pdata[1]; - } - else { - return &pdata[0]; - } + return (pdata[0].frame < pdata[1].frame) ? &pdata[1] : &pdata[0]; +} + +static struct pad_data_old* +padGetDmaStrOld(int port, int slot) +{ + struct pad_data_old *pdata; + + pdata = PadState[port][slot].padData->oldPadData; + SyncDCache(pdata, (u8 *)pdata + 256); + + return (pdata[0].frame < pdata[1].frame) ? &pdata[1] : &pdata[0]; } -#ifdef _XPAD /** * Returns the data for pad (opened) status. * This seems to have been removed from the official SDKs, very early during the PS2's lifetime. @@ -275,12 +282,8 @@ padGetConnDmaStr(void) { SyncDCache(openSlot, (u8*)openSlot + sizeof(openSlot)); - if(openSlot[0].frame < openSlot[1].frame) - return &openSlot[1]; - else - return &openSlot[0]; + return (openSlot[0].frame < openSlot[1].frame) ? &openSlot[1] : &openSlot[0]; } -#endif /* * Global functions @@ -299,6 +302,7 @@ padInit(int mode) // Version check isn't used by default // int ver; static int _rb_count = 0; + int rpc_init_next; if (_rb_count != _iop_reboot_count) { @@ -306,27 +310,71 @@ padInit(int mode) padInitialised = 0; } - if(padInitialised) + if (padInitialised) return 0; - padInitialised = 1; + padInitialised = 0xFFFFFFFF; + rpc_init_next = 0; padsif[0].server = NULL; padsif[1].server = NULL; - do { - if (sceSifBindRpc(&padsif[0], PAD_BIND_RPC_ID1, 0) < 0) { - return -1; + { + unsigned int i; + SifRpcClientData_t rpciftmp[2] __attribute__((aligned(64))); + static const int rpc_ids[] = { + PAD_BIND_RPC_ID1_NEW, + PAD_BIND_RPC_ID1_OLD, + }; + + padsif[0].server = NULL; + for (i = 0; i < (sizeof(rpc_ids)/sizeof(rpc_ids[0])); i += 1) + rpciftmp[i].server = NULL; + + for (;;) + { + for (i = 0; i < (sizeof(rpc_ids)/sizeof(rpc_ids[0])); i += 1) + { + if ((sceSifBindRpc(&rpciftmp[i], rpc_ids[i], 0) < 0)) + return -1; + if (rpciftmp[i].server != NULL) + { + switch (rpc_ids[i]) + { + case PAD_BIND_RPC_ID1_NEW: + { + padInitialised = 2; + rpc_init_next = PAD_BIND_RPC_ID2_NEW; + break; + } + case PAD_BIND_RPC_ID1_OLD: + { + padInitialised = 1; + rpc_init_next = PAD_BIND_RPC_ID2_OLD; + break; + } + default: + break; + } + memcpy(&padsif[0], &rpciftmp[i], sizeof(padsif[0])); + break; + } + } + if (padsif[0].server != NULL) + break; + nopdelay(); } - nopdelay(); - } while(!padsif[0].server); + } - do { - if (sceSifBindRpc(&padsif[1], PAD_BIND_RPC_ID2, 0) < 0) { + if (!rpc_init_next) + return -1; + + while (!padsif[1].server) + { + if (sceSifBindRpc(&padsif[1], rpc_init_next, 0) < 0) return -3; - } nopdelay(); - } while(!padsif[1].server); + } // If you require a special version of the padman, check for that here (uncomment) // ver = padGetModVersion(); @@ -337,55 +385,75 @@ padInit(int mode) int padPortInit(int mode) { -#ifdef _XPAD //Unofficial: libpad EE client from v1.3.4 has this RPC function implemented, but is not implemented within its PADMAN module. - int ret; -#endif - int i; + unsigned int i; + unsigned int j; (void)mode; - for(i = 0; i<8; i++) + for (i = 0; i < (sizeof(PadState)/sizeof(PadState[0])); i += 1) { - PadState[0][i].open = 0; - PadState[0][i].port = 0; - PadState[0][i].slot = 0; - PadState[1][i].open = 0; - PadState[1][i].port = 0; - PadState[1][i].slot = 0; + for (j = 0; j < (sizeof(PadState[0])/sizeof(PadState[0][0])); j += 1) + { + PadState[i][j].open = 0; + PadState[i][j].port = 0; + PadState[i][j].slot = 0; + } } -#ifdef _XPAD //Unofficial: libpad EE client from v1.3.4 has this RPC function implemented, but is not implemented within its PADMAN module. - -#ifdef _XPAD - buffer.padInitArgs.command = PAD_RPCCMD_INIT; - buffer.padInitArgs.statBuf = openSlot; -#else - buffer.command = PAD_RPCCMD_INIT; + switch (padInitialised) + { + case 1: + { +#if 0 + int ret; + //Unofficial: libpad EE client from v1.3.4 has this RPC function implemented, but is not implemented within its PADMAN module. + buffer.command = PAD_RPCCMD_OPEN_OLD; + ret = sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL); #endif - ret = sceSifCallRpc( &padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL); + return 1; + } + case 2: + { + int ret; - return(ret >= 0 ? buffer.padResult.result : 0); -#else - return 1; -#endif + buffer.command = PAD_RPCCMD_INIT; + buffer.padInitArgs.statBuf = openSlot; + ret = sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL); + + return ret >= 0 ? buffer.padResult.result : 0; + } + default: + return 1; + } } int padEnd(void) { - int ret; + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_END_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_END_NEW; + break; + } + default: + return -1; + } - buffer.command=PAD_RPCCMD_END; - - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return -1; ret = buffer.padResult.result; - if (ret == 1) { + if (ret == 1) padInitialised = 0; - } return ret; } @@ -393,54 +461,109 @@ padEnd(void) int padPortOpen(int port, int slot, void *padArea) { + union pad_data_u *dma_buf = (union pad_data_u *)padArea; - int i; - struct pad_data *dma_buf = (struct pad_data *)padArea; + if ((unsigned int)port >= (sizeof(PadState)/sizeof(PadState[0]))) + return 0; + if ((unsigned int)slot >= (sizeof(PadState[0])/sizeof(PadState[0][0]))) + return 0; -#ifndef _XPAD - // Check 16 byte alignment - if((u32)padArea & 0xf) { - printf("Address is not 16-byte aligned.\n"); + switch (padInitialised) + { + case 1: + { + // Check 16 byte alignment + if ((u32)padArea & 0xf) + { + printf("Address is not 16-byte aligned.\n"); + return 0; + } + break; + } + case 2: + { + // Check 64 byte alignment + if ((u32)padArea & 0x3f) + { + printf("Address is not 64-byte aligned.\n"); + return 0; + } + break; + } + default: return 0; } -#else - // Check 64 byte alignment - if((u32)padArea & 0x3f) { - printf("Address is not 16-byte aligned.\n"); + + + // Pad data is double buffered + switch (padInitialised) + { + case 1: + { + unsigned int i; + + for (i = 0; i < (sizeof(dma_buf->oldPadData)/sizeof(dma_buf->oldPadData[0])); i += 1) + { + struct pad_data_old *pdata; + + pdata = &dma_buf->oldPadData[i]; + memset(pdata->data, 0xff, sizeof(pdata->data)); // 'Clear' data area + pdata->frame = 0; + pdata->length = 0; + pdata->state = PAD_STATE_EXECCMD; + pdata->reqState = PAD_RSTAT_BUSY; + pdata->length = 0; + pdata->ok = 0; + } + break; + } + case 2: + { + unsigned int i; + + for (i = 0; i < (sizeof(dma_buf->newPadData)/sizeof(dma_buf->newPadData[0])); i += 1) + { + struct pad_data_new *pdata; + + pdata = &dma_buf->newPadData[i]; + memset(pdata->data, 0xff, sizeof(pdata->data)); // 'Clear' data area + pdata->frame = 0; + pdata->length = 0; + pdata->state = PAD_STATE_EXECCMD; + pdata->reqState = PAD_RSTAT_BUSY; + pdata->length = 0; + pdata->currentTask = 0; + pdata->buttonDataReady = 0; // Should be cleared in newer padman + } + break; + } + default: return 0; } -#endif - for (i=0; i<2; i++) { // Pad data is double buffered - memset(dma_buf[i].data, 0xff, 32); // 'Clear' data area - dma_buf[i].frame = 0; - dma_buf[i].length = 0; - dma_buf[i].state = PAD_STATE_EXECCMD; - dma_buf[i].reqState = PAD_RSTAT_BUSY; -#ifndef _XPAD - dma_buf[i].ok = 0; -#endif -#ifdef _XPAD - dma_buf[i].currentTask = 0; -#endif - dma_buf[i].length = 0; -#ifdef _XPAD - dma_buf[i].buttonDataReady = 0; // Should be cleared in newer padman -#endif + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_OPEN_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_OPEN_NEW; + break; + } + default: + return 0; } - - - buffer.padOpenArgs.command = PAD_RPCCMD_OPEN; buffer.padOpenArgs.port = port; buffer.padOpenArgs.slot = slot; buffer.padOpenArgs.padArea = padArea; - if(sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) - { + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return 0; - } - PadState[port][slot].open = 1; + PadState[port][slot].open = padInitialised; PadState[port][slot].padData = padArea; PadState[port][slot].padBuf = buffer.padOpenResult.padBuf; @@ -450,109 +573,190 @@ padPortOpen(int port, int slot, void *padArea) int padPortClose(int port, int slot) { - int ret; - buffer.padCloseArgs.command = PAD_RPCCMD_CLOSE; + if ((unsigned int)port >= (sizeof(PadState)/sizeof(PadState[0]))) + return -1; + if ((unsigned int)slot >= (sizeof(PadState[0])/sizeof(PadState[0][0]))) + return -1; + + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_CLOSE_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_CLOSE_NEW; + break; + } + default: + return -1; + } + buffer.padCloseArgs.port = port; buffer.padCloseArgs.slot = slot; buffer.padCloseArgs.mode = 1; - ret = sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL); + ret = sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL); - if(ret < 0) + if (ret < 0) return ret; - else { - PadState[port][slot].open = 0; - return buffer.padResult.result; - } + PadState[port][slot].open = 0; + return buffer.padResult.result; } unsigned char padRead(int port, int slot, struct padButtonStatus *data) { + if ((unsigned int)port >= (sizeof(PadState)/sizeof(PadState[0]))) + return 0; + if ((unsigned int)slot >= (sizeof(PadState[0])/sizeof(PadState[0][0]))) + return 0; - struct pad_data *pdata; + switch (PadState[port][slot].open) + { + case 1: + { + struct pad_data_old *pdata; + + pdata = padGetDmaStrOld(port, slot); - pdata = padGetDmaStr(port, slot); + memcpy(data, pdata->data, pdata->length); + return pdata->length; + } + case 2: + { + struct pad_data_new *pdata; - memcpy(data, pdata->data, pdata->length); - return pdata->length; + pdata = padGetDmaStrNew(port, slot); + + memcpy(data, pdata->data, pdata->length); + return pdata->length; + } + default: + return 0; + } } int padGetState(int port, int slot) { - struct pad_data *pdata; - unsigned char state; - - - pdata = padGetDmaStr(port, slot); - - state = pdata->state; + if ((unsigned int)port >= (sizeof(PadState)/sizeof(PadState[0]))) + return 0; + if ((unsigned int)slot >= (sizeof(PadState[0])/sizeof(PadState[0][0]))) + return 0; -#ifdef _XPAD - if (state == PAD_STATE_ERROR) + switch (PadState[port][slot].open) { - if (pdata->findPadRetries) + case 1: { - return PAD_STATE_FINDPAD; + const struct pad_data_old *pdata; + unsigned char state; + + pdata = padGetDmaStrOld(port, slot); + state = pdata->state; + + if (state == PAD_STATE_STABLE && padGetReqState(port, slot) == PAD_RSTAT_BUSY) // Ok + return PAD_STATE_EXECCMD; + return state; } - } -#endif + case 2: + { + const struct pad_data_new *pdata; + unsigned char state; - if (state == PAD_STATE_STABLE) { // Ok - if (padGetReqState(port, slot) == PAD_RSTAT_BUSY) { - return PAD_STATE_EXECCMD; + pdata = padGetDmaStrNew(port, slot); + state = pdata->state; + + if (state == PAD_STATE_ERROR && pdata->findPadRetries) + return PAD_STATE_FINDPAD; + + if (state == PAD_STATE_STABLE && padGetReqState(port, slot) == PAD_RSTAT_BUSY) // Ok + return PAD_STATE_EXECCMD; + return state; } + default: + return 0; } - return state; } unsigned char padGetReqState(int port, int slot) { + if ((unsigned int)port >= (sizeof(PadState)/sizeof(PadState[0]))) + return 0; + if ((unsigned int)slot >= (sizeof(PadState[0])/sizeof(PadState[0][0]))) + return 0; - struct pad_data *pdata; - - pdata = padGetDmaStr(port, slot); - return pdata->reqState; + switch (PadState[port][slot].open) + { + case 1: + return padGetDmaStrOld(port, slot)->reqState; + case 2: + return padGetDmaStrNew(port, slot)->reqState; + default: + return 0; + } } int padSetReqState(int port, int slot, int state) { + if ((unsigned int)port >= (sizeof(PadState)/sizeof(PadState[0]))) + return 0; + if ((unsigned int)slot >= (sizeof(PadState[0])/sizeof(PadState[0][0]))) + return 0; - struct pad_data *pdata; - - pdata = padGetDmaStr(port, slot); - pdata->reqState = state; - return 1; + switch (PadState[port][slot].open) + { + case 1: + padGetDmaStrOld(port, slot)->reqState = state; + return 1; + case 2: + padGetDmaStrNew(port, slot)->reqState = state; + return 1; + default: + return 0; + } } void padStateInt2String(int state, char buf[16]) { - - if(state < 8) { + if ((unsigned int)state < (sizeof(padStateString)/sizeof(padStateString[0]))) strcpy(buf, padStateString[state]); - } } void padReqStateInt2String(int state, char buf[16]) { - if(state < 3) + if ((unsigned int)state < (sizeof(padReqStateString)/sizeof(padReqStateString[0]))) strcpy(buf, padReqStateString[state]); } int padGetPortMax(void) { + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_GET_PORTMAX_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_GET_PORTMAX_NEW; + break; + } + default: + return -1; + } - buffer.command = PAD_RPCCMD_GET_PORTMAX; - - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return -1; return buffer.padResult.result; @@ -561,11 +765,24 @@ padGetPortMax(void) int padGetSlotMax(int port) { - - buffer.padSlotMaxArgs.command = PAD_RPCCMD_GET_SLOTMAX; + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_GET_SLOTMAX_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_GET_SLOTMAX_NEW; + break; + } + default: + return -1; + } buffer.padSlotMaxArgs.port = port; - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return -1; return buffer.padResult.result; @@ -574,118 +791,112 @@ padGetSlotMax(int port) int padGetModVersion() { -#ifdef _XPAD + if (padInitialised != 2) + return 1; // Well.. return a low version # buffer.command = PAD_RPCCMD_GET_MODVER; - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return -1; return buffer.padResult.result; -#else - return 1; // Well.. return a low version # -#endif } int padInfoMode(int port, int slot, int infoMode, int index) { -#ifdef _XPAD - struct pad_data *pdata; - - pdata = padGetDmaStr(port, slot); - - if (pdata->currentTask != 1) + if ((unsigned int)port >= (sizeof(PadState)/sizeof(PadState[0]))) return 0; - if (pdata->reqState == PAD_RSTAT_BUSY) + if ((unsigned int)slot >= (sizeof(PadState[0])/sizeof(PadState[0][0]))) return 0; - switch(infoMode) { - case PAD_MODECURID: - if (pdata->modeCurId == 0xF3) - return 0; - else - return (pdata->modeCurId >> 4); - break; - - case PAD_MODECUREXID: - if (pdata->modeConfig == pdata->currentTask) - return 0; - return pdata->modeTable[pdata->modeCurOffs]; - break; - - case PAD_MODECUROFFS: - if (pdata->modeConfig != 0) - return pdata->modeCurOffs; - else - return 0; - break; - - case PAD_MODETABLE: - if (pdata->modeConfig != 0) { - if(index == -1) { - return pdata->nrOfModes; - } - else if (index < pdata->nrOfModes) { - return pdata->modeTable[index]; - } - else { + switch (PadState[port][slot].open) + { + case 1: + { + buffer.command = PAD_RPCCMD_INFO_MODE; + buffer.padInfoModeArgs.port = port; + buffer.padInfoModeArgs.slot = slot; + buffer.padInfoModeArgs.infoMode = infoMode; + buffer.padInfoModeArgs.index = index; + + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) + return 0; + + if (buffer.padModeResult.result == 1) + padSetReqState(port, slot, PAD_RSTAT_BUSY); + return buffer.padModeResult.result; + } + case 2: + { + struct pad_data_new *pdata; + + pdata = padGetDmaStrNew(port, slot); + + if (pdata->currentTask != 1) + return 0; + if (pdata->reqState == PAD_RSTAT_BUSY) + return 0; + + switch (infoMode) + { + case PAD_MODECURID: + return (pdata->modeCurId == 0xF3) ? 0 : (pdata->modeCurId >> 4); + case PAD_MODECUREXID: + return (pdata->modeConfig == pdata->currentTask || ((unsigned int)(pdata->modeCurOffs) >= (sizeof(pdata->modeTable)/sizeof(pdata->modeTable[0])))) ? 0 : pdata->modeTable[pdata->modeCurOffs]; + case PAD_MODECUROFFS: + return (pdata->modeConfig == 0) ? 0 : pdata->modeCurOffs; + case PAD_MODETABLE: + if (pdata->modeConfig != 0) { + if (index == -1) + return pdata->nrOfModes; + else if (index < pdata->nrOfModes && ((unsigned int)index <= (sizeof(pdata->modeTable)/sizeof(pdata->modeTable[0])))) + return pdata->modeTable[index]; + } + return 0; + default: return 0; } } - else - return 0; - break; - } - return 0; -#else - buffer.padInfoModeArgs.command = PAD_RPCCMD_INFO_MODE; - buffer.padInfoModeArgs.port = port; - buffer.padInfoModeArgs.slot = slot; - buffer.padInfoModeArgs.infoMode = infoMode; - buffer.padInfoModeArgs.index = index; - - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + default: return 0; - - if (buffer.padModeResult.result == 1) { - padSetReqState(port, slot, PAD_RSTAT_BUSY); } - return buffer.padModeResult.result; -#endif } int padSetMainMode(int port, int slot, int mode, int lock) { - - buffer.padSetMainModeArgs.command = PAD_RPCCMD_SET_MMODE; + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_SET_MMODE_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_SET_MMODE_NEW; + break; + } + default: + return -1; + } buffer.padSetMainModeArgs.port = port; buffer.padSetMainModeArgs.slot = slot; buffer.padSetMainModeArgs.mode = mode; buffer.padSetMainModeArgs.lock = lock; - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return 0; - if (buffer.padModeResult.result == 1) { + if (buffer.padModeResult.result == 1) padSetReqState(port, slot, PAD_RSTAT_BUSY); - } return buffer.padModeResult.result; } int padInfoPressMode(int port, int slot) { - int mask; - - mask = padGetButtonMask(port, slot); - - if (mask^0x3ffff) { - return 0; - } - else { - return 1; - } + return (padGetButtonMask(port, slot) ^ 0x3ffff) ? 0 : 1; } int @@ -698,18 +909,30 @@ int padExitPressMode(int port, int slot) { return padSetButtonInfo(port, slot, 0); - } int padGetButtonMask(int port, int slot) { - - buffer.padGetButtonMaskArgs.command = PAD_RPCCMD_GET_BTNMASK; + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_GET_BTNMASK_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_GET_BTNMASK_NEW; + break; + } + default: + return -1; + } buffer.padGetButtonMaskArgs.port = port; buffer.padGetButtonMaskArgs.slot = slot; - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return 0; return buffer.padResult.result; @@ -718,101 +941,141 @@ padGetButtonMask(int port, int slot) int padSetButtonInfo(int port, int slot, int buttonInfo) { - int val; - - buffer.padSetButtonInfoArgs.command = PAD_RPCCMD_SET_BTNINFO; + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_SET_BTNINFO_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_SET_BTNINFO_NEW; + break; + } + default: + return -1; + } buffer.padSetButtonInfoArgs.port = port; buffer.padSetButtonInfoArgs.slot = slot; buffer.padSetButtonInfoArgs.buttonInfo = buttonInfo; - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return 0; - val = buffer.padSetButtonInfoResult.result; - - if (val == 1) { + if (buffer.padSetButtonInfoResult.result == 1) padSetReqState(port, slot, PAD_RSTAT_BUSY); - } return buffer.padSetButtonInfoResult.result; } unsigned char padInfoAct(int port, int slot, int actuator, int cmd) { -#ifdef _XPAD - struct pad_data *pdata; - - pdata = padGetDmaStr(port, slot); - - if (pdata->currentTask != 1) + if ((unsigned int)port >= (sizeof(PadState)/sizeof(PadState[0]))) return 0; - if (pdata->modeConfig < 2) - return 0; - if (actuator >= pdata->nrOfActuators) + if ((unsigned int)slot >= (sizeof(PadState[0])/sizeof(PadState[0][0]))) return 0; - if (actuator == -1) - return pdata->nrOfActuators; // # of acutators? + switch (PadState[port][slot].open) + { + case 1: + { + buffer.command = PAD_RPCCMD_INFO_ACT; + buffer.padInfoActArgs.port = port; + buffer.padInfoActArgs.slot = slot; + buffer.padInfoActArgs.actuator = actuator; + buffer.padInfoActArgs.act_cmd = cmd; - if (cmd >= 4) - return 0; + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) + return 0; - return pdata->actData[actuator*4+cmd]; -#else - buffer.padInfoActArgs.command = PAD_RPCCMD_INFO_ACT; - buffer.padInfoActArgs.port = port; - buffer.padInfoActArgs.slot = slot; - buffer.padInfoActArgs.actuator = actuator; - buffer.padInfoActArgs.act_cmd = cmd; + if (buffer.padModeResult.result == 1) + padSetReqState(port, slot, PAD_RSTAT_BUSY); + return buffer.padModeResult.result; + } + case 2: + { + struct pad_data_new *pdata; - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) - return 0; + pdata = padGetDmaStrNew(port, slot); - if (buffer.padModeResult.result == 1) { - padSetReqState(port, slot, PAD_RSTAT_BUSY); + if (pdata->currentTask != 1) + return 0; + if (pdata->modeConfig < 2) + return 0; + if (actuator >= pdata->nrOfActuators) + return 0; + + if (actuator == -1) + return pdata->nrOfActuators; // # of acutators? + + if ((unsigned int)actuator >= (sizeof(pdata->actData)/sizeof(pdata->actData[0]))) + return 0; + if ((unsigned int)cmd >= (sizeof(pdata->actData[0])/sizeof(pdata->actData[0][0]))) + return 0; + + return pdata->actData[actuator][cmd]; + } + default: + return 0; } - return buffer.padModeResult.result; -#endif } int padSetActAlign(int port, int slot, const char actAlign[6]) { - int i; - s8 *ptr; - - buffer.padActDirAlignArgs.command = PAD_RPCCMD_SET_ACTALIGN; + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_SET_ACTALIGN_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_SET_ACTALIGN_NEW; + break; + } + default: + return -1; + } buffer.padActDirAlignArgs.port = port; buffer.padActDirAlignArgs.slot = slot; - ptr = buffer.padActDirAlignArgs.align; - for (i=0; i<6; i++) - ptr[i]=actAlign[i]; + memcpy(buffer.padActDirAlignArgs.align, actAlign, sizeof(buffer.padActDirAlignArgs.align)); - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return 0; - if (buffer.padModeResult.result == 1) { + if (buffer.padModeResult.result == 1) padSetReqState(port, slot, PAD_RSTAT_BUSY); - } return buffer.padModeResult.result; } int -padSetActDirect(int port, int slot, char actAlign[6]) +padSetActDirect(int port, int slot, const char actAlign[6]) { - int i; - s8 *ptr; - - buffer.padActDirAlignArgs.command = PAD_RPCCMD_SET_ACTDIR; + switch (padInitialised) + { + case 1: + { + buffer.command = PAD_RPCCMD_SET_ACTDIR_OLD; + break; + } + case 2: + { + buffer.command = PAD_RPCCMD_SET_ACTDIR_NEW; + break; + } + default: + return -1; + } buffer.padActDirAlignArgs.port = port; buffer.padActDirAlignArgs.slot = slot; - ptr = buffer.padActDirAlignArgs.align; - for (i=0; i<6; i++) - ptr[i]=actAlign[i]; + memcpy(buffer.padActDirAlignArgs.align, actAlign, sizeof(buffer.padActDirAlignArgs.align)); - if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, 128, &buffer, 128, NULL, NULL) < 0) + if (sceSifCallRpc(&padsif[0], 1, 0, &buffer, sizeof(buffer), &buffer, sizeof(buffer), NULL, NULL) < 0) return 0; return buffer.padModeResult.result; @@ -824,15 +1087,12 @@ padSetActDirect(int port, int slot, char actAlign[6]) int padGetConnection(int port, int slot) { -#ifdef _XPAD - struct open_slot *oslot; + struct open_slot* oslt; - oslot = padGetConnDmaStr(); - - return ((oslot->openSlots[port] >> slot) & 0x1); -#else - (void)port; - (void)slot; - return 1; -#endif + if (padInitialised != 2) + return 1; + oslt = padGetConnDmaStr(); + if ((unsigned int)slot >= (sizeof(oslt->openSlots)/sizeof(oslt->openSlots[0]))) + return 1; + return ((oslt->openSlots[port] >> slot) & 0x1); }