Commit e195ca6c authored by Linus Torvalds's avatar Linus Torvalds

Merge branch 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid

Pull HID fixes from Jiri Kosina:

 - revert of the high-resolution scrolling feature, as it breaks certain
   hardware due to incompatibilities between Logitech and Microsoft
   worlds. Peter Hutterer is working on a fixed implementation. Until
   that is finished, revert by Benjamin Tissoires.

 - revert of incorrect strncpy->strlcpy conversion in uhid, from David
   Herrmann

 - fix for buggy sendfile() implementation on uhid device node, from
   Eric Biggers

 - a few assorted device-ID specific quirks

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/hid/hid:
  Revert "Input: Add the `REL_WHEEL_HI_RES` event code"
  Revert "HID: input: Create a utility class for counting scroll events"
  Revert "HID: logitech: Add function to enable HID++ 1.0 "scrolling acceleration""
  Revert "HID: logitech: Enable high-resolution scrolling on Logitech mice"
  Revert "HID: logitech: Use LDJ_DEVICE macro for existing Logitech mice"
  Revert "HID: logitech: fix a used uninitialized GCC warning"
  Revert "HID: input: simplify/fix high-res scroll event handling"
  HID: Add quirk for Primax PIXART OEM mice
  HID: i2c-hid: Disable runtime PM for LG touchscreen
  HID: multitouch: Add pointstick support for Cirque Touchpad
  HID: steam: remove input device when a hid client is running.
  Revert "HID: uhid: use strlcpy() instead of strncpy()"
  HID: uhid: forbid UHID_CREATE under KERNEL_DS or elevated privileges
  HID: input: Ignore battery reported by Symbol DS4308
  HID: Add quirk for Microsoft PIXART OEM mouse
