diff --git a/Utilities/Config.h b/Utilities/Config.h
index 4cbc88a85f..be7c58d2dc 100644
--- a/Utilities/Config.h
+++ b/Utilities/Config.h
@@ -118,7 +118,7 @@ namespace cfg
 		bool m_value;
 
 	public:
-		const bool def;
+		bool def;
 
 		_bool(node* owner, const std::string& name, bool def = false)
 			: _base(type::_bool, owner, name)
@@ -150,6 +150,11 @@ namespace cfg
 
 			return true;
 		}
+
+		void set(const bool& value)
+		{
+			m_value = value;
+		}
 	};
 
 	// Value node with fixed set of possible values, each maps to an enum value of type T.
@@ -217,7 +222,7 @@ namespace cfg
 		int_type m_value;
 
 	public:
-		const int_type def;
+		int_type def;
 
 		_int(node* owner, const std::string& name, int_type def = std::min<int_type>(Max, std::max<int_type>(Min, 0)))
 			: _base(type::_int, owner, name)
@@ -253,6 +258,11 @@ namespace cfg
 			return false;
 		}
 
+		void set(const s64& value)
+		{
+			m_value = static_cast<int_type>(value);
+		}
+
 		std::vector<std::string> to_list() const override
 		{
 			return make_int_range(Min, Max);
@@ -271,7 +281,7 @@ namespace cfg
 		std::string m_value;
 
 	public:
-		const std::string def;
+		std::string def;
 
 		string(node* owner, const std::string& name, const std::string& def = {})
 			: _base(type::string, owner, name)
diff --git a/rpcs3/Emu/Io/PadHandler.h b/rpcs3/Emu/Io/PadHandler.h
index 288665180a..fd49f87195 100644
--- a/rpcs3/Emu/Io/PadHandler.h
+++ b/rpcs3/Emu/Io/PadHandler.h
@@ -1,7 +1,10 @@
 #pragma once
 
+#include <cmath>
 #include <vector>
 #include <memory>
+#include "stdafx.h"
+#include "../../Utilities/Config.h"
 #include "../../Utilities/types.h"
 
 // TODO: HLE info (constants, structs, etc.) should not be available here
@@ -159,6 +162,13 @@ struct Pad
 	u32 m_device_capability;
 	u32 m_device_type;
 
+	// Cable State:   0 - 1  plugged in ?
+	u8 m_cable_state;
+
+	// DS4: 0 - 9  while unplugged, 0 - 10 while plugged in, 11 charge complete
+	// XInput: 0 = Empty, 1 = Low, 2 = Medium, 3 = Full
+	u8 m_battery_level;
+
 	std::vector<Button> m_buttons;
 	std::vector<AnalogStick> m_sticks;
 	std::vector<AnalogSensor> m_sensors;
@@ -238,23 +248,280 @@ struct Pad
 	}
 };
 
+struct pad_config : cfg::node
+{
+	std::string cfg_type = "";
+	std::string cfg_name = "";
+
+	cfg::string ls_left { this, "Left Stick Left", "" };
+	cfg::string ls_down { this, "Left Stick Down", "" };
+	cfg::string ls_right{ this, "Left Stick Right", "" };
+	cfg::string ls_up   { this, "Left Stick Up", "" };
+	cfg::string rs_left { this, "Right Stick Left", "" };
+	cfg::string rs_down { this, "Right Stick Down", "" };
+	cfg::string rs_right{ this, "Right Stick Right", "" };
+	cfg::string rs_up   { this, "Right Stick Up", "" };
+	cfg::string start   { this, "Start", "" };
+	cfg::string select  { this, "Select", "" };
+	cfg::string ps      { this, "PS Button", "" };
+	cfg::string square  { this, "Square", "" };
+	cfg::string cross   { this, "Cross", "" };
+	cfg::string circle  { this, "Circle", "" };
+	cfg::string triangle{ this, "Triangle", "" };
+	cfg::string left    { this, "Left", "" };
+	cfg::string down    { this, "Down", "" };
+	cfg::string right   { this, "Right", "" };
+	cfg::string up      { this, "Up", "" };
+	cfg::string r1      { this, "R1", "" };
+	cfg::string r2      { this, "R2", "" };
+	cfg::string r3      { this, "R3", "" };
+	cfg::string l1      { this, "L1", "" };
+	cfg::string l2      { this, "L2", "" };
+	cfg::string l3      { this, "L3", "" };
+
+	cfg::_int<0, 1000000> lstickdeadzone{ this, "Left Stick Deadzone", 0 };
+	cfg::_int<0, 1000000> rstickdeadzone{ this, "Right Stick Deadzone", 0 };
+	cfg::_int<0, 1000000> ltriggerthreshold{ this, "Left Trigger Threshold", 0 };
+	cfg::_int<0, 1000000> rtriggerthreshold{ this, "Right Trigger Threshold", 0 };
+	cfg::_int<0, 1000000> padsquircling{ this, "Pad Squircling Factor", 0 };
+
+	cfg::_int<0, 255> colorR{ this, "Color Value R", 0 };
+	cfg::_int<0, 255> colorG{ this, "Color Value G", 0 };
+	cfg::_int<0, 255> colorB{ this, "Color Value B", 0 };
+
+	cfg::_bool enable_vibration_motor_large{ this, "Enable Large Vibration Motor", true };
+	cfg::_bool enable_vibration_motor_small{ this, "Enable Small Vibration Motor", true };
+	cfg::_bool switch_vibration_motors{ this, "Switch Vibration Motors", false };
+
+	bool load()
+	{
+		if (fs::file cfg_file{ cfg_name, fs::read })
+		{
+			return from_string(cfg_file.to_string());
+		}
+
+		return false;
+	}
+
+	void save()
+	{
+		fs::file(cfg_name, fs::rewrite).write(to_string());
+	}
+
+	bool exist()
+	{
+		return fs::is_file(cfg_name);
+	}
+};
+
 class PadHandlerBase
 {
 protected:
+	static const u32 MAX_GAMEPADS = 7;
+
+	int m_trigger_threshold = 0;
+	int m_thumb_threshold = 0;
+
+	bool b_has_deadzones = false;
+	bool b_has_rumble = false;
 	bool b_has_config = false;
+	pad_config m_pad_config;
+
+	template <typename T>
+	T lerp(T v0, T v1, T t) {
+		return std::fma(t, v1, std::fma(-t, v0, v0));
+	}
+
+	// Search an unordered map for a string value and return found keycode
+	int FindKeyCode(std::unordered_map<u32, std::string> map, const std::string& name)
+	{
+		for (auto it = map.begin(); it != map.end(); ++it)
+		{
+			if (it->second == name) return it->first;
+		}
+		return -1;
+	};
+	long FindKeyCode(std::unordered_map<u64, std::string> map, const std::string& name)
+	{
+		for (auto it = map.begin(); it != map.end(); ++it)
+		{
+			if (it->second == name) return it->first;
+		}
+		return -1;
+	};
+
+	// Get normalized trigger value based on the range defined by a threshold
+	u16 NormalizeTriggerInput(u16 value, int threshold)
+	{
+		if (value <= threshold || threshold >= trigger_max)
+		{
+			return static_cast<u16>(0);
+		}
+		else if (threshold <= trigger_min)
+		{
+			return value;
+		}
+		else
+		{
+			return (u16)(float(trigger_max) * float(value - threshold) / float(trigger_max - threshold));
+		}
+	};
+
+	// Get new scaled value between 0 and 255 based on its minimum and maximum
+	float ScaleStickInput(s32 raw_value, int minimum, int maximum)
+	{
+		// value based on max range converted to [0, 1]
+		float val = float(Clamp(raw_value, minimum, maximum) - minimum) / float(abs(maximum) + abs(minimum));
+		return 255.0f * val;
+	};
+
+	// normalizes a directed input, meaning it will correspond to a single "button" and not an axis with two directions
+	// the input values must lie in 0+
+	u16 NormalizeDirectedInput(u16 raw_value, float threshold, float maximum)
+	{
+		if (threshold >= maximum || maximum <= 0)
+		{
+			return static_cast<u16>(0);
+		}
+
+		float val = float(Clamp(raw_value, 0, maximum)) / maximum; // value based on max range converted to [0, 1]
+
+		if (threshold <= 0)
+		{
+			return static_cast<u16>(255.0f * val);
+		}
+		else
+		{
+			float thresh = threshold / maximum; // threshold converted to [0, 1]
+			return static_cast<u16>(255.0f * std::min(1.0f, (val - thresh) / (1.0f - thresh)));
+		}
+	};
+
+	u16 NormalizeStickInput(s32 raw_value, int threshold, bool ignore_threshold = false)
+	{
+		if (ignore_threshold)
+		{
+			return static_cast<u16>(ScaleStickInput(raw_value, 0, thumb_max));
+		}
+		else
+		{
+			return NormalizeDirectedInput(raw_value, threshold, thumb_max);
+		}
+	}
+
+	// This function normalizes stick deadzone based on the DS3's deadzone, which is ~13%
+	// X and Y is expected to be in (-255) to 255 range, deadzone should be in terms of thumb stick range
+	// return is new x and y values in 0-255 range
+	std::tuple<u16, u16> NormalizeStickDeadzone(s32 inX, s32 inY, u32 deadzone)
+	{
+		const float dzRange = deadzone / float((std::abs(thumb_max) + std::abs(thumb_min)));
+
+		float X = inX / 255.0f;
+		float Y = inY / 255.0f;
+
+		if (dzRange > 0.f)
+		{
+			const float mag = std::min(sqrtf(X*X + Y*Y), 1.f);
+
+			if (mag <= 0)
+			{
+				return std::tuple<u16, u16>(ConvertAxis(X), ConvertAxis(Y));
+			}
+
+			if (mag > dzRange) {
+				float pos = lerp(0.13f, 1.f, (mag - dzRange) / (1 - dzRange));
+				float scale = pos / mag;
+				X = X * scale;
+				Y = Y * scale;
+			}
+			else {
+				float pos = lerp(0.f, 0.13f, mag / dzRange);
+				float scale = pos / mag;
+				X = X * scale;
+				Y = Y * scale;
+			}
+		}
+		return std::tuple<u16, u16>( ConvertAxis(X), ConvertAxis(Y) );
+	};
+
+	// get clamped value between min and max
+	s32 Clamp(f32 input, s32 min, s32 max)
+	{
+		if (input > max)
+			return max;
+		else if (input < min)
+			return min;
+		else return static_cast<s32>(input);
+	};
+
+	// get clamped value between 0 and 255
+	u16 Clamp0To255(f32 input)
+	{
+		return static_cast<u16>(Clamp(input, 0, 255));
+	};
+
+	// get clamped value between 0 and 1023
+	u16 Clamp0To1023(f32 input)
+	{
+		return static_cast<u16>(Clamp(input, 0, 1023));
+	}
+
+	// input has to be [-1,1]. result will be [0,255]
+	u16 ConvertAxis(float value)
+	{
+		return static_cast<u16>((value + 1.0)*(255.0 / 2.0));
+	};
+
+	// The DS3, (and i think xbox controllers) give a 'square-ish' type response, so that the corners will give (almost)max x/y instead of the ~30x30 from a perfect circle
+	// using a simple scale/sensitivity increase would *work* although it eats a chunk of our usable range in exchange
+	// this might be the best for now, in practice it seems to push the corners to max of 20x20, with a squircle_factor of 8000
+	// This function assumes inX and inY is already in 0-255 
+	std::tuple<u16, u16> ConvertToSquirclePoint(u16 inX, u16 inY, float squircle_factor)
+	{
+		// convert inX and Y to a (-1, 1) vector;
+		const f32 x = ((f32)inX - 127.5f) / 127.5f;
+		const f32 y = ((f32)inY - 127.5f) / 127.5f;
+
+		// compute angle and len of given point to be used for squircle radius
+		const f32 angle = std::atan2(y, x);
+		const f32 r = std::sqrt(std::pow(x, 2.f) + std::pow(y, 2.f));
+
+		// now find len/point on the given squircle from our current angle and radius in polar coords
+		// https://thatsmaths.com/2016/07/14/squircles/
+		const f32 newLen = (1 + std::pow(std::sin(2 * angle), 2.f) / (squircle_factor / 1000.f)) * r;
+
+		// we now have len and angle, convert to cartisian
+		const int newX = Clamp0To255(((newLen * std::cos(angle)) + 1) * 127.5f);
+		const int newY = Clamp0To255(((newLen * std::sin(angle)) + 1) * 127.5f);
+		return std::tuple<u16, u16>(newX, newY);
+	}
 
 public:
+	s32 thumb_min = 0;
+	s32 thumb_max = 255;
+	s32 trigger_min = 0;
+	s32 trigger_max = 255;
+	s32 vibration_min = 0;
+	s32 vibration_max = 255;
+
 	virtual bool Init() { return true; };
 	virtual ~PadHandlerBase() = default;
 
 	//Does it have GUI Config?
 	bool has_config() { return b_has_config; };
+	bool has_rumble() { return b_has_rumble; };
+	bool has_deadzones() { return b_has_deadzones; };
+	pad_config* GetConfig() { return &m_pad_config; };
 	//Sets window to config the controller(optional)
-	virtual void ConfigController(std::string device) {};
+	virtual void GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& callback) {};
+	virtual void TestVibration(const std::string& padId, u32 largeMotor, u32 smallMotor) {};
 	//Return list of devices for that handler
 	virtual std::vector<std::string> ListDevices() = 0;
 	//Callback called during pad_thread::ThreadFunc
 	virtual void ThreadProc() = 0;
 	//Binds a Pad to a device
 	virtual bool bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device) = 0;
+
+private:
+	virtual void TranslateButtonPress(u64 keyCode, bool& pressed, u16& val, bool ignore_threshold = false) {};
 };
diff --git a/rpcs3/ds4_pad_handler.cpp b/rpcs3/ds4_pad_handler.cpp
index 100005fdf1..1f57ddb4c4 100644
--- a/rpcs3/ds4_pad_handler.cpp
+++ b/rpcs3/ds4_pad_handler.cpp
@@ -1,9 +1,9 @@
 #include "stdafx.h"
 #include "Emu/System.h"
 #include "ds4_pad_handler.h"
+#include "rpcs3qt/pad_settings_dialog.h"
 
 #include <thread>
-#include <cmath>
 
 #ifdef _WIN32
 #include <Windows.h>
@@ -23,51 +23,7 @@ namespace
 	const u32 DS4_OUTPUT_REPORT_0x05_SIZE = 32;
 	const u32 DS4_OUTPUT_REPORT_0x11_SIZE = 78;
 	const u32 DS4_INPUT_REPORT_GYRO_X_OFFSET = 13;
-
-	inline u16 Clamp0To255(f32 input)
-	{
-		if (input > 255.f)
-			return 255;
-		else if (input < 0.f)
-			return 0;
-		else return static_cast<u16>(input);
-	}
-
-	inline u16 Clamp0To1023(f32 input)
-	{
-		if (input > 1023.f)
-			return 1023;
-		else if (input < 0.f)
-			return 0;
-		else return static_cast<u16>(input);
-	}
-
-	// we get back values from 0 - 255 for x and y from the ds4 packets,
-	// and they end up giving us basically a perfect circle, which is how the ds4 sticks are setup
-	// however,the ds3, (and i think xbox controllers) give instead a more 'square-ish' type response, so that the corners will give (almost)max x/y instead of the ~30x30 from a perfect circle
-	// using a simple scale/sensitivity increase would *work* although it eats a chunk of our usable range in exchange
-
-	// this might be the best for now, in practice it seems to push the corners to max of 20x20
-	std::tuple<u16, u16> ConvertToSquirclePoint(u16 inX, u16 inY)
-	{
-		// convert inX and Y to a (-1, 1) vector;
-		const f32 x = (inX - 127) / 127.f;
-		const f32 y = ((inY - 127) / 127.f);
-
-		// compute angle and len of given point to be used for squircle radius
-		const f32 angle = std::atan2(y, x);
-		const f32 r = std::sqrt(std::pow(x, 2.f) + std::pow(y, 2.f));
-
-		// now find len/point on the given squircle from our current angle and radius in polar coords
-		// https://thatsmaths.com/2016/07/14/squircles/
-		const f32 newLen = (1 + std::pow(std::sin(2 * angle), 2.f) / 8.f) * r;
-
-		// we now have len and angle, convert to cartisian
-
-		const int newX = Clamp0To255(((newLen * std::cos(angle)) + 1) * 127);
-		const int newY = Clamp0To255(((newLen * std::sin(angle)) + 1) * 127);
-		return std::tuple<u16, u16>(newX, newY);
-	}
+	const u32 DS4_INPUT_REPORT_BATTERY_OFFSET = 30;
 
 	// This tries to convert axis to give us the max even in the corners,
 	// this actually might work 'too' well, we end up actually getting diagonals of actual max/min, we need the corners still a bit rounded to match ds3
@@ -125,223 +81,431 @@ namespace
 		return (u32)(((u32)buf[0] << 0) + ((u32)buf[1] << 8) + ((u32)buf[2] << 16) + ((u32)buf[3] << 24));
 	}
 }
+
 ds4_pad_handler::ds4_pad_handler() : is_init(false)
 {
+	// Define border values
+	thumb_min = 0;
+	thumb_max = 255;
+	trigger_min = 0;
+	trigger_max = 255;
+	vibration_min = 0;
+	vibration_max = 255;
 
+	// Set this handler's type and save location
+	m_pad_config.cfg_type = "ds4";
+	m_pad_config.cfg_name = fs::get_config_dir() + "/config_ds4.yml";
+
+	// Set default button mapping
+	m_pad_config.ls_left.def  = button_list.at(DS4KeyCodes::LSXNeg);
+	m_pad_config.ls_down.def  = button_list.at(DS4KeyCodes::LSYNeg);
+	m_pad_config.ls_right.def = button_list.at(DS4KeyCodes::LSXPos);
+	m_pad_config.ls_up.def    = button_list.at(DS4KeyCodes::LSYPos);
+	m_pad_config.rs_left.def  = button_list.at(DS4KeyCodes::RSXNeg);
+	m_pad_config.rs_down.def  = button_list.at(DS4KeyCodes::RSYNeg);
+	m_pad_config.rs_right.def = button_list.at(DS4KeyCodes::RSXPos);
+	m_pad_config.rs_up.def    = button_list.at(DS4KeyCodes::RSYPos);
+	m_pad_config.start.def    = button_list.at(DS4KeyCodes::Options);
+	m_pad_config.select.def   = button_list.at(DS4KeyCodes::Share);
+	m_pad_config.ps.def       = button_list.at(DS4KeyCodes::PSButton);
+	m_pad_config.square.def   = button_list.at(DS4KeyCodes::Square);
+	m_pad_config.cross.def    = button_list.at(DS4KeyCodes::Cross);
+	m_pad_config.circle.def   = button_list.at(DS4KeyCodes::Circle);
+	m_pad_config.triangle.def = button_list.at(DS4KeyCodes::Triangle);
+	m_pad_config.left.def     = button_list.at(DS4KeyCodes::Left);
+	m_pad_config.down.def     = button_list.at(DS4KeyCodes::Down);
+	m_pad_config.right.def    = button_list.at(DS4KeyCodes::Right);
+	m_pad_config.up.def       = button_list.at(DS4KeyCodes::Up);
+	m_pad_config.r1.def       = button_list.at(DS4KeyCodes::R1);
+	m_pad_config.r2.def       = button_list.at(DS4KeyCodes::R2);
+	m_pad_config.r3.def       = button_list.at(DS4KeyCodes::R3);
+	m_pad_config.l1.def       = button_list.at(DS4KeyCodes::L1);
+	m_pad_config.l2.def       = button_list.at(DS4KeyCodes::L2);
+	m_pad_config.l3.def       = button_list.at(DS4KeyCodes::L3);
+
+	// Set default misc variables
+	m_pad_config.lstickdeadzone.def = 40;   // between 0 and 255
+	m_pad_config.rstickdeadzone.def = 40;   // between 0 and 255
+	m_pad_config.ltriggerthreshold.def = 0; // between 0 and 255
+	m_pad_config.rtriggerthreshold.def = 0; // between 0 and 255
+	m_pad_config.padsquircling.def = 8000;
+
+	// Set color value
+	m_pad_config.colorR.def = 0;
+	m_pad_config.colorG.def = 0;
+	m_pad_config.colorB.def = 20;
+
+	// apply defaults
+	m_pad_config.from_default();
+
+	// set capabilities
+	b_has_config = true;
+	b_has_rumble = true;
+	b_has_deadzones = true;
+
+	m_trigger_threshold = trigger_max / 2;
+	m_thumb_threshold = thumb_max / 2;
 }
 
