2012-11-01 15:19:01 +00:00
|
|
|
// Copyright (c) 2012- PPSSPP Project.
|
|
|
|
|
|
|
|
// 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
|
2012-11-04 22:01:49 +00:00
|
|
|
// the Free Software Foundation, version 2.0 or later versions.
|
2012-11-01 15:19:01 +00:00
|
|
|
|
|
|
|
// 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 2.0 for more details.
|
|
|
|
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
|
|
|
|
// Official git repository and contact information can be found at
|
|
|
|
// https://github.com/hrydgard/ppsspp and http://www.ppsspp.org/.
|
|
|
|
|
2013-04-18 04:53:38 +00:00
|
|
|
#include <math.h>
|
2014-04-20 04:43:27 +00:00
|
|
|
#include "Globals.h"
|
2013-08-29 06:15:13 +00:00
|
|
|
#include "Core/HLE/HLE.h"
|
2014-03-15 18:22:19 +00:00
|
|
|
#include "Core/HLE/FunctionWrappers.h"
|
2013-08-29 06:15:13 +00:00
|
|
|
#include "Core/MIPS/MIPS.h"
|
|
|
|
#include "Core/CoreTiming.h"
|
2014-03-15 18:22:19 +00:00
|
|
|
#include "Core/MemMap.h"
|
2013-08-29 06:15:13 +00:00
|
|
|
#include "Common/ChunkFile.h"
|
|
|
|
#include "Common/StdMutex.h"
|
|
|
|
#include "Core/HLE/sceCtrl.h"
|
|
|
|
#include "Core/HLE/sceDisplay.h"
|
|
|
|
#include "Core/HLE/sceKernel.h"
|
|
|
|
#include "Core/HLE/sceKernelThread.h"
|
|
|
|
#include "Core/HLE/sceKernelInterrupt.h"
|
2012-11-01 15:19:01 +00:00
|
|
|
|
|
|
|
/* Index for the two analog directions */
|
|
|
|
#define CTRL_ANALOG_X 0
|
|
|
|
#define CTRL_ANALOG_Y 1
|
2013-07-07 02:02:28 +00:00
|
|
|
#define CTRL_ANALOG_CENTER 128
|
2012-11-01 15:19:01 +00:00
|
|
|
|
2012-11-11 23:09:27 +00:00
|
|
|
#define CTRL_MODE_DIGITAL 0
|
|
|
|
#define CTRL_MODE_ANALOG 1
|
|
|
|
|
2013-02-18 17:04:43 +00:00
|
|
|
const u32 NUM_CTRL_BUFFERS = 64;
|
2012-12-03 05:07:17 +00:00
|
|
|
|
2013-09-07 19:19:21 +00:00
|
|
|
enum {
|
2012-12-03 01:03:13 +00:00
|
|
|
CTRL_WAIT_POSITIVE = 1,
|
|
|
|
CTRL_WAIT_NEGATIVE = 2,
|
|
|
|
};
|
|
|
|
|
2012-11-01 15:19:01 +00:00
|
|
|
// Returned control data
|
|
|
|
struct _ctrl_data
|
|
|
|
{
|
2013-07-27 22:30:36 +00:00
|
|
|
u32_le frame;
|
|
|
|
u32_le buttons;
|
2013-07-07 02:02:28 +00:00
|
|
|
// The PSP has only one stick, but has space for more info.
|
|
|
|
// The second stick is populated for HD remasters and possibly in the PSP emulator on PS3/Vita.
|
2013-07-27 22:30:36 +00:00
|
|
|
u8 analog[2][2];
|
|
|
|
u8 unused[4];
|
2012-11-01 15:19:01 +00:00
|
|
|
};
|
|
|
|
|
2012-11-08 15:28:45 +00:00
|
|
|
struct CtrlLatch {
|
2013-07-27 22:30:36 +00:00
|
|
|
u32_le btnMake;
|
|
|
|
u32_le btnBreak;
|
|
|
|
u32_le btnPress;
|
|
|
|
u32_le btnRelease;
|
2012-11-08 15:28:45 +00:00
|
|
|
};
|
|
|
|
|
2012-11-01 15:19:01 +00:00
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
// STATE BEGIN
|
|
|
|
static bool analogEnabled = false;
|
2012-11-26 06:10:25 +00:00
|
|
|
static int ctrlLatchBufs = 0;
|
|
|
|
static u32 ctrlOldButtons = 0;
|
2012-11-09 18:04:57 +00:00
|
|
|
|
2012-12-03 05:07:17 +00:00
|
|
|
static _ctrl_data ctrlBufs[NUM_CTRL_BUFFERS];
|
2012-12-02 23:44:23 +00:00
|
|
|
static _ctrl_data ctrlCurrent;
|
2013-02-18 17:04:43 +00:00
|
|
|
static u32 ctrlBuf = 0;
|
|
|
|
static u32 ctrlBufRead = 0;
|
2012-11-09 18:04:57 +00:00
|
|
|
static CtrlLatch latch;
|
2013-09-29 08:21:30 +00:00
|
|
|
static u32 dialogBtnMake = 0;
|
2012-11-09 18:04:57 +00:00
|
|
|
|
2012-12-23 02:41:49 +00:00
|
|
|
static int ctrlIdleReset = -1;
|
|
|
|
static int ctrlIdleBack = -1;
|
|
|
|
|
2012-12-23 05:23:28 +00:00
|
|
|
static int ctrlCycle = 0;
|
2012-12-23 04:31:22 +00:00
|
|
|
|
2012-12-03 01:03:13 +00:00
|
|
|
static std::vector<SceUID> waitingThreads;
|
2012-11-01 15:19:01 +00:00
|
|
|
static std::recursive_mutex ctrlMutex;
|
2012-11-09 18:04:57 +00:00
|
|
|
|
2012-12-23 05:23:28 +00:00
|
|
|
static int ctrlTimer = -1;
|
|
|
|
|
2012-11-01 15:19:01 +00:00
|
|
|
// STATE END
|
|
|
|
//////////////////////////////////////////////////////////////////////////
|
|
|
|
|
2013-07-07 01:54:33 +00:00
|
|
|
// Not savestated, this is emu state.
|
|
|
|
// Not related to sceCtrl*RapidFire(), although it may do the same thing.
|
|
|
|
static bool emuRapidFire = false;
|
|
|
|
static u32 emuRapidFireFrames = 0;
|
|
|
|
|
|
|
|
// These buttons are not affected by rapid fire (neither is analog.)
|
|
|
|
const u32 CTRL_EMU_RAPIDFIRE_MASK = CTRL_UP | CTRL_DOWN | CTRL_LEFT | CTRL_RIGHT;
|
2012-11-01 15:19:01 +00:00
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static void __CtrlUpdateLatch()
|
2012-11-26 04:59:52 +00:00
|
|
|
{
|
2012-11-26 06:10:25 +00:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
2013-07-07 01:54:33 +00:00
|
|
|
|
|
|
|
// Copy in the current data to the current buffer.
|
|
|
|
ctrlBufs[ctrlBuf] = ctrlCurrent;
|
|
|
|
u32 buttons = ctrlCurrent.buttons;
|
|
|
|
if (emuRapidFire && (emuRapidFireFrames % 10) < 5)
|
|
|
|
{
|
|
|
|
ctrlBufs[ctrlBuf].buttons &= CTRL_EMU_RAPIDFIRE_MASK;
|
|
|
|
buttons &= CTRL_EMU_RAPIDFIRE_MASK;
|
|
|
|
}
|
2012-11-26 06:10:25 +00:00
|
|
|
|
2013-07-07 01:54:33 +00:00
|
|
|
u32 changed = buttons ^ ctrlOldButtons;
|
|
|
|
latch.btnMake |= buttons & changed;
|
2012-11-26 06:10:25 +00:00
|
|
|
latch.btnBreak |= ctrlOldButtons & changed;
|
2013-07-07 01:54:33 +00:00
|
|
|
latch.btnPress |= buttons;
|
2013-11-16 23:27:19 +00:00
|
|
|
latch.btnRelease |= ~buttons;
|
2013-09-29 08:21:30 +00:00
|
|
|
dialogBtnMake |= buttons & changed;
|
2012-11-26 06:10:25 +00:00
|
|
|
ctrlLatchBufs++;
|
2012-11-09 18:04:57 +00:00
|
|
|
|
2013-07-07 01:54:33 +00:00
|
|
|
ctrlOldButtons = buttons;
|
2012-12-02 23:44:23 +00:00
|
|
|
|
2013-10-24 08:10:09 +00:00
|
|
|
ctrlBufs[ctrlBuf].frame = (u32) CoreTiming::GetGlobalTimeUs();
|
2012-12-02 23:44:23 +00:00
|
|
|
if (!analogEnabled)
|
2013-07-07 02:02:28 +00:00
|
|
|
memset(ctrlBufs[ctrlBuf].analog, CTRL_ANALOG_CENTER, sizeof(ctrlBufs[ctrlBuf].analog));
|
2012-12-02 23:44:23 +00:00
|
|
|
|
2012-12-03 05:07:17 +00:00
|
|
|
ctrlBuf = (ctrlBuf + 1) % NUM_CTRL_BUFFERS;
|
2012-12-02 23:44:23 +00:00
|
|
|
|
|
|
|
// If we wrapped around, push the read head forward.
|
|
|
|
// TODO: Is this right?
|
|
|
|
if (ctrlBufRead == ctrlBuf)
|
2012-12-03 05:07:17 +00:00
|
|
|
ctrlBufRead = (ctrlBufRead + 1) % NUM_CTRL_BUFFERS;
|
2012-11-09 18:04:57 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int __CtrlResetLatch()
|
2012-11-26 06:10:25 +00:00
|
|
|
{
|
|
|
|
int oldBufs = ctrlLatchBufs;
|
|
|
|
memset(&latch, 0, sizeof(CtrlLatch));
|
|
|
|
ctrlLatchBufs = 0;
|
|
|
|
return oldBufs;
|
|
|
|
}
|
2012-11-18 16:51:14 +00:00
|
|
|
|
|
|
|
u32 __CtrlPeekButtons()
|
|
|
|
{
|
2012-12-02 23:44:23 +00:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
2012-11-26 04:59:52 +00:00
|
|
|
|
2012-12-02 23:44:23 +00:00
|
|
|
return ctrlCurrent.buttons;
|
2012-11-18 16:51:14 +00:00
|
|
|
}
|
|
|
|
|
2013-07-20 10:54:33 +00:00
|
|
|
void __CtrlPeekAnalog(int stick, float *x, float *y)
|
|
|
|
{
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
|
|
|
|
2013-07-20 19:11:35 +00:00
|
|
|
*x = (ctrlCurrent.analog[stick][CTRL_ANALOG_X] - 127.5f) / 127.5f;
|
|
|
|
*y = -(ctrlCurrent.analog[stick][CTRL_ANALOG_Y] - 127.5f) / 127.5f;
|
2013-07-20 10:54:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2012-12-23 16:59:34 +00:00
|
|
|
u32 __CtrlReadLatch()
|
|
|
|
{
|
2013-09-29 08:21:30 +00:00
|
|
|
u32 ret = dialogBtnMake;
|
|
|
|
dialogBtnMake = 0;
|
2012-12-23 16:59:34 +00:00
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-11-01 15:19:01 +00:00
|
|
|
// Functions so that the rest of the emulator can control what the sceCtrl interface should return
|
|
|
|
// to the game:
|
|
|
|
|
|
|
|
void __CtrlButtonDown(u32 buttonBit)
|
|
|
|
{
|
2012-11-26 04:59:52 +00:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
2012-12-02 23:44:23 +00:00
|
|
|
ctrlCurrent.buttons |= buttonBit;
|
2012-11-01 15:19:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void __CtrlButtonUp(u32 buttonBit)
|
|
|
|
{
|
2012-11-26 04:59:52 +00:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
2012-12-02 23:44:23 +00:00
|
|
|
ctrlCurrent.buttons &= ~buttonBit;
|
2012-11-01 15:19:01 +00:00
|
|
|
}
|
|
|
|
|
2013-07-06 17:08:59 +00:00
|
|
|
void __CtrlSetAnalogX(float x, int stick)
|
2012-11-01 15:19:01 +00:00
|
|
|
{
|
2012-11-26 04:59:52 +00:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
2014-04-20 04:43:27 +00:00
|
|
|
int scaled = (int)ceilf(x * 127.5f + 127.5f);
|
|
|
|
ctrlCurrent.analog[stick][CTRL_ANALOG_X] = clamp_u8(scaled);
|
2013-07-06 17:08:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void __CtrlSetAnalogY(float y, int stick)
|
|
|
|
{
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
2014-04-20 04:43:27 +00:00
|
|
|
int scaled = (int)ceilf(-y * 127.5f + 127.5f);
|
|
|
|
ctrlCurrent.analog[stick][CTRL_ANALOG_Y] = clamp_u8(scaled);
|
2012-12-02 23:44:23 +00:00
|
|
|
}
|
2012-11-26 06:10:25 +00:00
|
|
|
|
2013-07-07 01:54:33 +00:00
|
|
|
void __CtrlSetRapidFire(bool state)
|
|
|
|
{
|
|
|
|
emuRapidFire = state;
|
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int __CtrlReadSingleBuffer(PSPPointer<_ctrl_data> data, bool negative)
|
2012-12-03 01:03:13 +00:00
|
|
|
{
|
2013-07-07 01:54:33 +00:00
|
|
|
if (data.IsValid())
|
2012-12-03 01:03:13 +00:00
|
|
|
{
|
2013-07-07 01:54:33 +00:00
|
|
|
*data = ctrlBufs[ctrlBufRead];
|
2012-12-03 05:07:17 +00:00
|
|
|
ctrlBufRead = (ctrlBufRead + 1) % NUM_CTRL_BUFFERS;
|
2012-12-03 01:03:13 +00:00
|
|
|
|
|
|
|
if (negative)
|
2013-07-07 01:54:33 +00:00
|
|
|
data->buttons = ~data->buttons;
|
2012-12-03 01:03:13 +00:00
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int __CtrlReadBuffer(u32 ctrlDataPtr, u32 nBufs, bool negative, bool peek)
|
2012-12-03 01:03:13 +00:00
|
|
|
{
|
2012-12-03 05:07:17 +00:00
|
|
|
if (nBufs > NUM_CTRL_BUFFERS)
|
2013-01-05 23:30:31 +00:00
|
|
|
return SCE_KERNEL_ERROR_INVALID_SIZE;
|
2012-12-03 01:03:13 +00:00
|
|
|
|
2013-08-28 06:19:53 +00:00
|
|
|
if (!peek && !__KernelIsDispatchEnabled())
|
|
|
|
return SCE_KERNEL_ERROR_CAN_NOT_WAIT;
|
2013-08-29 06:15:13 +00:00
|
|
|
if (!peek && __IsInInterrupt())
|
|
|
|
return SCE_KERNEL_ERROR_ILLEGAL_CONTEXT;
|
2013-08-28 06:19:53 +00:00
|
|
|
|
2013-02-18 17:04:43 +00:00
|
|
|
u32 resetRead = ctrlBufRead;
|
2012-12-03 01:03:13 +00:00
|
|
|
|
2012-12-03 05:07:17 +00:00
|
|
|
u32 availBufs;
|
|
|
|
// Peeks always work, they just go go from now X buffers.
|
|
|
|
if (peek)
|
2012-12-03 03:53:20 +00:00
|
|
|
availBufs = nBufs;
|
2012-12-03 05:07:17 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
availBufs = (ctrlBuf - ctrlBufRead + NUM_CTRL_BUFFERS) % NUM_CTRL_BUFFERS;
|
|
|
|
if (availBufs > nBufs)
|
|
|
|
availBufs = nBufs;
|
|
|
|
}
|
|
|
|
ctrlBufRead = (ctrlBuf - availBufs + NUM_CTRL_BUFFERS) % NUM_CTRL_BUFFERS;
|
2012-12-03 03:53:20 +00:00
|
|
|
|
2012-12-03 01:03:13 +00:00
|
|
|
int done = 0;
|
2013-12-17 07:47:34 +00:00
|
|
|
auto data = PSPPointer<_ctrl_data>::Create(ctrlDataPtr);
|
2012-12-03 05:07:17 +00:00
|
|
|
for (u32 i = 0; i < availBufs; ++i)
|
2013-11-16 22:00:42 +00:00
|
|
|
done += __CtrlReadSingleBuffer(data++, negative);
|
2012-12-03 01:03:13 +00:00
|
|
|
|
|
|
|
if (peek)
|
|
|
|
ctrlBufRead = resetRead;
|
|
|
|
|
|
|
|
return done;
|
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static void __CtrlDoSample()
|
2012-12-02 23:44:23 +00:00
|
|
|
{
|
2012-12-23 05:23:28 +00:00
|
|
|
// This samples the ctrl data into the buffers and updates the latch.
|
2012-11-26 06:10:25 +00:00
|
|
|
__CtrlUpdateLatch();
|
2012-12-03 01:03:13 +00:00
|
|
|
|
|
|
|
// Wake up a single thread that was waiting for the buffer.
|
|
|
|
retry:
|
|
|
|
if (!waitingThreads.empty() && ctrlBuf != ctrlBufRead)
|
|
|
|
{
|
|
|
|
SceUID threadID = waitingThreads[0];
|
|
|
|
waitingThreads.erase(waitingThreads.begin());
|
|
|
|
|
|
|
|
u32 error;
|
|
|
|
SceUID wVal = __KernelGetWaitID(threadID, WAITTYPE_CTRL, error);
|
|
|
|
// Make sure it didn't get woken or something.
|
|
|
|
if (wVal == 0)
|
|
|
|
goto retry;
|
|
|
|
|
2013-11-16 22:00:42 +00:00
|
|
|
PSPPointer<_ctrl_data> ctrlDataPtr;
|
|
|
|
ctrlDataPtr = __KernelGetWaitValue(threadID, error);
|
2012-12-03 01:03:13 +00:00
|
|
|
int retVal = __CtrlReadSingleBuffer(ctrlDataPtr, wVal == CTRL_WAIT_NEGATIVE);
|
|
|
|
__KernelResumeThreadFromWait(threadID, retVal);
|
2014-06-24 07:44:40 +00:00
|
|
|
__KernelReSchedule("ctrl buffers updated");
|
2012-12-03 01:03:13 +00:00
|
|
|
}
|
2012-11-01 15:19:01 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static void __CtrlVblank()
|
2012-12-23 05:23:28 +00:00
|
|
|
{
|
2013-07-07 01:54:33 +00:00
|
|
|
emuRapidFireFrames++;
|
|
|
|
|
2012-12-23 05:23:28 +00:00
|
|
|
// This always runs, so make sure we're in vblank mode.
|
|
|
|
if (ctrlCycle == 0)
|
|
|
|
__CtrlDoSample();
|
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static void __CtrlTimerUpdate(u64 userdata, int cyclesLate)
|
2012-12-23 05:23:28 +00:00
|
|
|
{
|
|
|
|
// This only runs in timer mode (ctrlCycle > 0.)
|
2013-09-07 19:19:21 +00:00
|
|
|
_dbg_assert_msg_(SCECTRL, ctrlCycle > 0, "Ctrl: sampling cycle should be > 0");
|
2012-12-23 05:23:28 +00:00
|
|
|
|
2014-07-06 08:08:44 +00:00
|
|
|
CoreTiming::ScheduleEvent(usToCycles(ctrlCycle) - cyclesLate, ctrlTimer, 0);
|
2014-07-01 07:25:20 +00:00
|
|
|
|
|
|
|
__CtrlDoSample();
|
2012-12-23 05:23:28 +00:00
|
|
|
}
|
|
|
|
|
2012-12-02 23:44:23 +00:00
|
|
|
void __CtrlInit()
|
2012-11-01 15:19:01 +00:00
|
|
|
{
|
2012-12-24 05:27:26 +00:00
|
|
|
ctrlTimer = CoreTiming::RegisterEvent("CtrlSampleTimer", __CtrlTimerUpdate);
|
|
|
|
__DisplayListenVblank(__CtrlVblank);
|
2012-11-26 04:59:52 +00:00
|
|
|
|
2012-12-24 05:27:26 +00:00
|
|
|
ctrlIdleReset = -1;
|
|
|
|
ctrlIdleBack = -1;
|
|
|
|
ctrlCycle = 0;
|
|
|
|
|
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
2012-12-02 23:44:23 +00:00
|
|
|
|
2012-12-03 01:04:57 +00:00
|
|
|
ctrlBuf = 1;
|
2012-12-02 23:44:23 +00:00
|
|
|
ctrlBufRead = 0;
|
|
|
|
ctrlOldButtons = 0;
|
|
|
|
ctrlLatchBufs = 0;
|
2013-09-29 08:21:30 +00:00
|
|
|
dialogBtnMake = 0;
|
2012-12-02 23:44:23 +00:00
|
|
|
|
2012-11-26 06:10:25 +00:00
|
|
|
memset(&latch, 0, sizeof(latch));
|
2012-12-02 20:44:33 +00:00
|
|
|
// Start with everything released.
|
|
|
|
latch.btnRelease = 0xffffffff;
|
|
|
|
|
2012-12-02 23:44:23 +00:00
|
|
|
memset(&ctrlCurrent, 0, sizeof(ctrlCurrent));
|
2013-07-07 02:02:28 +00:00
|
|
|
memset(ctrlCurrent.analog, CTRL_ANALOG_CENTER, sizeof(ctrlCurrent.analog));
|
2013-09-17 15:23:35 +00:00
|
|
|
analogEnabled = false;
|
2012-12-03 05:07:17 +00:00
|
|
|
|
2013-03-02 22:58:58 +00:00
|
|
|
for (u32 i = 0; i < NUM_CTRL_BUFFERS; i++)
|
2012-12-03 05:07:17 +00:00
|
|
|
memcpy(&ctrlBufs[i], &ctrlCurrent, sizeof(_ctrl_data));
|
2012-11-17 18:56:28 +00:00
|
|
|
}
|
|
|
|
|
2012-12-28 07:00:04 +00:00
|
|
|
void __CtrlDoState(PointerWrap &p)
|
|
|
|
{
|
2012-12-28 08:05:54 +00:00
|
|
|
std::lock_guard<std::recursive_mutex> guard(ctrlMutex);
|
2013-09-15 03:23:03 +00:00
|
|
|
|
2013-11-20 02:33:17 +00:00
|
|
|
auto s = p.Section("sceCtrl", 1, 3);
|
2013-09-15 03:23:03 +00:00
|
|
|
if (!s)
|
|
|
|
return;
|
2012-12-28 08:05:54 +00:00
|
|
|
|
2012-12-28 07:00:04 +00:00
|
|
|
p.Do(analogEnabled);
|
|
|
|
p.Do(ctrlLatchBufs);
|
|
|
|
p.Do(ctrlOldButtons);
|
|
|
|
|
|
|
|
p.DoVoid(ctrlBufs, sizeof(ctrlBufs));
|
2013-11-20 02:33:17 +00:00
|
|
|
if (s <= 2) {
|
|
|
|
_ctrl_data dummy = {0};
|
|
|
|
p.Do(dummy);
|
|
|
|
}
|
2012-12-28 07:00:04 +00:00
|
|
|
p.Do(ctrlBuf);
|
|
|
|
p.Do(ctrlBufRead);
|
|
|
|
p.Do(latch);
|
2013-09-29 09:30:17 +00:00
|
|
|
if (s == 1) {
|
|
|
|
dialogBtnMake = 0;
|
|
|
|
} else {
|
|
|
|
p.Do(dialogBtnMake);
|
|
|
|
}
|
2012-12-28 07:00:04 +00:00
|
|
|
|
|
|
|
p.Do(ctrlIdleReset);
|
|
|
|
p.Do(ctrlIdleBack);
|
|
|
|
|
|
|
|
p.Do(ctrlCycle);
|
|
|
|
|
2012-12-28 21:01:46 +00:00
|
|
|
SceUID dv = 0;
|
|
|
|
p.Do(waitingThreads, dv);
|
2012-12-28 07:00:04 +00:00
|
|
|
|
|
|
|
p.Do(ctrlTimer);
|
|
|
|
CoreTiming::RestoreRegisterEvent(ctrlTimer, "CtrlSampleTimer", __CtrlTimerUpdate);
|
|
|
|
}
|
|
|
|
|
2012-12-24 09:41:15 +00:00
|
|
|
void __CtrlShutdown()
|
|
|
|
{
|
|
|
|
waitingThreads.clear();
|
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static u32 sceCtrlSetSamplingCycle(u32 cycle)
|
2012-11-26 04:59:52 +00:00
|
|
|
{
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "sceCtrlSetSamplingCycle(%u)", cycle);
|
2012-12-23 04:31:22 +00:00
|
|
|
|
|
|
|
if ((cycle > 0 && cycle < 5555) || cycle > 20000)
|
|
|
|
{
|
2013-09-07 19:19:21 +00:00
|
|
|
WARN_LOG(SCECTRL, "SCE_KERNEL_ERROR_INVALID_VALUE=sceCtrlSetSamplingCycle(%u)", cycle);
|
2012-12-23 04:31:22 +00:00
|
|
|
return SCE_KERNEL_ERROR_INVALID_VALUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
u32 prev = ctrlCycle;
|
|
|
|
ctrlCycle = cycle;
|
|
|
|
|
2012-12-23 05:23:28 +00:00
|
|
|
if (prev > 0)
|
|
|
|
CoreTiming::UnscheduleEvent(ctrlTimer, 0);
|
|
|
|
if (cycle > 0)
|
|
|
|
CoreTiming::ScheduleEvent(usToCycles(ctrlCycle), ctrlTimer, 0);
|
|
|
|
|
2012-12-23 04:31:22 +00:00
|
|
|
return prev;
|
2012-11-26 04:59:52 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int sceCtrlGetSamplingCycle(u32 cyclePtr)
|
2012-11-26 04:59:52 +00:00
|
|
|
{
|
2013-09-19 07:28:57 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "sceCtrlGetSamplingCycle(%08x)", cyclePtr);
|
2012-12-23 04:31:22 +00:00
|
|
|
if (Memory::IsValidAddress(cyclePtr))
|
|
|
|
Memory::Write_U32(ctrlCycle, cyclePtr);
|
2012-11-26 04:59:52 +00:00
|
|
|
return 0;
|
2012-11-01 15:19:01 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static u32 sceCtrlSetSamplingMode(u32 mode)
|
2012-11-01 15:19:01 +00:00
|
|
|
{
|
2012-11-11 23:09:27 +00:00
|
|
|
u32 retVal = 0;
|
|
|
|
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "sceCtrlSetSamplingMode(%i)", mode);
|
2012-11-26 04:59:52 +00:00
|
|
|
if (mode > 1)
|
2013-04-01 06:42:56 +00:00
|
|
|
return SCE_KERNEL_ERROR_INVALID_MODE;
|
2012-11-11 23:09:27 +00:00
|
|
|
|
2012-11-26 04:59:52 +00:00
|
|
|
retVal = analogEnabled == true ? CTRL_MODE_ANALOG : CTRL_MODE_DIGITAL;
|
|
|
|
analogEnabled = mode == CTRL_MODE_ANALOG ? true : false;
|
2012-11-11 23:09:27 +00:00
|
|
|
return retVal;
|
2012-11-01 15:19:01 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int sceCtrlGetSamplingMode(u32 modePtr)
|
2012-11-26 04:59:52 +00:00
|
|
|
{
|
|
|
|
u32 retVal = analogEnabled == true ? CTRL_MODE_ANALOG : CTRL_MODE_DIGITAL;
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "%d=sceCtrlGetSamplingMode(%08x)", retVal, modePtr);
|
2012-11-26 04:59:52 +00:00
|
|
|
|
|
|
|
if (Memory::IsValidAddress(modePtr))
|
|
|
|
Memory::Write_U32(retVal, modePtr);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int sceCtrlSetIdleCancelThreshold(int idleReset, int idleBack)
|
2012-11-01 15:19:01 +00:00
|
|
|
{
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "FAKE sceCtrlSetIdleCancelThreshold(%d, %d)", idleReset, idleBack);
|
2012-12-23 02:41:49 +00:00
|
|
|
|
|
|
|
if (idleReset < -1 || idleBack < -1 || idleReset > 128 || idleBack > 128)
|
|
|
|
return SCE_KERNEL_ERROR_INVALID_VALUE;
|
|
|
|
|
|
|
|
ctrlIdleReset = idleReset;
|
|
|
|
ctrlIdleBack = idleBack;
|
2012-12-23 02:30:14 +00:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int sceCtrlGetIdleCancelThreshold(u32 idleResetPtr, u32 idleBackPtr)
|
2012-12-23 02:30:14 +00:00
|
|
|
{
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "sceCtrlSetIdleCancelThreshold(%08x, %08x)", idleResetPtr, idleBackPtr);
|
2012-12-23 02:41:49 +00:00
|
|
|
|
|
|
|
if (idleResetPtr && !Memory::IsValidAddress(idleResetPtr))
|
2014-04-03 16:12:22 +00:00
|
|
|
return SCE_KERNEL_ERROR_PRIV_REQUIRED;
|
2012-12-23 02:41:49 +00:00
|
|
|
if (idleBackPtr && !Memory::IsValidAddress(idleBackPtr))
|
2014-04-03 16:12:22 +00:00
|
|
|
return SCE_KERNEL_ERROR_PRIV_REQUIRED;
|
2012-12-23 02:41:49 +00:00
|
|
|
|
|
|
|
if (idleResetPtr)
|
|
|
|
Memory::Write_U32(ctrlIdleReset, idleResetPtr);
|
|
|
|
if (idleBackPtr)
|
|
|
|
Memory::Write_U32(ctrlIdleBack, idleBackPtr);
|
|
|
|
|
2012-12-23 02:30:14 +00:00
|
|
|
return 0;
|
2012-11-01 15:19:01 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static void sceCtrlReadBufferPositive(u32 ctrlDataPtr, u32 nBufs)
|
2012-11-26 04:59:52 +00:00
|
|
|
{
|
2012-12-03 01:03:13 +00:00
|
|
|
int done = __CtrlReadBuffer(ctrlDataPtr, nBufs, false, false);
|
2013-05-28 08:35:46 +00:00
|
|
|
hleEatCycles(330);
|
2012-12-03 01:03:13 +00:00
|
|
|
if (done != 0)
|
2012-12-03 03:53:20 +00:00
|
|
|
{
|
2012-12-03 01:03:13 +00:00
|
|
|
RETURN(done);
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "%d=sceCtrlReadBufferPositive(%08x, %i)", done, ctrlDataPtr, nBufs);
|
2012-12-03 03:53:20 +00:00
|
|
|
}
|
2012-12-03 01:03:13 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
waitingThreads.push_back(__KernelGetCurThread());
|
2013-01-26 18:44:04 +00:00
|
|
|
__KernelWaitCurThread(WAITTYPE_CTRL, CTRL_WAIT_POSITIVE, ctrlDataPtr, 0, false, "ctrl buffer waited");
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "sceCtrlReadBufferPositive(%08x, %i) - waiting", ctrlDataPtr, nBufs);
|
2012-12-03 01:03:13 +00:00
|
|
|
}
|
2012-12-02 23:44:23 +00:00
|
|
|
}
|
2012-11-26 04:59:52 +00:00
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static void sceCtrlReadBufferNegative(u32 ctrlDataPtr, u32 nBufs)
|
2012-12-02 23:44:23 +00:00
|
|
|
{
|
2012-12-03 01:03:13 +00:00
|
|
|
int done = __CtrlReadBuffer(ctrlDataPtr, nBufs, true, false);
|
2013-05-28 08:35:46 +00:00
|
|
|
hleEatCycles(330);
|
2012-12-03 01:03:13 +00:00
|
|
|
if (done != 0)
|
2012-12-03 03:53:20 +00:00
|
|
|
{
|
2012-12-03 01:03:13 +00:00
|
|
|
RETURN(done);
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "%d=sceCtrlReadBufferNegative(%08x, %i)", done, ctrlDataPtr, nBufs);
|
2012-12-03 03:53:20 +00:00
|
|
|
}
|
2012-12-03 01:03:13 +00:00
|
|
|
else
|
|
|
|
{
|
|
|
|
waitingThreads.push_back(__KernelGetCurThread());
|
2013-01-26 18:44:04 +00:00
|
|
|
__KernelWaitCurThread(WAITTYPE_CTRL, CTRL_WAIT_NEGATIVE, ctrlDataPtr, 0, false, "ctrl buffer waited");
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "sceCtrlReadBufferNegative(%08x, %i) - waiting", ctrlDataPtr, nBufs);
|
2012-12-03 01:03:13 +00:00
|
|
|
}
|
2012-12-02 23:44:23 +00:00
|
|
|
}
|
2012-11-26 05:44:01 +00:00
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int sceCtrlPeekBufferPositive(u32 ctrlDataPtr, u32 nBufs)
|
2012-12-02 23:44:23 +00:00
|
|
|
{
|
2012-12-03 03:53:20 +00:00
|
|
|
int done = __CtrlReadBuffer(ctrlDataPtr, nBufs, false, true);
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "%d=sceCtrlPeekBufferPositive(%08x, %i)", done, ctrlDataPtr, nBufs);
|
2013-05-28 08:35:46 +00:00
|
|
|
hleEatCycles(330);
|
2012-12-03 03:53:20 +00:00
|
|
|
return done;
|
2012-12-02 23:44:23 +00:00
|
|
|
}
|
2012-11-26 04:59:52 +00:00
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static int sceCtrlPeekBufferNegative(u32 ctrlDataPtr, u32 nBufs)
|
2012-12-02 23:44:23 +00:00
|
|
|
{
|
2012-12-03 03:53:20 +00:00
|
|
|
int done = __CtrlReadBuffer(ctrlDataPtr, nBufs, true, true);
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "%d=sceCtrlPeekBufferNegative(%08x, %i)", done, ctrlDataPtr, nBufs);
|
2013-05-28 08:35:46 +00:00
|
|
|
hleEatCycles(330);
|
2012-12-03 03:53:20 +00:00
|
|
|
return done;
|
2012-11-01 15:19:01 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static u32 sceCtrlPeekLatch(u32 latchDataPtr)
|
2012-11-26 04:59:52 +00:00
|
|
|
{
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "sceCtrlPeekLatch(%08x)", latchDataPtr);
|
2012-11-26 06:10:25 +00:00
|
|
|
|
2012-11-09 18:04:57 +00:00
|
|
|
if (Memory::IsValidAddress(latchDataPtr))
|
|
|
|
Memory::WriteStruct(latchDataPtr, &latch);
|
2012-12-02 23:44:23 +00:00
|
|
|
|
2012-11-26 06:10:25 +00:00
|
|
|
return ctrlLatchBufs;
|
2012-11-08 15:28:45 +00:00
|
|
|
}
|
|
|
|
|
2014-12-08 09:40:08 +00:00
|
|
|
static u32 sceCtrlReadLatch(u32 latchDataPtr)
|
2012-11-26 04:59:52 +00:00
|
|
|
{
|
2013-09-07 19:19:21 +00:00
|
|
|
DEBUG_LOG(SCECTRL, "sceCtrlReadLatch(%08x)", latchDataPtr);
|
2012-11-09 18:04:57 +00:00
|
|
|
|
|
|
|
if (Memory::IsValidAddress(latchDataPtr))
|
|
|
|
Memory::WriteStruct(latchDataPtr, &latch);
|
2012-11-08 15:28:45 +00:00
|
|
|
|
2012-11-26 06:10:25 +00:00
|
|
|
return __CtrlResetLatch();
|
2012-11-08 15:28:45 +00:00
|
|
|
}
|
|
|
|
|
2012-11-01 15:19:01 +00:00
|
|
|
static const HLEFunction sceCtrl[] =
|
|
|
|
{
|
2012-12-23 03:37:18 +00:00
|
|
|
{0x3E65A0EA, 0, "sceCtrlInit"}, //(int unknown), init with 0
|
2012-11-26 04:59:52 +00:00
|
|
|
{0x1f4011e6, WrapU_U<sceCtrlSetSamplingMode>, "sceCtrlSetSamplingMode"}, //(int on);
|
|
|
|
{0x6A2774F3, WrapU_U<sceCtrlSetSamplingCycle>, "sceCtrlSetSamplingCycle"},
|
|
|
|
{0x02BAAD91, WrapI_U<sceCtrlGetSamplingCycle>,"sceCtrlGetSamplingCycle"},
|
|
|
|
{0xDA6B76A1, WrapI_U<sceCtrlGetSamplingMode>, "sceCtrlGetSamplingMode"},
|
2012-12-02 23:44:23 +00:00
|
|
|
{0x1f803938, WrapV_UU<sceCtrlReadBufferPositive>, "sceCtrlReadBufferPositive"}, //(ctrl_data_t* paddata, int unknown) // unknown should be 1
|
|
|
|
{0x3A622550, WrapI_UU<sceCtrlPeekBufferPositive>, "sceCtrlPeekBufferPositive"},
|
|
|
|
{0xC152080A, WrapI_UU<sceCtrlPeekBufferNegative>, "sceCtrlPeekBufferNegative"},
|
|
|
|
{0x60B81F86, WrapV_UU<sceCtrlReadBufferNegative>, "sceCtrlReadBufferNegative"},
|
2012-11-26 04:59:52 +00:00
|
|
|
{0xB1D0E5CD, WrapU_U<sceCtrlPeekLatch>, "sceCtrlPeekLatch"},
|
|
|
|
{0x0B588501, WrapU_U<sceCtrlReadLatch>, "sceCtrlReadLatch"},
|
2013-05-20 02:38:00 +00:00
|
|
|
{0x348D99D4, 0, "sceCtrlSetSuspendingExtraSamples"},
|
|
|
|
{0xAF5960F3, 0, "sceCtrlGetSuspendingExtraSamples"},
|
2012-11-26 04:59:52 +00:00
|
|
|
{0xA68FD260, 0, "sceCtrlClearRapidFire"},
|
|
|
|
{0x6841BE1A, 0, "sceCtrlSetRapidFire"},
|
2012-12-23 02:30:14 +00:00
|
|
|
{0xa7144800, WrapI_II<sceCtrlSetIdleCancelThreshold>, "sceCtrlSetIdleCancelThreshold"},
|
|
|
|
{0x687660fa, WrapI_UU<sceCtrlGetIdleCancelThreshold>, "sceCtrlGetIdleCancelThreshold"},
|
2012-11-01 15:19:01 +00:00
|
|
|
};
|
|
|
|
|
2012-11-26 04:59:52 +00:00
|
|
|
void Register_sceCtrl()
|
|
|
|
{
|
|
|
|
RegisterModule("sceCtrl", ARRAY_SIZE(sceCtrl), sceCtrl);
|
2012-11-01 15:19:01 +00:00
|
|
|
}
|
2014-02-17 12:46:57 +00:00
|
|
|
|
|
|
|
void Register_sceCtrl_driver()
|
|
|
|
{
|
|
|
|
RegisterModule("sceCtrl_driver", ARRAY_SIZE(sceCtrl), sceCtrl);
|
|
|
|
}
|