| // Copyright 2020 The ChromiumOS Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "sommelier.h" // NOLINT(build/include_directory) |
| #include "sommelier-logging.h" // NOLINT(build/include_directory) |
| #include "sommelier-tracing.h" // NOLINT(build/include_directory) |
| |
| #include <assert.h> |
| #include <errno.h> |
| #include <libevdev/libevdev.h> |
| #include <libevdev/libevdev-uinput.h> |
| #include "libevdev/libevdev-shim.h" |
| #include <stdarg.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <unordered_map> |
| |
| #include "gaming-input-unstable-v2-client-protocol.h" // NOLINT(build/include_directory) |
| |
| // Overview of state management via gaming events, in order: |
| // 1) Acquire gaming seats (in sommelier.cc) |
| // 2) Add listeners to gaming seats |
| // 3) Listen for zcr_gaming_seat_v2.gamepad_added to construct a 'default' |
| // game controller (not currently implemented) |
| // Calls libevdev_new, libevdev_enable_event_type, |
| // libevdev_uinput_create_from_device |
| // 4) Listen for zcr_gaming_seat_v2.gamepad_added_with_device_info to construct |
| // a custom game controller |
| // Calls libevdev_new |
| // 5) Listen for zcr_gamepad_v2.axis_added to fill in a custom game controller |
| // Calls libevdev_enable_event_type |
| // 6) Listen for zcr_gamepad_v2.activated to finalize a custom game controller |
| // Calls libevdev_uinput_create_from_device |
| // 7) Listen for zcr_gamepad_v2.axis to set frame state for game controller |
| // Calls libevdev_uinput_write_event |
| // 8) Listen for zcr_gamepad_v2.button to set frame state for game controller |
| // Calls libevdev_uinput_write_event |
| // 9) Listen for zcr_gamepad_v2.frame to emit collected frame |
| // Calls libevdev_uinput_write_event(EV_SYN) |
| // 10) Listen for zcr_gamepad_v2.removed to destroy gamepad |
| // Must handle gamepads in all states of construction or error |
| |
| enum GamepadActivationState { |
| kStateUnknown = 0, // Should not happen |
| kStatePending = 1, // Constructed, pending axis definition |
| kStateActivated = 2, // Fully activated |
| kStateError = 3 // Error occurred during construction; ignore gracefully |
| }; |
| |
| struct DeviceID { |
| const uint32_t vendor; |
| const uint32_t product; |
| const uint32_t version; |
| |
| bool operator==(const DeviceID& other) const { |
| return vendor == other.vendor && product == other.product && |
| version == other.version; |
| } |
| }; |
| |
| // Simple Hash/equal operators for DeviceID struct. Doesn't need to be efficient |
| // as the size of our map will be small. |
| template <> |
| struct std::hash<DeviceID> { |
| std::size_t operator()(const DeviceID& device) const { |
| return device.vendor ^ device.product ^ device.version; |
| } |
| }; |
| |
| // Buttons being emulated by libevdev uinput. |
| // Note: Do not enable BTN_TL2 or BTN_TR2, as they will significantly |
| // change the Linux joydev interpretation of the triggers on ABS_Z/ABS_RZ. |
| const int kButtons[] = {BTN_SOUTH, BTN_EAST, BTN_NORTH, BTN_WEST, |
| BTN_TL, BTN_TR, BTN_THUMBL, BTN_THUMBR, |
| BTN_SELECT, BTN_START, BTN_MODE}; |
| |
| // ID constants for identifying gamepads. Note that some gamepads |
| // may share the same vendor if they're from the same brand. Bluetooth (BT) |
| // and USB variants may also share the same product id - though this is |
| // not guaranteed. |
| |
| // IDs for emulated controllers. |
| const char kXboxName[] = "Microsoft X-Box One S pad"; |
| const uint32_t kUsbBus = 0x03; |
| const uint32_t kXboxVendor = 0x45e; |
| const uint32_t kXboxProduct = 0x2ea; |
| const uint32_t kXboxVersion = 0x301; |
| |
| // Note: the Bluetooth (BT) vendor ID for SteelSeries is due to a chipset bug |
| // and is not an actual claimed Vendor ID. |
| const uint32_t kSteelSeriesBTVendor = 0x111; |
| |
| const uint32_t kStadiaVendor = 0x18d1; |
| const uint32_t kStadiaProduct = 0x9400; |
| |
| const uint32_t kSonyVendor = 0x54C; |
| const uint32_t kDualSenseProduct = 0xCE6; |
| const uint32_t kDualSenseEdgeProduct = 0xDF2; |
| const uint32_t kDualShock4v1Product = 0x5C4; |
| const uint32_t kDualShock4v2Product = 0x9CC; |
| |
| const DeviceID kStadiaUSB = { |
| .vendor = kStadiaVendor, .product = kStadiaProduct, .version = 0x111}; |
| |
| const DeviceID kStadiaBT = { |
| .vendor = kStadiaVendor, .product = kStadiaProduct, .version = 0x100}; |
| |
| const DeviceID kStratusDuoBT = { |
| .vendor = kSteelSeriesBTVendor, .product = 0x1431, .version = 0x11B}; |
| |
| const DeviceID kStratusPlusBT = { |
| .vendor = kSteelSeriesBTVendor, .product = 0x1434, .version = 0x216}; |
| |
| // DualSense versions are the HID specification versions (bcdHID). We care about |
| // these versions as hid-playstation and hid-sony use bcdHID to signal that the |
| // broken hid-generic mapping is not used. |
| const DeviceID kDualSenseUSB = { |
| .vendor = kSonyVendor, .product = kDualSenseProduct, .version = 0x111}; |
| |
| const DeviceID kDualSenseBT = { |
| .vendor = kSonyVendor, .product = kDualSenseProduct, .version = 0x100}; |
| |
| // There's currently a quirk that causes Dualsense gamepads to have 0x000 as |
| // their version when connected over BT after a ChromeOS reboot. |
| const DeviceID kDualSenseBuggedBT = { |
| .vendor = kSonyVendor, .product = kDualSenseProduct, .version = 0x000}; |
| |
| const DeviceID kDualSenseEdgeUSB = { |
| .vendor = kSonyVendor, .product = kDualSenseEdgeProduct, .version = 0x111}; |
| |
| const DeviceID kDualSenseEdgeBT = { |
| .vendor = kSonyVendor, .product = kDualSenseEdgeProduct, .version = 0x100}; |
| |
| const DeviceID kDualShock4v1USB = { |
| .vendor = kSonyVendor, .product = kDualShock4v1Product, .version = 0x8111}; |
| |
| const DeviceID kDualShock4v1BT = { |
| .vendor = kSonyVendor, .product = kDualShock4v1Product, .version = 0x8100}; |
| |
| const DeviceID kDualShock4v2USB = { |
| .vendor = kSonyVendor, .product = kDualShock4v2Product, .version = 0x8111}; |
| |
| const DeviceID kDualShock4v2BT = { |
| .vendor = kSonyVendor, .product = kDualShock4v2Product, .version = 0x8100}; |
| |
| const DeviceID kDualShock3USB = { |
| .vendor = kSonyVendor, .product = 0x268, .version = 0x8111}; |
| |
| const DeviceID kXboxSeriesXBT = { |
| .vendor = kXboxVendor, .product = 0xB13, .version = 0x513}; |
| |
| const DeviceID kXboxOneSOldBT = { |
| .vendor = kXboxVendor, .product = 0x2E0, .version = 0x903}; |
| |
| const DeviceID kXboxOneS2016BT = { |
| .vendor = kXboxVendor, .product = 0x2FD, .version = 0x903}; |
| |
| const DeviceID kXboxOneSUpdatedBT = { |
| .vendor = kXboxVendor, .product = 0xB20, .version = 0x517}; |
| |
| const DeviceID kXboxAdaptiveBT = { |
| .vendor = kXboxVendor, .product = 0xB21, .version = 0x511}; |
| |
| const DeviceID kXboxElite2BT = { |
| .vendor = kXboxVendor, .product = 0xB22, .version = 0x511}; |
| |
| // Mappings from the input event of a given gamepad (key) to the |
| // appropriate output event (value). These mappings are intended to maintain |
| // the locality of a gamepad; i.e the left face button should map to a |
| // left face button event. Input events not represented in a map will be |
| // discarded. |
| |
| // DualSense (PS5). |
| const InputMapping kDualSenseMapping = { |
| .id = "DualSenseMappingV1", |
| .mapping = { |
| // Left Joystick |
| {ABS_X, ABS_X}, |
| {ABS_Y, ABS_Y}, |
| // Right Joystick |
| {ABS_Z, ABS_RX}, |
| {ABS_RZ, ABS_RY}, |
| // Joystick press |
| {BTN_SELECT, BTN_THUMBL}, |
| {BTN_START, BTN_THUMBR}, |
| // DPad |
| {ABS_HAT0X, ABS_HAT0X}, |
| {ABS_HAT0Y, ABS_HAT0Y}, |
| // Face Buttons |
| {BTN_B, BTN_A}, |
| {BTN_C, BTN_B}, |
| {BTN_A, BTN_X}, |
| {BTN_X, BTN_Y}, |
| // Left bumper and trigger |
| {BTN_Y, BTN_TL}, |
| {ABS_RX, ABS_Z}, |
| // Right bumper and trigger |
| {BTN_Z, BTN_TR}, |
| {ABS_RY, ABS_RZ}, |
| // Menu buttons |
| {BTN_TL2, BTN_SELECT}, |
| {BTN_TR2, BTN_START}, |
| {BTN_MODE, BTN_MODE}, |
| // Unused buttons: Touchpad_click: BTN_THUMBL, Microphone_button: |
| // BTN_THUMBR |
| }}; |
| |
| // DualShock4 (PS4). |
| const InputMapping kDualShock4Mapping = {.id = "DualShock4MappingV1", |
| .mapping = { |
| // Left Joystick |
| {ABS_X, ABS_X}, |
| {ABS_Y, ABS_Y}, |
| // Right Joystick |
| {ABS_RX, ABS_RX}, |
| {ABS_RY, ABS_RY}, |
| // Joystick press |
| {BTN_THUMBL, BTN_THUMBL}, |
| {BTN_THUMBR, BTN_THUMBR}, |
| // DPad |
| {ABS_HAT0X, ABS_HAT0X}, |
| {ABS_HAT0Y, ABS_HAT0Y}, |
| // Right-hand Buttons |
| {BTN_A, BTN_A}, |
| {BTN_B, BTN_B}, |
| {BTN_X, BTN_Y}, |
| {BTN_Y, BTN_X}, |
| // Left bumper and trigger |
| {BTN_TL, BTN_TL}, |
| {ABS_Z, ABS_Z}, |
| // Right bumper and trigger |
| {BTN_TR, BTN_TR}, |
| {ABS_RZ, ABS_RZ}, |
| // Menu buttons |
| {BTN_SELECT, BTN_SELECT}, |
| {BTN_START, BTN_START}, |
| {BTN_MODE, BTN_MODE}, |
| }}; |
| |
| // DualShock3 (PS3). |
| const InputMapping kDualShock3Mapping = {.id = "DualShock3MappingV1", |
| .mapping = { |
| // Left Joystick |
| {ABS_X, ABS_X}, |
| {ABS_Y, ABS_Y}, |
| // Right Joystick |
| {ABS_RX, ABS_RX}, |
| {ABS_RY, ABS_RY}, |
| // Joystick press |
| {BTN_THUMBL, BTN_THUMBL}, |
| {BTN_THUMBR, BTN_THUMBR}, |
| // DPad |
| {BTN_DPAD_LEFT, ABS_HAT0X}, |
| {BTN_DPAD_RIGHT, ABS_HAT0X}, |
| {BTN_DPAD_UP, ABS_HAT0Y}, |
| {BTN_DPAD_DOWN, ABS_HAT0Y}, |
| // Face Buttons |
| {BTN_A, BTN_A}, |
| {BTN_B, BTN_B}, |
| {BTN_Y, BTN_X}, |
| {BTN_X, BTN_Y}, |
| // Left bumper and trigger |
| {BTN_TL, BTN_TL}, |
| {ABS_Z, ABS_Z}, |
| // Right bumper and trigger |
| {BTN_TR, BTN_TR}, |
| {ABS_RZ, ABS_RZ}, |
| // Menu buttons |
| {BTN_SELECT, BTN_SELECT}, |
| {BTN_START, BTN_START}, |
| {BTN_MODE, BTN_MODE}, |
| }}; |
| |
| // Represents how the input events of a certain controllers (key) should be |
| // interpreted (value). So far this pattern has been observed in: |
| // - Stadia |
| // - Stratus Duo (BT) |
| // - Stratus + (BT) |
| // - Xbox Series X (BT) |
| // - Xbox One S (updated firmware) (BT) |
| // - Xbox Adaptive (BT) |
| // - Xbox Elite 2 (BT) |
| const InputMapping kAxisQuirkMapping = {.id = "AxisQuirkMappingV1", |
| .mapping = { |
| // Left Joystick |
| {ABS_X, ABS_X}, |
| {ABS_Y, ABS_Y}, |
| // Right Joystick |
| {ABS_Z, ABS_RX}, |
| {ABS_RZ, ABS_RY}, |
| // Joystick press |
| {BTN_THUMBL, BTN_THUMBL}, |
| {BTN_THUMBR, BTN_THUMBR}, |
| // DPad |
| {ABS_HAT0X, ABS_HAT0X}, |
| {ABS_HAT0Y, ABS_HAT0Y}, |
| // Face Buttons |
| {BTN_A, BTN_A}, |
| {BTN_B, BTN_B}, |
| {BTN_X, BTN_X}, |
| {BTN_Y, BTN_Y}, |
| // Left bumper and trigger |
| {BTN_TL, BTN_TL}, |
| {ABS_BRAKE, ABS_Z}, |
| // Right bumper and trigger |
| {BTN_TR, BTN_TR}, |
| {ABS_GAS, ABS_RZ}, |
| // Menu buttons |
| {BTN_SELECT, BTN_SELECT}, |
| {BTN_START, BTN_START}, |
| {BTN_MODE, BTN_MODE}, |
| }}; |
| |
| // Xbox One S (BT) - Old firmware. |
| // Note: this mapping is based off of a mapping from another feature |
| // and has not been explicitly tested. See b/277829347. |
| const InputMapping kXboxOneSOldMapping = {.id = "XboxOneSOldMappingV1", |
| .mapping = { |
| // Left Joystick |
| {ABS_X, ABS_X}, |
| {ABS_Y, ABS_Y}, |
| // Right Joystick |
| {ABS_RX, ABS_RX}, |
| {ABS_RY, ABS_RY}, |
| // Joystick press |
| {BTN_TL2, BTN_THUMBL}, |
| {BTN_TR2, BTN_THUMBR}, |
| // DPad |
| {ABS_HAT0X, ABS_HAT0X}, |
| {ABS_HAT0Y, ABS_HAT0Y}, |
| // Face Buttons |
| {BTN_A, BTN_A}, |
| {BTN_B, BTN_B}, |
| {BTN_C, BTN_X}, |
| {BTN_X, BTN_Y}, |
| // Left bumper and trigger |
| {BTN_Y, BTN_TL}, |
| {ABS_Z, ABS_Z}, |
| // Right bumper and trigger |
| {BTN_Z, BTN_TR}, |
| {ABS_RZ, ABS_RZ}, |
| // Menu buttons |
| {BTN_TL, BTN_SELECT}, |
| {BTN_TR, BTN_START}, |
| {0x8b, BTN_MODE}, |
| }}; |
| |
| // Xbox One S (BT) - 2016 firmware. |
| const InputMapping kXboxOneS2016Mapping = {.id = "XboxOneS2016MappingV1", |
| .mapping = { |
| // Left Joystick |
| {ABS_X, ABS_X}, |
| {ABS_Y, ABS_Y}, |
| // Right Joystick |
| {ABS_Z, ABS_RX}, |
| {ABS_RZ, ABS_RY}, |
| // Joystick press |
| {BTN_THUMBL, BTN_THUMBL}, |
| {BTN_THUMBR, BTN_THUMBR}, |
| // DPad |
| {ABS_HAT0X, ABS_HAT0X}, |
| {ABS_HAT0Y, ABS_HAT0Y}, |
| // Face Buttons |
| {BTN_A, BTN_A}, |
| {BTN_B, BTN_B}, |
| {BTN_X, BTN_X}, |
| {BTN_Y, BTN_Y}, |
| // Left bumper and trigger |
| {BTN_TL, BTN_TL}, |
| {ABS_BRAKE, ABS_Z}, |
| // Right bumper and trigger |
| {BTN_TR, BTN_TR}, |
| {ABS_GAS, ABS_RZ}, |
| // Menu buttons |
| {KEY_BACK, BTN_SELECT}, |
| {BTN_START, BTN_START}, |
| {KEY_HOMEPAGE, BTN_MODE}, |
| }}; |
| |
| // Map of devices to their respctive input remappings. |
| const std::unordered_map<DeviceID, const InputMapping*> kDeviceMappings = { |
| {kStadiaUSB, &kAxisQuirkMapping}, |
| {kStadiaBT, &kAxisQuirkMapping}, |
| // Note that the BTN_MODE is not mapped correctly for the |
| // Stratus Duo, due to it being interpreted on the host |
| // as a key event causing a browser HOME action. |
| {kStratusDuoBT, &kAxisQuirkMapping}, |
| {kStratusPlusBT, &kAxisQuirkMapping}, |
| {kDualSenseUSB, &kDualSenseMapping}, |
| {kDualSenseBT, &kDualSenseMapping}, |
| {kDualSenseBuggedBT, &kDualSenseMapping}, |
| {kDualShock4v2USB, &kDualShock4Mapping}, |
| {kDualShock4v2BT, &kDualShock4Mapping}, |
| {kDualShock3USB, &kDualShock3Mapping}, |
| {kXboxSeriesXBT, &kAxisQuirkMapping}, |
| {kXboxOneSOldBT, &kXboxOneSOldMapping}, |
| {kXboxOneS2016BT, &kXboxOneS2016Mapping}, |
| {kXboxOneSUpdatedBT, &kAxisQuirkMapping}, |
| // These mappings are inferred to be the same based on the gamepad api |
| // mappings. |
| // See: |
| // https://source.chromium.org/chromium/chromium/src/+/refs/heads/main:device/gamepad/gamepad_standard_mappings_linux.cc;l=968 |
| {kXboxAdaptiveBT, &kAxisQuirkMapping}, |
| {kXboxElite2BT, &kAxisQuirkMapping}, |
| {kDualShock4v1USB, &kDualShock4Mapping}, |
| {kDualShock4v1BT, &kDualShock4Mapping}, |
| {kDualSenseEdgeUSB, &kDualSenseMapping}, |
| {kDualSenseEdgeBT, &kDualSenseMapping}, |
| }; |
| |
| // Note: the majority of protocol errors are treated as non-fatal, and |
| // are intended to be handled gracefully, as is removal at any |
| // state of construction or operation. We should expect that |
| // 'sudden removal' can happen at any time, due to hotplugging |
| // or unexpected state changes from the wayland server. |
| |
| static void sl_internal_gamepad_removed(void* data, |
| struct zcr_gamepad_v2* gamepad) { |
| TRACE_EVENT("gaming", "sl_internal_gamepad_removed"); |
| struct sl_host_gamepad* host_gamepad = (struct sl_host_gamepad*)data; |
| |
| assert(host_gamepad->state == kStatePending || |
| host_gamepad->state == kStateActivated || |
| host_gamepad->state == kStateError); |
| |
| if (host_gamepad->uinput_dev != nullptr) { |
| Libevdev::Get()->uinput_destroy(host_gamepad->uinput_dev); |
| } |
| if (host_gamepad->ev_dev != nullptr) { |
| Libevdev::Get()->free(host_gamepad->ev_dev); |
| } |
| |
| zcr_gamepad_v2_destroy(gamepad); |
| |
| wl_list_remove(&host_gamepad->link); |
| LOG(INFO) << "Gamepad removed: " << host_gamepad; |
| delete host_gamepad; |
| } |
| |
| // Helper function to remap the input events from a host_gamepad into the |
| // correct output event to be emulated by the generated uinput device. |
| static bool remap_input(struct sl_host_gamepad* host_gamepad, uint32_t& input) { |
| if (host_gamepad->input_mapping == nullptr) { |
| return true; |
| } |
| auto it = host_gamepad->input_mapping->mapping.find(input); |
| if (it != host_gamepad->input_mapping->mapping.end()) { |
| input = it->second; |
| return true; |
| } |
| // If an input_mapping exists, and we get an input we don't expect |
| // or don't handle, we shouldn't emulate it. An example of this |
| // is that the DualSense controller's triggers activate an axis |
| // and a button at the same time, which would result in unexpected |
| // behaviour if we forwarded both inputs. |
| return false; |
| } |
| |
| static void sl_internal_gamepad_axis(void* data, |
| struct zcr_gamepad_v2* gamepad, |
| uint32_t time, |
| uint32_t axis, |
| wl_fixed_t value) { |
| TRACE_EVENT("gaming", "sl_internal_gamepad_axis"); |
| struct sl_host_gamepad* host_gamepad = (struct sl_host_gamepad*)data; |
| |
| if (host_gamepad->state != kStateActivated) { |
| return; |
| } |
| |
| if (!remap_input(host_gamepad, axis)) { |
| return; |
| } |
| |
| // Note: incoming time is ignored, it will be regenerated from current time. |
| Libevdev::Get()->uinput_write_event(host_gamepad->uinput_dev, EV_ABS, axis, |
| wl_fixed_to_double(value)); |
| } |
| |
| static void sl_internal_gamepad_button(void* data, |
| struct zcr_gamepad_v2* gamepad, |
| uint32_t time, |
| uint32_t button, |
| uint32_t state, |
| wl_fixed_t analog) { |
| TRACE_EVENT("gaming", "sl_internal_gamepad_button"); |
| struct sl_host_gamepad* host_gamepad = (struct sl_host_gamepad*)data; |
| |
| if (host_gamepad->state != kStateActivated) { |
| return; |
| } |
| |
| uint32_t original_button = button; |
| if (!remap_input(host_gamepad, button)) { |
| return; |
| } |
| |
| // Note: Exo wayland server always sends analog==0, only pay attention |
| // to state. |
| int value = (state == ZCR_GAMEPAD_V2_BUTTON_STATE_PRESSED) ? 1 : 0; |
| |
| if (host_gamepad->input_mapping == &kDualShock3Mapping) { |
| // Convert button to axis if necessary. |
| if (original_button != button && |
| (original_button == BTN_DPAD_UP || original_button == BTN_DPAD_LEFT || |
| original_button == BTN_DPAD_DOWN || |
| original_button == BTN_DPAD_RIGHT)) { |
| // BTN_DPAD_UP and BTN_DPAD_LEFT are the equivalent of negative DPAD axis |
| // events and we need to correct their pressed (1) values. |
| if (value == 1 && (original_button == BTN_DPAD_UP || |
| original_button == BTN_DPAD_LEFT)) { |
| value = -1; |
| } |
| Libevdev::Get()->uinput_write_event(host_gamepad->uinput_dev, EV_ABS, |
| button, value); |
| return; |
| } |
| } |
| |
| // Note: incoming time is ignored, it will be regenerated from current time. |
| Libevdev::Get()->uinput_write_event(host_gamepad->uinput_dev, EV_KEY, button, |
| value); |
| } |
| |
| static void sl_internal_gamepad_frame(void* data, |
| struct zcr_gamepad_v2* gamepad, |
| uint32_t time) { |
| TRACE_EVENT("gaming", "sl_internal_gamepad_frame"); |
| struct sl_host_gamepad* host_gamepad = (struct sl_host_gamepad*)data; |
| |
| if (host_gamepad->state != kStateActivated) { |
| return; |
| } |
| |
| // Note: incoming time is ignored, it will be regenerated from current time. |
| Libevdev::Get()->uinput_write_event(host_gamepad->uinput_dev, EV_SYN, |
| SYN_REPORT, 0); |
| } |
| |
| static void sl_internal_gamepad_axis_added(void* data, |
| struct zcr_gamepad_v2* gamepad, |
| uint32_t index, |
| int32_t min_value, |
| int32_t max_value, |
| int32_t flat, |
| int32_t fuzz, |
| int32_t resolution) { |
| TRACE_EVENT("gaming", "sl_internal_gamepad_axis_added"); |
| struct sl_host_gamepad* host_gamepad = (struct sl_host_gamepad*)data; |
| struct input_absinfo info = {.value = 0, // Does this matter? |
| .minimum = min_value, |
| .maximum = max_value, |
| .fuzz = fuzz, |
| .flat = flat, |
| .resolution = resolution}; |
| if (host_gamepad->state != kStatePending) { |
| LOG(ERROR) << "invoked in unexpected state " << host_gamepad->state; |
| host_gamepad->state = kStateError; |
| return; |
| } |
| |
| if (!remap_input(host_gamepad, index)) { |
| return; |
| } |
| |
| Libevdev::Get()->enable_event_code(host_gamepad->ev_dev, EV_ABS, index, |
| &info); |
| } |
| |
| static void sl_internal_gamepad_activated(void* data, |
| struct zcr_gamepad_v2* gamepad) { |
| TRACE_EVENT("gaming", "sl_internal_gamepad_activated"); |
| struct sl_host_gamepad* host_gamepad = (struct sl_host_gamepad*)data; |
| |
| if (host_gamepad->state != kStatePending) { |
| LOG(ERROR) << "invoked in unexpected state " << host_gamepad->state; |
| host_gamepad->state = kStateError; |
| return; |
| } |
| |
| int err = Libevdev::Get()->uinput_create_from_device( |
| host_gamepad->ev_dev, LIBEVDEV_UINPUT_OPEN_MANAGED, |
| &host_gamepad->uinput_dev); |
| if (err == 0) { |
| // TODO(kenalba): can we destroy and clean up the ev_dev now? |
| host_gamepad->state = kStateActivated; |
| } else { |
| LOG(ERROR) << "libevdev_uinput_create_from_device failed with error " |
| << err; |
| host_gamepad->state = kStateError; |
| } |
| } |
| |
| static void sl_internal_gamepad_vibrator_added( |
| void* data, |
| struct zcr_gamepad_v2* gamepad, |
| struct zcr_gamepad_vibrator_v2* vibrator) { |
| TRACE_EVENT("gaming", "sl_internal_gamepad_vibrator_added"); |
| // TODO(kenalba): add vibration logic |
| } |
| |
| static const struct zcr_gamepad_v2_listener sl_internal_gamepad_listener = { |
| sl_internal_gamepad_removed, sl_internal_gamepad_axis, |
| sl_internal_gamepad_button, sl_internal_gamepad_frame, |
| sl_internal_gamepad_axis_added, sl_internal_gamepad_activated, |
| sl_internal_gamepad_vibrator_added}; |
| |
| static void sl_internal_gaming_seat_gamepad_added_with_device_info( |
| void* data, |
| struct zcr_gaming_seat_v2* gaming_seat, |
| struct zcr_gamepad_v2* gamepad, |
| const char* name, |
| uint32_t bus, |
| uint32_t vendor_id, |
| uint32_t product_id, |
| uint32_t version) { |
| TRACE_EVENT("gaming", |
| "sl_internal_gaming_seat_gamepad_added_with_device_info"); |
| struct sl_context* ctx = (struct sl_context*)data; |
| struct sl_host_gamepad* host_gamepad = new sl_host_gamepad(); |
| wl_list_insert(&ctx->gamepads, &host_gamepad->link); |
| zcr_gamepad_v2_add_listener(gamepad, &sl_internal_gamepad_listener, |
| host_gamepad); |
| |
| host_gamepad->ctx = ctx; |
| host_gamepad->state = kStatePending; |
| host_gamepad->ev_dev = Libevdev::Get()->new_evdev(); |
| host_gamepad->uinput_dev = nullptr; |
| host_gamepad->name = name; |
| host_gamepad->bus = bus; |
| host_gamepad->vendor_id = vendor_id; |
| host_gamepad->product_id = product_id; |
| host_gamepad->version = version; |
| host_gamepad->input_mapping = nullptr; |
| |
| if (host_gamepad->ev_dev == nullptr) { |
| LOG(ERROR) << "libevdev_new failed"; |
| host_gamepad->state = kStateError; |
| return; |
| } |
| |
| // We provide limited remapping at this time. Only moderately XBox360 |
| // HID compatible controllers are likely to work well. |
| auto it = kDeviceMappings.find(DeviceID{host_gamepad->vendor_id, |
| host_gamepad->product_id, |
| host_gamepad->version}); |
| if (it != kDeviceMappings.end()) { |
| host_gamepad->input_mapping = it->second; |
| if (it->first == kDualShock3USB) { |
| // The DualShock3 gamepad doesn't have any axes for its DPAD, we need to |
| // add them manually. |
| sl_internal_gamepad_axis_added( |
| host_gamepad, gamepad, BTN_DPAD_DOWN, /*min_value=*/-1, |
| /*max_value=*/1, /*flat=*/0, /*fuzz=*/0, /*resolution=*/0); |
| sl_internal_gamepad_axis_added( |
| host_gamepad, gamepad, BTN_DPAD_LEFT, /*min_value=*/-1, |
| /*max_value=*/1, /*flat=*/0, /*fuzz=*/0, /*resolution=*/0); |
| } |
| } |
| |
| // Describe a common controller |
| Libevdev::Get()->set_name(host_gamepad->ev_dev, kXboxName); |
| Libevdev::Get()->set_id_bustype(host_gamepad->ev_dev, kUsbBus); |
| Libevdev::Get()->set_id_vendor(host_gamepad->ev_dev, kXboxVendor); |
| Libevdev::Get()->set_id_product(host_gamepad->ev_dev, kXboxProduct); |
| Libevdev::Get()->set_id_version(host_gamepad->ev_dev, kXboxVersion); |
| |
| // Enable common set of buttons |
| for (unsigned int i = 0; i < ARRAY_SIZE(kButtons); i++) { |
| Libevdev::Get()->enable_event_code(host_gamepad->ev_dev, EV_KEY, |
| kButtons[i], nullptr); |
| } |
| LOG(INFO) << "Gamepad added: " << host_gamepad; |
| } |
| |
| // Note: not currently implemented by Exo. |
| static void sl_internal_gaming_seat_gamepad_added( |
| void* data, |
| struct zcr_gaming_seat_v2* gaming_seat, |
| struct zcr_gamepad_v2* gamepad) { |
| TRACE_EVENT("gaming", "sl_internal_gaming_seat_gamepad_added"); |
| LOG(ERROR) << "sl_internal_gaming_seat_gamepad_added unimplemented"; |
| } |
| |
| static const struct zcr_gaming_seat_v2_listener |
| sl_internal_gaming_seat_listener = { |
| sl_internal_gaming_seat_gamepad_added, |
| sl_internal_gaming_seat_gamepad_added_with_device_info}; |
| |
| void sl_gaming_seat_add_listener(struct sl_context* ctx) { |
| if (ctx->gaming_input_manager && ctx->gaming_input_manager->internal) { |
| TRACE_EVENT("gaming", "sl_gaming_seat_add_listener"); |
| ctx->gaming_seat = zcr_gaming_input_v2_get_gaming_seat( |
| ctx->gaming_input_manager->internal, ctx->default_seat->proxy); |
| zcr_gaming_seat_v2_add_listener(ctx->gaming_seat, |
| &sl_internal_gaming_seat_listener, ctx); |
| } |
| } |