-void ds4_pad_handler::ProcessData()
+void ds4_pad_handler::GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& callback)
 {
-	for (auto &bind : bindings)
+	if (!Init())
 	{
-		std::shared_ptr<DS4Device> device = bind.first;
-		auto pad = bind.second;
-		auto buf = device->padData;
+		return;
+	}
 
-		// these are added with previous value and divided to 'smooth' out the readings
-		// the ds4 seems to rapidly flicker sometimes between two values and this seems to stop that
+	// Get the DS4 Device or return if none found
+	size_t pos = padId.find("Ds4 Pad #");
 
-		u16 lx, ly;
-		//std::tie(lx, ly) = ConvertToSquarePoint(buf[1], buf[2]);
-		std::tie(lx, ly) = ConvertToSquirclePoint(buf[1], buf[2]);
-		pad->m_sticks[0].m_value = (lx + pad->m_sticks[0].m_value) / 2; // LX
-		pad->m_sticks[1].m_value = (ly + pad->m_sticks[1].m_value) / 2; // LY
+	if (pos == std::string::npos) return;
 
-		u16 rx, ry;
-		//std::tie(rx, ry) = ConvertToSquarePoint(buf[3], buf[4]);
-		std::tie(rx, ry) = ConvertToSquirclePoint(buf[3], buf[4]);
-		pad->m_sticks[2].m_value = (rx + pad->m_sticks[2].m_value) / 2; // RX
-		pad->m_sticks[3].m_value = (ry + pad->m_sticks[3].m_value) / 2; // RY
+	std::string pad_serial = padId.substr(pos + 9);
 
-																		// l2 r2
-		pad->m_buttons[0].m_pressed = buf[8] > 0;
-		pad->m_buttons[0].m_value = buf[8];
-		pad->m_buttons[1].m_pressed = buf[9] > 0;
-		pad->m_buttons[1].m_value = buf[9];
+	std::shared_ptr<DS4Device> device = nullptr;
 
-		// bleh, dpad in buffer is stored in a different state
-		u8 dpadState = buf[5] & 0xf;
-		switch (dpadState)
+	for (auto& cur_control : controllers)
+	{
+		if (pad_serial == cur_control.first)
 		{
-		case 0x08: // none pressed
-			pad->m_buttons[2].m_pressed = false;
-			pad->m_buttons[2].m_value = 0;
-			pad->m_buttons[3].m_pressed = false;
-			pad->m_buttons[3].m_value = 0;
-			pad->m_buttons[4].m_pressed = false;
-			pad->m_buttons[4].m_value = 0;
-			pad->m_buttons[5].m_pressed = false;
-			pad->m_buttons[5].m_value = 0;
+			device = cur_control.second;
 			break;
-		case 0x07: // NW...left and up
-			pad->m_buttons[2].m_pressed = true;
-			pad->m_buttons[2].m_value = 255;
-			pad->m_buttons[3].m_pressed = false;
-			pad->m_buttons[3].m_value = 0;
-			pad->m_buttons[4].m_pressed = true;
-			pad->m_buttons[4].m_value = 255;
-			pad->m_buttons[5].m_pressed = false;
-			pad->m_buttons[5].m_value = 0;
-			break;
-		case 0x06: // W..left
-			pad->m_buttons[2].m_pressed = false;
-			pad->m_buttons[2].m_value = 0;
-			pad->m_buttons[3].m_pressed = false;
-			pad->m_buttons[3].m_value = 0;
-			pad->m_buttons[4].m_pressed = true;
-			pad->m_buttons[4].m_value = 255;
-			pad->m_buttons[5].m_pressed = false;
-			pad->m_buttons[5].m_value = 0;
-			break;
-		case 0x05: // SW..left down
-			pad->m_buttons[2].m_pressed = false;
-			pad->m_buttons[2].m_value = 0;
-			pad->m_buttons[3].m_pressed = true;
-			pad->m_buttons[3].m_value = 255;
-			pad->m_buttons[4].m_pressed = true;
-			pad->m_buttons[4].m_value = 255;
-			pad->m_buttons[5].m_pressed = false;
-			pad->m_buttons[5].m_value = 0;
-			break;
-		case 0x04: // S..down
-			pad->m_buttons[2].m_pressed = false;
-			pad->m_buttons[2].m_value = 0;
-			pad->m_buttons[3].m_pressed = true;
-			pad->m_buttons[3].m_value = 255;
-			pad->m_buttons[4].m_pressed = false;
-			pad->m_buttons[4].m_value = 0;
-			pad->m_buttons[5].m_pressed = false;
-			pad->m_buttons[5].m_value = 0;
-			break;
-		case 0x03: // SE..down and right
-			pad->m_buttons[2].m_pressed = false;
-			pad->m_buttons[2].m_value = 0;
-			pad->m_buttons[3].m_pressed = true;
-			pad->m_buttons[3].m_value = 255;
-			pad->m_buttons[4].m_pressed = false;
-			pad->m_buttons[4].m_value = 0;
-			pad->m_buttons[5].m_pressed = true;
-			pad->m_buttons[5].m_value = 255;
-			break;
-		case 0x02: // E... right
-			pad->m_buttons[2].m_pressed = false;
-			pad->m_buttons[2].m_value = 0;
-			pad->m_buttons[3].m_pressed = false;
-			pad->m_buttons[3].m_value = 0;
-			pad->m_buttons[4].m_pressed = false;
-			pad->m_buttons[4].m_value = 0;
-			pad->m_buttons[5].m_pressed = true;
-			pad->m_buttons[5].m_value = 255;
-			break;
-		case 0x01: // NE.. up right
-			pad->m_buttons[2].m_pressed = true;
-			pad->m_buttons[2].m_value = 255;
-			pad->m_buttons[3].m_pressed = false;
-			pad->m_buttons[3].m_value = 0;
-			pad->m_buttons[4].m_pressed = false;
-			pad->m_buttons[4].m_value = 0;
-			pad->m_buttons[5].m_pressed = true;
-			pad->m_buttons[5].m_value = 255;
-			break;
-		case 0x00: // n.. up
-			pad->m_buttons[2].m_pressed = true;
-			pad->m_buttons[2].m_value = 255;
-			pad->m_buttons[3].m_pressed = false;
-			pad->m_buttons[3].m_value = 0;
-			pad->m_buttons[4].m_pressed = false;
-			pad->m_buttons[4].m_value = 0;
-			pad->m_buttons[5].m_pressed = false;
-			pad->m_buttons[5].m_value = 0;
-			break;
-		default:
-			fmt::throw_exception("ds4 dpad state encountered unexpected input");
 		}
+	}
 
-		// square, cross, circle, triangle
-		for (int i = 4; i < 8; ++i)
+	if (device == nullptr || device->hidDevice == nullptr) return;
+
+	// Now that we have found a device, get its status
+	DS4DataStatus status = GetRawData(device);
+
+	if (status == DS4DataStatus::ReadError)
+	{
+		// this also can mean disconnected, either way deal with it on next loop and reconnect
+		hid_close(device->hidDevice);
+		device->hidDevice = nullptr;
+		return;
+	}
+
+	if (status != DS4DataStatus::NewData) return;
+
+	// Get the current button values
+	auto data = GetButtonValues(device);
+
+	// Check for each button in our list if its corresponding (maybe remapped) button or axis was pressed.
+	// Return the new value if the button was pressed (aka. its value was bigger than 0 or the defined threshold)
+	// Use a pair to get all the legally pressed buttons and use the one with highest value (prioritize first)
+	std::pair<u16, std::string> pressed_button = { 0, "" };
+	for (const auto& button : button_list)
+	{
+		u32 keycode = button.first;
+		u16 value = data[keycode];
+
+		if (((keycode < DS4KeyCodes::L2) && (value > 0))
+		 || ((keycode == DS4KeyCodes::L2) && (value > m_trigger_threshold))
+		 || ((keycode == DS4KeyCodes::R2) && (value > m_trigger_threshold))
+		 || ((keycode >= DS4KeyCodes::LSXNeg && keycode <= DS4KeyCodes::LSYPos) && (value > m_thumb_threshold))
+		 || ((keycode >= DS4KeyCodes::RSXNeg && keycode <= DS4KeyCodes::RSYPos) && (value > m_thumb_threshold)))
 		{
-			const bool pressed = ((buf[5] & (1 << i)) != 0);
-			pad->m_buttons[6 + i - 4].m_pressed = pressed;
-			pad->m_buttons[6 + i - 4].m_value = pressed ? 255 : 0;
-		}
-
-		// L1, R1
-		const bool l1press = ((buf[6] & (1 << 0)) != 0);
-		pad->m_buttons[10].m_pressed = l1press;
-		pad->m_buttons[10].m_value = l1press ? 255 : 0;
-
-		const bool l2press = ((buf[6] & (1 << 1)) != 0);
-		pad->m_buttons[11].m_pressed = l2press;
-		pad->m_buttons[11].m_value = l2press ? 255 : 0;
-
-		// select, start, l3, r3
-		for (int i = 4; i < 8; ++i)
-		{
-			const bool pressed = ((buf[6] & (1 << i)) != 0);
-			pad->m_buttons[12 + i - 4].m_pressed = pressed;
-			pad->m_buttons[12 + i - 4].m_value = pressed ? 255 : 0;
-		}
-
-#ifdef _WIN32
-		for (int i = 6; i < 16; i++)
-		{
-			if (pad->m_buttons[i].m_pressed)
+			if (value > pressed_button.first)
 			{
-				SetThreadExecutionState(ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
-				break;
+				pressed_button = { value, button.second};
 			}
 		}
+	}
+
+	int preview_values[6] = { data[L2], data[R2], data[LSXPos] - data[LSXNeg], data[LSYPos] - data[LSYNeg], data[RSXPos] - data[RSXNeg], data[RSYPos] - data[RSYNeg] };
+
+	if (pressed_button.first > 0)
+		return callback(pressed_button.first, pressed_button.second, preview_values);
+	else
+		return callback(0, "", preview_values);
+}
+
+void ds4_pad_handler::TestVibration(const std::string& padId, u32 largeMotor, u32 smallMotor)
+{
+	if (!Init())
+	{
+		return;
+	}
+
+	size_t pos = padId.find("Ds4 Pad #");
+
+	if (pos == std::string::npos) return;
+
+	std::string pad_serial = padId.substr(pos + 9);
+
+	std::shared_ptr<DS4Device> device = nullptr;
+
+	for (auto& cur_control : controllers)
+	{
+		if (pad_serial == cur_control.first)
+		{
+			device = cur_control.second;
+			break;
+		}
+	}
+
+	if (device == nullptr || device->hidDevice == nullptr) return;
+
+	// Set the device's motor speeds to our requested values 0-255
+	device->largeVibrate = largeMotor;
+	device->smallVibrate = smallMotor;
+
+	// Start/Stop the engines :)
+	SendVibrateData(device);
+}
+
+void ds4_pad_handler::TranslateButtonPress(u64 keyCode, bool& pressed, u16& val, bool ignore_threshold)
+{
+	// Update the pad button values based on their type and thresholds.
+	// With this you can use axis or triggers as buttons or vice versa
+	switch (keyCode)
+	{
+	case DS4KeyCodes::L2:
+		pressed = val > m_pad_config.ltriggerthreshold;
+		val = pressed ? NormalizeTriggerInput(val, m_pad_config.ltriggerthreshold) : 0;
+		break;
+	case DS4KeyCodes::R2:
+		pressed = val > m_pad_config.rtriggerthreshold;
+		val = pressed ? NormalizeTriggerInput(val, m_pad_config.rtriggerthreshold) : 0;
+		break;
+	case DS4KeyCodes::LSXNeg:
+	case DS4KeyCodes::LSXPos:
+	case DS4KeyCodes::LSYNeg:
+	case DS4KeyCodes::LSYPos:
+		pressed = val > (ignore_threshold ? 0 : m_pad_config.lstickdeadzone);
+		val = pressed ? NormalizeStickInput(val, m_pad_config.lstickdeadzone, ignore_threshold) : 0;
+		break;
+	case DS4KeyCodes::RSXNeg:
+	case DS4KeyCodes::RSXPos:
+	case DS4KeyCodes::RSYNeg:
+	case DS4KeyCodes::RSYPos:
+		pressed = val > (ignore_threshold ? 0 : m_pad_config.rstickdeadzone);
+		val = pressed ? NormalizeStickInput(val, m_pad_config.rstickdeadzone, ignore_threshold) : 0;
+		break;
+	default: // normal button (should in theory also support sensitive buttons)
+		pressed = val > 0;
+		val = pressed ? val : 0;
+		break;
+	}
+}
+
+std::array<u16, ds4_pad_handler::DS4KeyCodes::KeyCodeCount> ds4_pad_handler::GetButtonValues(const std::shared_ptr<DS4Device>& device)
+{
+	std::array<u16, DS4KeyCodes::KeyCodeCount> keyBuffer;
+	auto buf = device->padData;
+
+	// Left Stick X Axis
+	keyBuffer[DS4KeyCodes::LSXNeg] = Clamp0To255((127.5f - buf[1]) * 2.0f);
+	keyBuffer[DS4KeyCodes::LSXPos] = Clamp0To255((buf[1] - 127.5f) * 2.0f);
+
+	// Left Stick Y Axis (Up is the negative for some reason)
+	keyBuffer[DS4KeyCodes::LSYNeg] = Clamp0To255((buf[2] - 127.5f) * 2.0f);
+	keyBuffer[DS4KeyCodes::LSYPos] = Clamp0To255((127.5f - buf[2]) * 2.0f);
+
+	// Right Stick X Axis
+	keyBuffer[DS4KeyCodes::RSXNeg] = Clamp0To255((127.5f - buf[3]) * 2.0f);
+	keyBuffer[DS4KeyCodes::RSXPos] = Clamp0To255((buf[3] - 127.5f) * 2.0f);
+
+	// Right Stick Y Axis (Up is the negative for some reason)
+	keyBuffer[DS4KeyCodes::RSYNeg] = Clamp0To255((buf[4] - 127.5f) * 2.0f);
+	keyBuffer[DS4KeyCodes::RSYPos] = Clamp0To255((127.5f - buf[4]) * 2.0f);
+
+	// bleh, dpad in buffer is stored in a different state
+	u8 dpadState = buf[5] & 0xf;
+	switch (dpadState)
+	{
+	case 0x08: // none pressed
+		keyBuffer[DS4KeyCodes::Up] = 0;
+		keyBuffer[DS4KeyCodes::Down] = 0;
+		keyBuffer[DS4KeyCodes::Left] = 0;
+		keyBuffer[DS4KeyCodes::Right] = 0;
+		break;
+	case 0x07: // NW...left and up
+		keyBuffer[DS4KeyCodes::Up] = 255;
+		keyBuffer[DS4KeyCodes::Down] = 0;
+		keyBuffer[DS4KeyCodes::Left] = 255;
+		keyBuffer[DS4KeyCodes::Right] = 0;
+		break;
+	case 0x06: // W..left
+		keyBuffer[DS4KeyCodes::Up] = 0;
+		keyBuffer[DS4KeyCodes::Down] = 0;
+		keyBuffer[DS4KeyCodes::Left] = 255;
+		keyBuffer[DS4KeyCodes::Right] = 0;
+		break;
+	case 0x05: // SW..left down
+		keyBuffer[DS4KeyCodes::Up] = 0;
+		keyBuffer[DS4KeyCodes::Down] = 255;
+		keyBuffer[DS4KeyCodes::Left] = 255;
+		keyBuffer[DS4KeyCodes::Right] = 0;
+		break;
+	case 0x04: // S..down
+		keyBuffer[DS4KeyCodes::Up] = 0;
+		keyBuffer[DS4KeyCodes::Down] = 255;
+		keyBuffer[DS4KeyCodes::Left] = 0;
+		keyBuffer[DS4KeyCodes::Right] = 0;
+		break;
+	case 0x03: // SE..down and right
+		keyBuffer[DS4KeyCodes::Up] = 0;
+		keyBuffer[DS4KeyCodes::Down] = 255;
+		keyBuffer[DS4KeyCodes::Left] = 0;
+		keyBuffer[DS4KeyCodes::Right] = 255;
+		break;
+	case 0x02: // E... right
+		keyBuffer[DS4KeyCodes::Up] = 0;
+		keyBuffer[DS4KeyCodes::Down] = 0;
+		keyBuffer[DS4KeyCodes::Left] = 0;
+		keyBuffer[DS4KeyCodes::Right] = 255;
+		break;
+	case 0x01: // NE.. up right
+		keyBuffer[DS4KeyCodes::Up] = 255;
+		keyBuffer[DS4KeyCodes::Down] = 0;
+		keyBuffer[DS4KeyCodes::Left] = 0;
+		keyBuffer[DS4KeyCodes::Right] = 255;
+		break;
+	case 0x00: // n.. up
+		keyBuffer[DS4KeyCodes::Up] = 255;
+		keyBuffer[DS4KeyCodes::Down] = 0;
+		keyBuffer[DS4KeyCodes::Left] = 0;
+		keyBuffer[DS4KeyCodes::Right] = 0;
+		break;
+	default:
+		fmt::throw_exception("ds4 dpad state encountered unexpected input");
+	}
+
+	// square, cross, circle, triangle
+	keyBuffer[DS4KeyCodes::Square] =   ((buf[5] & (1 << 4)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::Cross] =    ((buf[5] & (1 << 5)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::Circle] =   ((buf[5] & (1 << 6)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::Triangle] = ((buf[5] & (1 << 7)) != 0) ? 255 : 0;
+
+	// L1, R1, L2, L3, select, start, L3, L3
+	keyBuffer[DS4KeyCodes::L1]      = ((buf[6] & (1 << 0)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::R1]      = ((buf[6] & (1 << 1)) != 0) ? 255 : 0;
+	//keyBuffer[DS4KeyCodes::L2But]   = ((buf[6] & (1 << 2)) != 0) ? 255 : 0;
+	//keyBuffer[DS4KeyCodes::R2But]   = ((buf[6] & (1 << 3)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::Share]   = ((buf[6] & (1 << 4)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::Options] = ((buf[6] & (1 << 5)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::L3]      = ((buf[6] & (1 << 6)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::R3]      = ((buf[6] & (1 << 7)) != 0) ? 255 : 0;
+
+	// PS Button, Touch Button
+	keyBuffer[DS4KeyCodes::PSButton] = ((buf[7] & (1 << 0)) != 0) ? 255 : 0;
+	keyBuffer[DS4KeyCodes::TouchPad] = ((buf[7] & (1 << 1)) != 0) ? 255 : 0;
+
+	// L2, R2
+	keyBuffer[DS4KeyCodes::L2] = buf[8];
+	keyBuffer[DS4KeyCodes::R2] = buf[9];
+
+	return keyBuffer;
+}
+
+void ds4_pad_handler::ProcessDataToPad(const std::shared_ptr<DS4Device>& device, const std::shared_ptr<Pad>& pad)
+{
+	pad->m_battery_level = device->batteryLevel;
+	pad->m_cable_state = device->cableState;
+
+	auto buf = device->padData;
+
+	auto button_values = GetButtonValues(device);
+
+	// Translate any corresponding keycodes to our normal DS3 buttons and triggers
+	for (auto & btn : pad->m_buttons)
+	{
+		btn.m_value = button_values[btn.m_keyCode];
+		TranslateButtonPress(btn.m_keyCode, btn.m_pressed, btn.m_value);
+	}
+
+#ifdef _WIN32
+	for (int i = 6; i < 16; i++)
+	{
+		if (pad->m_buttons[i].m_pressed)
+		{
+			SetThreadExecutionState(ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
+			break;
+		}
+	}
 #endif
 
-		// these values come already calibrated from our ds4Thread,
-		// all we need to do is convert to ds3 range
+	// used to get the absolute value of an axis
+	float stick_val[4];
 
-		// accel
-		f32 accelX = (((s16)((u16)(buf[20] << 8) | buf[19])) / static_cast<f32>(DS4_ACC_RES_PER_G)) * -1;
-		f32 accelY = (((s16)((u16)(buf[22] << 8) | buf[21])) / static_cast<f32>(DS4_ACC_RES_PER_G)) * -1;
-		f32 accelZ = (((s16)((u16)(buf[24] << 8) | buf[23])) / static_cast<f32>(DS4_ACC_RES_PER_G)) * -1;
-
-		// now just use formula from ds3
-		accelX = accelX * 113 + 512;
-		accelY = accelY * 113 + 512;
-		accelZ = accelZ * 113 + 512;
-
-		pad->m_sensors[0].m_value = Clamp0To1023(accelX);
-		pad->m_sensors[1].m_value = Clamp0To1023(accelY);
-		pad->m_sensors[2].m_value = Clamp0To1023(accelZ);
-
-		// gyroX is yaw, which is all that we need
-		f32 gyroX = (((s16)((u16)(buf[16] << 8) | buf[15])) / static_cast<f32>(DS4_GYRO_RES_PER_DEG_S)) * -1;
-		//const int gyroY = ((u16)(buf[14] << 8) | buf[13]) / 256;
-		//const int gyroZ = ((u16)(buf[18] << 8) | buf[17]) / 256;
-
-		// convert to ds3
-		gyroX = gyroX * (123.f / 90.f) + 512;
-
-		pad->m_sensors[3].m_value = Clamp0To1023(gyroX);
-	}
-}
-
-void ds4_pad_handler::UpdateRumble()
-{
-	// todo: give unique identifier to this instead of port
-	for (auto &bind : bindings)
+	// Translate any corresponding keycodes to our two sticks. (ignoring thresholds for now)
+	for (int i = 0; i < static_cast<int>(pad->m_sticks.size()); i++)
 	{
-		std::shared_ptr<DS4Device> device = bind.first;
-		auto thepad = bind.second;
+		bool pressed;
 
-		device->newVibrateData = device->newVibrateData || device->largeVibrate != thepad->m_vibrateMotors[0].m_value || device->smallVibrate != (thepad->m_vibrateMotors[1].m_value ? 255 : 0);
-		device->largeVibrate = thepad->m_vibrateMotors[0].m_value;
-		device->smallVibrate = (thepad->m_vibrateMotors[1].m_value ? 255 : 0);
+		// m_keyCodeMin is the mapped key for left or down
+		u32 key_min = pad->m_sticks[i].m_keyCodeMin;
+		u16 val_min = button_values[key_min];
+		TranslateButtonPress(key_min, pressed, val_min, true);
+
+		// m_keyCodeMax is the mapped key for right or up
+		u32 key_max = pad->m_sticks[i].m_keyCodeMax;
+		u16 val_max = button_values[key_max];
+		TranslateButtonPress(key_max, pressed, val_max, true);
+
+		// cancel out opposing values and get the resulting difference
+		stick_val[i] = val_max - val_min;
 	}
+
+	u16 lx, ly, rx, ry;
+
+	// Normalize our two stick's axis based on the thresholds
+	std::tie(lx, ly) = NormalizeStickDeadzone(stick_val[0], stick_val[1], m_pad_config.lstickdeadzone);
+	std::tie(rx, ry) = NormalizeStickDeadzone(stick_val[2], stick_val[3], m_pad_config.rstickdeadzone);
+
+	if (m_pad_config.padsquircling != 0)
+	{
+		std::tie(lx, ly) = ConvertToSquirclePoint(lx, ly, m_pad_config.padsquircling);
+		std::tie(rx, ry) = ConvertToSquirclePoint(rx, ry, m_pad_config.padsquircling);
+	}
+
+	ly = 255 - ly;
+	ry = 255 - ry;
+
+	// these are added with previous value and divided to 'smooth' out the readings
+	// the ds4 seems to rapidly flicker sometimes between two values and this seems to stop that
+
+	pad->m_sticks[0].m_value = (lx + pad->m_sticks[0].m_value) / 2; // LX
+	pad->m_sticks[1].m_value = (ly + pad->m_sticks[1].m_value) / 2; // LY
+	pad->m_sticks[2].m_value = (rx + pad->m_sticks[2].m_value) / 2; // RX
+	pad->m_sticks[3].m_value = (ry + pad->m_sticks[3].m_value) / 2; // RY
+
+	// these values come already calibrated from our ds4Thread,
+	// all we need to do is convert to ds3 range
+
+	// accel
+	f32 accelX = (((s16)((u16)(buf[20] << 8) | buf[19])) / static_cast<f32>(DS4_ACC_RES_PER_G)) * -1;
+	f32 accelY = (((s16)((u16)(buf[22] << 8) | buf[21])) / static_cast<f32>(DS4_ACC_RES_PER_G)) * -1;
+	f32 accelZ = (((s16)((u16)(buf[24] << 8) | buf[23])) / static_cast<f32>(DS4_ACC_RES_PER_G)) * -1;
+
+	// now just use formula from ds3
+	accelX = accelX * 113 + 512;
+	accelY = accelY * 113 + 512;
+	accelZ = accelZ * 113 + 512;
+
+	pad->m_sensors[0].m_value = Clamp0To1023(accelX);
+	pad->m_sensors[1].m_value = Clamp0To1023(accelY);
+	pad->m_sensors[2].m_value = Clamp0To1023(accelZ);
+
+	// gyroX is yaw, which is all that we need
+	f32 gyroX = (((s16)((u16)(buf[16] << 8) | buf[15])) / static_cast<f32>(DS4_GYRO_RES_PER_DEG_S)) * -1;
+	//const int gyroY = ((u16)(buf[14] << 8) | buf[13]) / 256;
+	//const int gyroZ = ((u16)(buf[18] << 8) | buf[17]) / 256;
+
+	// convert to ds3
+	gyroX = gyroX * (123.f / 90.f) + 512;
+
+	pad->m_sensors[3].m_value = Clamp0To1023(gyroX);
 }
 
-bool ds4_pad_handler::GetCalibrationData(std::shared_ptr<DS4Device> ds4Dev)
+bool ds4_pad_handler::GetCalibrationData(const std::shared_ptr<DS4Device>& ds4Dev)
 {
 	std::array<u8, 64> buf;
 	if (ds4Dev->btCon)
 	{
-		for (int tries = 0; tries < 3; ++tries) {
+		for (int tries = 0; tries < 3; ++tries)
+		{
 			buf[0] = 0x05;
 			if (hid_get_feature_report(ds4Dev->hidDevice, buf.data(), DS4_FEATURE_REPORT_0x05_SIZE) <= 0)
 				return false;
@@ -473,12 +637,21 @@ ds4_pad_handler::~ds4_pad_handler()
 	for (auto& controller : controllers)
 	{
 		if (controller.second->hidDevice)
+		{
+			// Disable blinking and vibration
+			controller.second->smallVibrate = 0;
+			controller.second->largeVibrate = 0;
+			controller.second->led_delay_on = 0;
+			controller.second->led_delay_off = 0;
+			SendVibrateData(controller.second);
+
 			hid_close(controller.second->hidDevice);
+		}
 	}
 	hid_exit();
 }
 
-void ds4_pad_handler::SendVibrateData(const std::shared_ptr<DS4Device> device)
+int ds4_pad_handler::SendVibrateData(const std::shared_ptr<DS4Device>& device)
 {
 	std::array<u8, 78> outputBuf{0};
 	// write rumble state
@@ -489,9 +662,15 @@ void ds4_pad_handler::SendVibrateData(const std::shared_ptr<DS4Device> device)
 		outputBuf[3] = 0x07;
 		outputBuf[6] = device->smallVibrate;
 		outputBuf[7] = device->largeVibrate;
-		outputBuf[8] = 0x00; // red
-		outputBuf[9] = 0x00; // green
-		outputBuf[10] = 0xff; // blue
+		outputBuf[8] = m_pad_config.colorR; // red
+		outputBuf[9] = m_pad_config.colorG; // green
+		outputBuf[10] = m_pad_config.colorB; // blue
+
+		// alternating blink states with values 0-255: only setting both to zero disables blinking
+		// 255 is roughly 2 seconds, so setting both values to 255 results in a 4 second interval
+		// using something like (0,10) will heavily blink, while using (0, 255) will be slow. you catch the drift
+		outputBuf[9] = device->led_delay_on;
+		outputBuf[10] = device->led_delay_off;
 
 		const u8 btHdr = 0xA2;
 		const u32 crcHdr = CRCPP::CRC::Calculate(&btHdr, 1, crcTable);
@@ -502,7 +681,7 @@ void ds4_pad_handler::SendVibrateData(const std::shared_ptr<DS4Device> device)
 		outputBuf[76] = (crcCalc >> 16) & 0xFF;
 		outputBuf[77] = (crcCalc >> 24) & 0xFF;
 
-		hid_write_control(device->hidDevice, outputBuf.data(), DS4_OUTPUT_REPORT_0x11_SIZE);
+		return hid_write_control(device->hidDevice, outputBuf.data(), DS4_OUTPUT_REPORT_0x11_SIZE);
 	}
 	else
 	{
@@ -510,11 +689,13 @@ void ds4_pad_handler::SendVibrateData(const std::shared_ptr<DS4Device> device)
 		outputBuf[1] = 0x07;
 		outputBuf[4] = device->smallVibrate;
 		outputBuf[5] = device->largeVibrate;
-		outputBuf[6] = 0x00; // red
-		outputBuf[7] = 0x00; // green
-		outputBuf[8] = 0xff; // blue
+		outputBuf[6] = m_pad_config.colorR; // red
+		outputBuf[7] = m_pad_config.colorG; // green
+		outputBuf[8] = m_pad_config.colorB; // blue
+		outputBuf[9] = device->led_delay_on;
+		outputBuf[10] = device->led_delay_off;
 
-		hid_write(device->hidDevice, outputBuf.data(), DS4_OUTPUT_REPORT_0x05_SIZE);
+		return hid_write(device->hidDevice, outputBuf.data(), DS4_OUTPUT_REPORT_0x05_SIZE);
 	}
 }
 
@@ -550,6 +731,9 @@ bool ds4_pad_handler::Init()
 	else
 		LOG_SUCCESS(HLE, "[DS4] Controllers found: %d", controllers.size());
 
+	m_pad_config.load();
+	if (!m_pad_config.exist()) m_pad_config.save();
+
 	is_init = true;
 	return true;
 }
@@ -589,7 +773,10 @@ bool ds4_pad_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::strin
 
 	if (device_id == nullptr) return false;
 
-	pad->Init(
+	m_pad_config.load();
+
+	pad->Init
+	(
 		CELL_PAD_STATUS_CONNECTED | CELL_PAD_STATUS_ASSIGN_CHANGES,
 		CELL_PAD_SETTING_PRESS_OFF | CELL_PAD_SETTING_SENSOR_OFF,
 		CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE | CELL_PAD_CAPABILITY_HP_ANALOG_STICK | CELL_PAD_CAPABILITY_ACTUATOR | CELL_PAD_CAPABILITY_SENSOR_MODE,
@@ -597,28 +784,23 @@ bool ds4_pad_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::strin
 	);
 
 	// 'keycode' here is just 0 as we have to manually calculate this
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_L2);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_R2);
-
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, 0, CELL_PAD_CTRL_UP);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, 0, CELL_PAD_CTRL_DOWN);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, 0, CELL_PAD_CTRL_LEFT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, 0, CELL_PAD_CTRL_RIGHT);
-
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_SQUARE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_CROSS);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_CIRCLE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_TRIANGLE);
-
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_L1);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_R1);
-
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, 0, CELL_PAD_CTRL_SELECT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, 0, CELL_PAD_CTRL_START);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, 0, CELL_PAD_CTRL_L3);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, 0, CELL_PAD_CTRL_R3);
-
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.l2),       CELL_PAD_CTRL_L2);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.r2),       CELL_PAD_CTRL_R2);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.up),       CELL_PAD_CTRL_UP);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.down),     CELL_PAD_CTRL_DOWN);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.left),     CELL_PAD_CTRL_LEFT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.right),    CELL_PAD_CTRL_RIGHT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.square),   CELL_PAD_CTRL_SQUARE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.cross),    CELL_PAD_CTRL_CROSS);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.circle),   CELL_PAD_CTRL_CIRCLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.triangle), CELL_PAD_CTRL_TRIANGLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.l1),       CELL_PAD_CTRL_L1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.r1),       CELL_PAD_CTRL_R1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.select),   CELL_PAD_CTRL_SELECT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.start),    CELL_PAD_CTRL_START);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.l3),       CELL_PAD_CTRL_L3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.r3),       CELL_PAD_CTRL_R3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.ps),       0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
 	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x0); // Reserved
 
 	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_X, 512);
@@ -626,10 +808,10 @@ bool ds4_pad_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::strin
 	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Z, 512);
 	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_G, 512);
 
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, 0, 0);
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X,  FindKeyCode(button_list, m_pad_config.ls_left), FindKeyCode(button_list, m_pad_config.ls_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y,  FindKeyCode(button_list, m_pad_config.ls_down), FindKeyCode(button_list, m_pad_config.ls_up));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, FindKeyCode(button_list, m_pad_config.rs_left), FindKeyCode(button_list, m_pad_config.rs_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, FindKeyCode(button_list, m_pad_config.rs_down), FindKeyCode(button_list, m_pad_config.rs_up));
 
 	pad->m_vibrateMotors.emplace_back(true, 0);
 	pad->m_vibrateMotors.emplace_back(false, 0);
@@ -641,10 +823,6 @@ bool ds4_pad_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::strin
 
 void ds4_pad_handler::ThreadProc()
 {
-	UpdateRumble();
-
-	std::array<u8, 78> buf{};
-
 	for (auto &bind : bindings)
 	{
 		std::shared_ptr<DS4Device> device = bind.first;
@@ -670,76 +848,135 @@ void ds4_pad_handler::ThreadProc()
 			}
 		}
 
-		const int res = hid_read(device->hidDevice, buf.data(), device->btCon ? 78 : 64);
-		if (res == -1)
+		DS4DataStatus status = GetRawData(device);
+
+		if (status == DS4DataStatus::ReadError)
 		{
-			// looks like controller disconnected or read error, deal with it on next loop
+			// this also can mean disconnected, either way deal with it on next loop and reconnect
 			hid_close(device->hidDevice);
 			device->hidDevice = nullptr;
 			continue;
 		}
 
+		// Attempt to send rumble no matter what 
+		int idx_l = m_pad_config.switch_vibration_motors ? 1 : 0;
+		int idx_s = m_pad_config.switch_vibration_motors ? 0 : 1;
+
+		int speed_large = m_pad_config.enable_vibration_motor_large ? thepad->m_vibrateMotors[idx_l].m_value : vibration_min;
+		int speed_small = m_pad_config.enable_vibration_motor_small ? thepad->m_vibrateMotors[idx_s].m_value : vibration_min;
+
+		bool wireless = device->cableState < 1;
+		bool lowBattery = device->batteryLevel < 2;
+		bool isBlinking = device->led_delay_on > 0 || device->led_delay_off > 0;
+		bool newBlinkData = false;
+
+		// we are now wired or have okay battery level -> stop blinking
+		if (isBlinking && !(wireless && lowBattery))
+		{
+			device->led_delay_on = 0;
+			device->led_delay_off = 0;
+			newBlinkData = true;
+		}
+		// we are now wireless and low on battery -> blink
+		if (!isBlinking && wireless && lowBattery)
+		{
+			device->led_delay_on = 100;
+			device->led_delay_off = 100;
+			newBlinkData = true;
+		}
+
+		device->newVibrateData = device->newVibrateData || device->largeVibrate != speed_large || device->smallVibrate != speed_small || newBlinkData;
+
+		device->largeVibrate = speed_large;
+		device->smallVibrate = speed_small;
+
 		if (device->newVibrateData)
 		{
-			SendVibrateData(device);
-			device->newVibrateData = false;
+			if (SendVibrateData(device) >= 0)
+			{
+				device->newVibrateData = false;
+			}
 		}
 
 		// no data? keep going
-		if (res == 0)
+		if (status == DS4DataStatus::NoNewData)
 			continue;
 
-		// bt controller sends this until 0x02 feature report is sent back (happens on controller init/restart)
-		if (device->btCon && buf[0] == 0x1)
-		{
-			// tells controller to send 0x11 reports
-			std::array<u8, 64> buf_error{};
-			buf_error[0] = 0x2;
-			hid_get_feature_report(device->hidDevice, buf_error.data(), buf_error.size());
-			continue;
-		}
+		else if (status == DS4DataStatus::NewData)
+			ProcessDataToPad(device, thepad);
+	}
+}
 
-		int offset = 0;
-		// check report and set offset
-		if (device->btCon && buf[0] == 0x11 && res == 78)
-		{
-			offset = 2;
+ds4_pad_handler::DS4DataStatus ds4_pad_handler::GetRawData(const std::shared_ptr<DS4Device>& device)
+{
+	std::array<u8, 78> buf{};
 
-			const u8 btHdr = 0xA1;
-			const u32 crcHdr = CRCPP::CRC::Calculate(&btHdr, 1, crcTable);
-			const u32 crcCalc = CRCPP::CRC::Calculate(buf.data(), (DS4_INPUT_REPORT_0x11_SIZE - 4), crcTable, crcHdr);
-			const u32 crcReported = GetU32LEData(&buf[DS4_INPUT_REPORT_0x11_SIZE - 4]);
-			if (crcCalc != crcReported) {
-				LOG_WARNING(HLE, "[DS4] Data packet CRC check failed, ignoring! Received 0x%x, Expected 0x%x", crcReported, crcCalc);
-				continue;
-			}
-
-		}
-		else if (!device->btCon && buf[0] == 0x01 && res == 64)
-		{
-			// Ds4 Dongle uses this bit to actually report whether a controller is connected
-			bool connected = (buf[31] & 0x04) ? false : true;
-			if (connected && !device->hasCalibData)
-				device->hasCalibData = GetCalibrationData(device);
-
-			offset = 0;
-		}
-		else
-			continue;
-
-		if (device->hasCalibData)
-		{
-			int calibOffset = offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
-			for (int i = 0; i < DS4CalibIndex::COUNT; ++i)
-			{
-				const s16 rawValue = GetS16LEData(&buf[calibOffset]);
-				const s16 calValue = ApplyCalibration(rawValue, device->calibData[i]);
-				buf[calibOffset++] = ((u16)calValue >> 0) & 0xFF;
-				buf[calibOffset++] = ((u16)calValue >> 8) & 0xFF;
-			}
-		}
-		memcpy(device->padData.data(), &buf[offset], 64);
+	const int res = hid_read(device->hidDevice, buf.data(), device->btCon ? 78 : 64);
+	if (res == -1)
+	{
+		// looks like controller disconnected or read error
+		return DS4DataStatus::ReadError;
 	}
 
-	ProcessData();
+	// no data? keep going
+	if (res == 0)
+		return DS4DataStatus::NoNewData;
+
+	// bt controller sends this until 0x02 feature report is sent back (happens on controller init/restart)
+	if (device->btCon && buf[0] == 0x1)
+	{
+		// tells controller to send 0x11 reports
+		std::array<u8, 64> buf_error{};
+		buf_error[0] = 0x2;
+		hid_get_feature_report(device->hidDevice, buf_error.data(), buf_error.size());
+		return DS4DataStatus::NoNewData;
+	}
+
+	int offset = 0;
+	// check report and set offset
+	if (device->btCon && buf[0] == 0x11 && res == 78)
+	{
+		offset = 2;
+
+		const u8 btHdr = 0xA1;
+		const u32 crcHdr = CRCPP::CRC::Calculate(&btHdr, 1, crcTable);
+		const u32 crcCalc = CRCPP::CRC::Calculate(buf.data(), (DS4_INPUT_REPORT_0x11_SIZE - 4), crcTable, crcHdr);
+		const u32 crcReported = GetU32LEData(&buf[DS4_INPUT_REPORT_0x11_SIZE - 4]);
+		if (crcCalc != crcReported)
+		{
+			LOG_WARNING(HLE, "[DS4] Data packet CRC check failed, ignoring! Received 0x%x, Expected 0x%x", crcReported, crcCalc);
+			return DS4DataStatus::NoNewData;
+		}
+
+	}
+	else if (!device->btCon && buf[0] == 0x01 && res == 64)
+	{
+		// Ds4 Dongle uses this bit to actually report whether a controller is connected
+		bool connected = (buf[31] & 0x04) ? false : true;
+		if (connected && !device->hasCalibData)
+			device->hasCalibData = GetCalibrationData(device);
+
+		offset = 0;
+	}
+	else
+		return DS4DataStatus::NoNewData;
+
+	int battery_offset = offset + DS4_INPUT_REPORT_BATTERY_OFFSET;
+	device->cableState = (buf[battery_offset] >> 4) & 0x01;
+	device->batteryLevel = buf[battery_offset] & 0x0F;
+
+	if (device->hasCalibData)
+	{
+		int calibOffset = offset + DS4_INPUT_REPORT_GYRO_X_OFFSET;
+		for (int i = 0; i < DS4CalibIndex::COUNT; ++i)
+		{
+			const s16 rawValue = GetS16LEData(&buf[calibOffset]);
+			const s16 calValue = ApplyCalibration(rawValue, device->calibData[i]);
+			buf[calibOffset++] = ((u16)calValue >> 0) & 0xFF;
+			buf[calibOffset++] = ((u16)calValue >> 8) & 0xFF;
+		}
+	}
+	memcpy(device->padData.data(), &buf[offset], 64);
+
+	return DS4DataStatus::NewData;
 }
diff --git a/rpcs3/ds4_pad_handler.h b/rpcs3/ds4_pad_handler.h
index 2d970b3ecc..5c0e0d0ba5 100644
--- a/rpcs3/ds4_pad_handler.h
+++ b/rpcs3/ds4_pad_handler.h
@@ -7,10 +7,77 @@
 #include <limits>
 #include <unordered_map>
 
-const u32 MAX_GAMEPADS = 7;
-
 class ds4_pad_handler final : public PadHandlerBase
 {
+	// These are all the possible buttons on a standard DS4 controller
+	// The touchpad is restricted to its button for now (or forever?)
+	enum DS4KeyCodes
+	{
+		Triangle = 0,
+		Circle,
+		Cross,
+		Square,
+		Left,
+		Right,
+		Up,
+		Down,
+		R1,
+		//R2But,
+		R3,
+		L1,
+		//L2But,
+		L3,
+		Share,
+		Options,
+		PSButton,
+		TouchPad,
+
+		L2,
+		R2,
+
+		LSXNeg,
+		LSXPos,
+		LSYNeg,
+		LSYPos,
+		RSXNeg,
+		RSXPos,
+		RSYNeg,
+		RSYPos,
+
+		KeyCodeCount
+	};
+
+	// Unique names for the config files and our pad settings dialog
+	const std::unordered_map<u32, std::string> button_list =
+	{
+		{ DS4KeyCodes::Triangle, "Triangle" },
+		{ DS4KeyCodes::Circle,   "Circle" },
+		{ DS4KeyCodes::Cross,    "Cross" },
+		{ DS4KeyCodes::Square,   "Square" },
+		{ DS4KeyCodes::Left,     "Left" },
+		{ DS4KeyCodes::Right,    "Right" },
+		{ DS4KeyCodes::Up,       "Up" },
+		{ DS4KeyCodes::Down,     "Down" },
+		{ DS4KeyCodes::R1,       "R1" },
+		{ DS4KeyCodes::R2,       "R2" },
+		{ DS4KeyCodes::R3,       "R3" },
+		{ DS4KeyCodes::Options,  "Options" },
+		{ DS4KeyCodes::Share,    "Share" },
+		{ DS4KeyCodes::PSButton, "PS Button" },
+		{ DS4KeyCodes::TouchPad, "Touch Pad" },
+		{ DS4KeyCodes::L1,       "L1" },
+		{ DS4KeyCodes::L2,       "L2" },
+		{ DS4KeyCodes::L3,       "L3" },
+		{ DS4KeyCodes::LSXNeg,   "LS X-" },
+		{ DS4KeyCodes::LSXPos,   "LS X+" },
+		{ DS4KeyCodes::LSYPos,   "LS Y+" },
+		{ DS4KeyCodes::LSYNeg,   "LS Y-" },
+		{ DS4KeyCodes::RSXNeg,   "RS X-" },
+		{ DS4KeyCodes::RSXPos,   "RS X+" },
+		{ DS4KeyCodes::RSYPos,   "RS Y+" },
+		{ DS4KeyCodes::RSYNeg,   "RS Y-" }
+	};
+
 	enum DS4CalibIndex
 	{
 		// gyro
@@ -32,6 +99,13 @@ class ds4_pad_handler final : public PadHandlerBase
 		s32 sensDenom;
 	};
 
+	enum class DS4DataStatus
+	{
+		NewData,
+		NoNewData,
+		ReadError,
+	};
+
 	struct DS4Device
 	{
 		hid_device* hidDevice{ nullptr };
@@ -43,6 +117,10 @@ class ds4_pad_handler final : public PadHandlerBase
 		u8 largeVibrate{ 0 };
 		u8 smallVibrate{ 0 };
 		std::array<u8, 64> padData;
+		u8 batteryLevel{ 0 };
+		u8 cableState{ 0 };
+		u8 led_delay_on{ 0 };
+		u8 led_delay_off{ 0 };
 	};
 
 	const u16 DS4_VID = 0x054C;
@@ -63,6 +141,8 @@ public:
 	std::vector<std::string> ListDevices() override;
 	bool bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device) override;
 	void ThreadProc() override;
+	void GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& buttonCallback) override;
+	void TestVibration(const std::string& padId, u32 largeMotor, u32 smallMotor) override;
 
 private:
 	bool is_init;
@@ -73,11 +153,16 @@ private:
 	std::vector<std::pair<std::shared_ptr<DS4Device>, std::shared_ptr<Pad>>> bindings;
 
 private:
-	void ProcessData();
-	void UpdateRumble();
-	bool GetCalibrationData(std::shared_ptr<DS4Device> ds4Device);
+	void TranslateButtonPress(u64 keyCode, bool& pressed, u16& val, bool ignore_threshold = false) override;
+	void ProcessDataToPad(const std::shared_ptr<DS4Device>& ds4Device, const std::shared_ptr<Pad>& pad);
+	// Copies data into padData if status is NewData, otherwise buffer is untouched
+	DS4DataStatus GetRawData(const std::shared_ptr<DS4Device>& ds4Device);
+	// This function gets us usuable buffer from the rawbuffer of padData
+	// Todo: this currently only handles 'buttons' and not axis or sensors for the time being
+	std::array<u16, DS4KeyCodes::KeyCodeCount> GetButtonValues(const std::shared_ptr<DS4Device>& ds4Device);
+	bool GetCalibrationData(const std::shared_ptr<DS4Device>& ds4Device);
 	void CheckAddDevice(hid_device* hidDevice, hid_device_info* hidDevInfo);
