ref: 41c3afd927f72ef86d7eb81c0e4746b2b490c62b
dir: /external/SDL2/src/joystick/hidapi/SDL_hidapi_steam.c/
/*
Simple DirectMedia Layer
Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
arising from the use of this software.
Permission is granted to anyone to use this software for any purpose,
including commercial applications, and to alter it and redistribute it
freely, subject to the following restrictions:
1. The origin of this software must not be misrepresented; you must not
claim that you wrote the original software. If you use this software
in a product, an acknowledgment in the product documentation would be
appreciated but is not required.
2. Altered source versions must be plainly marked as such, and must not be
misrepresented as being the original software.
3. This notice may not be removed or altered from any source distribution.
*/
#include "../../SDL_internal.h"
#ifdef SDL_JOYSTICK_HIDAPI
#include "SDL_hints.h"
#include "SDL_log.h"
#include "SDL_events.h"
#include "SDL_timer.h"
#include "SDL_joystick.h"
#include "SDL_gamecontroller.h"
#include "../SDL_sysjoystick.h"
#include "SDL_hidapijoystick_c.h"
#ifdef SDL_JOYSTICK_HIDAPI_STEAM
/*****************************************************************************************************/
#include <stdint.h>
typedef enum
{
false,
true
} bool;
typedef uint32_t uint32;
typedef uint64_t uint64;
#include "steam/controller_constants.h"
#include "steam/controller_structs.h"
typedef struct SteamControllerStateInternal_t
{
// Controller Type for this Controller State
uint32 eControllerType;
// If packet num matches that on your prior call, then the controller state hasn't been changed since
// your last call and there is no need to process it
uint32 unPacketNum;
// bit flags for each of the buttons
uint64 ulButtons;
// Left pad coordinates
short sLeftPadX;
short sLeftPadY;
// Right pad coordinates
short sRightPadX;
short sRightPadY;
// Center pad coordinates
short sCenterPadX;
short sCenterPadY;
// Left analog stick coordinates
short sLeftStickX;
short sLeftStickY;
// Right analog stick coordinates
short sRightStickX;
short sRightStickY;
unsigned short sTriggerL;
unsigned short sTriggerR;
short sAccelX;
short sAccelY;
short sAccelZ;
short sGyroX;
short sGyroY;
short sGyroZ;
float sGyroQuatW;
float sGyroQuatX;
float sGyroQuatY;
float sGyroQuatZ;
short sGyroSteeringAngle;
unsigned short sBatteryLevel;
// Pressure sensor data.
unsigned short sPressurePadLeft;
unsigned short sPressurePadRight;
unsigned short sPressureBumperLeft;
unsigned short sPressureBumperRight;
// Internal state data
short sPrevLeftPad[2];
short sPrevLeftStick[2];
} SteamControllerStateInternal_t;
/* Defines for ulButtons in SteamControllerStateInternal_t */
#define STEAM_RIGHT_TRIGGER_MASK 0x00000001
#define STEAM_LEFT_TRIGGER_MASK 0x00000002
#define STEAM_RIGHT_BUMPER_MASK 0x00000004
#define STEAM_LEFT_BUMPER_MASK 0x00000008
#define STEAM_BUTTON_0_MASK 0x00000010 /* Y */
#define STEAM_BUTTON_1_MASK 0x00000020 /* B */
#define STEAM_BUTTON_2_MASK 0x00000040 /* X */
#define STEAM_BUTTON_3_MASK 0x00000080 /* A */
#define STEAM_TOUCH_0_MASK 0x00000100 /* DPAD UP */
#define STEAM_TOUCH_1_MASK 0x00000200 /* DPAD RIGHT */
#define STEAM_TOUCH_2_MASK 0x00000400 /* DPAD LEFT */
#define STEAM_TOUCH_3_MASK 0x00000800 /* DPAD DOWN */
#define STEAM_BUTTON_MENU_MASK 0x00001000 /* SELECT */
#define STEAM_BUTTON_STEAM_MASK 0x00002000 /* GUIDE */
#define STEAM_BUTTON_ESCAPE_MASK 0x00004000 /* START */
#define STEAM_BUTTON_BACK_LEFT_MASK 0x00008000
#define STEAM_BUTTON_BACK_RIGHT_MASK 0x00010000
#define STEAM_BUTTON_LEFTPAD_CLICKED_MASK 0x00020000
#define STEAM_BUTTON_RIGHTPAD_CLICKED_MASK 0x00040000
#define STEAM_LEFTPAD_FINGERDOWN_MASK 0x00080000
#define STEAM_RIGHTPAD_FINGERDOWN_MASK 0x00100000
#define STEAM_JOYSTICK_BUTTON_MASK 0x00400000
#define STEAM_LEFTPAD_AND_JOYSTICK_MASK 0x00800000
// Look for report version 0x0001, type WIRELESS (3), length >= 1 byte
#define D0G_IS_VALID_WIRELESS_EVENT(data, len) ((len) >= 5 && (data)[0] == 1 && (data)[1] == 0 && (data)[2] == 3 && (data)[3] >= 1)
#define D0G_GET_WIRELESS_EVENT_TYPE(data) ((data)[4])
#define D0G_WIRELESS_DISCONNECTED 1
#define D0G_WIRELESS_ESTABLISHED 2
#define D0G_WIRELESS_NEWLYPAIRED 3
#define D0G_IS_WIRELESS_DISCONNECT(data, len) ( D0G_IS_VALID_WIRELESS_EVENT(data,len) && D0G_GET_WIRELESS_EVENT_TYPE(data) == D0G_WIRELESS_DISCONNECTED )
#define MAX_REPORT_SEGMENT_PAYLOAD_SIZE 18
/*
* SteamControllerPacketAssembler has to be used when reading output repots from controllers.
*/
typedef struct
{
uint8_t uBuffer[ MAX_REPORT_SEGMENT_PAYLOAD_SIZE * 8 + 1 ];
int nExpectedSegmentNumber;
bool bIsBle;
} SteamControllerPacketAssembler;
#undef clamp
#define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
#undef offsetof
#define offsetof(s,m) (size_t)&(((s *)0)->m)
#ifdef DEBUG_STEAM_CONTROLLER
#define DPRINTF(format, ...) printf(format, ##__VA_ARGS__)
#define HEXDUMP(ptr, len) hexdump(ptr, len)
#else
#define DPRINTF(format, ...)
#define HEXDUMP(ptr, len)
#endif
#define printf SDL_Log
#define MAX_REPORT_SEGMENT_SIZE ( MAX_REPORT_SEGMENT_PAYLOAD_SIZE + 2 )
#define CALC_REPORT_SEGMENT_NUM(index) ( ( index / MAX_REPORT_SEGMENT_PAYLOAD_SIZE ) & 0x07 )
#define REPORT_SEGMENT_DATA_FLAG 0x80
#define REPORT_SEGMENT_LAST_FLAG 0x40
#define BLE_REPORT_NUMBER 0x03
#define STEAMCONTROLLER_TRIGGER_MAX_ANALOG 26000
// Enable mouse mode when using the Steam Controller locally
#undef ENABLE_MOUSE_MODE
// Wireless firmware quirk: the firmware intentionally signals "failure" when performing
// SET_FEATURE / GET_FEATURE when it actually means "pending radio round-trip". The only
// way to make SET_FEATURE / GET_FEATURE work is to loop several times with a sleep. If
// it takes more than 50ms to get the response for SET_FEATURE / GET_FEATURE, we assume
// that the controller has failed.
#define RADIO_WORKAROUND_SLEEP_ATTEMPTS 50
#define RADIO_WORKAROUND_SLEEP_DURATION_US 500
// This was defined by experimentation. 2000 seemed to work but to give that extra bit of margin, set to 3ms.
#define CONTROLLER_CONFIGURATION_DELAY_US 3000
static uint8_t GetSegmentHeader( int nSegmentNumber, bool bLastPacket )
{
uint8_t header = REPORT_SEGMENT_DATA_FLAG;
header |= nSegmentNumber;
if ( bLastPacket )
header |= REPORT_SEGMENT_LAST_FLAG;
return header;
}
static void hexdump( const uint8_t *ptr, int len )
{
int i;
for ( i = 0; i < len ; ++i )
printf("%02x ", ptr[i]);
printf("\n");
}
static void ResetSteamControllerPacketAssembler( SteamControllerPacketAssembler *pAssembler )
{
memset( pAssembler->uBuffer, 0, sizeof( pAssembler->uBuffer ) );
pAssembler->nExpectedSegmentNumber = 0;
}
static void InitializeSteamControllerPacketAssembler( SteamControllerPacketAssembler *pAssembler )
{
/* We only support BLE devices right now */
pAssembler->bIsBle = true;
ResetSteamControllerPacketAssembler( pAssembler );
}
// Returns:
// <0 on error
// 0 on not ready
// Complete packet size on completion
static int WriteSegmentToSteamControllerPacketAssembler( SteamControllerPacketAssembler *pAssembler, const uint8_t *pSegment, int nSegmentLength )
{
if ( pAssembler->bIsBle )
{
HEXDUMP( pSegment, nSegmentLength );
if ( pSegment[ 0 ] != BLE_REPORT_NUMBER )
{
// We may get keyboard/mouse input events until controller stops sending them
return 0;
}
if ( nSegmentLength != MAX_REPORT_SEGMENT_SIZE )
{
printf( "Bad segment size! %d\n", (int)nSegmentLength );
hexdump( pSegment, nSegmentLength );
ResetSteamControllerPacketAssembler( pAssembler );
return -1;
}
uint8_t uSegmentHeader = pSegment[ 1 ];
DPRINTF("GOT PACKET HEADER = 0x%x\n", uSegmentHeader);
if ( ( uSegmentHeader & REPORT_SEGMENT_DATA_FLAG ) == 0 )
{
// We get empty segments, just ignore them
return 0;
}
int nSegmentNumber = uSegmentHeader & 0x07;
if ( nSegmentNumber != pAssembler->nExpectedSegmentNumber )
{
ResetSteamControllerPacketAssembler( pAssembler );
if ( nSegmentNumber )
{
// This happens occasionally
DPRINTF("Bad segment number, got %d, expected %d\n",
nSegmentNumber, pAssembler->nExpectedSegmentNumber );
return -1;
}
}
memcpy( pAssembler->uBuffer + nSegmentNumber * MAX_REPORT_SEGMENT_PAYLOAD_SIZE,
pSegment + 2, // ignore header and report number
MAX_REPORT_SEGMENT_PAYLOAD_SIZE );
if ( uSegmentHeader & REPORT_SEGMENT_LAST_FLAG )
{
pAssembler->nExpectedSegmentNumber = 0;
return ( nSegmentNumber + 1 ) * MAX_REPORT_SEGMENT_PAYLOAD_SIZE;
}
pAssembler->nExpectedSegmentNumber++;
}
else
{
// Just pass through
memcpy( pAssembler->uBuffer,
pSegment,
nSegmentLength );
return nSegmentLength;
}
return 0;
}
#define BLE_MAX_READ_RETRIES 8
static int SetFeatureReport( hid_device *dev, unsigned char uBuffer[65], int nActualDataLen )
{
DPRINTF("SetFeatureReport %p %p %d\n", dev, uBuffer, nActualDataLen);
int nRet = -1;
bool bBle = true; // only wireless/BLE for now, though macOS could do wired in the future
if ( bBle )
{
if ( nActualDataLen < 1 )
return -1;
int nSegmentNumber = 0;
uint8_t uPacketBuffer[ MAX_REPORT_SEGMENT_SIZE ];
// Skip report number in data
unsigned char *pBufferPtr = uBuffer + 1;
nActualDataLen--;
while ( nActualDataLen > 0 )
{
int nBytesInPacket = nActualDataLen > MAX_REPORT_SEGMENT_PAYLOAD_SIZE ? MAX_REPORT_SEGMENT_PAYLOAD_SIZE : nActualDataLen;
nActualDataLen -= nBytesInPacket;
// Construct packet
memset( uPacketBuffer, 0, sizeof( uPacketBuffer ) );
uPacketBuffer[ 0 ] = BLE_REPORT_NUMBER;
uPacketBuffer[ 1 ] = GetSegmentHeader( nSegmentNumber, nActualDataLen == 0 );
memcpy( &uPacketBuffer[ 2 ], pBufferPtr, nBytesInPacket );
pBufferPtr += nBytesInPacket;
nSegmentNumber++;
nRet = hid_send_feature_report( dev, uPacketBuffer, sizeof( uPacketBuffer ) );
DPRINTF("SetFeatureReport() ret = %d\n", nRet);
}
}
return nRet;
}
static int GetFeatureReport( hid_device *dev, unsigned char uBuffer[65] )
{
DPRINTF("GetFeatureReport( %p %p )\n", dev, uBuffer );
int nRet = -1;
bool bBle = true;
if ( bBle )
{
SteamControllerPacketAssembler assembler;
InitializeSteamControllerPacketAssembler( &assembler );
int nRetries = 0;
uint8_t uSegmentBuffer[ MAX_REPORT_SEGMENT_SIZE ];
while( nRetries < BLE_MAX_READ_RETRIES )
{
memset( uSegmentBuffer, 0, sizeof( uSegmentBuffer ) );
uSegmentBuffer[ 0 ] = BLE_REPORT_NUMBER;
nRet = hid_get_feature_report( dev, uSegmentBuffer, sizeof( uSegmentBuffer ) );
DPRINTF( "GetFeatureReport ble ret=%d\n", nRet );
HEXDUMP( uSegmentBuffer, nRet );
// Zero retry counter if we got data
if ( nRet > 2 && ( uSegmentBuffer[ 1 ] & REPORT_SEGMENT_DATA_FLAG ) )
nRetries = 0;
else
nRetries++;
if ( nRet > 0 )
{
int nPacketLength = WriteSegmentToSteamControllerPacketAssembler( &assembler,
uSegmentBuffer,
nRet );
if ( nPacketLength > 0 && nPacketLength < 65 )
{
// Leave space for "report number"
uBuffer[ 0 ] = 0;
memcpy( uBuffer + 1, assembler.uBuffer, nPacketLength );
return nPacketLength;
}
}
}
printf("Could not get a full ble packet after %d retries\n", nRetries );
return -1;
}
return nRet;
}
static int ReadResponse( hid_device *dev, uint8_t uBuffer[65], int nExpectedResponse )
{
DPRINTF("ReadResponse( %p %p %d )\n", dev, uBuffer, nExpectedResponse );
int nRet = GetFeatureReport( dev, uBuffer );
if ( nRet < 0 )
return nRet;
DPRINTF("ReadResponse got %d bytes of data: ", nRet );
HEXDUMP( uBuffer, nRet );
if ( uBuffer[1] != nExpectedResponse )
return -1;
return nRet;
}
//---------------------------------------------------------------------------
// Reset steam controller (unmap buttons and pads) and re-fetch capability bits
//---------------------------------------------------------------------------
static bool ResetSteamController( hid_device *dev, bool bSuppressErrorSpew )
{
DPRINTF( "ResetSteamController hid=%p\n", dev );
// Firmware quirk: Set Feature and Get Feature requests always require a 65-byte buffer.
unsigned char buf[65];
int res = -1;
buf[0] = 0;
buf[1] = ID_GET_ATTRIBUTES_VALUES;
res = SetFeatureReport( dev, buf, 2 );
if ( res < 0 )
{
if ( !bSuppressErrorSpew )
printf( "GET_ATTRIBUTES_VALUES failed for controller %p\n", dev );
return false;
}
// Retrieve GET_ATTRIBUTES_VALUES result
// Wireless controller endpoints without a connected controller will return nAttrs == 0
res = ReadResponse( dev, buf, ID_GET_ATTRIBUTES_VALUES );
if ( res < 0 || buf[1] != ID_GET_ATTRIBUTES_VALUES )
{
HEXDUMP(buf, res);
if ( !bSuppressErrorSpew )
printf( "Bad GET_ATTRIBUTES_VALUES response for controller %p\n", dev );
return false;
}
int nAttributesLength = buf[ 2 ];
if ( nAttributesLength > res )
{
if ( !bSuppressErrorSpew )
printf( "Bad GET_ATTRIBUTES_VALUES response for controller %p\n", dev );
return false;
}
// Clear digital button mappings
buf[0] = 0;
buf[1] = ID_CLEAR_DIGITAL_MAPPINGS;
res = SetFeatureReport( dev, buf, 2 );
if ( res < 0 )
{
if ( !bSuppressErrorSpew )
printf( "CLEAR_DIGITAL_MAPPINGS failed for controller %p\n", dev );
return false;
}
// Reset the default settings
memset( buf, 0, 65 );
buf[1] = ID_LOAD_DEFAULT_SETTINGS;
buf[2] = 0;
res = SetFeatureReport( dev, buf, 3 );
if ( res < 0 )
{
if ( !bSuppressErrorSpew )
printf( "LOAD_DEFAULT_SETTINGS failed for controller %p\n", dev );
return false;
}
// Apply custom settings - clear trackpad modes (cancel mouse emulation), etc
int nSettings = 0;
#define ADD_SETTING(SETTING, VALUE) \
buf[3+nSettings*3] = SETTING; \
buf[3+nSettings*3+1] = ((uint16_t)VALUE)&0xFF; \
buf[3+nSettings*3+2] = ((uint16_t)VALUE)>>8; \
++nSettings;
memset( buf, 0, 65 );
buf[1] = ID_SET_SETTINGS_VALUES;
ADD_SETTING( SETTING_WIRELESS_PACKET_VERSION, 2 );
ADD_SETTING( SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE );
#ifdef ENABLE_MOUSE_MODE
ADD_SETTING( SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_ABSOLUTE_MOUSE );
ADD_SETTING( SETTING_SMOOTH_ABSOLUTE_MOUSE, 1 );
ADD_SETTING( SETTING_MOMENTUM_MAXIMUM_VELOCITY, 20000 ); // [0-20000] default 8000
ADD_SETTING( SETTING_MOMENTUM_DECAY_AMMOUNT, 50 ); // [0-50] default 5
#else
ADD_SETTING( SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE );
ADD_SETTING( SETTING_SMOOTH_ABSOLUTE_MOUSE, 0 );
#endif
buf[2] = nSettings*3;
res = SetFeatureReport( dev, buf, 3+nSettings*3 );
if ( res < 0 )
{
if ( !bSuppressErrorSpew )
printf( "SET_SETTINGS failed for controller %p\n", dev );
return false;
}
#ifdef ENABLE_MOUSE_MODE
// Wait for ID_CLEAR_DIGITAL_MAPPINGS to be processed on the controller
bool bMappingsCleared = false;
int iRetry;
for ( iRetry = 0; iRetry < 2; ++iRetry )
{
memset( buf, 0, 65 );
buf[1] = ID_GET_DIGITAL_MAPPINGS;
buf[2] = 1; // one byte - requesting from index 0
buf[3] = 0;
res = SetFeatureReport( dev, buf, 4 );
if ( res < 0 )
{
printf( "GET_DIGITAL_MAPPINGS failed for controller %p\n", dev );
return false;
}
res = ReadResponse( dev, buf, ID_GET_DIGITAL_MAPPINGS );
if ( res < 0 || buf[1] != ID_GET_DIGITAL_MAPPINGS )
{
printf( "Bad GET_DIGITAL_MAPPINGS response for controller %p\n", dev );
return false;
}
// If the length of the digital mappings result is not 1 (index byte, no mappings) then clearing hasn't executed
if ( buf[2] == 1 && buf[3] == 0xFF )
{
bMappingsCleared = true;
break;
}
usleep( CONTROLLER_CONFIGURATION_DELAY_US );
}
if ( !bMappingsCleared && !bSuppressErrorSpew )
{
printf( "Warning: CLEAR_DIGITAL_MAPPINGS never completed for controller %p\n", dev );
}
// Set our new mappings
memset( buf, 0, 65 );
buf[1] = ID_SET_DIGITAL_MAPPINGS;
buf[2] = 6; // 2 settings x 3 bytes
buf[3] = IO_DIGITAL_BUTTON_RIGHT_TRIGGER;
buf[4] = DEVICE_MOUSE;
buf[5] = MOUSE_BTN_LEFT;
buf[6] = IO_DIGITAL_BUTTON_LEFT_TRIGGER;
buf[7] = DEVICE_MOUSE;
buf[8] = MOUSE_BTN_RIGHT;
res = SetFeatureReport( dev, buf, 9 );
if ( res < 0 )
{
if ( !bSuppressErrorSpew )
printf( "SET_DIGITAL_MAPPINGS failed for controller %p\n", dev );
return false;
}
#endif // ENABLE_MOUSE_MODE
return true;
}
//---------------------------------------------------------------------------
// Read from a Steam Controller
//---------------------------------------------------------------------------
static int ReadSteamController( hid_device *dev, uint8_t *pData, int nDataSize )
{
memset( pData, 0, nDataSize );
pData[ 0 ] = BLE_REPORT_NUMBER; // hid_read will also overwrite this with the same value, 0x03
return hid_read( dev, pData, nDataSize );
}
//---------------------------------------------------------------------------
// Close a Steam Controller
//---------------------------------------------------------------------------
static void CloseSteamController( hid_device *dev )
{
// Switch the Steam Controller back to lizard mode so it works with the OS
unsigned char buf[65];
int nSettings = 0;
// Reset digital button mappings
memset( buf, 0, 65 );
buf[1] = ID_SET_DEFAULT_DIGITAL_MAPPINGS;
SetFeatureReport( dev, buf, 2 );
// Reset the default settings
memset( buf, 0, 65 );
buf[1] = ID_LOAD_DEFAULT_SETTINGS;
buf[2] = 0;
SetFeatureReport( dev, buf, 3 );
// Reset mouse mode for lizard mode
memset( buf, 0, 65 );
buf[1] = ID_SET_SETTINGS_VALUES;
ADD_SETTING( SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_ABSOLUTE_MOUSE );
buf[2] = nSettings*3;
SetFeatureReport( dev, buf, 3+nSettings*3 );
}
//---------------------------------------------------------------------------
// Scale and clamp values to a range
//---------------------------------------------------------------------------
static float RemapValClamped( float val, float A, float B, float C, float D)
{
if ( A == B )
{
return ( val - B ) >= 0.0f ? D : C;
}
else
{
float cVal = (val - A) / (B - A);
cVal = clamp( cVal, 0.0f, 1.0f );
return C + (D - C) * cVal;
}
}
//---------------------------------------------------------------------------
// Rotate the pad coordinates
//---------------------------------------------------------------------------
static void RotatePad( int *pX, int *pY, float flAngleInRad )
{
short int origX = *pX, origY = *pY;
*pX = (int)( SDL_cosf( flAngleInRad ) * origX - SDL_sinf( flAngleInRad ) * origY );
*pY = (int)( SDL_sinf( flAngleInRad ) * origX + SDL_cosf( flAngleInRad ) * origY );
}
static void RotatePadShort( short *pX, short *pY, float flAngleInRad )
{
short int origX = *pX, origY = *pY;
*pX = (short)( SDL_cosf( flAngleInRad ) * origX - SDL_sinf( flAngleInRad ) * origY );
*pY = (short)( SDL_sinf( flAngleInRad ) * origX + SDL_cosf( flAngleInRad ) * origY );
}
//---------------------------------------------------------------------------
// Format the first part of the state packet
//---------------------------------------------------------------------------
static void FormatStatePacketUntilGyro( SteamControllerStateInternal_t *pState, ValveControllerStatePacket_t *pStatePacket )
{
memset(pState, 0, offsetof(SteamControllerStateInternal_t, sBatteryLevel));
//pState->eControllerType = m_eControllerType;
pState->eControllerType = 2; // k_eControllerType_SteamController;
pState->unPacketNum = pStatePacket->unPacketNum;
// We have a chunk of trigger data in the packet format here, so zero it out afterwards
memcpy(&pState->ulButtons, &pStatePacket->ButtonTriggerData.ulButtons, 8);
pState->ulButtons &= ~0xFFFF000000LL;
// The firmware uses this bit to tell us what kind of data is packed into the left two axises
if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK)
{
// Finger-down bit not set; "left pad" is actually trackpad
pState->sLeftPadX = pState->sPrevLeftPad[0] = pStatePacket->sLeftPadX;
pState->sLeftPadY = pState->sPrevLeftPad[1] = pStatePacket->sLeftPadY;
if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK)
{
// The controller is interleaving both stick and pad data, both are active
pState->sLeftStickX = pState->sPrevLeftStick[0];
pState->sLeftStickY = pState->sPrevLeftStick[1];
}
else
{
// The stick is not active
pState->sPrevLeftStick[0] = 0;
pState->sPrevLeftStick[1] = 0;
}
}
else
{
// Finger-down bit not set; "left pad" is actually joystick
// XXX there's a firmware bug where sometimes padX is 0 and padY is a large number (acutally the battery voltage)
// If that happens skip this packet and report last frames stick
/*
if ( m_eControllerType == k_eControllerType_SteamControllerV2 && pStatePacket->sLeftPadY > 900 )
{
pState->sLeftStickX = pState->sPrevLeftStick[0];
pState->sLeftStickY = pState->sPrevLeftStick[1];
}
else
*/
{
pState->sPrevLeftStick[0] = pState->sLeftStickX = pStatePacket->sLeftPadX;
pState->sPrevLeftStick[1] = pState->sLeftStickY = pStatePacket->sLeftPadY;
}
/*
if (m_eControllerType == k_eControllerType_SteamControllerV2)
{
UpdateV2JoystickCap(&state);
}
*/
if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK)
{
// The controller is interleaving both stick and pad data, both are active
pState->sLeftPadX = pState->sPrevLeftPad[0];
pState->sLeftPadY = pState->sPrevLeftPad[1];
}
else
{
// The trackpad is not active
pState->sPrevLeftPad[0] = 0;
pState->sPrevLeftPad[1] = 0;
// Old controllers send trackpad click for joystick button when trackpad is not active
if (pState->ulButtons & STEAM_BUTTON_LEFTPAD_CLICKED_MASK)
{
pState->ulButtons &= ~STEAM_BUTTON_LEFTPAD_CLICKED_MASK;
pState->ulButtons |= STEAM_JOYSTICK_BUTTON_MASK;
}
}
}
// Fingerdown bit indicates if the packed left axis data was joystick or pad,
// but if we are interleaving both, the left finger is definitely on the pad.
if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK)
pState->ulButtons |= STEAM_LEFTPAD_FINGERDOWN_MASK;
pState->sRightPadX = pStatePacket->sRightPadX;
pState->sRightPadY = pStatePacket->sRightPadY;
int nLeftPadX = pState->sLeftPadX;
int nLeftPadY = pState->sLeftPadY;
int nRightPadX = pState->sRightPadX;
int nRightPadY = pState->sRightPadY;
// 15 degrees in rad
const float flRotationAngle = 0.261799f;
RotatePad(&nLeftPadX, &nLeftPadY, -flRotationAngle);
RotatePad(&nRightPadX, &nRightPadY, flRotationAngle);
int nPadOffset;
if (pState->ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK)
nPadOffset = 1000;
else
nPadOffset = 0;
pState->sLeftPadX = clamp(nLeftPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
pState->sLeftPadY = clamp(nLeftPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
nPadOffset = 0;
if (pState->ulButtons & STEAM_RIGHTPAD_FINGERDOWN_MASK)
nPadOffset = 1000;
else
nPadOffset = 0;
pState->sRightPadX = clamp(nRightPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
pState->sRightPadY = clamp(nRightPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
pState->sTriggerL = (unsigned short)RemapValClamped( (pStatePacket->ButtonTriggerData.Triggers.nLeft << 7) | pStatePacket->ButtonTriggerData.Triggers.nLeft, 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16 );
pState->sTriggerR = (unsigned short)RemapValClamped( (pStatePacket->ButtonTriggerData.Triggers.nRight << 7) | pStatePacket->ButtonTriggerData.Triggers.nRight, 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16 );
}
//---------------------------------------------------------------------------
// Update Steam Controller state from a BLE data packet, returns true if it parsed data
//---------------------------------------------------------------------------
static bool UpdateBLESteamControllerState( const uint8_t *pData, int nDataSize, SteamControllerStateInternal_t *pState )
{
const float flRotationAngle = 0.261799f;
uint32_t ucOptionDataMask;
pState->unPacketNum++;
ucOptionDataMask = ( *pData++ & 0xF0 );
ucOptionDataMask |= (uint32_t)(*pData++) << 8;
if ( ucOptionDataMask & k_EBLEButtonChunk1 )
{
memcpy( &pState->ulButtons, pData, 3 );
pData += 3;
}
if ( ucOptionDataMask & k_EBLEButtonChunk2 )
{
// The middle 2 bytes of the button bits over the wire are triggers when over the wire and non-SC buttons in the internal controller state packet
pState->sTriggerL = (unsigned short)RemapValClamped( ( pData[ 0 ] << 7 ) | pData[ 0 ], 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16 );
pState->sTriggerR = (unsigned short)RemapValClamped( ( pData[ 1 ] << 7 ) | pData[ 1 ], 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16 );
pData += 2;
}
if ( ucOptionDataMask & k_EBLEButtonChunk3 )
{
uint8_t *pButtonByte = (uint8_t *)&pState->ulButtons;
pButtonByte[ 5 ] = *pData++;
pButtonByte[ 6 ] = *pData++;
pButtonByte[ 7 ] = *pData++;
}
if ( ucOptionDataMask & k_EBLELeftJoystickChunk )
{
// This doesn't handle any of the special headcrab stuff for raw joystick which is OK for now since that FW doesn't support
// this protocol yet either
int nLength = sizeof( pState->sLeftStickX ) + sizeof( pState->sLeftStickY );
memcpy( &pState->sLeftStickX, pData, nLength );
pData += nLength;
}
if ( ucOptionDataMask & k_EBLELeftTrackpadChunk )
{
int nLength = sizeof( pState->sLeftPadX ) + sizeof( pState->sLeftPadY );
int nPadOffset;
memcpy( &pState->sLeftPadX, pData, nLength );
if ( pState->ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK )
nPadOffset = 1000;
else
nPadOffset = 0;
RotatePadShort( &pState->sLeftPadX, &pState->sLeftPadY, -flRotationAngle );
pState->sLeftPadX = clamp( pState->sLeftPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16 );
pState->sLeftPadY = clamp( pState->sLeftPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16 );
pData += nLength;
}
if ( ucOptionDataMask & k_EBLERightTrackpadChunk )
{
int nLength = sizeof( pState->sRightPadX ) + sizeof( pState->sRightPadY );
int nPadOffset = 0;
memcpy( &pState->sRightPadX, pData, nLength );
if ( pState->ulButtons & STEAM_RIGHTPAD_FINGERDOWN_MASK )
nPadOffset = 1000;
else
nPadOffset = 0;
RotatePadShort( &pState->sRightPadX, &pState->sRightPadY, flRotationAngle );
pState->sRightPadX = clamp( pState->sRightPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16 );
pState->sRightPadY = clamp( pState->sRightPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16 );
pData += nLength;
}
if ( ucOptionDataMask & k_EBLEIMUAccelChunk )
{
int nLength = sizeof( pState->sAccelX ) + sizeof( pState->sAccelY ) + sizeof( pState->sAccelZ );
memcpy( &pState->sAccelX, pData, nLength );
pData += nLength;
}
if ( ucOptionDataMask & k_EBLEIMUGyroChunk )
{
int nLength = sizeof( pState->sAccelX ) + sizeof( pState->sAccelY ) + sizeof( pState->sAccelZ );
memcpy( &pState->sGyroX, pData, nLength );
pData += nLength;
}
if ( ucOptionDataMask & k_EBLEIMUQuatChunk )
{
int nLength = sizeof( pState->sGyroQuatW ) + sizeof( pState->sGyroQuatX ) + sizeof( pState->sGyroQuatY ) + sizeof( pState->sGyroQuatZ );
memcpy( &pState->sGyroQuatW, pData, nLength );
pData += nLength;
}
return true;
}
//---------------------------------------------------------------------------
// Update Steam Controller state from a data packet, returns true if it parsed data
//---------------------------------------------------------------------------
static bool UpdateSteamControllerState( const uint8_t *pData, int nDataSize, SteamControllerStateInternal_t *pState )
{
ValveInReport_t *pInReport = (ValveInReport_t*)pData;
if ( pInReport->header.unReportVersion != k_ValveInReportMsgVersion )
{
if ( ( pData[ 0 ] & 0x0F ) == k_EBLEReportState )
{
return UpdateBLESteamControllerState( pData, nDataSize, pState );
}
return false;
}
if ( ( pInReport->header.ucType != ID_CONTROLLER_STATE ) &&
( pInReport->header.ucType != ID_CONTROLLER_BLE_STATE ) )
{
return false;
}
if ( pInReport->header.ucType == ID_CONTROLLER_STATE )
{
ValveControllerStatePacket_t *pStatePacket = &pInReport->payload.controllerState;
// No new data to process; indicate that we received a state packet, but otherwise do nothing.
if ( pState->unPacketNum == pStatePacket->unPacketNum )
return true;
FormatStatePacketUntilGyro( pState, pStatePacket );
pState->sAccelX = pStatePacket->sAccelX;
pState->sAccelY = pStatePacket->sAccelY;
pState->sAccelZ = pStatePacket->sAccelZ;
pState->sGyroQuatW = pStatePacket->sGyroQuatW;
pState->sGyroQuatX = pStatePacket->sGyroQuatX;
pState->sGyroQuatY = pStatePacket->sGyroQuatY;
pState->sGyroQuatZ = pStatePacket->sGyroQuatZ;
pState->sGyroX = pStatePacket->sGyroX;
pState->sGyroY = pStatePacket->sGyroY;
pState->sGyroZ = pStatePacket->sGyroZ;
}
else if ( pInReport->header.ucType == ID_CONTROLLER_BLE_STATE )
{
ValveControllerBLEStatePacket_t *pBLEStatePacket = &pInReport->payload.controllerBLEState;
ValveControllerStatePacket_t *pStatePacket = &pInReport->payload.controllerState;
// No new data to process; indicate that we received a state packet, but otherwise do nothing.
if ( pState->unPacketNum == pStatePacket->unPacketNum )
return true;
FormatStatePacketUntilGyro( pState, pStatePacket );
switch ( pBLEStatePacket->ucGyroDataType )
{
case 1:
pState->sGyroQuatW = (( float ) pBLEStatePacket->sGyro[0]);
pState->sGyroQuatX = (( float ) pBLEStatePacket->sGyro[1]);
pState->sGyroQuatY = (( float ) pBLEStatePacket->sGyro[2]);
pState->sGyroQuatZ = (( float ) pBLEStatePacket->sGyro[3]);
break;
case 2:
pState->sAccelX = pBLEStatePacket->sGyro[0];
pState->sAccelY = pBLEStatePacket->sGyro[1];
pState->sAccelZ = pBLEStatePacket->sGyro[2];
break;
case 3:
pState->sGyroX = pBLEStatePacket->sGyro[0];
pState->sGyroY = pBLEStatePacket->sGyro[1];
pState->sGyroZ = pBLEStatePacket->sGyro[2];
break;
default:
break;
}
}
return true;
}
/*****************************************************************************************************/
typedef struct {
SteamControllerPacketAssembler m_assembler;
SteamControllerStateInternal_t m_state;
SteamControllerStateInternal_t m_last_state;
} SDL_DriverSteam_Context;
static SDL_bool
HIDAPI_DriverSteam_IsSupportedDevice(const char *name, SDL_GameControllerType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol)
{
return SDL_IsJoystickSteamController(vendor_id, product_id);
}
static const char *
HIDAPI_DriverSteam_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
{
return "Steam Controller";
}
static SDL_bool
HIDAPI_DriverSteam_InitDevice(SDL_HIDAPI_Device *device)
{
return HIDAPI_JoystickConnected(device, NULL);
}
static int
HIDAPI_DriverSteam_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
{
return -1;
}
static void
HIDAPI_DriverSteam_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
{
}
static SDL_bool
HIDAPI_DriverSteam_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
{
SDL_DriverSteam_Context *ctx;
ctx = (SDL_DriverSteam_Context *)SDL_calloc(1, sizeof(*ctx));
if (!ctx) {
SDL_OutOfMemory();
goto error;
}
device->context = ctx;
device->dev = hid_open_path(device->path, 0);
if (!device->dev) {
SDL_SetError("Couldn't open %s", device->path);
goto error;
}
if (!ResetSteamController(device->dev, false)) {
goto error;
}
InitializeSteamControllerPacketAssembler(&ctx->m_assembler);
/* Initialize the joystick capabilities */
joystick->nbuttons = SDL_CONTROLLER_BUTTON_MAX;
joystick->naxes = SDL_CONTROLLER_AXIS_MAX;
return SDL_TRUE;
error:
if (device->dev) {
hid_close(device->dev);
device->dev = NULL;
}
if (device->context) {
SDL_free(device->context);
device->context = NULL;
}
return SDL_FALSE;
}
static int
HIDAPI_DriverSteam_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
{
/* You should use the full Steam Input API for rumble support */
return SDL_Unsupported();
}
static SDL_bool
HIDAPI_DriverSteam_UpdateDevice(SDL_HIDAPI_Device *device)
{
SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
SDL_Joystick *joystick = NULL;
if (device->num_joysticks > 0) {
joystick = SDL_JoystickFromInstanceID(device->joysticks[0]);
}
if (!joystick) {
return SDL_FALSE;
}
for (;;)
{
uint8_t data[128];
int r, nPacketLength;
const Uint8 *pPacket;
r = ReadSteamController(device->dev, data, sizeof(data));
if (r == 0)
{
break;
}
nPacketLength = 0;
if (r > 0) {
nPacketLength = WriteSegmentToSteamControllerPacketAssembler(&ctx->m_assembler, data, r);
}
pPacket = ctx->m_assembler.uBuffer;
if (nPacketLength > 0 && UpdateSteamControllerState(pPacket, nPacketLength, &ctx->m_state)) {
if (ctx->m_state.ulButtons != ctx->m_last_state.ulButtons) {
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_A,
(ctx->m_state.ulButtons & STEAM_BUTTON_3_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_B,
(ctx->m_state.ulButtons & STEAM_BUTTON_1_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_X,
(ctx->m_state.ulButtons & STEAM_BUTTON_2_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_Y,
(ctx->m_state.ulButtons & STEAM_BUTTON_0_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSHOULDER,
(ctx->m_state.ulButtons & STEAM_LEFT_BUMPER_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER,
(ctx->m_state.ulButtons & STEAM_RIGHT_BUMPER_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK,
(ctx->m_state.ulButtons & STEAM_BUTTON_MENU_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_START,
(ctx->m_state.ulButtons & STEAM_BUTTON_ESCAPE_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE,
(ctx->m_state.ulButtons & STEAM_BUTTON_STEAM_MASK) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSTICK,
(ctx->m_state.ulButtons & STEAM_JOYSTICK_BUTTON_MASK) ? SDL_PRESSED : SDL_RELEASED);
}
{
/* Minimum distance from center of pad to register a direction */
const int kPadDeadZone = 10000;
/* Pad coordinates are like math grid coordinates: negative is bottom left */
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_UP,
(ctx->m_state.sLeftPadY > kPadDeadZone) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_DOWN,
(ctx->m_state.sLeftPadY < -kPadDeadZone) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_LEFT,
(ctx->m_state.sLeftPadX < -kPadDeadZone) ? SDL_PRESSED : SDL_RELEASED);
SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
(ctx->m_state.sLeftPadX > kPadDeadZone) ? SDL_PRESSED : SDL_RELEASED);
}
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, (int)ctx->m_state.sTriggerL * 2 - 32768);
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, (int)ctx->m_state.sTriggerR * 2 - 32768);
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTX, ctx->m_state.sLeftStickX);
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTY, ~ctx->m_state.sLeftStickY);
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, ctx->m_state.sRightPadX);
SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, ~ctx->m_state.sRightPadY);
ctx->m_last_state = ctx->m_state;
}
if (r <= 0) {
/* Failed to read from controller */
HIDAPI_JoystickDisconnected(device, device->joysticks[0]);
return SDL_FALSE;
}
}
return SDL_TRUE;
}
static void
HIDAPI_DriverSteam_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
{
CloseSteamController(device->dev);
hid_close(device->dev);
device->dev = NULL;
SDL_free(device->context);
device->context = NULL;
}
static void
HIDAPI_DriverSteam_FreeDevice(SDL_HIDAPI_Device *device)
{
}
SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteam =
{
SDL_HINT_JOYSTICK_HIDAPI_STEAM,
SDL_TRUE,
HIDAPI_DriverSteam_IsSupportedDevice,
HIDAPI_DriverSteam_GetDeviceName,
HIDAPI_DriverSteam_InitDevice,
HIDAPI_DriverSteam_GetDevicePlayerIndex,
HIDAPI_DriverSteam_SetDevicePlayerIndex,
HIDAPI_DriverSteam_UpdateDevice,
HIDAPI_DriverSteam_OpenJoystick,
HIDAPI_DriverSteam_RumbleJoystick,
HIDAPI_DriverSteam_CloseJoystick,
HIDAPI_DriverSteam_FreeDevice
};
#endif /* SDL_JOYSTICK_HIDAPI_STEAM */
#endif /* SDL_JOYSTICK_HIDAPI */
/* vi: set ts=4 sw=4 expandtab: */