The-Homebrew-Cloud/controller_patcher
2
0
Fork 0
mirror of https://github.com/Maschell/controller_patcher.git synced 2024-11-22 03:59:16 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add a .clang_format

Browse Source
This commit is contained in:
Maschell 2023-04-10 11:45:58 +02:00
parent c8a077574e
commit 7c4232e177
37 changed files with 3074 additions and 3005 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

67
.clang-format Normal file
View File

@ -0,0 +1,67 @@
# Generated from CLion C/C++ Code Style settings
BasedOnStyle: LLVM
AccessModifierOffset: -4
AlignAfterOpenBracket: Align
AlignConsecutiveAssignments: Consecutive
AlignConsecutiveMacros: AcrossEmptyLinesAndComments
AlignOperands: Align
AllowAllArgumentsOnNextLine: false
AllowAllConstructorInitializersOnNextLine: false
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortBlocksOnASingleLine: Always
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Always
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: true
AlwaysBreakAfterReturnType: None
AlwaysBreakTemplateDeclarations: Yes
BreakBeforeBraces: Custom
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
IndentBraces: false
SplitEmptyFunction: false
SplitEmptyRecord: true
BreakBeforeBinaryOperators: None
BreakBeforeTernaryOperators: true
BreakConstructorInitializers: BeforeColon
BreakInheritanceList: BeforeColon
ColumnLimit: 0
CompactNamespaces: false
ContinuationIndentWidth: 8
IndentCaseLabels: true
IndentPPDirectives: None
IndentWidth: 4
KeepEmptyLinesAtTheStartOfBlocks: true
MaxEmptyLinesToKeep: 2
NamespaceIndentation: All
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PointerAlignment: Right
ReflowComments: false
SpaceAfterCStyleCast: true
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: false
SpaceBeforeAssignmentOperators: true
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInCStyleCastParentheses: false
SpacesInContainerLiterals: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
TabWidth: 4
UseTab: Never

4
README.md
View File

@ -50,6 +50,10 @@ ControllerPatcher::DeInit();
ControllerPatcher::stopNetworkServer(); ControllerPatcher::stopNetworkServer();
``` ```
## Format the code via docker
`docker run --rm -v ${PWD}:/src ghcr.io/wiiu-env/clang-format:13.0.0-2 -r ./source ./include -i`
# Credits: # Credits:
- Maschell - Maschell
- FIX94 - huge thanks to him and his initally created gc-to-vpad. Was a motivation and base to start all this - FIX94 - huge thanks to him and his initally created gc-to-vpad. Was a motivation and base to start all this

26
include/controller_patcher/ControllerPatcher.hpp
View File

@ -29,9 +29,9 @@
#include <string> #include <string>
#include "ControllerPatcherDefs.h"
#include <padscore/wpad.h> #include <padscore/wpad.h>
#include <vpad/input.h> #include <vpad/input.h>
#include "ControllerPatcherDefs.h"
class ControllerPatcher { class ControllerPatcher {
public: public:
@ -48,7 +48,7 @@ public:
devoptabs! If no configuration should be loaded from the SD Card, set this parameter to NULL. devoptabs! If no configuration should be loaded from the SD Card, set this parameter to NULL.
**/ **/
static BOOL Init(const char * pathToConfig); static BOOL Init(const char *pathToConfig);
/** /**
\brief De-Initialises the controller_patcher \brief De-Initialises the controller_patcher
@ -84,7 +84,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setProControllerDataFromHID(void * data,int32_t chan,int32_t mode = PRO_CONTROLLER_MODE_KPADDATA); static CONTROLLER_PATCHER_RESULT_OR_ERROR setProControllerDataFromHID(void *data, int32_t chan, int32_t mode = PRO_CONTROLLER_MODE_KPADDATA);
/** /**
@ -96,7 +96,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setControllerDataFromHID(VPADStatus * buffer); static CONTROLLER_PATCHER_RESULT_OR_ERROR setControllerDataFromHID(VPADStatus *buffer);
/*----------------------------------------------------------------------------------------------------------------------------------- /*-----------------------------------------------------------------------------------------------------------------------------------
* Useful functions * Useful functions
@ -144,7 +144,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR addControllerMapping(UController_Type type,ControllerMappingPADInfo config); static CONTROLLER_PATCHER_RESULT_OR_ERROR addControllerMapping(UController_Type type, ControllerMappingPADInfo config);
/** /**
@ -158,7 +158,7 @@ public:
@param mapping_slot: information about the added controller. @param mapping_slot: information about the added controller.
@return When the functions failed result < 0 is returned. Otherwise a pointer to a ControllerMappingPADInfo is returned. @return When the functions failed result < 0 is returned. Otherwise a pointer to a ControllerMappingPADInfo is returned.
**/ **/
static ControllerMappingPADInfo * getControllerMappingInfo(UController_Type type,int32_t mapping_slot); static ControllerMappingPADInfo *getControllerMappingInfo(UController_Type type, int32_t mapping_slot);
/** /**
Checks if a emulated controller is connected for the given controller type / mapping slot. Checks if a emulated controller is connected for the given controller type / mapping slot.
@ -168,13 +168,13 @@ public:
@return @return
**/ **/
static BOOL isControllerConnectedAndActive(UController_Type type,int32_t mapping_slot = 0); static BOOL isControllerConnectedAndActive(UController_Type type, int32_t mapping_slot = 0);
/** /**
Search for a connected mouse and returns a pointer to it's data. Search for a connected mouse and returns a pointer to it's data.
@return A pointer to the first connected mouse that is found. NULL if no mouse is connected. @return A pointer to the first connected mouse that is found. NULL if no mouse is connected.
**/ **/
static HID_Mouse_Data * getMouseData(); static HID_Mouse_Data *getMouseData();
/** /**
Sets a rumble status for a controller. Sets a rumble status for a controller.
@ -184,7 +184,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setRumble(UController_Type type,uint32_t status); static CONTROLLER_PATCHER_RESULT_OR_ERROR setRumble(UController_Type type, uint32_t status);
/** /**
Reads the input of all connected HID devices. Each attached controller will write his date into given array until it's full. Reads the input of all connected HID devices. Each attached controller will write his date into given array until it's full.
@ -194,7 +194,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. If the result is > 0 the number of stored sets in the array is returned. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. If the result is > 0 the number of stored sets in the array is returned.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevices(InputData * output,int32_t array_size); static CONTROLLER_PATCHER_RESULT_OR_ERROR gettingInputAllDevices(InputData *output, int32_t array_size);
/** /**
Remaps the buttons in the given \p VPADStatus pointer. InitButtonMapping() needs to be called before calling this. The information about the remapping is stored in the config_controller array. Remaps the buttons in the given \p VPADStatus pointer. InitButtonMapping() needs to be called before calling this. The information about the remapping is stored in the config_controller array.
@ -204,7 +204,7 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR buttonRemapping(VPADStatus * buffer, int32_t buffer_count); static CONTROLLER_PATCHER_RESULT_OR_ERROR buttonRemapping(VPADStatus *buffer, int32_t buffer_count);
/** /**
Prints the current pressed down buttons of the given \p VPADStatus pointer. Uses the utils/logger.c UDP logger.. Prints the current pressed down buttons of the given \p VPADStatus pointer. Uses the utils/logger.c UDP logger..
@ -213,9 +213,9 @@ public:
@return When the functions failed result < 0 is returned. If the result is == 0 the function was successful. @return When the functions failed result < 0 is returned. If the result is == 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR printVPADButtons(VPADStatus * buffer); static CONTROLLER_PATCHER_RESULT_OR_ERROR printVPADButtons(VPADStatus *buffer);
static std::string getIdentifierByVIDPID(uint16_t vid,uint16_t pid); static std::string getIdentifierByVIDPID(uint16_t vid, uint16_t pid);
static void destroyConfigHelper(); static void destroyConfigHelper();

2
include/controller_patcher/ControllerPatcherDefs.h
View File

@ -276,7 +276,7 @@ typedef struct _HID_Data {
} data_union; /**< The data union where the current and last data is stored.*/ } data_union; /**< The data union where the current and last data is stored.*/
DEVICE_TYPE type; /**< The device type*/ DEVICE_TYPE type; /**< The device type*/
HIDSlotData slotdata; /**< Information about the deviceslot and his mask*/ HIDSlotData slotdata; /**< Information about the deviceslot and his mask*/
my_cb_user * user_data; /**< Pointer to the user data the read callback is using*/ my_cb_user *user_data; /**< Pointer to the user data the read callback is using*/
} HID_Data; } HID_Data;

41
source/ConfigReader.cpp
View File

@ -17,13 +17,12 @@
#include "./ConfigReader.hpp" #include "./ConfigReader.hpp"
#include <fs/FSUtils.h> #include <fs/FSUtils.h>
#include <fcntl.h>
#include <map>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <map>
#include <stdio.h>
#include <sys/stat.h> #include <sys/stat.h>
#include <fcntl.h>
#include <sys/types.h> #include <sys/types.h>
#include <unistd.h> #include <unistd.h>
@ -39,13 +38,13 @@ ConfigReader::ConfigReader() {
BOOL ConfigReader::ReadConfigs(std::string path) { BOOL ConfigReader::ReadConfigs(std::string path) {
std::vector<std::string> fileList = ScanFolder(path); std::vector<std::string> fileList = ScanFolder(path);
if(fileList.size() == 1 && fileList[0].compare("ERROR") == 0) { if (fileList.size() == 1 && fileList[0].compare("ERROR") == 0) {
return false; return false;
} }
if(fileList.size() > 0) { if (fileList.size() > 0) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found %d config files",fileList.size()); DEBUG_FUNCTION_LINE("Found %d config files", fileList.size());
} }
processFileList(fileList); processFileList(fileList);
} }
@ -54,7 +53,7 @@ BOOL ConfigReader::ReadConfigs(std::string path) {
ConfigReader::~ConfigReader() { ConfigReader::~ConfigReader() {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("~ConfigReader"); DEBUG_FUNCTION_LINE("~ConfigReader");
} }
} }
@ -65,7 +64,7 @@ std::vector<std::string> ConfigReader::ScanFolder(std::string path) {
struct dirent *dirent = NULL; struct dirent *dirent = NULL;
DIR *dirHandle = opendir(path.c_str()); DIR *dirHandle = opendir(path.c_str());
if (dirHandle == NULL) { if (dirHandle == NULL) {
DEBUG_FUNCTION_LINE("Failed to open dir %s",path.c_str()); DEBUG_FUNCTION_LINE("Failed to open dir %s", path.c_str());
config_files.push_back("ERROR"); //TODO: Find a proper solution config_files.push_back("ERROR"); //TODO: Find a proper solution
return config_files; return config_files;
} }
@ -73,16 +72,16 @@ std::vector<std::string> ConfigReader::ScanFolder(std::string path) {
BOOL isDir = dirent->d_type & DT_DIR; BOOL isDir = dirent->d_type & DT_DIR;
const char *filename = dirent->d_name; const char *filename = dirent->d_name;
if(strcmp(filename,".") == 0 || strcmp(filename,"..") == 0) { if (strcmp(filename, ".") == 0 || strcmp(filename, "..") == 0) {
continue; continue;
} }
std::string newPath = path + "/" + std::string(filename); std::string newPath = path + "/" + std::string(filename);
if(!isDir && StringTools::EndsWith(std::string(filename),".ini")) { if (!isDir && StringTools::EndsWith(std::string(filename), ".ini")) {
config_files.push_back(newPath); config_files.push_back(newPath);
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found ini: %s ",newPath.c_str()); DEBUG_FUNCTION_LINE("Found ini: %s ", newPath.c_str());
} }
} }
} }
@ -91,8 +90,8 @@ std::vector<std::string> ConfigReader::ScanFolder(std::string path) {
} }
void ConfigReader::processFileList(std::vector<std::string> path) { void ConfigReader::processFileList(std::vector<std::string> path) {
for(std::vector<std::string>::iterator it = path.begin(); it != path.end(); ++it) { for (std::vector<std::string>::iterator it = path.begin(); it != path.end(); ++it) {
DEBUG_FUNCTION_LINE("Reading %s",it->c_str()); DEBUG_FUNCTION_LINE("Reading %s", it->c_str());
std::string result = loadFileToString(*it); std::string result = loadFileToString(*it);
ConfigParser parser(result); ConfigParser parser(result);
@ -102,12 +101,12 @@ void ConfigReader::processFileList(std::vector<std::string> path) {
std::string ConfigReader::loadFileToString(std::string path) { std::string ConfigReader::loadFileToString(std::string path) {
std::string strBuffer = ""; std::string strBuffer = "";
uint8_t * buffer = NULL; uint8_t *buffer = NULL;
if(FSUtils::LoadFileToMem(path.c_str(),&buffer,NULL) > 0) { if (FSUtils::LoadFileToMem(path.c_str(), &buffer, NULL) > 0) {
strBuffer = std::string((char *)buffer); strBuffer = std::string((char *) buffer);
strBuffer = StringTools::removeCharFromString(strBuffer,'\r'); strBuffer = StringTools::removeCharFromString(strBuffer, '\r');
strBuffer = StringTools::removeCharFromString(strBuffer,' '); strBuffer = StringTools::removeCharFromString(strBuffer, ' ');
strBuffer = StringTools::removeCharFromString(strBuffer,'\t'); strBuffer = StringTools::removeCharFromString(strBuffer, '\t');
} }
return strBuffer; return strBuffer;
} }

13
source/ConfigReader.hpp
View File

@ -22,29 +22,30 @@
#include "ControllerPatcherIncludes.hpp" #include "ControllerPatcherIncludes.hpp"
class ConfigReader{ class ConfigReader {
friend class ControllerPatcher; friend class ControllerPatcher;
friend class ConfigParser; friend class ConfigParser;
private:
private:
static ConfigReader *getInstance() { static ConfigReader *getInstance() {
if(!instance){ if (!instance) {
instance = new ConfigReader(); instance = new ConfigReader();
} }
return instance; return instance;
} }
static void destroyInstance() { static void destroyInstance() {
if(instance){ if (instance) {
delete instance; delete instance;
instance = NULL; instance = NULL;
} }
} }
static int32_t getNumberOfLoadedFiles(){ static int32_t getNumberOfLoadedFiles() {
return ConfigReader::numberValidFiles; return ConfigReader::numberValidFiles;
} }
static void increaseNumberOfLoadedFiles(){ static void increaseNumberOfLoadedFiles() {
ConfigReader::numberValidFiles++; ConfigReader::numberValidFiles++;
} }
BOOL ReadConfigs(std::string path); BOOL ReadConfigs(std::string path);

1043
source/ControllerPatcher.cpp
View File

File diff suppressed because it is too large Load Diff

10
source/ControllerPatcherIncludes.hpp
View File

@ -22,29 +22,29 @@
#include <wut_types.h> #include <wut_types.h>
#include <coreinit/systeminfo.h>
#include <padscore/kpad.h> #include <padscore/kpad.h>
#include <padscore/wpad.h> #include <padscore/wpad.h>
#include <vpad/input.h>
#include <coreinit/systeminfo.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <vpad/input.h>
#include "./ConfigReader.hpp" #include "./ConfigReader.hpp"
#include <controller_patcher/ControllerPatcher.hpp> #include <controller_patcher/ControllerPatcher.hpp>
#include <system/CThread.h>
#include "./utils/CPRetainVars.hpp" #include "./utils/CPRetainVars.hpp"
#include "./utils/PadConst.hpp" #include "./utils/PadConst.hpp"
#include <system/CThread.h>
#include <utils/StringTools.h> #include <utils/StringTools.h>
#include "./patcher/ControllerPatcherHID.hpp" #include "./patcher/ControllerPatcherHID.hpp"
#include "./patcher/ControllerPatcherUtils.hpp" #include "./patcher/ControllerPatcherUtils.hpp"
#include "./config/ConfigValues.hpp"
#include "./config/ConfigParser.hpp" #include "./config/ConfigParser.hpp"
#include "./config/ConfigValues.hpp"
#include "./network/CPTCPServer.hpp" #include "./network/CPTCPServer.hpp"
#include "./network/UDPServer.hpp"
#include "./network/UDPClient.hpp" #include "./network/UDPClient.hpp"
#include "./network/UDPServer.hpp"
#endif /* _CONTROLLER_PATCHER_INCLUDES_H_ */ #endif /* _CONTROLLER_PATCHER_INCLUDES_H_ */

229
source/config/ConfigParser.cpp
View File

@ -15,34 +15,34 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/ ****************************************************************************/
#include "./ConfigParser.hpp" #include "./ConfigParser.hpp"
#include <utils/StringTools.h>
#include <algorithm> #include <algorithm>
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <utils/StringTools.h>
ConfigParser::ConfigParser(std::string configData) { ConfigParser::ConfigParser(std::string configData) {
this->content = configData; this->content = configData;
this->contentLines = StringTools::stringSplit(content, ""); this->contentLines = StringTools::stringSplit(content, "");
if(contentLines.empty()) { if (contentLines.empty()) {
return; return;
} }
//remove the comments and make everything uppercase //remove the comments and make everything uppercase
for(uint32_t i = 0; i < contentLines.size(); i++) { for (uint32_t i = 0; i < contentLines.size(); i++) {
std::vector<std::string> comments = StringTools::stringSplit(contentLines[i], "//"); std::vector<std::string> comments = StringTools::stringSplit(contentLines[i], "//");
if(!comments.empty()) { if (!comments.empty()) {
contentLines[i] = comments[0]; contentLines[i] = comments[0];
} }
//we want everything uppercase //we want everything uppercase
std::transform(contentLines[i].begin(), contentLines[i].end(),contentLines[i].begin(), ::toupper); std::transform(contentLines[i].begin(), contentLines[i].end(), contentLines[i].begin(), ::toupper);
} }
//remove empty lines //remove empty lines
std::vector<std::string> contentline2; std::vector<std::string> contentline2;
for(uint32_t i = 0; i < contentLines.size(); i++) { for (uint32_t i = 0; i < contentLines.size(); i++) {
if(strlen(contentLines[i].c_str()) > 0) { if (strlen(contentLines[i].c_str()) > 0) {
contentline2.push_back(contentLines[i]); contentline2.push_back(contentLines[i]);
} }
} }
@ -51,7 +51,6 @@ ConfigParser::ConfigParser(std::string configData) {
} }
ConfigParser::~ConfigParser() { ConfigParser::~ConfigParser() {
} }
PARSE_TYPE ConfigParser::getType() { PARSE_TYPE ConfigParser::getType() {
@ -71,36 +70,36 @@ void ConfigParser::setSlot(uint16_t newSlot) {
} }
BOOL ConfigParser::Init() { BOOL ConfigParser::Init() {
if(contentLines.size() == 0) { if (contentLines.size() == 0) {
DEBUG_FUNCTION_LINE("File seems to be empty. Make sure to have a proper header"); DEBUG_FUNCTION_LINE("File seems to be empty. Make sure to have a proper header");
return false; return false;
} }
const char * line = contentLines[0].c_str(); const char *line = contentLines[0].c_str();
int32_t len = strlen(line); int32_t len = strlen(line);
if(len <= 4) { if (len <= 4) {
DEBUG_FUNCTION_LINE("Header is too short."); DEBUG_FUNCTION_LINE("Header is too short.");
return false; return false;
} }
std::string identify; std::string identify;
if(line[0] == '[' && line[len-1] == ']') { if (line[0] == '[' && line[len - 1] == ']') {
identify = contentLines[0].substr(1,len-2); identify = contentLines[0].substr(1, len - 2);
} else { } else {
DEBUG_FUNCTION_LINE("Not a proper config file!"); DEBUG_FUNCTION_LINE("Not a proper config file!");
return false; return false;
} }
if(identify.compare("GAMEPAD") == 0) { if (identify.compare("GAMEPAD") == 0) {
DEBUG_FUNCTION_LINE("Its a gamepad config file!"); DEBUG_FUNCTION_LINE("Its a gamepad config file!");
setSlot(gGamePadSlot); setSlot(gGamePadSlot);
setType(PARSE_GAMEPAD); setType(PARSE_GAMEPAD);
} else if(identify.compare("MOUSE") == 0) { } else if (identify.compare("MOUSE") == 0) {
DEBUG_FUNCTION_LINE("Its a mouse config file!"); DEBUG_FUNCTION_LINE("Its a mouse config file!");
setSlot(gMouseSlot); setSlot(gMouseSlot);
setType(PARSE_MOUSE); setType(PARSE_MOUSE);
this->vid = HID_MOUSE_VID; this->vid = HID_MOUSE_VID;
this->pid = HID_MOUSE_PID; this->pid = HID_MOUSE_PID;
} else if(identify.compare("KEYBOARD") == 0) { } else if (identify.compare("KEYBOARD") == 0) {
DEBUG_FUNCTION_LINE("Its a keyboard config file!"); DEBUG_FUNCTION_LINE("Its a keyboard config file!");
setSlot(gHID_SLOT_KEYBOARD); setSlot(gHID_SLOT_KEYBOARD);
setType(PARSE_KEYBOARD); setType(PARSE_KEYBOARD);
@ -112,7 +111,7 @@ BOOL ConfigParser::Init() {
setType(PARSE_CONTROLLER); setType(PARSE_CONTROLLER);
} }
if(getSlot() == HID_INVALID_SLOT) { if (getSlot() == HID_INVALID_SLOT) {
return false; return false;
} }
@ -122,53 +121,53 @@ BOOL ConfigParser::Init() {
} }
void ConfigParser::parseSingleLine(std::string line) { void ConfigParser::parseSingleLine(std::string line) {
if(line.empty()) { if (line.empty()) {
DEBUG_FUNCTION_LINE("Can't parse line. it's empty"); DEBUG_FUNCTION_LINE("Can't parse line. it's empty");
return; return;
} }
std::vector<std::string> cur_values = StringTools::stringSplit(line,"="); std::vector<std::string> cur_values = StringTools::stringSplit(line, "=");
if(cur_values.size() != 2) { if (cur_values.size() != 2) {
if(HID_DEBUG || cur_values.size() > 2) { if (HID_DEBUG || cur_values.size() > 2) {
DEBUG_FUNCTION_LINE("Not a valid key=pair line %s",line.c_str()); DEBUG_FUNCTION_LINE("Not a valid key=pair line %s", line.c_str());
} }
return; return;
} else { } else {
uint16_t hid_slot = getSlot(); uint16_t hid_slot = getSlot();
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("leftpart = \"%s\" ",cur_values[0].c_str()); DEBUG_FUNCTION_LINE("leftpart = \"%s\" ", cur_values[0].c_str());
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("rightpart = \"%s\" ",cur_values[1].c_str()); DEBUG_FUNCTION_LINE("rightpart = \"%s\" ", cur_values[1].c_str());
} }
int32_t keyslot = -1; int32_t keyslot = -1;
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Checking single value"); DEBUG_FUNCTION_LINE("Checking single value");
} }
if(getType() == PARSE_GAMEPAD || getType() == PARSE_KEYBOARD) { if (getType() == PARSE_GAMEPAD || getType() == PARSE_KEYBOARD) {
keyslot = ConfigValues::getKeySlotGamePad(cur_values[0]); keyslot = ConfigValues::getKeySlotGamePad(cur_values[0]);
} else if(getType() == PARSE_MOUSE) { } else if (getType() == PARSE_MOUSE) {
keyslot = ConfigValues::getKeySlotMouse(cur_values[0]); keyslot = ConfigValues::getKeySlotMouse(cur_values[0]);
} else { } else {
keyslot = ConfigValues::getKeySlotDefaultSingleValue(cur_values[0]); keyslot = ConfigValues::getKeySlotDefaultSingleValue(cur_values[0]);
} }
if(keyslot != -1) { if (keyslot != -1) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Its a single value"); DEBUG_FUNCTION_LINE("Its a single value");
} }
long rightValue = -1; long rightValue = -1;
BOOL valueSet = false; BOOL valueSet = false;
if(cur_values[0].compare("DPAD_MODE") == 0) { if (cur_values[0].compare("DPAD_MODE") == 0) {
const uint8_t * values_ = NULL; const uint8_t *values_ = NULL;
if((values_ = ConfigValues::getValuesStickPreset(cur_values[1])) != NULL) { if ((values_ = ConfigValues::getValuesStickPreset(cur_values[1])) != NULL) {
if(values_[STICK_CONF_MAGIC_VERSION] != STICK_CONF_MAGIC_VALUE) if (values_[STICK_CONF_MAGIC_VERSION] != STICK_CONF_MAGIC_VALUE)
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Settings preset DPAD MODE and Mask"); DEBUG_FUNCTION_LINE("Settings preset DPAD MODE and Mask");
} }
config_controller[hid_slot][CONTRPS_DPAD_MODE][0] = CONTROLLER_PATCHER_VALUE_SET; config_controller[hid_slot][CONTRPS_DPAD_MODE][0] = CONTROLLER_PATCHER_VALUE_SET;
config_controller[hid_slot][CONTRPS_DPAD_MODE][1] = values_[CONTRDPAD_MODE]; config_controller[hid_slot][CONTRPS_DPAD_MODE][1] = values_[CONTRDPAD_MODE];
if(values_[CONTRDPAD_MASK] != 0x00) { if (values_[CONTRDPAD_MASK] != 0x00) {
config_controller[hid_slot][CONTRPS_DPAD_MASK][0] = CONTROLLER_PATCHER_VALUE_SET; config_controller[hid_slot][CONTRPS_DPAD_MASK][0] = CONTROLLER_PATCHER_VALUE_SET;
config_controller[hid_slot][CONTRPS_DPAD_MASK][1] = values_[CONTRDPAD_MASK]; config_controller[hid_slot][CONTRPS_DPAD_MASK][1] = values_[CONTRDPAD_MASK];
} }
@ -176,83 +175,83 @@ void ConfigParser::parseSingleLine(std::string line) {
} }
} }
if(!valueSet) { if (!valueSet) {
if(getType() == PARSE_KEYBOARD) { if (getType() == PARSE_KEYBOARD) {
if((rightValue = ConfigValues::getPresetValuesKeyboard(cur_values[1]))!= -1) { if ((rightValue = ConfigValues::getPresetValuesKeyboard(cur_values[1])) != -1) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined Keyboard! \"%s\" is %d",cur_values[1].c_str(),rightValue); DEBUG_FUNCTION_LINE("Used pre-defined Keyboard! \"%s\" is %d", cur_values[1].c_str(), rightValue);
} }
} else { } else {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("I need to parse %s",cur_values[1].c_str()); DEBUG_FUNCTION_LINE("I need to parse %s", cur_values[1].c_str());
} }
char * ptr; char *ptr;
rightValue = strtol(cur_values[1].c_str(),&ptr,16); rightValue = strtol(cur_values[1].c_str(), &ptr, 16);
} }
} else { } else {
rightValue = ConfigValues::getPresetValue(cur_values[1]); rightValue = ConfigValues::getPresetValue(cur_values[1]);
if(getType() == PARSE_MOUSE) { //No parsing for the mouse if (getType() == PARSE_MOUSE) { //No parsing for the mouse
if(rightValue == -1) { if (rightValue == -1) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Invalid mouse value, lets skip it %s",cur_values[1].c_str()); DEBUG_FUNCTION_LINE("Invalid mouse value, lets skip it %s", cur_values[1].c_str());
} }
return; return;
} }
} else { } else {
if(rightValue == -1) { if (rightValue == -1) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("I need to parse %s",cur_values[1].c_str()); DEBUG_FUNCTION_LINE("I need to parse %s", cur_values[1].c_str());
} }
char * ptr; char *ptr;
rightValue = strtol(cur_values[1].c_str(),&ptr,16); rightValue = strtol(cur_values[1].c_str(), &ptr, 16);
} }
} }
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Setting value to %d",rightValue); DEBUG_FUNCTION_LINE("Setting value to %d", rightValue);
} }
config_controller[hid_slot][keyslot][0] = CONTROLLER_PATCHER_VALUE_SET; config_controller[hid_slot][keyslot][0] = CONTROLLER_PATCHER_VALUE_SET;
config_controller[hid_slot][keyslot][1] = rightValue; config_controller[hid_slot][keyslot][1] = rightValue;
} }
} else { } else {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Check pair value"); DEBUG_FUNCTION_LINE("Check pair value");
} }
keyslot = ConfigValues::getKeySlotDefaultPairedValue(cur_values[0]); keyslot = ConfigValues::getKeySlotDefaultPairedValue(cur_values[0]);
if(keyslot != -1) { if (keyslot != -1) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Its a pair value"); DEBUG_FUNCTION_LINE("Its a pair value");
} }
if(!ConfigValues::getInstance()->setIfValueIsAControllerPreset(cur_values[1],getSlot(),keyslot)) { if (!ConfigValues::getInstance()->setIfValueIsAControllerPreset(cur_values[1], getSlot(), keyslot)) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("And its no preset"); DEBUG_FUNCTION_LINE("And its no preset");
} }
std::vector<std::string> rightvalues = StringTools::stringSplit(cur_values[1],","); std::vector<std::string> rightvalues = StringTools::stringSplit(cur_values[1], ",");
if(rightvalues.size() != 2) { if (rightvalues.size() != 2) {
DEBUG_FUNCTION_LINE("%d instead of 2 key=values pairs in line",rightvalues.size()); DEBUG_FUNCTION_LINE("%d instead of 2 key=values pairs in line", rightvalues.size());
return; return;
} }
char * ptr; char *ptr;
long firstValue = strtol(rightvalues[0].c_str(),&ptr,16); long firstValue = strtol(rightvalues[0].c_str(), &ptr, 16);
long secondValue = strtol(rightvalues[1].c_str(),&ptr,16); long secondValue = strtol(rightvalues[1].c_str(), &ptr, 16);
config_controller[hid_slot][keyslot][0] = firstValue; config_controller[hid_slot][keyslot][0] = firstValue;
config_controller[hid_slot][keyslot][1] = secondValue; config_controller[hid_slot][keyslot][1] = secondValue;
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Set %02X,%02X",firstValue,secondValue); DEBUG_FUNCTION_LINE("Set %02X,%02X", firstValue, secondValue);
} }
} else { } else {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found preset value!!"); DEBUG_FUNCTION_LINE("Found preset value!!");
} }
} }
} else { } else {
DEBUG_FUNCTION_LINE("The setting \"%s\" is unknown!",cur_values[0].c_str()); DEBUG_FUNCTION_LINE("The setting \"%s\" is unknown!", cur_values[0].c_str());
} }
} }
} }
@ -260,8 +259,8 @@ void ConfigParser::parseSingleLine(std::string line) {
BOOL ConfigParser::resetConfig() { BOOL ConfigParser::resetConfig() {
int32_t slot = getSlot(); int32_t slot = getSlot();
if((slot == HID_INVALID_SLOT) || (slot >= gHIDMaxDevices)) return false; if ((slot == HID_INVALID_SLOT) || (slot >= gHIDMaxDevices)) return false;
for(int32_t j = (CONTRPS_PID+1); j< CONTRPS_MAX_VALUE; j++) { for (int32_t j = (CONTRPS_PID + 1); j < CONTRPS_MAX_VALUE; j++) {
config_controller[slot][j][0] = CONTROLLER_PATCHER_INVALIDVALUE; config_controller[slot][j][0] = CONTROLLER_PATCHER_INVALIDVALUE;
config_controller[slot][j][1] = CONTROLLER_PATCHER_INVALIDVALUE; config_controller[slot][j][1] = CONTROLLER_PATCHER_INVALIDVALUE;
} }
@ -269,38 +268,38 @@ BOOL ConfigParser::resetConfig() {
} }
int32_t ConfigParser::getSlotController(std::string identify) { int32_t ConfigParser::getSlotController(std::string identify) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Getting Controller Slot"); DEBUG_FUNCTION_LINE("Getting Controller Slot");
} }
std::vector<std::string> values = StringTools::stringSplit(identify,","); std::vector<std::string> values = StringTools::stringSplit(identify, ",");
if(values.size() != 2) { if (values.size() != 2) {
DEBUG_FUNCTION_LINE("You need to provide a VID and PID. e.g. \"[vid=0x451,pid=0x152]\". (%s)",identify.c_str()); DEBUG_FUNCTION_LINE("You need to provide a VID and PID. e.g. \"[vid=0x451,pid=0x152]\". (%s)", identify.c_str());
return HID_INVALID_SLOT; return HID_INVALID_SLOT;
} }
int32_t vid = getValueFromKeyValue(values[0],"VID","="); int32_t vid = getValueFromKeyValue(values[0], "VID", "=");
if(vid < 0) { if (vid < 0) {
return HID_INVALID_SLOT; return HID_INVALID_SLOT;
} }
int32_t pid = getValueFromKeyValue(values[1],"PID","="); int32_t pid = getValueFromKeyValue(values[1], "PID", "=");
if(pid < 0) { if (pid < 0) {
return HID_INVALID_SLOT; return HID_INVALID_SLOT;
} }
DEBUG_FUNCTION_LINE("VID: %04x PID: %04x",vid,pid); DEBUG_FUNCTION_LINE("VID: %04x PID: %04x", vid, pid);
this->vid = vid; this->vid = vid;
this->pid = pid; this->pid = pid;
DeviceInfo deviceinfo; DeviceInfo deviceinfo;
memset(&deviceinfo,0,sizeof(deviceinfo)); memset(&deviceinfo, 0, sizeof(deviceinfo));
deviceinfo.vidpid.vid = vid; deviceinfo.vidpid.vid = vid;
deviceinfo.vidpid.pid = pid; deviceinfo.vidpid.pid = pid;
int32_t result = ControllerPatcherUtils::getDeviceInfoFromVidPid(&deviceinfo); int32_t result = ControllerPatcherUtils::getDeviceInfoFromVidPid(&deviceinfo);
int32_t slot = deviceinfo.slotdata.deviceslot; int32_t slot = deviceinfo.slotdata.deviceslot;
int32_t hid = 0; int32_t hid = 0;
if(result < 0) { if (result < 0) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Its a new controller, lets save it"); DEBUG_FUNCTION_LINE("Its a new controller, lets save it");
} }
@ -310,95 +309,95 @@ int32_t ConfigParser::getSlotController(std::string identify) {
slot = slotdata.deviceslot; slot = slotdata.deviceslot;
hid = slotdata.hidmask; hid = slotdata.hidmask;
if(slot >= gHIDMaxDevices) { if (slot >= gHIDMaxDevices) {
DEBUG_FUNCTION_LINE("We don't a space for a new controller, please delete .inis"); DEBUG_FUNCTION_LINE("We don't a space for a new controller, please delete .inis");
return HID_INVALID_SLOT; return HID_INVALID_SLOT;
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Got new slot! slot: %d hid %s .. Lets registrate it!",slot,StringTools::byte_to_binary(hid)); DEBUG_FUNCTION_LINE("Got new slot! slot: %d hid %s .. Lets registrate it!", slot, StringTools::byte_to_binary(hid));
} }
config_controller[slot][CONTRPS_VID][0] = (vid & 0xFF00) >> 8; config_controller[slot][CONTRPS_VID][0] = (vid & 0xFF00) >> 8;
config_controller[slot][CONTRPS_VID][1] = (vid & 0x00FF); config_controller[slot][CONTRPS_VID][1] = (vid & 0x00FF);
config_controller[slot][CONTRPS_PID][0] = (pid & 0xFF00) >> 8; config_controller[slot][CONTRPS_PID][0] = (pid & 0xFF00) >> 8;
config_controller[slot][CONTRPS_PID][1] = (pid & 0x00FF); config_controller[slot][CONTRPS_PID][1] = (pid & 0x00FF);
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Saved vid: %04X pid: %04X", DEBUG_FUNCTION_LINE("Saved vid: %04X pid: %04X",
config_controller[slot][CONTRPS_VID][0] * 0x100 + config_controller[slot][CONTRPS_VID][1], config_controller[slot][CONTRPS_VID][0] * 0x100 + config_controller[slot][CONTRPS_VID][1],
config_controller[slot][CONTRPS_PID][0] * 0x100 + config_controller[slot][CONTRPS_PID][1]); config_controller[slot][CONTRPS_PID][0] * 0x100 + config_controller[slot][CONTRPS_PID][1]);
} }
config_controller_hidmask[slot] = hid; config_controller_hidmask[slot] = hid;
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Saved the hid"); DEBUG_FUNCTION_LINE("Saved the hid");
} }
} else { } else {
if(slot < gHIDMaxDevices) { if (slot < gHIDMaxDevices) {
hid = config_controller_hidmask[slot]; hid = config_controller_hidmask[slot];
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE(">>>>>> found slot %d (hid:%s). Modifing existing data <<<<<<<<",slot,StringTools::byte_to_binary(hid)); DEBUG_FUNCTION_LINE(">>>>>> found slot %d (hid:%s). Modifing existing data <<<<<<<<", slot, StringTools::byte_to_binary(hid));
} }
DEBUG_FUNCTION_LINE("We already have data of this controller, lets modify it"); DEBUG_FUNCTION_LINE("We already have data of this controller, lets modify it");
} else { } else {
DEBUG_FUNCTION_LINE("Something really odd happend to the slots. %d is bigger then max (%d)",slot,gHIDMaxDevices); DEBUG_FUNCTION_LINE("Something really odd happend to the slots. %d is bigger then max (%d)", slot, gHIDMaxDevices);
return HID_INVALID_SLOT; return HID_INVALID_SLOT;
} }
} }
DEBUG_FUNCTION_LINE("using slot: %d hid %08X",slot,hid); DEBUG_FUNCTION_LINE("using slot: %d hid %08X", slot, hid);
return slot; return slot;
} }
BOOL ConfigParser::parseIni() { BOOL ConfigParser::parseIni() {
if(getSlot() == HID_INVALID_SLOT) { if (getSlot() == HID_INVALID_SLOT) {
DEBUG_FUNCTION_LINE("Couldn't parse file. Not a valid slot. Probably broken config. Or you tried to have more than %d devices",getType(),gHIDMaxDevices); DEBUG_FUNCTION_LINE("Couldn't parse file. Not a valid slot. Probably broken config. Or you tried to have more than %d devices", getType(), gHIDMaxDevices);
return false; return false;
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Parsing content, type %d",getType()); DEBUG_FUNCTION_LINE("Parsing content, type %d", getType());
} }
int32_t start = 1; int32_t start = 1;
if(contentLines.size() <= 1) { if (contentLines.size() <= 1) {
DEBUG_FUNCTION_LINE("File only contains a header."); DEBUG_FUNCTION_LINE("File only contains a header.");
return false; return false;
} }
if(contentLines[1].compare("[IGNOREDEFAULT]") == 0) { if (contentLines[1].compare("[IGNOREDEFAULT]") == 0) {
resetConfig(); resetConfig();
DEBUG_FUNCTION_LINE("Ignoring existing settings of this device"); DEBUG_FUNCTION_LINE("Ignoring existing settings of this device");
start++; start++;
} }
for(uint32_t i = start; i < contentLines.size(); i++) { for (uint32_t i = start; i < contentLines.size(); i++) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("line %d: \"%s\" ",(i+1),contentLines[i].c_str()); DEBUG_FUNCTION_LINE("line %d: \"%s\" ", (i + 1), contentLines[i].c_str());
} }
parseSingleLine(contentLines[i]); parseSingleLine(contentLines[i]);
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Parsing of the file is done."); DEBUG_FUNCTION_LINE("Parsing of the file is done.");
} }
return true; return true;
} }
int32_t ConfigParser::getValueFromKeyValue(std::string value_pair,std::string expectedKey,std::string delimiter) { int32_t ConfigParser::getValueFromKeyValue(std::string value_pair, std::string expectedKey, std::string delimiter) {
std::vector<std::string> string_value = StringTools::stringSplit(value_pair,delimiter); std::vector<std::string> string_value = StringTools::stringSplit(value_pair, delimiter);
if(string_value.size() != 2) { if (string_value.size() != 2) {
if(HID_DEBUG || string_value.size() > 2) { if (HID_DEBUG || string_value.size() > 2) {
DEBUG_FUNCTION_LINE("Not a valid key=pair line %s",value_pair.c_str()); DEBUG_FUNCTION_LINE("Not a valid key=pair line %s", value_pair.c_str());
} }
return -1; return -1;
} }
if(string_value[0].compare(expectedKey) != 0) { if (string_value[0].compare(expectedKey) != 0) {
DEBUG_FUNCTION_LINE("Key part not %s, its %s",expectedKey.c_str(),string_value[0].c_str()); DEBUG_FUNCTION_LINE("Key part not %s, its %s", expectedKey.c_str(), string_value[0].c_str());
return -1; return -1;
} }
char * ptr; char *ptr;
int32_t value = strtol(string_value[1].c_str(),&ptr,16); int32_t value = strtol(string_value[1].c_str(), &ptr, 16);
return value; return value;
} }