-	void SendVibrateData(const std::shared_ptr<DS4Device> device);
+	int SendVibrateData(const std::shared_ptr<DS4Device>& device);
 	inline s16 ApplyCalibration(s32 rawValue, const DS4CalibData& calibData)
 	{
 		const s32 biased = rawValue - calibData.bias;
diff --git a/rpcs3/evdev_joystick_handler.cpp b/rpcs3/evdev_joystick_handler.cpp
index 0e7e33f95f..582bb3d089 100644
--- a/rpcs3/evdev_joystick_handler.cpp
+++ b/rpcs3/evdev_joystick_handler.cpp
@@ -1,5 +1,9 @@
+// This makes debugging on windows less painful
+//#define HAVE_LIBEVDEV
+
 #ifdef HAVE_LIBEVDEV
 
+#include "rpcs3qt/pad_settings_dialog.h"
 #include "evdev_joystick_handler.h"
 #include "Utilities/Thread.h"
 #include "Utilities/Log.h"
@@ -13,560 +17,711 @@
 #include <cstdio>
 #include <cmath>
 
-evdev_joystick_config g_evdev_joystick_config;
+evdev_joystick_handler::evdev_joystick_handler()
+{
+	// Define border values
+	thumb_min = 0;
+	thumb_max = 255;
+	trigger_min = 0;
+	trigger_max = 255;
+	vibration_min = 0;
+	vibration_max = 65535;
 
-evdev_joystick_handler::evdev_joystick_handler() {}
+	// Set this handler's type and save location
+	m_pad_config.cfg_type = "evdev";
+	m_pad_config.cfg_name = fs::get_config_dir() + "/config_evdev.yml";
 
-evdev_joystick_handler::~evdev_joystick_handler() { Close(); }
+	// Set default button mapping
+	m_pad_config.ls_left.def  = rev_axis_list.at(ABS_X);
+	m_pad_config.ls_down.def  = axis_list.at(ABS_Y);
+	m_pad_config.ls_right.def = axis_list.at(ABS_X);
+	m_pad_config.ls_up.def    = rev_axis_list.at(ABS_Y);
+	m_pad_config.rs_left.def  = rev_axis_list.at(ABS_RX);
+	m_pad_config.rs_down.def  = axis_list.at(ABS_RY);
+	m_pad_config.rs_right.def = axis_list.at(ABS_RX);
+	m_pad_config.rs_up.def    = rev_axis_list.at(ABS_RY);
+	m_pad_config.start.def    = button_list.at(BTN_START);
+	m_pad_config.select.def   = button_list.at(BTN_SELECT);
+	m_pad_config.ps.def       = button_list.at(BTN_MODE);
+	m_pad_config.square.def   = button_list.at(BTN_X);
+	m_pad_config.cross.def    = button_list.at(BTN_A);
+	m_pad_config.circle.def   = button_list.at(BTN_B);
+	m_pad_config.triangle.def = button_list.at(BTN_Y);
+	m_pad_config.left.def     = rev_axis_list.at(ABS_HAT0X);
+	m_pad_config.down.def     = axis_list.at(ABS_HAT0Y);
+	m_pad_config.right.def    = axis_list.at(ABS_HAT0X);
+	m_pad_config.up.def       = rev_axis_list.at(ABS_HAT0Y);
+	m_pad_config.r1.def       = button_list.at(BTN_TR);
+	m_pad_config.r2.def       = axis_list.at(ABS_RZ);
+	m_pad_config.r3.def       = button_list.at(BTN_THUMBR);
+	m_pad_config.l1.def       = button_list.at(BTN_TL);
+	m_pad_config.l2.def       = axis_list.at(ABS_Z);
+	m_pad_config.l3.def       = button_list.at(BTN_THUMBL);
+
+	// Set default misc variables
+	m_pad_config.lstickdeadzone.def = 30;   // between 0 and 255
+	m_pad_config.rstickdeadzone.def = 30;   // between 0 and 255
+	m_pad_config.ltriggerthreshold.def = 0; // between 0 and 255
+	m_pad_config.rtriggerthreshold.def = 0; // between 0 and 255
+	m_pad_config.padsquircling.def = 5000;
+
+	// apply defaults
+	m_pad_config.from_default();
+
+	// set capabilities
+	b_has_config = true;
+	b_has_rumble = false;
+	b_has_deadzones = true;
+
+	m_trigger_threshold = trigger_max / 2;
+	m_thumb_threshold = thumb_max / 2;
+}
+
+evdev_joystick_handler::~evdev_joystick_handler()
+{
+	Close();
+}
 
 bool evdev_joystick_handler::Init()
 {
-    g_evdev_joystick_config.load();
-
-    axistrigger = static_cast<bool>(g_evdev_joystick_config.axistrigger);
-
-    revaxis.emplace_back(g_evdev_joystick_config.lxreverse);
-    revaxis.emplace_back(g_evdev_joystick_config.lyreverse);
-    revaxis.emplace_back(g_evdev_joystick_config.rxreverse);
-    revaxis.emplace_back(g_evdev_joystick_config.ryreverse);
-
-    return true;
+	m_pad_config.load();
+	return true;
 }
 
-void evdev_joystick_handler::update_devs()
+bool evdev_joystick_handler::update_device(EvdevDevice& device, bool use_cell)
 {
-    for (u32 i = 0; i < joy_devs.size(); ++i)
-        try_open_dev(i);
+	std::shared_ptr<Pad> pad = device.pad;
+	const auto& path = device.path;
+	libevdev*& dev = device.device;
+
+	bool was_connected = dev != nullptr;
+
+	if (access(path.c_str(), R_OK) == -1)
+	{
+		if (was_connected)
+		{
+			// It was disconnected.
+			if (use_cell) pad->m_port_status |= CELL_PAD_STATUS_ASSIGN_CHANGES;
+
+			int fd = libevdev_get_fd(dev);
+			libevdev_free(dev);
+			close(fd);
+			dev = nullptr;
+		}
+
+		if (use_cell) pad->m_port_status &= ~CELL_PAD_STATUS_CONNECTED;
+		LOG_ERROR(GENERAL, "Joystick %s is not present or accessible [previous status: %d]", path.c_str(),
+			was_connected ? 1 : 0);
+		return false;
+	}
+
+	if (was_connected) return true;  // It's already been connected, and the js is still present.
+	int fd = open(path.c_str(), O_RDONLY | O_NONBLOCK);
+
+	if (fd == -1)
+	{
+		int err = errno;
+		LOG_ERROR(GENERAL, "Failed to open joystick: %s [errno %d]", strerror(err), err);
+		return false;
+	}
+
+	int ret = libevdev_new_from_fd(fd, &dev);
+	if (ret < 0)
+	{
+		LOG_ERROR(GENERAL, "Failed to initialize libevdev for joystick: %s [errno %d]", strerror(-ret), -ret);
+		return false;
+	}
+
+	LOG_NOTICE(GENERAL, "Opened joystick: '%s' at %s (fd %d)", libevdev_get_name(dev), path, fd);
+
+	if (use_cell)
+	{
+		// Connection status changed from disconnected to connected.
+		pad->m_port_status |= CELL_PAD_STATUS_ASSIGN_CHANGES;
+		pad->m_port_status |= CELL_PAD_STATUS_CONNECTED;
+	}
+
+	return true;
 }
 
-inline u16 Clamp0To255(f32 input)
+void evdev_joystick_handler::update_devs(bool use_cell)
 {
-    if (input > 255.f)
-        return 255;
-    else if (input < 0.f)
-        return 0;
-    else return static_cast<u16>(input);
-}
-
-std::tuple<u16, u16> evdev_joystick_handler::ConvertToSquirclePoint(u16 inX, u16 inY)
-{
-    // convert inX and Y to a (-1, 1) vector;
-    const f32 x = (inX - 127) / 127.f;
-    const f32 y = ((inY - 127) / 127.f);
-
-    // compute angle and len of given point to be used for squircle radius
-    const f32 angle = std::atan2(y, x);
-    const f32 r = std::sqrt(std::pow(x, 2.f) + std::pow(y, 2.f));
-
-    // now find len/point on the given squircle from our current angle and radius in polar coords
-    // https://thatsmaths.com/2016/07/14/squircles/
-    const f32 newLen = (1 + std::pow(std::sin(2 * angle), 2.f) / (g_evdev_joystick_config.squirclefactor / 1000.f)) * r;
-
-    // we now have len and angle, convert to cartisian
-
-    const int newX = Clamp0To255(((newLen * std::cos(angle)) + 1) * 127);
-    const int newY = Clamp0To255(((newLen * std::sin(angle)) + 1) * 127);
-    return std::tuple<u16, u16>(newX, newY);
-}
-
-bool evdev_joystick_handler::try_open_dev(u32 index)
-{
-    libevdev*& dev = joy_devs[index];
-    bool was_connected = dev != nullptr;
-
-    if (index >= joy_paths.size()) return false;
-    const auto& path = joy_paths[index];
-
-    if (access(path.c_str(), R_OK) == -1)
-    {
-        if (was_connected)
-        {
-            // It was disconnected.
-            pads[index]->m_port_status |= CELL_PAD_STATUS_ASSIGN_CHANGES;
-
-            int fd = libevdev_get_fd(dev);
-            libevdev_free(dev);
-            close(fd);
-            dev = nullptr;
-        }
-        pads[index]->m_port_status &= ~CELL_PAD_STATUS_CONNECTED;
-        LOG_ERROR(GENERAL, "Joystick %s is not present or accessible [previous status: %d]", path.c_str(),
-                  was_connected ? 1 : 0);
-        return false;
-    }
-
-    if (was_connected) return true;  // It's already been connected, and the js is still present.
-    int fd = open(path.c_str(), O_RDONLY | O_NONBLOCK);
-
-    if (fd == -1)
-    {
-        int err = errno;
-        LOG_ERROR(GENERAL, "Failed to open joystick #%d: %s [errno %d]", index, strerror(err), err);
-        return false;
-    }
-
-    int ret = libevdev_new_from_fd(fd, &dev);
-    if (ret < 0)
-    {
-        LOG_ERROR(GENERAL, "Failed to initialize libevdev for joystick #%d: %s [errno %d]", index, strerror(-ret), -ret);
-        return false;
-    }
-
-    LOG_NOTICE(GENERAL, "Opened joystick #%d '%s' at %s (fd %d)", index, libevdev_get_name(dev), path, fd);
-
-    if (!was_connected)
-        // Connection status changed from disconnected to connected.
-        pads[index]->m_port_status |= CELL_PAD_STATUS_ASSIGN_CHANGES;
-    pads[index]->m_port_status |= CELL_PAD_STATUS_CONNECTED;
-
-    int buttons = 0;
-    for (u32 i = BTN_JOYSTICK; i < KEY_MAX; i++)
-        if (libevdev_has_event_code(dev, EV_KEY, i))
-        {
-            LOG_NOTICE(GENERAL, "Joystick #%d has button %d as %d", index, i, buttons);
-            joy_button_maps[index][i - BTN_MISC] = buttons++;
-        }
-
-    int axes = 0;
-    for (u32 i = ABS_X; i <= ABS_RZ; i++)
-    {
-
-        if (libevdev_has_event_code(dev, EV_ABS, i))
-        {
-            LOG_NOTICE(GENERAL, "Joystick #%d has axis %d as %d", index, i, axes);
-
-            axis_ranges[i].first = libevdev_get_abs_minimum(dev, i);
-            axis_ranges[i].second = libevdev_get_abs_maximum(dev, i);
-
-            // Skip ABS_Z and ABS_RZ on controllers where it's used for the triggers.
-            if (axistrigger && (i == ABS_Z || i == ABS_RZ)) continue;
-            joy_axis_maps[index][i - ABS_X] = axes++;
-        }
-    }
-
-    for (u32 i = ABS_HAT0X; i <= ABS_HAT3Y; i += 2)
-        if (libevdev_has_event_code(dev, EV_ABS, i) ||
-            libevdev_has_event_code(dev, EV_ABS, i+1))
-        {
-            LOG_NOTICE(GENERAL, "Joystick #%d has hat %d", index, i);
-            joy_hat_ids[index] = i - ABS_HAT0X;
-        }
-
-    return true;
+	for (auto& device : devices)
+	{
+		update_device(device, use_cell);
+	}
 }
 
 void evdev_joystick_handler::Close()
 {
-    for (auto& dev : joy_devs)
-    {
-        if (dev != nullptr)
-        {
-            int fd = libevdev_get_fd(dev);
-            libevdev_free(dev);
-            close(fd);
-        }
-    }
+	for (auto& device : devices)
+	{
+		auto& dev = device.device;
+		if (dev != nullptr)
+		{
+			int fd = libevdev_get_fd(dev);
+			libevdev_free(dev);
+			close(fd);
+		}
+	}
 }
 
-inline float deadzone(f32 input)
+std::unordered_map<u64, std::pair<u16, bool>> evdev_joystick_handler::GetButtonValues(libevdev* dev)
 {
-    //when we're just above the deadzone, the output should be 128, not 128+deadzone
-    //otherwise, there'll be a jump. So, we need to recalculate the output with a linear function
-    float deadzone_slope, deadzone_origin;
-    if (input >= 127.5 - g_evdev_joystick_config.deadzone && input <= 127.5 + g_evdev_joystick_config.deadzone)
-    {
-        return 127.5;
-    }
-    else
-    {
-        if (input > 127.5 + g_evdev_joystick_config.deadzone)
-        {
-            deadzone_slope = 127.5 / (127.5 - g_evdev_joystick_config.deadzone);
-            deadzone_origin = 255.0 * (1.0 - deadzone_slope);
-            return (deadzone_slope * input + deadzone_origin);
-        }
-        if (input < 127.5 - g_evdev_joystick_config.deadzone)
-        {
-            return (127.5 / (127.5 - g_evdev_joystick_config.deadzone)) * input;
-        }
-    }
+	std::unordered_map<u64, std::pair<u16, bool>> button_values;
+
+	for (auto entry : button_list)
+	{
+		auto code = entry.first;
+		int val = 0;
+		if (libevdev_fetch_event_value(dev, EV_KEY, code, &val) == 0)
+			continue;
+
+		button_values.emplace(code, std::make_pair<u16, bool>(static_cast<u16>(val > 0 ? 255 : 0), false));
+	}
+
+	for (auto entry : axis_list)
+	{
+		auto code = entry.first;
+		int val = 0;
+		if (libevdev_fetch_event_value(dev, EV_ABS, code, &val) == 0)
+			continue;
+
+		float fvalue = ScaleStickInput(val, libevdev_get_abs_minimum(dev, code), libevdev_get_abs_maximum(dev, code));
+
+		// Triggers should be ABS_Z and ABS_RZ and do not need handling of negative values
+		if (code == ABS_Z || code == ABS_RZ)
+		{
+			button_values.emplace(code, std::make_pair<u16, bool>(static_cast<u16>(fvalue), false));
+			continue;
+		}
+
+		bool is_negative = fvalue <= 127.5;
+
+		if (is_negative)
+		{
+			u16 value = Clamp0To255((127.5f - fvalue) * 2.0f);
+			button_values.emplace(code, std::make_pair<u16, bool>(static_cast<u16>(value), true));
+		}
+		else
+		{
+			u16 value = Clamp0To255((fvalue - 127.5f) * 2.0f);
+			button_values.emplace(code, std::make_pair<u16, bool>(static_cast<u16>(value), false));
+		}
+	}
+
+	return button_values;
 }
 
-int evdev_joystick_handler::scale_axis(int axis, int value)
+void evdev_joystick_handler::GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& callback)
 {
-    auto range = axis_ranges[axis];
-    // Check if scaling is needed.
-    if (range.first != 0 || range.second != 255)
-    {
-        if (range.first < 0)
-        {
-            // Move the ranges up to make the following calculation actually *work*
-            value += -range.first;
-            range.second += -range.first;
-            range.first = 0;
-        }
-        return (deadzone(((static_cast<float>(value) - range.first) / range.second) * 255));
-    }
-    else
-    {
-        return (deadzone(static_cast<float>(value)));
-    }
+	// Add device if not yet present
+	m_pad_index = add_device(padId, true);
+
+	if (m_pad_index < 0) return;
+
+	EvdevDevice& device = devices[m_pad_index];
+
+	// Check if our device is connected
+	if (!update_device(device, false)) return;
+
+	auto& dev = device.device;
+
+	// Try to query the latest event from the joystick.
+	input_event evt;
+	int ret = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &evt);
+
+	// Grab any pending sync event.
+	if (ret == LIBEVDEV_READ_STATUS_SYNC)
+	{
+		ret = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL | LIBEVDEV_READ_FLAG_SYNC, &evt);
+	}
+	if (ret < 0) return;
+
+	auto data = GetButtonValues(dev);
+
+	std::pair<u16, std::string> pressed_button = { 0, "" };
+	for (const auto& button : button_list)
+	{
+		if (padId.find("Xbox 360") != std::string::npos && button.first >= BTN_TRIGGER_HAPPY)
+			continue;
+		if (padId.find("Sony") != std::string::npos && (button.first == BTN_TL2 || button.first == BTN_TR2))
+			continue;
+
+		u16 value = data[button.first].first;
+		if (value > 0 && value > pressed_button.first)
+			pressed_button = { value, button.second };
+	}
+
+	for (const auto& button : axis_list)
+	{
+		int code = button.first;
+		if (data[code].second)
+			continue;
+
+		u16 value = data[code].first;
+
+		if (((code == ABS_X || code == ABS_Y) && value < m_thumb_threshold)
+		 || ((code == ABS_RX || code == ABS_RY) && value < m_thumb_threshold)
+		 || (code == ABS_Z && value < m_trigger_threshold)
+		 || (code == ABS_RZ && value < m_trigger_threshold))
+			continue;
+
+		if (value > 0 && value > pressed_button.first)
+			pressed_button = { value, button.second };
+	}
+
+	for (const auto& button : rev_axis_list)
+	{
+		int code = button.first;
+		if (!data[code].second)
+			continue;
+
+		u16 value = data[code].first;
+
+		if (((code == ABS_X || code == ABS_Y) && value < m_thumb_threshold)
+		 || ((code == ABS_RX || code == ABS_RY) && value < m_thumb_threshold)
+		 || (code == ABS_Z && value < m_trigger_threshold)
+		 || (code == ABS_RZ && value < m_trigger_threshold))
+			continue;
+
+		if (value > 0 && value > pressed_button.first)
+			pressed_button = { value, button.second };
+	}
+
+	// get stick values
+	int lxp = 0, lxn = 0, lyp = 0, lyn = 0, rxp = 0, rxn = 0, ryp = 0, ryn = 0;
+
+	if (libevdev_has_event_code(dev, EV_ABS, ABS_X))
+		data[ABS_X].second ? lxn = data[ABS_X].first : lxp = data[ABS_X].first;
+
+	if (libevdev_has_event_code(dev, EV_ABS, ABS_Y))
+		data[ABS_Y].second ? lyp = data[ABS_Y].first : lyn = data[ABS_Y].first;
+
+	if (libevdev_has_event_code(dev, EV_ABS, ABS_RX))
+		data[ABS_RX].second ? rxn = data[ABS_RX].first : rxp = data[ABS_RX].first;
+
+	if (libevdev_has_event_code(dev, EV_ABS, ABS_RY))
+		data[ABS_RY].second ? ryp = data[ABS_RY].first : ryn = data[ABS_RY].first;
+
+	int preview_values[6] = { data[ABS_Z].first, data[ABS_RZ].first, lxp - lxn, lyp - lyn, rxp - rxn, ryp - ryn };
+
+	if (pressed_button.first > 0)
+		return callback(pressed_button.first, pressed_button.second, preview_values);
+	else
+		return callback(0, "", preview_values);
+}
+
+void evdev_joystick_handler::TestVibration(const std::string& padId, u32 largeMotor, u32 smallMotor)
+{
+}
+
+void evdev_joystick_handler::TranslateButtonPress(u64 keyCode, bool& pressed, u16& value, bool ignore_threshold)
+{
+	// Update the pad button values based on their type and thresholds.
+	// With this you can use axis or triggers as buttons or vice versa
+	switch (keyCode)
+	{
+	case ABS_Z:
+		value = value > (ignore_threshold ? 0 : m_pad_config.ltriggerthreshold) ? value : 0;
+		pressed = value > 0;
+		break;
+	case ABS_RZ:
+		value = value > (ignore_threshold ? 0 : m_pad_config.rtriggerthreshold) ? value : 0;
+		pressed = value > 0;
+		break;
+	case ABS_X:
+	case ABS_Y:
+		value = value > (ignore_threshold ? 0 : m_pad_config.lstickdeadzone) ? value : 0;
+		pressed = value > 0;
+		break;
+	case ABS_RX:
+	case ABS_RY:
+		value = value > (ignore_threshold ? 0 : m_pad_config.rstickdeadzone) ? value : 0;
+		pressed = value > 0;
+		break;
+	default:
+		pressed = value > 0;
+		value = pressed ? value : 0;
+		break;
+	}
+}
+
+int evdev_joystick_handler::GetButtonInfo(const input_event& evt, libevdev* dev, int& value, bool& is_negative)
+{
+	int code = evt.code;
+	int val = evt.value;
+
+	switch (evt.type)
+	{
+	case EV_KEY:
+	{
+		// get the button value and return its code
+		if (code < BTN_MISC)
+			return -1;
+
+		value = val > 0 ? 255 : 0;
+		return code;
+	}
+	case EV_ABS:
+	{
+		float fvalue = ScaleStickInput(val, libevdev_get_abs_minimum(dev, code), libevdev_get_abs_maximum(dev, code));
+
+		// Triggers should be ABS_Z and ABS_RZ and do not need handling of negative values
+		if (code == ABS_Z || code == ABS_RZ)
+		{
+			value = static_cast<u16>(fvalue);
+			return code;
+		}
+
+		is_negative = fvalue <= 127.5;
+
+		if (is_negative)
+			value = Clamp0To255((127.5f - fvalue) * 2.0f);
+		else
+			value = Clamp0To255((fvalue - 127.5f) * 2.0f);
+
+		return code;
+	}
+	default:
+		return -1;
+	}
 }
 
 std::vector<std::string> evdev_joystick_handler::ListDevices()
 {
-    Init();
-    std::vector<std::string> evdev_joystick_list;
-    fs::dir devdir{"/dev/input/"};
-    fs::dir_entry et;
+	Init();
+	std::vector<std::string> evdev_joystick_list;
+	fs::dir devdir{"/dev/input/"};
+	fs::dir_entry et;
 
-    while (devdir.read(et))
-    {
-        // Check if the entry starts with event (a 5-letter word)
-        if (et.name.size() > 5 && et.name.compare(0, 5,"event") == 0)
-        {
-            int fd = open(("/dev/input/" + et.name).c_str(), O_RDONLY|O_NONBLOCK);
-            struct libevdev *dev = NULL;
-            int rc = libevdev_new_from_fd(fd, &dev);
-            if (rc < 0)
-            {
-                // If it's just a bad file descriptor, don't bother logging, but otherwise, log it.
-                if (rc != -9)
-                    LOG_WARNING(GENERAL, "Failed to connect to device at %s, the error was: %s", "/dev/input/" + et.name, strerror(-rc));
-                libevdev_free(dev);
-                close(fd);
-                continue;
-            }
-            if (libevdev_has_event_type(dev, EV_KEY) &&
-                libevdev_has_event_code(dev, EV_ABS, ABS_X) &&
-                libevdev_has_event_code(dev, EV_ABS, ABS_Y))
-            {
-                // It's a joystick.
-                evdev_joystick_list.push_back(libevdev_get_name(dev));
-            }
-            libevdev_free(dev);
-            close(fd);
-        }
-    }
-    return evdev_joystick_list;
+	while (devdir.read(et))
+	{
+		// Check if the entry starts with event (a 5-letter word)
+		if (et.name.size() > 5 && et.name.compare(0, 5,"event") == 0)
+		{
+			int fd = open(("/dev/input/" + et.name).c_str(), O_RDONLY|O_NONBLOCK);
+			struct libevdev *dev = NULL;
+			int rc = libevdev_new_from_fd(fd, &dev);
+			if (rc < 0)
+			{
+				// If it's just a bad file descriptor, don't bother logging, but otherwise, log it.
+				if (rc != -9)
+					LOG_WARNING(GENERAL, "Failed to connect to device at %s, the error was: %s", "/dev/input/" + et.name, strerror(-rc));
+				libevdev_free(dev);
+				close(fd);
+				continue;
+			}
+			if (libevdev_has_event_type(dev, EV_KEY) &&
+				libevdev_has_event_code(dev, EV_ABS, ABS_X) &&
+				libevdev_has_event_code(dev, EV_ABS, ABS_Y))
+			{
+				// It's a joystick.
+				evdev_joystick_list.push_back(libevdev_get_name(dev));
+			}
+			libevdev_free(dev);
+			close(fd);
+		}
+	}
+	return evdev_joystick_list;
 }
 
-bool evdev_joystick_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device)
+int evdev_joystick_handler::add_device(const std::string& device, bool in_settings, std::shared_ptr<Pad> pad, const std::unordered_map<int, bool>& axis_map)
 {
-        Init();
+	if (in_settings && m_pad_index >= 0) return m_pad_index;
 
-        // Now we need to find the device with the same name, and make sure not to grab any duplicates.
-        fs::dir devdir{"/dev/input/"};
-        fs::dir_entry et;
-        while (devdir.read(et))
-        {
-            // Check if the entry starts with event (a 5-letter word)
-            if (et.name.size() > 5 && et.name.compare(0, 5,"event") == 0)
-            {
-                int fd = open(("/dev/input/" + et.name).c_str(), O_RDONLY|O_NONBLOCK);
-                struct libevdev *dev = NULL;
-                int rc = libevdev_new_from_fd(fd, &dev);
-                if (rc < 0)
-                {
-                    // If it's just a bad file descriptor, don't bother logging, but otherwise, log it.
-                    if (rc != -9)
-                        LOG_WARNING(GENERAL, "Failed to connect to device at %s, the error was: %s", "/dev/input/" + et.name, strerror(-rc));
-                    libevdev_free(dev);
-                    close(fd);
-                    continue;
-                }
-                const std::string name = libevdev_get_name(dev);
-                if (libevdev_has_event_type(dev, EV_KEY) &&
-                    libevdev_has_event_code(dev, EV_ABS, ABS_X) &&
-                    libevdev_has_event_code(dev, EV_ABS, ABS_Y) &&
-                    name == device)
-                {
-                    // It's a joystick.
+	// Now we need to find the device with the same name, and make sure not to grab any duplicates.
+	fs::dir devdir{ "/dev/input/" };
+	fs::dir_entry et;
+	while (devdir.read(et))
+	{
+		// Check if the entry starts with event (a 5-letter word)
+		if (et.name.size() > 5 && et.name.compare(0, 5, "event") == 0)
+		{
+			std::string path = "/dev/input/" + et.name;
+			int fd = open(path.c_str(), O_RDONLY | O_NONBLOCK);
+			struct libevdev *dev = NULL;
+			int rc = libevdev_new_from_fd(fd, &dev);
+			if (rc < 0)
+			{
+				// If it's just a bad file descriptor, don't bother logging, but otherwise, log it.
+				if (rc != -9)
+					LOG_WARNING(GENERAL, "Failed to connect to device at %s, the error was: %s", path, strerror(-rc));
+				libevdev_free(dev);
+				close(fd);
+				continue;
+			}
+			const std::string name = libevdev_get_name(dev);
+			if (libevdev_has_event_type(dev, EV_KEY) &&
+				libevdev_has_event_code(dev, EV_ABS, ABS_X) &&
+				libevdev_has_event_code(dev, EV_ABS, ABS_Y) &&
+				name == device)
+			{
+				// It's a joystick.
 
-                    // Now let's make sure we don't already have this one.
-                    bool alreadyIn = false;
-                    for (int i = 0; i < joy_paths.size(); i++)
-                        if (joy_paths[i] == fmt::format("/dev/input/%s", et.name))
-                        {
-                            alreadyIn = true;
-                            break;
-                        }
-                    if (alreadyIn == true)
-                    {
-                        libevdev_free(dev);
-                        close(fd);
-                        continue;
-                    }
+				// Now let's make sure we don't already have this one.
+				auto it = std::find_if(devices.begin(), devices.end(), [&path](const EvdevDevice &device) { return path == device.path; });
+				if (it != devices.end())
+				{
+					libevdev_free(dev);
+					close(fd);
+					return std::distance(devices.begin(), it);
+				}
 
-                    // Alright, now that we've confirmed we haven't added this joystick yet, les do dis.
-                    joy_paths.emplace_back(fmt::format("/dev/input/%s", et.name));
-                }
-                libevdev_free(dev);
-                close(fd);
-            }
-        }
-
-        joy_devs.push_back(nullptr);
-        joy_axis_maps.emplace_back(ABS_RZ - ABS_X, -1);
-        joy_axis.emplace_back(ABS_RZ - ABS_X, -1);
-        joy_button_maps.emplace_back(KEY_MAX - BTN_JOYSTICK, -1);
-        joy_hat_ids.emplace_back(-1);
-        pad->Init(
-            CELL_PAD_STATUS_DISCONNECTED,
-            CELL_PAD_SETTING_PRESS_OFF | CELL_PAD_SETTING_SENSOR_OFF,
-            CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE,
-            CELL_PAD_DEV_TYPE_STANDARD
-        );
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_evdev_joystick_config.triangle, CELL_PAD_CTRL_TRIANGLE);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_evdev_joystick_config.circle, CELL_PAD_CTRL_CIRCLE);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_evdev_joystick_config.cross, CELL_PAD_CTRL_CROSS);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_evdev_joystick_config.square, CELL_PAD_CTRL_SQUARE);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_evdev_joystick_config.l2, CELL_PAD_CTRL_L2);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_evdev_joystick_config.r2, CELL_PAD_CTRL_R2);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_evdev_joystick_config.l1, CELL_PAD_CTRL_L1);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_evdev_joystick_config.r1, CELL_PAD_CTRL_R1);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_evdev_joystick_config.start, CELL_PAD_CTRL_START);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_evdev_joystick_config.select, CELL_PAD_CTRL_SELECT);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_evdev_joystick_config.l3, CELL_PAD_CTRL_L3);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_evdev_joystick_config.r3, CELL_PAD_CTRL_R3);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
-
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_evdev_joystick_config.up, CELL_PAD_CTRL_UP);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_evdev_joystick_config.down, CELL_PAD_CTRL_DOWN);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_evdev_joystick_config.left, CELL_PAD_CTRL_LEFT);
-        pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_evdev_joystick_config.right, CELL_PAD_CTRL_RIGHT);
-
-        pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X+g_evdev_joystick_config.lxstick, 0, 0);
-        pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X+g_evdev_joystick_config.lystick, 0, 0);
-        pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X+g_evdev_joystick_config.rxstick, 0, 0);
-        pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X+g_evdev_joystick_config.rystick, 0, 0);
-        pad->m_vibrateMotors.emplace_back(true, 0);
-        pad->m_vibrateMotors.emplace_back(false, 0);
-        pads.emplace_back(pad);
-        update_devs();
-        return true;
+				// Alright, now that we've confirmed we haven't added this joystick yet, les do dis.
+				devices.push_back({nullptr, path, pad, axis_map});
+				return devices.size() - 1;
+			}
+			libevdev_free(dev);
+			close(fd);
+		}
+	}
+	return -1;
 }
 
 void evdev_joystick_handler::ThreadProc()
 {
-    update_devs();
+	update_devs();
 
-    for (int i = 0; i<joy_devs.size(); i++)
-    {
-        auto pad = pads[i];
-        auto& dev = joy_devs[i];
-        if (dev == nullptr) continue;
+	for (auto& device : devices)
+	{
+		auto pad = device.pad;
+		auto axis_orientations = device.axis_orientations;
+		auto& dev = device.device;
+		if (dev == nullptr) continue;
 
-        // Try to query the latest event from the joystick.
-        input_event evt;
-        int ret = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &evt);
+		// Try to query the latest event from the joystick.
+		input_event evt;
+		int ret = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL, &evt);
 
-        // Grab any pending sync event.
-        if (ret == LIBEVDEV_READ_STATUS_SYNC)
-        {
-            LOG_NOTICE(GENERAL, "Captured sync event");
-            ret = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL | LIBEVDEV_READ_FLAG_SYNC, &evt);
-        }
+		// Grab any pending sync event.
+		if (ret == LIBEVDEV_READ_STATUS_SYNC)
+		{
+			LOG_NOTICE(GENERAL, "Captured sync event");
+			ret = libevdev_next_event(dev, LIBEVDEV_READ_FLAG_NORMAL | LIBEVDEV_READ_FLAG_SYNC, &evt);
+		}
 
-        if (ret < 0)
-        {
-            // -EAGAIN signifies no available events, not an actual *error*.
-            if (ret != -EAGAIN)
-                LOG_ERROR(GENERAL, "Failed to read latest event from joystick #%d: %s [errno %d]", i, strerror(-ret), -ret);
-            continue;
-        }
+		if (ret < 0)
+		{
+			// -EAGAIN signifies no available events, not an actual *error*.
+			if (ret != -EAGAIN)
+				LOG_ERROR(GENERAL, "Failed to read latest event from joystick: %s [errno %d]", strerror(-ret), -ret);
+			continue;
+		}
 
