Lines Matching defs:hidpp
103 * There are two hidpp protocols in use, the first version hidpp10 is known
243 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
254 fields_count = hidpp->very_long_report_length;
266 if (hidpp->quirks & HIDPP_QUIRK_FORCE_OUTPUT_REPORTS) {
280 * Must be called with hidpp->send_mutex locked
287 static int __do_hidpp_send_message_sync(struct hidpp_device *hidpp,
293 __must_hold(&hidpp->send_mutex);
295 hidpp->send_receive_buf = response;
296 hidpp->answer_available = false;
304 ret = __hidpp_send_report(hidpp->hid_dev, message);
311 if (!wait_event_timeout(hidpp->wait, hidpp->answer_available,
321 dbg_hid("%s:got hidpp error %02X\n", __func__, ret);
329 dbg_hid("%s:got hidpp 2.0 error %02X\n", __func__, ret);
343 static int hidpp_send_message_sync(struct hidpp_device *hidpp,
350 mutex_lock(&hidpp->send_mutex);
353 ret = __do_hidpp_send_message_sync(hidpp, message, response);
357 dbg_hid("%s:got busy hidpp 2.0 error %02X, retrying\n", __func__, ret);
360 mutex_unlock(&hidpp->send_mutex);
372 static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp,
380 hid_dbg(hidpp->hid_dev,
399 ret = hidpp_send_message_sync(hidpp, message, response);
455 struct hidpp_device *hidpp = container_of(work, struct hidpp_device,
457 hidpp_connect_event(hidpp);
476 static inline bool hidpp_report_is_connect_event(struct hidpp_device *hidpp,
479 return (hidpp->wireless_feature_index &&
480 (report->fap.feature_index == hidpp->wireless_feature_index)) ||
516 static void hidpp_update_usb_wireless_status(struct hidpp_device *hidpp)
518 struct hid_device *hdev = hidpp->hid_dev;
521 if (!(hidpp->quirks & HIDPP_QUIRK_WIRELESS_STATUS))
527 usb_set_wireless_status(intf, hidpp->battery.online ?
724 static int hidpp10_query_battery_status(struct hidpp_device *hidpp)
729 ret = hidpp_send_rap_command_sync(hidpp,
737 hidpp->battery.level =
740 hidpp->battery.status = status;
742 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
776 static int hidpp10_query_battery_mileage(struct hidpp_device *hidpp)
781 ret = hidpp_send_rap_command_sync(hidpp,
789 hidpp->battery.capacity = response.rap.params[0];
791 hidpp->battery.status = status;
793 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
799 static int hidpp10_battery_event(struct hidpp_device *hidpp, u8 *data, int size)
810 capacity = hidpp->battery.capacity;
816 level = hidpp->battery.level;
823 changed = capacity != hidpp->battery.capacity ||
824 level != hidpp->battery.level ||
825 status != hidpp->battery.status;
828 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
832 hidpp->battery.level = level;
833 hidpp->battery.status = status;
834 if (hidpp->battery.ps)
835 power_supply_changed(hidpp->battery.ps);
881 static int hidpp_unifying_get_serial(struct hidpp_device *hidpp, u32 *serial)
887 ret = hidpp_send_rap_command_sync(hidpp,
903 static int hidpp_unifying_init(struct hidpp_device *hidpp)
905 struct hid_device *hdev = hidpp->hid_dev;
910 ret = hidpp_unifying_get_serial(hidpp, &serial);
917 name = hidpp_unifying_get_name(hidpp);
938 static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature,
945 ret = hidpp_send_fap_command_sync(hidpp,
961 static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp)
968 ret = hidpp_send_rap_command_sync(hidpp,
975 hidpp->protocol_major = 1;
976 hidpp->protocol_minor = 0;
985 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
993 hid_err(hidpp->hid_dev, "%s: ping mismatch 0x%02x != 0x%02x\n",
998 hidpp->protocol_major = response.rap.params[0];
999 hidpp->protocol_minor = response.rap.params[1];
1002 hid_info(hidpp->hid_dev, "HID++ %u.%u device connected.\n",
1003 hidpp->protocol_major, hidpp->protocol_minor);
1015 static int hidpp_get_serial(struct hidpp_device *hidpp, u32 *serial)
1022 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_DEVICE_INFORMATION,
1028 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1039 static int hidpp_serial_init(struct hidpp_device *hidpp)
1041 struct hid_device *hdev = hidpp->hid_dev;
1045 ret = hidpp_get_serial(hidpp, &serial);
1065 static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp,
1071 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1075 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1087 static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp,
1094 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1099 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1108 count = hidpp->very_long_report_length - 4;
1129 static char *hidpp_get_device_name(struct hidpp_device *hidpp)
1138 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE,
1143 ret = hidpp_devicenametype_get_count(hidpp, feature_index,
1153 ret = hidpp_devicenametype_get_device_name(hidpp,
1242 static int hidpp20_batterylevel_get_battery_capacity(struct hidpp_device *hidpp,
1253 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1260 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1274 static int hidpp20_batterylevel_get_battery_info(struct hidpp_device *hidpp,
1282 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1286 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1297 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1299 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
1304 static int hidpp20_query_battery_info_1000(struct hidpp_device *hidpp)
1310 if (hidpp->battery.feature_index == 0xff) {
1311 ret = hidpp_root_get_feature(hidpp,
1313 &hidpp->battery.feature_index,
1319 ret = hidpp20_batterylevel_get_battery_capacity(hidpp,
1320 hidpp->battery.feature_index,
1326 ret = hidpp20_batterylevel_get_battery_info(hidpp,
1327 hidpp->battery.feature_index);
1331 hidpp->battery.status = status;
1332 hidpp->battery.capacity = capacity;
1333 hidpp->battery.level = level;
1335 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1341 static int hidpp20_battery_event_1000(struct hidpp_device *hidpp,
1348 if (report->fap.feature_index != hidpp->battery.feature_index ||
1358 hidpp->battery.online = status == POWER_SUPPLY_STATUS_DISCHARGING ||
1361 changed = capacity != hidpp->battery.capacity ||
1362 level != hidpp->battery.level ||
1363 status != hidpp->battery.status;
1366 hidpp->battery.level = level;
1367 hidpp->battery.capacity = capacity;
1368 hidpp->battery.status = status;
1369 if (hidpp->battery.ps)
1370 power_supply_changed(hidpp->battery.ps);
1429 static int hidpp20_battery_get_battery_voltage(struct hidpp_device *hidpp,
1438 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1443 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1450 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_VOLTAGE;
1493 static int hidpp20_query_battery_voltage_info(struct hidpp_device *hidpp)
1499 if (hidpp->battery.voltage_feature_index == 0xff) {
1500 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_BATTERY_VOLTAGE,
1501 &hidpp->battery.voltage_feature_index,
1507 ret = hidpp20_battery_get_battery_voltage(hidpp,
1508 hidpp->battery.voltage_feature_index,
1514 hidpp->battery.status = status;
1515 hidpp->battery.voltage = voltage;
1516 hidpp->battery.capacity = hidpp20_map_battery_capacity(hidpp->hid_dev,
1518 hidpp->battery.level = level;
1519 hidpp->battery.charge_type = charge_type;
1520 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1525 static int hidpp20_battery_voltage_event(struct hidpp_device *hidpp,
1531 if (report->fap.feature_index != hidpp->battery.voltage_feature_index ||
1538 hidpp->battery.online = status != POWER_SUPPLY_STATUS_NOT_CHARGING;
1540 if (voltage != hidpp->battery.voltage || status != hidpp->battery.status) {
1541 hidpp->battery.voltage = voltage;
1542 hidpp->battery.capacity = hidpp20_map_battery_capacity(hidpp->hid_dev,
1544 hidpp->battery.status = status;
1545 hidpp->battery.level = level;
1546 hidpp->battery.charge_type = charge_type;
1547 if (hidpp->battery.ps)
1548 power_supply_changed(hidpp->battery.ps);
1572 static int hidpp20_unifiedbattery_get_capabilities(struct hidpp_device *hidpp,
1579 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS ||
1580 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE) {
1585 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1592 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1607 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_PERCENTAGE;
1608 hidpp->battery.supported_levels_1004 = 0;
1610 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
1611 hidpp->battery.supported_levels_1004 = params[0];
1617 static int hidpp20_unifiedbattery_map_status(struct hidpp_device *hidpp,
1636 hid_info(hidpp->hid_dev, "%s: charging error",
1637 hidpp->name);
1647 static int hidpp20_unifiedbattery_map_level(struct hidpp_device *hidpp,
1651 battery_level &= hidpp->battery.supported_levels_1004;
1665 static int hidpp20_unifiedbattery_get_status(struct hidpp_device *hidpp,
1675 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1682 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1690 *status = hidpp20_unifiedbattery_map_status(hidpp, params[2], params[3]);
1691 *level = hidpp20_unifiedbattery_map_level(hidpp, params[1]);
1696 static int hidpp20_query_battery_info_1004(struct hidpp_device *hidpp)
1703 if (hidpp->battery.feature_index == 0xff) {
1704 ret = hidpp_root_get_feature(hidpp,
1706 &hidpp->battery.feature_index,
1712 ret = hidpp20_unifiedbattery_get_capabilities(hidpp,
1713 hidpp->battery.feature_index);
1717 ret = hidpp20_unifiedbattery_get_status(hidpp,
1718 hidpp->battery.feature_index,
1725 hidpp->capabilities |= HIDPP_CAPABILITY_UNIFIED_BATTERY;
1726 hidpp->battery.capacity = state_of_charge;
1727 hidpp->battery.status = status;
1728 hidpp->battery.level = level;
1729 hidpp->battery.online = true;
1734 static int hidpp20_battery_event_1004(struct hidpp_device *hidpp,
1742 if (report->fap.feature_index != hidpp->battery.feature_index ||
1747 status = hidpp20_unifiedbattery_map_status(hidpp, params[2], params[3]);
1748 level = hidpp20_unifiedbattery_map_level(hidpp, params[1]);
1750 changed = status != hidpp->battery.status ||
1751 (state_of_charge != hidpp->battery.capacity &&
1752 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE) ||
1753 (level != hidpp->battery.level &&
1754 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS);
1757 hidpp->battery.capacity = state_of_charge;
1758 hidpp->battery.status = status;
1759 hidpp->battery.level = level;
1760 if (hidpp->battery.ps)
1761 power_supply_changed(hidpp->battery.ps);
1787 struct hidpp_device *hidpp = power_supply_get_drvdata(psy);
1792 val->intval = hidpp->battery.status;
1795 val->intval = hidpp->battery.capacity;
1798 val->intval = hidpp->battery.level;
1804 val->intval = hidpp->battery.online;
1807 if (!strncmp(hidpp->name, "Logitech ", 9))
1808 val->strval = hidpp->name + 9;
1810 val->strval = hidpp->name;
1816 val->strval = hidpp->hid_dev->uniq;
1820 val->intval = hidpp->battery.voltage * 1000;
1823 val->intval = hidpp->battery.charge_type;
1838 static int hidpp_get_wireless_feature_index(struct hidpp_device *hidpp, u8 *feature_index)
1843 ret = hidpp_root_get_feature(hidpp,
1932 static bool hidpp20_get_adc_measurement_1f20(struct hidpp_device *hidpp,
1942 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
1947 hid_dbg(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
1956 static int hidpp20_query_adc_measurement_info_1f20(struct hidpp_device *hidpp)
1960 if (hidpp->battery.adc_measurement_feature_index == 0xff) {
1963 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_ADC_MEASUREMENT,
1964 &hidpp->battery.adc_measurement_feature_index,
1969 hidpp->capabilities |= HIDPP_CAPABILITY_ADC_MEASUREMENT;
1972 hidpp->battery.online = hidpp20_get_adc_measurement_1f20(hidpp,
1973 hidpp->battery.adc_measurement_feature_index,
1974 &hidpp->battery.status,
1975 &hidpp->battery.voltage);
1976 hidpp->battery.capacity = hidpp20_map_adc_measurement_1f20_capacity(hidpp->hid_dev,
1977 hidpp->battery.voltage);
1978 hidpp_update_usb_wireless_status(hidpp);
1983 static int hidpp20_adc_measurement_event_1f20(struct hidpp_device *hidpp,
1989 if (report->fap.feature_index != hidpp->battery.adc_measurement_feature_index ||
1995 hidpp->battery.online = status != POWER_SUPPLY_STATUS_UNKNOWN;
1997 if (voltage != hidpp->battery.voltage || status != hidpp->battery.status) {
1998 hidpp->battery.status = status;
1999 hidpp->battery.voltage = voltage;
2000 hidpp->battery.capacity = hidpp20_map_adc_measurement_1f20_capacity(hidpp->hid_dev, voltage);
2001 if (hidpp->battery.ps)
2002 power_supply_changed(hidpp->battery.ps);
2003 hidpp_update_usb_wireless_status(hidpp);
2016 static int hidpp_hrs_set_highres_scrolling_mode(struct hidpp_device *hidpp,
2025 ret = hidpp_root_get_feature(hidpp,
2033 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2051 static int hidpp_hrw_get_wheel_capability(struct hidpp_device *hidpp,
2059 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
2064 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2073 hid_warn(hidpp->hid_dev,
2078 static int hidpp_hrw_set_wheel_mode(struct hidpp_device *hidpp, bool invert,
2087 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
2096 return hidpp_send_fap_command_sync(hidpp, feature_index,
2113 static int hidpp_solar_request_battery_event(struct hidpp_device *hidpp)
2120 if (hidpp->battery.feature_index == 0xff) {
2121 ret = hidpp_root_get_feature(hidpp,
2123 &hidpp->battery.solar_feature_index,
2129 ret = hidpp_send_fap_command_sync(hidpp,
2130 hidpp->battery.solar_feature_index,
2134 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2141 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
2146 static int hidpp_solar_battery_event(struct hidpp_device *hidpp,
2156 if (report->fap.feature_index != hidpp->battery.solar_feature_index ||
2174 if (capacity < hidpp->battery.capacity)
2184 hidpp->battery.online = true;
2185 if (capacity != hidpp->battery.capacity ||
2186 status != hidpp->battery.status) {
2187 hidpp->battery.capacity = capacity;
2188 hidpp->battery.status = status;
2189 if (hidpp->battery.ps)
2190 power_supply_changed(hidpp->battery.ps);
2215 static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp,
2223 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2227 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2286 static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp,
2293 ret = hidpp_send_fap_command_sync(hidpp, feature_index,
2297 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n",
2410 struct hidpp_device *hidpp;
2502 ret = hidpp_send_fap_command_sync(data->hidpp, data->feature_index,
2506 hid_err(data->hidpp->hid_dev, "Failed to send command to device!\n");
2568 hid_warn(data->hidpp->hid_dev, "Force feedback command queue contains %d commands, causing substantial delays!", s);
2627 hid_err(data->hidpp->hid_dev, "Unexpected periodic waveform type %i!\n", effect->u.periodic.waveform);
2712 hid_err(data->hidpp->hid_dev, "Unexpected force type %i!\n", effect->type);
2812 struct hid_device *hid = data->hidpp->hid_dev;
2821 static int hidpp_ff_init(struct hidpp_device *hidpp,
2824 struct hid_device *hid = hidpp->hid_dev;
2880 data->wq = create_singlethread_workqueue("hidpp-ff-sendqueue");
2887 data->hidpp = hidpp;
2903 error = device_create_file(&(hidpp->hid_dev->dev), &dev_attr_range);
2905 hid_warn(hidpp->hid_dev, "Unable to create sysfs interface for \"range\", errno %d!\n", error);
2945 static void wtp_populate_input(struct hidpp_device *hidpp,
2948 struct wtp_data *wd = hidpp->private_data;
2965 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)
2974 static void wtp_touch_event(struct hidpp_device *hidpp,
2977 struct wtp_data *wd = hidpp->private_data;
2984 slot = input_mt_get_slot_by_key(hidpp->input, touch_report->finger_id);
2986 input_mt_slot(hidpp->input, slot);
2987 input_mt_report_slot_state(hidpp->input, MT_TOOL_FINGER,
2990 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_X,
2992 input_event(hidpp->input, EV_ABS, ABS_MT_POSITION_Y,
2995 input_event(hidpp->input, EV_ABS, ABS_MT_PRESSURE,
3000 static void wtp_send_raw_xy_event(struct hidpp_device *hidpp,
3006 wtp_touch_event(hidpp, &(raw->fingers[i]));
3009 !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS))
3010 input_event(hidpp->input, EV_KEY, BTN_LEFT, raw->button);
3013 input_mt_sync_frame(hidpp->input);
3014 input_sync(hidpp->input);
3018 static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data)
3020 struct wtp_data *wd = hidpp->private_data;
3052 wtp_send_raw_xy_event(hidpp, &raw);
3059 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3060 struct wtp_data *wd = hidpp->private_data;
3064 if (!wd || !hidpp->input)
3074 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) {
3075 input_event(hidpp->input, EV_KEY, BTN_LEFT,
3077 input_event(hidpp->input, EV_KEY, BTN_RIGHT,
3079 input_sync(hidpp->input);
3084 return wtp_mouse_raw_xy_event(hidpp, &data[7]);
3091 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw);
3093 wtp_send_raw_xy_event(hidpp, &raw);
3100 static int wtp_get_config(struct hidpp_device *hidpp)
3102 struct wtp_data *wd = hidpp->private_data;
3107 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY,
3113 ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index,
3131 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3139 hidpp->private_data = wd;
3146 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3147 struct wtp_data *wd = hidpp->private_data;
3151 ret = wtp_get_config(hidpp);
3158 return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index,
3226 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3229 if (!hidpp->input) {
3256 input_report_key(hidpp->input, BTN_MIDDLE, 1);
3259 input_report_key(hidpp->input, BTN_FORWARD, 1);
3262 input_report_key(hidpp->input, BTN_BACK, 1);
3265 input_report_key(hidpp->input, BTN_BACK, 0);
3266 input_report_key(hidpp->input, BTN_FORWARD, 0);
3267 input_report_key(hidpp->input, BTN_MIDDLE, 0);
3273 input_sync(hidpp->input);
3287 input_report_key(hidpp->input, BTN_LEFT,
3289 input_report_key(hidpp->input, BTN_RIGHT,
3293 input_report_rel(hidpp->input, REL_HWHEEL, -1);
3294 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
3297 input_report_rel(hidpp->input, REL_HWHEEL, 1);
3298 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES,
3303 input_report_rel(hidpp->input, REL_X, v);
3306 input_report_rel(hidpp->input, REL_Y, v);
3310 hidpp_scroll_counter_handle_scroll(hidpp->input,
3311 &hidpp->vertical_wheel_counter, v);
3313 input_sync(hidpp->input);
3319 static void m560_populate_input(struct hidpp_device *hidpp,
3363 static int k400_disable_tap_to_click(struct hidpp_device *hidpp)
3365 struct k400_private_data *k400 = hidpp->private_data;
3371 ret = hidpp_root_get_feature(hidpp,
3379 ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items);
3388 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3396 hidpp->private_data = k400;
3403 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3408 return k400_disable_tap_to_click(hidpp);
3417 static int g920_ff_set_autocenter(struct hidpp_device *hidpp,
3429 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3434 hid_warn(hidpp->hid_dev, "Failed to autocenter device!\n");
3441 static int g920_get_config(struct hidpp_device *hidpp,
3451 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_G920_FORCE_FEEDBACK,
3457 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3464 hid_err(hidpp->hid_dev,
3472 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3477 hid_warn(hidpp->hid_dev, "Failed to reset all forces!\n");
3479 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3484 hid_warn(hidpp->hid_dev,
3491 ret = hidpp_send_fap_command_sync(hidpp, data->feature_index,
3496 hid_warn(hidpp->hid_dev,
3503 return g920_ff_set_autocenter(hidpp, data);
3529 static int hidpp10_wheel_connect(struct hidpp_device *hidpp)
3531 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3536 static int hidpp10_wheel_raw_event(struct hidpp_device *hidpp,
3541 if (!hidpp->input)
3553 input_report_rel(hidpp->input, REL_WHEEL, value);
3554 input_report_rel(hidpp->input, REL_WHEEL_HI_RES, value * 120);
3555 input_report_rel(hidpp->input, REL_HWHEEL, hvalue);
3556 input_report_rel(hidpp->input, REL_HWHEEL_HI_RES, hvalue * 120);
3557 input_sync(hidpp->input);
3562 static void hidpp10_wheel_populate_input(struct hidpp_device *hidpp,
3575 static int hidpp10_extra_mouse_buttons_connect(struct hidpp_device *hidpp)
3577 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3582 static int hidpp10_extra_mouse_buttons_raw_event(struct hidpp_device *hidpp,
3587 if (!hidpp->input)
3604 input_report_key(hidpp->input, BTN_MOUSE + i,
3609 input_report_key(hidpp->input, BTN_MISC + i,
3612 input_sync(hidpp->input);
3617 struct hidpp_device *hidpp, struct input_dev *input_dev)
3635 static u8 *hidpp10_consumer_keys_report_fixup(struct hidpp_device *hidpp,
3663 static int hidpp10_consumer_keys_connect(struct hidpp_device *hidpp)
3665 return hidpp10_set_register(hidpp, HIDPP_REG_ENABLE_REPORTS, 0,
3670 static int hidpp10_consumer_keys_raw_event(struct hidpp_device *hidpp,
3689 hid_report_raw_event(hidpp->hid_dev, HID_INPUT_REPORT,
3699 static int hi_res_scroll_enable(struct hidpp_device *hidpp)
3704 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL) {
3705 ret = hidpp_hrw_set_wheel_mode(hidpp, false, true, false);
3707 ret = hidpp_hrw_get_wheel_capability(hidpp, &multiplier);
3708 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL) {
3709 ret = hidpp_hrs_set_highres_scrolling_mode(hidpp, true,
3711 } else /* if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL) */ {
3712 ret = hidpp10_enable_scrolling_acceleration(hidpp);
3716 hid_dbg(hidpp->hid_dev,
3722 hid_dbg(hidpp->hid_dev,
3727 hidpp->vertical_wheel_counter.wheel_multiplier = multiplier;
3728 hid_dbg(hidpp->hid_dev, "wheel multiplier = %d\n", multiplier);
3732 static int hidpp_initialize_hires_scroll(struct hidpp_device *hidpp)
3737 capabilities = hidpp->capabilities;
3739 if (hidpp->protocol_major >= 2) {
3743 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HIRES_WHEEL,
3746 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_HI_RES_WHEEL;
3747 hid_dbg(hidpp->hid_dev, "Detected HID++ 2.0 hi-res scroll wheel\n");
3750 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_HI_RESOLUTION_SCROLLING,
3753 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_HI_RES_SCROLL;
3754 hid_dbg(hidpp->hid_dev, "Detected HID++ 2.0 hi-res scrolling\n");
3758 if (hidpp->quirks & HIDPP_QUIRK_HI_RES_SCROLL_1P0) {
3759 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_FAST_SCROLL;
3760 hid_dbg(hidpp->hid_dev, "Detected HID++ 1.0 fast scroll\n");
3764 if (hidpp->capabilities == capabilities)
3765 hid_dbg(hidpp->hid_dev, "Did not detect HID++ hi-res scrolling hardware support\n");
3776 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3778 if (!hidpp)
3783 (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS))
3784 rdesc = hidpp10_consumer_keys_report_fixup(hidpp, rdesc, rsize);
3793 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3795 if (!hidpp)
3798 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3800 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 &&
3814 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3816 if (!hidpp)
3820 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
3832 static void hidpp_populate_input(struct hidpp_device *hidpp,
3835 hidpp->input = input;
3837 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
3838 wtp_populate_input(hidpp, input);
3839 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
3840 m560_populate_input(hidpp, input);
3842 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS)
3843 hidpp10_wheel_populate_input(hidpp, input);
3845 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS)
3846 hidpp10_extra_mouse_buttons_populate_input(hidpp, input);
3852 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3855 if (!hidpp)
3858 hidpp_populate_input(hidpp, input);
3863 static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data,
3866 struct hidpp_report *question = hidpp->send_receive_buf;
3867 struct hidpp_report *answer = hidpp->send_receive_buf;
3875 if (unlikely(mutex_is_locked(&hidpp->send_mutex))) {
3883 hidpp->answer_available = true;
3884 wake_up(&hidpp->wait);
3895 if (unlikely(hidpp_report_is_connect_event(hidpp, report))) {
3896 atomic_set(&hidpp->connected,
3898 if (schedule_work(&hidpp->work) == 0)
3903 if (hidpp->hid_dev->group == HID_GROUP_LOGITECH_27MHZ_DEVICE &&
3907 dev_err_ratelimited(&hidpp->hid_dev->dev,
3909 dev_err_ratelimited(&hidpp->hid_dev->dev,
3913 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
3914 ret = hidpp20_battery_event_1000(hidpp, data, size);
3917 ret = hidpp20_battery_event_1004(hidpp, data, size);
3920 ret = hidpp_solar_battery_event(hidpp, data, size);
3923 ret = hidpp20_battery_voltage_event(hidpp, data, size);
3926 ret = hidpp20_adc_measurement_event_1f20(hidpp, data, size);
3931 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
3932 ret = hidpp10_battery_event(hidpp, data, size);
3937 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
3938 ret = hidpp10_wheel_raw_event(hidpp, data, size);
3943 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
3944 ret = hidpp10_extra_mouse_buttons_raw_event(hidpp, data, size);
3949 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
3950 ret = hidpp10_consumer_keys_raw_event(hidpp, data, size);
3961 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
3964 if (!hidpp)
3970 if (size != hidpp->very_long_report_length) {
3975 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3983 ret = hidpp_raw_hidpp_event(hidpp, data, size);
3991 ret = hidpp_raw_hidpp_event(hidpp, data, size);
4000 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)
4002 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560)
4014 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4017 if (!hidpp)
4020 counter = &hidpp->vertical_wheel_counter;
4026 if (!(hidpp->capabilities & HIDPP_CAPABILITY_HI_RES_SCROLL)
4027 || value == 0 || hidpp->input == NULL
4031 hidpp_scroll_counter_handle_scroll(hidpp->input, counter, value);
4035 static int hidpp_initialize_battery(struct hidpp_device *hidpp)
4038 struct power_supply_config cfg = { .drv_data = hidpp };
4039 struct power_supply_desc *desc = &hidpp->battery.desc;
4046 if (hidpp->battery.ps)
4049 hidpp->battery.feature_index = 0xff;
4050 hidpp->battery.solar_feature_index = 0xff;
4051 hidpp->battery.voltage_feature_index = 0xff;
4052 hidpp->battery.adc_measurement_feature_index = 0xff;
4054 if (hidpp->protocol_major >= 2) {
4055 if (hidpp->quirks & HIDPP_QUIRK_CLASS_K750)
4056 ret = hidpp_solar_request_battery_event(hidpp);
4061 ret = hidpp20_query_battery_info_1000(hidpp);
4063 ret = hidpp20_query_battery_info_1004(hidpp);
4065 ret = hidpp20_query_battery_voltage_info(hidpp);
4067 ret = hidpp20_query_adc_measurement_info_1f20(hidpp);
4072 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP20_BATTERY;
4074 ret = hidpp10_query_battery_status(hidpp);
4076 ret = hidpp10_query_battery_mileage(hidpp);
4079 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_MILEAGE;
4081 hidpp->capabilities |= HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS;
4083 hidpp->capabilities |= HIDPP_CAPABILITY_HIDPP10_BATTERY;
4086 battery_props = devm_kmemdup(&hidpp->hid_dev->dev,
4095 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE ||
4096 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_PERCENTAGE ||
4097 hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE ||
4098 hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4102 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_LEVEL_STATUS)
4106 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE ||
4107 hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4111 battery = &hidpp->battery;
4122 battery->ps = devm_power_supply_register(&hidpp->hid_dev->dev,
4128 power_supply_powers(battery->ps, &hidpp->hid_dev->dev);
4135 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4138 if (hidpp->protocol_major < 2)
4141 name = hidpp_get_device_name(hidpp);
4170 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4179 input_dev->name = hidpp->name;
4191 static void hidpp_connect_event(struct hidpp_device *hidpp)
4193 struct hid_device *hdev = hidpp->hid_dev;
4195 bool connected = atomic_read(&hidpp->connected);
4200 if (hidpp->battery.ps) {
4201 hidpp->battery.online = false;
4202 hidpp->battery.status = POWER_SUPPLY_STATUS_UNKNOWN;
4203 hidpp->battery.level = POWER_SUPPLY_CAPACITY_LEVEL_UNKNOWN;
4204 power_supply_changed(hidpp->battery.ps);
4209 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
4213 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) {
4217 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
4223 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_WHEELS) {
4224 ret = hidpp10_wheel_connect(hidpp);
4229 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_EXTRA_MOUSE_BTNS) {
4230 ret = hidpp10_extra_mouse_buttons_connect(hidpp);
4235 if (hidpp->quirks & HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS) {
4236 ret = hidpp10_consumer_keys_connect(hidpp);
4243 if (!hidpp->protocol_major) {
4244 ret = hidpp_root_get_protocol_version(hidpp);
4251 if (hidpp->protocol_major >= 2) {
4254 if (!hidpp_get_wireless_feature_index(hidpp, &feature_index))
4255 hidpp->wireless_feature_index = feature_index;
4258 if (hidpp->name == hdev->name && hidpp->protocol_major >= 2) {
4259 name = hidpp_get_device_name(hidpp);
4267 hidpp->name = devm_name;
4271 hidpp_initialize_battery(hidpp);
4272 if (!hid_is_usb(hidpp->hid_dev))
4273 hidpp_initialize_hires_scroll(hidpp);
4276 if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP10_BATTERY) {
4277 hidpp10_enable_battery_reporting(hidpp);
4278 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_MILEAGE)
4279 hidpp10_query_battery_mileage(hidpp);
4281 hidpp10_query_battery_status(hidpp);
4282 } else if (hidpp->capabilities & HIDPP_CAPABILITY_HIDPP20_BATTERY) {
4283 if (hidpp->capabilities & HIDPP_CAPABILITY_BATTERY_VOLTAGE)
4284 hidpp20_query_battery_voltage_info(hidpp);
4285 else if (hidpp->capabilities & HIDPP_CAPABILITY_UNIFIED_BATTERY)
4286 hidpp20_query_battery_info_1004(hidpp);
4287 else if (hidpp->capabilities & HIDPP_CAPABILITY_ADC_MEASUREMENT)
4288 hidpp20_query_adc_measurement_info_1f20(hidpp);
4290 hidpp20_query_battery_info_1000(hidpp);
4292 if (hidpp->battery.ps)
4293 power_supply_changed(hidpp->battery.ps);
4295 if (hidpp->capabilities & HIDPP_CAPABILITY_HI_RES_SCROLL)
4296 hi_res_scroll_enable(hidpp);
4298 if (!(hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT) || hidpp->delayed_input)
4308 hidpp_populate_input(hidpp, input);
4316 hidpp->delayed_input = input;
4345 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4375 hidpp->very_long_report_length = report_length;
4381 hid_warn(hdev, "not enough values in hidpp report %d\n", id);
4398 struct hidpp_device *hidpp;
4405 hidpp = devm_kzalloc(&hdev->dev, sizeof(*hidpp), GFP_KERNEL);
4406 if (!hidpp)
4409 hidpp->hid_dev = hdev;
4410 hidpp->name = hdev->name;
4411 hidpp->quirks = id->driver_data;
4412 hid_set_drvdata(hdev, hidpp);
4423 hidpp->supported_reports = hidpp_validate_device(hdev);
4425 if (!hidpp->supported_reports) {
4427 devm_kfree(&hdev->dev, hidpp);
4432 hidpp->quirks |= HIDPP_QUIRK_UNIFYING;
4436 hidpp->quirks |= HIDPP_QUIRK_HIDPP_WHEELS |
4441 hidpp->quirks |= HIDPP_QUIRK_HIDPP_CONSUMER_VENDOR_KEYS;
4443 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) {
4447 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) {
4453 INIT_WORK(&hidpp->work, delayed_work_cb);
4454 mutex_init(&hidpp->send_mutex);
4455 init_waitqueue_head(&hidpp->wait);
4485 if (hidpp->quirks & HIDPP_QUIRK_UNIFYING)
4486 hidpp_unifying_init(hidpp);
4487 else if (hid_is_usb(hidpp->hid_dev))
4488 hidpp_serial_init(hidpp);
4490 connected = hidpp_root_get_protocol_version(hidpp) == 0;
4491 atomic_set(&hidpp->connected, connected);
4492 if (!(hidpp->quirks & HIDPP_QUIRK_UNIFYING)) {
4502 if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) {
4503 ret = wtp_get_config(hidpp);
4506 } else if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_G920)) {
4507 ret = g920_get_config(hidpp, &data);
4512 schedule_work(&hidpp->work);
4513 flush_work(&hidpp->work);
4515 if (hidpp->quirks & HIDPP_QUIRK_DELAYED_INIT)
4525 if (hidpp->quirks & HIDPP_QUIRK_CLASS_G920) {
4526 ret = hidpp_ff_init(hidpp, &data);
4528 hid_warn(hidpp->hid_dev,
4546 cancel_work_sync(&hidpp->work);
4547 mutex_destroy(&hidpp->send_mutex);
4553 struct hidpp_device *hidpp = hid_get_drvdata(hdev);
4555 if (!hidpp)
4561 cancel_work_sync(&hidpp->work);
4562 mutex_destroy(&hidpp->send_mutex);
4699 .name = "logitech-hidpp-device",