Lines Matching defs:hidpp
92 * There are two hidpp protocols in use, the first version hidpp10 is known
220 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
231 fields_count = hidpp->very_long_report_length;
243 if (hidpp->quirks & HIDPP_QUIRK_FORCE_OUTPUT_REPORTS) {
262 static int hidpp_send_message_sync(struct hidpp_device *hidpp,
268 mutex_lock(&hidpp->send_mutex);
270 hidpp->send_receive_buf = response;
271 hidpp->answer_available = false;
279 ret = __hidpp_send_report(hidpp->hid_dev, message);
287 if (!wait_event_timeout(hidpp->wait, hidpp->answer_available,
297 dbg_hid("%s:got hidpp error %02X\n", __func__, ret);
305 dbg_hid("%s:got hidpp 2.0 error %02X\n", __func__, ret);
310 mutex_unlock(&hidpp->send_mutex);
315 static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp,
337 ret = hidpp_send_message_sync(hidpp, message, response);
386 struct hidpp_device *hidpp = container_of(work, struct hidpp_device,
388 hidpp_connect_event(hidpp);
407 static inline bool hidpp_report_is_connect_event(struct hidpp_device *hidpp,
410 return (hidpp->wireless_feature_index &&
411 (report->fap.feature_index == hidpp->wireless_feature_index)) ||
634 static int hidpp10_query_battery_status(struct hidpp_device *hidpp)
639 ret = hidpp_send_rap_command_sync(hidpp,
647 hidpp->battery.level =
650 hidpp->battery.status = status;
652 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
686 static int hidpp10_query_battery_mileage(struct hidpp_device *hidpp)
691 ret = hidpp_send_rap_command_sync(hidpp,
699 hidpp->battery.capacity = response.rap.params[0];
701 hidpp->battery.status = status;
703 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
709 static int hidpp10_battery_event(struct hidpp_device *hidpp, u8 *data, int size)
720 capacity = hidpp->battery.capacity;
726 level = hidpp->battery.level;
733 changed = capacity != hidpp->battery.capacity ||
734 level != hidpp->battery.level ||
735 status != hidpp->battery.status;
738 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
742 hidpp->battery.level = level;
743 hidpp->battery.status = status;
744 if (hidpp->battery.ps)
745 power_supply_changed(hidpp->battery.ps);
791 static int hidpp_unifying_get_serial(struct hidpp_device *hidpp, u32 *serial)
797 ret = hidpp_send_rap_command_sync(hidpp,
813 static int hidpp_unifying_init(struct hidpp_device *hidpp)
815 struct hid_device *hdev = hidpp->hid_dev;
820 ret = hidpp_unifying_get_serial(hidpp, &serial);
827 name = hidpp_unifying_get_name(hidpp);
848 static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
855 ret = hidpp_send_fap_command_sync(hidpp,
871 static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
878 ret = hidpp_send_rap_command_sync(hidpp,
885 hidpp->protocol_major = 1;
886 hidpp->protocol_minor = 0;
895 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
903 hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n",
908 hidpp->protocol_major = response.rap.params[0];
909 hidpp->protocol_minor = response.rap.params[1];
912 hid_info(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
913 hidpp->protocol_major, hidpp->protocol_minor);
925 static int hidpp_get_serial(struct hidpp_device *hidpp, u32 *serial)
932 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_DEVICE_INFORMATION,
938 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
949 static int hidpp_serial_init(struct hidpp_device *hidpp)
951 struct hid_device *hdev = hidpp->hid_dev;
955 ret = hidpp_get_serial(hidpp, &serial);
975 static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp,
981 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
985 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
997 static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
1004 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1009 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1018 count = hidpp->very_long_report_length - 4;
1039 static char *hidpp_get_device_name(struct hidpp_device *hidpp)
1048 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE,
1053 ret = hidpp_devicenametype_get_count(hidpp, feature_index,
1063 ret = hidpp_devicenametype_get_device_name(hidpp,
1152 static int hidpp20_batterylevel_get_battery_capacity(struct hidpp_device *hidpp,
1163 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1170 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1184 static int hidpp20_batterylevel_get_battery_info(struct hidpp_device *hidpp,
1192 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1196 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1207 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1209 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1214 static int hidpp20_query_battery_info(struct hidpp_device *hidpp)
1220 if (hidpp->battery.feature_index == 0xff) {
1221 ret = hidpp_root_get_feature(hidpp,
1223 &hidpp->battery.feature_index,
1229 ret = hidpp20_batterylevel_get_battery_capacity(hidpp,
1230 hidpp->battery.feature_index,
1236 ret = hidpp20_batterylevel_get_battery_info(hidpp,
1237 hidpp->battery.feature_index);
1241 hidpp->battery.status = status;
1242 hidpp->battery.capacity = capacity;
1243 hidpp->battery.level = level;
1245 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1251 static int hidpp20_battery_event(struct hidpp_device *hidpp,
1258 if (report->fap.feature_index != hidpp->battery.feature_index ||
1268 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1271 changed = capacity != hidpp->battery.capacity ||
1272 level != hidpp->battery.level ||
1273 status != hidpp->battery.status;
1276 hidpp->battery.level = level;
1277 hidpp->battery.capacity = capacity;
1278 hidpp->battery.status = status;
1279 if (hidpp->battery.ps)
1280 power_supply_changed(hidpp->battery.ps);
1339 static int hidpp20_battery_get_battery_voltage(struct hidpp_device *hidpp,
1348 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1353 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1360 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_VOLTAGE;
1368 static int hidpp20_query_battery_voltage_info(struct hidpp_device *hidpp)
1374 if (hidpp->battery.voltage_feature_index == 0xff) {
1375 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_BATTERY_VOLTAGE,
1376 &hidpp->battery.voltage_feature_index,
1382 ret = hidpp20_battery_get_battery_voltage(hidpp,
1383 hidpp->battery.voltage_feature_index,
1389 hidpp->battery.status = status;
1390 hidpp->battery.voltage = voltage;
1391 hidpp->battery.level = level;
1392 hidpp->battery.charge_type = charge_type;
1393 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1398 static int hidpp20_battery_voltage_event(struct hidpp_device *hidpp,
1404 if (report->fap.feature_index != hidpp->battery.voltage_feature_index ||
1411 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1413 if (voltage != hidpp->battery.voltage || status != hidpp->battery.status) {
1414 hidpp->battery.voltage = voltage;
1415 hidpp->battery.status = status;
1416 hidpp->battery.level = level;
1417 hidpp->battery.charge_type = charge_type;
1418 if (hidpp->battery.ps)
1419 power_supply_changed(hidpp->battery.ps);
1440 struct hidpp_device *hidpp = power_supply_get_drvdata(psy);
1445 val->intval = hidpp->battery.status;
1448 val->intval = hidpp->battery.capacity;
1451 val->intval = hidpp->battery.level;
1457 val->intval = hidpp->battery.online;
1460 if (!strncmp(hidpp->name, "Logitech ", 9))
1461 val->strval = hidpp->name + 9;
1463 val->strval = hidpp->name;
1469 val->strval = hidpp->hid_dev->uniq;
1473 val->intval = hidpp->battery.voltage * 1000;
1476 val->intval = hidpp->battery.charge_type;
1491 static int hidpp_get_wireless_feature_index(struct hidpp_device *hidpp, u8 *feature_index)
1496 ret = hidpp_root_get_feature(hidpp,
1511 static int hidpp_hrs_set_highres_scrolling_mode(struct hidpp_device *hidpp,
1520 ret = hidpp_root_get_feature(hidpp,
1528 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1546 static int hidpp_hrw_get_wheel_capability(struct hidpp_device *hidpp,
1554 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
1559 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1568 hid_warn(hidpp->hid_dev,
1573 static int hidpp_hrw_set_wheel_mode(struct hidpp_device *hidpp, bool invert,
1582 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
1591 return hidpp_send_fap_command_sync(hidpp, feature_index,
1608 static int hidpp_solar_request_battery_event(struct hidpp_device *hidpp)
1615 if (hidpp->battery.feature_index == 0xff) {
1616 ret = hidpp_root_get_feature(hidpp,
1618 &hidpp->battery.solar_feature_index,
1624 ret = hidpp_send_fap_command_sync(hidpp,
1625 hidpp->battery.solar_feature_index,
1629 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1636 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1641 static int hidpp_solar_battery_event(struct hidpp_device *hidpp,
1651 if (report->fap.feature_index != hidpp->battery.solar_feature_index ||
1669 if (capacity < hidpp->battery.capacity)
1679 hidpp->battery.online = true;
1680 if (capacity != hidpp->battery.capacity ||
1681 status != hidpp->battery.status) {
1682 hidpp->battery.capacity = capacity;
1683 hidpp->battery.status = status;
1684 if (hidpp->battery.ps)
1685 power_supply_changed(hidpp->battery.ps);
1710 static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp,
1718 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1722 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1781 static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
1788 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1792 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1905 struct hidpp_device *hidpp;
1997 ret = hidpp_send_fap_command_sync(data->hidpp, data->feature_index,
2001 hid_err(data->hidpp->hid_dev, "Failed to send command to device!\n");
2064 hid_warn(data->hidpp->hid_dev, "Force feedback command queue contains %d commands, causing substantial delays!", s);
2123 hid_err(data->hidpp->hid_dev, "Unexpected periodic waveform type %i!\n", effect->u.periodic.waveform);
2208 hid_err(data->hidpp->hid_dev, "Unexpected force type %i!\n", effect->type);
2308 struct hid_device *hid = data->hidpp->hid_dev;
2317 static int hidpp_ff_init(struct hidpp_device *hidpp,
2320 struct hid_device *hid = hidpp->hid_dev;
2369 data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
2376 data->hidpp = hidpp;
2392 error = device_create_file(&(hidpp->hid_dev->dev), &dev_attr_range);
2394 hid_warn(hidpp->hid_dev, "Unable to create sysfs interface for \"range\", errno %d!\n", error);
2434 static void wtp_populate_input(struct hidpp_device *hidpp,
2437 struct wtp_data *wd = hidpp->private_data;
2454 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
2463 static void wtp_touch_event(struct hidpp_device *hidpp,
2466 struct wtp_data *wd = hidpp->private_data;
2473 slot = input_mt_get_slot_by_key(hidpp->input, touch_report->finger_id);
2475 input_mt_slot(hidpp->input, slot);
2476 input_mt_report_slot_state(hidpp->input, MT_TOOL_FINGER,
2479 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_X,
2481 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_Y,
2484 input_event(hidpp->input, EV_ABS, ABS_MT_PRESSURE,
2489 static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
2495 wtp_touch_event(hidpp, &(raw->fingers[i]));
2498 !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
2499 input_event(hidpp->input, EV_KEY, BTN_LEFT, raw->button);
2502 input_mt_sync_frame(hidpp->input);
2503 input_sync(hidpp->input);
2507 static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
2509 struct wtp_data *wd = hidpp->private_data;
2541 wtp_send_raw_xy_event(hidpp, &raw);
2548 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2549 struct wtp_data *wd = hidpp->private_data;
2553 if (!wd || !hidpp->input)
2563 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
2564 input_event(hidpp->input, EV_KEY, BTN_LEFT,
2566 input_event(hidpp->input, EV_KEY, BTN_RIGHT,
2568 input_sync(hidpp->input);
2573 return wtp_mouse_raw_xy_event(hidpp, &data[7]);
2580 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
2582 wtp_send_raw_xy_event(hidpp, &raw);
2589 static int wtp_get_config(struct hidpp_device *hidpp)
2591 struct wtp_data *wd = hidpp->private_data;
2596 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
2602 ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
2620 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2628 hidpp->private_data = wd;
2635 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2636 struct wtp_data *wd = hidpp->private_data;
2640 ret = wtp_get_config(hidpp);
2647 return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
2715 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2718 if (!hidpp->input) {
2745 input_report_key(hidpp->input, BTN_MIDDLE, 1);
2748 input_report_key(hidpp->input, BTN_FORWARD, 1);
2751 input_report_key(hidpp->input, BTN_BACK, 1);
2754 input_report_key(hidpp->input, BTN_BACK, 0);
2755 input_report_key(hidpp->input, BTN_FORWARD, 0);
2756 input_report_key(hidpp->input, BTN_MIDDLE, 0);
2762 input_sync(hidpp->input);
2776 input_report_key(hidpp->input, BTN_LEFT,
2778 input_report_key(hidpp->input, BTN_RIGHT,
2782 input_report_rel(hidpp->input, REL_HWHEEL, -1);
2783 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
2786 input_report_rel(hidpp->input, REL_HWHEEL, 1);
2787 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
2792 input_report_rel(hidpp->input, REL_X, v);
2795 input_report_rel(hidpp->input, REL_Y, v);
2799 hidpp_scroll_counter_handle_scroll(hidpp->input,
2800 &hidpp->vertical_wheel_counter, v);
2802 input_sync(hidpp->input);
2808 static void m560_populate_input(struct hidpp_device *hidpp,
2852 static int k400_disable_tap_to_click(struct hidpp_device *hidpp)
2854 struct k400_private_data *k400 = hidpp->private_data;
2860 ret = hidpp_root_get_feature(hidpp,
2868 ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items);
2877 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2885 hidpp->private_data = k400;
2892 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
2897 return k400_disable_tap_to_click(hidpp);
2906 static int g920_ff_set_autocenter(struct hidpp_device *hidpp,
2918 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2923 hid_warn(hidpp->hid_dev, "Failed to autocenter device!\n");
2930 static int g920_get_config(struct hidpp_device *hidpp,
2940 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_G920_FORCE_FEEDBACK,
2946 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2953 hid_err(hidpp->hid_dev,
2961 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2966 hid_warn(hidpp->hid_dev, "Failed to reset all forces!\n");
2968 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2973 hid_warn(hidpp->hid_dev,
2980 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
2985 hid_warn(hidpp->hid_dev,
2992 return g920_ff_set_autocenter(hidpp, data);
3018 static int hidpp10_wheel_connect(struct hidpp_device *hidpp)
3020 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3025 static int hidpp10_wheel_raw_event(struct hidpp_device *hidpp,
3030 if (!hidpp->input)
3042 input_report_rel(hidpp->input, REL_WHEEL, value);
3043 input_report_rel(hidpp->input, REL_WHEEL_HI_RES, value * 120);
3044 input_report_rel(hidpp->input, REL_HWHEEL, hvalue);
3045 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES, hvalue * 120);
3046 input_sync(hidpp->input);
3051 static void hidpp10_wheel_populate_input(struct hidpp_device *hidpp,
3064 static int hidpp10_extra_mouse_buttons_connect(struct hidpp_device *hidpp)
3066 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3071 static int hidpp10_extra_mouse_buttons_raw_event(struct hidpp_device *hidpp,
3076 if (!hidpp->input)
3093 input_report_key(hidpp->input, BTN_MOUSE + i,
3098 input_report_key(hidpp->input, BTN_MISC + i,
3101 input_sync(hidpp->input);
3106 struct hidpp_device *hidpp, struct input_dev *input_dev)
3124 static u8 *hidpp10_consumer_keys_report_fixup(struct hidpp_device *hidpp,
3152 static int hidpp10_consumer_keys_connect(struct hidpp_device *hidpp)
3154 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3159 static int hidpp10_consumer_keys_raw_event(struct hidpp_device *hidpp,
3178 hid_report_raw_event(hidpp->hid_dev, HID_INPUT_REPORT,
3188 static int hi_res_scroll_enable(struct hidpp_device *hidpp)
3193 if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_X2121) {
3194 ret = hidpp_hrw_set_wheel_mode(hidpp, false, true, false);
3196 ret = hidpp_hrw_get_wheel_capability(hidpp, &multiplier);
3197 } else if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_X2120) {
3198 ret = hidpp_hrs_set_highres_scrolling_mode(hidpp, true,
3200 } else /* if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_1P0) */ {
3201 ret = hidpp10_enable_scrolling_acceleration(hidpp);
3210 hidpp->vertical_wheel_counter.wheel_multiplier = multiplier;
3211 hid_dbg(hidpp->hid_dev, "wheel multiplier = %d\n", multiplier);
3222 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3224 if (!hidpp)
3229 (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS))
3230 rdesc = hidpp10_consumer_keys_report_fixup(hidpp, rdesc, rsize);
3239 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3241 if (!hidpp)
3244 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3246 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
3260 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3262 if (!hidpp)
3266 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3278 static void hidpp_populate_input(struct hidpp_device *hidpp,
3281 hidpp->input = input;
3283 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3284 wtp_populate_input(hidpp, input);
3285 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3286 m560_populate_input(hidpp, input);
3288 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS)
3289 hidpp10_wheel_populate_input(hidpp, input);
3291 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS)
3292 hidpp10_extra_mouse_buttons_populate_input(hidpp, input);
3298 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3301 if (!hidpp)
3304 hidpp_populate_input(hidpp, input);
3309 static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
3312 struct hidpp_report *question = hidpp->send_receive_buf;
3313 struct hidpp_report *answer = hidpp->send_receive_buf;
3321 if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
3329 hidpp->answer_available = true;
3330 wake_up(&hidpp->wait);
3341 if (unlikely(hidpp_report_is_connect_event(hidpp, report))) {
3342 atomic_set(&hidpp->connected,
3344 if (schedule_work(&hidpp->work) == 0)
3349 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3350 ret = hidpp20_battery_event(hidpp, data, size);
3353 ret = hidpp_solar_battery_event(hidpp, data, size);
3356 ret = hidpp20_battery_voltage_event(hidpp, data, size);
3361 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3362 ret = hidpp10_battery_event(hidpp, data, size);
3367 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3368 ret = hidpp10_wheel_raw_event(hidpp, data, size);
3373 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3374 ret = hidpp10_extra_mouse_buttons_raw_event(hidpp, data, size);
3379 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3380 ret = hidpp10_consumer_keys_raw_event(hidpp, data, size);
3391 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3394 if (!hidpp)
3400 if (size != hidpp->very_long_report_length) {
3405 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3413 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3421 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3430 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3432 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3444 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3447 if (!hidpp)
3450 counter = &hidpp->vertical_wheel_counter;
3456 if (!(hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL) || value == 0
3457 || hidpp->input == NULL || counter->wheel_multiplier == 0)
3460 hidpp_scroll_counter_handle_scroll(hidpp->input, counter, value);
3464 static int hidpp_initialize_battery(struct hidpp_device *hidpp)
3467 struct power_supply_config cfg = { .drv_data = hidpp };
3468 struct power_supply_desc *desc = &hidpp->battery.desc;
3475 if (hidpp->battery.ps)
3478 hidpp->battery.feature_index = 0xff;
3479 hidpp->battery.solar_feature_index = 0xff;
3480 hidpp->battery.voltage_feature_index = 0xff;
3482 if (hidpp->protocol_major >= 2) {
3483 if (hidpp->quirks & HIDPP_QUIRK_CLASS_K750)
3484 ret = hidpp_solar_request_battery_event(hidpp);
3486 ret = hidpp20_query_battery_voltage_info(hidpp);
3488 ret = hidpp20_query_battery_info(hidpp);
3493 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_BATTERY;
3495 ret = hidpp10_query_battery_status(hidpp);
3497 ret = hidpp10_query_battery_mileage(hidpp);
3500 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
3502 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
3504 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_BATTERY;
3507 battery_props = devm_kmemdup(&hidpp->hid_dev->dev,
3516 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
3520 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS)
3524 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
3528 battery = &hidpp->battery;
3539 battery->ps = devm_power_supply_register(&hidpp->hid_dev->dev,
3545 power_supply_powers(battery->ps, &hidpp->hid_dev->dev);
3552 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3555 if (hidpp->protocol_major < 2)
3558 name = hidpp_get_device_name(hidpp);
3587 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3596 input_dev->name = hidpp->name;
3608 static void hidpp_connect_event(struct hidpp_device *hidpp)
3610 struct hid_device *hdev = hidpp->hid_dev;
3612 bool connected = atomic_read(&hidpp->connected);
3617 if (hidpp->battery.ps) {
3618 hidpp->battery.online = false;
3619 hidpp->battery.status = POWER_SUPPLY_STATUS_UNKNOWN;
3620 hidpp->battery.level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
3621 power_supply_changed(hidpp->battery.ps);
3626 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
3630 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
3634 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
3640 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3641 ret = hidpp10_wheel_connect(hidpp);
3646 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3647 ret = hidpp10_extra_mouse_buttons_connect(hidpp);
3652 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3653 ret = hidpp10_consumer_keys_connect(hidpp);
3660 if (!hidpp->protocol_major) {
3661 ret = hidpp_root_get_protocol_version(hidpp);
3668 if (hidpp->protocol_major >= 2) {
3671 if (!hidpp_get_wireless_feature_index(hidpp, &feature_index))
3672 hidpp->wireless_feature_index = feature_index;
3675 if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
3676 name = hidpp_get_device_name(hidpp);
3684 hidpp->name = devm_name;
3688 hidpp_initialize_battery(hidpp);
3691 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3692 hidpp10_enable_battery_reporting(hidpp);
3693 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
3694 hidpp10_query_battery_mileage(hidpp);
3696 hidpp10_query_battery_status(hidpp);
3697 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3698 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
3699 hidpp20_query_battery_voltage_info(hidpp);
3701 hidpp20_query_battery_info(hidpp);
3703 if (hidpp->battery.ps)
3704 power_supply_changed(hidpp->battery.ps);
3706 if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL)
3707 hi_res_scroll_enable(hidpp);
3709 if (!(hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT) || hidpp->delayed_input)
3719 hidpp_populate_input(hidpp, input);
3725 hidpp->delayed_input = input;
3754 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3784 hidpp->very_long_report_length = report_length;
3790 hid_warn(hdev, "not enough values in hidpp report %d\n", id);
3807 struct hidpp_device *hidpp;
3814 hidpp = devm_kzalloc(&hdev->dev, sizeof(*hidpp), GFP_KERNEL);
3815 if (!hidpp)
3818 hidpp->hid_dev = hdev;
3819 hidpp->name = hdev->name;
3820 hidpp->quirks = id->driver_data;
3821 hid_set_drvdata(hdev, hidpp);
3832 hidpp->supported_reports = hidpp_validate_device(hdev);
3834 if (!hidpp->supported_reports) {
3836 devm_kfree(&hdev->dev, hidpp);
3841 hidpp->quirks |= HIDPP_QUIRK_UNIFYING;
3845 hidpp->quirks |= HIDPP_QUIRK_HIDPP_WHEELS |
3850 hidpp->quirks |= HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS;
3852 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
3856 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
3862 INIT_WORK(&hidpp->work, delayed_work_cb);
3863 mutex_init(&hidpp->send_mutex);
3864 init_waitqueue_head(&hidpp->wait);
3894 if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
3895 hidpp_unifying_init(hidpp);
3896 else if (hid_is_usb(hidpp->hid_dev))
3897 hidpp_serial_init(hidpp);
3899 connected = hidpp_root_get_protocol_version(hidpp) == 0;
3900 atomic_set(&hidpp->connected, connected);
3901 if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
3911 if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
3912 ret = wtp_get_config(hidpp);
3915 } else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
3916 ret = g920_get_config(hidpp, &data);
3921 schedule_work(&hidpp->work);
3922 flush_work(&hidpp->work);
3924 if (hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT)
3934 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3935 ret = hidpp_ff_init(hidpp, &data);
3937 hid_warn(hidpp->hid_dev,
3955 cancel_work_sync(&hidpp->work);
3956 mutex_destroy(&hidpp->send_mutex);
3962 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3964 if (!hidpp)
3970 cancel_work_sync(&hidpp->work);
3971 mutex_destroy(&hidpp->send_mutex);
4111 .name = "logitech-hidpp-device",