-        switch (evt.type)
-        {
-        case EV_SYN:
-            LOG_NOTICE(GENERAL, "Joystick #%d sent EV_SYN", i);
-            break;
-        case EV_MSC:
-            LOG_NOTICE(GENERAL, "Joystick #%d sent EV_MSC", i);
-            break;
-        case EV_KEY:
-        {
-            LOG_NOTICE(GENERAL, "Joystick #%d EV_KEY: %d %d", i, evt.code, evt.value);
-            if (evt.code < BTN_MISC)
-            {
-                LOG_NOTICE(GENERAL, "Joystick #%d sent non-button key event %d", i, evt.code);
-                break;
-            }
+		bool is_negative = false;
+		int value;
+		int button_code = GetButtonInfo(evt, dev, value, is_negative);
+		if (button_code < 0 || value < 0)
+			continue;
 
-            int button_code = joy_button_maps[i][evt.code - BTN_MISC];
-            if (button_code == -1)
-            {
-                LOG_ERROR(GENERAL, "Joystick #%d sent invalid button code %d", i, evt.code);
-            }
+		bool is_button_or_trigger = evt.type == EV_KEY || button_code == ABS_Z || button_code == ABS_RZ;
 
-            auto which_button = std::find_if(
-                pad->m_buttons.begin(), pad->m_buttons.end(),
-                [&](const Button& bt) { return bt.m_keyCode == button_code; });
-            if (which_button == pad->m_buttons.end())
-            {
-                LOG_ERROR(GENERAL, "Joystick #%d sent button event for unmapped button %d", i, evt.code);
-                break;
-            }
+		// Translate any corresponding keycodes to our normal DS3 buttons and triggers
+		for (int i = 0; i < static_cast<int>(pad->m_buttons.size() - 1); i++) // skip reserved button
+		{
+			if (pad->m_buttons[i].m_keyCode != button_code)
+				continue;
 
-            which_button->m_pressed = evt.value;
-            which_button->m_value = evt.value ? 255 : 0;
-            break;
-        }
-        case EV_ABS:
-        {
+			// Be careful to handle mapped axis specially
+			if (evt.type == EV_ABS)
+			{
+				// get axis direction and skip on error or set to 0 if the stick/hat is actually pointing to the other direction.
+				// maybe mimic on error, needs investigation. FindAxisDirection should ideally never return -1 anyway
+				int direction = FindAxisDirection(axis_orientations, i);
+				if (direction < 0)
+				{
+					LOG_ERROR(HLE, "FindAxisDirection = %d, Button Nr.%d, value = %d", direction, i, value);
+					continue;
+				}
+				else if (direction != (is_negative ? 1 : 0))
+				{
+					pad->m_buttons[i].m_value = 0;
+					pad->m_buttons[i].m_pressed = 0;
+					continue;
+				}
+			}
 
-            LOG_NOTICE(GENERAL, "Joystick #%d EV_ABS: %d %d", i, evt.code, evt.value);
-            //duplicate the evt.code and evt.value, so that they're still available
-            //for the analog input
-            int code2 = evt.code;
-            int value2 = evt.value;
-            if (g_evdev_joystick_config.left_analog_to_dpad)
-            {
-                //some gamepad have a -32767 to +32767 range; others have a 0 to 255
-                float center2 = (axis_ranges[evt.code].second + axis_ranges[evt.code].first) / 2;
-                //arbitrary decision: when the value is higher than a 1/3 of the range, we simulate a dpad press
-                float threshold2 = (axis_ranges[evt.code].second-center2)/3;
-                if (code2 == 0 || code2 == 1)
-                {
-                    value2 = 0;
-                    if (evt.value > center2 + threshold2)
-                        value2 = 1;
-                    else if (evt.value < center2 - threshold2)
-                        value2 = -1;
-                    if (revaxis[code2])
-                        value2 = -value2;
-                    if (g_evdev_joystick_config.lxstick < g_evdev_joystick_config.lystick)
-                    {
-                        code2 = (code2 == 0) ? ABS_HAT0X : ABS_HAT0Y;
-                    }
-                    else
-                    {
-                        code2 = (code2 == 0) ? ABS_HAT0Y : ABS_HAT0X;
-                    }
-                }
-            }
-            if (code2 >= ABS_HAT0X && code2 <= ABS_HAT3Y)
-            {
-                int hat = code2 - ABS_HAT0X;
-                if (hat != joy_hat_ids[i] && hat-1 != joy_hat_ids[i])
-                {
-                    LOG_ERROR(GENERAL, "Joystick #%d sent HAT event for invalid hat %d (expected %d)", i, hat, joy_hat_ids[i]);
-                    break;
-                }
+			pad->m_buttons[i].m_value = static_cast<u16>(value);
+			TranslateButtonPress(button_code, pad->m_buttons[i].m_pressed, pad->m_buttons[i].m_value);
+		}
 
-                int source_axis = hat == joy_hat_ids[i] ? EVDEV_DPAD_HAT_AXIS_X : EVDEV_DPAD_HAT_AXIS_Y;
+		// Translate any corresponding keycodes to our two sticks. (ignoring thresholds for now)
+		for (int idx = 0; idx < static_cast<int>(pad->m_sticks.size()); idx++)
+		{
+			bool pressed_min = false, pressed_max = false;
 
-                for (Button& bt : pad->m_buttons)
-                {
-                    if (bt.m_keyCode != source_axis) continue;
+			// m_keyCodeMin is the mapped key for left or down
+			if (pad->m_sticks[idx].m_keyCodeMin == button_code)
+			{
+				bool is_direction_min = false;
 
-                    if (value2 == 0)
-                    {
-                        bt.m_pressed = false;
-                        bt.m_value = 0;
-                    }
-                    else
-                    {
-                        int code;
-                        if (source_axis == EVDEV_DPAD_HAT_AXIS_X)
-                        {
-                            code = value2 > 0 ? CELL_PAD_CTRL_RIGHT : CELL_PAD_CTRL_LEFT;
-                        }
-                        else
-                        {
-                            code = value2 > 0 ? CELL_PAD_CTRL_DOWN : CELL_PAD_CTRL_UP;
-                        }
-                        if (bt.m_outKeyCode == code)
-                        {
-                            bt.m_pressed = true;
-                            bt.m_value = 255;
-                        }
-                    }
-                }
-            }
-            else if (axistrigger && (evt.code == ABS_Z || evt.code == ABS_RZ))
-            {
-                // For Xbox controllers, a third axis represent the left/right triggers.
-                int which_trigger = 0;
+				if (!is_button_or_trigger && evt.type == EV_ABS)
+				{
+					int index = BUTTON_COUNT + (idx * 2) + 1;
+					int min_direction = FindAxisDirection(axis_orientations, index);
+					if (min_direction < 0)
+					{
+						LOG_ERROR(HLE, "keyCodeMin FindAxisDirection = %d, Axis Nr.%d, Button Nr.%d, value = %d", min_direction, idx, index, value);
+					}
+					else
+					{
+						is_direction_min = is_negative == (min_direction == 1);
+					}
+				}
 
-                if (evt.code == ABS_Z)
-                {
-                    which_trigger = CELL_PAD_CTRL_L2;
-                }
-                else if (evt.code == ABS_RZ)
-                {
-                    which_trigger = CELL_PAD_CTRL_R2;
-                }
-                else
-                {
-                    LOG_ERROR(GENERAL, "Joystick #%d sent invalid event code %d for 3rd axis", i, evt.code);
-                    break;
-                }
+				if (is_button_or_trigger || is_direction_min)
+				{
+					device.val_min[idx] = value;
+					TranslateButtonPress(button_code, pressed_min, device.val_min[idx], true);
+				}
+				else // set to 0 to avoid remnant counter axis values
+					device.val_min[idx] = 0;
+			}
 
-                auto which_button = std::find_if(
-                    pad->m_buttons.begin(), pad->m_buttons.end(),
-                    [&](const Button& bt) { return bt.m_outKeyCode == which_trigger; });
-                if (which_button == pad->m_buttons.end())
-                {
-                    LOG_ERROR(GENERAL, "Joystick #%d's pad has no trigger %d", i, which_trigger);
-                    break;
-                }
+			// m_keyCodeMax is the mapped key for right or up
+			if (pad->m_sticks[idx].m_keyCodeMax == button_code)
+			{
+				bool is_direction_max = false;
 
-                int value = scale_axis(evt.code, evt.value);
-                which_button->m_pressed = value > 0;
-                which_button->m_value = value;
-            }
-            if (evt.code >= ABS_X && evt.code <= ABS_RZ)
-            {
-                int axis = joy_axis_maps[i][evt.code - ABS_X];
+				if (!is_button_or_trigger && evt.type == EV_ABS)
+				{
+					int index = BUTTON_COUNT + (idx * 2);
+					int max_direction = FindAxisDirection(axis_orientations, index);
+					if (max_direction < 0)
+					{
+						LOG_ERROR(HLE, "keyCodeMax FindAxisDirection = %d, Axis Nr.%d, Button Nr.%d, value = %d", max_direction, idx, index, value);
+					}
+					else
+					{
+						is_direction_max = is_negative == (max_direction == 1);
+					}
+				}
 
-                if (axis > pad->m_sticks.size())
-                {
-                    LOG_ERROR(GENERAL, "Joystick #%d sent axis event for invalid axis %d", i, axis);
-                    break;
-                }
+				if (is_button_or_trigger || is_direction_max)
+				{
+					device.val_max[idx] = value;
+					TranslateButtonPress(button_code, pressed_max, device.val_max[idx], true);
+				}
+				else // set to 0 to avoid remnant counter axis values
+					device.val_max[idx] = 0;
+			}
 
-                int value = evt.value;
-                if (revaxis[axis])
-                {
-                    // Reverse the value in the range.
-                    value = (axis_ranges[evt.code].second + axis_ranges[evt.code].first) - value;
-                }
+			// cancel out opposing values and get the resulting difference. if there was no change, use the old value.
+			device.stick_val[idx] = device.val_max[idx] - device.val_min[idx];
+		}
 
-                if (g_evdev_joystick_config.squirclejoysticks)
-                {
-                    joy_axis[i][axis] = value;
-                    if (evt.code == ABS_X || evt.code == ABS_Y)
-                    {
-                        int Xaxis = joy_axis_maps[i][ABS_X];
-                        int Yaxis = joy_axis_maps[i][ABS_Y];
-                        pad->m_sticks[Xaxis].m_value = scale_axis(ABS_X, joy_axis[i][Xaxis]);
-                        pad->m_sticks[Yaxis].m_value = scale_axis(ABS_Y, joy_axis[i][Yaxis]);
+		// Normalize our two stick's axis based on the thresholds
+		u16 lx, ly, rx, ry;
 
-                        std::tie(pad->m_sticks[Xaxis].m_value, pad->m_sticks[Yaxis].m_value) =
-                            ConvertToSquirclePoint(pad->m_sticks[Xaxis].m_value, pad->m_sticks[Yaxis].m_value);
-                    }
-                    else
-                    {
-                        int Xaxis = joy_axis_maps[i][ABS_RX];
-                        int Yaxis = joy_axis_maps[i][ABS_RY];
-                        pad->m_sticks[Xaxis].m_value = scale_axis(ABS_RX, joy_axis[i][Xaxis]);
-                        pad->m_sticks[Yaxis].m_value = scale_axis(ABS_RY, joy_axis[i][Yaxis]);
+		// Normalize our two stick's axis based on the thresholds
+		std::tie(lx, ly) = NormalizeStickDeadzone(device.stick_val[0], device.stick_val[1], m_pad_config.lstickdeadzone);
+		std::tie(rx, ry) = NormalizeStickDeadzone(device.stick_val[2], device.stick_val[3], m_pad_config.rstickdeadzone);
 
-                        std::tie(pad->m_sticks[Xaxis].m_value, pad->m_sticks[Yaxis].m_value) =
-                            ConvertToSquirclePoint(pad->m_sticks[Xaxis].m_value, pad->m_sticks[Yaxis].m_value);
-                    }
-                }
-                else
-                    pad->m_sticks[axis].m_value = scale_axis(evt.code, value);
-            }
-            break;
-        }
-        default:
-            LOG_ERROR(GENERAL, "Unknown joystick #%d event %d", i, evt.type);
-            break;
-        }
-    }
+		// these are added with previous value and divided to 'smooth' out the readings
+
+		if (m_pad_config.padsquircling != 0)
+		{
+			std::tie(lx, ly) = ConvertToSquirclePoint(lx, ly, m_pad_config.padsquircling);
+			std::tie(rx, ry) = ConvertToSquirclePoint(rx, ry, m_pad_config.padsquircling);
+		}
+
+		pad->m_sticks[0].m_value = lx;
+		pad->m_sticks[1].m_value = 255 - ly;
+		pad->m_sticks[2].m_value = rx;
+		pad->m_sticks[3].m_value = 255 - ry;
+	}
+}
+
+// Search axis_orientations map for the direction by index, returns -1 if not found, 0 for positive and 1 for negative
+int evdev_joystick_handler::FindAxisDirection(const std::unordered_map<int, bool>& map, int index)
+{
+	auto it = map.find(index);
+	if (it == map.end())
+		return -1;
+	else
+		return it->second;
+};
+
+bool evdev_joystick_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device)
+{
+	Init();
+
+	std::unordered_map<int, bool> axis_orientations;
+	int i = 0; // increment to know the axis location (17-24). Be careful if you ever add more find_key() calls in here (BUTTON_COUNT = 17)
+
+	auto find_key = [&](const std::string& name)
+	{
+		int key = FindKeyCode(button_list, name);
+		if (key < 0)
+		{
+			key = FindKeyCode(axis_list, name);
+			if (key >= 0)
+			{
+				axis_orientations.emplace(i, false);
+			}
+		}
+		if (key < 0)
+		{
+			key = FindKeyCode(rev_axis_list, name);
+			if (key >= 0)
+			{
+				axis_orientations.emplace(i, true);
+			}
+		}
+		if (key < 0)
+			key = std::stoi(name);
+
+		i++;
+		return key;
+	};
+
+	pad->Init
+	(
+		CELL_PAD_STATUS_CONNECTED | CELL_PAD_STATUS_ASSIGN_CHANGES,
+		CELL_PAD_SETTING_PRESS_OFF | CELL_PAD_SETTING_SENSOR_OFF,
+		CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE | CELL_PAD_CAPABILITY_HP_ANALOG_STICK | CELL_PAD_CAPABILITY_ACTUATOR | CELL_PAD_CAPABILITY_SENSOR_MODE,
+		CELL_PAD_DEV_TYPE_STANDARD
+	);
+
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.triangle), CELL_PAD_CTRL_TRIANGLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.circle), CELL_PAD_CTRL_CIRCLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.cross), CELL_PAD_CTRL_CROSS);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.square), CELL_PAD_CTRL_SQUARE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.l2), CELL_PAD_CTRL_L2);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.r2), CELL_PAD_CTRL_R2);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.l1), CELL_PAD_CTRL_L1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.r1), CELL_PAD_CTRL_R1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.start), CELL_PAD_CTRL_START);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.select), CELL_PAD_CTRL_SELECT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.l3), CELL_PAD_CTRL_L3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.r3), CELL_PAD_CTRL_R3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.ps), 0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.up), CELL_PAD_CTRL_UP);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.down), CELL_PAD_CTRL_DOWN);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.left), CELL_PAD_CTRL_LEFT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.right), CELL_PAD_CTRL_RIGHT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x0); // Reserved
+
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X, find_key(m_pad_config.ls_left), find_key(m_pad_config.ls_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y, find_key(m_pad_config.ls_down), find_key(m_pad_config.ls_up));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, find_key(m_pad_config.rs_left), find_key(m_pad_config.rs_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, find_key(m_pad_config.rs_down), find_key(m_pad_config.rs_up));
+
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_X, 512);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Y, 399);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Z, 512);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_G, 512);
+
+	pad->m_vibrateMotors.emplace_back(true, 0);
+	pad->m_vibrateMotors.emplace_back(false, 0);
+
+	if (!add_device(device, false, pad, axis_orientations))
+	{
+		//return;
+	}
+	update_devs();
+	return true;
 }
 
 #endif
diff --git a/rpcs3/evdev_joystick_handler.h b/rpcs3/evdev_joystick_handler.h
index 6d0ef11401..3e03e96ec8 100644
--- a/rpcs3/evdev_joystick_handler.h
+++ b/rpcs3/evdev_joystick_handler.h
@@ -8,91 +8,259 @@
 #include <vector>
 #include <thread>
 
-enum { EVDEV_DPAD_HAT_AXIS_X = -1, EVDEV_DPAD_HAT_AXIS_Y = -2 };
-
-struct evdev_joystick_config final : cfg::node
-{
-    const std::string cfg_name = fs::get_config_dir() + "/config_linuxjoystick.yml";
-
-    cfg::int32 select{this, "Select", 6};
-    cfg::int32 start{this, "Start", 7};
-    cfg::int32 cross{this, "Cross", 0};
-    cfg::int32 circle{this, "Circle", 1};
-    cfg::int32 square{this, "Square", 2};
-    cfg::int32 triangle{this, "Triangle", 3};
-
-    cfg::int32 r1{this, "R1", 5};
-    cfg::int32 r2{this, "R2", 11};
-    cfg::int32 r3{this, "R3", 10};
-    cfg::int32 l1{this, "L1", 4};
-    cfg::int32 l2{this, "L2", 12};
-    cfg::int32 l3{this, "L3", 9};
-
-    cfg::int32 up{this, "Up", EVDEV_DPAD_HAT_AXIS_Y};
-    cfg::int32 down{this, "Down", EVDEV_DPAD_HAT_AXIS_Y};
-    cfg::int32 left{this, "Left", EVDEV_DPAD_HAT_AXIS_X};
-    cfg::int32 right{this, "Right", EVDEV_DPAD_HAT_AXIS_X};
-
-    cfg::int32 rxstick{this, "Right stick X axis",  0};
-    cfg::int32 rystick{this, "Right stick Y axis",  1};
-    cfg::int32 lxstick{this, "Left stick X axis",  2};
-    cfg::int32 lystick{this, "Left stick Y axis",  3};
-
-    cfg::_bool rxreverse{this, "Reverse right stick X axis", false};
-    cfg::_bool ryreverse{this, "Reverse right stick Y axis", false};
-    cfg::_bool lxreverse{this, "Reverse left stick X axis", false};
-    cfg::_bool lyreverse{this, "Reverse left stick Y axis", false};
-
-    cfg::_bool axistrigger{this, "Z axis triggers", true};
-    cfg::_bool squirclejoysticks{this, "Squircle Joysticks", true};
-    cfg::int32 squirclefactor{this, "Squircle Factor", 5000};
-    cfg::int32 deadzone{this, "Deadzone", 10};
-    cfg::_bool left_analog_to_dpad{this, "Left Analog to Dpad", false};
-
-    bool load()
-    {
-        if (fs::file cfg_file{ cfg_name, fs::read })
-        {
-            return from_string(cfg_file.to_string());
-        }
-
-        return false;
-    }
-
-    void save()
-    {
-        fs::file(cfg_name, fs::rewrite).write(to_string());
-    }
-};
-
-
 class evdev_joystick_handler final : public PadHandlerBase
 {
-public:
-    evdev_joystick_handler();
-    ~evdev_joystick_handler();
+	// Unique button names for the config files and our pad settings dialog
+	const std::unordered_map<u32, std::string> button_list =
+	{
+		//{ BTN_MISC            , "Misc"        }, same as BTN_0
+		{ BTN_0               , "0"           },
+		{ BTN_1               , "1"           },
+		{ BTN_2               , "2"           },
+		{ BTN_3               , "3"           },
+		{ BTN_4               , "4"           },
+		{ BTN_5               , "5"           },
+		{ BTN_6               , "6"           },
+		{ BTN_7               , "7"           },
+		{ BTN_8               , "8"           },
+		{ BTN_9               , "9"           },
+		//{ BTN_MOUSE           , "Mouse"       }, same as BTN_LEFT
+		{ BTN_LEFT            , "Left"        },
+		{ BTN_RIGHT           , "Right"       },
+		{ BTN_MIDDLE          , "Middle"      },
+		{ BTN_SIDE            , "Side"        },
+		{ BTN_EXTRA           , "Extra"       },
+		{ BTN_FORWARD         , "Forward"     },
+		{ BTN_BACK            , "Back"        },
+		{ BTN_TASK            , "Task"        },
+		{ BTN_JOYSTICK        , "Joystick"    },
+		{ BTN_TRIGGER         , "Trigger"     },
+		{ BTN_THUMB           , "Thumb"       },
+		{ BTN_THUMB2          , "Thumb 2"     },
+		{ BTN_TOP             , "Top"         },
+		{ BTN_TOP2            , "Top 2"       },
+		{ BTN_PINKIE          , "Pinkie"      },
+		{ BTN_BASE            , "Base"        },
+		{ BTN_BASE2           , "Base 2"      },
+		{ BTN_BASE3           , "Base 3"      },
+		{ BTN_BASE4           , "Base 4"      },
+		{ BTN_BASE5           , "Base 5"      },
+		{ BTN_BASE6           , "Base 6"      },
+		{ BTN_DEAD            , "Dead"        },
+		//{ BTN_GAMEPAD         , "Gamepad"     }, same as BTN_A
+		//{ BTN_SOUTH           , "South"       }, same as BTN_A
+		{ BTN_A               , "A"           },
+		//{ BTN_EAST            , "South"       }, same as BTN_B
+		{ BTN_B               , "B"           },
+		{ BTN_C               , "C"           },
+		//{ BTN_NORTH           , "North"       }, same as BTN_X
+		{ BTN_X               , "X"           },
+		//{ BTN_WEST            , "West"        }, same as BTN_Y
+		{ BTN_Y               , "Y"           },
+		{ BTN_Z               , "Z"           },
+		{ BTN_TL              , "TL"          },
+		{ BTN_TR              , "TR"          },
+		{ BTN_TL2             , "TL 2"        },
+		{ BTN_TR2             , "TR 2"        },
+		{ BTN_SELECT          , "Select"      },
+		{ BTN_START           , "Start"       },
+		{ BTN_MODE            , "Mode"        },
+		{ BTN_THUMBL          , "Thumb L"     },
+		{ BTN_THUMBR          , "Thumb R"     },
+		//{ BTN_DIGI            , "Digi"        }, same as BTN_TOOL_PEN
+		{ BTN_TOOL_PEN        , "Pen"         },
+		{ BTN_TOOL_RUBBER     , "Rubber"      },
+		{ BTN_TOOL_BRUSH      , "Brush"       },
+		{ BTN_TOOL_PENCIL     , "Pencil"      },
+		{ BTN_TOOL_AIRBRUSH   , "Airbrush"    },
+		{ BTN_TOOL_FINGER     , "Finger"      },
+		{ BTN_TOOL_MOUSE      , "Mouse"       },
+		{ BTN_TOOL_LENS       , "Lense"       },
+		{ BTN_TOOL_QUINTTAP   , "Quinttap"    },
+		{ BTN_TOUCH           , "Touch"       },
+		{ BTN_STYLUS          , "Stylus"      },
+		{ BTN_STYLUS2         , "Stylus 2"    },
+		{ BTN_TOOL_DOUBLETAP  , "Doubletap"   },
+		{ BTN_TOOL_TRIPLETAP  , "Tripletap"   },
+		{ BTN_TOOL_QUADTAP    , "Quadtap"     },
+		//{ BTN_WHEEL           , "Wheel"       }, same as BTN_GEAR_DOWN
+		{ BTN_GEAR_DOWN       , "Gear Up"     },
+		{ BTN_GEAR_UP         , "Gear Down"   },
+		{ BTN_DPAD_UP         , "D-Pad Up"    },
+		{ BTN_DPAD_DOWN       , "D-Pad Down"  },
+		{ BTN_DPAD_LEFT       , "D-Pad Left"  },
+		{ BTN_DPAD_RIGHT      , "D-Pad Right" },
+		{ BTN_TRIGGER_HAPPY   , "Happy"       },
+		{ BTN_TRIGGER_HAPPY1  , "Happy 1"     },
+		{ BTN_TRIGGER_HAPPY2  , "Happy 2"     },
+		{ BTN_TRIGGER_HAPPY3  , "Happy 3"     },
+		{ BTN_TRIGGER_HAPPY4  , "Happy 4"     },
+		{ BTN_TRIGGER_HAPPY5  , "Happy 5"     },
+		{ BTN_TRIGGER_HAPPY6  , "Happy 6"     },
+		{ BTN_TRIGGER_HAPPY7  , "Happy 7"     },
+		{ BTN_TRIGGER_HAPPY8  , "Happy 8"     },
+		{ BTN_TRIGGER_HAPPY9  , "Happy 9"     },
+		{ BTN_TRIGGER_HAPPY10 , "Happy 10"    },
+		{ BTN_TRIGGER_HAPPY11 , "Happy 11"    },
+		{ BTN_TRIGGER_HAPPY12 , "Happy 12"    },
+		{ BTN_TRIGGER_HAPPY13 , "Happy 13"    },
+		{ BTN_TRIGGER_HAPPY14 , "Happy 14"    },
+		{ BTN_TRIGGER_HAPPY15 , "Happy 15"    },
+		{ BTN_TRIGGER_HAPPY16 , "Happy 16"    },
+		{ BTN_TRIGGER_HAPPY17 , "Happy 17"    },
+		{ BTN_TRIGGER_HAPPY18 , "Happy 18"    },
+		{ BTN_TRIGGER_HAPPY19 , "Happy 19"    },
+		{ BTN_TRIGGER_HAPPY20 , "Happy 20"    },
+		{ BTN_TRIGGER_HAPPY21 , "Happy 21"    },
+		{ BTN_TRIGGER_HAPPY22 , "Happy 22"    },
+		{ BTN_TRIGGER_HAPPY23 , "Happy 23"    },
+		{ BTN_TRIGGER_HAPPY24 , "Happy 24"    },
+		{ BTN_TRIGGER_HAPPY25 , "Happy 25"    },
+		{ BTN_TRIGGER_HAPPY26 , "Happy 26"    },
+		{ BTN_TRIGGER_HAPPY27 , "Happy 27"    },
+		{ BTN_TRIGGER_HAPPY28 , "Happy 28"    },
+		{ BTN_TRIGGER_HAPPY29 , "Happy 29"    },
+		{ BTN_TRIGGER_HAPPY30 , "Happy 30"    },
+		{ BTN_TRIGGER_HAPPY31 , "Happy 31"    },
+		{ BTN_TRIGGER_HAPPY32 , "Happy 32"    },
+		{ BTN_TRIGGER_HAPPY33 , "Happy 33"    },
+		{ BTN_TRIGGER_HAPPY34 , "Happy 34"    },
+		{ BTN_TRIGGER_HAPPY35 , "Happy 35"    },
+		{ BTN_TRIGGER_HAPPY36 , "Happy 36"    },
+		{ BTN_TRIGGER_HAPPY37 , "Happy 37"    },
+		{ BTN_TRIGGER_HAPPY38 , "Happy 38"    },
+		{ BTN_TRIGGER_HAPPY39 , "Happy 39"    },
+		{ BTN_TRIGGER_HAPPY40 , "Happy 40"    },
+	};
 
-    bool Init() override;
-    std::vector<std::string> ListDevices() override;
-    bool bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device) override;
-    void ThreadProc() override;
-    void Close();
+	// Unique positive axis names for the config files and our pad settings dialog
+	const std::unordered_map<u32, std::string> axis_list =
+	{
+		{ ABS_X              , "LX+"          },
+		{ ABS_Y              , "LY+"          },
+		{ ABS_Z              , "LZ+"          },
+		{ ABS_RX             , "RX+"          },
+		{ ABS_RY             , "RY+"          },
+		{ ABS_RZ             , "RZ+"          },
+		{ ABS_THROTTLE       , "Throttle+"    },
+		{ ABS_RUDDER         , "Rudder+"      },
+		{ ABS_WHEEL          , "Wheel+"       },
+		{ ABS_GAS            , "Gas+"         },
+		{ ABS_BRAKE          , "Brake+"       },
+		{ ABS_HAT0X          , "Hat0 X+"      },
+		{ ABS_HAT0Y          , "Hat0 Y+"      },
+		{ ABS_HAT1X          , "Hat1 X+"      },
+		{ ABS_HAT1Y          , "Hat1 Y+"      },
+		{ ABS_HAT2X          , "Hat2 X+"      },
+		{ ABS_HAT2Y          , "Hat2 Y+"      },
+		{ ABS_HAT3X          , "Hat3 X+"      },
+		{ ABS_HAT3Y          , "Hat3 Y+"      },
+		{ ABS_PRESSURE       , "Pressure+"    },
+		{ ABS_DISTANCE       , "Distance+"    },
+		{ ABS_TILT_X         , "Tilt X+"      },
+		{ ABS_TILT_Y         , "Tilt Y+"      },
+		{ ABS_TOOL_WIDTH     , "Width+"       },
+		{ ABS_VOLUME         , "Volume+"      },
+		{ ABS_MISC           , "Misc+"        },
+		{ ABS_MT_SLOT        , "Slot+"        },
+		{ ABS_MT_TOUCH_MAJOR , "MT TMaj+"     },
+		{ ABS_MT_TOUCH_MINOR , "MT TMin+"     },
+		{ ABS_MT_WIDTH_MAJOR , "MT WMaj+"     },
+		{ ABS_MT_WIDTH_MINOR , "MT WMin+"     },
+		{ ABS_MT_ORIENTATION , "MT Orient+"   },
+		{ ABS_MT_POSITION_X  , "MT PosX+"     },
+		{ ABS_MT_POSITION_Y  , "MT PosY+"     },
+		{ ABS_MT_TOOL_TYPE   , "MT TType+"    },
+		{ ABS_MT_BLOB_ID     , "MT Blob ID+"  },
+		{ ABS_MT_TRACKING_ID , "MT Track ID+" },
+		{ ABS_MT_PRESSURE    , "MT Pressure+" },
+		{ ABS_MT_DISTANCE    , "MT Distance+" },
+		{ ABS_MT_TOOL_X      , "MT Tool X+"   },
+		{ ABS_MT_TOOL_Y      , "MT Tool Y+"   },
+	};
+
+	// Unique negative axis names for the config files and our pad settings dialog
+	const std::unordered_map<u32, std::string> rev_axis_list =
+	{
+		{ ABS_X              , "LX-"          },
+		{ ABS_Y              , "LY-"          },
+		{ ABS_Z              , "LZ-"          },
+		{ ABS_RX             , "RX-"          },
+		{ ABS_RY             , "RY-"          },
+		{ ABS_RZ             , "RZ-"          },
+		{ ABS_THROTTLE       , "Throttle-"    },
+		{ ABS_RUDDER         , "Rudder-"      },
+		{ ABS_WHEEL          , "Wheel-"       },
+		{ ABS_GAS            , "Gas-"         },
+		{ ABS_BRAKE          , "Brake-"       },
+		{ ABS_HAT0X          , "Hat0 X-"      },
+		{ ABS_HAT0Y          , "Hat0 Y-"      },
+		{ ABS_HAT1X          , "Hat1 X-"      },
+		{ ABS_HAT1Y          , "Hat1 Y-"      },
+		{ ABS_HAT2X          , "Hat2 X-"      },
+		{ ABS_HAT2Y          , "Hat2 Y-"      },
+		{ ABS_HAT3X          , "Hat3 X-"      },
+		{ ABS_HAT3Y          , "Hat3 Y-"      },
+		{ ABS_PRESSURE       , "Pressure-"    },
+		{ ABS_DISTANCE       , "Distance-"    },
+		{ ABS_TILT_X         , "Tilt X-"      },
+		{ ABS_TILT_Y         , "Tilt Y-"      },
+		{ ABS_TOOL_WIDTH     , "Width-"       },
+		{ ABS_VOLUME         , "Volume-"      },
+		{ ABS_MISC           , "Misc-"        },
+		{ ABS_MT_SLOT        , "Slot-"        },
+		{ ABS_MT_TOUCH_MAJOR , "MT TMaj-"     },
+		{ ABS_MT_TOUCH_MINOR , "MT TMin-"     },
+		{ ABS_MT_WIDTH_MAJOR , "MT WMaj-"     },
+		{ ABS_MT_WIDTH_MINOR , "MT WMin-"     },
+		{ ABS_MT_ORIENTATION , "MT Orient-"   },
+		{ ABS_MT_POSITION_X  , "MT PosX-"     },
+		{ ABS_MT_POSITION_Y  , "MT PosY-"     },
+		{ ABS_MT_TOOL_TYPE   , "MT TType-"    },
+		{ ABS_MT_BLOB_ID     , "MT Blob ID-"  },
+		{ ABS_MT_TRACKING_ID , "MT Track ID-" },
+		{ ABS_MT_PRESSURE    , "MT Pressure-" },
+		{ ABS_MT_DISTANCE    , "MT Distance-" },
+		{ ABS_MT_TOOL_X      , "MT Tool X-"   },
+		{ ABS_MT_TOOL_Y      , "MT Tool Y-"   },
+	};
+
+	struct EvdevDevice
+	{
+		libevdev* device;
+		std::string path;
+		std::shared_ptr<Pad> pad;
+		std::unordered_map<int, bool> axis_orientations; // value is true if key was found in rev_axis_list
+		float stick_val[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
+		u16 val_min[4] = { 0, 0, 0, 0 };
+		u16 val_max[4] = { 0, 0, 0, 0 };
+	};
+
+	const int BUTTON_COUNT = 17;
+
+public:
+	evdev_joystick_handler();
+	~evdev_joystick_handler();
+
+	bool Init() override;
+	std::vector<std::string> ListDevices() override;
+	bool bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device) override;
+	void ThreadProc() override;
+	void Close();
+	void GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& callback) override;
+	void TestVibration(const std::string& padId, u32 largeMotor, u32 smallMotor) override;
 
 private:
-    void update_devs();
-    std::tuple<u16, u16> ConvertToSquirclePoint(u16 inX, u16 inY);
-    bool try_open_dev(u32 index);
-    int scale_axis(int axis, int value);
+	void TranslateButtonPress(u64 keyCode, bool& pressed, u16& value, bool ignore_threshold = false) override;
+	bool update_device(EvdevDevice& device, bool use_cell = true);
+	void update_devs(bool use_cell = true);
+	int add_device(const std::string& device, bool in_settings = false, std::shared_ptr<Pad> pad = nullptr, const std::unordered_map<int, bool>& axis_map = std::unordered_map<int, bool>());
+	int GetButtonInfo(const input_event& evt, libevdev* dev, int& button_code, bool& is_negative);
+	std::unordered_map<u64, std::pair<u16, bool>> GetButtonValues(libevdev* dev);
 
-    std::vector<std::string> joy_paths;
-    std::vector<std::shared_ptr<Pad>> pads;
-    std::vector<libevdev*> joy_devs;
-    std::vector<std::vector<int>> joy_button_maps;
-    std::vector<std::vector<int>> joy_axis_maps;
-    // joy_axis is only used for squircling
-    std::vector<std::vector<int>> joy_axis;
-    std::vector<int> joy_hat_ids;
-    bool axistrigger;
-    std::map<int, std::pair<int, int>> axis_ranges;
-    std::vector<bool> revaxis;
+	// Search axis_orientations map for the direction by index, returns -1 if not found, 0 for positive and 1 for negative
+	int FindAxisDirection(const std::unordered_map<int, bool>& map, int index);
+
+	std::vector<EvdevDevice> devices;
+	int m_pad_index = -1;
 };
diff --git a/rpcs3/keyboard_pad_handler.cpp b/rpcs3/keyboard_pad_handler.cpp
index 73bf21580f..5055d34add 100644
--- a/rpcs3/keyboard_pad_handler.cpp
+++ b/rpcs3/keyboard_pad_handler.cpp
@@ -6,7 +6,8 @@
 
 #include "rpcs3qt/pad_settings_dialog.h"
 
