// SPDX-License-Identifier: GPL-2.0-or-later /* * HID driver for OneXPlayer gamepad configuration devices. * * Copyright (c) 2026 Valve Corporation */ #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "hid-ids.h" #define OXP_PACKET_SIZE 64 #define GEN1_MESSAGE_ID 0xff #define GEN2_MESSAGE_ID 0x3f #define GEN1_USAGE_PAGE 0xff01 #define GEN2_USAGE_PAGE 0xff00 enum oxp_function_index { OXP_FID_GEN1_RGB_SET = 0x07, OXP_FID_GEN1_RGB_REPLY = 0x0f, OXP_FID_GEN2_TOGGLE_MODE = 0xb2, OXP_FID_GEN2_RUMBLE_SET = 0xb3, OXP_FID_GEN2_KEY_STATE = 0xb4, OXP_FID_GEN2_STATUS_EVENT = 0xb8, }; #define OXP_MAPPING_GAMEPAD 0x01 #define OXP_MAPPING_KEYBOARD 0x02 struct oxp_button_data { u8 mode; u8 index; u8 key_id; u8 padding[2]; } __packed; struct oxp_button_entry { struct oxp_button_data data; const char *name; }; static const struct oxp_button_entry oxp_button_table[] = { /* Gamepad Buttons */ { { OXP_MAPPING_GAMEPAD, 0x01 }, "BTN_A" }, { { OXP_MAPPING_GAMEPAD, 0x02 }, "BTN_B" }, { { OXP_MAPPING_GAMEPAD, 0x03 }, "BTN_X" }, { { OXP_MAPPING_GAMEPAD, 0x04 }, "BTN_Y" }, { { OXP_MAPPING_GAMEPAD, 0x05 }, "BTN_LB" }, { { OXP_MAPPING_GAMEPAD, 0x06 }, "BTN_RB" }, { { OXP_MAPPING_GAMEPAD, 0x07 }, "BTN_LT" }, { { OXP_MAPPING_GAMEPAD, 0x08 }, "BTN_RT" }, { { OXP_MAPPING_GAMEPAD, 0x09 }, "BTN_START" }, { { OXP_MAPPING_GAMEPAD, 0x0a }, "BTN_SELECT" }, { { OXP_MAPPING_GAMEPAD, 0x0b }, "BTN_L3" }, { { OXP_MAPPING_GAMEPAD, 0x0c }, "BTN_R3" }, { { OXP_MAPPING_GAMEPAD, 0x0d }, "DPAD_UP" }, { { OXP_MAPPING_GAMEPAD, 0x0e }, "DPAD_DOWN" }, { { OXP_MAPPING_GAMEPAD, 0x0f }, "DPAD_LEFT" }, { { OXP_MAPPING_GAMEPAD, 0x10 }, "DPAD_RIGHT" }, { { OXP_MAPPING_GAMEPAD, 0x11 }, "JOY_L_UP" }, { { OXP_MAPPING_GAMEPAD, 0x12 }, "JOY_L_UP_RIGHT" }, { { OXP_MAPPING_GAMEPAD, 0x13 }, "JOY_L_RIGHT" }, { { OXP_MAPPING_GAMEPAD, 0x14 }, "JOY_L_DOWN_RIGHT" }, { { OXP_MAPPING_GAMEPAD, 0x15 }, "JOY_L_DOWN" }, { { OXP_MAPPING_GAMEPAD, 0x16 }, "JOY_L_DOWN_LEFT" }, { { OXP_MAPPING_GAMEPAD, 0x17 }, "JOY_L_LEFT" }, { { OXP_MAPPING_GAMEPAD, 0x18 }, "JOY_L_UP_LEFT" }, { { OXP_MAPPING_GAMEPAD, 0x19 }, "JOY_R_UP" }, { { OXP_MAPPING_GAMEPAD, 0x1a }, "JOY_R_UP_RIGHT" }, { { OXP_MAPPING_GAMEPAD, 0x1b }, "JOY_R_RIGHT" }, { { OXP_MAPPING_GAMEPAD, 0x1c }, "JOY_R_DOWN_RIGHT" }, { { OXP_MAPPING_GAMEPAD, 0x1d }, "JOY_R_DOWN" }, { { OXP_MAPPING_GAMEPAD, 0x1e }, "JOY_R_DOWN_LEFT" }, { { OXP_MAPPING_GAMEPAD, 0x1f }, "JOY_R_LEFT" }, { { OXP_MAPPING_GAMEPAD, 0x20 }, "JOY_R_UP_LEFT" }, { { OXP_MAPPING_GAMEPAD, 0x22 }, "BTN_GUIDE" }, /* Keyboard Keys */ { { OXP_MAPPING_KEYBOARD, 0x01, 0x5a }, "KEY_F1" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x5b }, "KEY_F2" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x5c }, "KEY_F3" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x5d }, "KEY_F4" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x5e }, "KEY_F5" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x5f }, "KEY_F6" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x60 }, "KEY_F7" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x61 }, "KEY_F8" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x62 }, "KEY_F9" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x63 }, "KEY_F10" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x64 }, "KEY_F11" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x65 }, "KEY_F12" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x66 }, "KEY_F13" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x67 }, "KEY_F14" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x68 }, "KEY_F15" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x69 }, "KEY_F16" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x6a }, "KEY_F17" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x6b }, "KEY_F18" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x6c }, "KEY_F19" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x6d }, "KEY_F20" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x6e }, "KEY_F21" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x6f }, "KEY_F22" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x70 }, "KEY_F23" }, { { OXP_MAPPING_KEYBOARD, 0x01, 0x71 }, "KEY_F24" }, }; enum oxp_joybutton_index { BUTTON_A = 0x01, BUTTON_B, BUTTON_X, BUTTON_Y, BUTTON_LB, BUTTON_RB, BUTTON_LT, BUTTON_RT, BUTTON_START, BUTTON_SELECT, BUTTON_L3, BUTTON_R3, BUTTON_DUP, BUTTON_DDOWN, BUTTON_DLEFT, BUTTON_DRIGHT, BUTTON_M1 = 0x22, BUTTON_M2, /* These are unused currently, reserved for future devices */ BUTTON_M3, BUTTON_M4, BUTTON_M5, BUTTON_M6, }; struct oxp_button_idx { enum oxp_joybutton_index button_idx; u8 mapping_idx; } __packed; struct oxp_bmap_page_1 { struct oxp_button_idx btn_a; struct oxp_button_idx btn_b; struct oxp_button_idx btn_x; struct oxp_button_idx btn_y; struct oxp_button_idx btn_lb; struct oxp_button_idx btn_rb; struct oxp_button_idx btn_lt; struct oxp_button_idx btn_rt; struct oxp_button_idx btn_start; } __packed; struct oxp_bmap_page_2 { struct oxp_button_idx btn_select; struct oxp_button_idx btn_l3; struct oxp_button_idx btn_r3; struct oxp_button_idx btn_dup; struct oxp_button_idx btn_ddown; struct oxp_button_idx btn_dleft; struct oxp_button_idx btn_dright; struct oxp_button_idx btn_m1; struct oxp_button_idx btn_m2; } __packed; static struct oxp_hid_cfg { struct delayed_work oxp_rgb_queue; struct delayed_work oxp_btn_queue; struct oxp_bmap_page_1 *bmap_1; struct oxp_bmap_page_2 *bmap_2; struct delayed_work oxp_mcu_init; struct led_classdev_mc *led_mc; struct hid_device *hdev; struct mutex cfg_mutex; /*ensure single synchronous output report*/ u8 rgb_brightness; u8 gamepad_mode; u8 rumble_intensity; u8 rgb_effect; u8 rgb_speed; u8 rgb_en; } drvdata; #define OXP_FILL_PAGE_SLOT(page, btn) \ { .button_idx = (page)->btn.button_idx, \ .mapping_idx = (page)->btn.mapping_idx } enum oxp_gamepad_mode_index { OXP_GP_MODE_XINPUT = 0x00, OXP_GP_MODE_DEBUG = 0x03, }; static const char *const oxp_gamepad_mode_text[] = { [OXP_GP_MODE_XINPUT] = "xinput", [OXP_GP_MODE_DEBUG] = "debug", }; enum oxp_feature_en_index { OXP_FEAT_DISABLED, OXP_FEAT_ENABLED, }; static const char *const oxp_feature_en_text[] = { [OXP_FEAT_DISABLED] = "false", [OXP_FEAT_ENABLED] = "true", }; enum oxp_rgb_effect_index { OXP_UNKNOWN, OXP_EFFECT_AURORA, OXP_EFFECT_BIRTHDAY, OXP_EFFECT_FLOWING, OXP_EFFECT_CHROMA_1, OXP_EFFECT_NEON, OXP_EFFECT_CHROMA_2, OXP_EFFECT_DREAMY, OXP_EFFECT_WARM, OXP_EFFECT_CYBERPUNK, OXP_EFFECT_SEA, OXP_EFFECT_SUNSET, OXP_EFFECT_COLORFUL, OXP_EFFECT_MONSTER, OXP_EFFECT_GREEN, OXP_EFFECT_BLUE, OXP_EFFECT_YELLOW, OXP_EFFECT_TEAL, OXP_EFFECT_PURPLE, OXP_EFFECT_FOGGY, OXP_EFFECT_MONO_LIST, /* placeholder for effect_index_show */ }; /* These belong to rgb_effect_index, but we want to hide them from * rgb_effect_text */ #define OXP_GET_PROPERTY 0xfc #define OXP_SET_PROPERTY 0xfd #define OXP_EFFECT_MONO_TRUE 0xfe /* actual index for monocolor */ static const char *const oxp_rgb_effect_text[] = { [OXP_UNKNOWN] = "unknown", [OXP_EFFECT_AURORA] = "aurora", [OXP_EFFECT_BIRTHDAY] = "birthday_cake", [OXP_EFFECT_FLOWING] = "flowing_light", [OXP_EFFECT_CHROMA_1] = "chroma_popping", [OXP_EFFECT_NEON] = "neon", [OXP_EFFECT_CHROMA_2] = "chroma_breathing", [OXP_EFFECT_DREAMY] = "dreamy", [OXP_EFFECT_WARM] = "warm_sun", [OXP_EFFECT_CYBERPUNK] = "cyberpunk", [OXP_EFFECT_SEA] = "sea_foam", [OXP_EFFECT_SUNSET] = "sunset_afterglow", [OXP_EFFECT_COLORFUL] = "colorful", [OXP_EFFECT_MONSTER] = "monster_woke", [OXP_EFFECT_GREEN] = "green_breathing", [OXP_EFFECT_BLUE] = "blue_breathing", [OXP_EFFECT_YELLOW] = "yellow_breathing", [OXP_EFFECT_TEAL] = "teal_breathing", [OXP_EFFECT_PURPLE] = "purple_breathing", [OXP_EFFECT_FOGGY] = "foggy_haze", [OXP_EFFECT_MONO_LIST] = "monocolor", }; enum oxp_rumble_side_index { OXP_RUMBLE_LEFT = 0x00, OXP_RUMBLE_RIGHT, }; struct oxp_gen_1_rgb_report { u8 report_id; u8 message_id; u8 padding_2[2]; u8 effect; u8 enabled; u8 speed; u8 brightness; u8 red; u8 green; u8 blue; } __packed; struct oxp_gen_2_rgb_report { u8 report_id; u8 header_id; u8 padding_2; u8 message_id; u8 padding_4[2]; u8 enabled; u8 speed; u8 brightness; u8 red; u8 green; u8 blue; u8 padding_12[3]; u8 effect; } __packed; struct oxp_attr { u8 index; }; static u16 get_usage_page(struct hid_device *hdev) { return hdev->collection[0].usage >> 16; } static int oxp_hid_raw_event_gen_1(struct hid_device *hdev, struct hid_report *report, u8 *data, int size) { struct led_classdev_mc *led_mc = drvdata.led_mc; struct oxp_gen_1_rgb_report *rgb_rep; if (data[1] != OXP_FID_GEN1_RGB_REPLY) return 0; rgb_rep = (struct oxp_gen_1_rgb_report *)data; /* Ensure we save monocolor as the list value */ drvdata.rgb_effect = rgb_rep->effect == OXP_EFFECT_MONO_TRUE ? OXP_EFFECT_MONO_LIST : rgb_rep->effect; drvdata.rgb_speed = rgb_rep->speed; drvdata.rgb_en = rgb_rep->enabled == 0 ? OXP_FEAT_DISABLED : OXP_FEAT_ENABLED; drvdata.rgb_brightness = rgb_rep->brightness; led_mc->led_cdev.brightness = rgb_rep->brightness / 4 * led_mc->led_cdev.max_brightness; /* If monocolor had less than 100% brightness on the previous boot, * there will be no reliable way to determine the real intensity. * Since intensity scaling is used with a hardware brightness set at max, * our brightness will always look like 100%. Use the last set value to * prevent successive boots from lowering the brightness further. * Brightness will be "wrong" but the effect will remain the same visually. */ led_mc->subled_info[0].intensity = rgb_rep->red; led_mc->subled_info[1].intensity = rgb_rep->green; led_mc->subled_info[2].intensity = rgb_rep->blue; return 0; } static int oxp_gen_2_property_out(enum oxp_function_index fid, u8 *data, u8 data_size); static int oxp_set_buttons(void); static int oxp_rumble_intensity_set(u8 intensity); static void oxp_mcu_init_fn(struct work_struct *work) { u8 gp_mode_data[3] = { OXP_GP_MODE_DEBUG, 0x01, 0x02 }; int ret; /* Re-apply the button mapping */ ret = oxp_set_buttons(); if (ret) dev_err(&drvdata.hdev->dev, "Error: Failed to set button mapping: %i\n", ret); /* Cycle the gamepad mode */ ret = oxp_gen_2_property_out(OXP_FID_GEN2_TOGGLE_MODE, gp_mode_data, 3); if (ret) dev_err(&drvdata.hdev->dev, "Error: Failed to set gamepad mode: %i\n", ret); /* Remainder only applies for xinput mode */ if (drvdata.gamepad_mode == OXP_GP_MODE_DEBUG) return; gp_mode_data[0] = OXP_GP_MODE_XINPUT; ret = oxp_gen_2_property_out(OXP_FID_GEN2_TOGGLE_MODE, gp_mode_data, 3); if (ret) dev_err(&drvdata.hdev->dev, "Error: Failed to set gamepad mode: %i\n", ret); /* Set vibration level */ ret = oxp_rumble_intensity_set(drvdata.rumble_intensity); if (ret) dev_err(&drvdata.hdev->dev, "Error: Failed to set rumble intensity: %i\n", ret); } static int oxp_hid_raw_event_gen_2(struct hid_device *hdev, struct hid_report *report, u8 *data, int size) { struct led_classdev_mc *led_mc = drvdata.led_mc; struct oxp_gen_2_rgb_report *rgb_rep; if (data[0] != OXP_FID_GEN2_STATUS_EVENT) return 0; /* Sent ~6s after resume event, indicating the MCU has fully reset. * Re-apply our settings after this has been received. */ if (data[3] == OXP_EFFECT_MONO_TRUE) { mod_delayed_work(system_wq, &drvdata.oxp_mcu_init, msecs_to_jiffies(50)); return 0; } if (data[3] != OXP_GET_PROPERTY) return 0; rgb_rep = (struct oxp_gen_2_rgb_report *)data; /* Ensure we save monocolor as the list value */ drvdata.rgb_effect = rgb_rep->effect == OXP_EFFECT_MONO_TRUE ? OXP_EFFECT_MONO_LIST : rgb_rep->effect; drvdata.rgb_speed = rgb_rep->speed; drvdata.rgb_en = rgb_rep->enabled == 0 ? OXP_FEAT_DISABLED : OXP_FEAT_ENABLED; drvdata.rgb_brightness = rgb_rep->brightness; led_mc->led_cdev.brightness = rgb_rep->brightness / 4 * led_mc->led_cdev.max_brightness; /* If monocolor had less than 100% brightness on the previous boot, * there will be no reliable way to determine the real intensity. * Since intensity scaling is used with a hardware brightness set at max, * our brightness will always look like 100%. Use the last set value to * prevent successive boots from lowering the brightness further. * Brightness will be "wrong" but the effect will remain the same visually. */ led_mc->subled_info[0].intensity = rgb_rep->red; led_mc->subled_info[1].intensity = rgb_rep->green; led_mc->subled_info[2].intensity = rgb_rep->blue; return 0; } static int oxp_hid_raw_event(struct hid_device *hdev, struct hid_report *report, u8 *data, int size) { u16 up = get_usage_page(hdev); dev_dbg(&hdev->dev, "raw event data: [%*ph]\n", OXP_PACKET_SIZE, data); switch (up) { case GEN1_USAGE_PAGE: return oxp_hid_raw_event_gen_1(hdev, report, data, size); case GEN2_USAGE_PAGE: return oxp_hid_raw_event_gen_2(hdev, report, data, size); default: break; } return 0; } static int mcu_property_out(u8 *header, size_t header_size, u8 *data, size_t data_size, u8 *footer, size_t footer_size) { unsigned char *dmabuf __free(kfree) = kzalloc(OXP_PACKET_SIZE, GFP_KERNEL); int ret; if (!dmabuf) return -ENOMEM; if (header_size + data_size + footer_size > OXP_PACKET_SIZE) return -EINVAL; guard(mutex)(&drvdata.cfg_mutex); memcpy(dmabuf, header, header_size); memcpy(dmabuf + header_size, data, data_size); if (footer_size) memcpy(dmabuf + OXP_PACKET_SIZE - footer_size, footer, footer_size); dev_dbg(&drvdata.hdev->dev, "raw data: [%*ph]\n", OXP_PACKET_SIZE, dmabuf); ret = hid_hw_output_report(drvdata.hdev, dmabuf, OXP_PACKET_SIZE); if (ret < 0) return ret; /* MCU takes 200ms to be ready for another command. */ msleep(200); return ret == OXP_PACKET_SIZE ? 0 : -EIO; } static int oxp_gen_1_property_out(enum oxp_function_index fid, u8 *data, u8 data_size) { u8 header[] = { fid, GEN1_MESSAGE_ID }; size_t header_size = ARRAY_SIZE(header); return mcu_property_out(header, header_size, data, data_size, NULL, 0); } static int oxp_gen_2_property_out(enum oxp_function_index fid, u8 *data, u8 data_size) { u8 header[] = { fid, GEN2_MESSAGE_ID, 0x01 }; u8 footer[] = { GEN2_MESSAGE_ID, fid }; size_t header_size = ARRAY_SIZE(header); size_t footer_size = ARRAY_SIZE(footer); return mcu_property_out(header, header_size, data, data_size, footer, footer_size); } static ssize_t gamepad_mode_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { u16 up = get_usage_page(drvdata.hdev); u8 data[3] = { 0x00, 0x01, 0x02 }; int ret = -EINVAL; int i; if (up != GEN2_USAGE_PAGE) return ret; for (i = 0; i < ARRAY_SIZE(oxp_gamepad_mode_text); i++) { if (oxp_gamepad_mode_text[i] && sysfs_streq(buf, oxp_gamepad_mode_text[i])) { ret = i; break; } } if (ret < 0) return ret; data[0] = ret; ret = oxp_gen_2_property_out(OXP_FID_GEN2_TOGGLE_MODE, data, 3); if (ret) return ret; drvdata.gamepad_mode = data[0]; if (drvdata.gamepad_mode == OXP_GP_MODE_DEBUG) return count; /* Re-apply rumble settings as switching gamepad mode will override */ ret = oxp_rumble_intensity_set(drvdata.rumble_intensity); if (ret) return ret; return count; } static ssize_t gamepad_mode_show(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_emit(buf, "%s\n", oxp_gamepad_mode_text[drvdata.gamepad_mode]); } static DEVICE_ATTR_RW(gamepad_mode); static ssize_t gamepad_mode_index_show(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0; unsigned int i; for (i = 0; i < ARRAY_SIZE(oxp_gamepad_mode_text); i++) { if (!oxp_gamepad_mode_text[i] || oxp_gamepad_mode_text[i][0] == '\0') continue; count += sysfs_emit_at(buf, count, "%s ", oxp_gamepad_mode_text[i]); } if (count) buf[count - 1] = '\n'; return count; } static DEVICE_ATTR_RO(gamepad_mode_index); static void oxp_set_defaults_bmap_1(struct oxp_bmap_page_1 *bmap) { bmap->btn_a.button_idx = BUTTON_A; bmap->btn_a.mapping_idx = 0; bmap->btn_b.button_idx = BUTTON_B; bmap->btn_b.mapping_idx = 1; bmap->btn_x.button_idx = BUTTON_X; bmap->btn_x.mapping_idx = 2; bmap->btn_y.button_idx = BUTTON_Y; bmap->btn_y.mapping_idx = 3; bmap->btn_lb.button_idx = BUTTON_LB; bmap->btn_lb.mapping_idx = 4; bmap->btn_rb.button_idx = BUTTON_RB; bmap->btn_rb.mapping_idx = 5; bmap->btn_lt.button_idx = BUTTON_LT; bmap->btn_lt.mapping_idx = 6; bmap->btn_rt.button_idx = BUTTON_RT; bmap->btn_rt.mapping_idx = 7; bmap->btn_start.button_idx = BUTTON_START; bmap->btn_start.mapping_idx = 8; } static void oxp_set_defaults_bmap_2(struct oxp_bmap_page_2 *bmap) { bmap->btn_select.button_idx = BUTTON_SELECT; bmap->btn_select.mapping_idx = 9; bmap->btn_l3.button_idx = BUTTON_L3; bmap->btn_l3.mapping_idx = 10; bmap->btn_r3.button_idx = BUTTON_R3; bmap->btn_r3.mapping_idx = 11; bmap->btn_dup.button_idx = BUTTON_DUP; bmap->btn_dup.mapping_idx = 12; bmap->btn_ddown.button_idx = BUTTON_DDOWN; bmap->btn_ddown.mapping_idx = 13; bmap->btn_dleft.button_idx = BUTTON_DLEFT; bmap->btn_dleft.mapping_idx = 14; bmap->btn_dright.button_idx = BUTTON_DRIGHT; bmap->btn_dright.mapping_idx = 15; bmap->btn_m1.button_idx = BUTTON_M1; bmap->btn_m1.mapping_idx = 48; /* KEY_F15 */ bmap->btn_m2.button_idx = BUTTON_M2; bmap->btn_m2.mapping_idx = 49; /* KEY_F16 */ } static void oxp_page_fill_data(char *buf, const struct oxp_button_idx *buttons, size_t len) { size_t offset_increment = sizeof(u8) + sizeof(struct oxp_button_idx); size_t offset = 5; unsigned int i; for (i = 0; i < len; i++, offset += offset_increment) { buf[offset] = (u8)buttons[i].button_idx; memcpy(buf + offset + 1, &oxp_button_table[buttons[i].mapping_idx].data, sizeof(struct oxp_button_data)); } } static int oxp_set_buttons(void) { u8 page_1[59] = { 0x02, 0x38, 0x20, 0x01, 0x01 }; u8 page_2[59] = { 0x02, 0x38, 0x20, 0x02, 0x01 }; u16 up = get_usage_page(drvdata.hdev); int ret; if (up != GEN2_USAGE_PAGE) return -EINVAL; const struct oxp_button_idx p1[] = { OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_a), OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_b), OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_x), OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_y), OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_lb), OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_rb), OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_lt), OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_rt), OXP_FILL_PAGE_SLOT(drvdata.bmap_1, btn_start), }; const struct oxp_button_idx p2[] = { OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_select), OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_l3), OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_r3), OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_dup), OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_ddown), OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_dleft), OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_dright), OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_m1), OXP_FILL_PAGE_SLOT(drvdata.bmap_2, btn_m2), }; oxp_page_fill_data(page_1, p1, ARRAY_SIZE(p1)); oxp_page_fill_data(page_2, p2, ARRAY_SIZE(p2)); ret = oxp_gen_2_property_out(OXP_FID_GEN2_KEY_STATE, page_1, ARRAY_SIZE(page_1)); if (ret) return ret; return oxp_gen_2_property_out(OXP_FID_GEN2_KEY_STATE, page_2, ARRAY_SIZE(page_2)); } static void oxp_reset_buttons(void) { oxp_set_defaults_bmap_1(drvdata.bmap_1); oxp_set_defaults_bmap_2(drvdata.bmap_2); } static ssize_t reset_buttons_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int val, ret; ret = kstrtoint(buf, 10, &val); if (ret) return ret; if (val != 1) return -EINVAL; oxp_reset_buttons(); ret = oxp_set_buttons(); if (ret) return ret; return count; } static DEVICE_ATTR_WO(reset_buttons); static void oxp_btn_queue_fn(struct work_struct *work) { int ret; ret = oxp_set_buttons(); if (ret) dev_err(&drvdata.hdev->dev, "Error: Failed to write button mapping: %i\n", ret); } static int oxp_button_idx_from_str(const char *buf) { int i; for (i = 0; i < ARRAY_SIZE(oxp_button_table); i++) if (sysfs_streq(buf, oxp_button_table[i].name)) return i; return -EINVAL; } static ssize_t map_button_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count, u8 index) { int idx; idx = oxp_button_idx_from_str(buf); if (idx < 0) return idx; switch (index) { case BUTTON_A: drvdata.bmap_1->btn_a.mapping_idx = idx; break; case BUTTON_B: drvdata.bmap_1->btn_b.mapping_idx = idx; break; case BUTTON_X: drvdata.bmap_1->btn_x.mapping_idx = idx; break; case BUTTON_Y: drvdata.bmap_1->btn_y.mapping_idx = idx; break; case BUTTON_LB: drvdata.bmap_1->btn_lb.mapping_idx = idx; break; case BUTTON_RB: drvdata.bmap_1->btn_rb.mapping_idx = idx; break; case BUTTON_LT: drvdata.bmap_1->btn_lt.mapping_idx = idx; break; case BUTTON_RT: drvdata.bmap_1->btn_rt.mapping_idx = idx; break; case BUTTON_START: drvdata.bmap_1->btn_start.mapping_idx = idx; break; case BUTTON_SELECT: drvdata.bmap_2->btn_select.mapping_idx = idx; break; case BUTTON_L3: drvdata.bmap_2->btn_l3.mapping_idx = idx; break; case BUTTON_R3: drvdata.bmap_2->btn_r3.mapping_idx = idx; break; case BUTTON_DUP: drvdata.bmap_2->btn_dup.mapping_idx = idx; break; case BUTTON_DDOWN: drvdata.bmap_2->btn_ddown.mapping_idx = idx; break; case BUTTON_DLEFT: drvdata.bmap_2->btn_dleft.mapping_idx = idx; break; case BUTTON_DRIGHT: drvdata.bmap_2->btn_dright.mapping_idx = idx; break; case BUTTON_M1: drvdata.bmap_2->btn_m1.mapping_idx = idx; break; case BUTTON_M2: drvdata.bmap_2->btn_m2.mapping_idx = idx; break; default: return -EINVAL; } mod_delayed_work(system_wq, &drvdata.oxp_btn_queue, msecs_to_jiffies(50)); return count; } static ssize_t map_button_show(struct device *dev, struct device_attribute *attr, char *buf, u8 index) { u8 i; switch (index) { case BUTTON_A: i = drvdata.bmap_1->btn_a.mapping_idx; break; case BUTTON_B: i = drvdata.bmap_1->btn_b.mapping_idx; break; case BUTTON_X: i = drvdata.bmap_1->btn_x.mapping_idx; break; case BUTTON_Y: i = drvdata.bmap_1->btn_y.mapping_idx; break; case BUTTON_LB: i = drvdata.bmap_1->btn_lb.mapping_idx; break; case BUTTON_RB: i = drvdata.bmap_1->btn_rb.mapping_idx; break; case BUTTON_LT: i = drvdata.bmap_1->btn_lt.mapping_idx; break; case BUTTON_RT: i = drvdata.bmap_1->btn_rt.mapping_idx; break; case BUTTON_START: i = drvdata.bmap_1->btn_start.mapping_idx; break; case BUTTON_SELECT: i = drvdata.bmap_2->btn_select.mapping_idx; break; case BUTTON_L3: i = drvdata.bmap_2->btn_l3.mapping_idx; break; case BUTTON_R3: i = drvdata.bmap_2->btn_r3.mapping_idx; break; case BUTTON_DUP: i = drvdata.bmap_2->btn_dup.mapping_idx; break; case BUTTON_DDOWN: i = drvdata.bmap_2->btn_ddown.mapping_idx; break; case BUTTON_DLEFT: i = drvdata.bmap_2->btn_dleft.mapping_idx; break; case BUTTON_DRIGHT: i = drvdata.bmap_2->btn_dright.mapping_idx; break; case BUTTON_M1: i = drvdata.bmap_2->btn_m1.mapping_idx; break; case BUTTON_M2: i = drvdata.bmap_2->btn_m2.mapping_idx; break; default: return -EINVAL; } if (i >= ARRAY_SIZE(oxp_button_table)) return -EINVAL; return sysfs_emit(buf, "%s\n", oxp_button_table[i].name); } static ssize_t button_mapping_options_show(struct device *dev, struct device_attribute *attr, char *buf) { ssize_t count = 0; unsigned int i; for (i = 0; i < ARRAY_SIZE(oxp_button_table); i++) count += sysfs_emit_at(buf, count, "%s ", oxp_button_table[i].name); if (count) buf[count - 1] = '\n'; return count; } static DEVICE_ATTR_RO(button_mapping_options); static int oxp_rumble_intensity_set(u8 intensity) { u8 header[15] = { 0x02, 0x38, 0x02, 0xe3, 0x39, 0xe3, 0x39, 0xe3, 0x39, 0x01, intensity, 0x05, 0xe3, 0x39, 0xe3 }; u8 footer[9] = { 0x39, 0xe3, 0x39, 0xe3, 0xe3, 0x02, 0x04, 0x39, 0x39 }; size_t footer_size = ARRAY_SIZE(footer); size_t header_size = ARRAY_SIZE(header); u8 data[59] = { 0x0 }; size_t data_size = ARRAY_SIZE(data); memcpy(data, header, header_size); memcpy(data + data_size - footer_size, footer, footer_size); return oxp_gen_2_property_out(OXP_FID_GEN2_RUMBLE_SET, data, data_size); } static ssize_t rumble_intensity_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int ret; u8 val; ret = kstrtou8(buf, 10, &val); if (ret) return ret; if (val < 0 || val > 5) return -EINVAL; ret = oxp_rumble_intensity_set(val); if (ret) return ret; drvdata.rumble_intensity = val; return count; } static ssize_t rumble_intensity_show(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_emit(buf, "%i\n", drvdata.rumble_intensity); } static DEVICE_ATTR_RW(rumble_intensity); static ssize_t rumble_intensity_range_show(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_emit(buf, "0-5\n"); } static DEVICE_ATTR_RO(rumble_intensity_range); #define OXP_DEVICE_ATTR_RW(_name, _group) \ static ssize_t _name##_store(struct device *dev, \ struct device_attribute *attr, \ const char *buf, size_t count) \ { \ return _group##_store(dev, attr, buf, count, _name.index); \ } \ static ssize_t _name##_show(struct device *dev, \ struct device_attribute *attr, char *buf) \ { \ return _group##_show(dev, attr, buf, _name.index); \ } \ static DEVICE_ATTR_RW(_name) static struct oxp_attr button_a = { BUTTON_A }; OXP_DEVICE_ATTR_RW(button_a, map_button); static struct oxp_attr button_b = { BUTTON_B }; OXP_DEVICE_ATTR_RW(button_b, map_button); static struct oxp_attr button_x = { BUTTON_X }; OXP_DEVICE_ATTR_RW(button_x, map_button); static struct oxp_attr button_y = { BUTTON_Y }; OXP_DEVICE_ATTR_RW(button_y, map_button); static struct oxp_attr button_lb = { BUTTON_LB }; OXP_DEVICE_ATTR_RW(button_lb, map_button); static struct oxp_attr button_rb = { BUTTON_RB }; OXP_DEVICE_ATTR_RW(button_rb, map_button); static struct oxp_attr button_lt = { BUTTON_LT }; OXP_DEVICE_ATTR_RW(button_lt, map_button); static struct oxp_attr button_rt = { BUTTON_RT }; OXP_DEVICE_ATTR_RW(button_rt, map_button); static struct oxp_attr button_start = { BUTTON_START }; OXP_DEVICE_ATTR_RW(button_start, map_button); static struct oxp_attr button_select = { BUTTON_SELECT }; OXP_DEVICE_ATTR_RW(button_select, map_button); static struct oxp_attr button_l3 = { BUTTON_L3 }; OXP_DEVICE_ATTR_RW(button_l3, map_button); static struct oxp_attr button_r3 = { BUTTON_R3 }; OXP_DEVICE_ATTR_RW(button_r3, map_button); static struct oxp_attr button_d_up = { BUTTON_DUP }; OXP_DEVICE_ATTR_RW(button_d_up, map_button); static struct oxp_attr button_d_down = { BUTTON_DDOWN }; OXP_DEVICE_ATTR_RW(button_d_down, map_button); static struct oxp_attr button_d_left = { BUTTON_DLEFT }; OXP_DEVICE_ATTR_RW(button_d_left, map_button); static struct oxp_attr button_d_right = { BUTTON_DRIGHT }; OXP_DEVICE_ATTR_RW(button_d_right, map_button); static struct oxp_attr button_m1 = { BUTTON_M1 }; OXP_DEVICE_ATTR_RW(button_m1, map_button); static struct oxp_attr button_m2 = { BUTTON_M2 }; OXP_DEVICE_ATTR_RW(button_m2, map_button); static struct attribute *oxp_cfg_attrs[] = { &dev_attr_button_a.attr, &dev_attr_button_b.attr, &dev_attr_button_d_down.attr, &dev_attr_button_d_left.attr, &dev_attr_button_d_right.attr, &dev_attr_button_d_up.attr, &dev_attr_button_l3.attr, &dev_attr_button_lb.attr, &dev_attr_button_lt.attr, &dev_attr_button_m1.attr, &dev_attr_button_m2.attr, &dev_attr_button_mapping_options.attr, &dev_attr_button_r3.attr, &dev_attr_button_rb.attr, &dev_attr_button_rt.attr, &dev_attr_button_select.attr, &dev_attr_button_start.attr, &dev_attr_button_x.attr, &dev_attr_button_y.attr, &dev_attr_gamepad_mode.attr, &dev_attr_gamepad_mode_index.attr, &dev_attr_reset_buttons.attr, &dev_attr_rumble_intensity.attr, &dev_attr_rumble_intensity_range.attr, NULL, }; static const struct attribute_group oxp_cfg_attrs_group = { .attrs = oxp_cfg_attrs, }; static int oxp_rgb_status_store(u8 enabled, u8 speed, u8 brightness) { u16 up = get_usage_page(drvdata.hdev); u8 *data; /* Always default to max brightness and use intensity scaling when in * monocolor mode. */ switch (up) { case GEN1_USAGE_PAGE: data = (u8[4]) { OXP_SET_PROPERTY, enabled, speed, brightness }; if (drvdata.rgb_effect == OXP_EFFECT_MONO_LIST) data[3] = 0x04; return oxp_gen_1_property_out(OXP_FID_GEN1_RGB_SET, data, 4); case GEN2_USAGE_PAGE: data = (u8[6]) { OXP_SET_PROPERTY, 0x00, 0x02, enabled, speed, brightness }; if (drvdata.rgb_effect == OXP_EFFECT_MONO_LIST) data[5] = 0x04; return oxp_gen_2_property_out(OXP_FID_GEN2_STATUS_EVENT, data, 6); default: return -ENODEV; } } static ssize_t oxp_rgb_status_show(void) { u16 up = get_usage_page(drvdata.hdev); u8 *data; switch (up) { case GEN1_USAGE_PAGE: data = (u8[1]) { OXP_GET_PROPERTY }; return oxp_gen_1_property_out(OXP_FID_GEN1_RGB_SET, data, 1); case GEN2_USAGE_PAGE: data = (u8[3]) { OXP_GET_PROPERTY, 0x00, 0x02 }; return oxp_gen_2_property_out(OXP_FID_GEN2_STATUS_EVENT, data, 3); default: return -ENODEV; } } static int oxp_rgb_color_set(void) { u8 max_br = drvdata.led_mc->led_cdev.max_brightness; u8 br = drvdata.led_mc->led_cdev.brightness; u16 up = get_usage_page(drvdata.hdev); u8 green, red, blue; size_t size; u8 *data; int i; red = br * drvdata.led_mc->subled_info[0].intensity / max_br; green = br * drvdata.led_mc->subled_info[1].intensity / max_br; blue = br * drvdata.led_mc->subled_info[2].intensity / max_br; switch (up) { case GEN1_USAGE_PAGE: size = 55; data = (u8[55]) { OXP_EFFECT_MONO_TRUE }; for (i = 0; i < (size - 1) / 3; i++) { data[3 * i + 1] = red; data[3 * i + 2] = green; data[3 * i + 3] = blue; } return oxp_gen_1_property_out(OXP_FID_GEN1_RGB_SET, data, size); case GEN2_USAGE_PAGE: size = 57; data = (u8[57]) { OXP_EFFECT_MONO_TRUE, 0x00, 0x02 }; for (i = 1; i < size / 3; i++) { data[3 * i] = red; data[3 * i + 1] = green; data[3 * i + 2] = blue; } return oxp_gen_2_property_out(OXP_FID_GEN2_STATUS_EVENT, data, size); default: return -ENODEV; } } static int oxp_rgb_effect_set(u8 effect) { u16 up = get_usage_page(drvdata.hdev); u8 *data; int ret; switch (effect) { case OXP_EFFECT_AURORA: case OXP_EFFECT_BIRTHDAY: case OXP_EFFECT_FLOWING: case OXP_EFFECT_CHROMA_1: case OXP_EFFECT_NEON: case OXP_EFFECT_CHROMA_2: case OXP_EFFECT_DREAMY: case OXP_EFFECT_WARM: case OXP_EFFECT_CYBERPUNK: case OXP_EFFECT_SEA: case OXP_EFFECT_SUNSET: case OXP_EFFECT_COLORFUL: case OXP_EFFECT_MONSTER: case OXP_EFFECT_GREEN: case OXP_EFFECT_BLUE: case OXP_EFFECT_YELLOW: case OXP_EFFECT_TEAL: case OXP_EFFECT_PURPLE: case OXP_EFFECT_FOGGY: switch (up) { case GEN1_USAGE_PAGE: data = (u8[1]) { effect }; ret = oxp_gen_1_property_out(OXP_FID_GEN1_RGB_SET, data, 1); break; case GEN2_USAGE_PAGE: data = (u8[3]) { effect, 0x00, 0x02 }; ret = oxp_gen_2_property_out(OXP_FID_GEN2_STATUS_EVENT, data, 3); break; default: ret = -ENODEV; } break; case OXP_EFFECT_MONO_LIST: ret = oxp_rgb_color_set(); break; default: return -EINVAL; } if (ret) return ret; drvdata.rgb_effect = effect; return 0; } static ssize_t enabled_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int ret; u8 val; ret = sysfs_match_string(oxp_feature_en_text, buf); if (ret < 0) return ret; val = ret; ret = oxp_rgb_status_store(val, drvdata.rgb_speed, drvdata.rgb_brightness); if (ret) return ret; drvdata.rgb_en = val; return count; } static ssize_t enabled_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; ret = oxp_rgb_status_show(); if (ret) return ret; if (drvdata.rgb_en >= ARRAY_SIZE(oxp_feature_en_text)) return -EINVAL; return sysfs_emit(buf, "%s\n", oxp_feature_en_text[drvdata.rgb_en]); } static DEVICE_ATTR_RW(enabled); static ssize_t enabled_index_show(struct device *dev, struct device_attribute *attr, char *buf) { size_t count = 0; unsigned int i; for (i = 0; i < ARRAY_SIZE(oxp_feature_en_text); i++) count += sysfs_emit_at(buf, count, "%s ", oxp_feature_en_text[i]); if (count) buf[count - 1] = '\n'; return count; } static DEVICE_ATTR_RO(enabled_index); static ssize_t effect_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int ret; u8 val; ret = sysfs_match_string(oxp_rgb_effect_text, buf); if (ret < 0) return ret; val = ret; ret = oxp_rgb_status_store(drvdata.rgb_en, drvdata.rgb_speed, drvdata.rgb_brightness); if (ret) return ret; ret = oxp_rgb_effect_set(val); if (ret) return ret; return count; } static ssize_t effect_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; ret = oxp_rgb_status_show(); if (ret) return ret; if (drvdata.rgb_effect >= ARRAY_SIZE(oxp_rgb_effect_text)) return -EINVAL; return sysfs_emit(buf, "%s\n", oxp_rgb_effect_text[drvdata.rgb_effect]); } static DEVICE_ATTR_RW(effect); static ssize_t effect_index_show(struct device *dev, struct device_attribute *attr, char *buf) { size_t count = 0; unsigned int i; for (i = 1; i < ARRAY_SIZE(oxp_rgb_effect_text); i++) count += sysfs_emit_at(buf, count, "%s ", oxp_rgb_effect_text[i]); if (count) buf[count - 1] = '\n'; return count; } static DEVICE_ATTR_RO(effect_index); static ssize_t speed_store(struct device *dev, struct device_attribute *attr, const char *buf, size_t count) { int ret; u8 val; ret = kstrtou8(buf, 10, &val); if (ret) return ret; if (val > 9) return -EINVAL; ret = oxp_rgb_status_store(drvdata.rgb_en, val, drvdata.rgb_brightness); if (ret) return ret; drvdata.rgb_speed = val; return count; } static ssize_t speed_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; ret = oxp_rgb_status_show(); if (ret) return ret; if (drvdata.rgb_speed > 9) return -EINVAL; return sysfs_emit(buf, "%hhu\n", drvdata.rgb_speed); } static DEVICE_ATTR_RW(speed); static ssize_t speed_range_show(struct device *dev, struct device_attribute *attr, char *buf) { return sysfs_emit(buf, "0-9\n"); } static DEVICE_ATTR_RO(speed_range); static void oxp_rgb_queue_fn(struct work_struct *work) { unsigned int max_brightness = drvdata.led_mc->led_cdev.max_brightness; unsigned int brightness = drvdata.led_mc->led_cdev.brightness; u8 val = 4 * brightness / max_brightness; int ret; if (drvdata.rgb_brightness != val) { ret = oxp_rgb_status_store(drvdata.rgb_en, drvdata.rgb_speed, val); if (ret) dev_err(drvdata.led_mc->led_cdev.dev, "Error: Failed to write RGB Status: %i\n", ret); drvdata.rgb_brightness = val; } if (drvdata.rgb_effect != OXP_EFFECT_MONO_LIST) return; ret = oxp_rgb_effect_set(drvdata.rgb_effect); if (ret) dev_err(drvdata.led_mc->led_cdev.dev, "Error: Failed to write RGB color: %i\n", ret); } static void oxp_rgb_brightness_set(struct led_classdev *led_cdev, enum led_brightness brightness) { led_cdev->brightness = brightness; mod_delayed_work(system_wq, &drvdata.oxp_rgb_queue, msecs_to_jiffies(50)); } static struct attribute *oxp_rgb_attrs[] = { &dev_attr_effect.attr, &dev_attr_effect_index.attr, &dev_attr_enabled.attr, &dev_attr_enabled_index.attr, &dev_attr_speed.attr, &dev_attr_speed_range.attr, NULL, }; static const struct attribute_group oxp_rgb_attr_group = { .attrs = oxp_rgb_attrs, }; static struct mc_subled oxp_rgb_subled_info[] = { { .color_index = LED_COLOR_ID_RED, .intensity = 0x24, .channel = 0x1, }, { .color_index = LED_COLOR_ID_GREEN, .intensity = 0x22, .channel = 0x2, }, { .color_index = LED_COLOR_ID_BLUE, .intensity = 0x99, .channel = 0x3, }, }; static struct led_classdev_mc oxp_cdev_rgb = { .led_cdev = { .name = "oxp:rgb:joystick_rings", .color = LED_COLOR_ID_RGB, .brightness = 0x64, .max_brightness = 0x64, .brightness_set = oxp_rgb_brightness_set, }, .num_colors = ARRAY_SIZE(oxp_rgb_subled_info), .subled_info = oxp_rgb_subled_info, }; struct quirk_entry { bool hybrid_mcu; }; static struct quirk_entry quirk_hybrid_mcu = { .hybrid_mcu = true, }; static const struct dmi_system_id oxp_hybrid_mcu_list[] = { { .ident = "OneXPlayer Apex", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "ONE-NETBOOK"), DMI_MATCH(DMI_PRODUCT_NAME, "ONEXPLAYER APEX"), }, .driver_data = &quirk_hybrid_mcu, }, { .ident = "OneXPlayer G1 AMD", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "ONE-NETBOOK"), DMI_MATCH(DMI_PRODUCT_NAME, "ONEXPLAYER G1 A"), }, .driver_data = &quirk_hybrid_mcu, }, { .ident = "OneXPlayer G1 Intel", .matches = { DMI_MATCH(DMI_SYS_VENDOR, "ONE-NETBOOK"), DMI_MATCH(DMI_PRODUCT_NAME, "ONEXPLAYER G1 i"), }, .driver_data = &quirk_hybrid_mcu, }, {}, }; static bool oxp_hybrid_mcu_device(void) { const struct dmi_system_id *dmi_id; struct quirk_entry *quirks; dmi_id = dmi_first_match(oxp_hybrid_mcu_list); if (!dmi_id) return false; quirks = dmi_id->driver_data; return quirks->hybrid_mcu; } static int oxp_cfg_probe(struct hid_device *hdev, u16 up) { struct oxp_bmap_page_1 *bmap_1; struct oxp_bmap_page_2 *bmap_2; int ret; hid_set_drvdata(hdev, &drvdata); mutex_init(&drvdata.cfg_mutex); drvdata.hdev = hdev; if (up == GEN2_USAGE_PAGE && oxp_hybrid_mcu_device()) goto skip_rgb; drvdata.led_mc = &oxp_cdev_rgb; INIT_DELAYED_WORK(&drvdata.oxp_rgb_queue, oxp_rgb_queue_fn); ret = devm_led_classdev_multicolor_register(&hdev->dev, &oxp_cdev_rgb); if (ret) return dev_err_probe(&hdev->dev, ret, "Failed to create RGB device\n"); ret = devm_device_add_group(drvdata.led_mc->led_cdev.dev, &oxp_rgb_attr_group); if (ret) return dev_err_probe(drvdata.led_mc->led_cdev.dev, ret, "Failed to create RGB configuration attributes\n"); ret = oxp_rgb_status_show(); if (ret) dev_warn(drvdata.led_mc->led_cdev.dev, "Failed to query RGB initial state: %i\n", ret); /* Below features are only implemented in gen 2 */ if (up != GEN2_USAGE_PAGE) return 0; skip_rgb: bmap_1 = devm_kzalloc(&hdev->dev, sizeof(struct oxp_bmap_page_1), GFP_KERNEL); if (!bmap_1) return dev_err_probe(&hdev->dev, -ENOMEM, "Unable to allocate button map page 1\n"); bmap_2 = devm_kzalloc(&hdev->dev, sizeof(struct oxp_bmap_page_2), GFP_KERNEL); if (!bmap_2) return dev_err_probe(&hdev->dev, -ENOMEM, "Unable to allocate button map page 2\n"); drvdata.bmap_1 = bmap_1; drvdata.bmap_2 = bmap_2; oxp_reset_buttons(); INIT_DELAYED_WORK(&drvdata.oxp_btn_queue, oxp_btn_queue_fn); drvdata.gamepad_mode = OXP_GP_MODE_XINPUT; drvdata.rumble_intensity = 5; INIT_DELAYED_WORK(&drvdata.oxp_mcu_init, oxp_mcu_init_fn); mod_delayed_work(system_wq, &drvdata.oxp_mcu_init, msecs_to_jiffies(50)); ret = devm_device_add_group(&hdev->dev, &oxp_cfg_attrs_group); if (ret) return dev_err_probe(&hdev->dev, ret, "Failed to attach configuration attributes\n"); return 0; } static int oxp_hid_probe(struct hid_device *hdev, const struct hid_device_id *id) { int ret; u16 up; ret = hid_parse(hdev); if (ret) return dev_err_probe(&hdev->dev, ret, "Failed to parse HID device\n"); ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); if (ret) return dev_err_probe(&hdev->dev, ret, "Failed to start HID device\n"); ret = hid_hw_open(hdev); if (ret) { hid_hw_stop(hdev); return dev_err_probe(&hdev->dev, ret, "Failed to open HID device\n"); } up = get_usage_page(hdev); dev_dbg(&hdev->dev, "Got usage page %04x\n", up); switch (up) { case GEN1_USAGE_PAGE: case GEN2_USAGE_PAGE: ret = oxp_cfg_probe(hdev, up); if (ret) { hid_hw_close(hdev); hid_hw_stop(hdev); } return ret; default: return 0; } } static void oxp_hid_remove(struct hid_device *hdev) { cancel_delayed_work(&drvdata.oxp_rgb_queue); cancel_delayed_work(&drvdata.oxp_btn_queue); cancel_delayed_work(&drvdata.oxp_mcu_init); hid_hw_close(hdev); hid_hw_stop(hdev); } static const struct hid_device_id oxp_devices[] = { { HID_USB_DEVICE(USB_VENDOR_ID_CRSC, USB_DEVICE_ID_ONEXPLAYER_GEN1) }, { HID_USB_DEVICE(USB_VENDOR_ID_WCH, USB_DEVICE_ID_ONEXPLAYER_GEN2) }, {} }; MODULE_DEVICE_TABLE(hid, oxp_devices); static struct hid_driver hid_oxp = { .name = "hid-oxp", .id_table = oxp_devices, .probe = oxp_hid_probe, .remove = oxp_hid_remove, .raw_event = oxp_hid_raw_event, }; module_hid_driver(hid_oxp); MODULE_AUTHOR("Derek J. Clark "); MODULE_DESCRIPTION("Driver for OneXPlayer HID Interfaces"); MODULE_LICENSE("GPL");