| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright 2017 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include <linux/input.h> |
| 6 #include <cstdint> |
| 7 #include <map> |
| 8 |
| 9 #include "base/macros.h" |
| 10 #include "ui/events/ozone/gamepad/gamepad_mapping.h" |
| 11 #include "ui/events/ozone/gamepad/webgamepad_constants.h" |
| 12 |
| 13 namespace ui { |
| 14 |
| 15 // KeyMap maps evdev key code to web gamepad code. |
| 16 struct KeyMapEntry { |
| 17 uint16_t evdev_code; |
| 18 uint16_t mapped_code; |
| 19 }; |
| 20 |
| 21 // AbsMap maps evdev abs code to web gamepad (type, code). |
| 22 struct AbsMapEntry { |
| 23 uint16_t evdev_code; |
| 24 GamepadEventType mapped_type; |
| 25 uint16_t mapped_code; |
| 26 }; |
| 27 |
| 28 using KeyMapType = const KeyMapEntry[]; |
| 29 using AbsMapType = const AbsMapEntry[]; |
| 30 |
| 31 #define TO_BTN(code, mapped_code) \ |
| 32 { code, GamepadEventType::BUTTON, mapped_code } |
| 33 |
| 34 #define TO_ABS(code, mapped_code) \ |
| 35 { code, GamepadEventType::AXIS, mapped_code } |
| 36 |
| 37 #define DO_MAPPING \ |
| 38 DoGamepadMapping(key_mapping, arraysize(key_mapping), abs_mapping, \ |
| 39 arraysize(abs_mapping), type, code, mapped_type, \ |
| 40 mapped_code) |
| 41 |
| 42 bool DoGamepadMapping(const KeyMapEntry* key_mapping, |
| 43 size_t key_map_size, |
| 44 const AbsMapEntry* abs_mapping, |
| 45 size_t abs_map_size, |
| 46 uint16_t type, |
| 47 uint16_t code, |
| 48 GamepadEventType* mapped_type, |
| 49 uint16_t* mapped_code) { |
| 50 if (type == EV_KEY) { |
| 51 const KeyMapEntry* entry = nullptr; |
| 52 for (size_t i = 0; i < key_map_size; i++) { |
| 53 if (key_mapping[i].evdev_code == code) { |
| 54 entry = key_mapping + i; |
| 55 } |
| 56 } |
| 57 if (!entry) { |
| 58 return false; |
| 59 } |
| 60 *mapped_type = GamepadEventType::BUTTON; |
| 61 *mapped_code = entry->mapped_code; |
| 62 return true; |
| 63 } |
| 64 |
| 65 if (type == EV_ABS) { |
| 66 const AbsMapEntry* entry = nullptr; |
| 67 for (size_t i = 0; i < abs_map_size; i++) { |
| 68 if (abs_mapping[i].evdev_code == code) { |
| 69 entry = abs_mapping + i; |
| 70 } |
| 71 } |
| 72 if (!entry) { |
| 73 return false; |
| 74 } |
| 75 *mapped_type = entry->mapped_type; |
| 76 *mapped_code = entry->mapped_code; |
| 77 return true; |
| 78 } |
| 79 return false; |
| 80 } |
| 81 |
| 82 // this mapper mapps gamepads compatible with xbox gamepad. |
| 83 bool XInputStyleMapper(uint16_t type, |
| 84 uint16_t code, |
| 85 GamepadEventType* mapped_type, |
| 86 uint16_t* mapped_code) { |
| 87 static const KeyMapType key_mapping = { |
| 88 {BTN_A, WG_BUTTON_A}, // btn_a = 304 / 0x130 |
| 89 {BTN_B, WG_BUTTON_B}, // btn_b = 305 / 0x131 |
| 90 {BTN_X, WG_BUTTON_X}, // btn_x = 307 / 0x133 |
| 91 {BTN_Y, WG_BUTTON_Y}, // btn_y = 308 / 0x134 |
| 92 {BTN_TL, WG_BUTTON_L1}, // btn_tl = 310 / 0x136 |
| 93 {BTN_TR, WG_BUTTON_R1}, // btn_tr = 311 / 0x137 |
| 94 {BTN_SELECT, WG_BUTTON_SELECT}, // btn_select = 314 / 0x13a |
| 95 {BTN_START, WG_BUTTON_START}, // btn_start = 315 / 0x13b |
| 96 {BTN_THUMBL, WG_BUTTON_THUMBL}, // btn_thumbl = 317 / 0x13d |
| 97 {BTN_THUMBR, WG_BUTTON_THUMBR}, // btn_thumbr = 318 / 0x13e |
| 98 {BTN_MODE, WG_BUTTON_MODE} // btn_mode = 316 / 0x13c |
| 99 }; |
| 100 |
| 101 static const AbsMapType abs_mapping = { |
| 102 TO_ABS(ABS_X, WG_ABS_X), // ABS_X = 0x00 |
| 103 TO_ABS(ABS_Y, WG_ABS_Y), // ABS_Y = 0x01 |
| 104 TO_ABS(ABS_RX, WG_ABS_RX), // ABS_RX = 0x03 |
| 105 TO_ABS(ABS_RY, WG_ABS_RY), // ABS_RZ = 0x04 |
| 106 TO_BTN(ABS_Z, WG_BUTTON_LT), // ABS_Z = 0x02 |
| 107 TO_BTN(ABS_RZ, WG_BUTTON_RT), // ABS_RZ = 0x05 |
| 108 TO_BTN(ABS_HAT0X, kHAT_X), // HAT0X = 0x10 |
| 109 TO_BTN(ABS_HAT0Y, kHAT_Y) // HAT0Y = 0x11 |
| 110 }; |
| 111 return DO_MAPPING; |
| 112 } |
| 113 |
| 114 bool PlaystationSixAxisMapper(uint16_t type, |
| 115 uint16_t code, |
| 116 GamepadEventType* mapped_type, |
| 117 uint16_t* mapped_code) { |
| 118 static const KeyMapType key_mapping = { |
| 119 {0x12e, WG_BUTTON_A}, |
| 120 {0x12d, WG_BUTTON_B}, |
| 121 {BTN_DEAD, WG_BUTTON_X}, |
| 122 {0x12c, WG_BUTTON_Y}, |
| 123 {BTN_BASE5, WG_BUTTON_L1}, |
| 124 {BTN_BASE6, WG_BUTTON_R1}, |
| 125 {BTN_BASE3, WG_BUTTON_LT}, |
| 126 {BTN_BASE4, WG_BUTTON_RT}, |
| 127 {BTN_TRIGGER, WG_BUTTON_SELECT}, |
| 128 {BTN_TOP, WG_BUTTON_START}, |
| 129 {BTN_THUMB, WG_BUTTON_THUMBL}, |
| 130 {BTN_THUMB2, WG_BUTTON_THUMBR}, |
| 131 {BTN_TOP2, WG_BUTTON_DPAD_UP}, |
| 132 {BTN_BASE, WG_BUTTON_DPAD_DOWN}, |
| 133 {BTN_BASE2, WG_BUTTON_DPAD_LEFT}, |
| 134 {BTN_PINKIE, WG_BUTTON_DPAD_RIGHT}, |
| 135 {BTN_TRIGGER_HAPPY17, WG_BUTTON_MODE}, |
| 136 }; |
| 137 |
| 138 static const AbsMapType abs_mapping = { |
| 139 TO_ABS(ABS_X, WG_ABS_X), |
| 140 TO_ABS(ABS_Y, WG_ABS_Y), |
| 141 TO_ABS(ABS_Z, WG_ABS_RX), |
| 142 TO_ABS(ABS_RZ, WG_ABS_RY), |
| 143 TO_BTN(ABS_MT_TOUCH_MAJOR, WG_BUTTON_LT), |
| 144 TO_BTN(ABS_MT_TOUCH_MINOR, WG_BUTTON_RT)}; |
| 145 return DO_MAPPING; |
| 146 } |
| 147 |
| 148 bool IBuffalocClassicMapper(uint16_t type, |
| 149 uint16_t code, |
| 150 GamepadEventType* mapped_type, |
| 151 uint16_t* mapped_code) { |
| 152 static const KeyMapType key_mapping = { |
| 153 {BTN_TRIGGER, WG_BUTTON_A}, {BTN_THUMB, WG_BUTTON_B}, |
| 154 {BTN_THUMB2, WG_BUTTON_X}, {BTN_TOP, WG_BUTTON_Y}, |
| 155 {BTN_BASE, WG_BUTTON_L1}, {BTN_BASE2, WG_BUTTON_R1}, |
| 156 {BTN_TOP2, WG_BUTTON_LT}, {BTN_PINKIE, WG_BUTTON_RT}}; |
| 157 |
| 158 static const AbsMapType abs_mapping = { |
| 159 TO_BTN(ABS_X, kHAT_X), TO_BTN(ABS_Y, kHAT_Y), |
| 160 }; |
| 161 return DO_MAPPING; |
| 162 } |
| 163 |
| 164 bool ClassicNESMapper(uint16_t type, |
| 165 uint16_t code, |
| 166 GamepadEventType* mapped_type, |
| 167 uint16_t* mapped_code) { |
| 168 static const KeyMapType key_mapping = { |
| 169 {BTN_THUMB, WG_BUTTON_A}, {BTN_THUMB2, WG_BUTTON_B}, |
| 170 {BTN_TRIGGER, WG_BUTTON_X}, {BTN_TOP, WG_BUTTON_Y}, |
| 171 {BTN_TOP2, WG_BUTTON_L1}, {BTN_PINKIE, WG_BUTTON_R1}, |
| 172 {BTN_BASE3, WG_BUTTON_SELECT}, {BTN_BASE4, WG_BUTTON_START}}; |
| 173 |
| 174 static const AbsMapType abs_mapping = { |
| 175 TO_BTN(ABS_X, kHAT_X), TO_BTN(ABS_Y, kHAT_Y), |
| 176 }; |
| 177 return DO_MAPPING; |
| 178 } |
| 179 |
| 180 bool SNesRetroMapper(uint16_t type, |
| 181 uint16_t code, |
| 182 GamepadEventType* mapped_type, |
| 183 uint16_t* mapped_code) { |
| 184 static const KeyMapType key_mapping = { |
| 185 {BTN_C, WG_BUTTON_A}, {BTN_B, WG_BUTTON_B}, |
| 186 {BTN_X, WG_BUTTON_X}, {BTN_A, WG_BUTTON_Y}, |
| 187 {BTN_Y, WG_BUTTON_L1}, {BTN_Z, WG_BUTTON_R1}, |
| 188 {BTN_TL2, WG_BUTTON_SELECT}, {BTN_TR2, WG_BUTTON_START}}; |
| 189 |
| 190 static const AbsMapType abs_mapping = { |
| 191 TO_ABS(ABS_X, kHAT_X), TO_ABS(ABS_Y, kHAT_Y), |
| 192 }; |
| 193 return DO_MAPPING; |
| 194 } |
| 195 |
| 196 bool ADT1Mapper(uint16_t type, |
| 197 uint16_t code, |
| 198 GamepadEventType* mapped_type, |
| 199 uint16_t* mapped_code) { |
| 200 static const KeyMapType key_mapping = { |
| 201 {BTN_A, WG_BUTTON_A}, {BTN_B, WG_BUTTON_B}, |
| 202 {BTN_X, WG_BUTTON_X}, {BTN_Y, WG_BUTTON_Y}, |
| 203 {BTN_TL, WG_BUTTON_L1}, {BTN_TR, WG_BUTTON_R1}, |
| 204 {BTN_THUMBL, WG_BUTTON_THUMBL}, {BTN_THUMBR, WG_BUTTON_THUMBR}, |
| 205 {BTN_MODE, WG_BUTTON_START}, {KEY_BACK, WG_BUTTON_SELECT}, |
| 206 {KEY_HOMEPAGE, WG_BUTTON_MODE}}; |
| 207 |
| 208 static const AbsMapType abs_mapping = { |
| 209 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), |
| 210 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), |
| 211 TO_BTN(ABS_BRAKE, WG_BUTTON_LT), TO_BTN(ABS_GAS, WG_BUTTON_RT), |
| 212 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; |
| 213 return DO_MAPPING; |
| 214 } |
| 215 |
| 216 bool Vendor_1d79Product_0009Mapper(uint16_t type, |
| 217 uint16_t code, |
| 218 GamepadEventType* mapped_type, |
| 219 uint16_t* mapped_code) { |
| 220 static const KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A}, |
| 221 {BTN_B, WG_BUTTON_B}, |
| 222 {BTN_X, WG_BUTTON_X}, |
| 223 {BTN_Y, WG_BUTTON_Y}, |
| 224 {BTN_TL, WG_BUTTON_L1}, |
| 225 {BTN_TR, WG_BUTTON_R1}, |
| 226 {BTN_START, WG_BUTTON_START}, |
| 227 {BTN_THUMBL, WG_BUTTON_THUMBL}, |
| 228 {BTN_THUMBR, WG_BUTTON_THUMBR}, |
| 229 {KEY_UP, WG_BUTTON_DPAD_UP}, |
| 230 {KEY_DOWN, WG_BUTTON_DPAD_DOWN}, |
| 231 {KEY_LEFT, WG_BUTTON_DPAD_LEFT}, |
| 232 {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT}, |
| 233 {KEY_BACK, WG_BUTTON_SELECT}, |
| 234 {KEY_HOMEPAGE, WG_BUTTON_MODE}}; |
| 235 |
| 236 static const AbsMapType abs_mapping = { |
| 237 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), |
| 238 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), |
| 239 TO_BTN(ABS_BRAKE, WG_BUTTON_LT), TO_BTN(ABS_GAS, WG_BUTTON_RT), |
| 240 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; |
| 241 return DO_MAPPING; |
| 242 } |
| 243 |
| 244 bool Vendor_046dProduct_b501Mapper(uint16_t type, |
| 245 uint16_t code, |
| 246 GamepadEventType* mapped_type, |
| 247 uint16_t* mapped_code) { |
| 248 static const KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A}, |
| 249 {BTN_B, WG_BUTTON_B}, |
| 250 {BTN_X, WG_BUTTON_X}, |
| 251 {BTN_Y, WG_BUTTON_Y}, |
| 252 {BTN_TL, WG_BUTTON_L1}, |
| 253 {BTN_TR, WG_BUTTON_R1}, |
| 254 {BTN_TL2, WG_BUTTON_LT}, |
| 255 {BTN_TR2, WG_BUTTON_RT}, |
| 256 {BTN_SELECT, WG_BUTTON_SELECT}, |
| 257 {BTN_START, WG_BUTTON_START}, |
| 258 {BTN_THUMBL, WG_BUTTON_THUMBL}, |
| 259 {BTN_THUMBR, WG_BUTTON_THUMBR}, |
| 260 {KEY_UP, WG_BUTTON_DPAD_UP}, |
| 261 {KEY_DOWN, WG_BUTTON_DPAD_DOWN}, |
| 262 {KEY_LEFT, WG_BUTTON_DPAD_LEFT}, |
| 263 {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT}, |
| 264 {BTN_MODE, WG_BUTTON_MODE}}; |
| 265 |
| 266 static const AbsMapType abs_mapping = { |
| 267 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), |
| 268 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), |
| 269 TO_BTN(ABS_BRAKE, WG_BUTTON_LT), TO_BTN(ABS_GAS, WG_BUTTON_RT), |
| 270 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; |
| 271 return DO_MAPPING; |
| 272 } |
| 273 |
| 274 bool Vendor_046dProduct_c216Mapper(uint16_t type, |
| 275 uint16_t code, |
| 276 GamepadEventType* mapped_type, |
| 277 uint16_t* mapped_code) { |
| 278 static const KeyMapType key_mapping = { |
| 279 {BTN_TRIGGER, WG_BUTTON_A}, {BTN_TOP, WG_BUTTON_B}, |
| 280 {BTN_THUMB, WG_BUTTON_X}, {BTN_THUMB2, WG_BUTTON_Y}, |
| 281 {BTN_TOP2, WG_BUTTON_L1}, {BTN_PINKIE, WG_BUTTON_R1}, |
| 282 {BTN_BASE, WG_BUTTON_LT}, {BTN_BASE2, WG_BUTTON_RT}, |
| 283 {BTN_BASE3, WG_BUTTON_SELECT}, {BTN_BASE4, WG_BUTTON_START}, |
| 284 {BTN_BASE5, WG_BUTTON_THUMBL}, {BTN_BASE6, WG_BUTTON_THUMBR}}; |
| 285 |
| 286 static const AbsMapType abs_mapping = { |
| 287 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), |
| 288 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), |
| 289 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; |
| 290 return DO_MAPPING; |
| 291 } |
| 292 |
| 293 bool Vendor_046dProduct_c219Mapper(uint16_t type, |
| 294 uint16_t code, |
| 295 GamepadEventType* mapped_type, |
| 296 uint16_t* mapped_code) { |
| 297 static const KeyMapType key_mapping = { |
| 298 {BTN_B, WG_BUTTON_A}, {BTN_C, WG_BUTTON_B}, |
| 299 {BTN_A, WG_BUTTON_X}, {BTN_X, WG_BUTTON_Y}, |
| 300 {BTN_Y, WG_BUTTON_L1}, {BTN_Z, WG_BUTTON_R1}, |
| 301 {BTN_TL, WG_BUTTON_LT}, {BTN_TR, WG_BUTTON_RT}, |
| 302 {BTN_TR2, WG_BUTTON_START}, {BTN_SELECT, WG_BUTTON_THUMBL}, |
| 303 {BTN_START, WG_BUTTON_THUMBR}, {BTN_TL2, WG_BUTTON_SELECT}}; |
| 304 |
| 305 static const AbsMapType abs_mapping = { |
| 306 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), |
| 307 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), |
| 308 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; |
| 309 return DO_MAPPING; |
| 310 } |
| 311 |
| 312 bool Vendor_1038Product_1412Mapper(uint16_t type, |
| 313 uint16_t code, |
| 314 GamepadEventType* mapped_type, |
| 315 uint16_t* mapped_code) { |
| 316 static const KeyMapType key_mapping = { |
| 317 {BTN_A, WG_BUTTON_A}, {BTN_B, WG_BUTTON_B}, |
| 318 {BTN_X, WG_BUTTON_X}, {BTN_Y, WG_BUTTON_Y}, |
| 319 {BTN_TL, WG_BUTTON_L1}, {BTN_TR, WG_BUTTON_R1}, |
| 320 {BTN_MODE, WG_BUTTON_SELECT}, {BTN_START, WG_BUTTON_START}, |
| 321 }; |
| 322 |
| 323 static const AbsMapType abs_mapping = { |
| 324 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), |
| 325 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), |
| 326 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; |
| 327 return DO_MAPPING; |
| 328 } |
| 329 |
| 330 bool Vendor_1689Product_fd00Mapper(uint16_t type, |
| 331 uint16_t code, |
| 332 GamepadEventType* mapped_type, |
| 333 uint16_t* mapped_code) { |
| 334 static const KeyMapType key_mapping = { |
| 335 {BTN_A, WG_BUTTON_A}, |
| 336 {BTN_B, WG_BUTTON_B}, |
| 337 {BTN_X, WG_BUTTON_X}, |
| 338 {BTN_Y, WG_BUTTON_Y}, |
| 339 {BTN_TL, WG_BUTTON_L1}, |
| 340 {BTN_TR, WG_BUTTON_R1}, |
| 341 {BTN_START, WG_BUTTON_START}, |
| 342 {BTN_THUMBL, WG_BUTTON_THUMBL}, |
| 343 {BTN_THUMBR, WG_BUTTON_THUMBR}, |
| 344 {BTN_TRIGGER_HAPPY3, WG_BUTTON_DPAD_UP}, |
| 345 {BTN_TRIGGER_HAPPY4, WG_BUTTON_DPAD_DOWN}, |
| 346 {BTN_TRIGGER_HAPPY1, WG_BUTTON_DPAD_LEFT}, |
| 347 {BTN_TRIGGER_HAPPY2, WG_BUTTON_DPAD_RIGHT}, |
| 348 {BTN_SELECT, WG_BUTTON_SELECT}, |
| 349 {BTN_MODE, WG_BUTTON_MODE}}; |
| 350 |
| 351 static const AbsMapType abs_mapping = { |
| 352 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), |
| 353 TO_ABS(ABS_RX, WG_ABS_RX), TO_ABS(ABS_RY, WG_ABS_RY), |
| 354 TO_BTN(ABS_Z, WG_BUTTON_LT), TO_BTN(ABS_RZ, WG_BUTTON_RT)}; |
| 355 return DO_MAPPING; |
| 356 } |
| 357 |
| 358 bool GenericMapper(uint16_t type, |
| 359 uint16_t code, |
| 360 GamepadEventType* mapped_type, |
| 361 uint16_t* mapped_code) { |
| 362 static const KeyMapType key_mapping = {{BTN_A, WG_BUTTON_A}, |
| 363 {BTN_B, WG_BUTTON_B}, |
| 364 {BTN_X, WG_BUTTON_X}, |
| 365 {BTN_Y, WG_BUTTON_Y}, |
| 366 {BTN_TL, WG_BUTTON_L1}, |
| 367 {BTN_TR, WG_BUTTON_R1}, |
| 368 {BTN_TL2, WG_BUTTON_LT}, |
| 369 {BTN_TR2, WG_BUTTON_RT}, |
| 370 {BTN_THUMBL, WG_BUTTON_THUMBL}, |
| 371 {BTN_THUMBR, WG_BUTTON_THUMBR}, |
| 372 {KEY_BACK, WG_BUTTON_SELECT}, |
| 373 {KEY_HOMEPAGE, WG_BUTTON_MODE}, |
| 374 {KEY_UP, WG_BUTTON_DPAD_UP}, |
| 375 {KEY_DOWN, WG_BUTTON_DPAD_DOWN}, |
| 376 {KEY_LEFT, WG_BUTTON_DPAD_LEFT}, |
| 377 {KEY_RIGHT, WG_BUTTON_DPAD_RIGHT}, |
| 378 {BTN_SELECT, WG_BUTTON_SELECT}, |
| 379 {BTN_START, WG_BUTTON_START}, |
| 380 {BTN_MODE, WG_BUTTON_MODE}}; |
| 381 |
| 382 static const AbsMapType abs_mapping = { |
| 383 TO_ABS(ABS_X, WG_ABS_X), TO_ABS(ABS_Y, WG_ABS_Y), |
| 384 TO_ABS(ABS_RX, WG_ABS_RX), TO_ABS(ABS_RY, WG_ABS_RY), |
| 385 TO_ABS(ABS_Z, WG_ABS_RX), TO_ABS(ABS_RZ, WG_ABS_RY), |
| 386 TO_BTN(ABS_BRAKE, WG_BUTTON_LT), TO_BTN(ABS_GAS, WG_BUTTON_RT), |
| 387 TO_BTN(ABS_HAT0X, kHAT_X), TO_BTN(ABS_HAT0Y, kHAT_Y)}; |
| 388 return DO_MAPPING; |
| 389 } |
| 390 |
| 391 static const struct MappingData { |
| 392 uint16_t vendor_id; |
| 393 uint16_t product_id; |
| 394 GamepadMapper mapper; |
| 395 } AvailableMappings[] = { |
| 396 // Xbox style gamepad. |
| 397 {0x045e, 0x028e, XInputStyleMapper}, // Xbox 360 wired. |
| 398 {0x045e, 0x028f, XInputStyleMapper}, // Xbox 360 wireless. |
| 399 {0x045e, 0x02a1, XInputStyleMapper}, // Xbox 360 wireless. |
| 400 {0x045e, 0x02d1, XInputStyleMapper}, // Xbox one wired. |
| 401 {0x045e, 0x02dd, XInputStyleMapper}, // Xbox one wired (2015 fw). |
| 402 {0x045e, 0x02e3, XInputStyleMapper}, // Xbox elite wired. |
| 403 {0x045e, 0x02ea, XInputStyleMapper}, // Xbox one s (usb). |
| 404 {0x045e, 0x0719, XInputStyleMapper}, // Xbox 360 wireless. |
| 405 {0x046d, 0xc21d, XInputStyleMapper}, // Logitech f310. |
| 406 {0x046d, 0xc21e, XInputStyleMapper}, // Logitech f510. |
| 407 {0x046d, 0xc21f, XInputStyleMapper}, // Logitech f710. |
| 408 {0x2378, 0x1008, XInputStyleMapper}, // Onlive controller (bluetooth). |
| 409 {0x2378, 0x100a, XInputStyleMapper}, // Onlive controller (wired). |
| 410 {0x1bad, 0xf016, XInputStyleMapper}, // Mad catz gamepad. |
| 411 {0x1bad, 0xf023, XInputStyleMapper}, // Mad catz mlg gamepad for Xbox360. |
| 412 {0x1bad, 0xf027, XInputStyleMapper}, // Mad catz fps pro. |
| 413 {0x1bad, 0xf036, XInputStyleMapper}, // Mad catz generic Xbox controller. |
| 414 {0x1689, 0xfd01, XInputStyleMapper}, // Razer Xbox 360 gamepad. |
| 415 {0x1689, 0xfe00, XInputStyleMapper}, // Razer sabertooth elite. |
| 416 // Sony gamepads. |
| 417 {0x054c, 0x0268, PlaystationSixAxisMapper}, // Playstation 3. |
| 418 // NES style gamepad. |
| 419 {0x0583, 0x2060, IBuffalocClassicMapper}, // iBuffalo Classic. |
| 420 {0x0079, 0x0011, ClassicNESMapper}, // Classic NES controller. |
| 421 {0x12bd, 0xd015, SNesRetroMapper}, // Hitgaming SNES retro. |
| 422 // Android gamepad. |
| 423 {0x0b05, 0x4500, ADT1Mapper}, // Nexus player controller (asus gamepad). |
| 424 {0x1532, 0x0900, ADT1Mapper}, // Razer serval. |
| 425 {0x18d1, 0x2c40, ADT1Mapper}, // ADT-1 controller (odie). |
| 426 // Other gamepads. |
| 427 {0x1d79, 0x0009, |
| 428 Vendor_1d79Product_0009Mapper}, // Nyko playpad / Playpad pro. |
| 429 {0x046d, 0xb501, Vendor_046dProduct_b501Mapper}, // Logitech redhawk. |
| 430 // Logitech dual action controller. |
| 431 {0x046d, 0xc216, Vendor_046dProduct_c216Mapper}, |
| 432 // Logitech cordless rumblepad2. |
| 433 {0x046d, 0xc219, Vendor_046dProduct_c219Mapper}, |
| 434 {0x1038, 0x1412, Vendor_1038Product_1412Mapper}, // Steelseries free. |
| 435 // Razer onza tournment edition. |
| 436 {0x1689, 0xfd00, Vendor_1689Product_fd00Mapper}}; |
| 437 |
| 438 GamepadMapper GetGamepadMapper(uint16_t vendor_id, uint16_t product_id) { |
| 439 for (size_t i = 0; i < arraysize(AvailableMappings); i++) { |
| 440 if (AvailableMappings[i].vendor_id == vendor_id && |
| 441 AvailableMappings[i].product_id == product_id) { |
| 442 return AvailableMappings[i].mapper; |
| 443 } |
| 444 } |
| 445 return GenericMapper; |
| 446 } |
| 447 |
| 448 } // namespace ui |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2805793002:
ozone: evdev: Add gamepad support (Closed)