-keyboard_pad_config g_kbpad_config;
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
+constexpr auto qstr = QString::fromStdString;
 
 bool keyboard_pad_handler::Init()
 {
@@ -15,17 +16,48 @@ bool keyboard_pad_handler::Init()
 
 keyboard_pad_handler::keyboard_pad_handler() : QObject()
 {
-	b_has_config = true;
-}
+	// Set this handler's type and save location
+	m_pad_config.cfg_type = "keyboard";
+	m_pad_config.cfg_name = fs::get_config_dir() + "/config_kbpad_qt.yml";
 
-void keyboard_pad_handler::ConfigController(std::string device)
-{
-	pad_settings_dialog dlg;
-	dlg.exec();
+	// Set default button mapping
+	m_pad_config.ls_left.def  = GetKeyName(Qt::Key_A);
+	m_pad_config.ls_down.def  = GetKeyName(Qt::Key_S);
+	m_pad_config.ls_right.def = GetKeyName(Qt::Key_D);
+	m_pad_config.ls_up.def    = GetKeyName(Qt::Key_W);
+	m_pad_config.rs_left.def  = GetKeyName(Qt::Key_Home);
+	m_pad_config.rs_down.def  = GetKeyName(Qt::Key_PageDown);
+	m_pad_config.rs_right.def = GetKeyName(Qt::Key_End);
+	m_pad_config.rs_up.def    = GetKeyName(Qt::Key_PageUp);
+	m_pad_config.start.def    = GetKeyName(Qt::Key_Return);
+	m_pad_config.select.def   = GetKeyName(Qt::Key_Space);
+	m_pad_config.ps.def       = GetKeyName(Qt::Key_Backspace);
+	m_pad_config.square.def   = GetKeyName(Qt::Key_Z);
+	m_pad_config.cross.def    = GetKeyName(Qt::Key_X);
+	m_pad_config.circle.def   = GetKeyName(Qt::Key_C);
+	m_pad_config.triangle.def = GetKeyName(Qt::Key_V);
+	m_pad_config.left.def     = GetKeyName(Qt::Key_Left);
+	m_pad_config.down.def     = GetKeyName(Qt::Key_Down);
+	m_pad_config.right.def    = GetKeyName(Qt::Key_Right);
+	m_pad_config.up.def       = GetKeyName(Qt::Key_Up);
+	m_pad_config.r1.def       = GetKeyName(Qt::Key_E);
+	m_pad_config.r2.def       = GetKeyName(Qt::Key_T);
+	m_pad_config.r3.def       = GetKeyName(Qt::Key_G);
+	m_pad_config.l1.def       = GetKeyName(Qt::Key_Q);
+	m_pad_config.l2.def       = GetKeyName(Qt::Key_R);
+	m_pad_config.l3.def       = GetKeyName(Qt::Key_F);
+
+	// apply defaults
+	m_pad_config.from_default();
+
+	// set capabilities
+	b_has_config = true;
 }
 
 void keyboard_pad_handler::Key(const u32 code, bool pressed, u16 value)
 {
+	value = Clamp0To255(value);
+
 	for (auto pad : bindings)
 	{
 		for (Button& button : pad->m_buttons)
@@ -33,13 +65,10 @@ void keyboard_pad_handler::Key(const u32 code, bool pressed, u16 value)
 			if (button.m_keyCode != code)
 				continue;
 
-			if (value >= 256) { value = 255; }
-
 			//Todo: Is this flush necessary once games hit decent speeds?
 			if (button.m_pressed && !pressed)
 			{
 				button.m_flush = true;
-
 			}
 			else
 			{
@@ -76,7 +105,6 @@ void keyboard_pad_handler::Key(const u32 code, bool pressed, u16 value)
 	}
 }
 
-
 bool keyboard_pad_handler::eventFilter(QObject* target, QEvent* ev)
 {
 	// !m_target is for future proofing when gsrender isn't automatically initialized on load.
@@ -123,36 +151,29 @@ void keyboard_pad_handler::keyPressEvent(QKeyEvent* event)
 	{
 		case Qt::Key_L:
 			if (!(event->modifiers() == Qt::AltModifier)) { Key(event->key(), 1); }
-			event->ignore();
 			break;
 		case Qt::Key_Return:
 			if (!(event->modifiers() == Qt::AltModifier)) { Key(event->key(), 1); }
-			event->ignore();
 			break;
 		case Qt::Key_Escape:
-			event->ignore();
 			break;
 		case Qt::Key_P:
 			if (!(event->modifiers() == Qt::ControlModifier)) { Key(event->key(), 1); }
-			event->ignore();
 			break;
 		case Qt::Key_S:
 			if (!(event->modifiers() == Qt::ControlModifier)) { Key(event->key(), 1); }
-			event->ignore();
 			break;
 		case Qt::Key_R:
 			if (!(event->modifiers() == Qt::ControlModifier)) { Key(event->key(), 1); }
-			event->ignore();
 			break;
 		case Qt::Key_E:
 			if (!(event->modifiers() == Qt::ControlModifier)) { Key(event->key(), 1); }
-			event->ignore();
 			break;
 		default:
 			Key(event->key(), 1);
-			event->ignore();
 			break;
 	}
+	event->ignore();
 }
 
 void keyboard_pad_handler::keyReleaseEvent(QKeyEvent* event)
@@ -174,42 +195,119 @@ std::vector<std::string> keyboard_pad_handler::ListDevices()
 	return list_devices;
 }
 
+std::string keyboard_pad_handler::GetKeyName(const QKeyEvent* keyEvent)
+{
+	//TODO what about numpad?
+	// Fix some unknown button names
+	switch (keyEvent->key())
+	{
+	case Qt::Key_Alt:
+		return "Alt";
+	case Qt::Key_AltGr:
+		return "AltGr";
+	case Qt::Key_Shift:
+		return "Shift";
+	case Qt::Key_Control:
+		return "Ctrl";
+	case Qt::Key_NumLock:
+		return sstr(QKeySequence(keyEvent->key()).toString(QKeySequence::NativeText));
+	default:
+		break;
+	}
+	return sstr(QKeySequence(keyEvent->key() | keyEvent->modifiers()).toString(QKeySequence::NativeText));
+}
+
+std::string keyboard_pad_handler::GetKeyName(const u32& keyCode)
+{
+	//TODO what about numpad?
+	return sstr(QKeySequence(keyCode).toString(QKeySequence::NativeText));
+}
+
+u32 keyboard_pad_handler::GetKeyCode(const std::string& keyName)
+{
+	if (keyName == "Alt")
+		return Qt::Key_Alt;
+	else if (keyName == "AltGr")
+		return Qt::Key_AltGr;
+	else if (keyName == "Shift")
+		return Qt::Key_Shift;
+	else if (keyName == "Ctrl")
+		return Qt::Key_Control;
+
+	QString key = qstr(keyName);
+	QKeySequence seq(key);
+	u32 keyCode;
+	// We should only working with a single key here
+	if (seq.count() == 1)
+	{
+		keyCode = seq[0];
+	}
+	else
+	{
+		// Should be here only if a modifier key (e.g. Ctrl, Alt) is pressed.
+		if (seq.count() != 0)
+		{
+			return 0;
+		}
+		// Add a non-modifier key "A" to the picture because QKeySequence
+		// seems to need that to acknowledge the modifier. We know that A has
+		// a keyCode of 65 (or 0x41 in hex)
+		seq = QKeySequence(key + "+A");
+		if (seq.count() != 0 || seq[0] <= 65)
+		{
+			return 0;
+		}
+		keyCode = seq[0] - 65;
+	}
+	return keyCode;
+}
+
 bool keyboard_pad_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device)
 {
 	if (device != "Keyboard") return false;
 
-	g_kbpad_config.load();
+	m_pad_config.load();
 
 	//Fixed assign change, default is both sensor and press off
-	pad->Init(
+	pad->Init
+	(
 		CELL_PAD_STATUS_CONNECTED | CELL_PAD_STATUS_ASSIGN_CHANGES,
 		CELL_PAD_SETTING_PRESS_OFF | CELL_PAD_SETTING_SENSOR_OFF,
-		CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE,
+		CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE | CELL_PAD_CAPABILITY_HP_ANALOG_STICK | CELL_PAD_CAPABILITY_ACTUATOR | CELL_PAD_CAPABILITY_SENSOR_MODE,
 		CELL_PAD_DEV_TYPE_STANDARD
 	);
 
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_kbpad_config.left, CELL_PAD_CTRL_LEFT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_kbpad_config.down, CELL_PAD_CTRL_DOWN);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_kbpad_config.right, CELL_PAD_CTRL_RIGHT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_kbpad_config.up, CELL_PAD_CTRL_UP);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_kbpad_config.start, CELL_PAD_CTRL_START);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_kbpad_config.r3, CELL_PAD_CTRL_R3);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_kbpad_config.l3, CELL_PAD_CTRL_L3);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_kbpad_config.select, CELL_PAD_CTRL_SELECT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, GetKeyCode(m_pad_config.left),     CELL_PAD_CTRL_LEFT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, GetKeyCode(m_pad_config.down),     CELL_PAD_CTRL_DOWN);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, GetKeyCode(m_pad_config.right),    CELL_PAD_CTRL_RIGHT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, GetKeyCode(m_pad_config.up),       CELL_PAD_CTRL_UP);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, GetKeyCode(m_pad_config.start),    CELL_PAD_CTRL_START);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, GetKeyCode(m_pad_config.r3),       CELL_PAD_CTRL_R3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, GetKeyCode(m_pad_config.l3),       CELL_PAD_CTRL_L3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, GetKeyCode(m_pad_config.select),   CELL_PAD_CTRL_SELECT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.ps),       0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x0); // Reserved
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.square),   CELL_PAD_CTRL_SQUARE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.cross),    CELL_PAD_CTRL_CROSS);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.circle),   CELL_PAD_CTRL_CIRCLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.triangle), CELL_PAD_CTRL_TRIANGLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.r1),       CELL_PAD_CTRL_R1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.l1),       CELL_PAD_CTRL_L1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.r2),       CELL_PAD_CTRL_R2);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, GetKeyCode(m_pad_config.l2),       CELL_PAD_CTRL_L2);
 
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_kbpad_config.square, CELL_PAD_CTRL_SQUARE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_kbpad_config.cross, CELL_PAD_CTRL_CROSS);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_kbpad_config.circle, CELL_PAD_CTRL_CIRCLE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_kbpad_config.triangle, CELL_PAD_CTRL_TRIANGLE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_kbpad_config.r1, CELL_PAD_CTRL_R1);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_kbpad_config.l1, CELL_PAD_CTRL_L1);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_kbpad_config.r2, CELL_PAD_CTRL_R2);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_kbpad_config.l2, CELL_PAD_CTRL_L2);
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X,  GetKeyCode(m_pad_config.ls_left), GetKeyCode(m_pad_config.ls_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y,  GetKeyCode(m_pad_config.ls_up),   GetKeyCode(m_pad_config.ls_down));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, GetKeyCode(m_pad_config.rs_left), GetKeyCode(m_pad_config.rs_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, GetKeyCode(m_pad_config.rs_up),   GetKeyCode(m_pad_config.rs_down));
 
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X, g_kbpad_config.left_stick_left, g_kbpad_config.left_stick_right);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y, g_kbpad_config.left_stick_up, g_kbpad_config.left_stick_down);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, g_kbpad_config.right_stick_left, g_kbpad_config.right_stick_right);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, g_kbpad_config.right_stick_up, g_kbpad_config.right_stick_down);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_X, 512);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Y, 399);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Z, 512);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_G, 512);
+
+	pad->m_vibrateMotors.emplace_back(true, 0);
+	pad->m_vibrateMotors.emplace_back(false, 0);
 
 	bindings.push_back(pad);
 
diff --git a/rpcs3/keyboard_pad_handler.h b/rpcs3/keyboard_pad_handler.h
index 4bc69e3965..774f8bc5c2 100644
--- a/rpcs3/keyboard_pad_handler.h
+++ b/rpcs3/keyboard_pad_handler.h
@@ -8,51 +8,6 @@
 #include <QWindow>
 #include <QKeyEvent>
 
-struct keyboard_pad_config final : cfg::node
-{
-	const std::string cfg_name = fs::get_config_dir() + "/config_kbpad_qt.yml";
-
-	cfg::int32 left_stick_left{ this, "Left Analog Stick Left", Qt::Key_A };
-	cfg::int32 left_stick_down{ this, "Left Analog Stick Down", Qt::Key_S };
-	cfg::int32 left_stick_right{ this, "Left Analog Stick Right", Qt::Key_D };
-	cfg::int32 left_stick_up{ this, "Left Analog Stick Up", Qt::Key_W };
-	cfg::int32 right_stick_left{ this, "Right Analog Stick Left", Qt::Key_Home };
-	cfg::int32 right_stick_down{ this, "Right Analog Stick Down", Qt::Key_PageDown };
-	cfg::int32 right_stick_right{ this, "Right Analog Stick Right", Qt::Key_End };
-	cfg::int32 right_stick_up{ this, "Right Analog Stick Up", Qt::Key_PageUp };
-	cfg::int32 start{ this, "Start", Qt::Key_Return };
-	cfg::int32 select{ this, "Select", Qt::Key_Space };
-	cfg::int32 square{ this, "Square", Qt::Key_Z };
-	cfg::int32 cross{ this, "Cross", Qt::Key_X };
-	cfg::int32 circle{ this, "Circle", Qt::Key_C };
-	cfg::int32 triangle{ this, "Triangle", Qt::Key_V };
-	cfg::int32 left{ this, "Left", Qt::Key_Left };
-	cfg::int32 down{ this, "Down", Qt::Key_Down };
-	cfg::int32 right{ this, "Right", Qt::Key_Right };
-	cfg::int32 up{ this, "Up", Qt::Key_Up };
-	cfg::int32 r1{ this, "R1", Qt::Key_E };
-	cfg::int32 r2{ this, "R2", Qt::Key_T };
-	cfg::int32 r3{ this, "R3", Qt::Key_G };
-	cfg::int32 l1{ this, "L1", Qt::Key_Q };
-	cfg::int32 l2{ this, "L2", Qt::Key_R };
-	cfg::int32 l3{ this, "L3", Qt::Key_F };
-
-	bool load()
-	{
-		if (fs::file cfg_file{ cfg_name, fs::read })
-		{
-			return from_string(cfg_file.to_string());
-		}
-
-		return false;
-	}
-
-	void save()
-	{
-		fs::file(cfg_name, fs::rewrite).write(to_string());
-	}
-};
-
 class keyboard_pad_handler final : public QObject, public PadHandlerBase
 {
 public:
@@ -69,7 +24,10 @@ public:
 	std::vector<std::string> ListDevices() override;
 	bool bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device) override;
 	void ThreadProc() override;
-	void ConfigController(std::string device) override;
+
+	std::string GetKeyName(const QKeyEvent* keyEvent);
+	std::string GetKeyName(const u32& keyCode);
+	u32 GetKeyCode(const std::string& keyName);
 
 protected:
 	void Key(const u32 code, bool pressed, u16 value = 255);
diff --git a/rpcs3/main.cpp b/rpcs3/main.cpp
index 609fececfc..beaee47a43 100644
--- a/rpcs3/main.cpp
+++ b/rpcs3/main.cpp
@@ -13,7 +13,7 @@
 #include <windows.h>
 #endif
 
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 
 template <typename... Args>
 inline auto tr(Args&&... args)
diff --git a/rpcs3/mm_joystick_handler.cpp b/rpcs3/mm_joystick_handler.cpp
index cb3097f0b1..d77c685527 100644
--- a/rpcs3/mm_joystick_handler.cpp
+++ b/rpcs3/mm_joystick_handler.cpp
@@ -2,9 +2,8 @@
 #ifdef _WIN32
 #include "mm_joystick_handler.h"
 
-mm_joystick_config g_mmjoystick_config;
-
-namespace {
+namespace
+{
 	const DWORD THREAD_SLEEP = 10;
 	const DWORD THREAD_SLEEP_INACTIVE = 100;
 	const DWORD THREAD_TIMEOUT = 1000;
@@ -15,9 +14,56 @@ namespace {
 	}
 }
 
-
 mm_joystick_handler::mm_joystick_handler() : is_init(false)
 {
+	// Set this handler's type and save location
+	m_pad_config.cfg_type = "mmjoystick";
+	m_pad_config.cfg_name = fs::get_config_dir() + "/config_mmjoystick.yml";
+
+	// Set default button mapping
+	m_pad_config.ls_left.def  = axis_list.at(mmjoy_axis::joy_x_neg);
+	m_pad_config.ls_down.def  = axis_list.at(mmjoy_axis::joy_y_neg);
+	m_pad_config.ls_right.def = axis_list.at(mmjoy_axis::joy_x_pos);
+	m_pad_config.ls_up.def    = axis_list.at(mmjoy_axis::joy_y_pos);
+	m_pad_config.rs_left.def  = axis_list.at(mmjoy_axis::joy_u_neg);
+	m_pad_config.rs_down.def  = axis_list.at(mmjoy_axis::joy_r_neg);
+	m_pad_config.rs_right.def = axis_list.at(mmjoy_axis::joy_u_pos);
+	m_pad_config.rs_up.def    = axis_list.at(mmjoy_axis::joy_r_pos);
+	m_pad_config.start.def    = button_list.at(JOY_BUTTON8);
+	m_pad_config.select.def   = button_list.at(JOY_BUTTON7);
+	m_pad_config.ps.def       = button_list.at(JOY_BUTTON17);
+	m_pad_config.square.def   = button_list.at(JOY_BUTTON3);
+	m_pad_config.cross.def    = button_list.at(JOY_BUTTON1);
+	m_pad_config.circle.def   = button_list.at(JOY_BUTTON2);
+	m_pad_config.triangle.def = button_list.at(JOY_BUTTON4);
+	m_pad_config.left.def     = pov_list.at(JOY_POVLEFT);
+	m_pad_config.down.def     = pov_list.at(JOY_POVBACKWARD);
+	m_pad_config.right.def    = pov_list.at(JOY_POVRIGHT);
+	m_pad_config.up.def       = pov_list.at(JOY_POVFORWARD);
+	m_pad_config.r1.def       = button_list.at(JOY_BUTTON6);
+	m_pad_config.r2.def       = axis_list.at(mmjoy_axis::joy_z_pos);
+	m_pad_config.r3.def       = button_list.at(JOY_BUTTON10);
+	m_pad_config.l1.def       = button_list.at(JOY_BUTTON5);
+	m_pad_config.l2.def       = axis_list.at(mmjoy_axis::joy_z_neg);
+	m_pad_config.l3.def       = button_list.at(JOY_BUTTON9);
+
+	// Set default misc variables
+	m_pad_config.lstickdeadzone.def = 0;    // between 0 and 255
+	m_pad_config.rstickdeadzone.def = 0;    // between 0 and 255
+	m_pad_config.ltriggerthreshold.def = 0; // between 0 and 255
+	m_pad_config.rtriggerthreshold.def = 0; // between 0 and 255
+	m_pad_config.padsquircling.def = 8000;
+
+	// apply defaults
+	m_pad_config.from_default();
+
+	// set capabilities
+	b_has_config = true;
+	b_has_rumble = true;
+	b_has_deadzones = true;
+
+	m_trigger_threshold = trigger_max / 2;
+	m_thumb_threshold = thumb_max / 2;
 }
 
 mm_joystick_handler::~mm_joystick_handler()
@@ -50,6 +96,7 @@ bool mm_joystick_handler::Init()
 		return false;
 	}
 
+	m_pad_config.load();
 	is_init = true;
 	return true;
 }
@@ -69,38 +116,60 @@ bool mm_joystick_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::s
 {
 	if (!Init()) return false;
 
-	g_mmjoystick_config.load();
+	auto find_key = [=](const std::string& name)
+	{
+		long key = FindKeyCode(button_list, name);
+		if (key < 0)
+			key = FindKeyCode(pov_list, name);
+		if (key < 0)
+			key = FindKeyCode(axis_list, name);
+		if (key < 0)
+		{
+			LOG_ERROR(HLE, "mmjoystick FindKey(%s) returned value %d", name, key);
+			key = -1;
+		}
+		return key;
+	};
 
-	pad->Init(
-		CELL_PAD_STATUS_DISCONNECTED,
+	pad->Init
+	(
+		CELL_PAD_STATUS_CONNECTED | CELL_PAD_STATUS_ASSIGN_CHANGES,
 		CELL_PAD_SETTING_PRESS_OFF | CELL_PAD_SETTING_SENSOR_OFF,
-		CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE,
+		CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE | CELL_PAD_CAPABILITY_HP_ANALOG_STICK | CELL_PAD_CAPABILITY_ACTUATOR | CELL_PAD_CAPABILITY_SENSOR_MODE,
 		CELL_PAD_DEV_TYPE_STANDARD
 	);
 
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_mmjoystick_config.triangle, CELL_PAD_CTRL_TRIANGLE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_mmjoystick_config.circle, CELL_PAD_CTRL_CIRCLE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_mmjoystick_config.cross, CELL_PAD_CTRL_CROSS);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_mmjoystick_config.square, CELL_PAD_CTRL_SQUARE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_mmjoystick_config.l2, CELL_PAD_CTRL_L2);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_mmjoystick_config.r2, CELL_PAD_CTRL_R2);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_mmjoystick_config.l1, CELL_PAD_CTRL_L1);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, g_mmjoystick_config.r1, CELL_PAD_CTRL_R1);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_mmjoystick_config.start, CELL_PAD_CTRL_START);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_mmjoystick_config.select, CELL_PAD_CTRL_SELECT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_mmjoystick_config.l3, CELL_PAD_CTRL_L3);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, g_mmjoystick_config.r3, CELL_PAD_CTRL_R3);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.triangle), CELL_PAD_CTRL_TRIANGLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.circle),   CELL_PAD_CTRL_CIRCLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.cross),    CELL_PAD_CTRL_CROSS);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.square),   CELL_PAD_CTRL_SQUARE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.l2),       CELL_PAD_CTRL_L2);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.r2),       CELL_PAD_CTRL_R2);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.l1),       CELL_PAD_CTRL_L1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.r1),       CELL_PAD_CTRL_R1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.start),    CELL_PAD_CTRL_START);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.select),   CELL_PAD_CTRL_SELECT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.l3),       CELL_PAD_CTRL_L3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.r3),       CELL_PAD_CTRL_R3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, find_key(m_pad_config.ps),       0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.up),	     CELL_PAD_CTRL_UP);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.down),	   CELL_PAD_CTRL_DOWN);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.left),	   CELL_PAD_CTRL_LEFT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, find_key(m_pad_config.right),    CELL_PAD_CTRL_RIGHT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x0); // Reserved
 
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, JOY_POVFORWARD, CELL_PAD_CTRL_UP);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, JOY_POVBACKWARD, CELL_PAD_CTRL_DOWN);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, JOY_POVLEFT, CELL_PAD_CTRL_LEFT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, JOY_POVRIGHT, CELL_PAD_CTRL_RIGHT);
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X,  find_key(m_pad_config.ls_left), find_key(m_pad_config.ls_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y,  find_key(m_pad_config.ls_down), find_key(m_pad_config.ls_up));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, find_key(m_pad_config.rs_left), find_key(m_pad_config.rs_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, find_key(m_pad_config.rs_down), find_key(m_pad_config.rs_up));
 
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, 0, 0);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_X, 512);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Y, 399);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Z, 512);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_G, 512);
+
+	pad->m_vibrateMotors.emplace_back(true, 0);
+	pad->m_vibrateMotors.emplace_back(false, 0);
 
 	bindings.push_back(pad);
 
@@ -132,25 +201,205 @@ void mm_joystick_handler::ThreadProc()
 				pad->m_port_status |= CELL_PAD_STATUS_ASSIGN_CHANGES;
 			last_connection_status[i] = true;
 			pad->m_port_status |= CELL_PAD_STATUS_CONNECTED;
-			for (DWORD j = 0; j <= 12; j++)
+
+			auto button_values = GetButtonValues();
+
+			// Translate any corresponding keycodes to our normal DS3 buttons and triggers
+			for (auto& btn : pad->m_buttons)
 			{
-				bool pressed = js_info.dwButtons & pad->m_buttons[j].m_keyCode;
-				pad->m_buttons[j].m_pressed = pressed;
-				pad->m_buttons[j].m_value = pressed ? 255 : 0;
+				btn.m_value = button_values[btn.m_keyCode];
+				TranslateButtonPress(btn.m_keyCode, btn.m_pressed, btn.m_value);
 			}
-			for (DWORD j = 13; j <= 16; j++)//POV aka digital pad
+
+			float stick_val[4];
+
+			// Translate any corresponding keycodes to our two sticks. (ignoring thresholds for now)
+			for (int i = 0; i < static_cast<int>(pad->m_sticks.size()); i++)
 			{
-				bool pressed = js_info.dwPOV == pad->m_buttons[j].m_keyCode;
-				pad->m_buttons[j].m_pressed = pressed;
-				pad->m_buttons[j].m_value = pressed ? 255 : 0;
+				bool pressed;
+			
+				// m_keyCodeMin is the mapped key for left or down
+				u32 key_min = pad->m_sticks[i].m_keyCodeMin;
+				u16 val_min = button_values[key_min];
+				TranslateButtonPress(key_min, pressed, val_min, true);
+			
+				// m_keyCodeMax is the mapped key for right or up
+				u32 key_max = pad->m_sticks[i].m_keyCodeMax;
+				u16 val_max = button_values[key_max];
+				TranslateButtonPress(key_max, pressed, val_max, true);
+
+				// cancel out opposing values and get the resulting difference
+				stick_val[i] = val_max - val_min;
 			}
-			pad->m_sticks[0].m_value = ConvertAxis(js_info.dwXpos);
-			pad->m_sticks[1].m_value = ConvertAxis(js_info.dwYpos);
-			pad->m_sticks[2].m_value = ConvertAxis(js_info.dwZpos);
-			pad->m_sticks[3].m_value = ConvertAxis(js_info.dwRpos);
+
+			u16 lx, ly, rx, ry;
+
+			// Normalize our two stick's axis based on the thresholds
+			std::tie(lx, ly) = NormalizeStickDeadzone(stick_val[0], stick_val[1], m_pad_config.lstickdeadzone);
+			std::tie(rx, ry) = NormalizeStickDeadzone(stick_val[2], stick_val[3], m_pad_config.rstickdeadzone);
+
+			if (m_pad_config.padsquircling != 0)
+			{
+				std::tie(lx, ly) = ConvertToSquirclePoint(lx, ly, m_pad_config.padsquircling);
+				std::tie(rx, ry) = ConvertToSquirclePoint(rx, ry, m_pad_config.padsquircling);
+			}
+
+			pad->m_sticks[0].m_value = lx;
+			pad->m_sticks[1].m_value = 255 - ly;
+			pad->m_sticks[2].m_value = rx;
+			pad->m_sticks[3].m_value = 255 - ry;
+
 			break;
 		}
 	}
 }
 
+void mm_joystick_handler::GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& callback)
+{
+	if (!Init())
+	{
+		return;
+	}
+
+	MMRESULT status = joyGetPosEx(JOYSTICKID1, &js_info);
+
+	switch (status)
+	{
+	case JOYERR_UNPLUGGED:
+		break;
+
+	case JOYERR_NOERROR:
+		auto data = GetButtonValues();
+
+		// Check for each button in our list if its corresponding (maybe remapped) button or axis was pressed.
+		// Return the new value if the button was pressed (aka. its value was bigger than 0 or the defined threshold)
+		// Use a pair to get all the legally pressed buttons and use the one with highest value (prioritize first)
+		std::pair<u16, std::string> pressed_button = { 0, "" };
+		for (const auto& button : button_list)
+		{
+			u16 value = data[button.first];
+			if (value > 0 && value > pressed_button.first)
+				pressed_button = { value, button.second };
+		}
+		for (const auto& button : pov_list)
+		{
+			u16 value = data[button.first];
+			if (value > 0 && value > pressed_button.first)
+				pressed_button = { value, button.second };
+		}
+		for (const auto& button : axis_list)
+		{
+			u32 keycode = button.first;
+			u16 value = data[keycode];
+
+			if (((keycode == mmjoy_axis::joy_z_neg) && (value > m_trigger_threshold))
+			 || ((keycode == mmjoy_axis::joy_z_pos) && (value > m_trigger_threshold))
+			 || ((keycode <= mmjoy_axis::joy_y_neg) && (value > m_thumb_threshold))
+			 || ((keycode <= mmjoy_axis::joy_u_neg && keycode > mmjoy_axis::joy_z_neg) && (value > m_thumb_threshold)))
+			{
+				if (value > pressed_button.first)
+				{
+					pressed_button = { value, button.second };
+				}
+			}
+		}
+
+		int preview_values[6] = 
+		{
+			data[mmjoy_axis::joy_z_neg],
+			data[mmjoy_axis::joy_z_pos],
+			data[mmjoy_axis::joy_x_pos] - data[mmjoy_axis::joy_x_neg],
+			data[mmjoy_axis::joy_y_pos] - data[mmjoy_axis::joy_y_neg],
+			data[mmjoy_axis::joy_u_pos] - data[mmjoy_axis::joy_u_neg],
+			data[mmjoy_axis::joy_r_pos] - data[mmjoy_axis::joy_r_neg]
+		};
+
+		if (pressed_button.first > 0)
+			return callback(pressed_button.first, pressed_button.second, preview_values);
+		else
+			return callback(0, "", preview_values);
+
+		break;
+	}
+}
+
+void mm_joystick_handler::TranslateButtonPress(u64 keyCode, bool& pressed, u16& val, bool ignore_threshold)
+{
+	// Update the pad button values based on their type and thresholds.
+	// With this you can use axis or triggers as buttons or vice versa
+	switch (keyCode)
+	{
+	case mmjoy_axis::joy_z_neg:
+		pressed = val > m_pad_config.ltriggerthreshold;
+		val = pressed ? NormalizeTriggerInput(val, m_pad_config.ltriggerthreshold) : 0;
+		break;
+	case mmjoy_axis::joy_z_pos:
+		pressed = val > m_pad_config.rtriggerthreshold;
+		val = pressed ? NormalizeTriggerInput(val, m_pad_config.rtriggerthreshold) : 0;
+		break;
+	case mmjoy_axis::joy_x_pos:
+	case mmjoy_axis::joy_x_neg:
+	case mmjoy_axis::joy_y_pos:
+	case mmjoy_axis::joy_y_neg:
+		pressed = val > (ignore_threshold ? 0 : m_pad_config.lstickdeadzone);
+		val = pressed ? NormalizeStickInput(val, m_pad_config.lstickdeadzone, ignore_threshold) : 0;
+		break;
+	case mmjoy_axis::joy_r_pos:
+	case mmjoy_axis::joy_r_neg:
+	case mmjoy_axis::joy_u_pos:
+	case mmjoy_axis::joy_u_neg:
+		pressed = val > (ignore_threshold ? 0 : m_pad_config.rstickdeadzone);
+		val = pressed ? NormalizeStickInput(val, m_pad_config.rstickdeadzone, ignore_threshold) : 0;
+		break;
+	default: // normal button (should in theory also support sensitive buttons)
+		pressed = val > 0;
+		val = pressed ? val : 0;
+		break;
+	}
+}
+
+std::unordered_map<u64, u16> mm_joystick_handler::GetButtonValues()
+{
+	std::unordered_map<u64, u16> button_values;
+
+	for (auto entry : button_list)
+	{
+		button_values.emplace(entry.first, js_info.dwButtons & entry.first ? 255 : 0);
+	}
+
+	for (auto entry : pov_list)
+	{
+		button_values.emplace(entry.first, js_info.dwPOV == entry.first ? 255 : 0);
+	}
+
+	auto add_axis_value = [&](DWORD axis, u64 pos, u64 neg)
+	{
+		u16 value = 0;
+		float fvalue = ScaleStickInput(axis, 0, 65535);
+		bool is_negative = fvalue <= 127.5;
+
+		if (is_negative)
+		{
+			value = Clamp0To255((127.5f - fvalue) * 2.0f);
+			button_values.emplace(pos, 0);
+			button_values.emplace(neg, value);
+		}
+		else
+		{
+			value = Clamp0To255((fvalue - 127.5f) * 2.0f);
+			button_values.emplace(pos, value);
+			button_values.emplace(neg, 0);
+		}
+	};
+
+	add_axis_value(js_info.dwXpos, mmjoy_axis::joy_x_pos, mmjoy_axis::joy_x_neg);
+	add_axis_value(js_info.dwYpos, mmjoy_axis::joy_y_neg, mmjoy_axis::joy_y_pos);
+	add_axis_value(js_info.dwZpos, mmjoy_axis::joy_z_neg, mmjoy_axis::joy_z_pos);
+	add_axis_value(js_info.dwRpos, mmjoy_axis::joy_r_neg, mmjoy_axis::joy_r_pos);
+	add_axis_value(js_info.dwUpos, mmjoy_axis::joy_u_pos, mmjoy_axis::joy_u_neg);
+	add_axis_value(js_info.dwVpos, mmjoy_axis::joy_v_pos, mmjoy_axis::joy_v_neg);
+
+	return button_values;
+}
+
 #endif
diff --git a/rpcs3/mm_joystick_handler.h b/rpcs3/mm_joystick_handler.h
index 924c4c039a..228b4f89a5 100644
--- a/rpcs3/mm_joystick_handler.h
+++ b/rpcs3/mm_joystick_handler.h
@@ -5,53 +5,87 @@
 #include <mmsystem.h>
 #include "Utilities/Config.h"
 
-struct mm_joystick_config final : cfg::node
-{
-	const std::string cfg_name = fs::get_config_dir() + "/config_mmjoystick.yml";
-
-	//cfg::int32 left_stick_left{this, "Left Analog Stick Left", static_cast<int>('A')};
-	//cfg::int32 left_stick_down{this, "Left Analog Stick Down", static_cast<int>('S')};
-	//cfg::int32 left_stick_right{this, "Left Analog Stick Right", static_cast<int>('D')};
-	//cfg::int32 left_stick_up{this, "Left Analog Stick Up", static_cast<int>('W')};
-	//cfg::int32 right_stick_left{this, "Right Analog Stick Left", 313};
-	//cfg::int32 right_stick_down{this, "Right Analog Stick Down", 367};
-	//cfg::int32 right_stick_right{this, "Right Analog Stick Right", 312};
-	//cfg::int32 right_stick_up{this, "Right Analog Stick Up", 366};
-	cfg::int32 start{this, "Start", JOY_BUTTON9};
-	cfg::int32 select{this, "Select", JOY_BUTTON10};
-	cfg::int32 square{this, "Square", JOY_BUTTON4};
-	cfg::int32 cross{this, "Cross", JOY_BUTTON3};
-	cfg::int32 circle{this, "Circle", JOY_BUTTON2};
-	cfg::int32 triangle{this, "Triangle", JOY_BUTTON1};
-	//cfg::int32 left{this, "Left", 314};
-	//cfg::int32 down{this, "Down", 317};
-	//cfg::int32 right{this, "Right", 316};
-	//cfg::int32 up{this, "Up", 315};
-	cfg::int32 r1{this, "R1", JOY_BUTTON8};
-	cfg::int32 r2{this, "R2", JOY_BUTTON6};
-	cfg::int32 r3{this, "R3", JOY_BUTTON12};
-	cfg::int32 l1{this, "L1", JOY_BUTTON7};
-	cfg::int32 l2{this, "L2", JOY_BUTTON5};
-	cfg::int32 l3{this, "L3", JOY_BUTTON11};
-
-	bool load()
-	{
-		if (fs::file cfg_file{ cfg_name, fs::read })
-		{
-			return from_string(cfg_file.to_string());
-		}
-
-		return false;
-	}
-
-	void save()
-	{
-		fs::file(cfg_name, fs::rewrite).write(to_string());
-	}
-};
-
 class mm_joystick_handler final : public PadHandlerBase
 {
+	// Unique names for the config files and our pad settings dialog
+	const std::unordered_map<u64, std::string> button_list =
+	{
+		{ JOY_BUTTON1 , "Button 1"  },
+		{ JOY_BUTTON2 , "Button 2"  },
+		{ JOY_BUTTON3 , "Button 3"  },
+		{ JOY_BUTTON4 , "Button 4"  },
+		{ JOY_BUTTON5 , "Button 5"  },
+		{ JOY_BUTTON6 , "Button 6"  },
+		{ JOY_BUTTON7 , "Button 7"  },
+		{ JOY_BUTTON8 , "Button 8"  },
+		{ JOY_BUTTON9 , "Button 9"  },
+		{ JOY_BUTTON10, "Button 10" },
+		{ JOY_BUTTON11, "Button 11" },
+		{ JOY_BUTTON12, "Button 12" },
+		{ JOY_BUTTON13, "Button 13" },
+		{ JOY_BUTTON14, "Button 14" },
+		{ JOY_BUTTON15, "Button 15" },
+		{ JOY_BUTTON16, "Button 16" },
+		{ JOY_BUTTON17, "Button 17" },
+		{ JOY_BUTTON18, "Button 18" },
+		{ JOY_BUTTON19, "Button 19" },
+		{ JOY_BUTTON20, "Button 20" },
+		{ JOY_BUTTON21, "Button 21" },
+		{ JOY_BUTTON22, "Button 22" },
+		{ JOY_BUTTON23, "Button 23" },
+		{ JOY_BUTTON24, "Button 24" },
+		{ JOY_BUTTON25, "Button 25" },
+		{ JOY_BUTTON26, "Button 26" },
+		{ JOY_BUTTON27, "Button 27" },
+		{ JOY_BUTTON28, "Button 28" },
+		{ JOY_BUTTON29, "Button 29" },
+		{ JOY_BUTTON30, "Button 30" },
+		{ JOY_BUTTON31, "Button 31" },
+		{ JOY_BUTTON32, "Button 32" },
+	};
+
+	// Unique names for the config files and our pad settings dialog
+	const std::unordered_map<u64, std::string> pov_list =
+	{
+		{ JOY_POVFORWARD,  "POV Up"    },
+		{ JOY_POVRIGHT,    "POV Right" },
+		{ JOY_POVBACKWARD, "POV Down"  },
+		{ JOY_POVLEFT,     "POV Left"  },
+	};
+
+	enum mmjoy_axis
+	{
+		joy_x_pos = 9700,
+		joy_x_neg,
+		joy_y_pos,
+		joy_y_neg,
+		joy_z_pos,
+		joy_z_neg,
+		joy_r_pos,
+		joy_r_neg,
+		joy_u_pos,
+		joy_u_neg,
+		joy_v_pos,
+		joy_v_neg,
+	};
+
+	// Unique names for the config files and our pad settings dialog
+	const std::unordered_map<u64, std::string> axis_list =
+	{
+		{ joy_x_pos, "X+" },
+		{ joy_x_neg, "X-" },
+		{ joy_y_pos, "Y+" },
+		{ joy_y_neg, "Y-" },
+		{ joy_z_pos, "Z+" },
+		{ joy_z_neg, "Z-" },
+		{ joy_r_pos, "R+" },
+		{ joy_r_neg, "R-" },
+		{ joy_u_pos, "U+" },
+		{ joy_u_neg, "U-" },
+		{ joy_v_pos, "V+" },
+		{ joy_v_neg, "V-" },
+	};
+
 public:
 	mm_joystick_handler();
 	~mm_joystick_handler();
@@ -61,14 +95,17 @@ public:
 	std::vector<std::string> ListDevices() override;
 	bool bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device) override;
 	void ThreadProc() override;
+	void GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& callback) override;
 
 private:
+	void TranslateButtonPress(u64 keyCode, bool& pressed, u16& val, bool ignore_threshold = false) override;
+	std::unordered_map<u64, u16> GetButtonValues();
+
 	bool is_init;
 	u32 supportedJoysticks;
-	JOYINFOEX    js_info;
-	JOYCAPS   js_caps;
+	JOYINFOEX js_info;
+	JOYCAPS js_caps;
 
 	std::vector<std::shared_ptr<Pad>> bindings;
 	std::array<bool, 7> last_connection_status = {};
-
 };