parents d146194f ffe0e7cf
...@@ -190,16 +190,7 @@ A few EV_REL codes have special meanings: ...@@ -190,16 +190,7 @@ A few EV_REL codes have special meanings:
* REL_WHEEL, REL_HWHEEL: * REL_WHEEL, REL_HWHEEL:
- These codes are used for vertical and horizontal scroll wheels, - These codes are used for vertical and horizontal scroll wheels,
respectively. The value is the number of "notches" moved on the wheel, the respectively.
physical size of which varies by device. For high-resolution wheels (which
report multiple events for each notch of movement, or do not have notches)
this may be an approximation based on the high-resolution scroll events.
* REL_WHEEL_HI_RES:
- If a vertical scroll wheel supports high-resolution scrolling, this code
will be emitted in addition to REL_WHEEL. The value is the (approximate)
distance travelled by the user's finger, in microns.
EV_ABS EV_ABS
------ ------
......
...@@ -275,6 +275,9 @@ ...@@ -275,6 +275,9 @@
#define USB_VENDOR_ID_CIDC 0x1677 #define USB_VENDOR_ID_CIDC 0x1677
#define I2C_VENDOR_ID_CIRQUE 0x0488
#define I2C_PRODUCT_ID_CIRQUE_121F 0x121F
#define USB_VENDOR_ID_CJTOUCH 0x24b8 #define USB_VENDOR_ID_CJTOUCH 0x24b8
#define USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020 0x0020 #define USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0020 0x0020
#define USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040 0x0040 #define USB_DEVICE_ID_CJTOUCH_MULTI_TOUCH_0040 0x0040
...@@ -707,6 +710,7 @@ ...@@ -707,6 +710,7 @@
#define USB_VENDOR_ID_LG 0x1fd2 #define USB_VENDOR_ID_LG 0x1fd2
#define USB_DEVICE_ID_LG_MULTITOUCH 0x0064 #define USB_DEVICE_ID_LG_MULTITOUCH 0x0064
#define USB_DEVICE_ID_LG_MELFAS_MT 0x6007 #define USB_DEVICE_ID_LG_MELFAS_MT 0x6007
#define I2C_DEVICE_ID_LG_8001 0x8001
#define USB_VENDOR_ID_LOGITECH 0x046d #define USB_VENDOR_ID_LOGITECH 0x046d
#define USB_DEVICE_ID_LOGITECH_AUDIOHUB 0x0a0e #define USB_DEVICE_ID_LOGITECH_AUDIOHUB 0x0a0e
...@@ -805,6 +809,7 @@ ...@@ -805,6 +809,7 @@
#define USB_DEVICE_ID_MS_TYPE_COVER_2 0x07a9 #define USB_DEVICE_ID_MS_TYPE_COVER_2 0x07a9
#define USB_DEVICE_ID_MS_POWER_COVER 0x07da #define USB_DEVICE_ID_MS_POWER_COVER 0x07da
#define USB_DEVICE_ID_MS_XBOX_ONE_S_CONTROLLER 0x02fd #define USB_DEVICE_ID_MS_XBOX_ONE_S_CONTROLLER 0x02fd
#define USB_DEVICE_ID_MS_PIXART_MOUSE 0x00cb
#define USB_VENDOR_ID_MOJO 0x8282 #define USB_VENDOR_ID_MOJO 0x8282
#define USB_DEVICE_ID_RETRO_ADAPTER 0x3201 #define USB_DEVICE_ID_RETRO_ADAPTER 0x3201
...@@ -1043,6 +1048,7 @@ ...@@ -1043,6 +1048,7 @@
#define USB_VENDOR_ID_SYMBOL 0x05e0 #define USB_VENDOR_ID_SYMBOL 0x05e0
#define USB_DEVICE_ID_SYMBOL_SCANNER_1 0x0800 #define USB_DEVICE_ID_SYMBOL_SCANNER_1 0x0800
#define USB_DEVICE_ID_SYMBOL_SCANNER_2 0x1300 #define USB_DEVICE_ID_SYMBOL_SCANNER_2 0x1300
#define USB_DEVICE_ID_SYMBOL_SCANNER_3 0x1200
#define USB_VENDOR_ID_SYNAPTICS 0x06cb #define USB_VENDOR_ID_SYNAPTICS 0x06cb
#define USB_DEVICE_ID_SYNAPTICS_TP 0x0001 #define USB_DEVICE_ID_SYNAPTICS_TP 0x0001
...@@ -1204,6 +1210,8 @@ ...@@ -1204,6 +1210,8 @@
#define USB_DEVICE_ID_PRIMAX_MOUSE_4D22 0x4d22 #define USB_DEVICE_ID_PRIMAX_MOUSE_4D22 0x4d22
#define USB_DEVICE_ID_PRIMAX_KEYBOARD 0x4e05 #define USB_DEVICE_ID_PRIMAX_KEYBOARD 0x4e05
#define USB_DEVICE_ID_PRIMAX_REZEL 0x4e72 #define USB_DEVICE_ID_PRIMAX_REZEL 0x4e72
#define USB_DEVICE_ID_PRIMAX_PIXART_MOUSE_4D0F 0x4d0f
#define USB_DEVICE_ID_PRIMAX_PIXART_MOUSE_4E22 0x4e22
#define USB_VENDOR_ID_RISO_KAGAKU 0x1294 /* Riso Kagaku Corp. */ #define USB_VENDOR_ID_RISO_KAGAKU 0x1294 /* Riso Kagaku Corp. */
......
...@@ -325,6 +325,9 @@ static const struct hid_device_id hid_battery_quirks[] = { ...@@ -325,6 +325,9 @@ static const struct hid_device_id hid_battery_quirks[] = {
{ HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM, { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ELECOM,
USB_DEVICE_ID_ELECOM_BM084), USB_DEVICE_ID_ELECOM_BM084),
HID_BATTERY_QUIRK_IGNORE }, HID_BATTERY_QUIRK_IGNORE },
{ HID_USB_DEVICE(USB_VENDOR_ID_SYMBOL,
USB_DEVICE_ID_SYMBOL_SCANNER_3),
HID_BATTERY_QUIRK_IGNORE },
{} {}
}; };
...@@ -1838,47 +1841,3 @@ void hidinput_disconnect(struct hid_device *hid) ...@@ -1838,47 +1841,3 @@ void hidinput_disconnect(struct hid_device *hid)
} }
EXPORT_SYMBOL_GPL(hidinput_disconnect); EXPORT_SYMBOL_GPL(hidinput_disconnect);
/**
* hid_scroll_counter_handle_scroll() - Send high- and low-resolution scroll
* events given a high-resolution wheel
* movement.
* @counter: a hid_scroll_counter struct describing the wheel.
* @hi_res_value: the movement of the wheel, in the mouse's high-resolution
* units.
*
* Given a high-resolution movement, this function converts the movement into
* microns and emits high-resolution scroll events for the input device. It also
* uses the multiplier from &struct hid_scroll_counter to emit low-resolution
* scroll events when appropriate for backwards-compatibility with userspace
* input libraries.
*/
void hid_scroll_counter_handle_scroll(struct hid_scroll_counter *counter,
int hi_res_value)
{
int low_res_value, remainder, multiplier;
input_report_rel(counter->dev, REL_WHEEL_HI_RES,
hi_res_value * counter->microns_per_hi_res_unit);
/*
* Update the low-res remainder with the high-res value,
* but reset if the direction has changed.
*/
remainder = counter->remainder;
if ((remainder ^ hi_res_value) < 0)
remainder = 0;
remainder += hi_res_value;
/*
* Then just use the resolution multiplier to see if
* we should send a low-res (aka regular wheel) event.
*/
multiplier = counter->resolution_multiplier;
low_res_value = remainder / multiplier;
remainder -= low_res_value * multiplier;
counter->remainder = remainder;
if (low_res_value)
input_report_rel(counter->dev, REL_WHEEL, low_res_value);
}
EXPORT_SYMBOL_GPL(hid_scroll_counter_handle_scroll);
This diff is collapsed.
...@@ -1814,6 +1814,12 @@ static const struct hid_device_id mt_devices[] = { ...@@ -1814,6 +1814,12 @@ static const struct hid_device_id mt_devices[] = {
MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT, MT_USB_DEVICE(USB_VENDOR_ID_CHUNGHWAT,
USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) }, USB_DEVICE_ID_CHUNGHWAT_MULTITOUCH) },
/* Cirque devices */
{ .driver_data = MT_CLS_WIN_8_DUAL,
HID_DEVICE(BUS_I2C, HID_GROUP_MULTITOUCH_WIN_8,
I2C_VENDOR_ID_CIRQUE,
I2C_PRODUCT_ID_CIRQUE_121F) },
/* CJTouch panels */ /* CJTouch panels */
{ .driver_data = MT_CLS_NSMU, { .driver_data = MT_CLS_NSMU,
MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH, MT_USB_DEVICE(USB_VENDOR_ID_CJTOUCH,
......
...@@ -107,6 +107,7 @@ static const struct hid_device_id hid_quirks[] = { ...@@ -107,6 +107,7 @@ static const struct hid_device_id hid_quirks[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOUSE_C05A), HID_QUIRK_ALWAYS_POLL }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOUSE_C05A), HID_QUIRK_ALWAYS_POLL },
{ HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOUSE_C06A), HID_QUIRK_ALWAYS_POLL }, { HID_USB_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_LOGITECH_MOUSE_C06A), HID_QUIRK_ALWAYS_POLL },
{ HID_USB_DEVICE(USB_VENDOR_ID_MCS, USB_DEVICE_ID_MCS_GAMEPADBLOCK), HID_QUIRK_MULTI_INPUT }, { HID_USB_DEVICE(USB_VENDOR_ID_MCS, USB_DEVICE_ID_MCS_GAMEPADBLOCK), HID_QUIRK_MULTI_INPUT },
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_PIXART_MOUSE), HID_QUIRK_ALWAYS_POLL },
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER), HID_QUIRK_NO_INIT_REPORTS }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_POWER_COVER), HID_QUIRK_NO_INIT_REPORTS },
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_SURFACE_PRO_2), HID_QUIRK_NO_INIT_REPORTS }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_SURFACE_PRO_2), HID_QUIRK_NO_INIT_REPORTS },
{ HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2), HID_QUIRK_NO_INIT_REPORTS }, { HID_USB_DEVICE(USB_VENDOR_ID_MICROSOFT, USB_DEVICE_ID_MS_TOUCH_COVER_2), HID_QUIRK_NO_INIT_REPORTS },
...@@ -129,6 +130,8 @@ static const struct hid_device_id hid_quirks[] = { ...@@ -129,6 +130,8 @@ static const struct hid_device_id hid_quirks[] = {
{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN), HID_QUIRK_NO_INIT_REPORTS }, { HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_OPTICAL_TOUCH_SCREEN), HID_QUIRK_NO_INIT_REPORTS },
{ HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE), HID_QUIRK_ALWAYS_POLL }, { HID_USB_DEVICE(USB_VENDOR_ID_PIXART, USB_DEVICE_ID_PIXART_USB_OPTICAL_MOUSE), HID_QUIRK_ALWAYS_POLL },
{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_MOUSE_4D22), HID_QUIRK_ALWAYS_POLL }, { HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_MOUSE_4D22), HID_QUIRK_ALWAYS_POLL },
{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_PIXART_MOUSE_4D0F), HID_QUIRK_ALWAYS_POLL },
{ HID_USB_DEVICE(USB_VENDOR_ID_PRIMAX, USB_DEVICE_ID_PRIMAX_PIXART_MOUSE_4E22), HID_QUIRK_ALWAYS_POLL },
{ HID_USB_DEVICE(USB_VENDOR_ID_PRODIGE, USB_DEVICE_ID_PRODIGE_CORDLESS), HID_QUIRK_NOGET }, { HID_USB_DEVICE(USB_VENDOR_ID_PRODIGE, USB_DEVICE_ID_PRODIGE_CORDLESS), HID_QUIRK_NOGET },
{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001), HID_QUIRK_NOGET }, { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3001), HID_QUIRK_NOGET },
{ HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3003), HID_QUIRK_NOGET }, { HID_USB_DEVICE(USB_VENDOR_ID_QUANTA, USB_DEVICE_ID_QUANTA_OPTICAL_TOUCH_3003), HID_QUIRK_NOGET },
......
...@@ -23,8 +23,9 @@ ...@@ -23,8 +23,9 @@
* In order to avoid breaking them this driver creates a layered hidraw device, * In order to avoid breaking them this driver creates a layered hidraw device,
* so it can detect when the client is running and then: * so it can detect when the client is running and then:
* - it will not send any command to the controller. * - it will not send any command to the controller.
* - this input device will be disabled, to avoid double input of the same * - this input device will be removed, to avoid double input of the same
* user action. * user action.
* When the client is closed, this input device will be created again.
* *
* For additional functions, such as changing the right-pad margin or switching * For additional functions, such as changing the right-pad margin or switching
* the led, you can use the user-space tool at: * the led, you can use the user-space tool at:
...@@ -113,7 +114,7 @@ struct steam_device { ...@@ -113,7 +114,7 @@ struct steam_device {
spinlock_t lock; spinlock_t lock;
struct hid_device *hdev, *client_hdev; struct hid_device *hdev, *client_hdev;
struct mutex mutex; struct mutex mutex;
bool client_opened, input_opened; bool client_opened;
struct input_dev __rcu *input; struct input_dev __rcu *input;
unsigned long quirks; unsigned long quirks;
struct work_struct work_connect; struct work_struct work_connect;
...@@ -279,18 +280,6 @@ static void steam_set_lizard_mode(struct steam_device *steam, bool enable) ...@@ -279,18 +280,6 @@ static void steam_set_lizard_mode(struct steam_device *steam, bool enable)
} }
} }
static void steam_update_lizard_mode(struct steam_device *steam)
{
mutex_lock(&steam->mutex);
if (!steam->client_opened) {
if (steam->input_opened)
steam_set_lizard_mode(steam, false);
else
steam_set_lizard_mode(steam, lizard_mode);
}
mutex_unlock(&steam->mutex);
}
static int steam_input_open(struct input_dev *dev) static int steam_input_open(struct input_dev *dev)
{ {
struct steam_device *steam = input_get_drvdata(dev); struct steam_device *steam = input_get_drvdata(dev);
...@@ -301,7 +290,6 @@ static int steam_input_open(struct input_dev *dev) ...@@ -301,7 +290,6 @@ static int steam_input_open(struct input_dev *dev)
return ret; return ret;
mutex_lock(&steam->mutex); mutex_lock(&steam->mutex);
steam->input_opened = true;
if (!steam->client_opened && lizard_mode) if (!steam->client_opened && lizard_mode)
steam_set_lizard_mode(steam, false); steam_set_lizard_mode(steam, false);
mutex_unlock(&steam->mutex); mutex_unlock(&steam->mutex);
...@@ -313,7 +301,6 @@ static void steam_input_close(struct input_dev *dev) ...@@ -313,7 +301,6 @@ static void steam_input_close(struct input_dev *dev)
struct steam_device *steam = input_get_drvdata(dev); struct steam_device *steam = input_get_drvdata(dev);
mutex_lock(&steam->mutex); mutex_lock(&steam->mutex);
steam->input_opened = false;
if (!steam->client_opened && lizard_mode) if (!steam->client_opened && lizard_mode)
steam_set_lizard_mode(steam, true); steam_set_lizard_mode(steam, true);
mutex_unlock(&steam->mutex); mutex_unlock(&steam->mutex);
...@@ -400,7 +387,7 @@ static int steam_battery_register(struct steam_device *steam) ...@@ -400,7 +387,7 @@ static int steam_battery_register(struct steam_device *steam)
return 0; return 0;
} }
static int steam_register(struct steam_device *steam) static int steam_input_register(struct steam_device *steam)
{ {
struct hid_device *hdev = steam->hdev; struct hid_device *hdev = steam->hdev;
struct input_dev *input; struct input_dev *input;
...@@ -414,17 +401,6 @@ static int steam_register(struct steam_device *steam) ...@@ -414,17 +401,6 @@ static int steam_register(struct steam_device *steam)
return 0; return 0;
} }
/*
* Unlikely, but getting the serial could fail, and it is not so
* important, so make up a serial number and go on.
*/
if (steam_get_serial(steam) < 0)
strlcpy(steam->serial_no, "XXXXXXXXXX",
sizeof(steam->serial_no));
hid_info(hdev, "Steam Controller '%s' connected",
steam->serial_no);
input = input_allocate_device(); input = input_allocate_device();
if (!input) if (!input)
return -ENOMEM; return -ENOMEM;
...@@ -492,11 +468,6 @@ static int steam_register(struct steam_device *steam) ...@@ -492,11 +468,6 @@ static int steam_register(struct steam_device *steam)
goto input_register_fail; goto input_register_fail;
rcu_assign_pointer(steam->input, input); rcu_assign_pointer(steam->input, input);
/* ignore battery errors, we can live without it */
if (steam->quirks & STEAM_QUIRK_WIRELESS)
steam_battery_register(steam);
return 0; return 0;
input_register_fail: input_register_fail:
...@@ -504,27 +475,88 @@ static int steam_register(struct steam_device *steam) ...@@ -504,27 +475,88 @@ static int steam_register(struct steam_device *steam)
return ret; return ret;
} }
static void steam_unregister(struct steam_device *steam) static void steam_input_unregister(struct steam_device *steam)
{ {
struct input_dev *input; struct input_dev *input;
rcu_read_lock();
input = rcu_dereference(steam->input);
rcu_read_unlock();
if (!input)
return;
RCU_INIT_POINTER(steam->input, NULL);
synchronize_rcu();
input_unregister_device(input);
}
static void steam_battery_unregister(struct steam_device *steam)
{
struct power_supply *battery; struct power_supply *battery;
rcu_read_lock(); rcu_read_lock();
input = rcu_dereference(steam->input);
battery = rcu_dereference(steam->battery); battery = rcu_dereference(steam->battery);
rcu_read_unlock(); rcu_read_unlock();
if (battery) { if (!battery)
RCU_INIT_POINTER(steam->battery, NULL); return;
synchronize_rcu(); RCU_INIT_POINTER(steam->battery, NULL);
power_supply_unregister(battery); synchronize_rcu();
power_supply_unregister(battery);
}
static int steam_register(struct steam_device *steam)
{
int ret;
/*
* This function can be called several times in a row with the
* wireless adaptor, without steam_unregister() between them, because
* another client send a get_connection_status command, for example.
* The battery and serial number are set just once per device.
*/
if (!steam->serial_no[0]) {
/*
* Unlikely, but getting the serial could fail, and it is not so
* important, so make up a serial number and go on.
*/
if (steam_get_serial(steam) < 0)
strlcpy(steam->serial_no, "XXXXXXXXXX",
sizeof(steam->serial_no));
hid_info(steam->hdev, "Steam Controller '%s' connected",
steam->serial_no);
/* ignore battery errors, we can live without it */
if (steam->quirks & STEAM_QUIRK_WIRELESS)
steam_battery_register(steam);
mutex_lock(&steam_devices_lock);
list_add(&steam->list, &steam_devices);
mutex_unlock(&steam_devices_lock);
} }
if (input) {
RCU_INIT_POINTER(steam->input, NULL); mutex_lock(&steam->mutex);
synchronize_rcu(); if (!steam->client_opened) {
steam_set_lizard_mode(steam, lizard_mode);
ret = steam_input_register(steam);
} else {
ret = 0;
}
mutex_unlock(&steam->mutex);
return ret;
}
static void steam_unregister(struct steam_device *steam)
{
steam_battery_unregister(steam);
steam_input_unregister(steam);
if (steam->serial_no[0]) {
hid_info(steam->hdev, "Steam Controller '%s' disconnected", hid_info(steam->hdev, "Steam Controller '%s' disconnected",
steam->serial_no); steam->serial_no);
input_unregister_device(input); mutex_lock(&steam_devices_lock);
list_del(&steam->list);
mutex_unlock(&steam_devices_lock);
steam->serial_no[0] = 0;
} }
} }
...@@ -600,6 +632,9 @@ static int steam_client_ll_open(struct hid_device *hdev) ...@@ -600,6 +632,9 @@ static int steam_client_ll_open(struct hid_device *hdev)
mutex_lock(&steam->mutex); mutex_lock(&steam->mutex);
steam->client_opened = true; steam->client_opened = true;
mutex_unlock(&steam->mutex); mutex_unlock(&steam->mutex);
steam_input_unregister(steam);
return ret; return ret;
} }
...@@ -609,13 +644,13 @@ static void steam_client_ll_close(struct hid_device *hdev) ...@@ -609,13 +644,13 @@ static void steam_client_ll_close(struct hid_device *hdev)
mutex_lock(&steam->mutex); mutex_lock(&steam->mutex);
steam->client_opened = false; steam->client_opened = false;
if (steam->input_opened)
steam_set_lizard_mode(steam, false);
else
steam_set_lizard_mode(steam, lizard_mode);
mutex_unlock(&steam->mutex); mutex_unlock(&steam->mutex);
hid_hw_close(steam->hdev); hid_hw_close(steam->hdev);
if (steam->connected) {
steam_set_lizard_mode(steam, lizard_mode);
steam_input_register(steam);
}
} }
static int steam_client_ll_raw_request(struct hid_device *hdev, static int steam_client_ll_raw_request(struct hid_device *hdev,
...@@ -744,11 +779,6 @@ static int steam_probe(struct hid_device *hdev, ...@@ -744,11 +779,6 @@ static int steam_probe(struct hid_device *hdev,
} }
} }
mutex_lock(&steam_devices_lock);
steam_update_lizard_mode(steam);
list_add(&steam->list, &steam_devices);
mutex_unlock(&steam_devices_lock);
return 0; return 0;
hid_hw_open_fail: hid_hw_open_fail:
...@@ -774,10 +804,6 @@ static void steam_remove(struct hid_device *hdev) ...@@ -774,10 +804,6 @@ static void steam_remove(struct hid_device *hdev)
return; return;
} }
mutex_lock(&steam_devices_lock);
list_del(&steam->list);
mutex_unlock(&steam_devices_lock);
hid_destroy_device(steam->client_hdev); hid_destroy_device(steam->client_hdev);
steam->client_opened = false; steam->client_opened = false;
cancel_work_sync(&steam->work_connect); cancel_work_sync(&steam->work_connect);
...@@ -792,12 +818,14 @@ static void steam_remove(struct hid_device *hdev) ...@@ -792,12 +818,14 @@ static void steam_remove(struct hid_device *hdev)
static void steam_do_connect_event(struct steam_device *steam, bool connected) static void steam_do_connect_event(struct steam_device *steam, bool connected)
{ {
unsigned long flags; unsigned long flags;
bool changed;
spin_lock_irqsave(&steam->lock, flags); spin_lock_irqsave(&steam->lock, flags);
changed = steam->connected != connected;
steam->connected = connected; steam->connected = connected;
spin_unlock_irqrestore(&steam->lock, flags); spin_unlock_irqrestore(&steam->lock, flags);
if (schedule_work(&steam->work_connect) == 0) if (changed && schedule_work(&steam->work_connect) == 0)
dbg_hid("%s: connected=%d event already queued\n", dbg_hid("%s: connected=%d event already queued\n",
__func__, connected); __func__, connected);
} }
...@@ -1019,13 +1047,8 @@ static int steam_raw_event(struct hid_device *hdev, ...@@ -1019,13 +1047,8 @@ static int steam_raw_event(struct hid_device *hdev,
return 0; return 0;
rcu_read_lock(); rcu_read_lock();
input = rcu_dereference(steam->input); input = rcu_dereference(steam->input);
if (likely(input)) { if (likely(input))
steam_do_input_event(steam, input, data); steam_do_input_event(steam, input, data);
} else {
dbg_hid("%s: input data without connect event\n",
__func__);
steam_do_connect_event(steam, true);
}
rcu_read_unlock(); rcu_read_unlock();
break; break;
case STEAM_EV_CONNECT: case STEAM_EV_CONNECT:
...@@ -1074,7 +1097,10 @@ static int steam_param_set_lizard_mode(const char *val, ...@@ -1074,7 +1097,10 @@ static int steam_param_set_lizard_mode(const char *val,
mutex_lock(&steam_devices_lock); mutex_lock(&steam_devices_lock);
list_for_each_entry(steam, &steam_devices, list) { list_for_each_entry(steam, &steam_devices, list) {
steam_update_lizard_mode(steam); mutex_lock(&steam->mutex);
if (!steam->client_opened)
steam_set_lizard_mode(steam, lizard_mode);
mutex_unlock(&steam->mutex);
} }
mutex_unlock(&steam_devices_lock); mutex_unlock(&steam_devices_lock);
return 0; return 0;
......
...@@ -177,6 +177,8 @@ static const struct i2c_hid_quirks { ...@@ -177,6 +177,8 @@ static const struct i2c_hid_quirks {
I2C_HID_QUIRK_NO_RUNTIME_PM }, I2C_HID_QUIRK_NO_RUNTIME_PM },
{ I2C_VENDOR_ID_RAYDIUM, I2C_PRODUCT_ID_RAYDIUM_4B33, { I2C_VENDOR_ID_RAYDIUM, I2C_PRODUCT_ID_RAYDIUM_4B33,
I2C_HID_QUIRK_DELAY_AFTER_SLEEP }, I2C_HID_QUIRK_DELAY_AFTER_SLEEP },
{ USB_VENDOR_ID_LG, I2C_DEVICE_ID_LG_8001,
I2C_HID_QUIRK_NO_RUNTIME_PM },
{ 0, 0 } { 0, 0 }
}; };
......
...@@ -12,6 +12,7 @@ ...@@ -12,6 +12,7 @@
#include <linux/atomic.h> #include <linux/atomic.h>
#include <linux/compat.h> #include <linux/compat.h>
#include <linux/cred.h>
#include <linux/device.h> #include <linux/device.h>
#include <linux/fs.h> #include <linux/fs.h>
#include <linux/hid.h> #include <linux/hid.h>
...@@ -496,12 +497,13 @@ static int uhid_dev_create2(struct uhid_device *uhid, ...@@ -496,12 +497,13 @@ static int uhid_dev_create2(struct uhid_device *uhid,
goto err_free; goto err_free;
} }
len = min(sizeof(hid->name), sizeof(ev->u.create2.name)); /* @hid is zero-initialized, strncpy() is correct, strlcpy() not */
strlcpy(hid->name, ev->u.create2.name, len); len = min(sizeof(hid->name), sizeof(ev->u.create2.name)) - 1;
len = min(sizeof(hid->phys), sizeof(ev->u.create2.phys)); strncpy(hid->name, ev->u.create2.name, len);
strlcpy(hid->phys, ev->u.create2.phys, len); len = min(sizeof(hid->phys), sizeof(ev->u.create2.phys)) - 1;
len = min(sizeof(hid->uniq), sizeof(ev->u.create2.uniq)); strncpy(hid->phys, ev->u.create2.phys, len);
strlcpy(hid->uniq, ev->u.create2.uniq, len); len = min(sizeof(hid->uniq), sizeof(ev->u.create2.uniq)) - 1;
strncpy(hid->uniq, ev->u.create2.uniq, len);
hid->ll_driver = &uhid_hid_driver; hid->ll_driver = &uhid_hid_driver;
hid->bus = ev->u.create2.bus; hid->bus = ev->u.create2.bus;
...@@ -722,6 +724,17 @@ static ssize_t uhid_char_write(struct file *file, const char __user *buffer, ...@@ -722,6 +724,17 @@ static ssize_t uhid_char_write(struct file *file, const char __user *buffer,
switch (uhid->input_buf.type) { switch (uhid->input_buf.type) {
case UHID_CREATE: case UHID_CREATE:
/*
* 'struct uhid_create_req' contains a __user pointer which is
* copied from, so it's unsafe to allow this with elevated
* privileges (e.g. from a setuid binary) or via kernel_write().
*/
if (file->f_cred != current_cred() || uaccess_kernel()) {
pr_err_once("UHID_CREATE from different security context by process %d (%s), this is not allowed.\n",
task_tgid_vnr(current), current->comm);
ret = -EACCES;
goto unlock;
}
ret = uhid_dev_create(uhid, &uhid->input_buf); ret = uhid_dev_create(uhid, &uhid->input_buf);
break; break;
case UHID_CREATE2: case UHID_CREATE2:
......
...@@ -1139,34 +1139,6 @@ static inline u32 hid_report_len(struct hid_report *report) ...@@ -1139,34 +1139,6 @@ static inline u32 hid_report_len(struct hid_report *report)
int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size, int hid_report_raw_event(struct hid_device *hid, int type, u8 *data, u32 size,
int interrupt); int interrupt);
/**
* struct hid_scroll_counter - Utility class for processing high-resolution
* scroll events.
* @dev: the input device for which events should be reported.
* @microns_per_hi_res_unit: the amount moved by the user's finger for each
* high-resolution unit reported by the mouse, in
* microns.
* @resolution_multiplier: the wheel's resolution in high-resolution mode as a
* multiple of its lower resolution. For example, if
* moving the wheel by one "notch" would result in a
* value of 1 in low-resolution mode but 8 in
* high-resolution, the multiplier is 8.
* @remainder: counts the number of high-resolution units moved since the last
* low-resolution event (REL_WHEEL or REL_HWHEEL) was sent. Should
* only be used by class methods.
*/
struct hid_scroll_counter {
struct input_dev *dev;
int microns_per_hi_res_unit;
int resolution_multiplier;
int remainder;
};
void hid_scroll_counter_handle_scroll(struct hid_scroll_counter *counter,
int hi_res_value);
/* HID quirks API */ /* HID quirks API */
unsigned long hid_lookup_quirk(const struct hid_device *hdev); unsigned long hid_lookup_quirk(const struct hid_device *hdev);
int hid_quirks_init(char **quirks_param, __u16 bus, int count); int hid_quirks_init(char **quirks_param, __u16 bus, int count);
......
...@@ -716,7 +716,6 @@ ...@@ -716,7 +716,6 @@
* the situation described above. * the situation described above.
*/ */
#define REL_RESERVED 0x0a #define REL_RESERVED 0x0a
#define REL_WHEEL_HI_RES 0x0b
#define REL_MAX 0x0f #define REL_MAX 0x0f
#define REL_CNT (REL_MAX+1) #define REL_CNT (REL_MAX+1)
...@@ -753,15 +752,6 @@ ...@@ -753,15 +752,6 @@
#define ABS_MISC 0x28 #define ABS_MISC 0x28
/*
* 0x2e is reserved and should not be used in input drivers.
* It was used by HID as ABS_MISC+6 and userspace needs to detect if
* the next ABS_* event is correct or is just ABS_MISC + n.
* We define here ABS_RESERVED so userspace can rely on it and detect
* the situation described above.
*/
#define ABS_RESERVED 0x2e
#define ABS_MT_SLOT 0x2f /* MT slot being modified */ #define ABS_MT_SLOT 0x2f /* MT slot being modified */
#define ABS_MT_TOUCH_MAJOR 0x30 /* Major axis of touching ellipse */ #define ABS_MT_TOUCH_MAJOR 0x30 /* Major axis of touching ellipse */
#define ABS_MT_TOUCH_MINOR 0x31 /* Minor axis (omit if circular) */ #define ABS_MT_TOUCH_MINOR 0x31 /* Minor axis (omit if circular) */
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment