ozone: evdev: Add gamepad support

ui/events/ozone/gamepad/gamepad_mapping.cc

Index: ui/events/ozone/gamepad/gamepad_mapping.cc
diff --git a/ui/events/ozone/gamepad/gamepad_mapping.cc b/ui/events/ozone/gamepad/gamepad_mapping.cc
new file mode 100644
index 0000000000000000000000000000000000000000..17559bbe9420e43b678b6975d13cb821c2f264e1
--- /dev/null
+++ b/ui/events/ozone/gamepad/gamepad_mapping.cc
@@ -0,0 +1,427 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include <linux/input.h>
+#include <cstdint>
+#include <map>
+
+#include "base/macros.h"
+#include "ui/events/ozone/gamepad/gamepad_mapping.h"
+#include "ui/events/ozone/gamepad/webgamepad_constants.h"
+
+namespace ui {
+using KeyMapType = std::map<uint16_t, uint16_t>;
+using AbsMapType = std::map<uint16_t, std::pair<GamepadEventType, uint16_t>>;
+#define TO_BTN(code, mapped_code)                   \
+  {                                                 \
+    code, { GamepadEventType::BUTTON, mapped_code } \
+  }
+
+#define TO_ABS(code, mapped_code)                 \
+  {                                               \
+    code, { GamepadEventType::AXIS, mapped_code } \
+  }
+
+bool DoGamepadMapping(const KeyMapType& key_mapping,
+                      const AbsMapType& abs_mapping,
+                      uint16_t type,
+                      uint16_t code,
+                      GamepadEventType* mapped_type,
+                      uint16_t* mapped_code) {
+  if (type == EV_KEY) {
+    auto ite = key_mapping.find(code);
+    if (ite == key_mapping.end()) {
+      return false;
+    }
+    *mapped_type = GamepadEventType::BUTTON;
+    *mapped_code = ite->second;
+  } else {
+    auto ite = abs_mapping.find(code);
+    if (ite == abs_mapping.end()) {
+      return false;
+    }
+    *mapped_type = ite->second.first;
+    *mapped_code = ite->second.second;
+  }
+  return true;
+}
+
+// this mapper mapps gamepads compatible with xbox gamepad.
+bool XInputStyleMapper(uint16_t type,
+                       uint16_t code,
+                       GamepadEventType* mapped_type,
+                       uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {BTN_A, WG_BUTTON_A},            // btn_a = 304 / 0x130
+      {BTN_B, WG_BUTTON_B},            // btn_b = 305 / 0x131
+      {BTN_X, WG_BUTTON_X},            // btn_x = 307 / 0x133
+      {BTN_Y, WG_BUTTON_Y},            // btn_y = 308 / 0x134
+      {BTN_TL, WG_BUTTON_L1},          // btn_tl = 310 / 0x136
+      {BTN_TR, WG_BUTTON_R1},          // btn_tr = 311 / 0x137
+      {BTN_SELECT, WG_BUTTON_SELECT},  // btn_select = 314 / 0x13a
+      {BTN_START, WG_BUTTON_START},    // btn_start = 315 / 0x13b
+      {BTN_THUMBL, WG_BUTTON_THUMBL},  // btn_thumbl = 317 / 0x13d
+      {BTN_THUMBR, WG_BUTTON_THUMBR},  // btn_thumbr = 318 / 0x13e
+      {BTN_MODE, WG_BUTTON_MODE}       // btn_mode = 316 / 0x13c
+  };
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),       // ABS_X = 0x00
+      TO_ABS(ABS_Y, WG_ABS_Y),       // ABS_Y = 0x01
+      TO_ABS(ABS_RX, WG_ABS_Z),      // ABS_RX = 0x03
+      TO_ABS(ABS_RY, WG_ABS_RZ),     // ABS_RZ = 0x04
+      TO_BTN(ABS_Z, WG_BUTTON_L2),   // ABS_Z = 0x02
+      TO_BTN(ABS_RZ, WG_BUTTON_R2),  // ABS_RZ = 0x05
+      TO_BTN(ABS_HAT0X, kHAT_X),     // HAT0X = 0x10
+      TO_BTN(ABS_HAT0Y, kHAT_Y)      // HAT0Y = 0x11
+  };
+
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool PlaystationSixAxisMapper(uint16_t type,
+                              uint16_t code,
+                              GamepadEventType* mapped_type,
+                              uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {0x12e, WG_BUTTON_A},
+      {0x12d, WG_BUTTON_B},
+      {BTN_DEAD, WG_BUTTON_X},
+      {0x12c, WG_BUTTON_Y},
+      {BTN_BASE5, WG_BUTTON_L1},
+      {BTN_BASE6, WG_BUTTON_R1},
+      {BTN_BASE3, WG_BUTTON_L2},
+      {BTN_BASE4, WG_BUTTON_R2},
+      {BTN_TRIGGER, WG_BUTTON_SELECT},
+      {BTN_TOP, WG_BUTTON_START},
+      {BTN_THUMB, WG_BUTTON_THUMBL},
+      {BTN_THUMB2, WG_BUTTON_THUMBR},
+      {BTN_TOP2, WG_BUTTON_DPAD_UP},
+      {BTN_BASE, WG_BUTTON_DPAD_DOWN},
+      {BTN_BASE2, WG_BUTTON_DPAD_LEFT},
+      {BTN_PINKIE, WG_BUTTON_DPAD_RIGHT},
+      {BTN_TRIGGER_HAPPY17, WG_BUTTON_MODE},
+  };
+
+  static AbsMapType abs_mapping = {TO_ABS(ABS_X, WG_ABS_X),
+                                   TO_ABS(ABS_Y, WG_ABS_Y),
+                                   TO_ABS(ABS_Z, WG_ABS_Z),
+                                   TO_ABS(ABS_RZ, WG_ABS_RZ),
+                                   TO_BTN(ABS_MT_TOUCH_MAJOR, WG_BUTTON_L2),
+                                   TO_BTN(ABS_MT_TOUCH_MINOR, WG_BUTTON_R2)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool IBuffalocClassicMapper(uint16_t type,
+                            uint16_t code,
+                            GamepadEventType* mapped_type,
+                            uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {BTN_TRIGGER, WG_BUTTON_A}, {BTN_THUMB, WG_BUTTON_B},
+      {BTN_THUMB2, WG_BUTTON_X},  {BTN_TOP, WG_BUTTON_Y},
+      {BTN_BASE, WG_BUTTON_L1},   {BTN_BASE2, WG_BUTTON_R1},
+      {BTN_TOP2, WG_BUTTON_L2},   {BTN_PINKIE, WG_BUTTON_R2}};
+
+  static AbsMapType abs_mapping = {
+      TO_BTN(ABS_X, kHAT_X), TO_BTN(ABS_Y, kHAT_Y),
+  };
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool ClassicNESMapper(uint16_t type,
+                      uint16_t code,
+                      GamepadEventType* mapped_type,
+                      uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {BTN_THUMB, WG_BUTTON_A},      {BTN_THUMB2, WG_BUTTON_B},
+      {BTN_TRIGGER, WG_BUTTON_X},    {BTN_TOP, WG_BUTTON_Y},
+      {BTN_TOP2, WG_BUTTON_L1},      {BTN_PINKIE, WG_BUTTON_R1},
+      {BTN_BASE3, WG_BUTTON_SELECT}, {BTN_BASE4, WG_BUTTON_START}};
+
+  static AbsMapType abs_mapping = {
+      TO_BTN(ABS_X, kHAT_X), TO_BTN(ABS_Y, kHAT_Y),
+  };
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool SNesRetroMapper(uint16_t type,
+                     uint16_t code,
+                     GamepadEventType* mapped_type,
+                     uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {BTN_C, WG_BUTTON_A},        {BTN_B, WG_BUTTON_B},
+      {BTN_X, WG_BUTTON_X},        {BTN_A, WG_BUTTON_Y},
+      {BTN_Y, WG_BUTTON_L1},       {BTN_Z, WG_BUTTON_R1},
+      {BTN_TL2, WG_BUTTON_SELECT}, {BTN_TR2, WG_BUTTON_START}};
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, kHAT_X), TO_ABS(ABS_Y, kHAT_Y),
+  };
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool ADT1Mapper(uint16_t type,
+                uint16_t code,
+                GamepadEventType* mapped_type,
+                uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {BTN_A, WG_BUTTON_A},           {BTN_B, WG_BUTTON_B},
+      {BTN_X, WG_BUTTON_X},           {BTN_Y, WG_BUTTON_Y},
+      {BTN_TL, WG_BUTTON_L1},         {BTN_TR, WG_BUTTON_R1},
+      {BTN_THUMBL, WG_BUTTON_THUMBL}, {BTN_THUMBR, WG_BUTTON_THUMBR},
+      {BTN_MODE, WG_BUTTON_START},    {KEY_BACK, WG_BUTTON_SELECT},
+      {KEY_HOMEPAGE, WG_BUTTON_MODE}};
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),         TO_ABS(ABS_Y, WG_ABS_Y),
+      TO_ABS(ABS_Z, WG_ABS_Z),         TO_ABS(ABS_RZ, WG_ABS_RZ),
+      TO_BTN(ABS_BRAKE, WG_BUTTON_L2), TO_BTN(ABS_GAS, WG_BUTTON_R2),
+      TO_BTN(ABS_HAT0X, kHAT_X),       TO_BTN(ABS_HAT0Y, kHAT_Y)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool Vendor_1d79Product_0009Mapper(uint16_t type,
+                                   uint16_t code,
+                                   GamepadEventType* mapped_type,
+                                   uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A},
+                                   {BTN_B, WG_BUTTON_B},
+                                   {BTN_X, WG_BUTTON_X},
+                                   {BTN_Y, WG_BUTTON_Y},
+                                   {BTN_TL, WG_BUTTON_L1},
+                                   {BTN_TR, WG_BUTTON_R1},
+                                   {BTN_START, WG_BUTTON_START},
+                                   {BTN_THUMBL, WG_BUTTON_THUMBL},
+                                   {BTN_THUMBR, WG_BUTTON_THUMBR},
+                                   {KEY_UP, WG_BUTTON_DPAD_UP},
+                                   {KEY_DOWN, WG_BUTTON_DPAD_DOWN},
+                                   {KEY_LEFT, WG_BUTTON_DPAD_LEFT},
+                                   {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT},
+                                   {KEY_BACK, WG_BUTTON_SELECT},
+                                   {KEY_HOMEPAGE, WG_BUTTON_MODE}};
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),         TO_ABS(ABS_Y, WG_ABS_Y),
+      TO_ABS(ABS_Z, WG_ABS_Z),         TO_ABS(ABS_RZ, WG_ABS_RZ),
+      TO_BTN(ABS_BRAKE, WG_BUTTON_L2), TO_BTN(ABS_GAS, WG_BUTTON_R2),
+      TO_BTN(ABS_HAT0X, kHAT_X),       TO_BTN(ABS_HAT0Y, kHAT_Y)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool Vendor_046dProduct_b501Mapper(uint16_t type,
+                                   uint16_t code,
+                                   GamepadEventType* mapped_type,
+                                   uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A},
+                                   {BTN_B, WG_BUTTON_B},
+                                   {BTN_X, WG_BUTTON_X},
+                                   {BTN_Y, WG_BUTTON_Y},
+                                   {BTN_TL, WG_BUTTON_L1},
+                                   {BTN_TR, WG_BUTTON_R1},
+                                   {BTN_TL2, WG_BUTTON_L2},
+                                   {BTN_TR2, WG_BUTTON_R2},
+                                   {BTN_SELECT, WG_BUTTON_SELECT},
+                                   {BTN_START, WG_BUTTON_START},
+                                   {BTN_THUMBL, WG_BUTTON_THUMBL},
+                                   {BTN_THUMBR, WG_BUTTON_THUMBR},
+                                   {KEY_UP, WG_BUTTON_DPAD_UP},
+                                   {KEY_DOWN, WG_BUTTON_DPAD_DOWN},
+                                   {KEY_LEFT, WG_BUTTON_DPAD_LEFT},
+                                   {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT},
+                                   {BTN_MODE, WG_BUTTON_MODE}};
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),         TO_ABS(ABS_Y, WG_ABS_Y),
+      TO_ABS(ABS_Z, WG_ABS_Z),         TO_ABS(ABS_RZ, WG_ABS_RZ),
+      TO_BTN(ABS_BRAKE, WG_BUTTON_L2), TO_BTN(ABS_GAS, WG_BUTTON_R2),
+      TO_BTN(ABS_HAT0X, kHAT_X),       TO_BTN(ABS_HAT0Y, kHAT_Y)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool Vendor_046dProduct_c216Mapper(uint16_t type,
+                                   uint16_t code,
+                                   GamepadEventType* mapped_type,
+                                   uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {BTN_TRIGGER, WG_BUTTON_A},    {BTN_TOP, WG_BUTTON_B},
+      {BTN_THUMB, WG_BUTTON_X},      {BTN_THUMB2, WG_BUTTON_Y},
+      {BTN_TOP2, WG_BUTTON_L1},      {BTN_PINKIE, WG_BUTTON_R1},
+      {BTN_BASE, WG_BUTTON_L2},      {BTN_BASE2, WG_BUTTON_R2},
+      {BTN_BASE3, WG_BUTTON_SELECT}, {BTN_BASE4, WG_BUTTON_START},
+      {BTN_BASE5, WG_BUTTON_THUMBL}, {BTN_BASE6, WG_BUTTON_THUMBR}};
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),   TO_ABS(ABS_Y, WG_ABS_Y),
+      TO_ABS(ABS_Z, WG_ABS_Z),   TO_ABS(ABS_RZ, WG_ABS_RZ),
+      TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool Vendor_046dProduct_c219Mapper(uint16_t type,
+                                   uint16_t code,
+                                   GamepadEventType* mapped_type,
+                                   uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {BTN_B, WG_BUTTON_A},          {BTN_C, WG_BUTTON_B},
+      {BTN_A, WG_BUTTON_X},          {BTN_X, WG_BUTTON_Y},
+      {BTN_Y, WG_BUTTON_L1},         {BTN_Z, WG_BUTTON_R1},
+      {BTN_TL, WG_BUTTON_L2},        {BTN_TR, WG_BUTTON_R2},
+      {BTN_TR2, WG_BUTTON_START},    {BTN_SELECT, WG_BUTTON_THUMBL},
+      {BTN_START, WG_BUTTON_THUMBR}, {BTN_TL2, WG_BUTTON_SELECT}};
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),   TO_ABS(ABS_Y, WG_ABS_Y),
+      TO_ABS(ABS_Z, WG_ABS_Z),   TO_ABS(ABS_RZ, WG_ABS_RZ),
+      TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool Vendor_1038Product_1412Mapper(uint16_t type,
+                                   uint16_t code,
+                                   GamepadEventType* mapped_type,
+                                   uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {
+      {BTN_A, WG_BUTTON_A},         {BTN_B, WG_BUTTON_B},
+      {BTN_X, WG_BUTTON_X},         {BTN_Y, WG_BUTTON_Y},
+      {BTN_TL, WG_BUTTON_L1},       {BTN_TR, WG_BUTTON_R1},
+      {BTN_MODE, WG_BUTTON_SELECT}, {BTN_START, WG_BUTTON_START},
+  };
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),   TO_ABS(ABS_Y, WG_ABS_Y),
+      TO_ABS(ABS_Z, WG_ABS_Z),   TO_ABS(ABS_RZ, WG_ABS_RZ),
+      TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool Vendor_1689Product_fd00Mapper(uint16_t type,
+                                   uint16_t code,
+                                   GamepadEventType* mapped_type,
+                                   uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A},
+                                   {BTN_B, WG_BUTTON_B},
+                                   {BTN_X, WG_BUTTON_X},
+                                   {BTN_Y, WG_BUTTON_Y},
+                                   {BTN_TL, WG_BUTTON_L1},
+                                   {BTN_TR, WG_BUTTON_R1},
+                                   {BTN_START, WG_BUTTON_START},
+                                   {BTN_THUMBL, WG_BUTTON_THUMBL},
+                                   {BTN_THUMBR, WG_BUTTON_THUMBR},
+                                   {BTN_TRIGGER_HAPPY3, WG_BUTTON_DPAD_UP},
+                                   {BTN_TRIGGER_HAPPY4, WG_BUTTON_DPAD_DOWN},
+                                   {BTN_TRIGGER_HAPPY1, WG_BUTTON_DPAD_LEFT},
+                                   {BTN_TRIGGER_HAPPY2, WG_BUTTON_DPAD_RIGHT},
+                                   {BTN_SELECT, WG_BUTTON_SELECT},
+                                   {BTN_MODE, WG_BUTTON_MODE}};
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),     TO_ABS(ABS_Y, WG_ABS_Y),
+      TO_ABS(ABS_RX, WG_ABS_Z),    TO_ABS(ABS_RY, WG_ABS_RZ),
+      TO_BTN(ABS_Z, WG_BUTTON_L2), TO_BTN(ABS_RZ, WG_BUTTON_R2)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+bool GenericMapper(uint16_t type,
+                   uint16_t code,
+                   GamepadEventType* mapped_type,
+                   uint16_t* mapped_code) {
+  static KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A},
+                                   {BTN_B, WG_BUTTON_B},
+                                   {BTN_X, WG_BUTTON_X},
+                                   {BTN_Y, WG_BUTTON_Y},
+                                   {BTN_TL, WG_BUTTON_L1},
+                                   {BTN_TR, WG_BUTTON_R1},
+                                   {BTN_TL2, WG_BUTTON_L2},
+                                   {BTN_TR2, WG_BUTTON_R2},
+                                   {BTN_THUMBL, WG_BUTTON_THUMBL},
+                                   {BTN_THUMBR, WG_BUTTON_THUMBR},
+                                   {KEY_BACK, WG_BUTTON_SELECT},
+                                   {KEY_HOMEPAGE, WG_BUTTON_MODE},
+                                   {KEY_UP, WG_BUTTON_DPAD_UP},
+                                   {KEY_DOWN, WG_BUTTON_DPAD_DOWN},
+                                   {KEY_LEFT, WG_BUTTON_DPAD_LEFT},
+                                   {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT},
+                                   {BTN_SELECT, WG_BUTTON_SELECT},
+                                   {BTN_START, WG_BUTTON_START},
+                                   {BTN_MODE, WG_BUTTON_MODE}};
+
+  static AbsMapType abs_mapping = {
+      TO_ABS(ABS_X, WG_ABS_X),         TO_ABS(ABS_Y, WG_ABS_Y),
+      TO_ABS(ABS_Z, WG_ABS_Z),         TO_ABS(ABS_RZ, WG_ABS_RZ),
+      TO_BTN(ABS_BRAKE, WG_BUTTON_L2), TO_BTN(ABS_GAS, WG_BUTTON_R2),
+      TO_BTN(ABS_HAT0X, kHAT_X),       TO_BTN(ABS_HAT0Y, kHAT_Y)};
+  return DoGamepadMapping(key_mapping, abs_mapping, type, code, mapped_type,
+                          mapped_code);
+}
+
+static struct MappingData {

[spang, 2017/04/21 05:38:46]

Please make all this stuff const.

I do not think we should copy the data into a std::map; this will use memory
that will never be freed and will be accessed rarely.

You can make static arrays + sizes and never copy the data (like
DeviceCapabilities).

It's unfortunate to duplicate all of this mapping data between the joydev
support in device/gamepad and here... it would be good to find a way to avoid
it. Let's talk to the gamepad owners before getting too deeply into mapping
here.

You might actually want to leave all the mapping stuff for a followup patch.

[jkwang, 2017/04/25 21:16:41]

Sure.
I was hesitating about static array or map. Did not think the memory will be a
huge problem. While map can avoid explicit loop through the array and make the
code cleaner, it might slow down the shut down time cause of the dtor. I am
changing it to static array. 
No. It's not duplicating. Jodev->Webgamepad and Evdev->Webgamepad are quite
different. I don't think anything can be easily reused.

[spang, 2017/05/03 22:00:37]

I'm confident you could compute joydev mappings from evdev mappings, because the
joydev state is computed from the evdev state in the kernel. If it's not true,
then the mappings must be inconsistent - which is really the problem we're
opening ourselves to by having two mappings for the same devices.

Unifying things is not necessarily a showstopper though.

+  uint16_t vendor_id;
+  uint16_t product_id;
+  GamepadMapper mapper;
+} AvailableMappings[] = {
+    // xbox style gamepad
+    {0x045e, 0x028e, XInputStyleMapper},  // xbox 360 wired
+    {0x045e, 0x028f, XInputStyleMapper},  // xbox 360 wireless
+    {0x045e, 0x02a1, XInputStyleMapper},  // xbox 360 wireless
+    {0x045e, 0x02d1, XInputStyleMapper},  // xbox one wired
+    {0x045e, 0x02dd, XInputStyleMapper},  // xbox one wired (2015 fw)
+    {0x045e, 0x02e3, XInputStyleMapper},  // xbox elite wired
+    {0x045e, 0x02ea, XInputStyleMapper},  // xbox one s (usb)
+    {0x045e, 0x0719, XInputStyleMapper},  // xbox 360 wireless
+    {0x046d, 0xc21d, XInputStyleMapper},  // logitech f310
+    {0x046d, 0xc21e, XInputStyleMapper},  // logitech f510
+    {0x046d, 0xc21f, XInputStyleMapper},  // logitech f710
+    {0x2378, 0x1008, XInputStyleMapper},  // onlive controller (bluetooth)
+    {0x2378, 0x100a, XInputStyleMapper},  // onlive controller (wired)
+    {0x1bad, 0xf016, XInputStyleMapper},  // madcatz gamepad
+    {0x1bad, 0xf023, XInputStyleMapper},  // mad catz mlg gamepad for xbox360
+    {0x1bad, 0xf027, XInputStyleMapper},  // madcatz fps pro
+    {0x1bad, 0xf036, XInputStyleMapper},  // madcatz generic xbox controller
+    {0x1689, 0xfd01, XInputStyleMapper},  // razer xbox 360 gamepad
+    {0x1689, 0xfe00, XInputStyleMapper},  // razer sabertooth elite
+    // sony gamepads
+    {0x054c, 0x0268, PlaystationSixAxisMapper},  // playstation 3
+    // nes style gamepad
+    {0x0583, 0x2060, IBuffalocClassicMapper},  // ibuffaloclassic
+    {0x0079, 0x0011, ClassicNESMapper},        // classic nes controller
+    {0x12bd, 0xd015, SNesRetroMapper},         // hitgaming snes retro
+    // android gamepad
+    {0x0b05, 0x4500, ADT1Mapper},  // nexus player controller (asus gamepad)
+    {0x1532, 0x0900, ADT1Mapper},  // razer serval
+    {0x18d1, 0x2c40, ADT1Mapper},  // adt-1 controller (odie)
+    // other gamepad
+    {0x1d79, 0x0009,
+     Vendor_1d79Product_0009Mapper},  // nyko playpad / playpad pro
+    {0x046d, 0xb501, Vendor_046dProduct_b501Mapper},  // logitech redhawk
+    // logitech dual action controller
+    {0x046d, 0xc216, Vendor_046dProduct_c216Mapper},
+    // logitech cordless rumblepad2
+    {0x046d, 0xc219, Vendor_046dProduct_c219Mapper},
+    {0x1038, 0x1412, Vendor_1038Product_1412Mapper},  // steelseries free
+    // razer onza tournment edition
+    {0x1689, 0xfd00, Vendor_1689Product_fd00Mapper}};
+
+GamepadMapper GetGamepadMapper(uint16_t vendor_id, uint16_t product_id) {
+  for (size_t i = 0; i < arraysize(AvailableMappings); i++) {
+    if (AvailableMappings[i].vendor_id == vendor_id &&
+        AvailableMappings[i].product_id == product_id) {
+      return AvailableMappings[i].mapper;
+    }
+  }
+  return GenericMapper;
+}
+
+}  // namespace ui