diff --git a/rpcs3/pad_thread.cpp b/rpcs3/pad_thread.cpp
index 37c701d0d5..7b8a8198a0 100644
--- a/rpcs3/pad_thread.cpp
+++ b/rpcs3/pad_thread.cpp
@@ -27,8 +27,8 @@ pad_thread::~pad_thread()
 void pad_thread::Init(const u32 max_connect)
 {
 	std::memset(&m_info, 0, sizeof(m_info));
-	m_info.max_connect = max_connect;
-	m_info.now_connect = std::min(max_connect, (u32)7); // max 7 pads
+	m_info.max_connect = std::min(max_connect, (u32)7); // max 7 pads
+	m_info.now_connect = 0;
 
 	input_cfg.load();
 
@@ -38,17 +38,19 @@ void pad_thread::Init(const u32 max_connect)
 	std::shared_ptr<NullPadHandler> nullpad = std::make_shared<NullPadHandler>();
 	handlers.emplace(pad_handler::null, nullpad);
 
-	for (u32 i = 0; i < m_info.now_connect; i++)
+	for (u32 i = 0; i < m_info.max_connect; i++)
 	{
 		std::shared_ptr<PadHandlerBase> cur_pad_handler;
 
-		if (handlers.count(input_cfg.player_input[i]) != 0)
+		const auto &handler_type = input_cfg.player_input[i];
+		
+		if (handlers.count(handler_type) != 0)
 		{
-			cur_pad_handler = handlers[input_cfg.player_input[i]];
+			cur_pad_handler = handlers[handler_type];
 		}
 		else
 		{
-			switch (input_cfg.player_input[i])
+			switch (handler_type)
 			{
 			case pad_handler::keyboard:
 				keyptr = std::make_shared<keyboard_pad_handler>();
@@ -75,7 +77,7 @@ void pad_thread::Init(const u32 max_connect)
 				break;
 #endif
 			}
-			handlers.emplace(input_cfg.player_input[i], cur_pad_handler);
+			handlers.emplace(handler_type, cur_pad_handler);
 		}
 		cur_pad_handler->Init();
 
@@ -88,9 +90,11 @@ void pad_thread::Init(const u32 max_connect)
 		if (cur_pad_handler->bindPadToDevice(m_pads.back(), input_cfg.player_device[i]->to_string()) == false)
 		{
 			//Failed to bind the device to cur_pad_handler so binds to NullPadHandler
-			LOG_ERROR(GENERAL, "Failed to bind device %s to handler %s", input_cfg.player_device[i]->to_string(), input_cfg.player_input[i].to_string());
+			LOG_ERROR(GENERAL, "Failed to bind device %s to handler %s", input_cfg.player_device[i]->to_string(), handler_type.to_string());
 			nullpad->bindPadToDevice(m_pads.back(), input_cfg.player_device[i]->to_string());
 		}
+		else if (handler_type != pad_handler::null)
+			m_info.now_connect++;
 	}
 
 	thread = std::make_shared<std::thread>(&pad_thread::ThreadFunc, this);
diff --git a/rpcs3/rpcs3.vcxproj b/rpcs3/rpcs3.vcxproj
index 0c929c90da..60c435f72c 100644
--- a/rpcs3/rpcs3.vcxproj
+++ b/rpcs3/rpcs3.vcxproj
@@ -336,6 +336,7 @@
     <ClCompile Include="basic_keyboard_handler.cpp" />
     <ClCompile Include="basic_mouse_handler.cpp" />
     <ClCompile Include="ds4_pad_handler.cpp" />
+    <ClCompile Include="evdev_joystick_handler.cpp" />
     <ClCompile Include="keyboard_pad_handler.cpp" />
     <ClCompile Include="main.cpp" />
     <ClCompile Include="mm_joystick_handler.cpp" />
@@ -985,6 +986,7 @@
       <AdditionalInputs Condition="'$(Configuration)|$(Platform)'=='Debug - LLVM|x64'">$(QTDIR)\bin\moc.exe;%(FullPath);$(QTDIR)\bin\moc.exe;%(FullPath)</AdditionalInputs>
     </CustomBuild>
     <ClInclude Include="ds4_pad_handler.h" />
+    <ClInclude Include="evdev_joystick_handler.h" />
     <ClInclude Include="keyboard_pad_handler.h" />
     <CustomBuild Include="rpcs3qt\gs_frame.h">
       <Message Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">Moc%27ing gs_frame.h...</Message>
diff --git a/rpcs3/rpcs3.vcxproj.filters b/rpcs3/rpcs3.vcxproj.filters
index 359b99fbb9..f630997167 100644
--- a/rpcs3/rpcs3.vcxproj.filters
+++ b/rpcs3/rpcs3.vcxproj.filters
@@ -96,6 +96,9 @@
     <Filter Include="Gui\syntax highlighter">
       <UniqueIdentifier>{adb985ae-88db-4274-a6fd-6bcf230451ca}</UniqueIdentifier>
     </Filter>
+    <Filter Include="Io\evdev">
+      <UniqueIdentifier>{6992629a-48f1-43ec-8070-d1dba81bcbf9}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="\rpcs3qt\*.cpp">
@@ -554,6 +557,9 @@
     <ClCompile Include="rpcs3qt\syntax_highlighter.cpp">
       <Filter>Generated Files\Debug</Filter>
     </ClCompile>
+    <ClCompile Include="evdev_joystick_handler.cpp">
+      <Filter>Io\evdev</Filter>
+    </ClCompile>
     <ClCompile Include="rpcs3qt\save_manager_dialog.cpp">
       <Filter>Gui\save</Filter>
     </ClCompile>
@@ -637,6 +643,9 @@
     <ClInclude Include="rpcs3qt\trophy_tree_widget_item.h">
       <Filter>Gui\trophy</Filter>
     </ClInclude>
+    <ClInclude Include="evdev_joystick_handler.h">
+      <Filter>Io\evdev</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <CustomBuild Include="debug\moc_predefs.h.cbt">
diff --git a/rpcs3/rpcs3qt/cg_disasm_window.cpp b/rpcs3/rpcs3qt/cg_disasm_window.cpp
index 3059e2575f..ab5097dbe4 100644
--- a/rpcs3/rpcs3qt/cg_disasm_window.cpp
+++ b/rpcs3/rpcs3qt/cg_disasm_window.cpp
@@ -18,7 +18,7 @@
 #include "Emu/RSX/CgBinaryProgram.h"
 
 constexpr auto qstr = QString::fromStdString;
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 
 cg_disasm_window::cg_disasm_window(std::shared_ptr<gui_settings> xSettings): xgui_settings(xSettings)
 {
diff --git a/rpcs3/rpcs3qt/emu_settings.cpp b/rpcs3/rpcs3qt/emu_settings.cpp
index 36a1533cba..539bd1b67b 100644
--- a/rpcs3/rpcs3qt/emu_settings.cpp
+++ b/rpcs3/rpcs3qt/emu_settings.cpp
@@ -18,7 +18,7 @@
 
 extern std::string g_cfg_defaults; //! Default settings grabbed from Utilities/Config.h
 
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 inline std::string sstr(const QVariant& _in) { return sstr(_in.toString()); }
 
 // Emit sorted YAML
diff --git a/rpcs3/rpcs3qt/game_list_frame.cpp b/rpcs3/rpcs3qt/game_list_frame.cpp
index aede1fd57c..f2f80ad43a 100644
--- a/rpcs3/rpcs3qt/game_list_frame.cpp
+++ b/rpcs3/rpcs3qt/game_list_frame.cpp
@@ -24,7 +24,7 @@
 #include <QLabel>
 #include <QScrollBar>
 
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 inline QSize sizeFromSlider(const int& pos) { return gui::gl_icon_size_min + (gui::gl_icon_size_max - gui::gl_icon_size_min) * (pos / (float)gui::gl_max_slider_pos); }
 
 game_list_frame::game_list_frame(std::shared_ptr<gui_settings> guiSettings, std::shared_ptr<emu_settings> emuSettings, QWidget *parent)
diff --git a/rpcs3/rpcs3qt/game_list_frame.h b/rpcs3/rpcs3qt/game_list_frame.h
index f28d8902de..bb46d737f8 100644
--- a/rpcs3/rpcs3qt/game_list_frame.h
+++ b/rpcs3/rpcs3qt/game_list_frame.h
@@ -236,7 +236,7 @@ protected:
 	/** Override inherited method from Qt to allow signalling when close happened.*/
 	void closeEvent(QCloseEvent* event) override;
 	void resizeEvent(QResizeEvent *event) override;
-	bool eventFilter(QObject *object, QEvent *event);
+	bool eventFilter(QObject *object, QEvent *event) override;
 private:
 	QPixmap PaintedPixmap(const QImage& img, bool paintConfigIcon = false);
 	bool Boot(const GameInfo& info);
diff --git a/rpcs3/rpcs3qt/gamepads_settings_dialog.cpp b/rpcs3/rpcs3qt/gamepads_settings_dialog.cpp
index 6f0718af97..36a652b73d 100644
--- a/rpcs3/rpcs3qt/gamepads_settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/gamepads_settings_dialog.cpp
@@ -1,4 +1,5 @@
 #include "gamepads_settings_dialog.h"
+#include "pad_settings_dialog.h"
 #include "../Emu/Io/PadHandler.h"
 #include "../ds4_pad_handler.h"
 #ifdef _WIN32
@@ -16,6 +17,9 @@
 
 input_config input_cfg;
 
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
+constexpr auto qstr = QString::fromStdString;
+
 // taken from https://stackoverflow.com/a/30818424/8353754
 // because size policies won't work as expected (see similar bugs in Qt bugtracker)
 inline void resizeComboBoxView(QComboBox* combo)
@@ -54,43 +58,6 @@ gamepads_settings_dialog::gamepads_settings_dialog(QWidget* parent)
 	input_cfg.from_default();
 	input_cfg.load();
 
-	auto fill_device_combo = [](QComboBox *combo)
-	{
-		std::vector<std::string> str_inputs = input_cfg.player_input[0].to_list();
-		for (int index = 0; index < str_inputs.size(); index++)
-		{
-			combo->addItem(str_inputs[index].c_str());
-		}
-		resizeComboBoxView(combo);
-	};
-
-	auto configure_combos = [=]
-	{
-		//Set the values from config
-		for (int i = 0; i < MAX_PLAYERS; i++)
-		{
-			for (int j = 0; j < co_inputtype[i]->count(); j++)
-			{
-				if (co_inputtype[i]->itemText(j).toStdString() == input_cfg.player_input[i].to_string())
-				{
-					co_inputtype[i]->setCurrentIndex(j);
-					ChangeInputType(i);
-					break;
-				}
-			}
-
-			for (int j = 0; j < co_deviceID[i]->count(); j++)
-			{
-				if (co_deviceID[i]->itemText(j).toStdString() == input_cfg.player_device[i]->to_string())
-				{
-					co_deviceID[i]->setCurrentIndex(j);
-					ChangeDevice(i);
-					break;
-				}
-			}
-		}
-	};
-
 	for (int i = 0; i < MAX_PLAYERS; i++)
 	{
 		QGroupBox *grp_player = new QGroupBox(QString(tr("Player %1").arg(i+1)));
@@ -126,7 +93,12 @@ gamepads_settings_dialog::gamepads_settings_dialog(QWidget* parent)
 		grp_player->setFixedSize(grp_player->sizeHint());
 
 		// fill comboboxes after setting the groupbox's size to prevent stretch
-		fill_device_combo(co_inputtype[i]);
+		std::vector<std::string> str_inputs = input_cfg.player_input[0].to_list();
+		for (int index = 0; index < str_inputs.size(); index++)
+		{
+			co_inputtype[i]->addItem(qstr(str_inputs[index]));
+		}
+		resizeComboBoxView(co_inputtype[i]);
 
 		all_players->addWidget(grp_player);
 
@@ -154,17 +126,38 @@ gamepads_settings_dialog::gamepads_settings_dialog(QWidget* parent)
 	setLayout(dialog_layout);
 	layout()->setSizeConstraint(QLayout::SetFixedSize);
 
-	configure_combos();
+	auto configure_combos = [=]
+	{
+		//Set the values from config
+		for (int i = 0; i < MAX_PLAYERS; i++)
+		{
+			// No extra loops are necessary because setCurrentText does it for us
+			co_inputtype[i]->setCurrentText(qstr(input_cfg.player_input[i].to_string()));
+			// Device will be empty on some rare occasions, so fill them by force
+			ChangeInputType(i);
+		}
+	};
 
 	for (int i = 0; i < MAX_PLAYERS; i++)
 	{
 		connect(co_inputtype[i], &QComboBox::currentTextChanged, [=] { ChangeInputType(i); });
-		connect(co_deviceID[i], &QComboBox::currentTextChanged, [=] { ChangeDevice(i); });
+		connect(co_deviceID[i], &QComboBox::currentTextChanged, [=](const QString& dev)
+		{
+			std::string device = sstr(dev);
+			if (!input_cfg.player_device[i]->from_string(device))
+			{
+				//Something went wrong
+				LOG_ERROR(GENERAL, "Failed to convert device string: %s", device);
+				return;
+			}
+		});
 		connect(bu_config[i], &QAbstractButton::clicked, [=] { ClickConfigButton(i); });
 	}
 	connect(ok_button, &QPushButton::pressed, this, &gamepads_settings_dialog::SaveExit);
 	connect(cancel_button, &QPushButton::pressed, this, &gamepads_settings_dialog::CancelExit);
 	connect(refresh_button, &QPushButton::pressed, [=] { configure_combos(); });
+
+	configure_combos();
 }
 
 void gamepads_settings_dialog::SaveExit()
@@ -193,20 +186,6 @@ void gamepads_settings_dialog::CancelExit()
 	QDialog::accept();
 }
 
-void gamepads_settings_dialog::ChangeDevice(int player)
-{
-	bool success;
-
-	success = input_cfg.player_device[player]->from_string(co_deviceID[player]->currentText().toStdString());
-
-	if (!success)
-	{
-		//Something went wrong
-		LOG_ERROR(GENERAL, "Failed to convert device string:%s", co_deviceID[player]->currentText().toStdString().c_str());
-		return;
-	}
-}
-
 std::shared_ptr<PadHandlerBase> gamepads_settings_dialog::GetHandler(pad_handler type)
 {
 	std::shared_ptr<PadHandlerBase> ret_handler;
@@ -244,24 +223,28 @@ std::shared_ptr<PadHandlerBase> gamepads_settings_dialog::GetHandler(pad_handler
 
 void gamepads_settings_dialog::ChangeInputType(int player)
 {
-	bool success;
+	std::string device = sstr(co_inputtype[player]->currentText());
 
-	success = input_cfg.player_input[player].from_string(co_inputtype[player]->currentText().toStdString());
-
-	if (!success)
+	// Change this player's current handler
+	if (!input_cfg.player_input[player].from_string(device))
 	{
 		//Something went wrong
-		LOG_ERROR(GENERAL, "Failed to convert input string:%s", co_inputtype[player]->currentText().toStdString().c_str());
+		LOG_ERROR(GENERAL, "Failed to convert input string:%s", device);
 		return;
 	}
 
+	// Get this player's current handler and it's currently available devices
 	std::shared_ptr<PadHandlerBase> cur_pad_handler = GetHandler(input_cfg.player_input[player]);
-
 	std::vector<std::string> list_devices = cur_pad_handler->ListDevices();
 
+	// Refill the device combobox with currently available devices
 	co_deviceID[player]->clear();
-	for (int i = 0; i < list_devices.size(); i++) co_deviceID[player]->addItem(list_devices[i].c_str(), i);
+	for (int i = 0; i < list_devices.size(); i++)
+	{
+		co_deviceID[player]->addItem(qstr(list_devices[i]), i);
+	}
 
+	// Handle empty device list
 	if (list_devices.size() == 0)
 	{
 		co_deviceID[player]->addItem(tr("No Device Detected"), -1);
@@ -270,14 +253,22 @@ void gamepads_settings_dialog::ChangeInputType(int player)
 	else
 	{
 		co_deviceID[player]->setEnabled(true);
+		co_deviceID[player]->setCurrentText(qstr(device));
 	}
 
+	// Update view and enable configuration if possible
 	resizeComboBoxView(co_deviceID[player]);
 	bu_config[player]->setEnabled(cur_pad_handler->has_config());
 }
 
 void gamepads_settings_dialog::ClickConfigButton(int player)
 {
+	// Get this player's current handler and open its pad settings dialog
 	std::shared_ptr<PadHandlerBase> cur_pad_handler = GetHandler(input_cfg.player_input[player]);
-	if (cur_pad_handler->has_config()) cur_pad_handler->ConfigController(*input_cfg.player_device[player]);
+	if (cur_pad_handler->has_config())
+	{
+		std::string device = sstr(co_deviceID[player]->currentText());
+		pad_settings_dialog dlg(device, cur_pad_handler);
+		dlg.exec();
+	}
 }
diff --git a/rpcs3/rpcs3qt/gamepads_settings_dialog.h b/rpcs3/rpcs3qt/gamepads_settings_dialog.h
index 4355db6703..08ff5c7e85 100644
--- a/rpcs3/rpcs3qt/gamepads_settings_dialog.h
+++ b/rpcs3/rpcs3qt/gamepads_settings_dialog.h
@@ -65,7 +65,6 @@ class gamepads_settings_dialog : public QDialog
 protected:
 	std::shared_ptr<PadHandlerBase> GetHandler(pad_handler type);
 	void ChangeInputType(int player);
-	void ChangeDevice(int player);
 	void ClickConfigButton(int player);
 	void SaveExit();
 	void CancelExit();
diff --git a/rpcs3/rpcs3qt/gui_settings.cpp b/rpcs3/rpcs3qt/gui_settings.cpp
index 63cbb6111e..5775a038eb 100644
--- a/rpcs3/rpcs3qt/gui_settings.cpp
+++ b/rpcs3/rpcs3qt/gui_settings.cpp
@@ -6,7 +6,7 @@
 #include <QDir>
 #include <QMessageBox>
 
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 
 gui_settings::gui_settings(QObject* parent) : QObject(parent), m_settings(ComputeSettingsDir() + tr("CurrentSettings") + ".ini", QSettings::Format::IniFormat, parent),
 	m_settingsDir(ComputeSettingsDir())
diff --git a/rpcs3/rpcs3qt/main_window.cpp b/rpcs3/rpcs3qt/main_window.cpp
index 7a83f97ad6..39103ec1b5 100644
--- a/rpcs3/rpcs3qt/main_window.cpp
+++ b/rpcs3/rpcs3qt/main_window.cpp
@@ -47,7 +47,7 @@
 
 #include "ui_main_window.h"
 
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 
 main_window::main_window(std::shared_ptr<gui_settings> guiSettings, std::shared_ptr<emu_settings> emuSettings, QWidget *parent)
 	: QMainWindow(parent), guiSettings(guiSettings), emuSettings(emuSettings), m_sys_menu_opened(false), ui(new Ui::main_window)
diff --git a/rpcs3/rpcs3qt/pad_settings_dialog.cpp b/rpcs3/rpcs3qt/pad_settings_dialog.cpp
index 88e9bb70f1..fed6508fb4 100644
--- a/rpcs3/rpcs3qt/pad_settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/pad_settings_dialog.cpp
@@ -5,19 +5,19 @@
 #include <QHBoxLayout>
 #include <QLabel>
 #include <QAction>
-#include <QButtonGroup>
+#include <QPainter>
 
-#include "stdafx.h"
 #include "pad_settings_dialog.h"
 #include "ui_pad_settings_dialog.h"
 
-// TODO: rewrite with std::chrono or QTimer
-#include <time.h>
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
+constexpr auto qstr = QString::fromStdString;
 
-extern keyboard_pad_config g_kbpad_config;
-
-pad_settings_dialog::pad_settings_dialog(QWidget *parent) : QDialog(parent), ui(new Ui::pad_settings_dialog)
+pad_settings_dialog::pad_settings_dialog(const std::string& device, std::shared_ptr<PadHandlerBase> handler, QWidget *parent)
+	: QDialog(parent), ui(new Ui::pad_settings_dialog), m_handler_cfg(handler->GetConfig()), m_device_name(device), m_handler(handler)
 {
+	m_handler_cfg->load();
+
 	ui->setupUi(this);
 
 	setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
@@ -25,46 +25,225 @@ pad_settings_dialog::pad_settings_dialog(QWidget *parent) : QDialog(parent), ui(
 	ui->b_cancel->setDefault(true);
 	connect(ui->b_cancel, &QAbstractButton::clicked, this, &QWidget::close);
 
-	// Handling
-	QButtonGroup *padButtons = new QButtonGroup(this);
-	padButtons->addButton(ui->b_left_lstick, 1);
-	padButtons->addButton(ui->b_down_lstick, 2);
-	padButtons->addButton(ui->b_right_lstick, 3);
-	padButtons->addButton(ui->b_up_lstick, 4);
-	
-	padButtons->addButton(ui->b_left, 5);
-	padButtons->addButton(ui->b_down, 6);
-	padButtons->addButton(ui->b_right, 7);
-	padButtons->addButton(ui->b_up, 8);
-	
-	padButtons->addButton(ui->b_shift_l1, 9);
-	padButtons->addButton(ui->b_shift_l2, 10);
-	padButtons->addButton(ui->b_shift_l3, 11);
-	
-	padButtons->addButton(ui->b_start, 12);
-	padButtons->addButton(ui->b_select, 13);
-	
-	padButtons->addButton(ui->b_shift_r1, 14);
-	padButtons->addButton(ui->b_shift_r2, 15);
-	padButtons->addButton(ui->b_shift_r3, 16);
-	
-	padButtons->addButton(ui->b_square, 17);
-	padButtons->addButton(ui->b_cross, 18);
-	padButtons->addButton(ui->b_circle, 19);
-	padButtons->addButton(ui->b_triangle, 20);
-	
-	padButtons->addButton(ui->b_left_rstick, 21);
-	padButtons->addButton(ui->b_down_rstick, 22);
-	padButtons->addButton(ui->b_right_rstick, 23);
-	padButtons->addButton(ui->b_up_rstick, 24);
-	
-	padButtons->addButton(ui->b_reset, 25);
-	padButtons->addButton(ui->b_ok, 26);
-	padButtons->addButton(ui->b_cancel, 27);
+	m_padButtons = new QButtonGroup(this);
+	m_palette = ui->b_left->palette(); // save normal palette
 
-	connect(padButtons, static_cast<void(QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), this, &pad_settings_dialog::OnPadButtonClicked);
+	ui->chb_vibration_large->setChecked((bool)m_handler_cfg->enable_vibration_motor_large);
+	ui->chb_vibration_small->setChecked((bool)m_handler_cfg->enable_vibration_motor_small);
+	ui->chb_vibration_switch->setChecked((bool)m_handler_cfg->switch_vibration_motors);
+
+	// Adjust to the different pad handlers
+	if (m_handler_cfg->cfg_type == "keyboard")
+	{
+		setWindowTitle(tr("Configure Keyboard"));
+		m_handler_type = handler_type::handler_type_keyboard;
+	}
+	else if (m_handler_cfg->cfg_type == "xinput")
+	{
+		setWindowTitle(tr("Configure XInput"));
+		m_handler_type = handler_type::handler_type_xinput;
+	}
+	else if (m_handler_cfg->cfg_type == "ds4")
+	{
+		setWindowTitle(tr("Configure DS4"));
+		m_handler_type = handler_type::handler_type_ds4;
+	}
+	else if (m_handler_cfg->cfg_type == "mmjoystick")
+	{
+		setWindowTitle(tr("Configure MMJoystick"));
+		m_handler_type = handler_type::handler_type_mmjoy;
+	}
+	else if (m_handler_cfg->cfg_type == "evdev")
+	{
+		setWindowTitle(tr("Configure evdev"));
+		m_handler_type = handler_type::handler_type_evdev;
+	}
+
+	// Enable Button Remapping
+	if (m_handler->has_config())
+	{
+		// Use timer to get button input
+		const auto& callback = [=](u16 val, std::string name, int preview_values[6])
+		{
+			if (m_handler->has_deadzones())
+			{
+				ui->preview_trigger_left->setValue(preview_values[0]);
+				ui->preview_trigger_right->setValue(preview_values[1]);
+
+				if (lx != preview_values[2] || ly != preview_values[3])
+				{
+					lx = preview_values[2], ly = preview_values[3];
+					RepaintPreviewLabel(ui->preview_stick_left, ui->slider_stick_left->value(), ui->slider_stick_left->sizeHint().width(), lx, ly);
+				}
+				if (rx != preview_values[4] || ry != preview_values[5])
+				{
+					rx = preview_values[4], ry = preview_values[5];
+					RepaintPreviewLabel(ui->preview_stick_right, ui->slider_stick_right->value(), ui->slider_stick_right->sizeHint().width(), rx, ry);
+				}
+			}
+
+			if (val <= 0) return;
+
+			LOG_NOTICE(HLE, "GetNextButtonPress: %s button %s pressed with value %d", m_handler_cfg->cfg_type, name, val);
+			if (m_button_id > button_ids::id_pad_begin && m_button_id < button_ids::id_pad_end)
+			{
+				m_cfg_entries[m_button_id].key = name;
+				m_cfg_entries[m_button_id].text = qstr(name);
+				ReactivateButtons();
+			}
+		};
+
+		connect(&m_timer_input, &QTimer::timeout, [=]()
+		{
+			m_handler->GetNextButtonPress(m_device_name, callback);
+		});
+
+		m_timer_input.start(1);
+	};
+
+	// Enable Vibration Checkboxes
+	if (m_handler->has_rumble())
+	{
+		const s32 min_force = m_handler->vibration_min;
+		const s32 max_force = m_handler->vibration_max;
+
+		ui->chb_vibration_large->setEnabled(true);
+		ui->chb_vibration_small->setEnabled(true);
+		ui->chb_vibration_switch->setEnabled(true);
+
+		connect(ui->chb_vibration_large, &QCheckBox::clicked, [=](bool checked)
+		{
+			if (!checked) return;
+
+			ui->chb_vibration_switch->isChecked() ? m_handler->TestVibration(m_device_name, min_force, max_force)
+				: m_handler->TestVibration(m_device_name, max_force, min_force);
+
+			QTimer::singleShot(300, [=]()
+			{
+				m_handler->TestVibration(m_device_name, min_force, min_force);
+			});
+		});
+
+		connect(ui->chb_vibration_small, &QCheckBox::clicked, [=](bool checked)
+		{
+			if (!checked) return;
+
+			ui->chb_vibration_switch->isChecked() ? m_handler->TestVibration(m_device_name, max_force, min_force)
+				: m_handler->TestVibration(m_device_name, min_force, max_force);
+
+			QTimer::singleShot(300, [=]()
+			{
+				m_handler->TestVibration(m_device_name, min_force, min_force);
+			});
+		});
+
+		connect(ui->chb_vibration_switch, &QCheckBox::clicked, [=](bool checked)
+		{
+			checked ? m_handler->TestVibration(m_device_name, min_force, max_force)
+				: m_handler->TestVibration(m_device_name, max_force, min_force);
+
+			QTimer::singleShot(200, [=]()
+			{
+				checked ? m_handler->TestVibration(m_device_name, max_force, min_force)
+					: m_handler->TestVibration(m_device_name, min_force, max_force);
+
+				QTimer::singleShot(200, [=]()
+				{
+					m_handler->TestVibration(m_device_name, min_force, min_force);
+				});
+			});
+		});
+	}
+
+	// Enable Deadzone Settings
+	if (m_handler->has_deadzones())
+	{
+		auto initSlider = [=](QSlider* slider, const s32& value, const s32& min, const s32& max)
+		{
+			slider->setEnabled(true);
+			slider->setRange(min, max);
+			slider->setValue(value);
+		};
+
+		// Enable Trigger Thresholds
+		initSlider(ui->slider_trigger_left, m_handler_cfg->ltriggerthreshold, 0, m_handler->trigger_max);
+		initSlider(ui->slider_trigger_right, m_handler_cfg->rtriggerthreshold, 0, m_handler->trigger_max);
+		ui->preview_trigger_left->setRange(0, m_handler->trigger_max);
+		ui->preview_trigger_right->setRange(0, m_handler->trigger_max);
+
+		// Enable Stick Deadzones
+		initSlider(ui->slider_stick_left, m_handler_cfg->lstickdeadzone, 0, m_handler->thumb_max);
+		initSlider(ui->slider_stick_right, m_handler_cfg->rstickdeadzone, 0, m_handler->thumb_max);
+
+		RepaintPreviewLabel(ui->preview_stick_left, ui->slider_stick_left->value(), ui->slider_stick_left->sizeHint().width(), lx, ly);
+		connect(ui->slider_stick_left, &QSlider::valueChanged, [&](int value)
+		{
+			RepaintPreviewLabel(ui->preview_stick_left, value, ui->slider_stick_left->sizeHint().width(), lx, ly);
+		});
+
+		RepaintPreviewLabel(ui->preview_stick_right, ui->slider_stick_right->value(), ui->slider_stick_right->sizeHint().width(), rx, ry);
+		connect(ui->slider_stick_right, &QSlider::valueChanged, [&](int value)
+		{
+			RepaintPreviewLabel(ui->preview_stick_right, value, ui->slider_stick_right->sizeHint().width(), rx, ry);
+		});
+	}
+
+	auto insertButton = [this](int id, QPushButton* button, cfg::string* cfg_name)
+	{
+		QString name = qstr(*cfg_name);
+		m_cfg_entries.insert(std::make_pair(id, pad_button{ cfg_name, *cfg_name, name }));
+		m_padButtons->addButton(button, id);
+		button->setText(name);
+	};
+
+	insertButton(button_ids::id_pad_lstick_left,  ui->b_lstick_left,  &m_handler_cfg->ls_left);  
+	insertButton(button_ids::id_pad_lstick_down,  ui->b_lstick_down,  &m_handler_cfg->ls_down);
+	insertButton(button_ids::id_pad_lstick_right, ui->b_lstick_right, &m_handler_cfg->ls_right);
+	insertButton(button_ids::id_pad_lstick_up,    ui->b_lstick_up,    &m_handler_cfg->ls_up);
+
+	insertButton(button_ids::id_pad_left,  ui->b_left,  &m_handler_cfg->left);
+	insertButton(button_ids::id_pad_down,  ui->b_down,  &m_handler_cfg->down);
+	insertButton(button_ids::id_pad_right, ui->b_right, &m_handler_cfg->right);
+	insertButton(button_ids::id_pad_up,    ui->b_up,    &m_handler_cfg->up);
+
+	insertButton(button_ids::id_pad_l1, ui->b_shift_l1, &m_handler_cfg->l1);
+	insertButton(button_ids::id_pad_l2, ui->b_shift_l2, &m_handler_cfg->l2);
+	insertButton(button_ids::id_pad_l3, ui->b_shift_l3, &m_handler_cfg->l3);
+
+	insertButton(button_ids::id_pad_start,  ui->b_start,  &m_handler_cfg->start);
+	insertButton(button_ids::id_pad_select, ui->b_select, &m_handler_cfg->select);
+	insertButton(button_ids::id_pad_ps,     ui->b_ps,     &m_handler_cfg->ps);
+
+	insertButton(button_ids::id_pad_r1, ui->b_shift_r1, &m_handler_cfg->r1);
+	insertButton(button_ids::id_pad_r2, ui->b_shift_r2, &m_handler_cfg->r2);
+	insertButton(button_ids::id_pad_r3, ui->b_shift_r3, &m_handler_cfg->r3);
+
+	insertButton(button_ids::id_pad_square,   ui->b_square,   &m_handler_cfg->square);
+	insertButton(button_ids::id_pad_cross,    ui->b_cross,    &m_handler_cfg->cross);
+	insertButton(button_ids::id_pad_circle,   ui->b_circle,   &m_handler_cfg->circle);
+	insertButton(button_ids::id_pad_triangle, ui->b_triangle, &m_handler_cfg->triangle);
+
+	insertButton(button_ids::id_pad_rstick_left,  ui->b_rstick_left,  &m_handler_cfg->rs_left);
+	insertButton(button_ids::id_pad_rstick_down,  ui->b_rstick_down,  &m_handler_cfg->rs_down);
+	insertButton(button_ids::id_pad_rstick_right, ui->b_rstick_right, &m_handler_cfg->rs_right);
+	insertButton(button_ids::id_pad_rstick_up,    ui->b_rstick_up,    &m_handler_cfg->rs_up);
+
+	m_padButtons->addButton(ui->b_reset,  button_ids::id_reset_parameters);
+	m_padButtons->addButton(ui->b_ok,     button_ids::id_ok);
+	m_padButtons->addButton(ui->b_cancel, button_ids::id_cancel);
+
+	connect(m_padButtons, static_cast<void(QButtonGroup::*)(int)>(&QButtonGroup::buttonClicked), this, &pad_settings_dialog::OnPadButtonClicked);
+
+	connect(&m_timer, &QTimer::timeout, [&]()
+	{
+		if (--m_seconds <= 0)
+		{
+			ReactivateButtons();
+			return;
+		}
+		m_padButtons->button(m_button_id)->setText(tr("[ Waiting %1 ]").arg(m_seconds));
+	});
 
-	g_kbpad_config.load();
 	UpdateLabel();
 
 	gui_settings settings(this);
@@ -81,224 +260,154 @@ pad_settings_dialog::~pad_settings_dialog()
 	delete ui;
 }
 
+void pad_settings_dialog::ReactivateButtons()
+{
+	m_timer.stop();
+	m_seconds = MAX_SECONDS;
+
+	if (m_button_id == button_ids::id_pad_begin)
+	{
+		return;
+	}
+
+	if (m_padButtons->button(m_button_id))
+	{
+		m_padButtons->button(m_button_id)->setPalette(m_palette);
+	}
+
+	m_button_id = button_ids::id_pad_begin;
+	UpdateLabel();
+	SwitchButtons(true);
+}
+
+void pad_settings_dialog::RepaintPreviewLabel(QLabel* l, int dz, int w, int x, int y)
+{
+	int max = m_handler->thumb_max;
+	int origin = w * 0.1;
+	int width = w * 0.8;
+	int dz_width = width * dz / max;
+	int dz_origin = (w - dz_width) / 2;
+
+	x = (w + (x * width / max)) / 2;
+	y = (w + (y * -1 * width / max)) / 2;
+
+	QPixmap pm(w, w);
+	pm.fill(Qt::transparent);
+	QPainter p(&pm);
+	p.setRenderHint(QPainter::Antialiasing, true);
+	QPen pen(Qt::black, 2);
+	p.setPen(pen);
+	QBrush brush(Qt::white);
+	p.setBrush(brush);
+	p.drawEllipse(origin, origin, width, width);
+	pen = QPen(Qt::red, 2);
+	p.setPen(pen);
+	p.drawEllipse(dz_origin, dz_origin, dz_width, dz_width);
+	pen = QPen(Qt::blue, 2);
+	p.setPen(pen);
+	p.drawEllipse(x, y, 1, 1);
+	l->setPixmap(pm);
+}
+
 void pad_settings_dialog::keyPressEvent(QKeyEvent *keyEvent)
 {
-	m_key_pressed = true;
-
-	cfg::int32* entry = nullptr;
-
-	switch (m_button_id)
+	if (m_handler_type != handler_type::handler_type_keyboard)
 	{
-	case id_pad_lstick_left: entry = &g_kbpad_config.left_stick_left; break;
-	case id_pad_lstick_down: entry = &g_kbpad_config.left_stick_down; break;
-	case id_pad_lstick_right: entry = &g_kbpad_config.left_stick_right; break;
-	case id_pad_lstick_up: entry = &g_kbpad_config.left_stick_up; break;
-	
-	case id_pad_left: entry = &g_kbpad_config.left; break;
-	case id_pad_down: entry = &g_kbpad_config.down; break;
-	case id_pad_right: entry = &g_kbpad_config.right; break;
-	case id_pad_up: entry = &g_kbpad_config.up; break;
-	
-	case id_pad_l1: entry = &g_kbpad_config.l1; break;
-	case id_pad_l2: entry = &g_kbpad_config.l2; break;
-	case id_pad_l3: entry = &g_kbpad_config.l3; break;
-	
-	case id_pad_start: entry = &g_kbpad_config.start; break;
-	case id_pad_select: entry = &g_kbpad_config.select; break;
-	
-	case id_pad_r1: entry = &g_kbpad_config.r1; break;
-	case id_pad_r2: entry = &g_kbpad_config.r2; break;
-	case id_pad_r3: entry = &g_kbpad_config.r3; break;
-	
-	case id_pad_square: entry = &g_kbpad_config.square; break;
-	case id_pad_cross: entry = &g_kbpad_config.cross; break;
-	case id_pad_circle: entry = &g_kbpad_config.circle; break;
-	case id_pad_triangle: entry = &g_kbpad_config.triangle; break;
-	case id_pad_rstick_left: entry = &g_kbpad_config.right_stick_left; break;
-	case id_pad_rstick_down: entry = &g_kbpad_config.right_stick_down; break;
-	case id_pad_rstick_right: entry = &g_kbpad_config.right_stick_right; break;
-	case id_pad_rstick_up: entry = &g_kbpad_config.right_stick_up; break;
-
-	case 0: break;
-	default: LOG_ERROR(HLE, "Unknown button ID: %d", m_button_id); break;
+		return;
 	}
 
-	if (entry)
+	if (m_button_id == button_ids::id_pad_begin)
 	{
-		// TODO: do not modify config
-		entry->from_string(std::to_string(keyEvent->key()));
+		return;
 	}
 
-	SwitchButtons(true);  // enable all buttons
-	m_button_id = 0; // reset current button id
-	m_key_pressed = false;
-	UpdateLabel();
-}
-
-void pad_settings_dialog::UpdateLabel()
-{
-	// Get button labels from .ini
-	ui->b_up_lstick->setText(GetKeyName(g_kbpad_config.left_stick_up));
-	ui->b_down_lstick->setText(GetKeyName(g_kbpad_config.left_stick_down));
-	ui->b_left_lstick->setText(GetKeyName(g_kbpad_config.left_stick_left));
-	ui->b_right_lstick->setText(GetKeyName(g_kbpad_config.left_stick_right));
-	
-	ui->b_up->setText(GetKeyName(g_kbpad_config.up));
-	ui->b_down->setText(GetKeyName(g_kbpad_config.down));
-	ui->b_left->setText(GetKeyName(g_kbpad_config.left));
-	ui->b_right->setText(GetKeyName(g_kbpad_config.right));
-	
-	ui->b_shift_l1->setText(GetKeyName(g_kbpad_config.l1));
-	ui->b_shift_l2->setText(GetKeyName(g_kbpad_config.l2));
-	ui->b_shift_l3->setText(GetKeyName(g_kbpad_config.l3));
-	
-	ui->b_start->setText(GetKeyName(g_kbpad_config.start));
-	ui->b_select->setText(GetKeyName(g_kbpad_config.select));
-	
-	ui->b_shift_r1->setText(GetKeyName(g_kbpad_config.r1));
-	ui->b_shift_r2->setText(GetKeyName(g_kbpad_config.r2));
-	ui->b_shift_r3->setText(GetKeyName(g_kbpad_config.r3));
-	
-	ui->b_square->setText(GetKeyName(g_kbpad_config.square));
-	ui->b_cross->setText(GetKeyName(g_kbpad_config.cross));
-	ui->b_circle->setText(GetKeyName(g_kbpad_config.circle));
-	ui->b_triangle->setText(GetKeyName(g_kbpad_config.triangle));
-	
-	ui->b_up_rstick->setText(GetKeyName(g_kbpad_config.right_stick_up));
-	ui->b_down_rstick->setText(GetKeyName(g_kbpad_config.right_stick_down));
-	ui->b_left_rstick->setText(GetKeyName(g_kbpad_config.right_stick_left));
-	ui->b_right_rstick->setText(GetKeyName(g_kbpad_config.right_stick_right));
-}
-
-void pad_settings_dialog::UpdateTimerLabel(const u32 id)
-{
-	// Lambda used to update label. The 47 is magical.
-	auto UpdateLabel = [=](QPushButton* target)
+	if (m_button_id <= button_ids::id_pad_begin || m_button_id >= button_ids::id_pad_end)
 	{
-		target->setText(QString::number(m_seconds + 47));
-	};
-
-	switch (id)
-	{
-	case id_pad_lstick_left: UpdateLabel(ui->b_left_lstick); break;
-	case id_pad_lstick_down: UpdateLabel(ui->b_down_lstick); break;
-	case id_pad_lstick_right: UpdateLabel(ui->b_right_lstick); break;
-	case id_pad_lstick_up: UpdateLabel(ui->b_up_lstick); break;
-
-	case id_pad_left: UpdateLabel(ui->b_left); break;
-	case id_pad_down: UpdateLabel(ui->b_down); break;
-	case id_pad_right: UpdateLabel(ui->b_right); break;
-	case id_pad_up: UpdateLabel(ui->b_up); break;
-
-	case id_pad_l1: UpdateLabel(ui->b_shift_l1); break;
-	case id_pad_l2: UpdateLabel(ui->b_shift_l2); break;
-	case id_pad_l3: UpdateLabel(ui->b_shift_l3); break;
-
-	case id_pad_start: UpdateLabel(ui->b_start); break;
-	case id_pad_select: UpdateLabel(ui->b_select); break;
-
-	case id_pad_r1: UpdateLabel(ui->b_shift_r1); break;
-	case id_pad_r2: UpdateLabel(ui->b_shift_r2); break;
-	case id_pad_r3: UpdateLabel(ui->b_shift_r3); break;
-
-	case id_pad_square: UpdateLabel(ui->b_square); break;
-	case id_pad_cross: UpdateLabel(ui->b_cross); break;
-	case id_pad_circle: UpdateLabel(ui->b_circle); break;
-	case id_pad_triangle: UpdateLabel(ui->b_triangle); break;
-
-	case id_pad_rstick_left: UpdateLabel(ui->b_left_rstick); break;
-	case id_pad_rstick_down: UpdateLabel(ui->b_down_rstick); break;
-	case id_pad_rstick_right: UpdateLabel(ui->b_right_rstick); break;
-	case id_pad_rstick_up: UpdateLabel(ui->b_up_rstick); break;
-
-	default: LOG_ERROR(HLE, "Unknown button ID: %d", id); break;
+		LOG_NOTICE(HLE, "Pad Settings: Handler Type: %d, Unknown button ID: %d", static_cast<int>(m_handler_type), m_button_id);
 	}
-}
-
-void pad_settings_dialog::SwitchButtons(const bool IsEnabled)
-{
-	ui->b_up_lstick->setEnabled(IsEnabled);
-	ui->b_down_lstick->setEnabled(IsEnabled);
-	ui->b_left_lstick->setEnabled(IsEnabled);
-	ui->b_right_lstick->setEnabled(IsEnabled);
-
-	ui->b_up->setEnabled(IsEnabled);
-	ui->b_down->setEnabled(IsEnabled);
-	ui->b_left->setEnabled(IsEnabled);
-	ui->b_right->setEnabled(IsEnabled);
-
-	ui->b_shift_l1->setEnabled(IsEnabled);
-	ui->b_shift_l2->setEnabled(IsEnabled);
-	ui->b_shift_l3->setEnabled(IsEnabled);
-
-	ui->b_start->setEnabled(IsEnabled);
-	ui->b_select->setEnabled(IsEnabled);
-
-	ui->b_shift_r1->setEnabled(IsEnabled);
-	ui->b_shift_r2->setEnabled(IsEnabled);
-	ui->b_shift_r3->setEnabled(IsEnabled);
-
-	ui->b_square->setEnabled(IsEnabled);
-	ui->b_cross->setEnabled(IsEnabled);
-	ui->b_circle->setEnabled(IsEnabled);
-	ui->b_triangle->setEnabled(IsEnabled);
-
-	ui->b_up_rstick->setEnabled(IsEnabled);
-	ui->b_down_rstick->setEnabled(IsEnabled);
-	ui->b_left_rstick->setEnabled(IsEnabled);
-	ui->b_right_rstick->setEnabled(IsEnabled);
-
-	ui->b_ok->setEnabled(IsEnabled);
-	ui->b_cancel->setEnabled(IsEnabled);
-	ui->b_reset->setEnabled(IsEnabled);
-}
-
-void pad_settings_dialog::RunTimer(const u32 seconds, const u32 id)
-{
-	m_seconds = seconds;
-	clock_t t1, t2;
-	t1 = t2 = clock() / CLOCKS_PER_SEC;
-	while (m_seconds)
+	else
 	{
-		if (t1 / CLOCKS_PER_SEC + 1 <= (t2 = clock()) / CLOCKS_PER_SEC)
+		m_cfg_entries[m_button_id].key = ((keyboard_pad_handler*)m_handler.get())->GetKeyName(keyEvent);
+		m_cfg_entries[m_button_id].text = qstr(m_cfg_entries[m_button_id].key);
+	}
+
+	ReactivateButtons();
+}
+
+void pad_settings_dialog::UpdateLabel(bool is_reset)
+{
+	if (is_reset)
+	{
+		ui->chb_vibration_large->setChecked((bool)m_handler_cfg->enable_vibration_motor_large);
+		ui->chb_vibration_small->setChecked((bool)m_handler_cfg->enable_vibration_motor_small);
+		ui->chb_vibration_switch->setChecked((bool)m_handler_cfg->switch_vibration_motors);
+
+		ui->slider_trigger_left->setValue(m_handler_cfg->ltriggerthreshold);
+		ui->slider_trigger_right->setValue(m_handler_cfg->rtriggerthreshold);
+		ui->slider_stick_left->setValue(m_handler_cfg->lstickdeadzone);
+		ui->slider_stick_right->setValue(m_handler_cfg->rstickdeadzone);
+	}
+
+	for (auto& entry : m_cfg_entries)
+	{
+		if (is_reset)
 		{
-			UpdateTimerLabel(id);
-			m_seconds--;
-			t1 = t2;
+			entry.second.key = *entry.second.cfg_name;
+			entry.second.text = qstr(entry.second.key);
 		}
 
-		if (m_key_pressed)
-		{
-			m_seconds = 0;
-			break;
-		}
+		m_padButtons->button(entry.first)->setText(entry.second.text);
 	}
 }
 
-const QString pad_settings_dialog::GetKeyName(const u32 keyCode)
+void pad_settings_dialog::SwitchButtons(bool is_enabled)
 {
-	//TODO what about numpad?
-	return QKeySequence(keyCode).toString();
+	for (int i = button_ids::id_pad_begin + 1; i < button_ids::id_pad_end; i++)
+	{
+		m_padButtons->button(i)->setEnabled(is_enabled);
+	}
+}
+
+void pad_settings_dialog::SaveConfig()
+{
+	for (const auto& entry : m_cfg_entries)
+	{
+		entry.second.cfg_name->from_string(entry.second.key);
+	}
+	m_handler_cfg->enable_vibration_motor_large.set(ui->chb_vibration_large->isChecked());
+	m_handler_cfg->enable_vibration_motor_small.set(ui->chb_vibration_small->isChecked());
+	m_handler_cfg->switch_vibration_motors.set(ui->chb_vibration_switch->isChecked());
+	m_handler_cfg->ltriggerthreshold.set(ui->slider_trigger_left->value());
+	m_handler_cfg->rtriggerthreshold.set(ui->slider_trigger_right->value());
+	m_handler_cfg->lstickdeadzone.set(ui->slider_stick_left->value());
+	m_handler_cfg->rstickdeadzone.set(ui->slider_stick_right->value());
+	m_handler_cfg->save();
 }
 
 void pad_settings_dialog::OnPadButtonClicked(int id)
 {
-	if (id != id_reset_parameters && id != id_ok)
+	switch (id)
 	{
-		m_button_id = id;
-		SwitchButtons(false); // disable all buttons, needed for using Space, Enter and other specific buttons
-		//RunTimer(3, event.GetId()); // TODO: Currently, timer disabled. Use by later, have some strange problems
-		//SwitchButtons(true); // needed, if timer enabled
-		UpdateLabel();
+	case button_ids::id_pad_begin:
+	case button_ids::id_pad_end:
+	case button_ids::id_cancel:
+		return;
+	case button_ids::id_reset_parameters:
+		ReactivateButtons();
+		m_handler_cfg->from_default();
+		UpdateLabel(true);
+		return;
+	case button_ids::id_ok:
+		SaveConfig();
+		QDialog::accept();
+		return;
+	default:
+		break;
 	}
 
-	else
-	{
-		switch (id)
-		{
-		case id_reset_parameters: g_kbpad_config.from_default(); UpdateLabel(); break;
-		case id_ok: g_kbpad_config.save(); QDialog::accept(); break;
-		case id_cancel: break;
-		}
-	}
+	m_button_id = id;
+	m_padButtons->button(m_button_id)->setText(tr("[ Waiting %1 ]").arg(MAX_SECONDS));
+	m_padButtons->button(m_button_id)->setPalette(QPalette(Qt::blue));
+	SwitchButtons(false); // disable all buttons, needed for using Space, Enter and other specific buttons
+	m_timer.start(1000);
 }
diff --git a/rpcs3/rpcs3qt/pad_settings_dialog.h b/rpcs3/rpcs3qt/pad_settings_dialog.h
index 3432ed0c1c..93f9a34d6f 100644
--- a/rpcs3/rpcs3qt/pad_settings_dialog.h
+++ b/rpcs3/rpcs3qt/pad_settings_dialog.h
@@ -3,6 +3,9 @@
 #include <QDialog>
 #include <QEvent>
 #include <QKeyEvent>
+#include <QTimer>
+#include <QButtonGroup>
+
 #include "keyboard_pad_handler.h"
 #include "Utilities/types.h"
 #include "Utilities/Config.h"
@@ -11,43 +14,10 @@
 #include "Emu/System.h"
 #include "gui_settings.h"
 
-enum button_ids
-{
-	id_pad_lstick_left = 0x1,
-	id_pad_lstick_down,
-	id_pad_lstick_right,
-	id_pad_lstick_up,
-
-	id_pad_left,
-	id_pad_down,
-	id_pad_right,
-	id_pad_up,
-
-	id_pad_l1,
-	id_pad_l2,
-	id_pad_l3,
-
-	id_pad_start,
-	id_pad_select,
-
-	id_pad_r1,
-	id_pad_r2,
-	id_pad_r3,
-
-	id_pad_square,
-	id_pad_cross,
-	id_pad_circle,
-	id_pad_triangle,
-
-	id_pad_rstick_left,
-	id_pad_rstick_down,
-	id_pad_rstick_right,
-	id_pad_rstick_up,
-
-	id_reset_parameters,
-	id_ok,
-	id_cancel
-};
+#ifdef _WIN32
+#include "xinput_pad_handler.h"
+#endif
+#include "ds4_pad_handler.h"
 
 namespace Ui
 {
@@ -58,22 +28,118 @@ class pad_settings_dialog : public QDialog
 {
 	Q_OBJECT
 
+	enum button_ids
+	{
+		id_pad_begin, // begin
+
+		id_pad_lstick_left,
+		id_pad_lstick_down,
+		id_pad_lstick_right,
+		id_pad_lstick_up,
+
+		id_pad_left,
+		id_pad_down,
+		id_pad_right,
+		id_pad_up,
+
+		id_pad_l1,
+		id_pad_l2,
+		id_pad_l3,
+
+		id_pad_start,
+		id_pad_select,
+		id_pad_ps,
+
+		id_pad_r1,
+		id_pad_r2,
+		id_pad_r3,
+
+		id_pad_square,
+		id_pad_cross,
+		id_pad_circle,
+		id_pad_triangle,
+
+		id_pad_rstick_left,
+		id_pad_rstick_down,
+		id_pad_rstick_right,
+		id_pad_rstick_up,
+
+		id_pad_end, // end
+
+		id_reset_parameters,
+		id_ok,
+		id_cancel
+	};
+
+	enum handler_type
+	{
+		handler_type_keyboard,
+		handler_type_xinput,
+		handler_type_ds4,
+		handler_type_mmjoy,
+		handler_type_evdev
+	};
+
+	struct pad_button
+	{
+		cfg::string* cfg_name;
+		std::string key;
+		QString text;
+	};
+
 private Q_SLOTS:
 	void OnPadButtonClicked(int id);
 
 private:
-	u32 m_seconds;
-	u32 m_button_id;
-	bool m_key_pressed;
 	Ui::pad_settings_dialog *ui;
 
+	// Button Mapping
+	QButtonGroup* m_padButtons;
+	u32 m_button_id = id_pad_begin;
+	std::map<int /*id*/, pad_button /*info*/> m_cfg_entries;
+
+	// Real time stick values
+	int lx = 0;
+	int ly = 0;
+	int rx = 0;
+	int ry = 0;
+
+	// Backup for standard button palette
+	QPalette m_palette;
+
+	// Pad Handlers 
+	std::shared_ptr<PadHandlerBase> m_handler;
+	handler_type m_handler_type;
+	pad_config* m_handler_cfg;
+	std::string m_device_name;
+
+	// Remap Timer
+	const int MAX_SECONDS = 5;
+	int m_seconds = MAX_SECONDS;
+	QTimer m_timer;
+
+	// Input timer. Its Callback handles the input
+	QTimer m_timer_input;
+
+	/** Resets the view to default. Resets the Remap Timer */
+	void ReactivateButtons();
+
+	/** Repaints a stick deadzone preview label */
+	void RepaintPreviewLabel(QLabel* l, int dz, int w, int x, int y);
+
 public:
-	explicit pad_settings_dialog(QWidget *parent = nullptr);
+	explicit pad_settings_dialog(const std::string& device, std::shared_ptr<PadHandlerBase> handler, QWidget *parent = nullptr);
 	~pad_settings_dialog();
+
+	/** Handle keyboard handler input */
 	void keyPressEvent(QKeyEvent *keyEvent) override;
-	void UpdateLabel();
-	void UpdateTimerLabel(const u32 id);
-	void SwitchButtons(const bool IsEnabled);
-	void RunTimer(const u32 seconds, const u32 id);
-	const QString GetKeyName(const u32 keyCode);
+
+	/** Update all the Button Labels with current button mapping */
+	void UpdateLabel(bool is_reset = false);
+
+	/** Enable/Disable Buttons while trying to remap an other */
+	void SwitchButtons(bool is_enabled);
+
+	/** Save the Pad Configuration to the current Pad Handler Config File */
+	void SaveConfig();
 };
diff --git a/rpcs3/rpcs3qt/pad_settings_dialog.ui b/rpcs3/rpcs3qt/pad_settings_dialog.ui
index b67b7d4f61..5cdc217dde 100644
--- a/rpcs3/rpcs3qt/pad_settings_dialog.ui
+++ b/rpcs3/rpcs3qt/pad_settings_dialog.ui
@@ -7,7 +7,7 @@
     <x>0</x>
     <y>0</y>
     <width>892</width>
-    <height>554</height>
+    <height>568</height>
    </rect>
   </property>
   <property name="windowTitle">
@@ -23,64 +23,6 @@
      <property name="spacing">
       <number>5</number>
      </property>
-     <item>
-      <widget class="QGroupBox" name="groupBox">
-       <property name="enabled">
-        <bool>false</bool>
-       </property>
-       <property name="title">
-        <string>Controller to Configure</string>
-       </property>
-       <layout class="QVBoxLayout" name="verticalLayout">
-        <property name="leftMargin">
-         <number>5</number>
-        </property>
-        <property name="topMargin">
-         <number>5</number>
-        </property>
-        <property name="rightMargin">
-         <number>5</number>
-        </property>
-        <property name="bottomMargin">
-         <number>5</number>
-        </property>
-        <item>
-         <widget class="QComboBox" name="cb_controller"/>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox_3">
-       <property name="enabled">
-        <bool>false</bool>
-       </property>
-       <property name="title">
-        <string>Profiles</string>
-       </property>
-       <layout class="QVBoxLayout" name="verticalLayout_2">
-        <property name="leftMargin">
-         <number>5</number>
-        </property>
-        <property name="topMargin">
-         <number>5</number>
-        </property>
-        <property name="rightMargin">
-         <number>5</number>
-        </property>
-        <property name="bottomMargin">
-         <number>5</number>
-        </property>
-        <item>
-         <widget class="QPushButton" name="b_profile">
-          <property name="text">
-           <string>Manage Profiles</string>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
      <item>
       <widget class="QGroupBox" name="groupBox_15">
        <property name="title">
@@ -389,7 +331,7 @@
                <number>5</number>
               </property>
               <item>
-               <widget class="QPushButton" name="b_up_lstick">
+               <widget class="QPushButton" name="b_lstick_up">
                 <property name="text">
                  <string>Up</string>
                 </property>
@@ -438,7 +380,7 @@
               <number>5</number>
              </property>
              <item>
-              <widget class="QPushButton" name="b_left_lstick">
+              <widget class="QPushButton" name="b_lstick_left">
                <property name="text">
                 <string>Left</string>
                </property>
@@ -469,7 +411,7 @@
               <number>5</number>
              </property>
              <item>
-              <widget class="QPushButton" name="b_right_lstick">
+              <widget class="QPushButton" name="b_lstick_right">
                <property name="text">
                 <string>Right</string>
                </property>
@@ -530,7 +472,7 @@
                <number>5</number>
               </property>
               <item>
-               <widget class="QPushButton" name="b_down_lstick">
+               <widget class="QPushButton" name="b_lstick_down">
                 <property name="text">
                  <string>Down</string>
                 </property>
@@ -561,6 +503,138 @@
        </layout>
       </widget>
      </item>
+     <item>
+      <widget class="QGroupBox" name="gb_triggers">
+       <property name="minimumSize">
+        <size>
+         <width>0</width>
+         <height>80</height>
+        </size>
+       </property>
+       <property name="title">
+        <string>Trigger Thresholds</string>
+       </property>
+       <layout class="QHBoxLayout" name="horizontalLayout_21">
+        <property name="leftMargin">
+         <number>5</number>
+        </property>
+        <property name="topMargin">
+         <number>5</number>
+        </property>
+        <property name="rightMargin">
+         <number>5</number>
+        </property>
+        <property name="bottomMargin">
+         <number>5</number>
+        </property>
+        <item>
+         <layout class="QVBoxLayout" name="gb_trigger_left">
+          <item>
+           <widget class="QSlider" name="slider_trigger_left">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QSlider" name="preview_trigger_left">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+        <item>
+         <layout class="QVBoxLayout" name="gb_trigger_right">
+          <item>
+           <widget class="QSlider" name="slider_trigger_right">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QSlider" name="preview_trigger_right">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
+     <item>
+      <widget class="QGroupBox" name="gb_vibration">
+       <property name="title">
+        <string>Enable Vibration</string>
+       </property>
+       <layout class="QHBoxLayout" name="horizontalLayout_2">
+        <property name="leftMargin">
+         <number>5</number>
+        </property>
+        <property name="topMargin">
+         <number>9</number>
+        </property>
+        <property name="rightMargin">
+         <number>5</number>
+        </property>
+        <property name="bottomMargin">
+         <number>9</number>
+        </property>
+        <item>
+         <widget class="QCheckBox" name="chb_vibration_large">
+          <property name="enabled">
+           <bool>false</bool>
+          </property>
+          <property name="text">
+           <string>Large</string>
+          </property>
+          <property name="checked">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="chb_vibration_small">
+          <property name="enabled">
+           <bool>false</bool>
+          </property>
+          <property name="text">
+           <string>Small</string>
+          </property>
+          <property name="checked">
+           <bool>true</bool>
+          </property>
+         </widget>
+        </item>
+        <item>
+         <widget class="QCheckBox" name="chb_vibration_switch">
+          <property name="enabled">
+           <bool>false</bool>
+          </property>
+          <property name="text">
+           <string>Switch</string>
+          </property>
+         </widget>
+        </item>
+       </layout>
+      </widget>
+     </item>
      <item>
       <spacer name="verticalSpacer_2">
        <property name="orientation">
@@ -818,11 +892,8 @@
                </property>
                <item>
                 <widget class="QPushButton" name="b_ps">
-                 <property name="enabled">
-                  <bool>false</bool>
-                 </property>
                  <property name="text">
-                  <string>Null</string>
+                  <string>Backspace</string>
                  </property>
                  <property name="autoDefault">
                   <bool>false</bool>
@@ -1107,86 +1178,6 @@
      <property name="spacing">
       <number>5</number>
      </property>
-     <item>
-      <widget class="QGroupBox" name="groupBox_4">
-       <property name="enabled">
-        <bool>false</bool>
-       </property>
-       <property name="title">
-        <string>Controller Status</string>
-       </property>
-       <layout class="QVBoxLayout" name="verticalLayout_3">
-        <property name="leftMargin">
-         <number>5</number>
-        </property>
-        <property name="topMargin">
-         <number>5</number>
-        </property>
-        <property name="rightMargin">
-         <number>5</number>
-        </property>
-        <property name="bottomMargin">
-         <number>5</number>
-        </property>
-        <item>
-         <widget class="QComboBox" name="cb_status"/>
-        </item>
-       </layout>
-      </widget>
-     </item>
-     <item>
-      <widget class="QGroupBox" name="groupBox_5">
-       <property name="enabled">
-        <bool>false</bool>
-       </property>
-       <property name="title">
-        <string>Features</string>
-       </property>
-       <layout class="QHBoxLayout" name="horizontalLayout_2">
-        <property name="leftMargin">
-         <number>5</number>
-        </property>
-        <property name="topMargin">
-         <number>9</number>
-        </property>
-        <property name="rightMargin">
-         <number>5</number>
-        </property>
-        <property name="bottomMargin">
-         <number>9</number>
-        </property>
-        <item>
-         <widget class="QCheckBox" name="chb_sixaxis">
-          <property name="enabled">
-           <bool>false</bool>
-          </property>
-          <property name="text">
-           <string>Sixaxis</string>
-          </property>
-          <property name="checkable">
-           <bool>true</bool>
-          </property>
-          <property name="checked">
-           <bool>false</bool>
-          </property>
-         </widget>
-        </item>
-        <item>
-         <widget class="QCheckBox" name="chb_vibration">
-          <property name="enabled">
-           <bool>false</bool>
-          </property>
-          <property name="text">
-           <string>Vibration</string>
-          </property>
-          <property name="checked">
-           <bool>true</bool>
-          </property>
-         </widget>
-        </item>
-       </layout>
-      </widget>
-     </item>
      <item>
       <widget class="QGroupBox" name="groupBox_20">
        <property name="title">
@@ -1489,7 +1480,7 @@
                <number>5</number>
               </property>
               <item>
-               <widget class="QPushButton" name="b_up_rstick">
+               <widget class="QPushButton" name="b_rstick_up">
                 <property name="text">
                  <string>PgUp</string>
                 </property>
@@ -1538,7 +1529,7 @@
               <number>5</number>
              </property>
              <item>
-              <widget class="QPushButton" name="b_left_rstick">
+              <widget class="QPushButton" name="b_rstick_left">
                <property name="text">
                 <string>Home</string>
                </property>
@@ -1569,7 +1560,7 @@
               <number>5</number>
              </property>
              <item>
-              <widget class="QPushButton" name="b_right_rstick">
+              <widget class="QPushButton" name="b_rstick_right">
                <property name="text">
                 <string>End</string>
                </property>
@@ -1630,7 +1621,7 @@
                <number>5</number>
               </property>
               <item>
-               <widget class="QPushButton" name="b_down_rstick">
+               <widget class="QPushButton" name="b_rstick_down">
                 <property name="text">
                  <string>PgDown</string>
                 </property>
@@ -1661,6 +1652,69 @@
        </layout>
       </widget>
      </item>
+     <item>
+      <widget class="QGroupBox" name="gb_sticks">
+       <property name="title">
+        <string>Analog Deadzones</string>
+       </property>
+       <layout class="QHBoxLayout" name="horizontalLayout_22">
+        <property name="leftMargin">
+         <number>5</number>
+        </property>
+        <property name="topMargin">
+         <number>5</number>
+        </property>
+        <property name="rightMargin">
+         <number>5</number>
+        </property>
+        <property name="bottomMargin">
+         <number>5</number>
+        </property>
+        <item>
+         <layout class="QVBoxLayout" name="gb_stick_left">
+          <item>
+           <widget class="QSlider" name="slider_stick_left">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="preview_stick_left">
+            <property name="text">
+             <string/>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+        <item>
+         <layout class="QVBoxLayout" name="gb_stick_right">
+          <item>
+           <widget class="QSlider" name="slider_stick_right">
+            <property name="enabled">
+             <bool>false</bool>
+            </property>
+            <property name="orientation">
+             <enum>Qt::Horizontal</enum>
+            </property>
+           </widget>
+          </item>
+          <item>
+           <widget class="QLabel" name="preview_stick_right">
+            <property name="text">
+             <string/>
+            </property>
+           </widget>
+          </item>
+         </layout>
+        </item>
+       </layout>
+      </widget>
+     </item>
      <item>
       <spacer name="verticalSpacer_3">
        <property name="orientation">
diff --git a/rpcs3/rpcs3qt/register_editor_dialog.cpp b/rpcs3/rpcs3qt/register_editor_dialog.cpp
index 83d85e8f33..1a021379de 100644
--- a/rpcs3/rpcs3qt/register_editor_dialog.cpp
+++ b/rpcs3/rpcs3qt/register_editor_dialog.cpp
@@ -2,7 +2,7 @@
 #include "register_editor_dialog.h"
 
 constexpr auto qstr = QString::fromStdString;
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 inline std::string sstr(const QVariant& _in) { return sstr(_in.toString()); }
 
 register_editor_dialog::register_editor_dialog(QWidget *parent, u32 _pc, const std::shared_ptr<cpu_thread>& _cpu, CPUDisAsm* _disasm)
diff --git a/rpcs3/rpcs3qt/save_manager_dialog.cpp b/rpcs3/rpcs3qt/save_manager_dialog.cpp
index 11ac80025e..b1df7c822d 100644
--- a/rpcs3/rpcs3qt/save_manager_dialog.cpp
+++ b/rpcs3/rpcs3qt/save_manager_dialog.cpp
@@ -21,7 +21,7 @@ namespace
 {
 	// Helper converters
 	constexpr auto qstr = QString::fromStdString;
-	inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+	inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 
 	/**
 	* This certainly isn't ideal for this code, as it essentially copies cellSaveData.  But, I have no other choice without adding public methods to cellSaveData.
diff --git a/rpcs3/rpcs3qt/settings_dialog.cpp b/rpcs3/rpcs3qt/settings_dialog.cpp
index aebec43e99..57c2459438 100644
--- a/rpcs3/rpcs3qt/settings_dialog.cpp
+++ b/rpcs3/rpcs3qt/settings_dialog.cpp
@@ -23,7 +23,7 @@
 
 #include <unordered_set>
 
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 inline std::string sstr(const QVariant& _in) { return sstr(_in.toString()); }
 
 settings_dialog::settings_dialog(std::shared_ptr<gui_settings> guiSettings, std::shared_ptr<emu_settings> emuSettings, const int& tabIndex, QWidget *parent, const GameInfo* game)
diff --git a/rpcs3/rpcs3qt/settings_dialog.h b/rpcs3/rpcs3qt/settings_dialog.h
index a6930c8c87..1fe95a98a9 100644
--- a/rpcs3/rpcs3qt/settings_dialog.h
+++ b/rpcs3/rpcs3qt/settings_dialog.h
@@ -22,7 +22,7 @@ class settings_dialog : public QDialog
 public:
 	explicit settings_dialog(std::shared_ptr<gui_settings> guiSettings, std::shared_ptr<emu_settings> emuSettings, const int& tabIndex = 0, QWidget *parent = 0, const GameInfo *game = nullptr);
 	~settings_dialog();
-	int exec();
+	int exec() override;
 Q_SIGNALS:
 	void GuiSettingsSyncRequest(bool configure_all);
 	void GuiStylesheetRequest(const QString& path);
@@ -51,5 +51,5 @@ private:
 	QHash<QObject*, QString> m_descriptions;
 	void SubscribeDescription(QLabel* description);
 	void SubscribeTooltip(QObject* object, const QString& tooltip);
-	bool eventFilter(QObject* object, QEvent* event);
+	bool eventFilter(QObject* object, QEvent* event) override;
 };
diff --git a/rpcs3/rpcs3qt/vfs_dialog.cpp b/rpcs3/rpcs3qt/vfs_dialog.cpp
index a011050485..e729d73181 100644
--- a/rpcs3/rpcs3qt/vfs_dialog.cpp
+++ b/rpcs3/rpcs3qt/vfs_dialog.cpp
@@ -7,7 +7,7 @@
 #include <QVBoxLayout>
 #include <QPushButton>
 
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 
 vfs_dialog::vfs_dialog(std::shared_ptr<gui_settings> guiSettings, std::shared_ptr<emu_settings> emuSettings, QWidget* parent)
 	: QDialog(parent), m_gui_settings(guiSettings), m_emu_settings(emuSettings)
diff --git a/rpcs3/rpcs3qt/vfs_dialog_tab.cpp b/rpcs3/rpcs3qt/vfs_dialog_tab.cpp
index 4752d82ad7..16af392287 100644
--- a/rpcs3/rpcs3qt/vfs_dialog_tab.cpp
+++ b/rpcs3/rpcs3qt/vfs_dialog_tab.cpp
@@ -5,7 +5,7 @@
 #include <QHBoxLayout>
 #include <QVBoxLayout>
 
-inline std::string sstr(const QString& _in) { return _in.toUtf8().toStdString(); }
+inline std::string sstr(const QString& _in) { return _in.toStdString(); }
 
 vfs_dialog_tab::vfs_dialog_tab(const vfs_settings_info& settingsInfo, std::shared_ptr<gui_settings> guiSettings, std::shared_ptr<emu_settings> emuSettings, QWidget* parent)
 	: QWidget(parent), m_info(settingsInfo), m_gui_settings(guiSettings), m_emu_settings(emuSettings)
diff --git a/rpcs3/xinput_pad_handler.cpp b/rpcs3/xinput_pad_handler.cpp
index 322516e9a0..df32e2c440 100644
--- a/rpcs3/xinput_pad_handler.cpp
+++ b/rpcs3/xinput_pad_handler.cpp
@@ -1,41 +1,68 @@
-#include "stdafx.h"
 
 #ifdef _MSC_VER
 #include "xinput_pad_handler.h"
+#include "rpcs3qt/pad_settings_dialog.h"
 
-xinput_config xinput_cfg;
-
-namespace {
-	const DWORD THREAD_TIMEOUT = 1000;
-	const DWORD THREAD_SLEEP = 10;
-	const DWORD THREAD_SLEEP_INACTIVE = 100;
-	const DWORD MAX_GAMEPADS = 4;
-	const DWORD XINPUT_GAMEPAD_GUIDE = 0x0400;
-	const DWORD XINPUT_GAMEPAD_BUTTONS = 16;
-	const LPCWSTR LIBRARY_FILENAMES[] = {
-		L"xinput1_4.dll",
-		L"xinput1_3.dll",
-		L"xinput1_2.dll",
-		L"xinput9_1_0.dll"
-	};
-
-	inline u16 Clamp0To255(f32 input)
-	{
-		if (input > 255.f)
-			return 255;
-		else if (input < 0.f)
-			return 0;
-		else return static_cast<u16>(input);
-	}
-
-	inline u16 ConvertAxis(float value)
-	{
-		return static_cast<u16>((value + 1.0)*(255.0 / 2.0));
-	}
-}
-
-xinput_pad_handler::xinput_pad_handler() : library(nullptr), xinputGetState(nullptr), xinputEnable(nullptr), xinputSetState(nullptr), is_init(false)
+xinput_pad_handler::xinput_pad_handler() :
+	library(nullptr), xinputGetState(nullptr), xinputEnable(nullptr),
+	xinputSetState(nullptr), xinputGetBatteryInformation(nullptr), is_init(false)
 {
+	// Define border values
+	thumb_min = -32768;
+	thumb_max = 32767;
+	trigger_min = 0;
+	trigger_max = 255;
+	vibration_min = 0;
+	vibration_max = 65535;
+
+	// Set this handler's type and save location
+	m_pad_config.cfg_type = "xinput";
+	m_pad_config.cfg_name = fs::get_config_dir() + "/config_xinput.yml";
+
+	// Set default button mapping
+	m_pad_config.ls_left.def  = button_list.at(XInputKeyCodes::LSXNeg);
+	m_pad_config.ls_down.def  = button_list.at(XInputKeyCodes::LSYNeg);
+	m_pad_config.ls_right.def = button_list.at(XInputKeyCodes::LSXPos);
+	m_pad_config.ls_up.def    = button_list.at(XInputKeyCodes::LSYPos);
+	m_pad_config.rs_left.def  = button_list.at(XInputKeyCodes::RSXNeg);
+	m_pad_config.rs_down.def  = button_list.at(XInputKeyCodes::RSYNeg);
+	m_pad_config.rs_right.def = button_list.at(XInputKeyCodes::RSXPos);
+	m_pad_config.rs_up.def    = button_list.at(XInputKeyCodes::RSYPos);
+	m_pad_config.start.def    = button_list.at(XInputKeyCodes::Start);
+	m_pad_config.select.def   = button_list.at(XInputKeyCodes::Back);
+	m_pad_config.ps.def       = button_list.at(XInputKeyCodes::Guide);
+	m_pad_config.square.def   = button_list.at(XInputKeyCodes::X);
+	m_pad_config.cross.def    = button_list.at(XInputKeyCodes::A);
+	m_pad_config.circle.def   = button_list.at(XInputKeyCodes::B);
+	m_pad_config.triangle.def = button_list.at(XInputKeyCodes::Y);
+	m_pad_config.left.def     = button_list.at(XInputKeyCodes::Left);
+	m_pad_config.down.def     = button_list.at(XInputKeyCodes::Down);
+	m_pad_config.right.def    = button_list.at(XInputKeyCodes::Right);
+	m_pad_config.up.def       = button_list.at(XInputKeyCodes::Up);
+	m_pad_config.r1.def       = button_list.at(XInputKeyCodes::RB);
+	m_pad_config.r2.def       = button_list.at(XInputKeyCodes::RT);
+	m_pad_config.r3.def       = button_list.at(XInputKeyCodes::RS);
+	m_pad_config.l1.def       = button_list.at(XInputKeyCodes::RB);
+	m_pad_config.l2.def       = button_list.at(XInputKeyCodes::LT);
+	m_pad_config.l3.def       = button_list.at(XInputKeyCodes::LS);
+
+	// Set default misc variables
+	m_pad_config.lstickdeadzone.def = XINPUT_GAMEPAD_LEFT_THUMB_DEADZONE;  // between 0 and 32767
+	m_pad_config.rstickdeadzone.def = XINPUT_GAMEPAD_RIGHT_THUMB_DEADZONE; // between 0 and 32767
+	m_pad_config.ltriggerthreshold.def = XINPUT_GAMEPAD_TRIGGER_THRESHOLD; // between 0 and 255
+	m_pad_config.rtriggerthreshold.def = XINPUT_GAMEPAD_TRIGGER_THRESHOLD; // between 0 and 255
+	m_pad_config.padsquircling.def = 8000;
+
+	// apply defaults
+	m_pad_config.from_default();
+
+	// set capabilities
+	b_has_config = true;
+	b_has_rumble = true;
+	b_has_deadzones = true;
+
+	m_trigger_threshold = trigger_max / 2;
+	m_thumb_threshold = thumb_max / 2;
 }
 
 xinput_pad_handler::~xinput_pad_handler()
@@ -43,11 +70,198 @@ xinput_pad_handler::~xinput_pad_handler()
 	Close();
 }
 
+void xinput_pad_handler::GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& callback)
+{
+	if (!Init())
+	{
+		return;
+	}
+
+	size_t pos = padId.find("Xinput Pad #");
+	int device_number;
+
+	if (pos != std::string::npos)
+	{
+		device_number = std::stoul(padId.substr(pos + 12));
+	}
+
+	if (pos == std::string::npos || device_number >= XUSER_MAX_COUNT)
+	{
+		return;
+	}
+
+	DWORD dwResult;
+	XINPUT_STATE state;
+	ZeroMemory(&state, sizeof(XINPUT_STATE));
+
+	// Simply get the state of the controller from XInput.
+	dwResult = (*xinputGetState)(device_number, &state);
+
+	if (dwResult != ERROR_SUCCESS)
+	{
+		return;
+	}
+
+	// Check for each button in our list if its corresponding (maybe remapped) button or axis was pressed.
+	// Return the new value if the button was pressed (aka. its value was bigger than 0 or the defined threshold)
+	// Use a pair to get all the legally pressed buttons and use the one with highest value (prioritize first)
+	std::pair<u16, std::string> pressed_button = { 0, "" };
+	auto data = GetButtonValues(state);
+	for (const auto& button : button_list)
+	{
+		u32 keycode = button.first;
+		u16 value = data[keycode];
+
+		if (((keycode < XInputKeyCodes::LT) && (value > 0))
+		 || ((keycode == XInputKeyCodes::LT) && (value > m_trigger_threshold))
+		 || ((keycode == XInputKeyCodes::RT) && (value > m_trigger_threshold))
+		 || ((keycode >= XInputKeyCodes::LSXNeg && keycode <= XInputKeyCodes::LSYPos) && (value > m_thumb_threshold))
+		 || ((keycode >= XInputKeyCodes::RSXNeg && keycode <= XInputKeyCodes::RSYPos) && (value > m_thumb_threshold)))
+		{
+			if (value > pressed_button.first)
+			{
+				pressed_button = { value, button.second };
+			}
+		}
+	}
+
+	int preview_values[6] = { data[LT], data[RT], data[LSXPos] - data[LSXNeg], data[LSYPos] - data[LSYNeg], data[RSXPos] - data[RSXNeg], data[RSYPos] - data[RSYNeg] };
+
+	if (pressed_button.first > 0)
+		return callback(pressed_button.first, pressed_button.second, preview_values);
+	else
+		return callback(0, "", preview_values);
+}
+
+void xinput_pad_handler::TestVibration(const std::string& padId, u32 largeMotor, u32 smallMotor)
+{
+	if (!Init())
+	{
+		return;
+	}
+
+	u32 device_number = 0;
+	size_t pos = padId.find("Xinput Pad #");
+
+	if (pos != std::string::npos)
+	{
+		device_number = std::stoul(padId.substr(pos + 12));
+	}
+
+	if (pos == std::string::npos || device_number >= XUSER_MAX_COUNT)
+	{
+		return;
+	}
+
+	// The left motor is the low-frequency rumble motor. The right motor is the high-frequency rumble motor.
+	// The two motors are not the same, and they create different vibration effects.
+	XINPUT_VIBRATION vibrate;
+
+	vibrate.wLeftMotorSpeed = largeMotor;  // between 0 to 65535
+	vibrate.wRightMotorSpeed = smallMotor; // between 0 to 65535
+
+	(*xinputSetState)(device_number, &vibrate);
+}
+
+void xinput_pad_handler::TranslateButtonPress(u64 keyCode, bool& pressed, u16& val, bool ignore_threshold)
+{
+	// Update the pad button values based on their type and thresholds.
+	// With this you can use axis or triggers as buttons or vice versa
+	switch (keyCode)
+	{
+	case XInputKeyCodes::LT:
+		pressed = val > m_pad_config.ltriggerthreshold;
+		val = pressed ? NormalizeTriggerInput(val, m_pad_config.ltriggerthreshold) : 0;
+		break;
+	case XInputKeyCodes::RT:
+		pressed = val > m_pad_config.rtriggerthreshold;
+		val = pressed ? NormalizeTriggerInput(val, m_pad_config.rtriggerthreshold) : 0;
+		break;
+	case XInputKeyCodes::LSXNeg:
+	case XInputKeyCodes::LSXPos:
+	case XInputKeyCodes::LSYPos:
+	case XInputKeyCodes::LSYNeg:
+		pressed = val > (ignore_threshold ? 0 : m_pad_config.lstickdeadzone);
+		val = pressed ? NormalizeStickInput(val, m_pad_config.lstickdeadzone, ignore_threshold) : 0;
+		break;
+	case XInputKeyCodes::RSXNeg:
+	case XInputKeyCodes::RSXPos:
+	case XInputKeyCodes::RSYPos:
+	case XInputKeyCodes::RSYNeg:
+		pressed = val > (ignore_threshold ? 0 : m_pad_config.rstickdeadzone);
+		val = pressed ? NormalizeStickInput(val, m_pad_config.rstickdeadzone, ignore_threshold) : 0;
+		break;
+	default: // normal button (should in theory also support sensitive buttons)
+		pressed = val > 0;
+		val = pressed ? val : 0;
+		break;
+	}
+}
+
+std::array<u16, xinput_pad_handler::XInputKeyCodes::KeyCodeCount> xinput_pad_handler::GetButtonValues(const XINPUT_STATE& state)
+{
+	std::array<u16, xinput_pad_handler::XInputKeyCodes::KeyCodeCount> values;
+
+	// Triggers
+	values[XInputKeyCodes::LT] = state.Gamepad.bLeftTrigger;
+	values[XInputKeyCodes::RT] = state.Gamepad.bRightTrigger;
+
+	// Sticks
+	int lx = state.Gamepad.sThumbLX;
+	int ly = state.Gamepad.sThumbLY;
+	int rx = state.Gamepad.sThumbRX;
+	int ry = state.Gamepad.sThumbRY;
+
+	// Left Stick X Axis
+	values[XInputKeyCodes::LSXNeg] = lx < 0 ? abs(lx) - 1 : 0;
+	values[XInputKeyCodes::LSXPos] = lx > 0 ? lx : 0;
+
+	// Left Stick Y Axis
+	values[XInputKeyCodes::LSYNeg] = ly < 0 ? abs(ly) - 1 : 0;
+	values[XInputKeyCodes::LSYPos] = ly > 0 ? ly : 0;
+
+	// Right Stick X Axis
+	values[XInputKeyCodes::RSXNeg] = rx < 0 ? abs(rx) - 1 : 0;
+	values[XInputKeyCodes::RSXPos] = rx > 0 ? rx : 0;
+
+	// Right Stick Y Axis
+	values[XInputKeyCodes::RSYNeg] = ry < 0 ? abs(ry) - 1 : 0;
+	values[XInputKeyCodes::RSYPos] = ry > 0 ? ry : 0;
+
+	// Buttons
+	WORD buttons = state.Gamepad.wButtons;
+
+	// A, B, X, Y
+	values[XInputKeyCodes::A] = buttons & XINPUT_GAMEPAD_A ? 255 : 0;
+	values[XInputKeyCodes::B] = buttons & XINPUT_GAMEPAD_B ? 255 : 0;
+	values[XInputKeyCodes::X] = buttons & XINPUT_GAMEPAD_X ? 255 : 0;
+	values[XInputKeyCodes::Y] = buttons & XINPUT_GAMEPAD_Y ? 255 : 0;
+
+	// D-Pad
+	values[XInputKeyCodes::Left]  = buttons & XINPUT_GAMEPAD_DPAD_LEFT ? 255 : 0;
+	values[XInputKeyCodes::Right] = buttons & XINPUT_GAMEPAD_DPAD_RIGHT ? 255 : 0;
+	values[XInputKeyCodes::Up]    = buttons & XINPUT_GAMEPAD_DPAD_UP ? 255 : 0;
+	values[XInputKeyCodes::Down]  = buttons & XINPUT_GAMEPAD_DPAD_DOWN ? 255 : 0;
+
+	// LB, RB, LS, RS
+	values[XInputKeyCodes::LB] = buttons & XINPUT_GAMEPAD_LEFT_SHOULDER ? 255 : 0;
+	values[XInputKeyCodes::RB] = buttons & XINPUT_GAMEPAD_RIGHT_SHOULDER ? 255 : 0;
+	values[XInputKeyCodes::LS] = buttons & XINPUT_GAMEPAD_LEFT_THUMB ? 255 : 0;
+	values[XInputKeyCodes::RS] = buttons & XINPUT_GAMEPAD_RIGHT_THUMB ? 255 : 0;
+
+	// Start, Back, Guide
+	values[XInputKeyCodes::Start] = buttons & XINPUT_GAMEPAD_START ? 255 : 0;
+	values[XInputKeyCodes::Back]  = buttons & XINPUT_GAMEPAD_BACK ? 255 : 0;
+	values[XInputKeyCodes::Guide] = buttons & XINPUT_INFO::GUIDE_BUTTON ? 255 : 0;
+
+	return values;
+}
+
 bool xinput_pad_handler::Init()
 {
 	if (is_init) return true;
 
-	for (auto it : LIBRARY_FILENAMES)
+	for (auto it : XINPUT_INFO::LIBRARY_FILENAMES)
 	{
 		library = LoadLibrary(it);
 		if (library)
@@ -60,8 +274,9 @@ bool xinput_pad_handler::Init()
 			}
 
 			xinputSetState = reinterpret_cast<PFN_XINPUTSETSTATE>(GetProcAddress(library, "XInputSetState"));
+			xinputGetBatteryInformation = reinterpret_cast<PFN_XINPUTGETBATTERYINFORMATION>(GetProcAddress(library, "XInputGetBatteryInformation"));
 
-			if (xinputEnable && xinputGetState && xinputSetState)
+			if (xinputEnable && xinputGetState && xinputSetState && xinputGetBatteryInformation)
 			{
 				is_init = true;
 				break;
@@ -71,17 +286,14 @@ bool xinput_pad_handler::Init()
 			library = nullptr;
 			xinputEnable = nullptr;
 			xinputGetState = nullptr;
+			xinputGetBatteryInformation = nullptr;
 		}
 	}
 
 	if (!is_init) return false;
 
-	xinput_cfg.load();
-	if (!xinput_cfg.exist()) xinput_cfg.save();
-
-	squircle_factor = xinput_cfg.padsquircling / 1000.f;
-	left_stick_deadzone = xinput_cfg.lstickdeadzone;
-	right_stick_deadzone = xinput_cfg.rstickdeadzone;
+	m_pad_config.load();
+	if (!m_pad_config.exist()) m_pad_config.save();
 
 	return true;
 }
@@ -94,36 +306,17 @@ void xinput_pad_handler::Close()
 		library = nullptr;
 		xinputGetState = nullptr;
 		xinputEnable = nullptr;
+		xinputGetBatteryInformation = nullptr;
 	}
 }
 
-std::tuple<u16, u16> xinput_pad_handler::ConvertToSquirclePoint(u16 inX, u16 inY)
-{
-	// convert inX and Y to a (-1, 1) vector;
-	const f32 x = (inX - 127) / 127.f;
-	const f32 y = ((inY - 127) / 127.f);
-
-	// compute angle and len of given point to be used for squircle radius
-	const f32 angle = std::atan2(y, x);
-	const f32 r = std::sqrt(std::pow(x, 2.f) + std::pow(y, 2.f));
-
-	// now find len/point on the given squircle from our current angle and radius in polar coords
-	// https://thatsmaths.com/2016/07/14/squircles/
-	const f32 newLen = (1 + std::pow(std::sin(2 * angle), 2.f) / squircle_factor) * r;
-
-	// we now have len and angle, convert to cartisian
-
-	const int newX = Clamp0To255(((newLen * std::cos(angle)) + 1) * 127);
-	const int newY = Clamp0To255(((newLen * std::sin(angle)) + 1) * 127);
-	return std::tuple<u16, u16>(newX, newY);
-}
-
 void xinput_pad_handler::ThreadProc()
 {
-	for (u32 index = 0; index != bindings.size(); index++)
+	for (auto &bind : bindings)
 	{
-		auto padnum = bindings[index].first;
-		auto pad = bindings[index].second;
+		auto device = bind.first;
+		auto padnum = device->deviceNumber;
+		auto pad = bind.second;
 
 		result = (*xinputGetState)(padnum, &state);
 		switch (result)
@@ -142,77 +335,95 @@ void xinput_pad_handler::ThreadProc()
 			last_connection_status[padnum] = true;
 			pad->m_port_status |= CELL_PAD_STATUS_CONNECTED;
 
-			for (DWORD j = 0; j != XINPUT_GAMEPAD_BUTTONS; ++j)
+			std::array<u16, XInputKeyCodes::KeyCodeCount> button_values = GetButtonValues(state);
+
+			// Translate any corresponding keycodes to our normal DS3 buttons and triggers
+			for (auto& btn : pad->m_buttons)
 			{
-				bool pressed = state.Gamepad.wButtons & (1 << j);
-				pad->m_buttons[j].m_pressed = pressed;
-				pad->m_buttons[j].m_value = pressed ? 255 : 0;
+				btn.m_value = button_values[btn.m_keyCode];
+				TranslateButtonPress(btn.m_keyCode, btn.m_pressed, btn.m_value);
 			}
 
-			for (int i = 6; i < 16; i++)
+			for (const auto& btn : pad->m_buttons)
 			{
-				if (pad->m_buttons[i].m_pressed)
+				if (btn.m_pressed)
 				{
 					SetThreadExecutionState(ES_SYSTEM_REQUIRED | ES_DISPLAY_REQUIRED);
 					break;
 				}
 			}
 
-			pad->m_buttons[XINPUT_GAMEPAD_BUTTONS].m_pressed = state.Gamepad.bLeftTrigger > 0;
-			pad->m_buttons[XINPUT_GAMEPAD_BUTTONS].m_value = state.Gamepad.bLeftTrigger;
-			pad->m_buttons[XINPUT_GAMEPAD_BUTTONS + 1].m_pressed = state.Gamepad.bRightTrigger > 0;
-			pad->m_buttons[XINPUT_GAMEPAD_BUTTONS + 1].m_value = state.Gamepad.bRightTrigger;
+			// used to get the absolute value of an axis
+			float stick_val[4];
 
-			float LX, LY, RX, RY;
-
-			LX = state.Gamepad.sThumbLX;
-			LY = state.Gamepad.sThumbLY;
-			RX = state.Gamepad.sThumbRX;
-			RY = state.Gamepad.sThumbRY;
-
-			auto normalize_input = [](float& X, float& Y, float deadzone)
+			// Translate any corresponding keycodes to our two sticks. (ignoring thresholds for now)
+			for (int i = 0; i < static_cast<int>(pad->m_sticks.size()); i++)
 			{
-				X /= 32767.0f;
-				Y /= 32767.0f;
-				deadzone /= 32767.0f;
+				bool pressed;
 
-				float mag = sqrtf(X*X + Y*Y);
+				// m_keyCodeMin is the mapped key for left or down
+				u32 key_min = pad->m_sticks[i].m_keyCodeMin;
+				u16 val_min = button_values[key_min];
+				TranslateButtonPress(key_min, pressed, val_min, true);
 
-				if (mag > deadzone)
-				{
-					float legalRange = 1.0f - deadzone;
-					float normalizedMag = std::min(1.0f, (mag - deadzone) / legalRange);
-					float scale = normalizedMag / mag;
-					X = X * scale;
-					Y = Y * scale;
-				}
-				else
-				{
-					X = 0;
-					Y = 0;
-				}
-			};
+				// m_keyCodeMax is the mapped key for right or up
+				u32 key_max = pad->m_sticks[i].m_keyCodeMax;
+				u16 val_max = button_values[key_max];
+				TranslateButtonPress(key_max, pressed, val_max, true);
 
-			normalize_input(LX, LY, left_stick_deadzone);
-			normalize_input(RX, RY, right_stick_deadzone);
-
-			pad->m_sticks[0].m_value = ConvertAxis(LX);
-			pad->m_sticks[1].m_value = 255 - ConvertAxis(LY);
-			pad->m_sticks[2].m_value = ConvertAxis(RX);
-			pad->m_sticks[3].m_value = 255 - ConvertAxis(RY);
-
-			if (squircle_factor != 0.f)
-			{
-				std::tie(pad->m_sticks[0].m_value, pad->m_sticks[1].m_value) = ConvertToSquirclePoint(pad->m_sticks[0].m_value, pad->m_sticks[1].m_value);
-				std::tie(pad->m_sticks[2].m_value, pad->m_sticks[3].m_value) = ConvertToSquirclePoint(pad->m_sticks[2].m_value, pad->m_sticks[3].m_value);
+				// cancel out opposing values and get the resulting difference
+				stick_val[i] = val_max - val_min;
 			}
 
-			XINPUT_VIBRATION vibrate;
+			u16 lx, ly, rx, ry;
 
-			vibrate.wLeftMotorSpeed = pad->m_vibrateMotors[0].m_value * 257;
-			vibrate.wRightMotorSpeed = pad->m_vibrateMotors[1].m_value * 257;
+			// Normalize our two stick's axis based on the thresholds
+			std::tie(lx, ly) = NormalizeStickDeadzone(stick_val[0], stick_val[1], m_pad_config.lstickdeadzone);
+			std::tie(rx, ry) = NormalizeStickDeadzone(stick_val[2], stick_val[3], m_pad_config.rstickdeadzone);
 
-			(*xinputSetState)(padnum, &vibrate);
+			if (m_pad_config.padsquircling != 0)
+			{
+				std::tie(lx, ly) = ConvertToSquirclePoint(lx, ly, m_pad_config.padsquircling);
+				std::tie(rx, ry) = ConvertToSquirclePoint(rx, ry, m_pad_config.padsquircling);
+			}
+
+			pad->m_sticks[0].m_value = lx;
+			pad->m_sticks[1].m_value = 255 - ly;
+			pad->m_sticks[2].m_value = rx;
+			pad->m_sticks[3].m_value = 255 - ry;
+
+			// Receive Battery Info. If device is not on cable, get battery level, else assume full
+			XINPUT_BATTERY_INFORMATION battery_info;
+			(*xinputGetBatteryInformation)(padnum, BATTERY_DEVTYPE_GAMEPAD, &battery_info);
+			pad->m_cable_state = battery_info.BatteryType == BATTERY_TYPE_WIRED ? 1 : 0;
+			pad->m_battery_level = pad->m_cable_state ? BATTERY_LEVEL_FULL : battery_info.BatteryLevel;
+
+			// The left motor is the low-frequency rumble motor. The right motor is the high-frequency rumble motor.
+			// The two motors are not the same, and they create different vibration effects. Values range between 0 to 65535.
+			int idx_l = m_pad_config.switch_vibration_motors ? 1 : 0;
+			int idx_s = m_pad_config.switch_vibration_motors ? 0 : 1;
+
+			int speed_large = m_pad_config.enable_vibration_motor_large ? pad->m_vibrateMotors[idx_l].m_value * 257 : vibration_min;
+			int speed_small = m_pad_config.enable_vibration_motor_small ? pad->m_vibrateMotors[idx_s].m_value * 257 : vibration_min;
+
+			device->newVibrateData = device->newVibrateData || device->largeVibrate != speed_large || device->smallVibrate != speed_small;
+
+			device->largeVibrate = speed_large;
+			device->smallVibrate = speed_small;
+
+			// XBox One Controller can't handle faster vibration updates than ~10ms. Elite is even worse. So I'll use 20ms to be on the safe side. No lag was noticable.
+			if (device->newVibrateData && (clock() - device->last_vibration > 20))
+			{
+				XINPUT_VIBRATION vibrate;
+				vibrate.wLeftMotorSpeed = speed_large;
+				vibrate.wRightMotorSpeed = speed_small;
+
+				if ((*xinputSetState)(padnum, &vibrate) == ERROR_SUCCESS)
+				{
+					device->newVibrateData = false;
+					device->last_vibration = clock();
+				}
+			}
 
 			break;
 		}
@@ -225,7 +436,7 @@ std::vector<std::string> xinput_pad_handler::ListDevices()
 
 	if (!Init()) return xinput_pads_list;
 
-	for (DWORD i = 0; i < MAX_GAMEPADS; i++)
+	for (DWORD i = 0; i < XUSER_MAX_COUNT; i++)
 	{
 		XINPUT_STATE state;
 		DWORD result = (*xinputGetState)(i, &state);
@@ -245,43 +456,54 @@ bool xinput_pad_handler::bindPadToDevice(std::shared_ptr<Pad> pad, const std::st
 
 	if (pos != std::string::npos) device_number = std::stoul(device.substr(pos + 12));
 
-	if (pos == std::string::npos || device_number >= MAX_GAMEPADS) return false;
+	if (pos == std::string::npos || device_number >= XUSER_MAX_COUNT) return false;
 
-	pad->Init(
-		CELL_PAD_STATUS_DISCONNECTED,
+	std::shared_ptr<XInputDevice> device_id = std::make_shared<XInputDevice>();
+	device_id->deviceNumber = device_number;
+
+	m_pad_config.load();
+
+	pad->Init
+	(
+		CELL_PAD_STATUS_CONNECTED | CELL_PAD_STATUS_ASSIGN_CHANGES,
 		CELL_PAD_SETTING_PRESS_OFF | CELL_PAD_SETTING_SENSOR_OFF,
-		CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE | CELL_PAD_CAPABILITY_ACTUATOR,
+		CELL_PAD_CAPABILITY_PS3_CONFORMITY | CELL_PAD_CAPABILITY_PRESS_MODE | CELL_PAD_CAPABILITY_HP_ANALOG_STICK | CELL_PAD_CAPABILITY_ACTUATOR | CELL_PAD_CAPABILITY_SENSOR_MODE,
 		CELL_PAD_DEV_TYPE_STANDARD
 	);
 
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_DPAD_UP, CELL_PAD_CTRL_UP);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_DPAD_DOWN, CELL_PAD_CTRL_DOWN);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_DPAD_LEFT, CELL_PAD_CTRL_LEFT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_DPAD_RIGHT, CELL_PAD_CTRL_RIGHT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_START, CELL_PAD_CTRL_START);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_BACK, CELL_PAD_CTRL_SELECT);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_LEFT_THUMB, CELL_PAD_CTRL_L3);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, XINPUT_GAMEPAD_RIGHT_THUMB, CELL_PAD_CTRL_R3);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_LEFT_SHOULDER, CELL_PAD_CTRL_L1);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_RIGHT_SHOULDER, CELL_PAD_CTRL_R1);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_GUIDE, 0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.up),       CELL_PAD_CTRL_UP);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.down),     CELL_PAD_CTRL_DOWN);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.left),     CELL_PAD_CTRL_LEFT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.right),    CELL_PAD_CTRL_RIGHT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.start),    CELL_PAD_CTRL_START);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.select),   CELL_PAD_CTRL_SELECT);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.l3),       CELL_PAD_CTRL_L3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL1, FindKeyCode(button_list, m_pad_config.r3),       CELL_PAD_CTRL_R3);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.l1),       CELL_PAD_CTRL_L1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.r1),       CELL_PAD_CTRL_R1);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.ps),       0x100/*CELL_PAD_CTRL_PS*/);// TODO: PS button support
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.cross),    CELL_PAD_CTRL_CROSS);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.circle),   CELL_PAD_CTRL_CIRCLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.square),   CELL_PAD_CTRL_SQUARE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.triangle), CELL_PAD_CTRL_TRIANGLE);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.l2),       CELL_PAD_CTRL_L2);
+	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, FindKeyCode(button_list, m_pad_config.r2),       CELL_PAD_CTRL_R2);
 	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, 0x0); // Reserved
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_A, CELL_PAD_CTRL_CROSS);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_B, CELL_PAD_CTRL_CIRCLE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_X, CELL_PAD_CTRL_SQUARE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, XINPUT_GAMEPAD_Y, CELL_PAD_CTRL_TRIANGLE);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_L2);
-	pad->m_buttons.emplace_back(CELL_PAD_BTN_OFFSET_DIGITAL2, 0, CELL_PAD_CTRL_R2);
 
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, 0, 0);
-	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, 0, 0);
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_X,  FindKeyCode(button_list, m_pad_config.ls_left), FindKeyCode(button_list, m_pad_config.ls_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_LEFT_Y,  FindKeyCode(button_list, m_pad_config.ls_down), FindKeyCode(button_list, m_pad_config.ls_up));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_X, FindKeyCode(button_list, m_pad_config.rs_left), FindKeyCode(button_list, m_pad_config.rs_right));
+	pad->m_sticks.emplace_back(CELL_PAD_BTN_OFFSET_ANALOG_RIGHT_Y, FindKeyCode(button_list, m_pad_config.rs_down), FindKeyCode(button_list, m_pad_config.rs_up));
+
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_X, 512);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Y, 399);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_Z, 512);
+	pad->m_sensors.emplace_back(CELL_PAD_BTN_OFFSET_SENSOR_G, 512);
 
 	pad->m_vibrateMotors.emplace_back(true, 0);
 	pad->m_vibrateMotors.emplace_back(false, 0);
 