9
source/config/ConfigParser.hpp
View File

@ -17,9 +17,9 @@
#ifndef _ConfigParser_H_ #ifndef _ConfigParser_H_
#define _ConfigParser_H_ #define _ConfigParser_H_
#include <map>
#include <string> #include <string>
#include <vector> #include <vector>
#include <map>
#include <stdio.h> #include <stdio.h>
@ -27,16 +27,17 @@
#include <utils/logger.h> #include <utils/logger.h>
enum PARSE_TYPE{ enum PARSE_TYPE {
PARSE_CONTROLLER, PARSE_CONTROLLER,
PARSE_GAMEPAD, PARSE_GAMEPAD,
PARSE_MOUSE, PARSE_MOUSE,
PARSE_KEYBOARD PARSE_KEYBOARD
}; };
class ConfigParser{ class ConfigParser {
friend class ConfigReader; friend class ConfigReader;
friend class ControllerPatcher; friend class ControllerPatcher;
private: private:
//!Constructor //!Constructor
ConfigParser(std::string configData); ConfigParser(std::string configData);
@ -59,7 +60,7 @@ private:
int32_t checkExistingController(int32_t vid, int32_t pid); int32_t checkExistingController(int32_t vid, int32_t pid);
int32_t getValueFromKeyValue(std::string value_pair,std::string expectedKey,std::string delimiter); int32_t getValueFromKeyValue(std::string value_pair, std::string expectedKey, std::string delimiter);
BOOL resetConfig(); BOOL resetConfig();

76
source/config/ConfigValues.cpp
View File

@ -28,13 +28,13 @@ ConfigValues::ConfigValues() {
} }
ConfigValues::~ConfigValues() { ConfigValues::~ConfigValues() {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("\n"); DEBUG_FUNCTION_LINE("\n");
} }
} }
const uint8_t * ConfigValues::getValuesForPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue) { const uint8_t *ConfigValues::getValuesForPreset(std::map<std::string, const uint8_t *> values, std::string possibleValue) {
std::map<std::string,const uint8_t*>::iterator it; std::map<std::string, const uint8_t *>::iterator it;
it = values.find(possibleValue); it = values.find(possibleValue);
if (it != values.end()) { if (it != values.end()) {
return it->second; return it->second;
@ -42,46 +42,46 @@ const uint8_t * ConfigValues::getValuesForPreset(std::map<std::string,const uint
return NULL; return NULL;
} }
BOOL ConfigValues::setIfValueIsAControllerPresetEx(std::string value,int32_t slot,int32_t keyslot) { BOOL ConfigValues::setIfValueIsAControllerPresetEx(std::string value, int32_t slot, int32_t keyslot) {
if(setIfValueIsPreset(presetGCValues,value,slot,keyslot)) return true; if (setIfValueIsPreset(presetGCValues, value, slot, keyslot)) return true;
if(setIfValueIsPreset(presetDS3Values,value,slot,keyslot)) return true; if (setIfValueIsPreset(presetDS3Values, value, slot, keyslot)) return true;
if(setIfValueIsPreset(presetDS4Values,value,slot,keyslot)) return true; if (setIfValueIsPreset(presetDS4Values, value, slot, keyslot)) return true;
if(setIfValueIsPreset(presetXInputValues,value,slot,keyslot)) return true; if (setIfValueIsPreset(presetXInputValues, value, slot, keyslot)) return true;
if(setIfValueIsPreset(presetSwitchProValues,value,slot,keyslot)) return true; if (setIfValueIsPreset(presetSwitchProValues, value, slot, keyslot)) return true;
return false; return false;
} }
//We need this function here so we can use preset sticks. //We need this function here so we can use preset sticks.
BOOL ConfigValues::setIfValueIsPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue,int32_t slot,int32_t keyslot) { BOOL ConfigValues::setIfValueIsPreset(std::map<std::string, const uint8_t *> values, std::string possibleValue, int32_t slot, int32_t keyslot) {
if(slot > gHIDMaxDevices || slot < 0 || keyslot < 0 || keyslot >= CONTRPS_MAX_VALUE) { if (slot > gHIDMaxDevices || slot < 0 || keyslot < 0 || keyslot >= CONTRPS_MAX_VALUE) {
return false; return false;
} }
const uint8_t * values_ = NULL; const uint8_t *values_ = NULL;
if( keyslot == CONTRPS_VPAD_BUTTON_L_STICK_X || if (keyslot == CONTRPS_VPAD_BUTTON_L_STICK_X ||
keyslot == CONTRPS_VPAD_BUTTON_L_STICK_Y || keyslot == CONTRPS_VPAD_BUTTON_L_STICK_Y ||
keyslot == CONTRPS_VPAD_BUTTON_R_STICK_X || keyslot == CONTRPS_VPAD_BUTTON_R_STICK_X ||
keyslot == CONTRPS_VPAD_BUTTON_R_STICK_Y) { keyslot == CONTRPS_VPAD_BUTTON_R_STICK_Y) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("This may be a predefined stick %s",possibleValue.c_str()); DEBUG_FUNCTION_LINE("This may be a predefined stick %s", possibleValue.c_str());
} }
if((values_ = ConfigValues::getValuesStickPreset(possibleValue)) != NULL) { if ((values_ = ConfigValues::getValuesStickPreset(possibleValue)) != NULL) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Found predefined stick!"); DEBUG_FUNCTION_LINE("Found predefined stick!");
} }
config_controller[slot][keyslot][0] = values_[STICK_CONF_BYTE]; //CONTRPS_VPAD_BUTTON_L_STICK_X config_controller[slot][keyslot][0] = values_[STICK_CONF_BYTE]; //CONTRPS_VPAD_BUTTON_L_STICK_X
config_controller[slot][keyslot][1] = values_[STICK_CONF_DEFAULT]; config_controller[slot][keyslot][1] = values_[STICK_CONF_DEFAULT];
config_controller[slot][keyslot+DEF_STICK_OFFSET_INVERT][0] = CONTROLLER_PATCHER_VALUE_SET; //CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT config_controller[slot][keyslot + DEF_STICK_OFFSET_INVERT][0] = CONTROLLER_PATCHER_VALUE_SET; //CONTRPS_VPAD_BUTTON_L_STICK_X_INVERT
config_controller[slot][keyslot+DEF_STICK_OFFSET_INVERT][1] = values_[STICK_CONF_INVERT]; config_controller[slot][keyslot + DEF_STICK_OFFSET_INVERT][1] = values_[STICK_CONF_INVERT];
config_controller[slot][keyslot+DEF_STICK_OFFSET_DEADZONE][0] = CONTROLLER_PATCHER_VALUE_SET; //CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE config_controller[slot][keyslot + DEF_STICK_OFFSET_DEADZONE][0] = CONTROLLER_PATCHER_VALUE_SET; //CONTRPS_VPAD_BUTTON_L_STICK_X_DEADZONE
config_controller[slot][keyslot+DEF_STICK_OFFSET_DEADZONE][1] = values_[STICK_CONF_DEADZONE]; config_controller[slot][keyslot + DEF_STICK_OFFSET_DEADZONE][1] = values_[STICK_CONF_DEADZONE];
config_controller[slot][keyslot+DEF_STICK_OFFSET_MINMAX][0] = values_[STICK_CONF_MIN]; //CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX config_controller[slot][keyslot + DEF_STICK_OFFSET_MINMAX][0] = values_[STICK_CONF_MIN]; //CONTRPS_VPAD_BUTTON_L_STICK_X_MINMAX
config_controller[slot][keyslot+DEF_STICK_OFFSET_MINMAX][1] = values_[STICK_CONF_MAX]; config_controller[slot][keyslot + DEF_STICK_OFFSET_MINMAX][1] = values_[STICK_CONF_MAX];
return true; return true;
} }
} }
if((values_ = getValuesForPreset(values,possibleValue)) != NULL) { if ((values_ = getValuesForPreset(values, possibleValue)) != NULL) {
config_controller[slot][keyslot][0] = values_[0]; config_controller[slot][keyslot][0] = values_[0];
config_controller[slot][keyslot][1] = values_[1]; config_controller[slot][keyslot][1] = values_[1];
return true; return true;
@ -90,8 +90,8 @@ BOOL ConfigValues::setIfValueIsPreset(std::map<std::string,const uint8_t*> value
} }
int32_t ConfigValues::getValueFromMap(std::map<std::string,int> values,std::string nameOfString) { int32_t ConfigValues::getValueFromMap(std::map<std::string, int> values, std::string nameOfString) {
std::map<std::string,int>::iterator it; std::map<std::string, int>::iterator it;
it = values.find(nameOfString); it = values.find(nameOfString);
if (it != values.end()) { if (it != values.end()) {
return it->second; return it->second;
@ -103,31 +103,31 @@ int32_t ConfigValues::getValueFromMap(std::map<std::string,int> values,std::stri
int32_t ConfigValues::getPresetValueEx(std::string possibleString) { int32_t ConfigValues::getPresetValueEx(std::string possibleString) {
int32_t rightValue = -1; int32_t rightValue = -1;
if((rightValue = getValueFromMap(gGamePadValuesToCONTRPSString,possibleString))!= -1) { if ((rightValue = getValueFromMap(gGamePadValuesToCONTRPSString, possibleString)) != -1) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined VPAD_VALUE! \"%s\" is %d",possibleString.c_str(),rightValue); DEBUG_FUNCTION_LINE("Used pre-defined VPAD_VALUE! \"%s\" is %d", possibleString.c_str(), rightValue);
} }
} else if((rightValue = getValueFromMap(presetValues,possibleString))!= -1) { } else if ((rightValue = getValueFromMap(presetValues, possibleString)) != -1) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Used pre-defined value! \"%s\" is %d",possibleString.c_str(),rightValue); DEBUG_FUNCTION_LINE("Used pre-defined value! \"%s\" is %d", possibleString.c_str(), rightValue);
} }
} }
return rightValue; return rightValue;
} }
void ConfigValues::addDeviceNameEx(uint16_t vid,uint16_t pid,std::string value) { void ConfigValues::addDeviceNameEx(uint16_t vid, uint16_t pid, std::string value) {
deviceNames[StringTools::strfmt("%04X%04X",vid,pid).c_str()] = value; deviceNames[StringTools::strfmt("%04X%04X", vid, pid).c_str()] = value;
} }
std::string ConfigValues::getStringByVIDPIDEx(uint16_t vid,uint16_t pid) { std::string ConfigValues::getStringByVIDPIDEx(uint16_t vid, uint16_t pid) {
std::string result = ""; std::string result = "";
std::map<std::string,std::string>::iterator it; std::map<std::string, std::string>::iterator it;
it = deviceNames.find(StringTools::strfmt("%04X%04X",vid,pid)); it = deviceNames.find(StringTools::strfmt("%04X%04X", vid, pid));
if (it != deviceNames.end()) { if (it != deviceNames.end()) {
result = it->second; result = it->second;
} else { } else {
result = StringTools::strfmt("VID: 0x%04X\nPID: 0x%04X",vid,pid); result = StringTools::strfmt("VID: 0x%04X\nPID: 0x%04X", vid, pid);
} }
return result; return result;
} }

158
source/config/ConfigValues.hpp
View File

