// 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 <hadess@hadess.net>" );
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) * 0 xFF);
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 ] == 0 x00)
touch = TOUCH_NONE;
else if (data[11 ] == 0 x40)
touch = TOUCH_PEN;
else if (data[11 ] == 0 x80)
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 0 x0:
y = -127 ;
break ;
case 0 x1:
y = -127 ;
x = 127 ;
break ;
case 0 x2:
x = 127 ;
break ;
case 0 x3:
y = 127 ;
x = 127 ;
break ;
case 0 x4:
y = 127 ;
break ;
case 0 x5:
y = 127 ;
x = -127 ;
break ;
case 0 x6:
x = -127 ;
break ;
case 0 x7:
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 ] != 0 x0F)
x = data[15 ] * 256 + data[17 ];
if (data[16 ] != 0 x0F)
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);
Messung V0.5 in Prozent C=96 H=100 G=97
¤ Dauer der Verarbeitung: 0.11 Sekunden
(vorverarbeitet am 2026-09-29)
¤
*© Formatika GbR, Deutschland