forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
466 lines
11 KiB
466 lines
11 KiB
// SPDX-License-Identifier: GPL-2.0-only |
|
/* |
|
* HID driver for THQ PS3 uDraw tablet |
|
* |
|
* Copyright (C) 2016 Red Hat Inc. All Rights Reserved |
|
*/ |
|
|
|
#include <linux/device.h> |
|
#include <linux/hid.h> |
|
#include <linux/module.h> |
|
#include "hid-ids.h" |
|
|
|
MODULE_AUTHOR("Bastien Nocera <[email protected]>"); |
|
MODULE_DESCRIPTION("PS3 uDraw tablet driver"); |
|
MODULE_LICENSE("GPL"); |
|
|
|
/* |
|
* Protocol information from: |
|
* https://brandonw.net/udraw/ |
|
* and the source code of: |
|
* https://vvvv.org/contribution/udraw-hid |
|
*/ |
|
|
|
/* |
|
* The device is setup with multiple input devices: |
|
* - the touch area which works as a touchpad |
|
* - the tablet area which works as a touchpad/drawing tablet |
|
* - a joypad with a d-pad, and 7 buttons |
|
* - an accelerometer device |
|
*/ |
|
|
|
enum { |
|
TOUCH_NONE, |
|
TOUCH_PEN, |
|
TOUCH_FINGER, |
|
TOUCH_TWOFINGER |
|
}; |
|
|
|
enum { |
|
AXIS_X, |
|
AXIS_Y, |
|
AXIS_Z |
|
}; |
|
|
|
/* |
|
* Accelerometer min/max values |
|
* in order, X, Y and Z |
|
*/ |
|
static struct { |
|
int min; |
|
int max; |
|
} accel_limits[] = { |
|
[AXIS_X] = { 490, 534 }, |
|
[AXIS_Y] = { 490, 534 }, |
|
[AXIS_Z] = { 492, 536 } |
|
}; |
|
|
|
#define DEVICE_NAME "THQ uDraw Game Tablet for PS3" |
|
/* resolution in pixels */ |
|
#define RES_X 1920 |
|
#define RES_Y 1080 |
|
/* size in mm */ |
|
#define WIDTH 160 |
|
#define HEIGHT 90 |
|
#define PRESSURE_OFFSET 113 |
|
#define MAX_PRESSURE (255 - PRESSURE_OFFSET) |
|
|
|
struct udraw { |
|
struct input_dev *joy_input_dev; |
|
struct input_dev *touch_input_dev; |
|
struct input_dev *pen_input_dev; |
|
struct input_dev *accel_input_dev; |
|
struct hid_device *hdev; |
|
|
|
/* |
|
* The device's two-finger support is pretty unreliable, as |
|
* the device could report a single touch when the two fingers |
|
* are too close together, and the distance between fingers, even |
|
* though reported is not in the same unit as the touches. |
|
* |
|
* We'll make do without it, and try to report the first touch |
|
* as reliably as possible. |
|
*/ |
|
int last_one_finger_x; |
|
int last_one_finger_y; |
|
int last_two_finger_x; |
|
int last_two_finger_y; |
|
}; |
|
|
|
static int clamp_accel(int axis, int offset) |
|
{ |
|
axis = clamp(axis, |
|
accel_limits[offset].min, |
|
accel_limits[offset].max); |
|
axis = (axis - accel_limits[offset].min) / |
|
((accel_limits[offset].max - |
|
accel_limits[offset].min) * 0xFF); |
|
return axis; |
|
} |
|
|
|
static int udraw_raw_event(struct hid_device *hdev, struct hid_report *report, |
|
u8 *data, int len) |
|
{ |
|
struct udraw *udraw = hid_get_drvdata(hdev); |
|
int touch; |
|
int x, y, z; |
|
|
|
if (len != 27) |
|
return 0; |
|
|
|
if (data[11] == 0x00) |
|
touch = TOUCH_NONE; |
|
else if (data[11] == 0x40) |
|
touch = TOUCH_PEN; |
|
else if (data[11] == 0x80) |
|
touch = TOUCH_FINGER; |
|
else |
|
touch = TOUCH_TWOFINGER; |
|
|
|
/* joypad */ |
|
input_report_key(udraw->joy_input_dev, BTN_WEST, data[0] & 1); |
|
input_report_key(udraw->joy_input_dev, BTN_SOUTH, !!(data[0] & 2)); |
|
input_report_key(udraw->joy_input_dev, BTN_EAST, !!(data[0] & 4)); |
|
input_report_key(udraw->joy_input_dev, BTN_NORTH, !!(data[0] & 8)); |
|
|
|
input_report_key(udraw->joy_input_dev, BTN_SELECT, !!(data[1] & 1)); |
|
input_report_key(udraw->joy_input_dev, BTN_START, !!(data[1] & 2)); |
|
input_report_key(udraw->joy_input_dev, BTN_MODE, !!(data[1] & 16)); |
|
|
|
x = y = 0; |
|
switch (data[2]) { |
|
case 0x0: |
|
y = -127; |
|
break; |
|
case 0x1: |
|
y = -127; |
|
x = 127; |
|
break; |
|
case 0x2: |
|
x = 127; |
|
break; |
|
case 0x3: |
|
y = 127; |
|
x = 127; |
|
break; |
|
case 0x4: |
|
y = 127; |
|
break; |
|
case 0x5: |
|
y = 127; |
|
x = -127; |
|
break; |
|
case 0x6: |
|
x = -127; |
|
break; |
|
case 0x7: |
|
y = -127; |
|
x = -127; |
|
break; |
|
default: |
|
break; |
|
} |
|
|
|
input_report_abs(udraw->joy_input_dev, ABS_X, x); |
|
input_report_abs(udraw->joy_input_dev, ABS_Y, y); |
|
|
|
input_sync(udraw->joy_input_dev); |
|
|
|
/* For pen and touchpad */ |
|
x = y = 0; |
|
if (touch != TOUCH_NONE) { |
|
if (data[15] != 0x0F) |
|
x = data[15] * 256 + data[17]; |
|
if (data[16] != 0x0F) |
|
y = data[16] * 256 + data[18]; |
|
} |
|
|
|
if (touch == TOUCH_FINGER) { |
|
/* Save the last one-finger touch */ |
|
udraw->last_one_finger_x = x; |
|
udraw->last_one_finger_y = y; |
|
udraw->last_two_finger_x = -1; |
|
udraw->last_two_finger_y = -1; |
|
} else if (touch == TOUCH_TWOFINGER) { |
|
/* |
|
* We have a problem because x/y is the one for the |
|
* second finger but we want the first finger given |
|
* to user-space otherwise it'll look as if it jumped. |
|
* |
|
* See the udraw struct definition for why this was |
|
* implemented this way. |
|
*/ |
|
if (udraw->last_two_finger_x == -1) { |
|
/* Save the position of the 2nd finger */ |
|
udraw->last_two_finger_x = x; |
|
udraw->last_two_finger_y = y; |
|
|
|
x = udraw->last_one_finger_x; |
|
y = udraw->last_one_finger_y; |
|
} else { |
|
/* |
|
* Offset the 2-finger coords using the |
|
* saved data from the first finger |
|
*/ |
|
x = x - (udraw->last_two_finger_x |
|
- udraw->last_one_finger_x); |
|
y = y - (udraw->last_two_finger_y |
|
- udraw->last_one_finger_y); |
|
} |
|
} |
|
|
|
/* touchpad */ |
|
if (touch == TOUCH_FINGER || touch == TOUCH_TWOFINGER) { |
|
input_report_key(udraw->touch_input_dev, BTN_TOUCH, 1); |
|
input_report_key(udraw->touch_input_dev, BTN_TOOL_FINGER, |
|
touch == TOUCH_FINGER); |
|
input_report_key(udraw->touch_input_dev, BTN_TOOL_DOUBLETAP, |
|
touch == TOUCH_TWOFINGER); |
|
|
|
input_report_abs(udraw->touch_input_dev, ABS_X, x); |
|
input_report_abs(udraw->touch_input_dev, ABS_Y, y); |
|
} else { |
|
input_report_key(udraw->touch_input_dev, BTN_TOUCH, 0); |
|
input_report_key(udraw->touch_input_dev, BTN_TOOL_FINGER, 0); |
|
input_report_key(udraw->touch_input_dev, BTN_TOOL_DOUBLETAP, 0); |
|
} |
|
input_sync(udraw->touch_input_dev); |
|
|
|
/* pen */ |
|
if (touch == TOUCH_PEN) { |
|
int level; |
|
|
|
level = clamp(data[13] - PRESSURE_OFFSET, |
|
0, MAX_PRESSURE); |
|
|
|
input_report_key(udraw->pen_input_dev, BTN_TOUCH, (level != 0)); |
|
input_report_key(udraw->pen_input_dev, BTN_TOOL_PEN, 1); |
|
input_report_abs(udraw->pen_input_dev, ABS_PRESSURE, level); |
|
input_report_abs(udraw->pen_input_dev, ABS_X, x); |
|
input_report_abs(udraw->pen_input_dev, ABS_Y, y); |
|
} else { |
|
input_report_key(udraw->pen_input_dev, BTN_TOUCH, 0); |
|
input_report_key(udraw->pen_input_dev, BTN_TOOL_PEN, 0); |
|
input_report_abs(udraw->pen_input_dev, ABS_PRESSURE, 0); |
|
} |
|
input_sync(udraw->pen_input_dev); |
|
|
|
/* accel */ |
|
x = (data[19] + (data[20] << 8)); |
|
x = clamp_accel(x, AXIS_X); |
|
y = (data[21] + (data[22] << 8)); |
|
y = clamp_accel(y, AXIS_Y); |
|
z = (data[23] + (data[24] << 8)); |
|
z = clamp_accel(z, AXIS_Z); |
|
input_report_abs(udraw->accel_input_dev, ABS_X, x); |
|
input_report_abs(udraw->accel_input_dev, ABS_Y, y); |
|
input_report_abs(udraw->accel_input_dev, ABS_Z, z); |
|
input_sync(udraw->accel_input_dev); |
|
|
|
/* let hidraw and hiddev handle the report */ |
|
return 0; |
|
} |
|
|
|
static int udraw_open(struct input_dev *dev) |
|
{ |
|
struct udraw *udraw = input_get_drvdata(dev); |
|
|
|
return hid_hw_open(udraw->hdev); |
|
} |
|
|
|
static void udraw_close(struct input_dev *dev) |
|
{ |
|
struct udraw *udraw = input_get_drvdata(dev); |
|
|
|
hid_hw_close(udraw->hdev); |
|
} |
|
|
|
static struct input_dev *allocate_and_setup(struct hid_device *hdev, |
|
const char *name) |
|
{ |
|
struct input_dev *input_dev; |
|
|
|
input_dev = devm_input_allocate_device(&hdev->dev); |
|
if (!input_dev) |
|
return NULL; |
|
|
|
input_dev->name = name; |
|
input_dev->phys = hdev->phys; |
|
input_dev->dev.parent = &hdev->dev; |
|
input_dev->open = udraw_open; |
|
input_dev->close = udraw_close; |
|
input_dev->uniq = hdev->uniq; |
|
input_dev->id.bustype = hdev->bus; |
|
input_dev->id.vendor = hdev->vendor; |
|
input_dev->id.product = hdev->product; |
|
input_dev->id.version = hdev->version; |
|
input_set_drvdata(input_dev, hid_get_drvdata(hdev)); |
|
|
|
return input_dev; |
|
} |
|
|
|
static bool udraw_setup_touch(struct udraw *udraw, |
|
struct hid_device *hdev) |
|
{ |
|
struct input_dev *input_dev; |
|
|
|
input_dev = allocate_and_setup(hdev, DEVICE_NAME " Touchpad"); |
|
if (!input_dev) |
|
return false; |
|
|
|
input_dev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY); |
|
|
|
input_set_abs_params(input_dev, ABS_X, 0, RES_X, 1, 0); |
|
input_abs_set_res(input_dev, ABS_X, RES_X / WIDTH); |
|
input_set_abs_params(input_dev, ABS_Y, 0, RES_Y, 1, 0); |
|
input_abs_set_res(input_dev, ABS_Y, RES_Y / HEIGHT); |
|
|
|
set_bit(BTN_TOUCH, input_dev->keybit); |
|
set_bit(BTN_TOOL_FINGER, input_dev->keybit); |
|
set_bit(BTN_TOOL_DOUBLETAP, input_dev->keybit); |
|
|
|
set_bit(INPUT_PROP_POINTER, input_dev->propbit); |
|
|
|
udraw->touch_input_dev = input_dev; |
|
|
|
return true; |
|
} |
|
|
|
static bool udraw_setup_pen(struct udraw *udraw, |
|
struct hid_device *hdev) |
|
{ |
|
struct input_dev *input_dev; |
|
|
|
input_dev = allocate_and_setup(hdev, DEVICE_NAME " Pen"); |
|
if (!input_dev) |
|
return false; |
|
|
|
input_dev->evbit[0] = BIT(EV_ABS) | BIT(EV_KEY); |
|
|
|
input_set_abs_params(input_dev, ABS_X, 0, RES_X, 1, 0); |
|
input_abs_set_res(input_dev, ABS_X, RES_X / WIDTH); |
|
input_set_abs_params(input_dev, ABS_Y, 0, RES_Y, 1, 0); |
|
input_abs_set_res(input_dev, ABS_Y, RES_Y / HEIGHT); |
|
input_set_abs_params(input_dev, ABS_PRESSURE, |
|
0, MAX_PRESSURE, 0, 0); |
|
|
|
set_bit(BTN_TOUCH, input_dev->keybit); |
|
set_bit(BTN_TOOL_PEN, input_dev->keybit); |
|
|
|
set_bit(INPUT_PROP_POINTER, input_dev->propbit); |
|
|
|
udraw->pen_input_dev = input_dev; |
|
|
|
return true; |
|
} |
|
|
|
static bool udraw_setup_accel(struct udraw *udraw, |
|
struct hid_device *hdev) |
|
{ |
|
struct input_dev *input_dev; |
|
|
|
input_dev = allocate_and_setup(hdev, DEVICE_NAME " Accelerometer"); |
|
if (!input_dev) |
|
return false; |
|
|
|
input_dev->evbit[0] = BIT(EV_ABS); |
|
|
|
/* 1G accel is reported as ~256, so clamp to 2G */ |
|
input_set_abs_params(input_dev, ABS_X, -512, 512, 0, 0); |
|
input_set_abs_params(input_dev, ABS_Y, -512, 512, 0, 0); |
|
input_set_abs_params(input_dev, ABS_Z, -512, 512, 0, 0); |
|
|
|
set_bit(INPUT_PROP_ACCELEROMETER, input_dev->propbit); |
|
|
|
udraw->accel_input_dev = input_dev; |
|
|
|
return true; |
|
} |
|
|
|
static bool udraw_setup_joypad(struct udraw *udraw, |
|
struct hid_device *hdev) |
|
{ |
|
struct input_dev *input_dev; |
|
|
|
input_dev = allocate_and_setup(hdev, DEVICE_NAME " Joypad"); |
|
if (!input_dev) |
|
return false; |
|
|
|
input_dev->evbit[0] = BIT(EV_KEY) | BIT(EV_ABS); |
|
|
|
set_bit(BTN_SOUTH, input_dev->keybit); |
|
set_bit(BTN_NORTH, input_dev->keybit); |
|
set_bit(BTN_EAST, input_dev->keybit); |
|
set_bit(BTN_WEST, input_dev->keybit); |
|
set_bit(BTN_SELECT, input_dev->keybit); |
|
set_bit(BTN_START, input_dev->keybit); |
|
set_bit(BTN_MODE, input_dev->keybit); |
|
|
|
input_set_abs_params(input_dev, ABS_X, -127, 127, 0, 0); |
|
input_set_abs_params(input_dev, ABS_Y, -127, 127, 0, 0); |
|
|
|
udraw->joy_input_dev = input_dev; |
|
|
|
return true; |
|
} |
|
|
|
static int udraw_probe(struct hid_device *hdev, const struct hid_device_id *id) |
|
{ |
|
struct udraw *udraw; |
|
int ret; |
|
|
|
udraw = devm_kzalloc(&hdev->dev, sizeof(struct udraw), GFP_KERNEL); |
|
if (!udraw) |
|
return -ENOMEM; |
|
|
|
udraw->hdev = hdev; |
|
udraw->last_two_finger_x = -1; |
|
udraw->last_two_finger_y = -1; |
|
|
|
hid_set_drvdata(hdev, udraw); |
|
|
|
ret = hid_parse(hdev); |
|
if (ret) { |
|
hid_err(hdev, "parse failed\n"); |
|
return ret; |
|
} |
|
|
|
if (!udraw_setup_joypad(udraw, hdev) || |
|
!udraw_setup_touch(udraw, hdev) || |
|
!udraw_setup_pen(udraw, hdev) || |
|
!udraw_setup_accel(udraw, hdev)) { |
|
hid_err(hdev, "could not allocate interfaces\n"); |
|
return -ENOMEM; |
|
} |
|
|
|
ret = input_register_device(udraw->joy_input_dev) || |
|
input_register_device(udraw->touch_input_dev) || |
|
input_register_device(udraw->pen_input_dev) || |
|
input_register_device(udraw->accel_input_dev); |
|
if (ret) { |
|
hid_err(hdev, "failed to register interfaces\n"); |
|
return ret; |
|
} |
|
|
|
ret = hid_hw_start(hdev, HID_CONNECT_HIDRAW | HID_CONNECT_DRIVER); |
|
if (ret) { |
|
hid_err(hdev, "hw start failed\n"); |
|
return ret; |
|
} |
|
|
|
return 0; |
|
} |
|
|
|
static const struct hid_device_id udraw_devices[] = { |
|
{ HID_USB_DEVICE(USB_VENDOR_ID_THQ, USB_DEVICE_ID_THQ_PS3_UDRAW) }, |
|
{ } |
|
}; |
|
MODULE_DEVICE_TABLE(hid, udraw_devices); |
|
|
|
static struct hid_driver udraw_driver = { |
|
.name = "hid-udraw", |
|
.id_table = udraw_devices, |
|
.raw_event = udraw_raw_event, |
|
.probe = udraw_probe, |
|
}; |
|
module_hid_driver(udraw_driver);
|
|
|