@ -17,21 +17,21 @@
#ifndef _ConfigValues_H_ #ifndef _ConfigValues_H_
#define _ConfigValues_H_ #define _ConfigValues_H_
#include <map>
#include <string> #include <string>
#include <vector> #include <vector>
#include <map>
#include "../ControllerPatcherIncludes.hpp" #include "../ControllerPatcherIncludes.hpp"
#include <utils/logger.h> #include <utils/logger.h>
class ConfigValues class ConfigValues {
{ friend class ConfigParser;
friend class ConfigParser; friend class ControllerPatcher;
friend class ControllerPatcher;
private: private:
static ConfigValues *getInstance() { static ConfigValues *getInstance() {
if(instance == NULL){ if (instance == NULL) {
DEBUG_FUNCTION_LINE("We need a new instance!!!\n"); DEBUG_FUNCTION_LINE("We need a new instance!!!\n");
instance = new ConfigValues(); instance = new ConfigValues();
} }
@ -39,7 +39,7 @@ private:
} }
static void destroyInstance() { static void destroyInstance() {
if(instance){ if (instance) {
delete instance; delete instance;
instance = NULL; instance = NULL;
} }
@ -48,96 +48,88 @@ private:
/** /**
Returns NULL if not a preset! Returns NULL if not a preset!
**/ **/
static const uint8_t * getValuesStickPreset(std::string possibleValue) static const uint8_t *getValuesStickPreset(std::string possibleValue) {
{ ConfigValues *cur_instance = getInstance();
ConfigValues * cur_instance = getInstance(); if (cur_instance == NULL) return NULL;
if(cur_instance == NULL) return NULL; return cur_instance->getValuesForPreset(cur_instance->presetSticks, possibleValue);
return cur_instance->getValuesForPreset(cur_instance->presetSticks,possibleValue);
} }
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static int32_t getKeySlotGamePad(std::string possibleValue) static int32_t getKeySlotGamePad(std::string possibleValue) {
{ ConfigValues *cur_instance = getInstance();
ConfigValues * cur_instance = getInstance(); if (cur_instance == NULL) return -1;
if(cur_instance == NULL) return -1; return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValue, possibleValue);
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValue,possibleValue);
} }
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static int32_t getKeySlotMouse(std::string possibleValue) static int32_t getKeySlotMouse(std::string possibleValue) {
{ ConfigValues *cur_instance = getInstance();
ConfigValues * cur_instance = getInstance(); if (cur_instance == NULL) return -1;
if(cur_instance == NULL) return -1; return cur_instance->getValueFromMap(cur_instance->mouseLeftValues, possibleValue);
return cur_instance->getValueFromMap(cur_instance->mouseLeftValues,possibleValue);
} }
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static int32_t getKeySlotDefaultSingleValue(std::string possibleValue) static int32_t getKeySlotDefaultSingleValue(std::string possibleValue) {
{ ConfigValues *cur_instance = getInstance();
ConfigValues * cur_instance = getInstance(); if (cur_instance == NULL) return -1;
if(cur_instance == NULL) return -1; return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValueSingle, possibleValue);
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValueSingle,possibleValue);
} }
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static int32_t getKeySlotDefaultPairedValue(std::string possibleValue) static int32_t getKeySlotDefaultPairedValue(std::string possibleValue) {
{ ConfigValues *cur_instance = getInstance();
ConfigValues * cur_instance = getInstance(); if (cur_instance == NULL) return -1;
if(cur_instance == NULL) return -1; return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValue, possibleValue);
return cur_instance->getValueFromMap(cur_instance->CONTPRStringToValue,possibleValue);
} }
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static int32_t getPresetValuesKeyboard(std::string possibleValue) static int32_t getPresetValuesKeyboard(std::string possibleValue) {
{ ConfigValues *cur_instance = getInstance();
ConfigValues * cur_instance = getInstance(); if (cur_instance == NULL) return -1;
if(cur_instance == NULL) return -1; return cur_instance->getValueFromMap(cur_instance->presetKeyboardValues, possibleValue);
return cur_instance->getValueFromMap(cur_instance->presetKeyboardValues,possibleValue);
} }
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static int32_t getPresetValue(std::string possibleValue) static int32_t getPresetValue(std::string possibleValue) {
{ ConfigValues *cur_instance = getInstance();
ConfigValues * cur_instance = getInstance(); if (cur_instance == NULL) return -1;
if(cur_instance == NULL) return -1;
return cur_instance->getPresetValueEx(possibleValue); return cur_instance->getPresetValueEx(possibleValue);
} }
/** /**
Returns -1 if not found Returns -1 if not found
**/ **/
static int32_t setIfValueIsAControllerPreset(std::string value,int32_t slot,int32_t keyslot) static int32_t setIfValueIsAControllerPreset(std::string value, int32_t slot, int32_t keyslot) {
{ ConfigValues *cur_instance = getInstance();
ConfigValues * cur_instance = getInstance(); if (cur_instance == NULL) return -1;
if(cur_instance == NULL) return -1; return cur_instance->setIfValueIsAControllerPresetEx(value, slot, keyslot);
return cur_instance->setIfValueIsAControllerPresetEx(value,slot,keyslot);
} }
static void addDeviceName(uint16_t vid,uint16_t pid,std::string value){ static void addDeviceName(uint16_t vid, uint16_t pid, std::string value) {
ConfigValues * cur_instance = getInstance(); ConfigValues *cur_instance = getInstance();
if(cur_instance != NULL){ if (cur_instance != NULL) {
cur_instance->addDeviceNameEx(vid,pid,value); cur_instance->addDeviceNameEx(vid, pid, value);
} }
} }
/** /**
Returns empty String if not found Returns empty String if not found
**/ **/
static std::string getStringByVIDPID(uint16_t vid,uint16_t pid){ static std::string getStringByVIDPID(uint16_t vid, uint16_t pid) {
ConfigValues * cur_instance = getInstance(); ConfigValues *cur_instance = getInstance();
if(cur_instance == NULL) return ""; if (cur_instance == NULL) return "";
return cur_instance->getStringByVIDPIDEx(vid,pid); return cur_instance->getStringByVIDPIDEx(vid, pid);
} }
//!Constructor //!Constructor
@ -147,29 +139,29 @@ private:
static ConfigValues *instance; static ConfigValues *instance;
std::map<std::string,int> mouseLeftValues; std::map<std::string, int> mouseLeftValues;
std::map<std::string,int> CONTPRStringToValue; std::map<std::string, int> CONTPRStringToValue;
std::map<std::string,int> CONTPRStringToValueSingle; std::map<std::string, int> CONTPRStringToValueSingle;
std::map<std::string,int> presetValues; std::map<std::string, int> presetValues;
std::map<std::string,int> gGamePadValuesToCONTRPSString; std::map<std::string, int> gGamePadValuesToCONTRPSString;
std::map<std::string,int> presetKeyboardValues; std::map<std::string, int> presetKeyboardValues;
std::map<std::string,std::string> deviceNames; std::map<std::string, std::string> deviceNames;
std::map<std::string,const uint8_t*> presetGCValues; std::map<std::string, const uint8_t *> presetGCValues;
std::map<std::string,const uint8_t*> presetDS3Values; std::map<std::string, const uint8_t *> presetDS3Values;
std::map<std::string,const uint8_t*> presetDS4Values; std::map<std::string, const uint8_t *> presetDS4Values;
std::map<std::string,const uint8_t*> presetXInputValues; std::map<std::string, const uint8_t *> presetXInputValues;
std::map<std::string,const uint8_t*> presetSwitchProValues; std::map<std::string, const uint8_t *> presetSwitchProValues;
std::map<std::string,const uint8_t*> presetSticks; std::map<std::string, const uint8_t *> presetSticks;
int32_t getValueFromMap(std::map<std::string,int> values,std::string nameOfString); int32_t getValueFromMap(std::map<std::string, int> values, std::string nameOfString);
BOOL checkIfValueIsAControllerPreset(std::string value,int32_t slot,int32_t keyslot); BOOL checkIfValueIsAControllerPreset(std::string value, int32_t slot, int32_t keyslot);
int32_t getPresetValueEx(std::string possibleString); int32_t getPresetValueEx(std::string possibleString);
void InitValues(){ void InitValues() {
DEBUG_FUNCTION_LINE("Init values for the configuration"); DEBUG_FUNCTION_LINE("Init values for the configuration");
CONTPRStringToValue["VPAD_BUTTON_A"] = CONTRPS_VPAD_BUTTON_A; CONTPRStringToValue["VPAD_BUTTON_A"] = CONTRPS_VPAD_BUTTON_A;
CONTPRStringToValue["VPAD_BUTTON_B"] = CONTRPS_VPAD_BUTTON_B; CONTPRStringToValue["VPAD_BUTTON_B"] = CONTRPS_VPAD_BUTTON_B;
@ -553,22 +545,22 @@ private:
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_UP"] = CONTRPS_VPAD_STICK_L_EMULATION_UP; gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_UP"] = CONTRPS_VPAD_STICK_L_EMULATION_UP;
gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_L_EMULATION_DOWN; gGamePadValuesToCONTRPSString["VPAD_STICK_L_EMULATION_DOWN"] = CONTRPS_VPAD_STICK_L_EMULATION_DOWN;
deviceNames[StringTools::strfmt("%04X%04X",HID_GC_VID, HID_GC_PID).c_str()] = HID_GC_STRING; deviceNames[StringTools::strfmt("%04X%04X", HID_GC_VID, HID_GC_PID).c_str()] = HID_GC_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_KEYBOARD_VID, HID_KEYBOARD_PID).c_str()] = HID_KEYBOARD_STRING; deviceNames[StringTools::strfmt("%04X%04X", HID_KEYBOARD_VID, HID_KEYBOARD_PID).c_str()] = HID_KEYBOARD_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_MOUSE_VID, HID_MOUSE_PID).c_str()] = HID_MOUSE_STRING; deviceNames[StringTools::strfmt("%04X%04X", HID_MOUSE_VID, HID_MOUSE_PID).c_str()] = HID_MOUSE_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_DS3_VID, HID_DS3_PID).c_str()] = HID_DS3_STRING; deviceNames[StringTools::strfmt("%04X%04X", HID_DS3_VID, HID_DS3_PID).c_str()] = HID_DS3_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_NEW_DS4_VID, HID_NEW_DS4_PID).c_str()] = HID_NEW_DS4_STRING; deviceNames[StringTools::strfmt("%04X%04X", HID_NEW_DS4_VID, HID_NEW_DS4_PID).c_str()] = HID_NEW_DS4_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_DS4_VID, HID_DS4_PID).c_str()] = HID_DS4_STRING; deviceNames[StringTools::strfmt("%04X%04X", HID_DS4_VID, HID_DS4_PID).c_str()] = HID_DS4_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_XINPUT_VID, HID_XINPUT_PID).c_str()] = HID_XINPUT_STRING; deviceNames[StringTools::strfmt("%04X%04X", HID_XINPUT_VID, HID_XINPUT_PID).c_str()] = HID_XINPUT_STRING;
deviceNames[StringTools::strfmt("%04X%04X",HID_SWITCH_PRO_VID,HID_SWITCH_PRO_PID).c_str()] = HID_SWITCH_PRO_STRING; deviceNames[StringTools::strfmt("%04X%04X", HID_SWITCH_PRO_VID, HID_SWITCH_PRO_PID).c_str()] = HID_SWITCH_PRO_STRING;
} }
const uint8_t * getValuesForPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue); const uint8_t *getValuesForPreset(std::map<std::string, const uint8_t *> values, std::string possibleValue);
BOOL setIfValueIsPreset(std::map<std::string,const uint8_t*> values,std::string possibleValue,int32_t slot,int32_t keyslot); BOOL setIfValueIsPreset(std::map<std::string, const uint8_t *> values, std::string possibleValue, int32_t slot, int32_t keyslot);
BOOL setIfValueIsAControllerPresetEx(std::string value,int32_t slot,int32_t keyslot); BOOL setIfValueIsAControllerPresetEx(std::string value, int32_t slot, int32_t keyslot);
void addDeviceNameEx(uint16_t vid,uint16_t pid,std::string value); void addDeviceNameEx(uint16_t vid, uint16_t pid, std::string value);
std::string getStringByVIDPIDEx(uint16_t vid,uint16_t pid); std::string getStringByVIDPIDEx(uint16_t vid, uint16_t pid);
}; };
#endif #endif

4
source/fs/CFile.cpp
View File

@ -1,7 +1,7 @@
#include "CFile.hpp"
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h> #include <stdio.h>
#include <strings.h> #include <strings.h>
#include "CFile.hpp"
CFile::CFile() { CFile::CFile() {
iFd = -1; iFd = -1;
@ -169,5 +169,3 @@ int32_t CFile::fwrite(const char *format, ...) {
return result; return result;
} }

6
source/fs/CFile.hpp
View File

@ -1,10 +1,10 @@
#ifndef CFILE_HPP_ #ifndef CFILE_HPP_
#define CFILE_HPP_ #define CFILE_HPP_
#include <stdio.h>
#include <string>
#include <string.h>
#include <fcntl.h> #include <fcntl.h>
#include <stdio.h>
#include <string.h>
#include <string>
#include <unistd.h> #include <unistd.h>
#include <wut_types.h> #include <wut_types.h>

11
source/fs/FSUtils.cpp
View File

@ -1,11 +1,11 @@
#include <malloc.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include "FSUtils.h" #include "FSUtils.h"
#include "CFile.hpp" #include "CFile.hpp"
#include "utils/logger.h" #include "utils/logger.h"
#include <fcntl.h>
#include <malloc.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size) { int32_t FSUtils::LoadFileToMem(const char *filepath, uint8_t **inbuffer, uint32_t *size) {
//! always initialze input //! always initialze input
@ -171,4 +171,3 @@ int32_t FSUtils::saveBufferToFile(const char *path, const void *buffer, uint32_t
file.close(); file.close();
return written; return written;
} }

2
source/fs/FSUtils.h
View File