-	bindings.emplace_back(device_number, pad);
+	bindings.emplace_back(device_id, pad);
 
 	return true;
 }
diff --git a/rpcs3/xinput_pad_handler.h b/rpcs3/xinput_pad_handler.h
index 8c1eed9834..c56ac4a740 100644
--- a/rpcs3/xinput_pad_handler.h
+++ b/rpcs3/xinput_pad_handler.h
@@ -1,43 +1,102 @@
-#ifndef X_INPUT_PAD_HANDLER
-#define X_INPUT_PAD_HANDLER
+#pragma once
 
+#include "stdafx.h"
 #include "Utilities/Config.h"
 #include "Emu/Io/PadHandler.h"
 #define NOMINMAX
 #include <Windows.h>
 #include <Xinput.h>
+#include <ctime>
 
-struct xinput_config final : cfg::node
+namespace XINPUT_INFO
 {
-	const std::string cfg_name = fs::get_config_dir() + "/config_xinput.yml";
-
-	cfg::_int<0, 1000000> lstickdeadzone{ this, "Left Stick Deadzone", 7849 };
-	cfg::_int<0, 1000000> rstickdeadzone{ this, "Right Stick Deadzone", 8689 };
-	cfg::_int<0, 1000000> padsquircling{ this, "Pad Squircling Factor", 8000 };
-
-	bool load()
-	{
-		if (fs::file cfg_file{ cfg_name, fs::read })
-		{
-			return from_string(cfg_file.to_string());
-		}
-
-		return false;
-	}
-
-	void save()
-	{
-		fs::file(cfg_name, fs::rewrite).write(to_string());
-	}
-
-	bool exist()
-	{
-		return fs::is_file(cfg_name);
-	}
-};
+	const DWORD THREAD_TIMEOUT = 1000;
+	const DWORD THREAD_SLEEP = 10;
+	const DWORD THREAD_SLEEP_INACTIVE = 100;
+	const DWORD GUIDE_BUTTON = 0x0400;
+	const LPCWSTR LIBRARY_FILENAMES[] = {
+		L"xinput1_4.dll",
+		L"xinput1_3.dll",
+		L"xinput1_2.dll",
+		L"xinput9_1_0.dll"
+	};
+}
 
 class xinput_pad_handler final : public PadHandlerBase
 {
+	// These are all the possible buttons on a standard xbox 360 or xbox one controller
+	enum XInputKeyCodes
+	{
+		A,
+		B,
+		X,
+		Y,
+		Left,
+		Right,
+		Up,
+		Down,
+		LB,
+		RB,
+		LS,
+		RS,
+		Start,
+		Back,
+		Guide,
+
+		LT,
+		RT,
+
+		LSXNeg,
+		LSXPos,
+		LSYNeg,
+		LSYPos,
+		RSXNeg,
+		RSXPos,
+		RSYNeg,
+		RSYPos,
+
+		KeyCodeCount
+	};
+
+	// Unique names for the config files and our pad settings dialog
+	const std::unordered_map<u32, std::string> button_list =
+	{
+		{ XInputKeyCodes::A,      "A" },
+		{ XInputKeyCodes::B,      "B" },
+		{ XInputKeyCodes::X,      "X" },
+		{ XInputKeyCodes::Y,      "Y" },
+		{ XInputKeyCodes::Left,   "Left" },
+		{ XInputKeyCodes::Right,  "Right" },
+		{ XInputKeyCodes::Up,     "Up" },
+		{ XInputKeyCodes::Down,   "Down" },
+		{ XInputKeyCodes::LB,     "LB" },
+		{ XInputKeyCodes::RB,     "RB" },
+		{ XInputKeyCodes::Back,   "Back" },
+		{ XInputKeyCodes::Start,  "Start" },
+		{ XInputKeyCodes::LS,     "LS" },
+		{ XInputKeyCodes::RS,     "RS" },
+		{ XInputKeyCodes::Guide,  "Guide" },
+		{ XInputKeyCodes::LT,     "LT" },
+		{ XInputKeyCodes::RT,     "RT" },
+		{ XInputKeyCodes::LSXNeg, "LS X-" },
+		{ XInputKeyCodes::LSXPos, "LS X+" },
+		{ XInputKeyCodes::LSYPos, "LS Y+" },
+		{ XInputKeyCodes::LSYNeg, "LS Y-" },
+		{ XInputKeyCodes::RSXNeg, "RS X-" },
+		{ XInputKeyCodes::RSXPos, "RS X+" },
+		{ XInputKeyCodes::RSYPos, "RS Y+" },
+		{ XInputKeyCodes::RSYNeg, "RS Y-" }
+	};
+
+	struct XInputDevice
+	{
+		u32 deviceNumber{ 0 };
+		bool newVibrateData{ true };
+		u8 largeVibrate{ 0 };
+		u8 smallVibrate{ 0 };
+		clock_t last_vibration{ 0 };
+	};
+
 public:
 	xinput_pad_handler();
 	~xinput_pad_handler();
@@ -48,25 +107,27 @@ public:
 	std::vector<std::string> ListDevices() override;
 	bool bindPadToDevice(std::shared_ptr<Pad> pad, const std::string& device) override;
 	void ThreadProc() override;
+	void GetNextButtonPress(const std::string& padId, const std::function<void(u16, std::string, int[])>& callback) override;
+	void TestVibration(const std::string& padId, u32 largeMotor, u32 smallMotor) override;
 
 private:
 	typedef void (WINAPI * PFN_XINPUTENABLE)(BOOL);
 	typedef DWORD (WINAPI * PFN_XINPUTGETSTATE)(DWORD, XINPUT_STATE *);
 	typedef DWORD (WINAPI * PFN_XINPUTSETSTATE)(DWORD, XINPUT_VIBRATION *);
+	typedef DWORD (WINAPI * PFN_XINPUTGETBATTERYINFORMATION)(DWORD, BYTE, XINPUT_BATTERY_INFORMATION *);
 
 private:
-	std::tuple<u16, u16> ConvertToSquirclePoint(u16 inX, u16 inY);
+	std::array<u16, XInputKeyCodes::KeyCodeCount> GetButtonValues(const XINPUT_STATE& state);
+	void TranslateButtonPress(u64 keyCode, bool& pressed, u16& val, bool ignore_threshold = false) override;
 
-private:
 	bool is_init;
-	float squircle_factor;
-	u32 left_stick_deadzone, right_stick_deadzone;
 	HMODULE library;
 	PFN_XINPUTGETSTATE xinputGetState;
 	PFN_XINPUTSETSTATE xinputSetState;
 	PFN_XINPUTENABLE xinputEnable;
+	PFN_XINPUTGETBATTERYINFORMATION xinputGetBatteryInformation;
 
-	std::vector<std::pair<u32, std::shared_ptr<Pad>>> bindings;
+	std::vector<std::pair<std::shared_ptr<XInputDevice>, std::shared_ptr<Pad>>> bindings;
 	std::array<bool, 7> last_connection_status = {};
 
 	// holds internal controller state change
@@ -74,7 +135,3 @@ private:
 	DWORD result;
 	DWORD online = 0;
 };
-
-extern xinput_config xinput_cfg;
-
-#endif