@ -1,7 +1,7 @@
#pragma once #pragma once
#include <wut_types.h>
#include <string> #include <string>
#include <wut_types.h>
class FSUtils { class FSUtils {
public: public:

176
source/network/CPTCPServer.cpp
View File

@ -15,16 +15,16 @@
* along with this program. If not, see <http://www.gnu.org/licenses/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
****************************************************************************/ ****************************************************************************/
#include "CPTCPServer.hpp" #include "CPTCPServer.hpp"
#include <netinet/in.h>
#include <malloc.h> #include <malloc.h>
#include <netinet/in.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <utils/logger.h> #include <utils/logger.h>
CPTCPServer * CPTCPServer::instance = NULL; CPTCPServer *CPTCPServer::instance = NULL;
CPTCPServer::CPTCPServer(int32_t port): TCPServer(port,CPTCPServer::getPriority()) { CPTCPServer::CPTCPServer(int32_t port) : TCPServer(port, CPTCPServer::getPriority()) {
CPTCPServer::AttachDetach(HID_DEVICE_DETACH); CPTCPServer::AttachDetach(HID_DEVICE_DETACH);
} }
@ -33,34 +33,34 @@ CPTCPServer::~CPTCPServer() {
} }
void CPTCPServer::AttachDetach(HIDAttachEvent attach) { void CPTCPServer::AttachDetach(HIDAttachEvent attach) {
if(HID_DEBUG) { if (HID_DEBUG) {
if(attach) { if (attach) {
DEBUG_FUNCTION_LINE("Network Attach"); DEBUG_FUNCTION_LINE("Network Attach");
} else { } else {
DEBUG_FUNCTION_LINE("Network Detach"); DEBUG_FUNCTION_LINE("Network Detach");
} }
} }
for(int32_t i= 0; i< gHIDMaxDevices; i++) { for (int32_t i = 0; i < gHIDMaxDevices; i++) {
for(int32_t j= 0; j< HID_MAX_PADS_COUNT; j++) { for (int32_t j = 0; j < HID_MAX_PADS_COUNT; j++) {
if(gNetworkController[i][j][NETWORK_CONTROLLER_ACTIVE] > 0) { if (gNetworkController[i][j][NETWORK_CONTROLLER_ACTIVE] > 0) {
DEBUG_FUNCTION_LINE("Found a registered pad in deviceslot %d and padslot %d! Lets detach it.",i,j); DEBUG_FUNCTION_LINE("Found a registered pad in deviceslot %d and padslot %d! Lets detach it.", i, j);
HIDDevice device; HIDDevice device;
memset(&device,0,sizeof(device)); memset(&device, 0, sizeof(device));
device.interfaceIndex = 0; device.interfaceIndex = 0;
device.vid = gNetworkController[i][j][NETWORK_CONTROLLER_VID]; device.vid = gNetworkController[i][j][NETWORK_CONTROLLER_VID];
device.pid = gNetworkController[i][j][NETWORK_CONTROLLER_PID]; device.pid = gNetworkController[i][j][NETWORK_CONTROLLER_PID];
device.handle = gNetworkController[i][j][NETWORK_CONTROLLER_HANDLE]; device.handle = gNetworkController[i][j][NETWORK_CONTROLLER_HANDLE];
device.maxPacketSizeRx = 8; device.maxPacketSizeRx = 8;
ControllerPatcherHID::externAttachDetachCallback(&device,attach); ControllerPatcherHID::externAttachDetachCallback(&device, attach);
memset(gNetworkController[i][j],0,sizeof(gNetworkController[i][j])); memset(gNetworkController[i][j], 0, sizeof(gNetworkController[i][j]));
} }
} }
} }
if(HID_DEBUG) { if (HID_DEBUG) {
if(attach) { if (attach) {
DEBUG_FUNCTION_LINE("Network Attach DONE!"); DEBUG_FUNCTION_LINE("Network Attach DONE!");
} else { } else {
DEBUG_FUNCTION_LINE("Network Detach DONE!"); DEBUG_FUNCTION_LINE("Network Detach DONE!");
@ -70,19 +70,19 @@ void CPTCPServer::AttachDetach(HIDAttachEvent attach) {
void CPTCPServer::DetachAndDelete() { void CPTCPServer::DetachAndDelete() {
CPTCPServer::AttachDetach(HID_DEVICE_DETACH); CPTCPServer::AttachDetach(HID_DEVICE_DETACH);
memset(&gNetworkController,0,sizeof(gNetworkController)); memset(&gNetworkController, 0, sizeof(gNetworkController));
} }
BOOL CPTCPServer::whileLoop() { BOOL CPTCPServer::whileLoop() {
int32_t ret; int32_t ret;
int32_t clientfd = getClientFD(); int32_t clientfd = getClientFD();
while (1) { while (1) {
if(shouldExit()) { if (shouldExit()) {
break; break;
} }
ret = checkbyte(clientfd); ret = checkbyte(clientfd);
if (ret < 0) { if (ret < 0) {
if(errno != EWOULDBLOCK) { if (errno != EWOULDBLOCK) {
return false; return false;
} }
OSSleepTicks(OSMicrosecondsToTicks(1000)); OSSleepTicks(OSMicrosecondsToTicks(1000));
@ -91,85 +91,85 @@ BOOL CPTCPServer::whileLoop() {
//DEBUG_FUNCTION_LINE("got byte from tcp! %01X",ret); //DEBUG_FUNCTION_LINE("got byte from tcp! %01X",ret);
switch (ret) { switch (ret) {
case WIIU_CP_TCP_ATTACH: { /*attach */ case WIIU_CP_TCP_ATTACH: { /*attach */
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) { if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
int32_t handle; int32_t handle;
ret = recvwait(clientfd, &handle, 4); ret = recvwait(clientfd, &handle, 4);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle",WIIU_CP_TCP_ATTACH); DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle", WIIU_CP_TCP_ATTACH);
return false; return false;
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("got handle %d",handle); DEBUG_FUNCTION_LINE("got handle %d", handle);
} }
uint16_t vid = 0; uint16_t vid = 0;
uint16_t pid = 0; uint16_t pid = 0;
ret = recvwait(clientfd, &vid, 2); ret = recvwait(clientfd, &vid, 2);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait vid",WIIU_CP_TCP_ATTACH); DEBUG_FUNCTION_LINE("Error in %02X: recvwait vid", WIIU_CP_TCP_ATTACH);
return false; return false;
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("got vid %04X",vid); DEBUG_FUNCTION_LINE("got vid %04X", vid);
} }
ret = recvwait(clientfd, &pid, 2); ret = recvwait(clientfd, &pid, 2);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait pid",WIIU_CP_TCP_ATTACH); DEBUG_FUNCTION_LINE("Error in %02X: recvwait pid", WIIU_CP_TCP_ATTACH);
return false; return false;
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("got pid %04X",pid); DEBUG_FUNCTION_LINE("got pid %04X", pid);
} }
HIDDevice device; HIDDevice device;
memset(&device,0,sizeof(device)); memset(&device, 0, sizeof(device));
device.handle = handle; device.handle = handle;
device.interfaceIndex = 0; device.interfaceIndex = 0;
device.vid = SWAP16(vid); device.vid = SWAP16(vid);
device.pid = SWAP16(pid); device.pid = SWAP16(pid);
device.maxPacketSizeRx = 8; device.maxPacketSizeRx = 8;
my_cb_user * user = NULL; my_cb_user *user = NULL;
ControllerPatcherHID::externAttachDetachCallback(&device,HID_DEVICE_ATTACH); ControllerPatcherHID::externAttachDetachCallback(&device, HID_DEVICE_ATTACH);
if((ret = ControllerPatcherUtils::getDataByHandle(handle,&user)) < 0) { if ((ret = ControllerPatcherUtils::getDataByHandle(handle, &user)) < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: getDataByHandle(%d,%08X).",WIIU_CP_TCP_ATTACH,handle,&user); DEBUG_FUNCTION_LINE("Error in %02X: getDataByHandle(%d,%08X).", WIIU_CP_TCP_ATTACH, handle, &user);
DEBUG_FUNCTION_LINE("Error in %02X: Config for the controller is missing.",WIIU_CP_TCP_ATTACH); DEBUG_FUNCTION_LINE("Error in %02X: Config for the controller is missing.", WIIU_CP_TCP_ATTACH);
if((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND) < 0)) { if ((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND byte failed. Error: %d.",WIIU_CP_TCP_ATTACH,ret); DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_CONFIG_NOT_FOUND byte failed. Error: %d.", WIIU_CP_TCP_ATTACH, ret);
} }
return false; return false;
} }
if((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_CONFIG_FOUND) < 0)) { if ((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_CONFIG_FOUND) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_CONFIG_FOUND byte failed. Error: %d.",WIIU_CP_TCP_ATTACH,ret); DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_CONFIG_FOUND byte failed. Error: %d.", WIIU_CP_TCP_ATTACH, ret);
return false; return false;
} }
if(user != NULL) { if (user != NULL) {
if((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_USER_DATA_OKAY) < 0)) { if ((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_USER_DATA_OKAY) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_USER_DATA_OKAY byte failed. Error: %d.",WIIU_CP_TCP_ATTACH,ret); DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_USER_DATA_OKAY byte failed. Error: %d.", WIIU_CP_TCP_ATTACH, ret);
return false; return false;
} }
ret = sendwait(clientfd,&user->slotdata.deviceslot,2); ret = sendwait(clientfd, &user->slotdata.deviceslot, 2);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendwait slotdata: %04X",WIIU_CP_TCP_ATTACH,user->slotdata.deviceslot); DEBUG_FUNCTION_LINE("Error in %02X: sendwait slotdata: %04X", WIIU_CP_TCP_ATTACH, user->slotdata.deviceslot);
return false; return false;
} }
ret = sendwait(clientfd,&user->pad_slot,1); ret = sendwait(clientfd, &user->pad_slot, 1);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendwait pad_slot: %04X",WIIU_CP_TCP_ATTACH,user->pad_slot); DEBUG_FUNCTION_LINE("Error in %02X: sendwait pad_slot: %04X", WIIU_CP_TCP_ATTACH, user->pad_slot);
return false; return false;
} }
} else { } else {
DEBUG_FUNCTION_LINE("Error in %02X: invalid user data.",WIIU_CP_TCP_ATTACH); DEBUG_FUNCTION_LINE("Error in %02X: invalid user data.", WIIU_CP_TCP_ATTACH);
if((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_USER_DATA_BAD) < 0)) { if ((ret = sendbyte(clientfd, WIIU_CP_TCP_ATTACH_USER_DATA_BAD) < 0)) {
DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_USER_DATA_BAD byte failed. Error: %d.",WIIU_CP_TCP_ATTACH,ret); DEBUG_FUNCTION_LINE("Error in %02X: Sending the WIIU_CP_TCP_ATTACH_USER_DATA_BAD byte failed. Error: %d.", WIIU_CP_TCP_ATTACH, ret);
return false; return false;
} }
return false; return false;
break; break;
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("attachted to device slot: %d , pad slot is: %d",user->slotdata.deviceslot,user->pad_slot); DEBUG_FUNCTION_LINE("attachted to device slot: %d , pad slot is: %d", user->slotdata.deviceslot, user->pad_slot);
} }
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_VID] = device.vid; gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_VID] = device.vid;
@ -177,74 +177,74 @@ BOOL CPTCPServer::whileLoop() {
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_ACTIVE] = 1; gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_ACTIVE] = 1;
gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_HANDLE] = handle; gNetworkController[user->slotdata.deviceslot][user->pad_slot][NETWORK_CONTROLLER_HANDLE] = handle;
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("handle %d connected! vid: %02X pid: %02X deviceslot %d, padslot %d",handle,vid,pid,user->slotdata.deviceslot,user->pad_slot); DEBUG_FUNCTION_LINE("handle %d connected! vid: %02X pid: %02X deviceslot %d, padslot %d", handle, vid, pid, user->slotdata.deviceslot, user->pad_slot);
} }
break; break;
} }
break; break;
} }
case WIIU_CP_TCP_DETACH: { /*detach */ case WIIU_CP_TCP_DETACH: { /*detach */
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) { if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
int32_t handle; int32_t handle;
ret = recvwait(clientfd, &handle, 4); ret = recvwait(clientfd, &handle, 4);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle",WIIU_CP_TCP_DETACH); DEBUG_FUNCTION_LINE("Error in %02X: recvwait handle", WIIU_CP_TCP_DETACH);
return false; return false;
break; break;
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("got detach for handle: %d",handle); DEBUG_FUNCTION_LINE("got detach for handle: %d", handle);
} }
my_cb_user * user = NULL; my_cb_user *user = NULL;
if(ControllerPatcherUtils::getDataByHandle(handle,&user) < 0) { if (ControllerPatcherUtils::getDataByHandle(handle, &user) < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: getDataByHandle(%d,%08X).",WIIU_CP_TCP_DETACH,handle,&user); DEBUG_FUNCTION_LINE("Error in %02X: getDataByHandle(%d,%08X).", WIIU_CP_TCP_DETACH, handle, &user);
return false; return false;
break; break;
} }
if(user == NULL) { if (user == NULL) {
DEBUG_FUNCTION_LINE("Error in %02X: invalid user data.",WIIU_CP_TCP_DETACH); DEBUG_FUNCTION_LINE("Error in %02X: invalid user data.", WIIU_CP_TCP_DETACH);
return false; return false;
break; break;
} }
int32_t deviceslot = user->slotdata.deviceslot; int32_t deviceslot = user->slotdata.deviceslot;
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("device slot is: %d , pad slot is: %d",deviceslot,user->pad_slot); DEBUG_FUNCTION_LINE("device slot is: %d , pad slot is: %d", deviceslot, user->pad_slot);
} }
DeviceVIDPIDInfo vidpid; DeviceVIDPIDInfo vidpid;
int32_t result; int32_t result;
if((result = ControllerPatcherUtils::getVIDPIDbyDeviceSlot(deviceslot,&vidpid)) < 0) { if ((result = ControllerPatcherUtils::getVIDPIDbyDeviceSlot(deviceslot, &vidpid)) < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: Couldn't find a valid VID/PID for device slot %d. Error: %d",WIIU_CP_TCP_DETACH,deviceslot,ret); DEBUG_FUNCTION_LINE("Error in %02X: Couldn't find a valid VID/PID for device slot %d. Error: %d", WIIU_CP_TCP_DETACH, deviceslot, ret);
return false; return false;
break; break;
} }
HIDDevice device; HIDDevice device;
memset(&device,0,sizeof(device)); memset(&device, 0, sizeof(device));
device.handle = handle; device.handle = handle;
device.interfaceIndex = 0; device.interfaceIndex = 0;
device.vid = SWAP16(vidpid.vid); device.vid = SWAP16(vidpid.vid);
device.pid = SWAP16(vidpid.pid); device.pid = SWAP16(vidpid.pid);
device.maxPacketSizeRx = 14; device.maxPacketSizeRx = 14;
ControllerPatcherHID::externAttachDetachCallback(&device,HID_DEVICE_DETACH); ControllerPatcherHID::externAttachDetachCallback(&device, HID_DEVICE_DETACH);
memset(gNetworkController[deviceslot][user->pad_slot],0,sizeof(gNetworkController[deviceslot][user->pad_slot])); memset(gNetworkController[deviceslot][user->pad_slot], 0, sizeof(gNetworkController[deviceslot][user->pad_slot]));
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("handle %d disconnected!",handle); DEBUG_FUNCTION_LINE("handle %d disconnected!", handle);
} }
break; break;
} }
break; break;
} }
case WIIU_CP_TCP_PING: { /*ping*/ case WIIU_CP_TCP_PING: { /*ping*/
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) { if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Got Ping, sending now a Pong"); DEBUG_FUNCTION_LINE("Got Ping, sending now a Pong");
} }
int32_t ret = sendbyte(clientfd, WIIU_CP_TCP_PONG); int32_t ret = sendbyte(clientfd, WIIU_CP_TCP_PONG);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error in %02X: sendbyte PONG"); DEBUG_FUNCTION_LINE("Error in %02X: sendbyte PONG");
return false; return false;
} }
@ -263,37 +263,37 @@ BOOL CPTCPServer::whileLoop() {
BOOL CPTCPServer::acceptConnection() { BOOL CPTCPServer::acceptConnection() {
int32_t clientfd = getClientFD(); int32_t clientfd = getClientFD();
DEBUG_FUNCTION_LINE("TCP Connection accepted! Sending my protocol version: %d (0x%02X)", (WIIU_CP_TCP_HANDSHAKE - WIIU_CP_TCP_HANDSHAKE_VERSION_1)+1,WIIU_CP_TCP_HANDSHAKE); DEBUG_FUNCTION_LINE("TCP Connection accepted! Sending my protocol version: %d (0x%02X)", (WIIU_CP_TCP_HANDSHAKE - WIIU_CP_TCP_HANDSHAKE_VERSION_1) + 1, WIIU_CP_TCP_HANDSHAKE);
gUDPClientip = getSockAddr().sin_addr.s_addr; gUDPClientip = getSockAddr().sin_addr.s_addr;
UDPClient::createInstance(); UDPClient::createInstance();
int32_t ret; int32_t ret;
ret = sendbyte(clientfd, WIIU_CP_TCP_HANDSHAKE); //Hey I'm a WiiU console! ret = sendbyte(clientfd, WIIU_CP_TCP_HANDSHAKE); //Hey I'm a WiiU console!
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error sendbyte: %02X",WIIU_CP_TCP_HANDSHAKE); DEBUG_FUNCTION_LINE("Error sendbyte: %02X", WIIU_CP_TCP_HANDSHAKE);
return false; return false;
} }
uint8_t clientProtocolVersion = recvbyte(clientfd); uint8_t clientProtocolVersion = recvbyte(clientfd);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error recvbyte: %02X",WIIU_CP_TCP_HANDSHAKE); DEBUG_FUNCTION_LINE("Error recvbyte: %02X", WIIU_CP_TCP_HANDSHAKE);
return false; return false;
} }
if(clientProtocolVersion == WIIU_CP_TCP_HANDSHAKE_ABORT) { if (clientProtocolVersion == WIIU_CP_TCP_HANDSHAKE_ABORT) {
DEBUG_FUNCTION_LINE("The network client wants to abort."); DEBUG_FUNCTION_LINE("The network client wants to abort.");
return false; return false;
} }
DEBUG_FUNCTION_LINE("received protocol version: %d (0x%02X)",(clientProtocolVersion - WIIU_CP_TCP_HANDSHAKE_VERSION_1)+1,clientProtocolVersion); DEBUG_FUNCTION_LINE("received protocol version: %d (0x%02X)", (clientProtocolVersion - WIIU_CP_TCP_HANDSHAKE_VERSION_1) + 1, clientProtocolVersion);
if(clientProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_MIN && clientProtocolVersion <= WIIU_CP_TCP_HANDSHAKE_VERSION_MAX) { if (clientProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_MIN && clientProtocolVersion <= WIIU_CP_TCP_HANDSHAKE_VERSION_MAX) {
DEBUG_FUNCTION_LINE("We support this protocol version. Let's confirm it to the network client."); DEBUG_FUNCTION_LINE("We support this protocol version. Let's confirm it to the network client.");
gUsedProtocolVersion = clientProtocolVersion; gUsedProtocolVersion = clientProtocolVersion;
ret = sendbyte(clientfd, clientProtocolVersion); ret = sendbyte(clientfd, clientProtocolVersion);
if(ret < 0) { if (ret < 0) {
DEBUG_FUNCTION_LINE("Error sendbyte: %02X",clientProtocolVersion); DEBUG_FUNCTION_LINE("Error sendbyte: %02X", clientProtocolVersion);
return false; return false;
} }
} else { } else {

23
source/network/CPTCPServer.hpp
View File

@ -19,12 +19,12 @@
#include "../ControllerPatcherIncludes.hpp" #include "../ControllerPatcherIncludes.hpp"
#include <errno.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <utils/TCPServer.hpp>
#include <network/net.h>
#include <coreinit/title.h> #include <coreinit/title.h>
#include <errno.h>
#include <netinet/in.h>
#include <network/net.h>
#include <sys/socket.h>
#include <utils/TCPServer.hpp>
#define WIIU_CP_TCP_HANDSHAKE WIIU_CP_TCP_HANDSHAKE_VERSION_3 #define WIIU_CP_TCP_HANDSHAKE WIIU_CP_TCP_HANDSHAKE_VERSION_3
@ -49,12 +49,12 @@
#define DEFAULT_TCP_PORT 8112 #define DEFAULT_TCP_PORT 8112
class CPTCPServer: TCPServer { class CPTCPServer : TCPServer {
friend class ControllerPatcher; friend class ControllerPatcher;
private: private:
static CPTCPServer *getInstance() { static CPTCPServer *getInstance() {
if(!instance) { if (!instance) {
instance = new CPTCPServer(DEFAULT_TCP_PORT); instance = new CPTCPServer(DEFAULT_TCP_PORT);
} }
@ -62,7 +62,7 @@ private:
} }
static void destroyInstance() { static void destroyInstance() {
if(instance) { if (instance) {
delete instance; delete instance;
instance = NULL; instance = NULL;
} }
@ -70,13 +70,13 @@ private:
static int32_t getPriority() { static int32_t getPriority() {
int32_t priority = 28; int32_t priority = 28;
if(OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN if (OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN
OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA
OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR
OSGetTitleID() == 0x00050000101c9b00 || //The Binding of Isaac: Rebirth EUR OSGetTitleID() == 0x00050000101c9b00 || //The Binding of Isaac: Rebirth EUR
OSGetTitleID() == 0x00050000101a3c00) { //The Binding of Isaac: Rebirth USA OSGetTitleID() == 0x00050000101a3c00) { //The Binding of Isaac: Rebirth USA
priority = 10; priority = 10;
DEBUG_FUNCTION_LINE("This game needs higher thread priority. We set it to %d",priority); DEBUG_FUNCTION_LINE("This game needs higher thread priority. We set it to %d", priority);
} }
return priority; return priority;
} }
@ -97,8 +97,7 @@ private:
virtual void onConnectionClosed(); virtual void onConnectionClosed();
static CPTCPServer * instance; static CPTCPServer *instance;
}; };
#endif //_TCPSERVER_WINDOW_H_ #endif //_TCPSERVER_WINDOW_H_

14
source/network/UDPClient.cpp
View File

@ -23,7 +23,7 @@
#define MAX_UDP_SIZE 0x578 #define MAX_UDP_SIZE 0x578
UDPClient * UDPClient::instance = NULL; UDPClient *UDPClient::instance = NULL;
UDPClient::UDPClient(uint32_t ip, int32_t port) { UDPClient::UDPClient(uint32_t ip, int32_t port) {
sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP); sockfd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
@ -36,7 +36,7 @@ UDPClient::UDPClient(uint32_t ip, int32_t port) {
connect_addr.sin_port = port; connect_addr.sin_port = port;
connect_addr.sin_addr.s_addr = ip; connect_addr.sin_addr.s_addr = ip;
if(connect(sockfd, (struct sockaddr*)&connect_addr, sizeof(connect_addr)) < 0) { if (connect(sockfd, (struct sockaddr *) &connect_addr, sizeof(connect_addr)) < 0) {
close(sockfd); close(sockfd);
sockfd = -1; sockfd = -1;
} }
@ -46,16 +46,16 @@ UDPClient::~UDPClient() {
if (this->sockfd != -1) { if (this->sockfd != -1) {
close(sockfd); close(sockfd);
} }
if(HID_DEBUG) { if (HID_DEBUG) {
log_printf("UDPClient::~UDPClient(line %d): Thread has been closed",__LINE__); log_printf("UDPClient::~UDPClient(line %d): Thread has been closed", __LINE__);
} }
} }
BOOL UDPClient::sendData(char * data,int32_t length) { BOOL UDPClient::sendData(char *data, int32_t length) {
if(sockfd < 0 || data == 0 || length < 0 || gUsedProtocolVersion < WIIU_CP_TCP_HANDSHAKE_VERSION_3) { if (sockfd < 0 || data == 0 || length < 0 || gUsedProtocolVersion < WIIU_CP_TCP_HANDSHAKE_VERSION_3) {
return false; return false;
} }
if(length > 1400) length = 1400; if (length > 1400) length = 1400;
int32_t ret = send(sockfd, data, length, 0); int32_t ret = send(sockfd, data, length, 0);
return (ret >= 0); return (ret >= 0);

16
source/network/UDPClient.hpp
View File

@ -18,8 +18,8 @@
#define _UDPCLIENT_WINDOW_H_ #define _UDPCLIENT_WINDOW_H_
#include "../ControllerPatcherIncludes.hpp" #include "../ControllerPatcherIncludes.hpp"
#include <sys/socket.h>
#include <netinet/in.h> #include <netinet/in.h>
#include <sys/socket.h>
#define DEFAULT_UDP_CLIENT_PORT 8114 #define DEFAULT_UDP_CLIENT_PORT 8114
@ -27,11 +27,11 @@ class UDPClient {
friend class ControllerPatcher; friend class ControllerPatcher;
friend class ControllerPatcherHID; friend class ControllerPatcherHID;
friend class CPTCPServer; friend class CPTCPServer;
public:
public:
private: private:
static UDPClient *getInstance() { static UDPClient *getInstance() {
if(instance == NULL) { if (instance == NULL) {
createInstance(); createInstance();
} }
return instance; return instance;
@ -39,24 +39,24 @@ private:
static UDPClient *createInstance() { static UDPClient *createInstance() {
if(instance != NULL) { if (instance != NULL) {
destroyInstance(); destroyInstance();
} }
instance = new UDPClient(gUDPClientip,DEFAULT_UDP_CLIENT_PORT); instance = new UDPClient(gUDPClientip, DEFAULT_UDP_CLIENT_PORT);
return getInstance(); return getInstance();
} }
static void destroyInstance() { static void destroyInstance() {
if(instance != NULL) { if (instance != NULL) {
delete instance; delete instance;
instance = NULL; instance = NULL;
} }
} }
UDPClient(uint32_t ip,int32_t port); UDPClient(uint32_t ip, int32_t port);
~UDPClient(); ~UDPClient();
BOOL sendData(char * data, int32_t length); BOOL sendData(char *data, int32_t length);
volatile int32_t sockfd = -1; volatile int32_t sockfd = -1;
struct sockaddr_in addr; struct sockaddr_in addr;

78
source/network/UDPServer.cpp
View File

@ -23,8 +23,8 @@
#define MAX_UDP_SIZE 0x578 #define MAX_UDP_SIZE 0x578
CThread * UDPServer::pThread = NULL; CThread *UDPServer::pThread = NULL;
UDPServer * UDPServer::instance = NULL; UDPServer *UDPServer::instance = NULL;
UDPServer::UDPServer(int32_t port) { UDPServer::UDPServer(int32_t port) {
int32_t ret; int32_t ret;
@ -35,20 +35,20 @@ UDPServer::UDPServer(int32_t port) {
addr.sin_addr.s_addr = 0; addr.sin_addr.s_addr = 0;
this->sockfd = ret = socket(AF_INET, SOCK_DGRAM, 0); this->sockfd = ret = socket(AF_INET, SOCK_DGRAM, 0);
if(ret == -1) return; if (ret == -1) return;
int32_t enable = 1; int32_t enable = 1;
setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)); setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
ret = bind(sockfd, (sockaddr *)&addr, 16); ret = bind(sockfd, (sockaddr *) &addr, 16);
if(ret < 0) return; if (ret < 0) return;
StartUDPThread(this); StartUDPThread(this);
} }
UDPServer::~UDPServer() { UDPServer::~UDPServer() {
CThread * pThreadPointer = UDPServer::pThread; CThread *pThreadPointer = UDPServer::pThread;
if(pThreadPointer != NULL) { if (pThreadPointer != NULL) {
exitThread = 1; exitThread = 1;
if(pThreadPointer != NULL) { if (pThreadPointer != NULL) {
delete pThreadPointer; delete pThreadPointer;
UDPServer::pThread = NULL; UDPServer::pThread = NULL;
if (this->sockfd != -1) { if (this->sockfd != -1) {
@ -57,39 +57,37 @@ UDPServer::~UDPServer() {
this->sockfd = -1; this->sockfd = -1;
} }
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Thread has been closed"); DEBUG_FUNCTION_LINE("Thread has been closed");
} }
} }
void UDPServer::StartUDPThread(UDPServer * server) { void UDPServer::StartUDPThread(UDPServer *server) {
int32_t priority = 28; int32_t priority = 28;
if(OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN if (OSGetTitleID() == 0x00050000101c9300 || //The Legend of Zelda Breath of the Wild JPN
OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA OSGetTitleID() == 0x00050000101c9400 || //The Legend of Zelda Breath of the Wild USA
OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR OSGetTitleID() == 0x00050000101c9500 || //The Legend of Zelda Breath of the Wild EUR
OSGetTitleID() == 0x00050000101c9b00 || //The Binding of Isaac: Rebirth EUR OSGetTitleID() == 0x00050000101c9b00 || //The Binding of Isaac: Rebirth EUR
OSGetTitleID() == 0x00050000101a3c00) { //The Binding of Isaac: Rebirth USA OSGetTitleID() == 0x00050000101a3c00) { //The Binding of Isaac: Rebirth USA
priority = 10; priority = 10;
DEBUG_FUNCTION_LINE("This game needs higher thread priority. We set it to %d",priority); DEBUG_FUNCTION_LINE("This game needs higher thread priority. We set it to %d", priority);
} }
UDPServer::pThread = CThread::create(UDPServer::DoUDPThread, (void*)server, CThread::eAttributeAffCore2,priority); UDPServer::pThread = CThread::create(UDPServer::DoUDPThread, (void *) server, CThread::eAttributeAffCore2, priority);
UDPServer::pThread->resumeThread(); UDPServer::pThread->resumeThread();
} }
BOOL UDPServer::cpyIncrementBufferOffset(void * target, void * source, int32_t * offset, int32_t typesize, int32_t maximum) { BOOL UDPServer::cpyIncrementBufferOffset(void *target, void *source, int32_t *offset, int32_t typesize, int32_t maximum) {
if(((int)*offset + typesize) > maximum) { if (((int) *offset + typesize) > maximum) {
DEBUG_FUNCTION_LINE("Transfer error. Excepted %04X bytes, but only got %04X",(*offset + typesize),maximum); DEBUG_FUNCTION_LINE("Transfer error. Excepted %04X bytes, but only got %04X", (*offset + typesize), maximum);
return false; return false;
} }
memcpy(target,(void*)((uint32_t)source+(*offset)),typesize); memcpy(target, (void *) ((uint32_t) source + (*offset)), typesize);
*offset += typesize; *offset += typesize;
return true; return true;
} }
void UDPServer::DoUDPThread(CThread *thread, void *arg) { void UDPServer::DoUDPThread(CThread *thread, void *arg) {
UDPServer * args = (UDPServer * )arg; UDPServer *args = (UDPServer *) arg;
args->DoUDPThreadInternal(); args->DoUDPThreadInternal();
} }
@ -98,60 +96,60 @@ void UDPServer::DoUDPThreadInternal() {
int32_t n; int32_t n;
my_cb_user user; my_cb_user user;
while(1) { while (1) {
//int32_t usingVar = exitThread; //int32_t usingVar = exitThread;
if(exitThread)break; if (exitThread) break;
memset(buffer,0,MAX_UDP_SIZE); memset(buffer, 0, MAX_UDP_SIZE);
n = recv(sockfd,buffer,MAX_UDP_SIZE,0); n = recv(sockfd, buffer, MAX_UDP_SIZE, 0);
if (n < 0) { if (n < 0) {
int32_t errno_ = errno; int32_t errno_ = errno;
OSSleepTicks(OSMicrosecondsToTicks(2000)); OSSleepTicks(OSMicrosecondsToTicks(2000));
if(errno_ != EINVAL && errno_ != ENOTCONN) { if (errno_ != EINVAL && errno_ != ENOTCONN) {
break; break;
} }
continue; continue;
} }
int32_t bufferoffset = 0; int32_t bufferoffset = 0;
uint8_t type; uint8_t type;
memcpy((void *)&type,buffer,sizeof(type)); memcpy((void *) &type, buffer, sizeof(type));
bufferoffset += sizeof(type); bufferoffset += sizeof(type);
switch (buffer[0]) { switch (buffer[0]) {
case WIIU_CP_UDP_CONTROLLER_READ_DATA: { case WIIU_CP_UDP_CONTROLLER_READ_DATA: {
if(gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) { if (gUsedProtocolVersion >= WIIU_CP_TCP_HANDSHAKE_VERSION_1) {
uint8_t count_commands; uint8_t count_commands;
memcpy((void *)&count_commands,buffer+bufferoffset,sizeof(count_commands)); memcpy((void *) &count_commands, buffer + bufferoffset, sizeof(count_commands));
bufferoffset += sizeof(count_commands); bufferoffset += sizeof(count_commands);
for(int32_t i = 0; i<count_commands; i++) { for (int32_t i = 0; i < count_commands; i++) {
int32_t handle; int32_t handle;
uint16_t deviceSlot; uint16_t deviceSlot;
uint32_t hid; uint32_t hid;
uint8_t padslot; uint8_t padslot;
uint8_t datasize; uint8_t datasize;
if(!cpyIncrementBufferOffset((void *)&handle, (void *)buffer,&bufferoffset,sizeof(handle), n))continue; if (!cpyIncrementBufferOffset((void *) &handle, (void *) buffer, &bufferoffset, sizeof(handle), n)) continue;
if(!cpyIncrementBufferOffset((void *)&deviceSlot, (void *)buffer,&bufferoffset,sizeof(deviceSlot),n))continue; if (!cpyIncrementBufferOffset((void *) &deviceSlot, (void *) buffer, &bufferoffset, sizeof(deviceSlot), n)) continue;
hid = (1 << deviceSlot); hid = (1 << deviceSlot);
if(!cpyIncrementBufferOffset((void *)&padslot, (void *)buffer,&bufferoffset,sizeof(padslot), n))continue; if (!cpyIncrementBufferOffset((void *) &padslot, (void *) buffer, &bufferoffset, sizeof(padslot), n)) continue;
if(!cpyIncrementBufferOffset((void *)&datasize, (void *)buffer,&bufferoffset,sizeof(datasize), n))continue; if (!cpyIncrementBufferOffset((void *) &datasize, (void *) buffer, &bufferoffset, sizeof(datasize), n)) continue;
uint8_t * databuffer = (uint8_t*) malloc(datasize * sizeof(uint8_t)); uint8_t *databuffer = (uint8_t *) malloc(datasize * sizeof(uint8_t));
if(!databuffer) { if (!databuffer) {
DEBUG_FUNCTION_LINE("Allocating memory failed"); DEBUG_FUNCTION_LINE("Allocating memory failed");
continue; continue;
} }
if(!cpyIncrementBufferOffset((void *)databuffer, (void *)buffer,&bufferoffset,datasize, n))continue; if (!cpyIncrementBufferOffset((void *) databuffer, (void *) buffer, &bufferoffset, datasize, n)) continue;
//DEBUG_FUNCTION_LINE("UDPServer::DoUDPThreadInternal(): Got handle: %d slot %04X hid %04X pad %02X datasize %02X\n",handle,deviceSlot,hid,padslot,datasize); //DEBUG_FUNCTION_LINE("UDPServer::DoUDPThreadInternal(): Got handle: %d slot %04X hid %04X pad %02X datasize %02X\n",handle,deviceSlot,hid,padslot,datasize);
user.pad_slot = padslot; user.pad_slot = padslot;
user.slotdata.deviceslot = deviceSlot; user.slotdata.deviceslot = deviceSlot;
user.slotdata.hidmask = hid; user.slotdata.hidmask = hid;
if(gNetworkController[deviceSlot][padslot][0] == 0) { if (gNetworkController[deviceSlot][padslot][0] == 0) {
DEBUG_FUNCTION_LINE("Ehm. Pad is not connected. STOP SENDING DATA ;) \n"); DEBUG_FUNCTION_LINE("Ehm. Pad is not connected. STOP SENDING DATA ;) \n");
} else { } else {
ControllerPatcherHID::externHIDReadCallback(handle,databuffer,datasize,&user); ControllerPatcherHID::externHIDReadCallback(handle, databuffer, datasize, &user);
} }
if(databuffer) { if (databuffer) {
free(databuffer); free(databuffer);
databuffer = NULL; databuffer = NULL;
} }
@ -165,7 +163,7 @@ void UDPServer::DoUDPThreadInternal() {
} }
} }
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("UDPServer Thread ended"); DEBUG_FUNCTION_LINE("UDPServer Thread ended");
} }
} }

8
source/network/UDPServer.hpp
View File

@ -28,13 +28,13 @@ class UDPServer {
private: private:
static UDPServer *getInstance() { static UDPServer *getInstance() {
if(instance == NULL) if (instance == NULL)
instance = new UDPServer(DEFAULT_UDP_PORT); instance = new UDPServer(DEFAULT_UDP_PORT);
return instance; return instance;
} }
static void destroyInstance() { static void destroyInstance() {
if(instance != NULL) { if (instance != NULL) {
delete instance; delete instance;
instance = NULL; instance = NULL;
} }
@ -42,10 +42,10 @@ private:
UDPServer(int32_t port); UDPServer(int32_t port);
~UDPServer(); ~UDPServer();
void StartUDPThread(UDPServer * server); void StartUDPThread(UDPServer *server);
static void DoUDPThread(CThread *thread, void *arg); static void DoUDPThread(CThread *thread, void *arg);
void DoUDPThreadInternal(); void DoUDPThreadInternal();
BOOL cpyIncrementBufferOffset(void * target, void * source, int32_t * offset, int32_t typesize, int32_t maximum); BOOL cpyIncrementBufferOffset(void *target, void *source, int32_t *offset, int32_t typesize, int32_t maximum);
volatile int32_t sockfd = -1; volatile int32_t sockfd = -1;
volatile int32_t exitThread = 0; volatile int32_t exitThread = 0;

17
source/network/net.c
View File

@ -4,23 +4,22 @@
static volatile int socket_lock __attribute__((section(".data"))) = 0; static volatile int socket_lock __attribute__((section(".data"))) = 0;
void initNetwork(){ void initNetwork() {
} }
int32_t recvwait(int32_t sock, void *buffer, int32_t len) { int32_t recvwait(int32_t sock, void *buffer, int32_t len) {
while(socket_lock) { while (socket_lock) {
OSSleepTicks(OSMicrosecondsToTicks(1000)); OSSleepTicks(OSMicrosecondsToTicks(1000));
} }
int32_t ret; int32_t ret;
while (len > 0) { while (len > 0) {
ret = recv(sock, buffer, len, 0); ret = recv(sock, buffer, len, 0);
if(ret < 0) { if (ret < 0) {
socket_lock = 0; socket_lock = 0;
return ret; return ret;
} }
len -= ret; len -= ret;
buffer = (void *)(((char *) buffer) + ret); buffer = (void *) (((char *) buffer) + ret);
} }
socket_lock = 0; socket_lock = 0;
return 0; return 0;
@ -45,7 +44,7 @@ uint32_t recvword(int32_t sock) {
} }
int32_t checkbyte(int32_t sock) { int32_t checkbyte(int32_t sock) {
while(socket_lock) { while (socket_lock) {
OSSleepTicks(OSMicrosecondsToTicks(1000)); OSSleepTicks(OSMicrosecondsToTicks(1000));
} }
unsigned char buffer[1]; unsigned char buffer[1];
@ -59,7 +58,7 @@ int32_t checkbyte(int32_t sock) {
} }
int32_t sendwait(int32_t sock, const void *buffer, int32_t len) { int32_t sendwait(int32_t sock, const void *buffer, int32_t len) {
while(socket_lock) { while (socket_lock) {
OSSleepTicks(OSMicrosecondsToTicks(1000)); OSSleepTicks(OSMicrosecondsToTicks(1000));
} }
int32_t ret; int32_t ret;
@ -67,12 +66,12 @@ int32_t sendwait(int32_t sock, const void *buffer, int32_t len) {
// For some reason the send blocks/crashes if the buffer is too big.. // For some reason the send blocks/crashes if the buffer is too big..
int cur_length = len <= 0x30 ? len : 0x30; int cur_length = len <= 0x30 ? len : 0x30;
ret = send(sock, buffer, cur_length, 0); ret = send(sock, buffer, cur_length, 0);
if(ret < 0) { if (ret < 0) {
socket_lock = 0; socket_lock = 0;
return ret; return ret;
} }
len -= ret; len -= ret;
buffer = (void *)(((char *) buffer) + ret); buffer = (void *) (((char *) buffer) + ret);
} }
socket_lock = 0; socket_lock = 0;
return 0; return 0;

455
source/patcher/ControllerPatcherHID.cpp
View File

@ -28,12 +28,12 @@
int32_t ControllerPatcherHID::externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach) { int32_t ControllerPatcherHID::externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach) {
HIDClient client; HIDClient client;
memset(&client,0,sizeof(client)); memset(&client, 0, sizeof(client));
return AttachDetachCallback(&client,p_device,attach); return AttachDetachCallback(&client, p_device, attach);
} }
void ControllerPatcherHID::externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr) { void ControllerPatcherHID::externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user *usr) {
HIDReadCallback(handle,buf,bytes_transfered,usr); HIDReadCallback(handle, buf, bytes_transfered, usr);
} }
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@ -41,26 +41,26 @@ void ControllerPatcherHID::externHIDReadCallback(uint32_t handle, unsigned char
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
int32_t ControllerPatcherHID::myAttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) { int32_t ControllerPatcherHID::myAttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) {
return AttachDetachCallback(p_client,p_device,attach); return AttachDetachCallback(p_client, p_device, attach);
} }
void ControllerPatcherHID::myHIDMouseReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user) { void ControllerPatcherHID::myHIDMouseReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user) {
if(error == 0) { if (error == 0) {
my_cb_user *usr = (my_cb_user*)p_user; my_cb_user *usr = (my_cb_user *) p_user;
uint32_t slot = 0; uint32_t slot = 0;
if(usr->pad_slot < HID_MAX_PADS_COUNT) { if (usr->pad_slot < HID_MAX_PADS_COUNT) {
slot = usr->pad_slot; slot = usr->pad_slot;
} }
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]); HID_Data *data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]);
HID_Mouse_Data * cur_mouse_data = &data_ptr->data_union.mouse.cur_mouse_data; HID_Mouse_Data *cur_mouse_data = &data_ptr->data_union.mouse.cur_mouse_data;
data_ptr->type = DEVICE_TYPE_MOUSE; data_ptr->type = DEVICE_TYPE_MOUSE;
//DEBUG_FUNCTION_LINE("%02X %02X %02X %02X %02X bytes_transfered: %d\n",buf[0],buf[1],buf[2],buf[3],buf[4],bytes_transfered); //DEBUG_FUNCTION_LINE("%02X %02X %02X %02X %02X bytes_transfered: %d\n",buf[0],buf[1],buf[2],buf[3],buf[4],bytes_transfered);
if(buf[0] == 2 && bytes_transfered > 3) { // using the other mouse mode if (buf[0] == 2 && bytes_transfered > 3) { // using the other mouse mode
buf +=1; buf += 1;
} }
int8_t x_value = 0; int8_t x_value = 0;
@ -76,13 +76,13 @@ void ControllerPatcherHID::myHIDMouseReadCallback(uint32_t handle, int32_t error
cur_mouse_data->deltaY = y_value; cur_mouse_data->deltaY = y_value;
cur_mouse_data->left_click = buf[0]; cur_mouse_data->left_click = buf[0];
cur_mouse_data->right_click = buf[0]>>1; cur_mouse_data->right_click = buf[0] >> 1;
if(cur_mouse_data->X < 0) cur_mouse_data->X = 0; if (cur_mouse_data->X < 0) cur_mouse_data->X = 0;
if(cur_mouse_data->X > 1280) cur_mouse_data->X = 1280; if (cur_mouse_data->X > 1280) cur_mouse_data->X = 1280;
if(cur_mouse_data->Y < 0) cur_mouse_data->Y = 0; if (cur_mouse_data->Y < 0) cur_mouse_data->Y = 0;
if(cur_mouse_data->Y > 720) cur_mouse_data->Y = 720; if (cur_mouse_data->Y > 720) cur_mouse_data->Y = 720;
cur_mouse_data->valuedChanged = 1; cur_mouse_data->valuedChanged = 1;
@ -93,12 +93,12 @@ void ControllerPatcherHID::myHIDMouseReadCallback(uint32_t handle, int32_t error
} }
void ControllerPatcherHID::myHIDReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user) { void ControllerPatcherHID::myHIDReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user) {
if(error == 0 && p_user != NULL && gHIDAttached) { if (error == 0 && p_user != NULL && gHIDAttached) {
my_cb_user *usr = (my_cb_user*)p_user; my_cb_user *usr = (my_cb_user *) p_user;
HIDReadCallback(handle,buf,bytes_transfered,usr); HIDReadCallback(handle, buf, bytes_transfered, usr);
if(usr->slotdata.hidmask == gHID_LIST_DS4) { if (usr->slotdata.hidmask == gHID_LIST_DS4) {
OSSleepTicks(OSMicrosecondsToTicks(2000)); //DS4 is way tooo fast. sleeping to reduce lag. (need to check the other pads) OSSleepTicks(OSMicrosecondsToTicks(2000)); //DS4 is way tooo fast. sleeping to reduce lag. (need to check the other pads)
} }
HIDRead(handle, usr->buf, bytes_transfered, myHIDReadCallback, usr); HIDRead(handle, usr->buf, bytes_transfered, myHIDReadCallback, usr);
@ -110,9 +110,9 @@ void ControllerPatcherHID::myHIDReadCallback(uint32_t handle, int32_t error, uns
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) { int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach) {
if(attach) { if (attach) {
DEBUG_FUNCTION_LINE("vid %04x pid %04x connected", SWAP16(p_device->vid),SWAP16(p_device->pid)); DEBUG_FUNCTION_LINE("vid %04x pid %04x connected", SWAP16(p_device->vid), SWAP16(p_device->pid));
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("interface index %02x", p_device->interfaceIndex); DEBUG_FUNCTION_LINE("interface index %02x", p_device->interfaceIndex);
DEBUG_FUNCTION_LINE("sub class %02x", p_device->subClass); DEBUG_FUNCTION_LINE("sub class %02x", p_device->subClass);
DEBUG_FUNCTION_LINE("protocol %02x", p_device->protocol); DEBUG_FUNCTION_LINE("protocol %02x", p_device->protocol);
@ -120,16 +120,16 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
DEBUG_FUNCTION_LINE("max packet out %02x", p_device->maxPacketSizeRx); DEBUG_FUNCTION_LINE("max packet out %02x", p_device->maxPacketSizeRx);
} }
} }
if(!attach) { if (!attach) {
DEBUG_FUNCTION_LINE("vid %04x pid %04x disconnected", SWAP16(p_device->vid),SWAP16(p_device->pid)); DEBUG_FUNCTION_LINE("vid %04x pid %04x disconnected", SWAP16(p_device->vid), SWAP16(p_device->pid));
} }
DeviceInfo device_info; DeviceInfo device_info;
memset(&device_info,0,sizeof(DeviceInfo)); memset(&device_info, 0, sizeof(DeviceInfo));
device_info.slotdata.deviceslot = -1; device_info.slotdata.deviceslot = -1;
device_info.vidpid.vid = SWAP16(p_device->vid); device_info.vidpid.vid = SWAP16(p_device->vid);
device_info.vidpid.pid = SWAP16(p_device->pid); device_info.vidpid.pid = SWAP16(p_device->pid);
HIDSlotData * slotdata = &(device_info.slotdata); HIDSlotData *slotdata = &(device_info.slotdata);
if ((p_device->subClass == 1) && (p_device->protocol == 1)) { //Keyboard if ((p_device->subClass == 1) && (p_device->protocol == 1)) { //Keyboard
slotdata->hidmask = gHID_LIST_KEYBOARD; slotdata->hidmask = gHID_LIST_KEYBOARD;
@ -141,23 +141,23 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
//DEBUG_FUNCTION_LINE("Found Mouse: device: %s slot: %d",byte_to_binary(device_info.hid),device_info.slot); //DEBUG_FUNCTION_LINE("Found Mouse: device: %s slot: %d",byte_to_binary(device_info.hid),device_info.slot);
} else { } else {
int32_t ret; int32_t ret;
if((ret = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) { if ((ret = ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info)) < 0) {
DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) failed %d ",ret); DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) failed %d ", ret);
return HID_DEVICE_DETACH; return HID_DEVICE_DETACH;
} else { } else {
//DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) success %d ",ret); //DEBUG_FUNCTION_LINE("ControllerPatcherUtils::getDeviceInfoFromVidPid(&device_info) success %d ",ret);
} }
} }
if(slotdata->hidmask) { if (slotdata->hidmask) {
if(attach) { if (attach) {
int32_t bufSize = 64; int32_t bufSize = 64;
if(slotdata->hidmask != gHID_LIST_MOUSE && config_controller[slotdata->deviceslot][CONTRPS_BUF_SIZE][0] == CONTROLLER_PATCHER_VALUE_SET) { if (slotdata->hidmask != gHID_LIST_MOUSE && config_controller[slotdata->deviceslot][CONTRPS_BUF_SIZE][0] == CONTROLLER_PATCHER_VALUE_SET) {
bufSize = config_controller[slotdata->deviceslot][CONTRPS_BUF_SIZE][1]; bufSize = config_controller[slotdata->deviceslot][CONTRPS_BUF_SIZE][1];
} }
unsigned char *buf = (unsigned char *) memalign(64,bufSize); unsigned char *buf = (unsigned char *) memalign(64, bufSize);
memset(buf,0,bufSize); memset(buf, 0, bufSize);
my_cb_user *usr = (my_cb_user *) memalign(64,sizeof(my_cb_user)); my_cb_user *usr = (my_cb_user *) memalign(64, sizeof(my_cb_user));
usr->buf = buf; usr->buf = buf;
usr->slotdata = device_info.slotdata; usr->slotdata = device_info.slotdata;
usr->transfersize = p_device->maxPacketSizeRx; usr->transfersize = p_device->maxPacketSizeRx;
@ -165,22 +165,22 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
gHIDAttached |= slotdata->hidmask; gHIDAttached |= slotdata->hidmask;
gHIDCurrentDevice |= slotdata->hidmask; gHIDCurrentDevice |= slotdata->hidmask;
int32_t pads_per_device = 1; int32_t pads_per_device = 1;
if(config_controller[slotdata->deviceslot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if (config_controller[slotdata->deviceslot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
pads_per_device = config_controller[slotdata->deviceslot][CONTRPS_PAD_COUNT][1]; pads_per_device = config_controller[slotdata->deviceslot][CONTRPS_PAD_COUNT][1];
if(pads_per_device > HID_MAX_PADS_COUNT) { //maximum of HID_MAX_PADS_COUNT if (pads_per_device > HID_MAX_PADS_COUNT) { //maximum of HID_MAX_PADS_COUNT
pads_per_device = HID_MAX_PADS_COUNT; pads_per_device = HID_MAX_PADS_COUNT;
} }
} }
int32_t pad_count = config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]; int32_t pad_count = config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1];
if(pad_count > 0x0F) pad_count = 0; //??? if (pad_count > 0x0F) pad_count = 0; //???
int32_t pad_slot = 0; int32_t pad_slot = 0;
int32_t failed = 1; int32_t failed = 1;
for(int32_t i = 0; i<HID_MAX_PADS_COUNT; i += pads_per_device) { for (int32_t i = 0; i < HID_MAX_PADS_COUNT; i += pads_per_device) {
if(!(pad_count & (1 << i))) { if (!(pad_count & (1 << i))) {
failed = 0; failed = 0;
pad_count |= (1 << i); pad_count |= (1 << i);
pad_slot = i; pad_slot = i;
@ -188,13 +188,13 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
} }
} }
if(failed) { if (failed) {
DEBUG_FUNCTION_LINE("error: I can only handle %d devices of the same type. Sorry ",HID_MAX_PADS_COUNT); DEBUG_FUNCTION_LINE("error: I can only handle %d devices of the same type. Sorry ", HID_MAX_PADS_COUNT);
if(buf) { if (buf) {
free(buf); free(buf);
buf = NULL; buf = NULL;
} }
if(usr) { if (usr) {
free(usr); free(usr);
usr = NULL; usr = NULL;
} }
@ -203,30 +203,30 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] = pad_count; config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] = pad_count;
DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1])); DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1], sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1])); DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1], sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
usr->pads_per_device = pads_per_device; usr->pads_per_device = pads_per_device;
usr->pad_slot = pad_slot; usr->pad_slot = pad_slot;
for(int32_t i = 0; i<pads_per_device; i++) { for (int32_t i = 0; i < pads_per_device; i++) {
memset(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],0,sizeof(HID_Data)); memset(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i], 0, sizeof(HID_Data));
gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i].handle = p_device->handle; gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i].handle = p_device->handle;
//DEBUG_FUNCTION_LINE("saved handle %d to slot %d and pad %d",p_device->handle,slotdata->deviceslot,pad_slot); //DEBUG_FUNCTION_LINE("saved handle %d to slot %d and pad %d",p_device->handle,slotdata->deviceslot,pad_slot);
gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i].user_data = usr; gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i].user_data = usr;
gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i].slotdata = device_info.slotdata; gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i].slotdata = device_info.slotdata;
DCFlushRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],sizeof(HID_Data)); DCFlushRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i], sizeof(HID_Data));
DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot+i],sizeof(HID_Data)); DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[pad_slot + i], sizeof(HID_Data));
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Device successfully attached"); DEBUG_FUNCTION_LINE("Device successfully attached");
} }
if(slotdata->hidmask == gHID_LIST_GC) { // GC PAD if (slotdata->hidmask == gHID_LIST_GC) { // GC PAD
//The GC Adapter has all ports in one device. Set them all. //The GC Adapter has all ports in one device. Set them all.
gHID_Devices[slotdata->deviceslot].pad_data[0].slotdata = device_info.slotdata; gHID_Devices[slotdata->deviceslot].pad_data[0].slotdata = device_info.slotdata;
gHID_Devices[slotdata->deviceslot].pad_data[1].slotdata = device_info.slotdata; gHID_Devices[slotdata->deviceslot].pad_data[1].slotdata = device_info.slotdata;
@ -234,18 +234,18 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
gHID_Devices[slotdata->deviceslot].pad_data[3].slotdata = device_info.slotdata; gHID_Devices[slotdata->deviceslot].pad_data[3].slotdata = device_info.slotdata;
buf[0] = 0x13; buf[0] = 0x13;
HIDWrite(p_device->handle, usr->buf, 1, NULL,NULL); HIDWrite(p_device->handle, usr->buf, 1, NULL, NULL);
HIDRead(p_device->handle, usr->buf, usr->transfersize, myHIDReadCallback, usr); HIDRead(p_device->handle, usr->buf, usr->transfersize, myHIDReadCallback, usr);
} else if (slotdata->hidmask == gHID_LIST_MOUSE) { } else if (slotdata->hidmask == gHID_LIST_MOUSE) {
HIDSetProtocol(p_device->handle, p_device->interfaceIndex, 0, 0, 0); HIDSetProtocol(p_device->handle, p_device->interfaceIndex, 0, 0, 0);
//HIDGetDescriptor(p_device->handle,0x22,0x00,0,my_buf,512,my_foo_cb,NULL); //HIDGetDescriptor(p_device->handle,0x22,0x00,0,my_buf,512,my_foo_cb,NULL);
HIDSetIdle(p_device->handle,p_device->interfaceIndex,1,NULL,NULL,NULL); HIDSetIdle(p_device->handle, p_device->interfaceIndex, 1, NULL, NULL, NULL);
gHID_Mouse_Mode = HID_MOUSE_MODE_AIM; gHID_Mouse_Mode = HID_MOUSE_MODE_AIM;
HIDRead(p_device->handle, buf, p_device->maxPacketSizeRx, myHIDMouseReadCallback, usr); HIDRead(p_device->handle, buf, p_device->maxPacketSizeRx, myHIDMouseReadCallback, usr);
} else if (slotdata->hidmask == gHID_LIST_SWITCH_PRO) { } else if (slotdata->hidmask == gHID_LIST_SWITCH_PRO) {
int32_t read_result = HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL); int32_t read_result = HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
if(read_result == 64) { if (read_result == 64) {
if(usr->buf[01] == 0x01) { //We need to do the handshake if (usr->buf[01] == 0x01) { //We need to do the handshake
DEBUG_FUNCTION_LINE("Switch Pro Controller handshake needed"); DEBUG_FUNCTION_LINE("Switch Pro Controller handshake needed");
/** /**
Thanks to ShinyQuagsire23 for the values (https://github.com/shinyquagsire23/HID-Joy-Con-Whispering) Thanks to ShinyQuagsire23 for the values (https://github.com/shinyquagsire23/HID-Joy-Con-Whispering)
@ -253,17 +253,17 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
//Get MAC //Get MAC
buf[0] = 0x80; buf[0] = 0x80;
buf[1] = 0x01; buf[1] = 0x01;
HIDWrite(p_device->handle, usr->buf, 2, NULL,NULL); HIDWrite(p_device->handle, usr->buf, 2, NULL, NULL);
HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL); HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
//Do handshake //Do handshake
buf[0] = 0x80; buf[0] = 0x80;
buf[1] = 0x02; buf[1] = 0x02;
HIDWrite(p_device->handle, usr->buf, 2, NULL,NULL); HIDWrite(p_device->handle, usr->buf, 2, NULL, NULL);
HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL); HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
//Talk over HID only. //Talk over HID only.
buf[0] = 0x80; buf[0] = 0x80;
buf[1] = 0x04; buf[1] = 0x04;
HIDWrite(p_device->handle, usr->buf, 2, NULL,NULL); HIDWrite(p_device->handle, usr->buf, 2, NULL, NULL);
HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL); HIDRead(p_device->handle, usr->buf, usr->transfersize, NULL, NULL);
} else { } else {
DEBUG_FUNCTION_LINE("Switch Pro Controller handshake already done"); DEBUG_FUNCTION_LINE("Switch Pro Controller handshake already done");
@ -276,7 +276,7 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
HIDRead(p_device->handle, buf, p_device->maxPacketSizeRx, myHIDReadCallback, usr); HIDRead(p_device->handle, buf, p_device->maxPacketSizeRx, myHIDReadCallback, usr);
} else if (slotdata->hidmask == gHID_LIST_DS3) { } else if (slotdata->hidmask == gHID_LIST_DS3) {
HIDSetProtocol(p_device->handle, p_device->interfaceIndex, 1, 0, 0); HIDSetProtocol(p_device->handle, p_device->interfaceIndex, 1, 0, 0);
HIDDS3Rumble(p_device->handle,usr,0); HIDDS3Rumble(p_device->handle, usr, 0);
buf[0] = 0x42; buf[0] = 0x42;
buf[1] = 0x0c; buf[1] = 0x0c;
buf[2] = 0x00; buf[2] = 0x00;
@ -289,14 +289,14 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
return HID_DEVICE_ATTACH; return HID_DEVICE_ATTACH;
} else { } else {
my_cb_user * user_data = NULL; my_cb_user *user_data = NULL;
int32_t founddata = 0; int32_t founddata = 0;
for(int32_t i = 0; i<HID_MAX_PADS_COUNT; i++) { for (int32_t i = 0; i < HID_MAX_PADS_COUNT; i++) {
if(gHID_Devices[slotdata->deviceslot].pad_data[i].handle == p_device->handle) { if (gHID_Devices[slotdata->deviceslot].pad_data[i].handle == p_device->handle) {
gHID_Devices[slotdata->deviceslot].pad_data[i].handle = 0; gHID_Devices[slotdata->deviceslot].pad_data[i].handle = 0;
DCFlushRange(&gHID_Devices[slotdata->deviceslot].pad_data[i].handle,sizeof(gHID_Devices[slotdata->deviceslot].pad_data[i].handle)); DCFlushRange(&gHID_Devices[slotdata->deviceslot].pad_data[i].handle, sizeof(gHID_Devices[slotdata->deviceslot].pad_data[i].handle));
DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[i].handle,sizeof(gHID_Devices[slotdata->deviceslot].pad_data[i].handle)); DCInvalidateRange(&gHID_Devices[slotdata->deviceslot].pad_data[i].handle, sizeof(gHID_Devices[slotdata->deviceslot].pad_data[i].handle));
user_data = (my_cb_user *) gHID_Devices[slotdata->deviceslot].pad_data[i].user_data; user_data = (my_cb_user *) gHID_Devices[slotdata->deviceslot].pad_data[i].user_data;
@ -305,40 +305,40 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
} }
} }
if(user_data) { if (user_data) {
config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] &= ~ (1 << user_data->pad_slot); config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] &= ~(1 << user_data->pad_slot);
DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1])); DCFlushRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1], sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1],sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1])); DCInvalidateRange(&config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1], sizeof(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1]));
if(user_data->buf) { if (user_data->buf) {
free(user_data->buf); free(user_data->buf);
user_data->buf = NULL; user_data->buf = NULL;
} }
free(user_data); free(user_data);
user_data = NULL; user_data = NULL;
} else { } else {
if(founddata) { if (founddata) {
DEBUG_FUNCTION_LINE("user_data null. You may have a memory leak."); DEBUG_FUNCTION_LINE("user_data null. You may have a memory leak.");
} }
return HID_DEVICE_DETACH; return HID_DEVICE_DETACH;
} }
if(config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] == 0) { if (config_controller[slotdata->deviceslot][CONTRPS_CONNECTED_PADS][1] == 0) {
gHIDAttached &= ~slotdata->hidmask; gHIDAttached &= ~slotdata->hidmask;
gHIDCurrentDevice &= ~slotdata->hidmask; gHIDCurrentDevice &= ~slotdata->hidmask;
DCFlushRange(&gHIDAttached,sizeof(gHIDAttached)); DCFlushRange(&gHIDAttached, sizeof(gHIDAttached));
DCInvalidateRange(&gHIDAttached,sizeof(gHIDAttached)); DCInvalidateRange(&gHIDAttached, sizeof(gHIDAttached));
DCFlushRange(&gHIDCurrentDevice,sizeof(gHIDCurrentDevice)); DCFlushRange(&gHIDCurrentDevice, sizeof(gHIDCurrentDevice));
DCInvalidateRange(&gHIDCurrentDevice,sizeof(gHIDCurrentDevice)); DCInvalidateRange(&gHIDCurrentDevice, sizeof(gHIDCurrentDevice));
if (slotdata->hidmask == gHID_LIST_MOUSE) { if (slotdata->hidmask == gHID_LIST_MOUSE) {
gHID_Mouse_Mode = HID_MOUSE_MODE_AIM; gHID_Mouse_Mode = HID_MOUSE_MODE_AIM;
} }
} else { } else {
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("We still have pad for deviceslot %d connected.",slotdata->deviceslot); DEBUG_FUNCTION_LINE("We still have pad for deviceslot %d connected.", slotdata->deviceslot);
} }
} }
if(HID_DEBUG) { if (HID_DEBUG) {
DEBUG_FUNCTION_LINE("Device successfully detached"); DEBUG_FUNCTION_LINE("Device successfully detached");
} }
} }
@ -348,19 +348,18 @@ int32_t ControllerPatcherHID::AttachDetachCallback(HIDClient *p_client, HIDDevic
return HID_DEVICE_DETACH; return HID_DEVICE_DETACH;
} }
void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr) { void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user *usr) {
ControllerPatcherUtils::doSampling(usr->slotdata.deviceslot,usr->pad_slot,false); ControllerPatcherUtils::doSampling(usr->slotdata.deviceslot, usr->pad_slot, false);
//DEBUG_FUNCTION_LINE("my_read_cbInternal: %d %08X %d",bytes_transfered,usr->slotdata.hidmask,usr->slotdata.deviceslot); //DEBUG_FUNCTION_LINE("my_read_cbInternal: %d %08X %d",bytes_transfered,usr->slotdata.hidmask,usr->slotdata.deviceslot);
if(usr->slotdata.hidmask == gHID_LIST_GC) { if (usr->slotdata.hidmask == gHID_LIST_GC) {
HID_Data * data_ptr = NULL; HID_Data *data_ptr = NULL;
//Copy the data for all 4 pads //Copy the data for all 4 pads
for(int32_t i = 0; i<4; i++) { for (int32_t i = 0; i < 4; i++) {
data_ptr = &(gHID_Devices[gHID_SLOT_GC].pad_data[i]); data_ptr = &(gHID_Devices[gHID_SLOT_GC].pad_data[i]);
memcpy(&(data_ptr->data_union.controller.last_hid_data[0]),&(data_ptr->data_union.controller.cur_hid_data[0]),10); //save last data. memcpy(&(data_ptr->data_union.controller.last_hid_data[0]), &(data_ptr->data_union.controller.cur_hid_data[0]), 10); //save last data.
memcpy(&(data_ptr->data_union.controller.cur_hid_data[0]),&buf[(i*9)+1],9); //save new data. memcpy(&(data_ptr->data_union.controller.cur_hid_data[0]), &buf[(i * 9) + 1], 9); //save new data.
} }
/* /*
@ -369,13 +368,13 @@ void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf,
DEBUG_FUNCTION_LINE("GC2 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++; DEBUG_FUNCTION_LINE("GC2 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++;
DEBUG_FUNCTION_LINE("GC3 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++; DEBUG_FUNCTION_LINE("GC3 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X ", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);i++;
DEBUG_FUNCTION_LINE("GC4 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X \n", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);*/ DEBUG_FUNCTION_LINE("GC4 %08X: %02X %02X %02X %02X %02X %02X %02X %02X %02X \n", buf[i*9+0],buf[i*9+1],buf[i*9+2],buf[i*9+3],buf[i*9+4],buf[i*9+5],buf[i*9+6],buf[i*9+7],buf[i*9+8]);*/
HIDGCRumble(handle,usr); HIDGCRumble(handle, usr);
} else if(usr->slotdata.hidmask != 0) { } else if (usr->slotdata.hidmask != 0) {
//Depending on how the switch pro controller is connected, it has a different data format. At first we had the Bluetooth version, so we need to convert //Depending on how the switch pro controller is connected, it has a different data format. At first we had the Bluetooth version, so we need to convert
//the USB one into it now. (When it's connected via USB). The network client always sends the BT version, even if connected via USB to the PC. //the USB one into it now. (When it's connected via USB). The network client always sends the BT version, even if connected via USB to the PC.
if(usr->slotdata.hidmask == gHID_LIST_SWITCH_PRO && buf != NULL && bytes_transfered >= 0x20) { if (usr->slotdata.hidmask == gHID_LIST_SWITCH_PRO && buf != NULL && bytes_transfered >= 0x20) {
uint8_t buffer[0x13]; uint8_t buffer[0x13];
memcpy(buffer,buf+0x0D,0x013); memcpy(buffer, buf + 0x0D, 0x013);
/** /**
Thanks to ShinyQuagsire23 for the values (https://github.com/shinyquagsire23/HID-Joy-Con-Whispering) Thanks to ShinyQuagsire23 for the values (https://github.com/shinyquagsire23/HID-Joy-Con-Whispering)
@ -390,62 +389,62 @@ void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf,
buf[7] = 0x00; buf[7] = 0x00;
buf[8] = 0x1F; buf[8] = 0x1F;
//We want to get the next input! //We want to get the next input!
int32_t res = HIDWrite(handle, buf, 9, NULL,NULL); int32_t res = HIDWrite(handle, buf, 9, NULL, NULL);
if(res == 9) { //Check if it's the USB data format. if (res == 9) { //Check if it's the USB data format.
if(buffer[1] == 0) return; if (buffer[1] == 0) return;
//Converting the buttons //Converting the buttons
uint32_t buttons = (((uint32_t*)(buffer))[0]) & 0xFFFFFF00; uint32_t buttons = (((uint32_t *) (buffer))[0]) & 0xFFFFFF00;
uint32_t newButtons = 0; uint32_t newButtons = 0;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_A_VALUE) == HID_SWITCH_PRO_USB_BUTTON_A_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_A_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_A_VALUE) == HID_SWITCH_PRO_USB_BUTTON_A_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_A_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_B_VALUE) == HID_SWITCH_PRO_USB_BUTTON_B_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_B_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_B_VALUE) == HID_SWITCH_PRO_USB_BUTTON_B_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_B_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_X_VALUE) == HID_SWITCH_PRO_USB_BUTTON_X_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_X_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_X_VALUE) == HID_SWITCH_PRO_USB_BUTTON_X_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_X_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_Y_VALUE) == HID_SWITCH_PRO_USB_BUTTON_Y_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_Y_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_Y_VALUE) == HID_SWITCH_PRO_USB_BUTTON_Y_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_Y_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_PLUS_VALUE) == HID_SWITCH_PRO_USB_BUTTON_PLUS_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_PLUS_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_PLUS_VALUE) == HID_SWITCH_PRO_USB_BUTTON_PLUS_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_PLUS_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_MINUS_VALUE) == HID_SWITCH_PRO_USB_BUTTON_MINUS_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_MINUS_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_MINUS_VALUE) == HID_SWITCH_PRO_USB_BUTTON_MINUS_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_MINUS_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_HOME_VALUE) == HID_SWITCH_PRO_USB_BUTTON_HOME_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_HOME_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_HOME_VALUE) == HID_SWITCH_PRO_USB_BUTTON_HOME_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_HOME_VALUE;
//if((buttons & SWITCH_PRO_USB_BUTTON_SCREENSHOT) == HID_SWITCH_PRO_USB_BUTTON_SCREENSHOT) newButtons |= HID_SWITCH_PRO_BT_BUTTON_SCREENSHOT; //if((buttons & SWITCH_PRO_USB_BUTTON_SCREENSHOT) == HID_SWITCH_PRO_USB_BUTTON_SCREENSHOT) newButtons |= HID_SWITCH_PRO_BT_BUTTON_SCREENSHOT;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_R_VALUE) == HID_SWITCH_PRO_USB_BUTTON_R_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_R_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_R_VALUE) == HID_SWITCH_PRO_USB_BUTTON_R_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_R_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_ZR_VALUE) == HID_SWITCH_PRO_USB_BUTTON_ZR_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_ZR_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_ZR_VALUE) == HID_SWITCH_PRO_USB_BUTTON_ZR_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_ZR_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_STICK_R_VALUE) == HID_SWITCH_PRO_USB_BUTTON_STICK_R_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_STICK_R_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_STICK_R_VALUE) == HID_SWITCH_PRO_USB_BUTTON_STICK_R_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_STICK_R_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_L_VALUE) == HID_SWITCH_PRO_USB_BUTTON_L_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_L_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_L_VALUE) == HID_SWITCH_PRO_USB_BUTTON_L_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_L_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_ZL_VALUE) == HID_SWITCH_PRO_USB_BUTTON_ZL_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_ZL_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_ZL_VALUE) == HID_SWITCH_PRO_USB_BUTTON_ZL_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_ZL_VALUE;
if((buttons & HID_SWITCH_PRO_USB_BUTTON_STICK_L_VALUE) == HID_SWITCH_PRO_USB_BUTTON_STICK_L_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_STICK_L_VALUE; if ((buttons & HID_SWITCH_PRO_USB_BUTTON_STICK_L_VALUE) == HID_SWITCH_PRO_USB_BUTTON_STICK_L_VALUE) newButtons |= HID_SWITCH_PRO_BT_BUTTON_STICK_L_VALUE;
uint8_t dpad = buffer[2]; uint8_t dpad = buffer[2];
uint8_t dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE; uint8_t dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE;
//Converting the DPAD //Converting the DPAD
if(((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) && if (((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE)) { ((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE)) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NE_VALUE; dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NE_VALUE;
} else if(((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) && } else if (((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE)) { ((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE)) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_SE_VALUE; dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_SE_VALUE;
} else if(((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) && } else if (((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE)) { ((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE)) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_SW_VALUE; dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_SW_VALUE;
} else if(((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) && } else if (((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) &&
((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE)) { ((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE)) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NW_VALUE; dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_NW_VALUE;
} else if((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) { } else if ((dpad & HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) == HID_SWITCH_PRO_USB_BUTTON_UP_VALUE) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_N_VALUE; dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_N_VALUE;
} else if((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) { } else if ((dpad & HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_RIGHT_VALUE) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_E_VALUE; dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_E_VALUE;
} else if((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) { } else if ((dpad & HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) == HID_SWITCH_PRO_USB_BUTTON_DOWN_VALUE) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_S_VALUE; dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_S_VALUE;
} else if((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) { } else if ((dpad & HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) == HID_SWITCH_PRO_USB_BUTTON_LEFT_VALUE) {
dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_W_VALUE; dpadResult = HID_SWITCH_PRO_BT_BUTTON_DPAD_W_VALUE;
} }
//Converting the stick data //Converting the stick data
uint8_t LX = (uint8_t) ((uint16_t) ((buffer[0x04] << 8 &0xFF00) | (((uint16_t)buffer[0x03])&0xFF)) >> 0x04); uint8_t LX = (uint8_t) ((uint16_t) ((buffer[0x04] << 8 & 0xFF00) | (((uint16_t) buffer[0x03]) & 0xFF)) >> 0x04);
uint8_t LY = (uint8_t)((buffer[0x05] *-1)); uint8_t LY = (uint8_t) ((buffer[0x05] * -1));
uint8_t RX = (uint8_t) ((uint16_t) ((buffer[0x07] << 8 &0xFF00) | (((uint16_t)buffer[0x06])&0xFF)) >> 0x04); uint8_t RX = (uint8_t) ((uint16_t) ((buffer[0x07] << 8 & 0xFF00) | (((uint16_t) buffer[0x06]) & 0xFF)) >> 0x04);
uint8_t RY = (uint8_t)((buffer[0x08] *-1)); uint8_t RY = (uint8_t) ((buffer[0x08] * -1));
buf[0] = (newButtons >> 24) & 0xFF; buf[0] = (newButtons >> 24) & 0xFF;
buf[1] = (newButtons >> 16) & 0xFF; buf[1] = (newButtons >> 16) & 0xFF;
@ -457,33 +456,33 @@ void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf,
} }
} }
int32_t dsize = (HID_MAX_DATA_LENGTH_PER_PAD > bytes_transfered)? bytes_transfered : HID_MAX_DATA_LENGTH_PER_PAD; int32_t dsize = (HID_MAX_DATA_LENGTH_PER_PAD > bytes_transfered) ? bytes_transfered : HID_MAX_DATA_LENGTH_PER_PAD;
int32_t skip = 0; int32_t skip = 0;
//Input filter //Input filter
if( config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if (config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
if(buf[config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0]] != config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][1]) { if (buf[config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][0]] != config_controller[usr->slotdata.deviceslot][CONTRPS_INPUT_FILTER][1]) {
skip = 1; skip = 1;
} }
} }
if(!skip) { if (!skip) {
uint32_t slot = 0; uint32_t slot = 0;
if(usr->pad_slot < HID_MAX_PADS_COUNT) { if (usr->pad_slot < HID_MAX_PADS_COUNT) {
slot = usr->pad_slot; slot = usr->pad_slot;
} }
slot += ControllerPatcherUtils::getPadSlotInAdapter(usr->slotdata.deviceslot,buf); // If the controller has multiple slots, we need to use the right one. slot += ControllerPatcherUtils::getPadSlotInAdapter(usr->slotdata.deviceslot, buf); // If the controller has multiple slots, we need to use the right one.
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]); HID_Data *data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]);
memcpy(&(data_ptr->data_union.controller.last_hid_data[0]),&(data_ptr->data_union.controller.cur_hid_data[0]),dsize); // save the last data. memcpy(&(data_ptr->data_union.controller.last_hid_data[0]), &(data_ptr->data_union.controller.cur_hid_data[0]), dsize); // save the last data.
memcpy(&(data_ptr->data_union.controller.cur_hid_data[0]),&buf[0],dsize); // save the new data. memcpy(&(data_ptr->data_union.controller.cur_hid_data[0]), &buf[0], dsize); // save the new data.
DCFlushRange(&gHID_Devices[usr->slotdata.deviceslot].pad_data[slot],sizeof(HID_Data)); DCFlushRange(&gHID_Devices[usr->slotdata.deviceslot].pad_data[slot], sizeof(HID_Data));
data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]); data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[slot]);
HIDRumble(handle,usr,slot); HIDRumble(handle, usr, slot);
} }
} }
} }
@ -492,17 +491,17 @@ void ControllerPatcherHID::HIDReadCallback(uint32_t handle, unsigned char *buf,
* Other functions * Other functions
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(VPADStatus * buffer,std::vector<HID_Data *>& data) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(VPADStatus *buffer, std::vector<HID_Data *> &data) {
if(buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER; if (buffer == NULL) return CONTROLLER_PATCHER_ERROR_NULL_POINTER;
HID_Data * data_cur; HID_Data *data_cur;
int32_t buttons_hold; int32_t buttons_hold;
for(uint32_t i = 0; i<data.size(); i++) { for (uint32_t i = 0; i < data.size(); i++) {
data_cur = data[i]; data_cur = data[i];
if(data_cur->slotdata.hidmask & gHID_LIST_MOUSE) { //Reset the input when we have no new inputs if (data_cur->slotdata.hidmask & gHID_LIST_MOUSE) { //Reset the input when we have no new inputs
HID_Mouse_Data * mouse_data = &data_cur->data_union.mouse.cur_mouse_data; HID_Mouse_Data *mouse_data = &data_cur->data_union.mouse.cur_mouse_data;
if(mouse_data->valuedChanged == 1) { //Fix for the mouse cursor if (mouse_data->valuedChanged == 1) { //Fix for the mouse cursor
mouse_data->valuedChanged = 0; mouse_data->valuedChanged = 0;
} else { } else {
mouse_data->deltaX = 0; mouse_data->deltaX = 0;
@ -511,27 +510,27 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(V
} }
buttons_hold = 0; buttons_hold = 0;
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_A); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_A);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_B); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_B);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_X); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_X);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_Y); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_Y);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_LEFT); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_LEFT);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_RIGHT); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_RIGHT);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_DOWN); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_DOWN);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_UP); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_UP);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_MINUS); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_MINUS);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_L); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_L);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_R); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_R);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_PLUS); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_PLUS);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_ZL); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_ZL);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_ZR); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_ZR);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_HOME); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_HOME);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_STICK_L); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_STICK_L);
ControllerPatcherUtils::getButtonPressed(data_cur,&buttons_hold,VPAD_BUTTON_STICK_R); ControllerPatcherUtils::getButtonPressed(data_cur, &buttons_hold, VPAD_BUTTON_STICK_R);
uint32_t last_emulate_stick = (data_cur->last_buttons) & VPAD_MASK_EMULATED_STICKS; // We should only need the emulated stick data. uint32_t last_emulate_stick = (data_cur->last_buttons) & VPAD_MASK_EMULATED_STICKS; // We should only need the emulated stick data.
int32_t last_realbuttons = (data_cur->last_buttons) & VPAD_MASK_BUTTONS; int32_t last_realbuttons = (data_cur->last_buttons) & VPAD_MASK_BUTTONS;
@ -540,20 +539,20 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::setVPADControllerData(V
buffer->trigger |= (buttons_hold & (~last_realbuttons)); buffer->trigger |= (buttons_hold & (~last_realbuttons));
buffer->release |= (last_realbuttons & (~buttons_hold)); buffer->release |= (last_realbuttons & (~buttons_hold));
ControllerPatcherUtils::convertAnalogSticks(data_cur,buffer); ControllerPatcherUtils::convertAnalogSticks(data_cur, buffer);
ControllerPatcherUtils::setEmulatedSticks(buffer,&last_emulate_stick); ControllerPatcherUtils::setEmulatedSticks(buffer, &last_emulate_stick);
ControllerPatcherUtils::checkAndSetMouseMode(data_cur); ControllerPatcherUtils::checkAndSetMouseMode(data_cur);
ControllerPatcherUtils::setTouch(data_cur,buffer); ControllerPatcherUtils::setTouch(data_cur, buffer);
data_cur->last_buttons = buttons_hold & VPAD_MASK_BUTTONS; data_cur->last_buttons = buttons_hold & VPAD_MASK_BUTTONS;
data_cur->last_buttons |= last_emulate_stick; data_cur->last_buttons |= last_emulate_stick;
} }
// Caculates a valid stick position // Caculates a valid stick position
if(data.size() > 0) { if (data.size() > 0) {
ControllerPatcherUtils::normalizeStickValues(&buffer->leftStick); ControllerPatcherUtils::normalizeStickValues(&buffer->leftStick);
ControllerPatcherUtils::normalizeStickValues(&buffer->rightStick); ControllerPatcherUtils::normalizeStickValues(&buffer->rightStick);
} }
@ -565,17 +564,17 @@ std::vector<HID_Data *> ControllerPatcherHID::getHIDDataAll() {
uint32_t hid = gHIDCurrentDevice; uint32_t hid = gHIDCurrentDevice;
std::vector<HID_Data *> data_list; std::vector<HID_Data *> data_list;
for(int32_t i = 0; i < gHIDMaxDevices; i++) { for (int32_t i = 0; i < gHIDMaxDevices; i++) {
if((hid & (1 << i)) != 0) { if ((hid & (1 << i)) != 0) {
uint32_t cur_hidmask = config_controller_hidmask[i]; uint32_t cur_hidmask = config_controller_hidmask[i];
for(int32_t pad = 0; pad < HID_MAX_PADS_COUNT; pad++) { for (int32_t pad = 0; pad < HID_MAX_PADS_COUNT; pad++) {
int32_t res; int32_t res;
HID_Data * new_data = NULL; HID_Data *new_data = NULL;
if((res = ControllerPatcherHID::getHIDData(cur_hidmask,pad,&new_data)) < 0) { // Checks if the pad is invalid. if ((res = ControllerPatcherHID::getHIDData(cur_hidmask, pad, &new_data)) < 0) { // Checks if the pad is invalid.
//DEBUG_FUNCTION_LINE("error: Error getting the HID data from HID(%s) CHAN(). Error %d\n",StringTools::byte_to_binary(cur_hidmask),pad,res); //DEBUG_FUNCTION_LINE("error: Error getting the HID data from HID(%s) CHAN(). Error %d\n",StringTools::byte_to_binary(cur_hidmask),pad,res);
continue; continue;
} }
if(new_data != NULL) data_list.push_back(new_data); if (new_data != NULL) data_list.push_back(new_data);
} }
} }
} }
@ -585,26 +584,26 @@ std::vector<HID_Data *> ControllerPatcherHID::getHIDDataAll() {
/* /*
The slotdata in the HID_Data pointer is empty. We need to provide the hidmask via the parameter The slotdata in the HID_Data pointer is empty. We need to provide the hidmask via the parameter
*/ */
CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::getHIDData(uint32_t hidmask, int32_t pad, HID_Data ** data) { CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::getHIDData(uint32_t hidmask, int32_t pad, HID_Data **data) {
if(data == NULL) return CONTROLLER_PATCHER_ERROR_INVALID_BUFFER; if (data == NULL) return CONTROLLER_PATCHER_ERROR_INVALID_BUFFER;
if(!(hidmask & gHIDCurrentDevice)) return CONTROLLER_PATCHER_ERROR_HID_NOT_CONNECTED; if (!(hidmask & gHIDCurrentDevice)) return CONTROLLER_PATCHER_ERROR_HID_NOT_CONNECTED;
if(pad < 0 && pad > 3) return CONTROLLER_PATCHER_ERROR_INVALID_CHAN; if (pad < 0 && pad > 3) return CONTROLLER_PATCHER_ERROR_INVALID_CHAN;
int32_t device_slot = ControllerPatcherUtils::getDeviceSlot(hidmask); int32_t device_slot = ControllerPatcherUtils::getDeviceSlot(hidmask);
if(device_slot < 0) { if (device_slot < 0) {
return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND; return CONTROLLER_PATCHER_ERROR_DEVICE_SLOT_NOT_FOUND;
} }
int32_t real_pad = pad; int32_t real_pad = pad;
if((device_slot != gHID_SLOT_GC) && config_controller[device_slot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) { if ((device_slot != gHID_SLOT_GC) && config_controller[device_slot][CONTRPS_PAD_COUNT][0] != CONTROLLER_PATCHER_INVALIDVALUE) {
int32_t pad_count = config_controller[device_slot][CONTRPS_PAD_COUNT][1]; int32_t pad_count = config_controller[device_slot][CONTRPS_PAD_COUNT][1];
if(pad_count > HID_MAX_PADS_COUNT) pad_count = HID_MAX_PADS_COUNT; if (pad_count > HID_MAX_PADS_COUNT) pad_count = HID_MAX_PADS_COUNT;
pad = (pad/(pad_count))*pad_count; pad = (pad / (pad_count)) * pad_count;
} }
int32_t result = ControllerPatcherUtils::checkActivePad(hidmask,pad); int32_t result = ControllerPatcherUtils::checkActivePad(hidmask, pad);
if(result < 0) { //Not pad connected to adapter if (result < 0) { //Not pad connected to adapter
return CONTROLLER_PATCHER_ERROR_NO_PAD_CONNECTED; return CONTROLLER_PATCHER_ERROR_NO_PAD_CONNECTED;
} }
@ -614,40 +613,40 @@ CONTROLLER_PATCHER_RESULT_OR_ERROR ControllerPatcherHID::getHIDData(uint32_t hid
} }
void ControllerPatcherHID::HIDGCRumble(uint32_t handle,my_cb_user *usr) { void ControllerPatcherHID::HIDGCRumble(uint32_t handle, my_cb_user *usr) {
if(usr == NULL) return; if (usr == NULL) return;
if(!ControllerPatcher::isRumbleActivated()) return; if (!ControllerPatcher::isRumbleActivated()) return;
int32_t rumblechanged = 0; int32_t rumblechanged = 0;
for(int32_t i = 0; i<HID_GC_PAD_COUNT; i++) { for (int32_t i = 0; i < HID_GC_PAD_COUNT; i++) {
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[i]); HID_Data *data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[i]);
if(data_ptr->rumbleActive != usr->rumblestatus[i]) { if (data_ptr->rumbleActive != usr->rumblestatus[i]) {
rumblechanged = 1; rumblechanged = 1;
} }
usr->rumblestatus[i] = data_ptr->rumbleActive; usr->rumblestatus[i] = data_ptr->rumbleActive;
usr->buf[i+1] = usr->rumblestatus[i]; usr->buf[i + 1] = usr->rumblestatus[i];
} }
usr->forceRumbleInTicks[0]--; usr->forceRumbleInTicks[0]--;
if(rumblechanged || usr->forceRumbleInTicks[0] <= 0) { if (rumblechanged || usr->forceRumbleInTicks[0] <= 0) {
usr->buf[0] = 0x11; usr->buf[0] = 0x11;
HIDWrite(handle, usr->buf, 5, NULL, NULL); HIDWrite(handle, usr->buf, 5, NULL, NULL);
usr->forceRumbleInTicks[0] = 10; usr->forceRumbleInTicks[0] = 10;
} }
} }
void ControllerPatcherHID::HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pad) { void ControllerPatcherHID::HIDRumble(uint32_t handle, my_cb_user *usr, uint32_t pad) {
if(usr == NULL || pad > HID_MAX_PADS_COUNT) return; if (usr == NULL || pad > HID_MAX_PADS_COUNT) return;
if(!ControllerPatcher::isRumbleActivated()) return; if (!ControllerPatcher::isRumbleActivated()) return;
int32_t rumblechanged = 0; int32_t rumblechanged = 0;
HID_Data * data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[pad]); HID_Data *data_ptr = &(gHID_Devices[usr->slotdata.deviceslot].pad_data[pad]);
if(data_ptr->rumbleActive != usr->rumblestatus[pad]) { if (data_ptr->rumbleActive != usr->rumblestatus[pad]) {
usr->rumblestatus[pad] = data_ptr->rumbleActive; usr->rumblestatus[pad] = data_ptr->rumbleActive;
rumblechanged = 1; rumblechanged = 1;
} }
usr->forceRumbleInTicks[pad]--; usr->forceRumbleInTicks[pad]--;
if(rumblechanged || usr->forceRumbleInTicks[pad] <= 0) { if (rumblechanged || usr->forceRumbleInTicks[pad] <= 0) {
//DEBUG_FUNCTION_LINE("Rumble: %d %d",usr->rumblestatus[pad],usr->rumbleForce[pad]); //DEBUG_FUNCTION_LINE("Rumble: %d %d",usr->rumblestatus[pad],usr->rumbleForce[pad]);
//Seding to the network client! //Seding to the network client!
char bytes[6]; char bytes[6];
@ -660,14 +659,14 @@ void ControllerPatcherHID::HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pa
bytes[i++] = handle & 0xFF; bytes[i++] = handle & 0xFF;
bytes[i++] = usr->rumblestatus[pad]; bytes[i++] = usr->rumblestatus[pad];
UDPClient * instance = UDPClient::getInstance(); UDPClient *instance = UDPClient::getInstance();
if(instance != NULL) { if (instance != NULL) {
instance->sendData(bytes,6); instance->sendData(bytes, 6);
} }
if(usr->slotdata.hidmask == gHID_LIST_DS3) { if (usr->slotdata.hidmask == gHID_LIST_DS3) {
HIDDS3Rumble(handle,usr,usr->rumblestatus[pad]); HIDDS3Rumble(handle, usr, usr->rumblestatus[pad]);
} else { } else {
// Not implemented for other devices =( // Not implemented for other devices =(
} }
@ -676,19 +675,57 @@ void ControllerPatcherHID::HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pa
} }
static uint8_t ds3_rumble_Report[48] = { static uint8_t ds3_rumble_Report[48] = {
0x00, 0xFF, 0x00, 0xFF, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0xFF,
0xFF, 0x27, 0x10, 0x00, 0x32, 0x00,
0xFF, 0x27, 0x10, 0x00, 0x32, 0xFF,
0xFF, 0x27, 0x10, 0x00, 0x32, 0x00,
0xFF, 0x27, 0x10, 0x00, 0x32, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
0xFF,
0x27,
0x10,
0x00,
0x32,
0xFF,
0x27,
0x10,
0x00,
0x32,
0xFF,
0x27,
0x10,
0x00,
0x32,
0xFF,
0x27,
0x10,
0x00,
0x32,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
}; };
void ControllerPatcherHID::HIDDS3Rumble(uint32_t handle,my_cb_user *usr,int32_t rumble) { void ControllerPatcherHID::HIDDS3Rumble(uint32_t handle, my_cb_user *usr, int32_t rumble) {
memcpy(usr->buf, ds3_rumble_Report, 48); memcpy(usr->buf, ds3_rumble_Report, 48);
if (rumble) { if (rumble) {

19
source/patcher/ControllerPatcherHID.hpp
View File

@ -37,30 +37,31 @@
#define VPAD_MASK_BUTTONS ~VPAD_MASK_EMULATED_STICKS #define VPAD_MASK_BUTTONS ~VPAD_MASK_EMULATED_STICKS
#define SWAP16(x) ((x>>8) | ((x&0xFF)<<8)) #define SWAP16(x) ((x >> 8) | ((x & 0xFF) << 8))
#define SWAP8(x) ((x>>4) | ((x&0xF)<<4)) #define SWAP8(x) ((x >> 4) | ((x & 0xF) << 4))
class ControllerPatcherHID { class ControllerPatcherHID {
friend class ControllerPatcher; friend class ControllerPatcher;
friend class ControllerPatcherUtils; friend class ControllerPatcherUtils;
public: public:
static int32_t externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach); static int32_t externAttachDetachCallback(HIDDevice *p_device, HIDAttachEvent attach);
static void externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr); static void externHIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user *usr);
private: private:
static CONTROLLER_PATCHER_RESULT_OR_ERROR setVPADControllerData(VPADStatus * buffer,std::vector<HID_Data *>& data); static CONTROLLER_PATCHER_RESULT_OR_ERROR setVPADControllerData(VPADStatus *buffer, std::vector<HID_Data *> &data);
static std::vector<HID_Data *> getHIDDataAll(); static std::vector<HID_Data *> getHIDDataAll();
static CONTROLLER_PATCHER_RESULT_OR_ERROR getHIDData(uint32_t hidmask, int32_t pad, HID_Data ** data); static CONTROLLER_PATCHER_RESULT_OR_ERROR getHIDData(uint32_t hidmask, int32_t pad, HID_Data **data);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Rumble * Rumble
*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/ *---------------------------------------------------------------------------------------------------------------------------------------------------------------------------*/
static void HIDRumble(uint32_t handle,my_cb_user *usr,uint32_t pad); static void HIDRumble(uint32_t handle, my_cb_user *usr, uint32_t pad);
static void HIDGCRumble(uint32_t handle,my_cb_user *usr); static void HIDGCRumble(uint32_t handle, my_cb_user *usr);
static void HIDDS3Rumble(uint32_t handle,my_cb_user *usr,int32_t rumble); static void HIDDS3Rumble(uint32_t handle, my_cb_user *usr, int32_t rumble);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* HID Callbacks * HID Callbacks
@ -71,7 +72,7 @@ private:
static void myHIDReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user); static void myHIDReadCallback(uint32_t handle, int32_t error, unsigned char *buf, uint32_t bytes_transfered, void *p_user);
static int32_t AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach); static int32_t AttachDetachCallback(HIDClient *p_client, HIDDevice *p_device, HIDAttachEvent attach);
static void HIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user * usr); static void HIDReadCallback(uint32_t handle, unsigned char *buf, uint32_t bytes_transfered, my_cb_user *usr);
}; };
#endif /* _CONTROLLER_PATCHER_HID_H_ */ #endif /* _CONTROLLER_PATCHER_HID_H_ */

657
source/patcher/ControllerPatcherUtils.cpp
View File

File diff suppressed because it is too large Load Diff

49
source/patcher/ControllerPatcherUtils.hpp
View File

@ -56,7 +56,7 @@ public:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The actual result will be store in the given my_cb_user **. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The actual result will be store in the given my_cb_user **.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getDataByHandle(int32_t handle, my_cb_user ** data); static CONTROLLER_PATCHER_RESULT_OR_ERROR getDataByHandle(int32_t handle, my_cb_user **data);
/** /**
\brief Returns the VID/PID for the given device slot. \brief Returns the VID/PID for the given device slot.
@ -66,7 +66,7 @@ public:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The actual result will be store in the given DeviceVIDPIDInfo *. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. The actual result will be store in the given DeviceVIDPIDInfo *.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getVIDPIDbyDeviceSlot(int32_t deviceslot, DeviceVIDPIDInfo * vidpid); static CONTROLLER_PATCHER_RESULT_OR_ERROR getVIDPIDbyDeviceSlot(int32_t deviceslot, DeviceVIDPIDInfo *vidpid);
/** \brief Set the VPAD data for a given KPAD data. /** \brief Set the VPAD data for a given KPAD data.
* *
@ -76,7 +76,8 @@ public:
* \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. * \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToVPAD(VPADStatus * vpad_buffer,KPADStatus * pro_buffer,uint32_t * lastButtonsPressesVPAD); static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToVPAD(VPADStatus *vpad_buffer, KPADStatus *pro_buffer, uint32_t *lastButtonsPressesVPAD);
private: private:
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Analyse inputs * Analyse inputs
@ -90,7 +91,7 @@ private:
* \return When the functions failed result < 0 is returned.If the result is >= 0 the function was successful. * \return When the functions failed result < 0 is returned.If the result is >= 0 the function was successful.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR getButtonPressed(HID_Data * data, int32_t * buttons_hold, int32_t VPADButton); static CONTROLLER_PATCHER_RESULT_OR_ERROR getButtonPressed(HID_Data *data, int32_t *buttons_hold, int32_t VPADButton);
/** \brief Checks if a given value is set in the HID_DATA given the data in the slot number provided by cur_config. /** \brief Checks if a given value is set in the HID_DATA given the data in the slot number provided by cur_config.
@ -100,7 +101,7 @@ private:
* \return When the functions failed result < 0 is returned. If the value is set, 1 will be returned. Otherwise 0. * \return When the functions failed result < 0 is returned. If the value is set, 1 will be returned. Otherwise 0.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR isValueSet(HID_Data * data,int32_t cur_config); static CONTROLLER_PATCHER_RESULT_OR_ERROR isValueSet(HID_Data *data, int32_t cur_config);
/** \brief Checks if a given key in the keyboard data is pressed. /** \brief Checks if a given key in the keyboard data is pressed.
@ -110,7 +111,7 @@ private:
* \return When the functions failed result < 0 is returned. If the key is active pressed, 1 is returned. * \return When the functions failed result < 0 is returned. If the key is active pressed, 1 is returned.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR isInKeyboardData(unsigned char * keyboardData,int32_t key); static CONTROLLER_PATCHER_RESULT_OR_ERROR isInKeyboardData(unsigned char *keyboardData, int32_t key);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Utils for setting the Button data * Utils for setting the Button data
@ -126,7 +127,7 @@ private:
* \return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned. * \return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonRemappingData(VPADStatus * old_buffer, VPADStatus * new_buffer,uint32_t VPADButton, int32_t CONTRPS_SLOT); static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonRemappingData(VPADStatus *old_buffer, VPADStatus *new_buffer, uint32_t VPADButton, int32_t CONTRPS_SLOT);
/** /**
\brief Checks if a given button (oldVPADButton) is set in a given VPADStatus struct (old_buffer). If its set, it will set an other \brief Checks if a given button (oldVPADButton) is set in a given VPADStatus struct (old_buffer). If its set, it will set an other
@ -139,7 +140,7 @@ private:
\return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned. \return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonData(VPADStatus * old_buffer, VPADStatus * new_buffer,uint32_t oldVPADButton,uint32_t newVPADButton); static CONTROLLER_PATCHER_RESULT_OR_ERROR setButtonData(VPADStatus *old_buffer, VPADStatus *new_buffer, uint32_t oldVPADButton, uint32_t newVPADButton);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Pad Status functions * Pad Status functions
@ -152,7 +153,7 @@ private:
\return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned. \return When the functions failed result < 0 is returned. If the pad is active/connected, 1 is returned.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR checkActivePad(uint32_t hidmask,int32_t pad); static CONTROLLER_PATCHER_RESULT_OR_ERROR checkActivePad(uint32_t hidmask, int32_t pad);
/** /**
\brief Returns the first active pad of devices with the given HID-Mask. Currently only implemented for the GC-Adapter. Every other pad will always return 0. \brief Returns the first active pad of devices with the given HID-Mask. Currently only implemented for the GC-Adapter. Every other pad will always return 0.
@ -173,7 +174,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR normalizeStickValues(VPADVec2D * stick); static CONTROLLER_PATCHER_RESULT_OR_ERROR normalizeStickValues(VPADVec2D *stick);
/** /**
\brief Converts the digital absolute stick data into a float value. It also applies the deadzones, and can invert the result. \brief Converts the digital absolute stick data into a float value. It also applies the deadzones, and can invert the result.
@ -187,7 +188,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static float convertAnalogValue(uint8_t value, uint8_t default_val, uint8_t min, uint8_t max, uint8_t invert,uint8_t deadzone); static float convertAnalogValue(uint8_t value, uint8_t default_val, uint8_t min, uint8_t max, uint8_t invert, uint8_t deadzone);
/** /**
\brief Calculates a the stick data (VPADVec2D) from given digital direction. \brief Calculates a the stick data (VPADVec2D) from given digital direction.
@ -206,7 +207,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR convertAnalogSticks(HID_Data * data,VPADStatus * buffer); static CONTROLLER_PATCHER_RESULT_OR_ERROR convertAnalogSticks(HID_Data *data, VPADStatus *buffer);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Mouse functions * Mouse functions
@ -220,7 +221,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setTouch(HID_Data * data,VPADStatus * buffer); static CONTROLLER_PATCHER_RESULT_OR_ERROR setTouch(HID_Data *data, VPADStatus *buffer);
/** \brief Checks if the mouse mode needs to be changed. Sets it to the new mode if necessary. /** \brief Checks if the mouse mode needs to be changed. Sets it to the new mode if necessary.
* Currently the incoming data needs to be from a keyboard. * Currently the incoming data needs to be from a keyboard.
@ -229,7 +230,7 @@ private:
* \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. * \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR checkAndSetMouseMode(HID_Data * data); static CONTROLLER_PATCHER_RESULT_OR_ERROR checkAndSetMouseMode(HID_Data *data);
/** /**
\brief Set the emulated sticks for a given VPAD data. \brief Set the emulated sticks for a given VPAD data.
@ -239,7 +240,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR setEmulatedSticks(VPADStatus * buffer, uint32_t * last_emulatedSticks); static CONTROLLER_PATCHER_RESULT_OR_ERROR setEmulatedSticks(VPADStatus *buffer, uint32_t *last_emulatedSticks);
/*---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- /*----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
* Other functions * Other functions
@ -252,8 +253,8 @@ private:
* \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. * \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
* *
*/ */
static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToPro(VPADStatus * vpad_buffer, KPADStatus * pro_buffer, uint32_t * lastButtonsPressesPRO); static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToPro(VPADStatus *vpad_buffer, KPADStatus *pro_buffer, uint32_t *lastButtonsPressesPRO);
static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToProWPADRead(VPADStatus * vpad_buffer,WPADStatusProController * pro_buffer); static CONTROLLER_PATCHER_RESULT_OR_ERROR translateToProWPADRead(VPADStatus *vpad_buffer, WPADStatusProController *pro_buffer);
/** /**
\brief Checks if the value at the given device + CONTRPS slot equals the expected value. \brief Checks if the value at the given device + CONTRPS slot equals the expected value.
@ -264,7 +265,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR checkValueinConfigController(int32_t device_slot,int32_t CONTRPS_slot,int32_t expectedValue); static CONTROLLER_PATCHER_RESULT_OR_ERROR checkValueinConfigController(int32_t device_slot, int32_t CONTRPS_slot, int32_t expectedValue);
/** /**
\brief Sets two uint8_t values to the given pointer. \brief Sets two uint8_t values to the given pointer.
@ -273,7 +274,7 @@ private:
\param first: Value that will be written in @p dest[0] \param first: Value that will be written in @p dest[0]
\param second: Value that will be written in @p dest[1] \param second: Value that will be written in @p dest[1]
**/ **/
static void setConfigValue(uint8_t * dest , uint8_t first, uint8_t second); static void setConfigValue(uint8_t *dest, uint8_t first, uint8_t second);
/** /**
\brief Saves a new free device slot and the corresponding HID-Mask in the given @p HIDSlotData pointer \brief Saves a new free device slot and the corresponding HID-Mask in the given @p HIDSlotData pointer
@ -282,7 +283,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getNextSlotData(HIDSlotData * slotdata); static CONTROLLER_PATCHER_RESULT_OR_ERROR getNextSlotData(HIDSlotData *slotdata);
/** /**
\brief Fills up a given DeviceInfo, which provides a valid VID/PID, with HIDSlotData. \brief Fills up a given DeviceInfo, which provides a valid VID/PID, with HIDSlotData.
@ -291,7 +292,7 @@ private:
\return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful. \return When the functions failed result < 0 is returned. If the result is >= 0 the function was successful.
**/ **/
static CONTROLLER_PATCHER_RESULT_OR_ERROR getDeviceInfoFromVidPid(DeviceInfo * info); static CONTROLLER_PATCHER_RESULT_OR_ERROR getDeviceInfoFromVidPid(DeviceInfo *info);
/** /**
\brief returns the internal slot number of the device. Some adapters have multiple slot and send the data for each one \brief returns the internal slot number of the device. Some adapters have multiple slot and send the data for each one
@ -302,7 +303,7 @@ private:
\param current input data \param current input data
\return The relative slot in the device \return The relative slot in the device
**/ **/
static int32_t getPadSlotInAdapter(int32_t deviceslot, uint8_t * input_data); static int32_t getPadSlotInAdapter(int32_t deviceslot, uint8_t *input_data);
/** /**
\brief returns a pointer to the ControllerMapping to the given controller type \brief returns a pointer to the ControllerMapping to the given controller type
@ -311,9 +312,9 @@ private:
\return pointer to ControllerMapping data, null is type was invalid \return pointer to ControllerMapping data, null is type was invalid
**/ **/
static ControllerMappingPAD * getControllerMappingByType(UController_Type type); static ControllerMappingPAD *getControllerMappingByType(UController_Type type);
static CONTROLLER_PATCHER_RESULT_OR_ERROR doSampling(uint16_t deviceslot,uint8_t padslot,BOOL ignorePadSlot); static CONTROLLER_PATCHER_RESULT_OR_ERROR doSampling(uint16_t deviceslot, uint8_t padslot, BOOL ignorePadSlot);
static CONTROLLER_PATCHER_RESULT_OR_ERROR doSamplingSingle(WPADChan chan, uint16_t deviceslot, uint8_t padslot, BOOL ignorePadSlot); static CONTROLLER_PATCHER_RESULT_OR_ERROR doSamplingSingle(WPADChan chan, uint16_t deviceslot, uint8_t padslot, BOOL ignorePadSlot);
}; };

46
source/system/CThread.h
View File

@ -18,30 +18,27 @@
#define CTHREAD_H_ #define CTHREAD_H_
#include <malloc.h>
#include <unistd.h>
#include <coreinit/systeminfo.h> #include <coreinit/systeminfo.h>
#include <coreinit/thread.h> #include <coreinit/thread.h>
#include <malloc.h>
#include <unistd.h>
class CThread { class CThread {
public: public:
typedef void (* Callback)(CThread *thread, void *arg); typedef void (*Callback)(CThread *thread, void *arg);
//! constructor //! constructor
CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL) CThread(int32_t iAttr, int32_t iPriority = 16, int32_t iStackSize = 0x8000, CThread::Callback callback = NULL, void *callbackArg = NULL)
: pThread(NULL) : pThread(NULL), pThreadStack(NULL), pCallback(callback), pCallbackArg(callbackArg) {
, pThreadStack(NULL)
, pCallback(callback)
, pCallbackArg(callbackArg) {
//! save attribute assignment //! save attribute assignment
iAttributes = iAttr; iAttributes = iAttr;
//! allocate the thread //! allocate the thread
pThread = (OSThread*)memalign(8, sizeof(OSThread)); pThread = (OSThread *) memalign(8, sizeof(OSThread));
//! allocate the stack //! allocate the stack
pThreadStack = (uint8_t *) memalign(0x20, iStackSize); pThreadStack = (uint8_t *) memalign(0x20, iStackSize);
//! create the thread //! create the thread
if(pThread && pThreadStack) if (pThread && pThreadStack)
OSCreateThread(pThread, &CThread::threadCallback, 1, (char*)this, pThreadStack+iStackSize, iStackSize, iPriority, iAttributes); OSCreateThread(pThread, &CThread::threadCallback, 1, (char *) this, pThreadStack + iStackSize, iStackSize, iPriority, iAttributes);
} }
//! destructor //! destructor
@ -50,40 +47,40 @@ public:
} }
static CThread *create(CThread::Callback callback, void *callbackArg, int32_t iAttr = eAttributeNone, int32_t iPriority = 16, int32_t iStackSize = 0x8000) { static CThread *create(CThread::Callback callback, void *callbackArg, int32_t iAttr = eAttributeNone, int32_t iPriority = 16, int32_t iStackSize = 0x8000) {
return ( new CThread(iAttr, iPriority, iStackSize, callback, callbackArg) ); return (new CThread(iAttr, iPriority, iStackSize, callback, callbackArg));
} }
//! Get thread ID //! Get thread ID
virtual void* getThread() const { virtual void *getThread() const {
return pThread; return pThread;
} }
//! Thread entry function //! Thread entry function
virtual void executeThread(void) { virtual void executeThread(void) {
if(pCallback) if (pCallback)
pCallback(this, pCallbackArg); pCallback(this, pCallbackArg);
} }
//! Suspend thread //! Suspend thread
virtual void suspendThread(void) { virtual void suspendThread(void) {
if(isThreadSuspended()) return; if (isThreadSuspended()) return;
if(pThread) OSSuspendThread(pThread); if (pThread) OSSuspendThread(pThread);
} }
//! Resume thread //! Resume thread
virtual void resumeThread(void) { virtual void resumeThread(void) {
if(!isThreadSuspended()) return; if (!isThreadSuspended()) return;
if(pThread) OSResumeThread(pThread); if (pThread) OSResumeThread(pThread);
} }
//! Set thread priority //! Set thread priority
virtual void setThreadPriority(int prio) { virtual void setThreadPriority(int prio) {
if(pThread) OSSetThreadPriority(pThread, prio); if (pThread) OSSetThreadPriority(pThread, prio);
} }
//! Check if thread is suspended //! Check if thread is suspended
virtual BOOL isThreadSuspended(void) const { virtual BOOL isThreadSuspended(void) const {
if(pThread) return OSIsThreadSuspended(pThread); if (pThread) return OSIsThreadSuspended(pThread);
return false; return false;
} }
//! Check if thread is terminated //! Check if thread is terminated
virtual BOOL isThreadTerminated(void) const { virtual BOOL isThreadTerminated(void) const {
if(pThread) return OSIsThreadTerminated(pThread); if (pThread) return OSIsThreadTerminated(pThread);
return false; return false;
} }
//! Check if thread is running //! Check if thread is running
@ -93,16 +90,16 @@ public:
//! Shutdown thread //! Shutdown thread
virtual void shutdownThread(void) { virtual void shutdownThread(void) {
//! wait for thread to finish //! wait for thread to finish
if(pThread && !(iAttributes & eAttributeDetach)) { if (pThread && !(iAttributes & eAttributeDetach)) {
if(isThreadSuspended()) if (isThreadSuspended())
resumeThread(); resumeThread();
OSJoinThread(pThread, NULL); OSJoinThread(pThread, NULL);
} }
//! free the thread stack buffer //! free the thread stack buffer
if(pThreadStack) if (pThreadStack)
free(pThreadStack); free(pThreadStack);
if(pThread) if (pThread)
free(pThread); free(pThread);
pThread = NULL; pThread = NULL;
@ -117,6 +114,7 @@ public:
eAttributeDetach = 0x08, eAttributeDetach = 0x08,
eAttributePinnedAff = 0x10 eAttributePinnedAff = 0x10
}; };
private: private:
static int threadCallback(int argc, const char **argv) { static int threadCallback(int argc, const char **argv) {
//! After call to start() continue with the internal function //! After call to start() continue with the internal function

5
source/utils/CPRetainVars.cpp
View File

@ -69,8 +69,7 @@ uint8_t gNetworkControllerActivated __attribute__((section(".data"))) = 1;
uint8_t gGlobalRumbleActivated __attribute__((section(".data"))) = 0; uint8_t gGlobalRumbleActivated __attribute__((section(".data"))) = 0;
uint32_t gUDPClientip __attribute__((section(".data"))) = 0; uint32_t gUDPClientip __attribute__((section(".data"))) = 0;
ControllerMappingPADInfo* gProPadInfo[4] __attribute__((section(".data"))) = {&gControllerMapping.proController[0].pad_infos[0], ControllerMappingPADInfo *gProPadInfo[4] __attribute__((section(".data"))) = {&gControllerMapping.proController[0].pad_infos[0],
&gControllerMapping.proController[1].pad_infos[0], &gControllerMapping.proController[1].pad_infos[0],
&gControllerMapping.proController[2].pad_infos[0], &gControllerMapping.proController[2].pad_infos[0],
&gControllerMapping.proController[3].pad_infos[0] &gControllerMapping.proController[3].pad_infos[0]};
} ;

2
source/utils/CPRetainVars.hpp
View File

@ -71,6 +71,6 @@ extern uint8_t gGlobalRumbleActivated;
extern uint8_t gNetworkControllerActivated; extern uint8_t gNetworkControllerActivated;
extern uint32_t gUDPClientip; extern uint32_t gUDPClientip;
extern ControllerMappingPADInfo* gProPadInfo[4]; extern ControllerMappingPADInfo *gProPadInfo[4];
#endif // CP_RETAINS_VARS_H_ #endif // CP_RETAINS_VARS_H_

293
source/utils/PadConst.cpp
View File

@ -40,323 +40,302 @@ const char *HID_SWITCH_PRO_STRING = "Switch\nPro Controller";
//! GC-Adapter //! GC-Adapter
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_GC_BUTTON_A[] = { 0x01,HID_GC_BUTTON_A_VALUE}; const uint8_t HID_GC_BUTTON_A[] = {0x01, HID_GC_BUTTON_A_VALUE};
const uint8_t HID_GC_BUTTON_B[] = { 0x01,HID_GC_BUTTON_B_VALUE}; const uint8_t HID_GC_BUTTON_B[] = {0x01, HID_GC_BUTTON_B_VALUE};
const uint8_t HID_GC_BUTTON_X[] = { 0x01,HID_GC_BUTTON_X_VALUE}; const uint8_t HID_GC_BUTTON_X[] = {0x01, HID_GC_BUTTON_X_VALUE};
const uint8_t HID_GC_BUTTON_Y[] = { 0x01,HID_GC_BUTTON_Y_VALUE}; const uint8_t HID_GC_BUTTON_Y[] = {0x01, HID_GC_BUTTON_Y_VALUE};
const uint8_t HID_GC_BUTTON_LEFT[] = { 0x01,HID_GC_BUTTON_LEFT_VALUE}; const uint8_t HID_GC_BUTTON_LEFT[] = {0x01, HID_GC_BUTTON_LEFT_VALUE};
const uint8_t HID_GC_BUTTON_RIGHT[] = { 0x01,HID_GC_BUTTON_RIGHT_VALUE}; const uint8_t HID_GC_BUTTON_RIGHT[] = {0x01, HID_GC_BUTTON_RIGHT_VALUE};
const uint8_t HID_GC_BUTTON_DOWN[] = { 0x01,HID_GC_BUTTON_DOWN_VALUE}; const uint8_t HID_GC_BUTTON_DOWN[] = {0x01, HID_GC_BUTTON_DOWN_VALUE};
const uint8_t HID_GC_BUTTON_UP[] = { 0x01,HID_GC_BUTTON_UP_VALUE}; const uint8_t HID_GC_BUTTON_UP[] = {0x01, HID_GC_BUTTON_UP_VALUE};
const uint8_t HID_GC_BUTTON_START[] = { 0x02,HID_GC_BUTTON_START_VALUE}; const uint8_t HID_GC_BUTTON_START[] = {0x02, HID_GC_BUTTON_START_VALUE};
const uint8_t HID_GC_BUTTON_Z[] = { 0x02,HID_GC_BUTTON_Z_VALUE}; const uint8_t HID_GC_BUTTON_Z[] = {0x02, HID_GC_BUTTON_Z_VALUE};
const uint8_t HID_GC_BUTTON_L[] = { 0x07,HID_GC_BUTTON_L_VALUE}; const uint8_t HID_GC_BUTTON_L[] = {0x07, HID_GC_BUTTON_L_VALUE};
const uint8_t HID_GC_BUTTON_R[] = { 0x08,HID_GC_BUTTON_R_VALUE}; const uint8_t HID_GC_BUTTON_R[] = {0x08, HID_GC_BUTTON_R_VALUE};
const uint8_t HID_GC_BUTTON_DPAD_TYPE[] = { CONTRPDM_Normal,0x00}; const uint8_t HID_GC_BUTTON_DPAD_TYPE[] = {CONTRPDM_Normal, 0x00};
const uint8_t HID_GC_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_GC_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE, 0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE, 0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x1A, //STICK_CONF_MIN, 0x1A, //STICK_CONF_MIN,
0xE4 0xE4}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_GC_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_GC_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE, 0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE, 0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x11, //STICK_CONF_MIN, 0x11, //STICK_CONF_MIN,
0xE1 0xE1}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_GC_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_GC_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x05, //STICK_CONF_BYTE, 0x05, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE, 0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x2B, //STICK_CONF_MIN, 0x2B, //STICK_CONF_MIN,
0xE2 0xE2}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_GC_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_GC_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE, 0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE, 0x09, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x1D, //STICK_CONF_MIN, 0x1D, //STICK_CONF_MIN,
0xDB 0xDB}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! DS3 //! DS3
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_DS3_BUTTON_CROSS[] = { 0x03,HID_DS3_BUTTON_CROSS_VALUE}; const uint8_t HID_DS3_BUTTON_CROSS[] = {0x03, HID_DS3_BUTTON_CROSS_VALUE};
const uint8_t HID_DS3_BUTTON_CIRCLE[] = { 0x03,HID_DS3_BUTTON_CIRCLE_VALUE}; const uint8_t HID_DS3_BUTTON_CIRCLE[] = {0x03, HID_DS3_BUTTON_CIRCLE_VALUE};
const uint8_t HID_DS3_BUTTON_SQUARE [] = { 0x03,HID_DS3_BUTTON_SQUARE_VALUE}; const uint8_t HID_DS3_BUTTON_SQUARE[] = {0x03, HID_DS3_BUTTON_SQUARE_VALUE};
const uint8_t HID_DS3_BUTTON_TRIANGLE[] = { 0x03,HID_DS3_BUTTON_TRIANGLE_VALUE}; const uint8_t HID_DS3_BUTTON_TRIANGLE[] = {0x03, HID_DS3_BUTTON_TRIANGLE_VALUE};
const uint8_t HID_DS3_BUTTON_L1[] = { 0x03,HID_DS3_BUTTON_L1_VALUE}; const uint8_t HID_DS3_BUTTON_L1[] = {0x03, HID_DS3_BUTTON_L1_VALUE};
const uint8_t HID_DS3_BUTTON_L2[] = { 0x03,HID_DS3_BUTTON_L2_VALUE}; const uint8_t HID_DS3_BUTTON_L2[] = {0x03, HID_DS3_BUTTON_L2_VALUE};
const uint8_t HID_DS3_BUTTON_R1[] = { 0x03,HID_DS3_BUTTON_R1_VALUE}; const uint8_t HID_DS3_BUTTON_R1[] = {0x03, HID_DS3_BUTTON_R1_VALUE};
const uint8_t HID_DS3_BUTTON_R2[] = { 0x03,HID_DS3_BUTTON_R2_VALUE}; const uint8_t HID_DS3_BUTTON_R2[] = {0x03, HID_DS3_BUTTON_R2_VALUE};
const uint8_t HID_DS3_BUTTON_L3[] = { 0x02,HID_DS3_BUTTON_L3_VALUE}; const uint8_t HID_DS3_BUTTON_L3[] = {0x02, HID_DS3_BUTTON_L3_VALUE};
const uint8_t HID_DS3_BUTTON_R3[] = { 0x02,HID_DS3_BUTTON_R3_VALUE}; const uint8_t HID_DS3_BUTTON_R3[] = {0x02, HID_DS3_BUTTON_R3_VALUE};
const uint8_t HID_DS3_BUTTON_SELECT[] = { 0x02,HID_DS3_BUTTON_SELECT_VALUE}; const uint8_t HID_DS3_BUTTON_SELECT[] = {0x02, HID_DS3_BUTTON_SELECT_VALUE};
const uint8_t HID_DS3_BUTTON_START[] = { 0x02,HID_DS3_BUTTON_START_VALUE}; const uint8_t HID_DS3_BUTTON_START[] = {0x02, HID_DS3_BUTTON_START_VALUE};
const uint8_t HID_DS3_BUTTON_LEFT[] = { 0x02,HID_DS3_BUTTON_LEFT_VALUE}; const uint8_t HID_DS3_BUTTON_LEFT[] = {0x02, HID_DS3_BUTTON_LEFT_VALUE};
const uint8_t HID_DS3_BUTTON_RIGHT[] = { 0x02,HID_DS3_BUTTON_RIGHT_VALUE}; const uint8_t HID_DS3_BUTTON_RIGHT[] = {0x02, HID_DS3_BUTTON_RIGHT_VALUE};
const uint8_t HID_DS3_BUTTON_UP[] = { 0x02,HID_DS3_BUTTON_UP_VALUE}; const uint8_t HID_DS3_BUTTON_UP[] = {0x02, HID_DS3_BUTTON_UP_VALUE};
const uint8_t HID_DS3_BUTTON_DOWN[] = { 0x02,HID_DS3_BUTTON_DOWN_VALUE}; const uint8_t HID_DS3_BUTTON_DOWN[] = {0x02, HID_DS3_BUTTON_DOWN_VALUE};
const uint8_t HID_DS3_BUTTON_GUIDE[] = { 0x04,HID_DS3_BUTTON_GUIDE_VALUE}; const uint8_t HID_DS3_BUTTON_GUIDE[] = {0x04, HID_DS3_BUTTON_GUIDE_VALUE};
const uint8_t HID_DS3_BUTTON_DPAD_TYPE[] = { CONTRPDM_Normal,0x00}; const uint8_t HID_DS3_BUTTON_DPAD_TYPE[] = {CONTRPDM_Normal, 0x00};
const uint8_t HID_DS3_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_DS3_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE, 0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE, 0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_DS3_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x07, //STICK_CONF_BYTE, 0x07, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE, 0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT, 0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_DS3_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x08, //STICK_CONF_BYTE, 0x08, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE, 0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_DS3_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_DS3_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x09, //STICK_CONF_BYTE, 0x09, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE, 0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT, 0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! DS4 //! DS4
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_DS4_BUTTON_CROSS[] = { 0x05,HID_DS4_BUTTON_CROSS_VALUE}; const uint8_t HID_DS4_BUTTON_CROSS[] = {0x05, HID_DS4_BUTTON_CROSS_VALUE};
const uint8_t HID_DS4_BUTTON_CIRCLE[] = { 0x05,HID_DS4_BUTTON_CIRCLE_VALUE}; const uint8_t HID_DS4_BUTTON_CIRCLE[] = {0x05, HID_DS4_BUTTON_CIRCLE_VALUE};
const uint8_t HID_DS4_BUTTON_SQUARE [] = { 0x05,HID_DS4_BUTTON_SQUARE_VALUE}; const uint8_t HID_DS4_BUTTON_SQUARE[] = {0x05, HID_DS4_BUTTON_SQUARE_VALUE};
const uint8_t HID_DS4_BUTTON_TRIANGLE[] = { 0x05,HID_DS4_BUTTON_TRIANGLE_VALUE}; const uint8_t HID_DS4_BUTTON_TRIANGLE[] = {0x05, HID_DS4_BUTTON_TRIANGLE_VALUE};
const uint8_t HID_DS4_BUTTON_L1[] = { 0x06,HID_DS4_BUTTON_L1_VALUE}; const uint8_t HID_DS4_BUTTON_L1[] = {0x06, HID_DS4_BUTTON_L1_VALUE};
const uint8_t HID_DS4_BUTTON_L2[] = { 0x06,HID_DS4_BUTTON_L2_VALUE}; const uint8_t HID_DS4_BUTTON_L2[] = {0x06, HID_DS4_BUTTON_L2_VALUE};
const uint8_t HID_DS4_BUTTON_L3[] = { 0x06,HID_DS4_BUTTON_L3_VALUE}; const uint8_t HID_DS4_BUTTON_L3[] = {0x06, HID_DS4_BUTTON_L3_VALUE};
const uint8_t HID_DS4_BUTTON_R1[] = { 0x06,HID_DS4_BUTTON_R1_VALUE}; const uint8_t HID_DS4_BUTTON_R1[] = {0x06, HID_DS4_BUTTON_R1_VALUE};
const uint8_t HID_DS4_BUTTON_R2[] = { 0x06,HID_DS4_BUTTON_R2_VALUE}; const uint8_t HID_DS4_BUTTON_R2[] = {0x06, HID_DS4_BUTTON_R2_VALUE};
const uint8_t HID_DS4_BUTTON_R3[] = { 0x06,HID_DS4_BUTTON_R3_VALUE}; const uint8_t HID_DS4_BUTTON_R3[] = {0x06, HID_DS4_BUTTON_R3_VALUE};
const uint8_t HID_DS4_BUTTON_SHARE[] = { 0x06,HID_DS4_BUTTON_SHARE_VALUE}; const uint8_t HID_DS4_BUTTON_SHARE[] = {0x06, HID_DS4_BUTTON_SHARE_VALUE};
const uint8_t HID_DS4_BUTTON_OPTIONS[] = { 0x06,HID_DS4_BUTTON_OPTIONS_VALUE}; const uint8_t HID_DS4_BUTTON_OPTIONS[] = {0x06, HID_DS4_BUTTON_OPTIONS_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_TYPE[] = { CONTRPDM_Hat,HID_DS4_BUTTON_DPAD_MASK_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_TYPE[] = {CONTRPDM_Hat, HID_DS4_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_N[] = { 0x05,HID_DS4_BUTTON_DPAD_N_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_N[] = {0x05, HID_DS4_BUTTON_DPAD_N_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NE[] = { 0x05,HID_DS4_BUTTON_DPAD_NE_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_NE[] = {0x05, HID_DS4_BUTTON_DPAD_NE_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_E[] = { 0x05,HID_DS4_BUTTON_DPAD_E_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_E[] = {0x05, HID_DS4_BUTTON_DPAD_E_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_SE[] = { 0x05,HID_DS4_BUTTON_DPAD_SE_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_SE[] = {0x05, HID_DS4_BUTTON_DPAD_SE_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_S[] = { 0x05,HID_DS4_BUTTON_DPAD_S_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_S[] = {0x05, HID_DS4_BUTTON_DPAD_S_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_SW[] = { 0x05,HID_DS4_BUTTON_DPAD_SW_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_SW[] = {0x05, HID_DS4_BUTTON_DPAD_SW_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_W[] = { 0x05,HID_DS4_BUTTON_DPAD_W_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_W[] = {0x05, HID_DS4_BUTTON_DPAD_W_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NW[] = { 0x05,HID_DS4_BUTTON_DPAD_NW_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_NW[] = {0x05, HID_DS4_BUTTON_DPAD_NW_VALUE};
const uint8_t HID_DS4_BUTTON_DPAD_NEUTRAL[] = { 0x05,HID_DS4_BUTTON_DPAD_NEUTRAL_VALUE}; const uint8_t HID_DS4_BUTTON_DPAD_NEUTRAL[] = {0x05, HID_DS4_BUTTON_DPAD_NEUTRAL_VALUE};
const uint8_t HID_DS4_BUTTON_GUIDE[] = { 0x07,HID_DS4_BUTTON_GUIDE_VALUE}; const uint8_t HID_DS4_BUTTON_GUIDE[] = {0x07, HID_DS4_BUTTON_GUIDE_VALUE};
const uint8_t HID_DS4_BUTTON_T_PAD_CLICK[] = { 0x07,HID_DS4_BUTTON_T_PAD_CLICK_VALUE}; const uint8_t HID_DS4_BUTTON_T_PAD_CLICK[] = {0x07, HID_DS4_BUTTON_T_PAD_CLICK_VALUE};
const uint8_t HID_DS4_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_DS4_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x01, //STICK_CONF_BYTE, 0x01, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE, 0x06, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_DS4_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x02, //STICK_CONF_BYTE, 0x02, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x05, //STICK_CONF_DEADZONE, 0x05, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT, 0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_DS4_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE, 0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x07, //STICK_CONF_DEADZONE, 0x07, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_DS4_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_DS4_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE, 0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x09, //STICK_CONF_DEADZONE, 0x09, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT, 0x01, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! XInput //! XInput
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_XINPUT_BUTTON_A[] = { 0x07,HID_XINPUT_BUTTON_A_VALUE}; const uint8_t HID_XINPUT_BUTTON_A[] = {0x07, HID_XINPUT_BUTTON_A_VALUE};
const uint8_t HID_XINPUT_BUTTON_B[] = { 0x07,HID_XINPUT_BUTTON_B_VALUE}; const uint8_t HID_XINPUT_BUTTON_B[] = {0x07, HID_XINPUT_BUTTON_B_VALUE};
const uint8_t HID_XINPUT_BUTTON_X[] = { 0x07,HID_XINPUT_BUTTON_X_VALUE}; const uint8_t HID_XINPUT_BUTTON_X[] = {0x07, HID_XINPUT_BUTTON_X_VALUE};
const uint8_t HID_XINPUT_BUTTON_Y[] = { 0x07,HID_XINPUT_BUTTON_Y_VALUE}; const uint8_t HID_XINPUT_BUTTON_Y[] = {0x07, HID_XINPUT_BUTTON_Y_VALUE};
const uint8_t HID_XINPUT_BUTTON_LB[] = { 0x06,HID_XINPUT_BUTTON_LB_VALUE}; const uint8_t HID_XINPUT_BUTTON_LB[] = {0x06, HID_XINPUT_BUTTON_LB_VALUE};
const uint8_t HID_XINPUT_BUTTON_LT[] = { 0x04,HID_XINPUT_BUTTON_LT_VALUE}; const uint8_t HID_XINPUT_BUTTON_LT[] = {0x04, HID_XINPUT_BUTTON_LT_VALUE};
const uint8_t HID_XINPUT_BUTTON_L3[] = { 0x06,HID_XINPUT_BUTTON_L3_VALUE}; const uint8_t HID_XINPUT_BUTTON_L3[] = {0x06, HID_XINPUT_BUTTON_L3_VALUE};
const uint8_t HID_XINPUT_BUTTON_RB[] = { 0x06,HID_XINPUT_BUTTON_RB_VALUE}; const uint8_t HID_XINPUT_BUTTON_RB[] = {0x06, HID_XINPUT_BUTTON_RB_VALUE};
const uint8_t HID_XINPUT_BUTTON_RT[] = { 0x05,HID_XINPUT_BUTTON_RT_VALUE}; const uint8_t HID_XINPUT_BUTTON_RT[] = {0x05, HID_XINPUT_BUTTON_RT_VALUE};
const uint8_t HID_XINPUT_BUTTON_R3[] = { 0x06,HID_XINPUT_BUTTON_R3_VALUE}; const uint8_t HID_XINPUT_BUTTON_R3[] = {0x06, HID_XINPUT_BUTTON_R3_VALUE};
const uint8_t HID_XINPUT_BUTTON_START[] = { 0x06,HID_XINPUT_BUTTON_START_VALUE}; const uint8_t HID_XINPUT_BUTTON_START[] = {0x06, HID_XINPUT_BUTTON_START_VALUE};
const uint8_t HID_XINPUT_BUTTON_BACK[] = { 0x06,HID_XINPUT_BUTTON_BACK_VALUE}; const uint8_t HID_XINPUT_BUTTON_BACK[] = {0x06, HID_XINPUT_BUTTON_BACK_VALUE};
const uint8_t HID_XINPUT_BUTTON_GUIDE[] = { 0x06,HID_XINPUT_BUTTON_GUIDE_VALUE}; const uint8_t HID_XINPUT_BUTTON_GUIDE[] = {0x06, HID_XINPUT_BUTTON_GUIDE_VALUE};
const uint8_t HID_XINPUT_BUTTON_DPAD_TYPE[] = { CONTRPDM_Normal,HID_XINPUT_BUTTON_DPAD_MASK_VALUE}; const uint8_t HID_XINPUT_BUTTON_DPAD_TYPE[] = {CONTRPDM_Normal, HID_XINPUT_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_XINPUT_BUTTON_LEFT[] = { 0x07,HID_XINPUT_BUTTON_LEFT_VALUE}; const uint8_t HID_XINPUT_BUTTON_LEFT[] = {0x07, HID_XINPUT_BUTTON_LEFT_VALUE};
const uint8_t HID_XINPUT_BUTTON_RIGHT[] = { 0x07,HID_XINPUT_BUTTON_RIGHT_VALUE}; const uint8_t HID_XINPUT_BUTTON_RIGHT[] = {0x07, HID_XINPUT_BUTTON_RIGHT_VALUE};
const uint8_t HID_XINPUT_BUTTON_DOWN[] = { 0x07,HID_XINPUT_BUTTON_DOWN_VALUE}; const uint8_t HID_XINPUT_BUTTON_DOWN[] = {0x07, HID_XINPUT_BUTTON_DOWN_VALUE};
const uint8_t HID_XINPUT_BUTTON_UP[] = { 0x07,HID_XINPUT_BUTTON_UP_VALUE}; const uint8_t HID_XINPUT_BUTTON_UP[] = {0x07, HID_XINPUT_BUTTON_UP_VALUE};
const uint8_t HID_XINPUT_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_XINPUT_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x00, //STICK_CONF_BYTE, 0x00, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE, 0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_XINPUT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x01, //STICK_CONF_BYTE, 0x01, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE, 0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_XINPUT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x02, //STICK_CONF_BYTE, 0x02, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE, 0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_XINPUT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_XINPUT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x03, //STICK_CONF_BYTE, 0x03, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x10, //STICK_CONF_DEADZONE, 0x10, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x00, //STICK_CONF_MIN, 0x00, //STICK_CONF_MIN,
0xFF 0xFF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
//! Switch Pro Controller //! Switch Pro Controller
//!---------------------------------------------------------------------------------------------------------------------------------------------------------------------------- //!----------------------------------------------------------------------------------------------------------------------------------------------------------------------------
const uint8_t HID_SWITCH_PRO_BT_BUTTON_A[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_A_VALUE >> 24) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_A[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_A_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_B[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_B_VALUE >> 24) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_B[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_B_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_X[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_X_VALUE >> 24) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_X[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_X_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_Y[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_Y_VALUE >> 24) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_Y[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_Y_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_L[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_L_VALUE >> 24) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_L[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_L_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_ZL[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_ZL_VALUE >> 24) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_ZL[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_ZL_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_STICK_L[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_STICK_L_VALUE >> 16) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_STICK_L[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_STICK_L_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_R[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_R_VALUE >> 24) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_R[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_R_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_ZR[] = { 0x00,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_ZR_VALUE >> 24) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_ZR[] = {0x00, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_ZR_VALUE >> 24) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_STICK_R[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_STICK_R_VALUE >> 16) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_STICK_R[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_STICK_R_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_PLUS[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_PLUS_VALUE >> 16) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_PLUS[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_PLUS_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_MINUS[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_MINUS_VALUE >> 16) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_MINUS[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_MINUS_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_HOME[] = { 0x01,(uint8_t)((HID_SWITCH_PRO_BT_BUTTON_HOME_VALUE >> 16) & 0xFF)}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_HOME[] = {0x01, (uint8_t) ((HID_SWITCH_PRO_BT_BUTTON_HOME_VALUE >> 16) & 0xFF)};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE[] = { CONTRPDM_Hat,HID_SWITCH_PRO_BT_BUTTON_DPAD_MASK_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_TYPE[] = {CONTRPDM_Hat, HID_SWITCH_PRO_BT_BUTTON_DPAD_MASK_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_N[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_N_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_N[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_N_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NE[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_NE_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NE[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_NE_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_E[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_E_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_E[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_E_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_SE[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_SE_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_SE[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_SE_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_S[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_S_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_S[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_S_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_SW[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_SW_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_SW[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_SW_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_W[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_W_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_W[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_W_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NW[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_NW_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NW[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_NW_VALUE};
const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL[] = { 0x02,HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE}; const uint8_t HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL[] = {0x02, HID_SWITCH_PRO_BT_BUTTON_DPAD_NEUTRAL_VALUE};
const uint8_t HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_SWITCH_PRO_BT_STICK_L_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x04, //STICK_CONF_BYTE, 0x04, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x01, //STICK_CONF_DEADZONE, 0x01, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x28, //STICK_CONF_MIN, 0x28, //STICK_CONF_MIN,
0xDF 0xDF}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_SWITCH_PRO_BT_STICK_L_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x06, //STICK_CONF_BYTE, 0x06, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x06, //STICK_CONF_DEADZONE, 0x06, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT, 0x01, //STICK_CONF_INVERT,
0x16, //STICK_CONF_MIN, 0x16, //STICK_CONF_MIN,
0xD7 0xD7}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_SWITCH_PRO_BT_STICK_R_X[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x08, //STICK_CONF_BYTE, 0x08, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x04, //STICK_CONF_DEADZONE, 0x04, //STICK_CONF_DEADZONE,
0x00, //STICK_CONF_INVERT, 0x00, //STICK_CONF_INVERT,
0x29, //STICK_CONF_MIN, 0x29, //STICK_CONF_MIN,
0xE2 0xE2}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,
const uint8_t HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = { STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION const uint8_t HID_SWITCH_PRO_BT_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE] = {STICK_CONF_MAGIC_VALUE, //STICK_CONF_MAGIC_VERSION
0x0A, //STICK_CONF_BYTE, 0x0A, //STICK_CONF_BYTE,
0x80, //STICK_CONF_DEFAULT, 0x80, //STICK_CONF_DEFAULT,
0x08, //STICK_CONF_DEADZONE, 0x08, //STICK_CONF_DEADZONE,
0x01, //STICK_CONF_INVERT, 0x01, //STICK_CONF_INVERT,
0x22, //STICK_CONF_MIN, 0x22, //STICK_CONF_MIN,
0xE4 0xE4}; //STICK_CONF_MAX,
};//STICK_CONF_MAX,

6
source/utils/PadConst.hpp
View File

@ -19,8 +19,8 @@
#define _PAD_CONST_H_ #define _PAD_CONST_H_
#include <string>
#include <controller_patcher/ControllerPatcherDefs.h> #include <controller_patcher/ControllerPatcherDefs.h>
#include <string>
extern const uint8_t DEF_R_STICK; extern const uint8_t DEF_R_STICK;
extern const uint8_t DEF_L_STICK; extern const uint8_t DEF_L_STICK;
@ -74,7 +74,7 @@ extern const uint8_t HID_GC_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE];
extern const uint8_t HID_DS3_BUTTON_CROSS[]; extern const uint8_t HID_DS3_BUTTON_CROSS[];
extern const uint8_t HID_DS3_BUTTON_CIRCLE[]; extern const uint8_t HID_DS3_BUTTON_CIRCLE[];
extern const uint8_t HID_DS3_BUTTON_SQUARE []; extern const uint8_t HID_DS3_BUTTON_SQUARE[];
extern const uint8_t HID_DS3_BUTTON_TRIANGLE[]; extern const uint8_t HID_DS3_BUTTON_TRIANGLE[];
extern const uint8_t HID_DS3_BUTTON_L1[]; extern const uint8_t HID_DS3_BUTTON_L1[];
@ -106,7 +106,7 @@ extern const uint8_t HID_DS3_STICK_R_Y[STICK_CONF_ENUM_MAXVALUE];
extern const uint8_t HID_DS4_BUTTON_CROSS[]; extern const uint8_t HID_DS4_BUTTON_CROSS[];
extern const uint8_t HID_DS4_BUTTON_CIRCLE[]; extern const uint8_t HID_DS4_BUTTON_CIRCLE[];
extern const uint8_t HID_DS4_BUTTON_SQUARE []; extern const uint8_t HID_DS4_BUTTON_SQUARE[];
extern const uint8_t HID_DS4_BUTTON_TRIANGLE[]; extern const uint8_t HID_DS4_BUTTON_TRIANGLE[];
extern const uint8_t HID_DS4_BUTTON_L1[]; extern const uint8_t HID_DS4_BUTTON_L1[];

69
source/utils/StringTools.cpp
View File

@ -23,25 +23,24 @@
* *
* for WiiXplorer 2010 * for WiiXplorer 2010
***************************************************************************/ ***************************************************************************/
#include <vector>
#include <string>
#include <string.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <string.h>
#include <wchar.h> #include <string>
#include <strings.h> #include <strings.h>
#include <wut_types.h>
#include <stdio.h>
#include <utils/StringTools.h> #include <utils/StringTools.h>
#include <vector>
#include <wchar.h>
#include <wut_types.h>
BOOL StringTools::EndsWith(const std::string& a, const std::string& b) { BOOL StringTools::EndsWith(const std::string &a, const std::string &b) {
if (b.size() > a.size()) return false; if (b.size() > a.size()) return false;
return std::equal(a.begin() + a.size() - b.size(), a.end(), b.begin()); return std::equal(a.begin() + a.size() - b.size(), a.end(), b.begin());
} }
const char * StringTools::byte_to_binary(int32_t x) { const char *StringTools::byte_to_binary(int32_t x) {
static char b[9]; static char b[9];
b[0] = '\0'; b[0] = '\0';
@ -53,25 +52,25 @@ const char * StringTools::byte_to_binary(int32_t x) {
return b; return b;
} }
std::string StringTools::removeCharFromString(std::string& input,char toBeRemoved) { std::string StringTools::removeCharFromString(std::string &input, char toBeRemoved) {
std::string output = input; std::string output = input;
size_t position; size_t position;
while(1) { while (1) {
position = output.find(toBeRemoved); position = output.find(toBeRemoved);
if(position == std::string::npos) if (position == std::string::npos)
break; break;
output.erase(position, 1); output.erase(position, 1);
} }
return output; return output;
} }
const char * StringTools::fmt(const char * format, ...) { const char *StringTools::fmt(const char *format, ...) {
static char strChar[512]; static char strChar[512];
strChar[0] = 0; strChar[0] = 0;
va_list va; va_list va;
va_start(va, format); va_start(va, format);
if((vsprintf(strChar, format, va) >= 0)) { if ((vsprintf(strChar, format, va) >= 0)) {
va_end(va); va_end(va);
return (const char *) strChar; return (const char *) strChar;
} }
@ -80,26 +79,26 @@ const char * StringTools::fmt(const char * format, ...) {
return NULL; return NULL;
} }
const wchar_t * StringTools::wfmt(const char * format, ...) { const wchar_t *StringTools::wfmt(const char *format, ...) {
static char tmp[512]; static char tmp[512];
static wchar_t strWChar[512]; static wchar_t strWChar[512];
strWChar[0] = 0; strWChar[0] = 0;
tmp[0] = 0; tmp[0] = 0;
if(!format) if (!format)
return (const wchar_t *) strWChar; return (const wchar_t *) strWChar;
if(strcmp(format, "") == 0) if (strcmp(format, "") == 0)
return (const wchar_t *) strWChar; return (const wchar_t *) strWChar;
va_list va; va_list va;
va_start(va, format); va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) { if ((vsprintf(tmp, format, va) >= 0)) {
int bt; int bt;
int32_t strlength = strlen(tmp); int32_t strlength = strlen(tmp);
bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512 ); bt = mbstowcs(strWChar, tmp, (strlength < 512) ? strlength : 512);
if(bt > 0) { if (bt > 0) {
strWChar[bt] = 0; strWChar[bt] = 0;
return (const wchar_t *) strWChar; return (const wchar_t *) strWChar;
} }
@ -109,14 +108,14 @@ const wchar_t * StringTools::wfmt(const char * format, ...) {
return NULL; return NULL;
} }
int32_t StringTools::strprintf(std::string &str, const char * format, ...) { int32_t StringTools::strprintf(std::string &str, const char *format, ...) {
static char tmp[512]; static char tmp[512];
tmp[0] = 0; tmp[0] = 0;
int32_t result = 0; int32_t result = 0;
va_list va; va_list va;
va_start(va, format); va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) { if ((vsprintf(tmp, format, va) >= 0)) {
str = tmp; str = tmp;
result = str.size(); result = str.size();
} }
@ -125,14 +124,14 @@ int32_t StringTools::strprintf(std::string &str, const char * format, ...) {
return result; return result;
} }
std::string StringTools::strfmt(const char * format, ...) { std::string StringTools::strfmt(const char *format, ...) {
std::string str; std::string str;
static char tmp[512]; static char tmp[512];
tmp[0] = 0; tmp[0] = 0;
va_list va; va_list va;
va_start(va, format); va_start(va, format);
if((vsprintf(tmp, format, va) >= 0)) { if ((vsprintf(tmp, format, va) >= 0)) {
str = tmp; str = tmp;
} }
va_end(va); va_end(va);
@ -140,8 +139,8 @@ std::string StringTools::strfmt(const char * format, ...) {
return str; return str;
} }
BOOL StringTools::char2wchar_t(const char * strChar, wchar_t * dest) { BOOL StringTools::char2wchar_t(const char *strChar, wchar_t *dest) {
if(!strChar || !dest) if (!strChar || !dest)
return false; return false;
int bt; int bt;
@ -154,39 +153,39 @@ BOOL StringTools::char2wchar_t(const char * strChar, wchar_t * dest) {
return false; return false;
} }
int32_t StringTools::strtokcmp(const char * string, const char * compare, const char * separator) { int32_t StringTools::strtokcmp(const char *string, const char *compare, const char *separator) {
if(!string || !compare) if (!string || !compare)
return -1; return -1;
char TokCopy[512]; char TokCopy[512];
strncpy(TokCopy, compare, sizeof(TokCopy)); strncpy(TokCopy, compare, sizeof(TokCopy));
TokCopy[511] = '\0'; TokCopy[511] = '\0';
char * strTok = strtok(TokCopy, separator); char *strTok = strtok(TokCopy, separator);
while (strTok != NULL) { while (strTok != NULL) {
if (strcasecmp(string, strTok) == 0) { if (strcasecmp(string, strTok) == 0) {
return 0; return 0;
} }
strTok = strtok(NULL,separator); strTok = strtok(NULL, separator);
} }
return -1; return -1;
} }
int32_t StringTools::strextcmp(const char * string, const char * extension, char seperator) { int32_t StringTools::strextcmp(const char *string, const char *extension, char seperator) {
if(!string || !extension) if (!string || !extension)
return -1; return -1;
char *ptr = strrchr(string, seperator); char *ptr = strrchr(string, seperator);
if(!ptr) if (!ptr)
return -1; return -1;
return strcasecmp(ptr + 1, extension); return strcasecmp(ptr + 1, extension);
} }
std::vector<std::string> StringTools::stringSplit(const std::string & inValue, const std::string & splitter) { std::vector<std::string> StringTools::stringSplit(const std::string &inValue, const std::string &splitter) {
std::string value = inValue; std::string value = inValue;
std::vector<std::string> result; std::vector<std::string> result;
while (true) { while (true) {
@ -201,7 +200,7 @@ std::vector<std::string> StringTools::stringSplit(const std::string & inValue, c
result.push_back(""); result.push_back("");
break; break;
} }
if(index + splitter.size() > value.length()) { if (index + splitter.size() > value.length()) {
break; break;
} }
value = value.substr(index + splitter.size(), value.length()); value = value.substr(index + splitter.size(), value.length());

51
source/utils/StringTools.h
View File

@ -26,33 +26,32 @@
#ifndef __STRING_TOOLS_H #ifndef __STRING_TOOLS_H
#define __STRING_TOOLS_H #define __STRING_TOOLS_H
#include <vector>
#include <string> #include <string>
#include <vector>
#include <wut_types.h> #include <wut_types.h>
class StringTools{ class StringTools {
public: public:
static BOOL EndsWith(const std::string& a, const std::string& b); static BOOL EndsWith(const std::string &a, const std::string &b);
static const char * byte_to_binary(int32_t x); static const char *byte_to_binary(int32_t x);
static std::string removeCharFromString(std::string& input,char toBeRemoved); static std::string removeCharFromString(std::string &input, char toBeRemoved);
static const char * fmt(const char * format, ...); static const char *fmt(const char *format, ...);
static const wchar_t * wfmt(const char * format, ...); static const wchar_t *wfmt(const char *format, ...);
static int32_t strprintf(std::string &str, const char * format, ...); static int32_t strprintf(std::string &str, const char *format, ...);
static std::string strfmt(const char * format, ...); static std::string strfmt(const char *format, ...);
static BOOL char2wchar_t(const char * src, wchar_t * dest); static BOOL char2wchar_t(const char *src, wchar_t *dest);
static int32_t strtokcmp(const char * string, const char * compare, const char * separator); static int32_t strtokcmp(const char *string, const char *compare, const char *separator);
static int32_t strextcmp(const char * string, const char * extension, char seperator); static int32_t strextcmp(const char *string, const char *extension, char seperator);
static const char * FullpathToFilename(const char *path){ static const char *FullpathToFilename(const char *path) {
if(!path) return path; if (!path) return path;
const char * ptr = path; const char *ptr = path;
const char * Filename = ptr; const char *Filename = ptr;
while(*ptr != '\0') while (*ptr != '\0') {
{ if (ptr[0] == '/' && ptr[1] != '\0')
if(ptr[0] == '/' && ptr[1] != '\0') Filename = ptr + 1;
Filename = ptr+1;
++ptr; ++ptr;
} }
@ -60,14 +59,12 @@ class StringTools{
return Filename; return Filename;
} }
static void RemoveDoubleSlashs(std::string &str){ static void RemoveDoubleSlashs(std::string &str) {
uint32_t length = str.size(); uint32_t length = str.size();
//! clear path of double slashes //! clear path of double slashes
for(uint32_t i = 1; i < length; ++i) for (uint32_t i = 1; i < length; ++i) {
{ if (str[i - 1] == '/' && str[i] == '/') {
if(str[i-1] == '/' && str[i] == '/')
{
str.erase(i, 1); str.erase(i, 1);
i--; i--;
length--; length--;
@ -75,7 +72,7 @@ class StringTools{
} }
} }
static std::vector<std::string> stringSplit(const std::string & value, const std::string & splitter); static std::vector<std::string> stringSplit(const std::string &value, const std::string &splitter);
}; };
#endif /* __STRING_TOOLS_H */ #endif /* __STRING_TOOLS_H */

44
source/utils/TCPServer.cpp
View File

@ -1,20 +1,20 @@
#include <utils/TCPServer.hpp>
#include <malloc.h> #include <malloc.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <utils/TCPServer.hpp>
#include <utils/logger.h>
#include <network/net.h> #include <network/net.h>
#include <utils/logger.h>
#define wiiu_errno (*__gh_errno_ptr()) #define wiiu_errno (*__gh_errno_ptr())
TCPServer::TCPServer(int32_t port,int32_t priority) { TCPServer::TCPServer(int32_t port, int32_t priority) {
this->port = port; this->port = port;
this->sockfd = -1; this->sockfd = -1;
this->clientfd = -1; this->clientfd = -1;
memset(&(this->sock_addr),0,sizeof(this->sock_addr)); memset(&(this->sock_addr), 0, sizeof(this->sock_addr));
pThread = CThread::create(TCPServer::DoTCPThread, (void*)this, CThread::eAttributeAffCore2,priority); pThread = CThread::create(TCPServer::DoTCPThread, (void *) this, CThread::eAttributeAffCore2, priority);
pThread->resumeThread(); pThread->resumeThread();
} }
@ -23,10 +23,10 @@ TCPServer::~TCPServer() {
//DEBUG_FUNCTION_LINE("Thread will be closed"); //DEBUG_FUNCTION_LINE("Thread will be closed");
exitThread = 1; exitThread = 1;
ICInvalidateRange((void*)&exitThread, 4); ICInvalidateRange((void *) &exitThread, 4);
DCFlushRange((void*)&exitThread, 4); DCFlushRange((void *) &exitThread, 4);
if(pThread != NULL) { if (pThread != NULL) {
//DEBUG_FUNCTION_LINE("Deleting it!"); //DEBUG_FUNCTION_LINE("Deleting it!");
delete pThread; delete pThread;
} }
@ -47,7 +47,7 @@ void TCPServer::CloseSockets() {
void TCPServer::ErrorHandling() { void TCPServer::ErrorHandling() {
CloseSockets(); CloseSockets();
OSSleepTicks(OSMicrosecondsToTicks(1000*1000*2)); OSSleepTicks(OSMicrosecondsToTicks(1000 * 1000 * 2));
} }
void TCPServer::DoTCPThreadInternal() { void TCPServer::DoTCPThreadInternal() {
@ -55,16 +55,16 @@ void TCPServer::DoTCPThreadInternal() {
socklen_t len; socklen_t len;
connected = false; connected = false;
while (1) { while (1) {
if(exitThread) { if (exitThread) {
break; break;
} }
memset(&(this->sock_addr),0,sizeof(sock_addr)); memset(&(this->sock_addr), 0, sizeof(sock_addr));
sock_addr.sin_family = AF_INET; sock_addr.sin_family = AF_INET;
sock_addr.sin_port = this->port; sock_addr.sin_port = this->port;
sock_addr.sin_addr.s_addr = 0; sock_addr.sin_addr.s_addr = 0;
this->sockfd = ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP); this->sockfd = ret = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
if(ret == -1) { if (ret == -1) {
ErrorHandling(); ErrorHandling();
continue; continue;
} }
@ -72,31 +72,31 @@ void TCPServer::DoTCPThreadInternal() {
setsockopt(this->sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable)); setsockopt(this->sockfd, SOL_SOCKET, SO_REUSEADDR, &enable, sizeof(enable));
ret = bind(this->sockfd, (sockaddr *)&sock_addr, 16); ret = bind(this->sockfd, (sockaddr *) &sock_addr, 16);
if(ret < 0) { if (ret < 0) {
ErrorHandling(); ErrorHandling();
continue; continue;
} }
ret = listen(this->sockfd, 1); ret = listen(this->sockfd, 1);
if(ret < 0) { if (ret < 0) {
ErrorHandling(); ErrorHandling();
continue; continue;
} }
do { do {
DEBUG_FUNCTION_LINE("Waiting for a connection"); DEBUG_FUNCTION_LINE("Waiting for a connection");
if(exitThread) { if (exitThread) {
break; break;
} }
len = 16; len = 16;
clientfd = ret = accept(sockfd, (sockaddr *)&(sock_addr), &len); clientfd = ret = accept(sockfd, (sockaddr *) &(sock_addr), &len);
if(ret == -1) { if (ret == -1) {
ErrorHandling(); ErrorHandling();
break; break;
} }
if(!acceptConnection()) { if (!acceptConnection()) {
ErrorHandling(); ErrorHandling();
break; break;
} }
@ -109,11 +109,11 @@ void TCPServer::DoTCPThreadInternal() {
DEBUG_FUNCTION_LINE("Client disconnected"); DEBUG_FUNCTION_LINE("Client disconnected");
if(clientfd != -1) { if (clientfd != -1) {
close(clientfd); close(clientfd);
} }
clientfd = -1; clientfd = -1;
} while(0); } while (0);
DEBUG_FUNCTION_LINE("Closing TCPServer"); DEBUG_FUNCTION_LINE("Closing TCPServer");
connected = false; connected = false;
onConnectionClosed(); onConnectionClosed();
@ -124,6 +124,6 @@ void TCPServer::DoTCPThreadInternal() {
} }
void TCPServer::DoTCPThread(CThread *thread, void *arg) { void TCPServer::DoTCPThread(CThread *thread, void *arg) {
TCPServer * args = (TCPServer * )arg; TCPServer *args = (TCPServer *) arg;
return args->DoTCPThreadInternal(); return args->DoTCPThreadInternal();
} }

10
source/utils/TCPServer.hpp
View File

@ -1,14 +1,14 @@
#ifndef _TCPSERVER_H_ #ifndef _TCPSERVER_H_
#define _TCPSERVER_H_ #define _TCPSERVER_H_
#include <netinet/in.h>
#include <sys/select.h> #include <sys/select.h>
#include <sys/socket.h> #include <sys/socket.h>
#include <netinet/in.h>
#include <system/CThread.h> #include <system/CThread.h>
#include <wut_types.h> #include <wut_types.h>
#include <coreinit/cache.h>
#include "utils/logger.h" #include "utils/logger.h"
#include <coreinit/cache.h>
class TCPServer { class TCPServer {
public: public:
@ -18,6 +18,7 @@ public:
BOOL isConnected() { BOOL isConnected() {
return connected; return connected;
} }
protected: protected:
BOOL shouldExit() { BOOL shouldExit() {
return (exitThread == 1); return (exitThread == 1);
@ -32,7 +33,7 @@ protected:
} }
void setThreadPriority(int32_t priority) { void setThreadPriority(int32_t priority) {
if(pThread != NULL){ if (pThread != NULL) {
pThread->setThreadPriority(priority); pThread->setThreadPriority(priority);
} }
} }
@ -40,6 +41,7 @@ protected:
struct sockaddr_in getSockAddr() { struct sockaddr_in getSockAddr() {
return sock_addr; return sock_addr;
} }
private: private:
virtual void CloseSockets(); virtual void CloseSockets();
virtual void ErrorHandling(); virtual void ErrorHandling();
@ -49,7 +51,7 @@ private:
virtual BOOL acceptConnection() = 0; virtual BOOL acceptConnection() = 0;
virtual void onConnectionClosed(){ virtual void onConnectionClosed() {
DEBUG_FUNCTION_LINE("Default onConnectionClosed "); DEBUG_FUNCTION_LINE("Default onConnectionClosed ");
} }

12
source/utils/logger.h
View File

@ -13,14 +13,16 @@ extern "C" {
#ifdef __LOGGING__ #ifdef __LOGGING__
#define log_print(str) WHBLogPrint(str) #define log_print(str) WHBLogPrint(str)
#define log_printf(FMT, ARGS...) WHBLogPrintf(FMT, ## ARGS); #define log_printf(FMT, ARGS...) WHBLogPrintf(FMT, ##ARGS);
#define DEBUG_FUNCTION_LINE(FMT, ARGS...)do { \ #define DEBUG_FUNCTION_LINE(FMT, ARGS...) \
WHBLogPrintf("[%23s]%30s@L%04d: " FMT "",__FILENAME__,__FUNCTION__, __LINE__, ## ARGS); \ do { \
WHBLogPrintf("[%23s]%30s@L%04d: " FMT "", __FILENAME__, __FUNCTION__, __LINE__, ##ARGS); \
} while (0); } while (0);
#define DEBUG_FUNCTION_LINE_WRITE(FMT, ARGS...)do { \ #define DEBUG_FUNCTION_LINE_WRITE(FMT, ARGS...) \
WHBLogWritef("[%23s]%30s@L%04d: " FMT "",__FILENAME__,__FUNCTION__, __LINE__, ## ARGS); \ do { \
WHBLogWritef("[%23s]%30s@L%04d: " FMT "", __FILENAME__, __FUNCTION__, __LINE__, ##ARGS); \
} while (0); } while (0);
#else #else