2006-07-13 19:01:36 -06:00
|
|
|
/*
|
2007-05-07 14:16:29 -06:00
|
|
|
* drivers/input/tablet/wacom_sys.c
|
2006-07-13 19:01:36 -06:00
|
|
|
*
|
2009-12-15 01:35:24 -07:00
|
|
|
* USB Wacom tablet support - system specific code
|
2006-07-13 19:01:36 -06:00
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "wacom_wac.h"
|
2010-03-19 23:18:15 -06:00
|
|
|
#include "wacom.h"
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2011-08-16 01:17:56 -06:00
|
|
|
#define WAC_MSG_RETRIES 5
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-09-10 13:41:31 -06:00
|
|
|
#define WAC_CMD_WL_LED_CONTROL 0x03
|
2011-09-07 15:08:54 -06:00
|
|
|
#define WAC_CMD_LED_CONTROL 0x20
|
|
|
|
#define WAC_CMD_ICON_START 0x21
|
|
|
|
#define WAC_CMD_ICON_XFER 0x23
|
2014-08-06 14:58:25 -06:00
|
|
|
#define WAC_CMD_ICON_BT_XFER 0x26
|
2011-09-07 15:08:54 -06:00
|
|
|
#define WAC_CMD_RETRIES 10
|
|
|
|
|
2014-09-10 13:40:05 -06:00
|
|
|
#define DEV_ATTR_RW_PERM (S_IRUGO | S_IWUSR | S_IWGRP)
|
|
|
|
#define DEV_ATTR_WO_PERM (S_IWUSR | S_IWGRP)
|
|
|
|
|
2014-09-10 13:41:04 -06:00
|
|
|
static int wacom_get_report(struct hid_device *hdev, u8 type, u8 *buf,
|
|
|
|
size_t size, unsigned int retries)
|
2006-07-13 19:01:36 -06:00
|
|
|
{
|
2011-09-07 15:08:54 -06:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
do {
|
2014-09-10 13:41:04 -06:00
|
|
|
retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
|
2014-07-24 13:56:22 -06:00
|
|
|
HID_REQ_GET_REPORT);
|
2011-09-07 15:08:54 -06:00
|
|
|
} while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
|
|
|
|
|
|
|
|
return retval;
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
2014-08-06 15:00:38 -06:00
|
|
|
static int wacom_set_report(struct hid_device *hdev, u8 type, u8 *buf,
|
|
|
|
size_t size, unsigned int retries)
|
2006-07-13 19:01:36 -06:00
|
|
|
{
|
2011-09-07 15:08:54 -06:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
do {
|
2014-08-06 15:00:38 -06:00
|
|
|
retval = hid_hw_raw_request(hdev, buf[0], buf, size, type,
|
2014-07-24 13:56:22 -06:00
|
|
|
HID_REQ_SET_REPORT);
|
2011-09-07 15:08:54 -06:00
|
|
|
} while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
|
|
|
|
|
|
|
|
return retval;
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
static int wacom_raw_event(struct hid_device *hdev, struct hid_report *report,
|
|
|
|
u8 *raw_data, int size)
|
2006-07-13 19:01:36 -06:00
|
|
|
{
|
2014-07-24 13:52:23 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
if (size > WACOM_PKGLEN_MAX)
|
|
|
|
return 1;
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
memcpy(wacom->wacom_wac.data, raw_data, size);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
wacom_wac_irq(&wacom->wacom_wac, size);
|
|
|
|
|
|
|
|
return 0;
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_open(struct input_dev *dev)
|
|
|
|
{
|
2007-04-11 23:34:39 -06:00
|
|
|
struct wacom *wacom = input_get_drvdata(dev);
|
2014-07-24 13:52:23 -06:00
|
|
|
int retval;
|
2010-10-04 22:46:11 -06:00
|
|
|
|
|
|
|
mutex_lock(&wacom->lock);
|
2014-07-24 13:52:23 -06:00
|
|
|
retval = hid_hw_open(wacom->hdev);
|
2008-04-14 23:31:57 -06:00
|
|
|
mutex_unlock(&wacom->lock);
|
2014-07-24 13:52:23 -06:00
|
|
|
|
2010-10-04 22:46:11 -06:00
|
|
|
return retval;
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_close(struct input_dev *dev)
|
|
|
|
{
|
2007-04-11 23:34:39 -06:00
|
|
|
struct wacom *wacom = input_get_drvdata(dev);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2008-04-14 23:31:57 -06:00
|
|
|
mutex_lock(&wacom->lock);
|
2014-07-24 13:52:23 -06:00
|
|
|
hid_hw_close(wacom->hdev);
|
2008-04-14 23:31:57 -06:00
|
|
|
mutex_unlock(&wacom->lock);
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
2012-10-03 18:24:32 -06:00
|
|
|
/*
|
2014-07-24 14:03:05 -06:00
|
|
|
* Calculate the resolution of the X or Y axis using hidinput_calc_abs_res.
|
2012-10-03 18:24:32 -06:00
|
|
|
*/
|
|
|
|
static int wacom_calc_hid_res(int logical_extents, int physical_extents,
|
2014-07-24 14:02:14 -06:00
|
|
|
unsigned unit, int exponent)
|
2012-10-03 18:24:32 -06:00
|
|
|
{
|
2014-07-24 14:03:05 -06:00
|
|
|
struct hid_field field = {
|
|
|
|
.logical_maximum = logical_extents,
|
|
|
|
.physical_maximum = physical_extents,
|
|
|
|
.unit = unit,
|
|
|
|
.unit_exponent = exponent,
|
|
|
|
};
|
|
|
|
|
|
|
|
return hidinput_calc_abs_res(&field, ABS_X);
|
2012-10-03 18:24:32 -06:00
|
|
|
}
|
|
|
|
|
2014-07-24 14:02:14 -06:00
|
|
|
static void wacom_feature_mapping(struct hid_device *hdev,
|
|
|
|
struct hid_field *field, struct hid_usage *usage)
|
2012-04-29 22:09:17 -06:00
|
|
|
{
|
2014-07-24 14:02:14 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
|
|
|
struct wacom_features *features = &wacom->wacom_wac.features;
|
2014-09-16 14:56:39 -06:00
|
|
|
u8 *data;
|
|
|
|
int ret;
|
2012-04-29 22:09:17 -06:00
|
|
|
|
2014-07-24 14:02:14 -06:00
|
|
|
switch (usage->hid) {
|
|
|
|
case HID_DG_CONTACTMAX:
|
|
|
|
/* leave touch_max as is if predefined */
|
2014-09-16 14:56:39 -06:00
|
|
|
if (!features->touch_max) {
|
|
|
|
/* read manually */
|
|
|
|
data = kzalloc(2, GFP_KERNEL);
|
|
|
|
if (!data)
|
|
|
|
break;
|
|
|
|
data[0] = field->report->id;
|
|
|
|
ret = wacom_get_report(hdev, HID_FEATURE_REPORT,
|
|
|
|
data, 2, 0);
|
|
|
|
if (ret == 2)
|
|
|
|
features->touch_max = data[1];
|
|
|
|
kfree(data);
|
|
|
|
}
|
2014-07-24 14:02:14 -06:00
|
|
|
break;
|
2012-04-29 22:09:17 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-10-26 23:26:59 -06:00
|
|
|
/*
|
|
|
|
* Interface Descriptor of wacom devices can be incomplete and
|
|
|
|
* inconsistent so wacom_features table is used to store stylus
|
|
|
|
* device's packet lengths, various maximum values, and tablet
|
|
|
|
* resolution based on product ID's.
|
|
|
|
*
|
|
|
|
* For devices that contain 2 interfaces, wacom_features table is
|
|
|
|
* inaccurate for the touch interface. Since the Interface Descriptor
|
|
|
|
* for touch interfaces has pretty complete data, this function exists
|
|
|
|
* to query tablet for this missing information instead of hard coding in
|
|
|
|
* an additional table.
|
|
|
|
*
|
|
|
|
* A typical Interface Descriptor for a stylus will contain a
|
|
|
|
* boot mouse application collection that is not of interest and this
|
|
|
|
* function will ignore it.
|
|
|
|
*
|
|
|
|
* It also contains a digitizer application collection that also is not
|
|
|
|
* of interest since any information it contains would be duplicate
|
|
|
|
* of what is in wacom_features. Usually it defines a report of an array
|
|
|
|
* of bytes that could be used as max length of the stylus packet returned.
|
|
|
|
* If it happens to define a Digitizer-Stylus Physical Collection then
|
|
|
|
* the X and Y logical values contain valid data but it is ignored.
|
|
|
|
*
|
|
|
|
* A typical Interface Descriptor for a touch interface will contain a
|
|
|
|
* Digitizer-Finger Physical Collection which will define both logical
|
|
|
|
* X/Y maximum as well as the physical size of tablet. Since touch
|
|
|
|
* interfaces haven't supported pressure or distance, this is enough
|
|
|
|
* information to override invalid values in the wacom_features table.
|
2011-10-26 23:32:52 -06:00
|
|
|
*
|
2014-07-24 14:02:14 -06:00
|
|
|
* Intuos5 touch interface and 3rd gen Bamboo Touch do not contain useful
|
|
|
|
* data. We deal with them after returning from this function.
|
2011-10-26 23:26:59 -06:00
|
|
|
*/
|
2014-07-24 14:02:14 -06:00
|
|
|
static void wacom_usage_mapping(struct hid_device *hdev,
|
|
|
|
struct hid_field *field, struct hid_usage *usage)
|
2008-11-24 09:44:27 -07:00
|
|
|
{
|
2014-07-24 14:02:14 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
|
|
|
struct wacom_features *features = &wacom->wacom_wac.features;
|
|
|
|
bool finger = (field->logical == HID_DG_FINGER) ||
|
|
|
|
(field->physical == HID_DG_FINGER);
|
|
|
|
bool pen = (field->logical == HID_DG_STYLUS) ||
|
|
|
|
(field->physical == HID_DG_STYLUS);
|
2014-04-19 14:49:37 -06:00
|
|
|
|
2014-07-24 14:02:14 -06:00
|
|
|
/*
|
|
|
|
* Requiring Stylus Usage will ignore boot mouse
|
|
|
|
* X/Y values and some cases of invalid Digitizer X/Y
|
|
|
|
* values commonly reported.
|
|
|
|
*/
|
|
|
|
if (!pen && !finger)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (finger && !features->touch_max)
|
|
|
|
/* touch device at least supports one touch point */
|
|
|
|
features->touch_max = 1;
|
|
|
|
|
|
|
|
switch (usage->hid) {
|
|
|
|
case HID_GD_X:
|
|
|
|
features->x_max = field->logical_maximum;
|
|
|
|
if (finger) {
|
|
|
|
features->device_type = BTN_TOOL_FINGER;
|
|
|
|
features->x_phy = field->physical_maximum;
|
|
|
|
if (features->type != BAMBOO_PT) {
|
|
|
|
features->unit = field->unit;
|
|
|
|
features->unitExpo = field->unit_exponent;
|
2008-11-24 09:44:27 -07:00
|
|
|
}
|
2014-07-24 14:02:14 -06:00
|
|
|
} else {
|
|
|
|
features->device_type = BTN_TOOL_PEN;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case HID_GD_Y:
|
|
|
|
features->y_max = field->logical_maximum;
|
|
|
|
if (finger) {
|
|
|
|
features->y_phy = field->physical_maximum;
|
|
|
|
if (features->type != BAMBOO_PT) {
|
|
|
|
features->unit = field->unit;
|
|
|
|
features->unitExpo = field->unit_exponent;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case HID_DG_TIPPRESSURE:
|
|
|
|
if (pen)
|
|
|
|
features->pressure_max = field->logical_maximum;
|
|
|
|
break;
|
|
|
|
}
|
2014-09-23 10:08:08 -06:00
|
|
|
|
|
|
|
if (features->type == HID_GENERIC)
|
|
|
|
wacom_wac_usage_mapping(hdev, field, usage);
|
2014-07-24 14:02:14 -06:00
|
|
|
}
|
2011-10-26 23:32:52 -06:00
|
|
|
|
2014-07-24 14:02:14 -06:00
|
|
|
static void wacom_parse_hid(struct hid_device *hdev,
|
|
|
|
struct wacom_features *features)
|
|
|
|
{
|
|
|
|
struct hid_report_enum *rep_enum;
|
|
|
|
struct hid_report *hreport;
|
|
|
|
int i, j;
|
|
|
|
|
|
|
|
/* check features first */
|
|
|
|
rep_enum = &hdev->report_enum[HID_FEATURE_REPORT];
|
|
|
|
list_for_each_entry(hreport, &rep_enum->report_list, list) {
|
|
|
|
for (i = 0; i < hreport->maxfield; i++) {
|
|
|
|
/* Ignore if report count is out of bounds. */
|
|
|
|
if (hreport->field[i]->report_count < 1)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (j = 0; j < hreport->field[i]->maxusage; j++) {
|
|
|
|
wacom_feature_mapping(hdev, hreport->field[i],
|
|
|
|
hreport->field[i]->usage + j);
|
2011-10-26 23:32:52 -06:00
|
|
|
}
|
2008-11-24 09:44:27 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-24 14:02:14 -06:00
|
|
|
/* now check the input usages */
|
|
|
|
rep_enum = &hdev->report_enum[HID_INPUT_REPORT];
|
|
|
|
list_for_each_entry(hreport, &rep_enum->report_list, list) {
|
|
|
|
|
|
|
|
if (!hreport->maxfield)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (i = 0; i < hreport->maxfield; i++)
|
|
|
|
for (j = 0; j < hreport->field[i]->maxusage; j++)
|
|
|
|
wacom_usage_mapping(hdev, hreport->field[i],
|
|
|
|
hreport->field[i]->usage + j);
|
|
|
|
}
|
2008-11-24 09:44:27 -07:00
|
|
|
}
|
|
|
|
|
2014-07-24 13:56:22 -06:00
|
|
|
static int wacom_set_device_mode(struct hid_device *hdev, int report_id,
|
|
|
|
int length, int mode)
|
2009-08-20 22:41:04 -06:00
|
|
|
{
|
|
|
|
unsigned char *rep_data;
|
2012-10-03 18:25:35 -06:00
|
|
|
int error = -ENOMEM, limit = 0;
|
2009-08-20 22:41:04 -06:00
|
|
|
|
2012-10-03 18:25:35 -06:00
|
|
|
rep_data = kzalloc(length, GFP_KERNEL);
|
2009-08-20 22:41:04 -06:00
|
|
|
if (!rep_data)
|
2009-12-15 01:35:24 -07:00
|
|
|
return error;
|
|
|
|
|
2012-10-03 18:25:35 -06:00
|
|
|
do {
|
2013-01-23 20:37:34 -07:00
|
|
|
rep_data[0] = report_id;
|
|
|
|
rep_data[1] = mode;
|
|
|
|
|
2014-08-06 15:00:38 -06:00
|
|
|
error = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data,
|
|
|
|
length, 1);
|
2014-07-24 13:47:47 -06:00
|
|
|
if (error >= 0)
|
2014-07-24 13:56:22 -06:00
|
|
|
error = wacom_get_report(hdev, HID_FEATURE_REPORT,
|
2014-09-10 13:41:04 -06:00
|
|
|
rep_data, length, 1);
|
2012-10-03 18:25:35 -06:00
|
|
|
} while ((error < 0 || rep_data[1] != mode) && limit++ < WAC_MSG_RETRIES);
|
|
|
|
|
|
|
|
kfree(rep_data);
|
|
|
|
|
|
|
|
return error < 0 ? error : 0;
|
|
|
|
}
|
|
|
|
|
2014-08-06 14:48:01 -06:00
|
|
|
static int wacom_bt_query_tablet_data(struct hid_device *hdev, u8 speed,
|
|
|
|
struct wacom_features *features)
|
|
|
|
{
|
2014-08-06 14:52:56 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
|
|
|
int ret;
|
|
|
|
u8 rep_data[2];
|
|
|
|
|
|
|
|
switch (features->type) {
|
|
|
|
case GRAPHIRE_BT:
|
|
|
|
rep_data[0] = 0x03;
|
|
|
|
rep_data[1] = 0x00;
|
2014-08-06 15:00:38 -06:00
|
|
|
ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
|
|
|
|
3);
|
2014-08-06 14:52:56 -06:00
|
|
|
|
|
|
|
if (ret >= 0) {
|
|
|
|
rep_data[0] = speed == 0 ? 0x05 : 0x06;
|
|
|
|
rep_data[1] = 0x00;
|
|
|
|
|
|
|
|
ret = wacom_set_report(hdev, HID_FEATURE_REPORT,
|
2014-08-06 15:00:38 -06:00
|
|
|
rep_data, 2, 3);
|
2014-08-06 14:52:56 -06:00
|
|
|
|
|
|
|
if (ret >= 0) {
|
|
|
|
wacom->wacom_wac.bt_high_speed = speed;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Note that if the raw queries fail, it's not a hard failure
|
|
|
|
* and it is safe to continue
|
|
|
|
*/
|
|
|
|
hid_warn(hdev, "failed to poke device, command %d, err %d\n",
|
|
|
|
rep_data[0], ret);
|
|
|
|
break;
|
2014-08-06 14:55:56 -06:00
|
|
|
case INTUOS4WL:
|
|
|
|
if (speed == 1)
|
|
|
|
wacom->wacom_wac.bt_features &= ~0x20;
|
|
|
|
else
|
|
|
|
wacom->wacom_wac.bt_features |= 0x20;
|
|
|
|
|
|
|
|
rep_data[0] = 0x03;
|
|
|
|
rep_data[1] = wacom->wacom_wac.bt_features;
|
|
|
|
|
2014-08-06 15:00:38 -06:00
|
|
|
ret = wacom_set_report(hdev, HID_FEATURE_REPORT, rep_data, 2,
|
|
|
|
1);
|
2014-08-06 14:55:56 -06:00
|
|
|
if (ret >= 0)
|
|
|
|
wacom->wacom_wac.bt_high_speed = speed;
|
|
|
|
break;
|
2014-08-06 14:52:56 -06:00
|
|
|
}
|
|
|
|
|
2014-08-06 14:48:01 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-10-03 18:25:35 -06:00
|
|
|
/*
|
|
|
|
* Switch the tablet into its most-capable mode. Wacom tablets are
|
|
|
|
* typically configured to power-up in a mode which sends mouse-like
|
|
|
|
* reports to the OS. To get absolute position, pressure data, etc.
|
|
|
|
* from the tablet, it is necessary to switch the tablet out of this
|
|
|
|
* mode and into one which sends the full range of tablet data.
|
|
|
|
*/
|
2014-07-24 13:56:22 -06:00
|
|
|
static int wacom_query_tablet_data(struct hid_device *hdev,
|
|
|
|
struct wacom_features *features)
|
2012-10-03 18:25:35 -06:00
|
|
|
{
|
2014-08-06 14:48:01 -06:00
|
|
|
if (hdev->bus == BUS_BLUETOOTH)
|
|
|
|
return wacom_bt_query_tablet_data(hdev, 1, features);
|
|
|
|
|
2012-04-29 22:09:18 -06:00
|
|
|
if (features->device_type == BTN_TOOL_FINGER) {
|
2012-06-12 01:14:12 -06:00
|
|
|
if (features->type > TABLETPC) {
|
2012-10-03 18:25:35 -06:00
|
|
|
/* MT Tablet PC touch */
|
2014-07-24 13:56:22 -06:00
|
|
|
return wacom_set_device_mode(hdev, 3, 4, 4);
|
2012-10-03 18:25:35 -06:00
|
|
|
}
|
2013-09-20 10:47:35 -06:00
|
|
|
else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) {
|
2014-07-24 13:56:22 -06:00
|
|
|
return wacom_set_device_mode(hdev, 18, 3, 2);
|
2012-10-21 01:38:04 -06:00
|
|
|
}
|
2012-10-03 18:25:35 -06:00
|
|
|
} else if (features->device_type == BTN_TOOL_PEN) {
|
|
|
|
if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
|
2014-07-24 13:56:22 -06:00
|
|
|
return wacom_set_device_mode(hdev, 2, 2, 2);
|
2012-04-29 22:09:18 -06:00
|
|
|
}
|
2009-12-15 01:35:24 -07:00
|
|
|
}
|
2009-08-20 22:41:04 -06:00
|
|
|
|
2012-10-03 18:25:35 -06:00
|
|
|
return 0;
|
2009-08-20 22:41:04 -06:00
|
|
|
}
|
|
|
|
|
2014-07-24 14:02:14 -06:00
|
|
|
static void wacom_retrieve_hid_descriptor(struct hid_device *hdev,
|
2012-04-29 22:09:18 -06:00
|
|
|
struct wacom_features *features)
|
2009-12-15 01:35:24 -07:00
|
|
|
{
|
2014-07-24 13:56:22 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
|
|
|
struct usb_interface *intf = wacom->intf;
|
2009-12-15 01:35:24 -07:00
|
|
|
|
2010-09-05 13:25:11 -06:00
|
|
|
/* default features */
|
2009-12-15 01:35:24 -07:00
|
|
|
features->device_type = BTN_TOOL_PEN;
|
2010-09-05 13:25:11 -06:00
|
|
|
features->x_fuzz = 4;
|
|
|
|
features->y_fuzz = 4;
|
|
|
|
features->pressure_fuzz = 0;
|
|
|
|
features->distance_fuzz = 0;
|
2009-12-15 01:35:24 -07:00
|
|
|
|
2012-03-26 00:26:11 -06:00
|
|
|
/*
|
|
|
|
* The wireless device HID is basic and layout conflicts with
|
|
|
|
* other tablets (monitor and touch interface can look like pen).
|
|
|
|
* Skip the query for this type and modify defaults based on
|
|
|
|
* interface number.
|
|
|
|
*/
|
|
|
|
if (features->type == WIRELESS) {
|
|
|
|
if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
|
|
|
|
features->device_type = 0;
|
|
|
|
} else if (intf->cur_altsetting->desc.bInterfaceNumber == 2) {
|
2012-06-28 17:48:17 -06:00
|
|
|
features->device_type = BTN_TOOL_FINGER;
|
2012-03-26 00:26:11 -06:00
|
|
|
features->pktlen = WACOM_PKGLEN_BBTOUCH3;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-04-29 22:09:18 -06:00
|
|
|
/* only devices that support touch need to retrieve the info */
|
2014-07-24 14:02:14 -06:00
|
|
|
if (features->type < BAMBOO_PT)
|
|
|
|
return;
|
2009-12-15 01:35:24 -07:00
|
|
|
|
2014-07-24 14:02:14 -06:00
|
|
|
wacom_parse_hid(hdev, features);
|
2009-12-15 01:35:24 -07:00
|
|
|
}
|
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
struct wacom_hdev_data {
|
2010-03-19 23:18:15 -06:00
|
|
|
struct list_head list;
|
|
|
|
struct kref kref;
|
2014-07-24 14:01:05 -06:00
|
|
|
struct hid_device *dev;
|
2010-03-19 23:18:15 -06:00
|
|
|
struct wacom_shared shared;
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(wacom_udev_list);
|
|
|
|
static DEFINE_MUTEX(wacom_udev_list_lock);
|
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
static bool wacom_are_sibling(struct hid_device *hdev,
|
|
|
|
struct hid_device *sibling)
|
2012-10-21 01:38:03 -06:00
|
|
|
{
|
2014-07-24 14:01:05 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
|
|
|
struct wacom_features *features = &wacom->wacom_wac.features;
|
|
|
|
int vid = features->oVid;
|
|
|
|
int pid = features->oPid;
|
|
|
|
int n1,n2;
|
|
|
|
|
|
|
|
if (vid == 0 && pid == 0) {
|
|
|
|
vid = hdev->vendor;
|
|
|
|
pid = hdev->product;
|
|
|
|
}
|
2012-10-21 01:38:03 -06:00
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
if (vid != sibling->vendor || pid != sibling->product)
|
|
|
|
return false;
|
2012-10-21 01:38:03 -06:00
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
/* Compare the physical path. */
|
|
|
|
n1 = strrchr(hdev->phys, '.') - hdev->phys;
|
|
|
|
n2 = strrchr(sibling->phys, '.') - sibling->phys;
|
|
|
|
if (n1 != n2 || n1 <= 0 || n2 <= 0)
|
|
|
|
return false;
|
2012-10-21 01:38:03 -06:00
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
return !strncmp(hdev->phys, sibling->phys, n1);
|
2012-10-21 01:38:03 -06:00
|
|
|
}
|
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
static struct wacom_hdev_data *wacom_get_hdev_data(struct hid_device *hdev)
|
2010-03-19 23:18:15 -06:00
|
|
|
{
|
2014-07-24 14:01:05 -06:00
|
|
|
struct wacom_hdev_data *data;
|
2010-03-19 23:18:15 -06:00
|
|
|
|
|
|
|
list_for_each_entry(data, &wacom_udev_list, list) {
|
2014-07-24 14:01:05 -06:00
|
|
|
if (wacom_are_sibling(hdev, data->dev)) {
|
2010-03-19 23:18:15 -06:00
|
|
|
kref_get(&data->kref);
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
static int wacom_add_shared_data(struct hid_device *hdev)
|
2010-03-19 23:18:15 -06:00
|
|
|
{
|
2014-07-24 14:01:05 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
|
|
|
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
|
|
|
|
struct wacom_hdev_data *data;
|
2010-03-19 23:18:15 -06:00
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
mutex_lock(&wacom_udev_list_lock);
|
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
data = wacom_get_hdev_data(hdev);
|
2010-03-19 23:18:15 -06:00
|
|
|
if (!data) {
|
2014-07-24 14:01:05 -06:00
|
|
|
data = kzalloc(sizeof(struct wacom_hdev_data), GFP_KERNEL);
|
2010-03-19 23:18:15 -06:00
|
|
|
if (!data) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
kref_init(&data->kref);
|
2014-07-24 14:01:05 -06:00
|
|
|
data->dev = hdev;
|
2010-03-19 23:18:15 -06:00
|
|
|
list_add_tail(&data->list, &wacom_udev_list);
|
|
|
|
}
|
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
wacom_wac->shared = &data->shared;
|
2010-03-19 23:18:15 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&wacom_udev_list_lock);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_release_shared_data(struct kref *kref)
|
|
|
|
{
|
2014-07-24 14:01:05 -06:00
|
|
|
struct wacom_hdev_data *data =
|
|
|
|
container_of(kref, struct wacom_hdev_data, kref);
|
2010-03-19 23:18:15 -06:00
|
|
|
|
|
|
|
mutex_lock(&wacom_udev_list_lock);
|
|
|
|
list_del(&data->list);
|
|
|
|
mutex_unlock(&wacom_udev_list_lock);
|
|
|
|
|
|
|
|
kfree(data);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_remove_shared_data(struct wacom_wac *wacom)
|
|
|
|
{
|
2014-07-24 14:01:05 -06:00
|
|
|
struct wacom_hdev_data *data;
|
2010-03-19 23:18:15 -06:00
|
|
|
|
|
|
|
if (wacom->shared) {
|
2014-07-24 14:01:05 -06:00
|
|
|
data = container_of(wacom->shared, struct wacom_hdev_data, shared);
|
2010-03-19 23:18:15 -06:00
|
|
|
kref_put(&data->kref, wacom_release_shared_data);
|
|
|
|
wacom->shared = NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-09-07 15:08:54 -06:00
|
|
|
static int wacom_led_control(struct wacom *wacom)
|
|
|
|
{
|
|
|
|
unsigned char *buf;
|
2012-04-03 16:50:37 -06:00
|
|
|
int retval;
|
2014-09-10 13:41:31 -06:00
|
|
|
unsigned char report_id = WAC_CMD_LED_CONTROL;
|
|
|
|
int buf_size = 9;
|
2011-09-07 15:08:54 -06:00
|
|
|
|
2014-09-10 13:41:31 -06:00
|
|
|
if (wacom->wacom_wac.pid) { /* wireless connected */
|
|
|
|
report_id = WAC_CMD_WL_LED_CONTROL;
|
|
|
|
buf_size = 13;
|
|
|
|
}
|
|
|
|
buf = kzalloc(buf_size, GFP_KERNEL);
|
2011-09-07 15:08:54 -06:00
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2012-04-03 16:50:37 -06:00
|
|
|
if (wacom->wacom_wac.features.type >= INTUOS5S &&
|
2013-09-20 10:51:56 -06:00
|
|
|
wacom->wacom_wac.features.type <= INTUOSPL) {
|
2012-04-03 16:50:37 -06:00
|
|
|
/*
|
|
|
|
* Touch Ring and crop mark LED luminance may take on
|
|
|
|
* one of four values:
|
|
|
|
* 0 = Low; 1 = Medium; 2 = High; 3 = Off
|
|
|
|
*/
|
|
|
|
int ring_led = wacom->led.select[0] & 0x03;
|
|
|
|
int ring_lum = (((wacom->led.llv & 0x60) >> 5) - 1) & 0x03;
|
|
|
|
int crop_lum = 0;
|
2014-09-10 13:41:31 -06:00
|
|
|
unsigned char led_bits = (crop_lum << 4) | (ring_lum << 2) | (ring_led);
|
|
|
|
|
|
|
|
buf[0] = report_id;
|
|
|
|
if (wacom->wacom_wac.pid) {
|
|
|
|
wacom_get_report(wacom->hdev, HID_FEATURE_REPORT,
|
|
|
|
buf, buf_size, WAC_CMD_RETRIES);
|
|
|
|
buf[0] = report_id;
|
|
|
|
buf[4] = led_bits;
|
|
|
|
} else
|
|
|
|
buf[1] = led_bits;
|
2012-04-03 16:50:37 -06:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
int led = wacom->led.select[0] | 0x4;
|
|
|
|
|
|
|
|
if (wacom->wacom_wac.features.type == WACOM_21UX2 ||
|
|
|
|
wacom->wacom_wac.features.type == WACOM_24HD)
|
|
|
|
led |= (wacom->led.select[1] << 4) | 0x40;
|
|
|
|
|
2014-09-10 13:41:31 -06:00
|
|
|
buf[0] = report_id;
|
2012-04-03 16:50:37 -06:00
|
|
|
buf[1] = led;
|
|
|
|
buf[2] = wacom->led.llv;
|
|
|
|
buf[3] = wacom->led.hlv;
|
|
|
|
buf[4] = wacom->led.img_lum;
|
|
|
|
}
|
2011-09-07 15:08:54 -06:00
|
|
|
|
2014-09-10 13:41:31 -06:00
|
|
|
retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, buf_size,
|
2014-08-06 15:00:38 -06:00
|
|
|
WAC_CMD_RETRIES);
|
2011-09-07 15:08:54 -06:00
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2014-08-06 14:58:25 -06:00
|
|
|
static int wacom_led_putimage(struct wacom *wacom, int button_id, u8 xfer_id,
|
|
|
|
const unsigned len, const void *img)
|
2011-09-07 15:08:54 -06:00
|
|
|
{
|
|
|
|
unsigned char *buf;
|
|
|
|
int i, retval;
|
2014-08-06 14:58:25 -06:00
|
|
|
const unsigned chunk_len = len / 4; /* 4 chunks are needed to be sent */
|
2011-09-07 15:08:54 -06:00
|
|
|
|
2014-08-06 14:58:25 -06:00
|
|
|
buf = kzalloc(chunk_len + 3 , GFP_KERNEL);
|
2011-09-07 15:08:54 -06:00
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Send 'start' command */
|
|
|
|
buf[0] = WAC_CMD_ICON_START;
|
|
|
|
buf[1] = 1;
|
2014-08-06 15:00:38 -06:00
|
|
|
retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
|
|
|
|
WAC_CMD_RETRIES);
|
2011-09-07 15:08:54 -06:00
|
|
|
if (retval < 0)
|
|
|
|
goto out;
|
|
|
|
|
2014-08-06 14:58:25 -06:00
|
|
|
buf[0] = xfer_id;
|
2011-09-07 15:08:54 -06:00
|
|
|
buf[1] = button_id & 0x07;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
buf[2] = i;
|
2014-08-06 14:58:25 -06:00
|
|
|
memcpy(buf + 3, img + i * chunk_len, chunk_len);
|
2011-09-07 15:08:54 -06:00
|
|
|
|
2014-07-24 13:56:22 -06:00
|
|
|
retval = wacom_set_report(wacom->hdev, HID_FEATURE_REPORT,
|
2014-08-06 15:00:38 -06:00
|
|
|
buf, chunk_len + 3, WAC_CMD_RETRIES);
|
2011-09-07 15:08:54 -06:00
|
|
|
if (retval < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send 'stop' */
|
|
|
|
buf[0] = WAC_CMD_ICON_START;
|
|
|
|
buf[1] = 0;
|
2014-08-06 15:00:38 -06:00
|
|
|
wacom_set_report(wacom->hdev, HID_FEATURE_REPORT, buf, 2,
|
|
|
|
WAC_CMD_RETRIES);
|
2011-09-07 15:08:54 -06:00
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(buf);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
static ssize_t wacom_led_select_store(struct device *dev, int set_id,
|
2011-09-07 15:08:54 -06:00
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2014-07-24 13:59:45 -06:00
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
2014-07-24 13:52:23 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
2011-09-07 15:08:54 -06:00
|
|
|
unsigned int id;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtouint(buf, 10, &id);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
mutex_lock(&wacom->lock);
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
wacom->led.select[set_id] = id & 0x3;
|
2011-09-07 15:08:54 -06:00
|
|
|
err = wacom_led_control(wacom);
|
|
|
|
|
|
|
|
mutex_unlock(&wacom->lock);
|
|
|
|
|
|
|
|
return err < 0 ? err : count;
|
|
|
|
}
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
#define DEVICE_LED_SELECT_ATTR(SET_ID) \
|
|
|
|
static ssize_t wacom_led##SET_ID##_select_store(struct device *dev, \
|
|
|
|
struct device_attribute *attr, const char *buf, size_t count) \
|
|
|
|
{ \
|
|
|
|
return wacom_led_select_store(dev, SET_ID, buf, count); \
|
|
|
|
} \
|
2011-10-05 00:51:49 -06:00
|
|
|
static ssize_t wacom_led##SET_ID##_select_show(struct device *dev, \
|
|
|
|
struct device_attribute *attr, char *buf) \
|
|
|
|
{ \
|
2014-07-24 13:59:45 -06:00
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
|
2014-07-24 13:52:23 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev); \
|
2014-09-10 13:40:30 -06:00
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", \
|
|
|
|
wacom->led.select[SET_ID]); \
|
2011-10-05 00:51:49 -06:00
|
|
|
} \
|
2014-09-10 13:40:05 -06:00
|
|
|
static DEVICE_ATTR(status_led##SET_ID##_select, DEV_ATTR_RW_PERM, \
|
2011-10-05 00:51:49 -06:00
|
|
|
wacom_led##SET_ID##_select_show, \
|
2011-10-05 00:51:14 -06:00
|
|
|
wacom_led##SET_ID##_select_store)
|
|
|
|
|
|
|
|
DEVICE_LED_SELECT_ATTR(0);
|
|
|
|
DEVICE_LED_SELECT_ATTR(1);
|
2011-09-07 15:08:54 -06:00
|
|
|
|
|
|
|
static ssize_t wacom_luminance_store(struct wacom *wacom, u8 *dest,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
unsigned int value;
|
|
|
|
int err;
|
|
|
|
|
|
|
|
err = kstrtouint(buf, 10, &value);
|
|
|
|
if (err)
|
|
|
|
return err;
|
|
|
|
|
|
|
|
mutex_lock(&wacom->lock);
|
|
|
|
|
|
|
|
*dest = value & 0x7f;
|
|
|
|
err = wacom_led_control(wacom);
|
|
|
|
|
|
|
|
mutex_unlock(&wacom->lock);
|
|
|
|
|
|
|
|
return err < 0 ? err : count;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define DEVICE_LUMINANCE_ATTR(name, field) \
|
|
|
|
static ssize_t wacom_##name##_luminance_store(struct device *dev, \
|
|
|
|
struct device_attribute *attr, const char *buf, size_t count) \
|
|
|
|
{ \
|
2014-07-24 13:59:45 -06:00
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);\
|
2014-07-24 13:52:23 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev); \
|
2011-09-07 15:08:54 -06:00
|
|
|
\
|
|
|
|
return wacom_luminance_store(wacom, &wacom->led.field, \
|
|
|
|
buf, count); \
|
|
|
|
} \
|
2014-09-10 13:40:30 -06:00
|
|
|
static ssize_t wacom_##name##_luminance_show(struct device *dev, \
|
|
|
|
struct device_attribute *attr, char *buf) \
|
|
|
|
{ \
|
|
|
|
struct wacom *wacom = dev_get_drvdata(dev); \
|
|
|
|
return scnprintf(buf, PAGE_SIZE, "%d\n", wacom->led.field); \
|
|
|
|
} \
|
2014-09-10 13:40:05 -06:00
|
|
|
static DEVICE_ATTR(name##_luminance, DEV_ATTR_RW_PERM, \
|
2014-09-10 13:40:30 -06:00
|
|
|
wacom_##name##_luminance_show, \
|
|
|
|
wacom_##name##_luminance_store)
|
2011-09-07 15:08:54 -06:00
|
|
|
|
|
|
|
DEVICE_LUMINANCE_ATTR(status0, llv);
|
|
|
|
DEVICE_LUMINANCE_ATTR(status1, hlv);
|
|
|
|
DEVICE_LUMINANCE_ATTR(buttons, img_lum);
|
|
|
|
|
|
|
|
static ssize_t wacom_button_image_store(struct device *dev, int button_id,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
2014-07-24 13:59:45 -06:00
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
2014-07-24 13:52:23 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
2011-09-07 15:08:54 -06:00
|
|
|
int err;
|
2014-08-06 14:58:25 -06:00
|
|
|
unsigned len;
|
|
|
|
u8 xfer_id;
|
|
|
|
|
|
|
|
if (hdev->bus == BUS_BLUETOOTH) {
|
|
|
|
len = 256;
|
|
|
|
xfer_id = WAC_CMD_ICON_BT_XFER;
|
|
|
|
} else {
|
|
|
|
len = 1024;
|
|
|
|
xfer_id = WAC_CMD_ICON_XFER;
|
|
|
|
}
|
2011-09-07 15:08:54 -06:00
|
|
|
|
2014-08-06 14:58:25 -06:00
|
|
|
if (count != len)
|
2011-09-07 15:08:54 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&wacom->lock);
|
|
|
|
|
2014-08-06 14:58:25 -06:00
|
|
|
err = wacom_led_putimage(wacom, button_id, xfer_id, len, buf);
|
2011-09-07 15:08:54 -06:00
|
|
|
|
|
|
|
mutex_unlock(&wacom->lock);
|
|
|
|
|
|
|
|
return err < 0 ? err : count;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define DEVICE_BTNIMG_ATTR(BUTTON_ID) \
|
|
|
|
static ssize_t wacom_btnimg##BUTTON_ID##_store(struct device *dev, \
|
|
|
|
struct device_attribute *attr, const char *buf, size_t count) \
|
|
|
|
{ \
|
|
|
|
return wacom_button_image_store(dev, BUTTON_ID, buf, count); \
|
|
|
|
} \
|
2014-09-10 13:40:05 -06:00
|
|
|
static DEVICE_ATTR(button##BUTTON_ID##_rawimg, DEV_ATTR_WO_PERM, \
|
2011-09-07 15:08:54 -06:00
|
|
|
NULL, wacom_btnimg##BUTTON_ID##_store)
|
|
|
|
|
|
|
|
DEVICE_BTNIMG_ATTR(0);
|
|
|
|
DEVICE_BTNIMG_ATTR(1);
|
|
|
|
DEVICE_BTNIMG_ATTR(2);
|
|
|
|
DEVICE_BTNIMG_ATTR(3);
|
|
|
|
DEVICE_BTNIMG_ATTR(4);
|
|
|
|
DEVICE_BTNIMG_ATTR(5);
|
|
|
|
DEVICE_BTNIMG_ATTR(6);
|
|
|
|
DEVICE_BTNIMG_ATTR(7);
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
static struct attribute *cintiq_led_attrs[] = {
|
|
|
|
&dev_attr_status_led0_select.attr,
|
|
|
|
&dev_attr_status_led1_select.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group cintiq_led_attr_group = {
|
|
|
|
.name = "wacom_led",
|
|
|
|
.attrs = cintiq_led_attrs,
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute *intuos4_led_attrs[] = {
|
2011-09-07 15:08:54 -06:00
|
|
|
&dev_attr_status0_luminance.attr,
|
|
|
|
&dev_attr_status1_luminance.attr,
|
2011-10-05 00:51:14 -06:00
|
|
|
&dev_attr_status_led0_select.attr,
|
2011-09-07 15:08:54 -06:00
|
|
|
&dev_attr_buttons_luminance.attr,
|
|
|
|
&dev_attr_button0_rawimg.attr,
|
|
|
|
&dev_attr_button1_rawimg.attr,
|
|
|
|
&dev_attr_button2_rawimg.attr,
|
|
|
|
&dev_attr_button3_rawimg.attr,
|
|
|
|
&dev_attr_button4_rawimg.attr,
|
|
|
|
&dev_attr_button5_rawimg.attr,
|
|
|
|
&dev_attr_button6_rawimg.attr,
|
|
|
|
&dev_attr_button7_rawimg.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
static struct attribute_group intuos4_led_attr_group = {
|
2011-09-07 15:08:54 -06:00
|
|
|
.name = "wacom_led",
|
2011-10-05 00:51:14 -06:00
|
|
|
.attrs = intuos4_led_attrs,
|
2011-09-07 15:08:54 -06:00
|
|
|
};
|
|
|
|
|
2012-04-03 16:50:37 -06:00
|
|
|
static struct attribute *intuos5_led_attrs[] = {
|
|
|
|
&dev_attr_status0_luminance.attr,
|
|
|
|
&dev_attr_status_led0_select.attr,
|
|
|
|
NULL
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct attribute_group intuos5_led_attr_group = {
|
|
|
|
.name = "wacom_led",
|
|
|
|
.attrs = intuos5_led_attrs,
|
|
|
|
};
|
|
|
|
|
2011-09-07 15:08:54 -06:00
|
|
|
static int wacom_initialize_leds(struct wacom *wacom)
|
|
|
|
{
|
|
|
|
int error;
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
/* Initialize default values */
|
|
|
|
switch (wacom->wacom_wac.features.type) {
|
2012-06-12 01:27:53 -06:00
|
|
|
case INTUOS4S:
|
2011-10-05 00:51:14 -06:00
|
|
|
case INTUOS4:
|
2014-08-06 14:55:56 -06:00
|
|
|
case INTUOS4WL:
|
2011-10-05 00:51:14 -06:00
|
|
|
case INTUOS4L:
|
|
|
|
wacom->led.select[0] = 0;
|
|
|
|
wacom->led.select[1] = 0;
|
2011-10-05 00:49:42 -06:00
|
|
|
wacom->led.llv = 10;
|
2011-09-07 15:08:54 -06:00
|
|
|
wacom->led.hlv = 20;
|
|
|
|
wacom->led.img_lum = 10;
|
2014-07-24 13:59:45 -06:00
|
|
|
error = sysfs_create_group(&wacom->hdev->dev.kobj,
|
2011-10-05 00:51:14 -06:00
|
|
|
&intuos4_led_attr_group);
|
|
|
|
break;
|
|
|
|
|
2011-12-12 01:12:04 -07:00
|
|
|
case WACOM_24HD:
|
2011-10-05 00:51:14 -06:00
|
|
|
case WACOM_21UX2:
|
|
|
|
wacom->led.select[0] = 0;
|
|
|
|
wacom->led.select[1] = 0;
|
|
|
|
wacom->led.llv = 0;
|
|
|
|
wacom->led.hlv = 0;
|
|
|
|
wacom->led.img_lum = 0;
|
2011-09-07 15:08:54 -06:00
|
|
|
|
2014-07-24 13:59:45 -06:00
|
|
|
error = sysfs_create_group(&wacom->hdev->dev.kobj,
|
2011-10-05 00:51:14 -06:00
|
|
|
&cintiq_led_attr_group);
|
|
|
|
break;
|
|
|
|
|
2012-04-03 16:50:37 -06:00
|
|
|
case INTUOS5S:
|
|
|
|
case INTUOS5:
|
|
|
|
case INTUOS5L:
|
2013-09-20 10:51:56 -06:00
|
|
|
case INTUOSPS:
|
|
|
|
case INTUOSPM:
|
|
|
|
case INTUOSPL:
|
2013-09-20 10:50:14 -06:00
|
|
|
if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN) {
|
|
|
|
wacom->led.select[0] = 0;
|
|
|
|
wacom->led.select[1] = 0;
|
|
|
|
wacom->led.llv = 32;
|
|
|
|
wacom->led.hlv = 0;
|
|
|
|
wacom->led.img_lum = 0;
|
|
|
|
|
2014-07-24 13:59:45 -06:00
|
|
|
error = sysfs_create_group(&wacom->hdev->dev.kobj,
|
2013-09-20 10:50:14 -06:00
|
|
|
&intuos5_led_attr_group);
|
|
|
|
} else
|
|
|
|
return 0;
|
2012-04-03 16:50:37 -06:00
|
|
|
break;
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
default:
|
|
|
|
return 0;
|
2011-09-07 15:08:54 -06:00
|
|
|
}
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
if (error) {
|
2014-07-24 13:59:45 -06:00
|
|
|
hid_err(wacom->hdev,
|
2011-10-05 00:51:14 -06:00
|
|
|
"cannot create sysfs group err: %d\n", error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
wacom_led_control(wacom);
|
2014-07-24 14:16:17 -06:00
|
|
|
wacom->led_initialized = true;
|
2011-10-05 00:51:14 -06:00
|
|
|
|
2011-09-07 15:08:54 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_destroy_leds(struct wacom *wacom)
|
|
|
|
{
|
2014-07-24 14:16:17 -06:00
|
|
|
if (!wacom->led_initialized)
|
|
|
|
return;
|
|
|
|
|
|
|
|
wacom->led_initialized = false;
|
|
|
|
|
2011-10-05 00:51:14 -06:00
|
|
|
switch (wacom->wacom_wac.features.type) {
|
2012-06-12 01:27:53 -06:00
|
|
|
case INTUOS4S:
|
2011-10-05 00:51:14 -06:00
|
|
|
case INTUOS4:
|
2014-08-06 14:55:56 -06:00
|
|
|
case INTUOS4WL:
|
2011-10-05 00:51:14 -06:00
|
|
|
case INTUOS4L:
|
2014-07-24 13:59:45 -06:00
|
|
|
sysfs_remove_group(&wacom->hdev->dev.kobj,
|
2011-10-05 00:51:14 -06:00
|
|
|
&intuos4_led_attr_group);
|
|
|
|
break;
|
|
|
|
|
2011-12-12 01:12:04 -07:00
|
|
|
case WACOM_24HD:
|
2011-10-05 00:51:14 -06:00
|
|
|
case WACOM_21UX2:
|
2014-07-24 13:59:45 -06:00
|
|
|
sysfs_remove_group(&wacom->hdev->dev.kobj,
|
2011-10-05 00:51:14 -06:00
|
|
|
&cintiq_led_attr_group);
|
|
|
|
break;
|
2012-04-03 16:50:37 -06:00
|
|
|
|
|
|
|
case INTUOS5S:
|
|
|
|
case INTUOS5:
|
|
|
|
case INTUOS5L:
|
2013-09-20 10:51:56 -06:00
|
|
|
case INTUOSPS:
|
|
|
|
case INTUOSPM:
|
|
|
|
case INTUOSPL:
|
2013-09-20 10:50:14 -06:00
|
|
|
if (wacom->wacom_wac.features.device_type == BTN_TOOL_PEN)
|
2014-07-24 13:59:45 -06:00
|
|
|
sysfs_remove_group(&wacom->hdev->dev.kobj,
|
2013-09-20 10:50:14 -06:00
|
|
|
&intuos5_led_attr_group);
|
2012-04-03 16:50:37 -06:00
|
|
|
break;
|
2011-09-07 15:08:54 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-03-26 00:26:30 -06:00
|
|
|
static enum power_supply_property wacom_battery_props[] = {
|
2014-07-25 18:29:48 -06:00
|
|
|
POWER_SUPPLY_PROP_STATUS,
|
2013-10-16 00:33:00 -06:00
|
|
|
POWER_SUPPLY_PROP_SCOPE,
|
2012-03-26 00:26:30 -06:00
|
|
|
POWER_SUPPLY_PROP_CAPACITY
|
|
|
|
};
|
|
|
|
|
2014-07-25 18:32:41 -06:00
|
|
|
static enum power_supply_property wacom_ac_props[] = {
|
|
|
|
POWER_SUPPLY_PROP_PRESENT,
|
|
|
|
POWER_SUPPLY_PROP_ONLINE,
|
|
|
|
POWER_SUPPLY_PROP_SCOPE,
|
|
|
|
};
|
|
|
|
|
2012-03-26 00:26:30 -06:00
|
|
|
static int wacom_battery_get_property(struct power_supply *psy,
|
|
|
|
enum power_supply_property psp,
|
|
|
|
union power_supply_propval *val)
|
|
|
|
{
|
|
|
|
struct wacom *wacom = container_of(psy, struct wacom, battery);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
switch (psp) {
|
2013-10-16 00:33:00 -06:00
|
|
|
case POWER_SUPPLY_PROP_SCOPE:
|
|
|
|
val->intval = POWER_SUPPLY_SCOPE_DEVICE;
|
|
|
|
break;
|
2012-03-26 00:26:30 -06:00
|
|
|
case POWER_SUPPLY_PROP_CAPACITY:
|
|
|
|
val->intval =
|
2014-07-25 18:29:48 -06:00
|
|
|
wacom->wacom_wac.battery_capacity;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_STATUS:
|
|
|
|
if (wacom->wacom_wac.bat_charging)
|
|
|
|
val->intval = POWER_SUPPLY_STATUS_CHARGING;
|
|
|
|
else if (wacom->wacom_wac.battery_capacity == 100 &&
|
|
|
|
wacom->wacom_wac.ps_connected)
|
|
|
|
val->intval = POWER_SUPPLY_STATUS_FULL;
|
|
|
|
else
|
|
|
|
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
|
2012-03-26 00:26:30 -06:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-07-25 18:32:41 -06:00
|
|
|
static int wacom_ac_get_property(struct power_supply *psy,
|
|
|
|
enum power_supply_property psp,
|
|
|
|
union power_supply_propval *val)
|
|
|
|
{
|
|
|
|
struct wacom *wacom = container_of(psy, struct wacom, ac);
|
|
|
|
int ret = 0;
|
|
|
|
|
|
|
|
switch (psp) {
|
|
|
|
case POWER_SUPPLY_PROP_PRESENT:
|
|
|
|
/* fall through */
|
|
|
|
case POWER_SUPPLY_PROP_ONLINE:
|
|
|
|
val->intval = wacom->wacom_wac.ps_connected;
|
|
|
|
break;
|
|
|
|
case POWER_SUPPLY_PROP_SCOPE:
|
|
|
|
val->intval = POWER_SUPPLY_SCOPE_DEVICE;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-03-26 00:26:30 -06:00
|
|
|
static int wacom_initialize_battery(struct wacom *wacom)
|
|
|
|
{
|
2014-07-25 18:31:51 -06:00
|
|
|
static atomic_t battery_no = ATOMIC_INIT(0);
|
2014-07-25 18:32:41 -06:00
|
|
|
int error;
|
2014-07-25 18:31:51 -06:00
|
|
|
unsigned long n;
|
2012-03-26 00:26:30 -06:00
|
|
|
|
2014-07-25 18:29:48 -06:00
|
|
|
if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) {
|
2014-07-25 18:31:51 -06:00
|
|
|
n = atomic_inc_return(&battery_no) - 1;
|
2014-07-25 18:32:41 -06:00
|
|
|
|
2012-03-26 00:26:30 -06:00
|
|
|
wacom->battery.properties = wacom_battery_props;
|
|
|
|
wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
|
|
|
|
wacom->battery.get_property = wacom_battery_get_property;
|
2014-07-25 18:31:51 -06:00
|
|
|
sprintf(wacom->wacom_wac.bat_name, "wacom_battery_%ld", n);
|
|
|
|
wacom->battery.name = wacom->wacom_wac.bat_name;
|
2012-03-26 00:26:30 -06:00
|
|
|
wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
|
|
|
|
wacom->battery.use_for_apm = 0;
|
|
|
|
|
2014-07-25 18:32:41 -06:00
|
|
|
wacom->ac.properties = wacom_ac_props;
|
|
|
|
wacom->ac.num_properties = ARRAY_SIZE(wacom_ac_props);
|
|
|
|
wacom->ac.get_property = wacom_ac_get_property;
|
|
|
|
sprintf(wacom->wacom_wac.ac_name, "wacom_ac_%ld", n);
|
|
|
|
wacom->ac.name = wacom->wacom_wac.ac_name;
|
|
|
|
wacom->ac.type = POWER_SUPPLY_TYPE_MAINS;
|
|
|
|
wacom->ac.use_for_apm = 0;
|
|
|
|
|
2014-07-24 14:01:40 -06:00
|
|
|
error = power_supply_register(&wacom->hdev->dev,
|
2012-03-26 00:26:30 -06:00
|
|
|
&wacom->battery);
|
2014-07-25 18:32:41 -06:00
|
|
|
if (error)
|
|
|
|
return error;
|
|
|
|
|
|
|
|
power_supply_powers(&wacom->battery, &wacom->hdev->dev);
|
2012-06-12 01:25:23 -06:00
|
|
|
|
2014-07-25 18:32:41 -06:00
|
|
|
error = power_supply_register(&wacom->hdev->dev, &wacom->ac);
|
|
|
|
if (error) {
|
|
|
|
power_supply_unregister(&wacom->battery);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
power_supply_powers(&wacom->ac, &wacom->hdev->dev);
|
2012-03-26 00:26:30 -06:00
|
|
|
}
|
|
|
|
|
2014-07-25 18:32:41 -06:00
|
|
|
return 0;
|
2012-03-26 00:26:30 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_destroy_battery(struct wacom *wacom)
|
|
|
|
{
|
2014-07-25 18:29:48 -06:00
|
|
|
if ((wacom->wacom_wac.features.quirks & WACOM_QUIRK_BATTERY) &&
|
|
|
|
wacom->battery.dev) {
|
2012-03-26 00:26:30 -06:00
|
|
|
power_supply_unregister(&wacom->battery);
|
2012-06-12 01:25:23 -06:00
|
|
|
wacom->battery.dev = NULL;
|
2014-07-25 18:32:41 -06:00
|
|
|
power_supply_unregister(&wacom->ac);
|
|
|
|
wacom->ac.dev = NULL;
|
2012-06-12 01:25:23 -06:00
|
|
|
}
|
2012-03-26 00:26:30 -06:00
|
|
|
}
|
|
|
|
|
2014-08-06 14:48:01 -06:00
|
|
|
static ssize_t wacom_show_speed(struct device *dev,
|
|
|
|
struct device_attribute
|
|
|
|
*attr, char *buf)
|
|
|
|
{
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
|
|
|
|
|
|
|
return snprintf(buf, PAGE_SIZE, "%i\n", wacom->wacom_wac.bt_high_speed);
|
|
|
|
}
|
|
|
|
|
|
|
|
static ssize_t wacom_store_speed(struct device *dev,
|
|
|
|
struct device_attribute *attr,
|
|
|
|
const char *buf, size_t count)
|
|
|
|
{
|
|
|
|
struct hid_device *hdev = container_of(dev, struct hid_device, dev);
|
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
|
|
|
u8 new_speed;
|
|
|
|
|
|
|
|
if (kstrtou8(buf, 0, &new_speed))
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (new_speed != 0 && new_speed != 1)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
wacom_bt_query_tablet_data(hdev, new_speed, &wacom->wacom_wac.features);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
}
|
|
|
|
|
2014-09-10 13:40:05 -06:00
|
|
|
static DEVICE_ATTR(speed, DEV_ATTR_RW_PERM,
|
2014-08-06 14:48:01 -06:00
|
|
|
wacom_show_speed, wacom_store_speed);
|
|
|
|
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
static struct input_dev *wacom_allocate_input(struct wacom *wacom)
|
2012-03-26 00:25:45 -06:00
|
|
|
{
|
|
|
|
struct input_dev *input_dev;
|
2014-07-24 14:00:03 -06:00
|
|
|
struct hid_device *hdev = wacom->hdev;
|
2012-03-26 00:25:45 -06:00
|
|
|
struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
|
|
|
|
|
|
|
|
input_dev = input_allocate_device();
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
if (!input_dev)
|
|
|
|
return NULL;
|
2012-03-26 00:25:45 -06:00
|
|
|
|
|
|
|
input_dev->name = wacom_wac->name;
|
2014-07-24 14:00:03 -06:00
|
|
|
input_dev->phys = hdev->phys;
|
|
|
|
input_dev->dev.parent = &hdev->dev;
|
2012-03-26 00:25:45 -06:00
|
|
|
input_dev->open = wacom_open;
|
|
|
|
input_dev->close = wacom_close;
|
2014-07-24 14:00:03 -06:00
|
|
|
input_dev->uniq = hdev->uniq;
|
|
|
|
input_dev->id.bustype = hdev->bus;
|
|
|
|
input_dev->id.vendor = hdev->vendor;
|
2014-09-11 11:14:04 -06:00
|
|
|
input_dev->id.product = wacom_wac->pid ? wacom_wac->pid : hdev->product;
|
2014-07-24 14:00:03 -06:00
|
|
|
input_dev->id.version = hdev->version;
|
2012-03-26 00:25:45 -06:00
|
|
|
input_set_drvdata(input_dev, wacom);
|
|
|
|
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
return input_dev;
|
|
|
|
}
|
|
|
|
|
2014-09-23 10:08:06 -06:00
|
|
|
static void wacom_free_inputs(struct wacom *wacom)
|
2014-07-24 13:51:26 -06:00
|
|
|
{
|
2014-09-23 10:08:06 -06:00
|
|
|
struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
|
|
|
|
|
|
|
|
if (wacom_wac->input)
|
|
|
|
input_free_device(wacom_wac->input);
|
|
|
|
if (wacom_wac->pad_input)
|
|
|
|
input_free_device(wacom_wac->pad_input);
|
|
|
|
wacom_wac->input = NULL;
|
|
|
|
wacom_wac->pad_input = NULL;
|
2014-07-24 13:51:26 -06:00
|
|
|
}
|
|
|
|
|
2014-09-23 10:08:06 -06:00
|
|
|
static int wacom_allocate_inputs(struct wacom *wacom)
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
{
|
|
|
|
struct input_dev *input_dev, *pad_input_dev;
|
|
|
|
struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
|
|
|
|
|
|
|
|
input_dev = wacom_allocate_input(wacom);
|
|
|
|
pad_input_dev = wacom_allocate_input(wacom);
|
|
|
|
if (!input_dev || !pad_input_dev) {
|
2014-09-23 10:08:06 -06:00
|
|
|
wacom_free_inputs(wacom);
|
|
|
|
return -ENOMEM;
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
}
|
|
|
|
|
2012-03-26 00:25:45 -06:00
|
|
|
wacom_wac->input = input_dev;
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
wacom_wac->pad_input = pad_input_dev;
|
|
|
|
wacom_wac->pad_input->name = wacom_wac->pad_name;
|
|
|
|
|
2014-09-23 10:08:06 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_clean_inputs(struct wacom *wacom)
|
|
|
|
{
|
|
|
|
if (wacom->wacom_wac.input) {
|
|
|
|
if (wacom->wacom_wac.input_registered)
|
|
|
|
input_unregister_device(wacom->wacom_wac.input);
|
|
|
|
else
|
|
|
|
input_free_device(wacom->wacom_wac.input);
|
|
|
|
}
|
|
|
|
if (wacom->wacom_wac.pad_input) {
|
|
|
|
if (wacom->wacom_wac.input_registered)
|
|
|
|
input_unregister_device(wacom->wacom_wac.pad_input);
|
|
|
|
else
|
|
|
|
input_free_device(wacom->wacom_wac.pad_input);
|
|
|
|
}
|
|
|
|
wacom->wacom_wac.input = NULL;
|
|
|
|
wacom->wacom_wac.pad_input = NULL;
|
|
|
|
wacom_destroy_leds(wacom);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_register_inputs(struct wacom *wacom)
|
|
|
|
{
|
|
|
|
struct input_dev *input_dev, *pad_input_dev;
|
|
|
|
struct wacom_wac *wacom_wac = &(wacom->wacom_wac);
|
|
|
|
int error;
|
|
|
|
|
|
|
|
input_dev = wacom_wac->input;
|
|
|
|
pad_input_dev = wacom_wac->pad_input;
|
|
|
|
|
|
|
|
if (!input_dev || !pad_input_dev)
|
|
|
|
return -EINVAL;
|
|
|
|
|
2012-04-29 22:09:18 -06:00
|
|
|
error = wacom_setup_input_capabilities(input_dev, wacom_wac);
|
|
|
|
if (error)
|
2014-09-23 10:08:06 -06:00
|
|
|
return error;
|
2012-03-26 00:25:45 -06:00
|
|
|
|
|
|
|
error = input_register_device(input_dev);
|
2012-04-29 22:09:18 -06:00
|
|
|
if (error)
|
2014-09-23 10:08:06 -06:00
|
|
|
return error;
|
2012-04-29 22:09:18 -06:00
|
|
|
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
error = wacom_setup_pad_input_capabilities(pad_input_dev, wacom_wac);
|
|
|
|
if (error) {
|
|
|
|
/* no pad in use on this interface */
|
|
|
|
input_free_device(pad_input_dev);
|
|
|
|
wacom_wac->pad_input = NULL;
|
|
|
|
pad_input_dev = NULL;
|
|
|
|
} else {
|
|
|
|
error = input_register_device(pad_input_dev);
|
|
|
|
if (error)
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_register_pad_input;
|
2014-09-10 13:41:31 -06:00
|
|
|
|
|
|
|
error = wacom_initialize_leds(wacom);
|
|
|
|
if (error)
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_leds;
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
}
|
|
|
|
|
2014-09-23 10:08:06 -06:00
|
|
|
wacom_wac->input_registered = true;
|
|
|
|
|
2012-04-29 22:09:18 -06:00
|
|
|
return 0;
|
2012-03-26 00:25:45 -06:00
|
|
|
|
2014-09-23 10:08:05 -06:00
|
|
|
fail_leds:
|
2014-09-10 13:41:31 -06:00
|
|
|
input_unregister_device(pad_input_dev);
|
|
|
|
pad_input_dev = NULL;
|
2014-09-23 10:08:05 -06:00
|
|
|
fail_register_pad_input:
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
input_unregister_device(input_dev);
|
2012-04-29 22:09:18 -06:00
|
|
|
wacom_wac->input = NULL;
|
2012-03-26 00:25:45 -06:00
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2012-03-26 00:26:20 -06:00
|
|
|
static void wacom_wireless_work(struct work_struct *work)
|
|
|
|
{
|
|
|
|
struct wacom *wacom = container_of(work, struct wacom, work);
|
|
|
|
struct usb_device *usbdev = wacom->usbdev;
|
|
|
|
struct wacom_wac *wacom_wac = &wacom->wacom_wac;
|
2014-07-24 13:52:23 -06:00
|
|
|
struct hid_device *hdev1, *hdev2;
|
2012-06-12 01:25:23 -06:00
|
|
|
struct wacom *wacom1, *wacom2;
|
|
|
|
struct wacom_wac *wacom_wac1, *wacom_wac2;
|
|
|
|
int error;
|
2012-03-26 00:26:20 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Regardless if this is a disconnect or a new tablet,
|
2012-06-12 01:25:23 -06:00
|
|
|
* remove any existing input and battery devices.
|
2012-03-26 00:26:20 -06:00
|
|
|
*/
|
|
|
|
|
2012-06-12 01:25:23 -06:00
|
|
|
wacom_destroy_battery(wacom);
|
|
|
|
|
2012-03-26 00:26:20 -06:00
|
|
|
/* Stylus interface */
|
2014-07-24 13:52:23 -06:00
|
|
|
hdev1 = usb_get_intfdata(usbdev->config->interface[1]);
|
|
|
|
wacom1 = hid_get_drvdata(hdev1);
|
2012-06-12 01:25:23 -06:00
|
|
|
wacom_wac1 = &(wacom1->wacom_wac);
|
2014-09-23 10:08:06 -06:00
|
|
|
wacom_clean_inputs(wacom1);
|
2012-03-26 00:26:20 -06:00
|
|
|
|
|
|
|
/* Touch interface */
|
2014-07-24 13:52:23 -06:00
|
|
|
hdev2 = usb_get_intfdata(usbdev->config->interface[2]);
|
|
|
|
wacom2 = hid_get_drvdata(hdev2);
|
2012-06-12 01:25:23 -06:00
|
|
|
wacom_wac2 = &(wacom2->wacom_wac);
|
2014-09-23 10:08:06 -06:00
|
|
|
wacom_clean_inputs(wacom2);
|
2012-03-26 00:26:20 -06:00
|
|
|
|
|
|
|
if (wacom_wac->pid == 0) {
|
2014-07-24 14:01:56 -06:00
|
|
|
hid_info(wacom->hdev, "wireless tablet disconnected\n");
|
2014-07-25 18:29:48 -06:00
|
|
|
wacom_wac1->shared->type = 0;
|
2012-03-26 00:26:20 -06:00
|
|
|
} else {
|
2014-07-24 13:52:23 -06:00
|
|
|
const struct hid_device_id *id = wacom_ids;
|
2012-03-26 00:26:20 -06:00
|
|
|
|
2014-07-24 14:01:56 -06:00
|
|
|
hid_info(wacom->hdev, "wireless tablet connected with PID %x\n",
|
2012-05-02 01:13:38 -06:00
|
|
|
wacom_wac->pid);
|
2012-03-26 00:26:20 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
while (id->bus) {
|
|
|
|
if (id->vendor == USB_VENDOR_ID_WACOM &&
|
|
|
|
id->product == wacom_wac->pid)
|
2012-03-26 00:26:20 -06:00
|
|
|
break;
|
|
|
|
id++;
|
|
|
|
}
|
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
if (!id->bus) {
|
2014-07-24 14:01:56 -06:00
|
|
|
hid_info(wacom->hdev, "ignoring unknown PID.\n");
|
2012-03-26 00:26:20 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Stylus interface */
|
2012-06-12 01:25:23 -06:00
|
|
|
wacom_wac1->features =
|
2014-07-24 13:52:23 -06:00
|
|
|
*((struct wacom_features *)id->driver_data);
|
2012-06-12 01:25:23 -06:00
|
|
|
wacom_wac1->features.device_type = BTN_TOOL_PEN;
|
2013-10-16 00:44:00 -06:00
|
|
|
snprintf(wacom_wac1->name, WACOM_NAME_MAX, "%s (WL) Pen",
|
|
|
|
wacom_wac1->features.name);
|
2014-07-24 13:51:26 -06:00
|
|
|
snprintf(wacom_wac1->pad_name, WACOM_NAME_MAX, "%s (WL) Pad",
|
|
|
|
wacom_wac1->features.name);
|
2013-12-05 13:54:53 -07:00
|
|
|
wacom_wac1->shared->touch_max = wacom_wac1->features.touch_max;
|
|
|
|
wacom_wac1->shared->type = wacom_wac1->features.type;
|
2014-09-10 13:41:31 -06:00
|
|
|
wacom_wac1->pid = wacom_wac->pid;
|
2014-09-23 10:08:06 -06:00
|
|
|
error = wacom_allocate_inputs(wacom1) ||
|
|
|
|
wacom_register_inputs(wacom1);
|
2012-06-12 01:25:23 -06:00
|
|
|
if (error)
|
2013-10-16 00:44:00 -06:00
|
|
|
goto fail;
|
2012-03-26 00:26:20 -06:00
|
|
|
|
|
|
|
/* Touch interface */
|
2013-11-25 19:44:55 -07:00
|
|
|
if (wacom_wac1->features.touch_max ||
|
|
|
|
wacom_wac1->features.type == INTUOSHT) {
|
2013-10-16 00:44:00 -06:00
|
|
|
wacom_wac2->features =
|
2014-07-24 13:52:23 -06:00
|
|
|
*((struct wacom_features *)id->driver_data);
|
2013-10-16 00:44:00 -06:00
|
|
|
wacom_wac2->features.pktlen = WACOM_PKGLEN_BBTOUCH3;
|
|
|
|
wacom_wac2->features.device_type = BTN_TOOL_FINGER;
|
|
|
|
wacom_wac2->features.x_max = wacom_wac2->features.y_max = 4096;
|
|
|
|
if (wacom_wac2->features.touch_max)
|
|
|
|
snprintf(wacom_wac2->name, WACOM_NAME_MAX,
|
|
|
|
"%s (WL) Finger",wacom_wac2->features.name);
|
|
|
|
else
|
|
|
|
snprintf(wacom_wac2->name, WACOM_NAME_MAX,
|
|
|
|
"%s (WL) Pad",wacom_wac2->features.name);
|
2014-07-24 13:51:26 -06:00
|
|
|
snprintf(wacom_wac2->pad_name, WACOM_NAME_MAX,
|
|
|
|
"%s (WL) Pad", wacom_wac2->features.name);
|
2014-09-10 13:41:31 -06:00
|
|
|
wacom_wac2->pid = wacom_wac->pid;
|
2014-09-23 10:08:06 -06:00
|
|
|
error = wacom_allocate_inputs(wacom2) ||
|
|
|
|
wacom_register_inputs(wacom2);
|
2013-10-16 00:44:00 -06:00
|
|
|
if (error)
|
|
|
|
goto fail;
|
2013-12-05 13:54:53 -07:00
|
|
|
|
|
|
|
if (wacom_wac1->features.type == INTUOSHT &&
|
|
|
|
wacom_wac1->features.touch_max)
|
|
|
|
wacom_wac->shared->touch_input = wacom_wac2->input;
|
2013-10-16 00:44:00 -06:00
|
|
|
}
|
2012-06-12 01:25:23 -06:00
|
|
|
|
|
|
|
error = wacom_initialize_battery(wacom);
|
|
|
|
if (error)
|
2013-10-16 00:44:00 -06:00
|
|
|
goto fail;
|
2012-03-26 00:26:20 -06:00
|
|
|
}
|
2012-06-12 01:25:23 -06:00
|
|
|
|
|
|
|
return;
|
|
|
|
|
2013-10-16 00:44:00 -06:00
|
|
|
fail:
|
2014-09-23 10:08:06 -06:00
|
|
|
wacom_clean_inputs(wacom1);
|
|
|
|
wacom_clean_inputs(wacom2);
|
2012-06-12 01:25:23 -06:00
|
|
|
return;
|
2012-03-26 00:26:20 -06:00
|
|
|
}
|
|
|
|
|
2013-07-28 01:38:54 -06:00
|
|
|
/*
|
|
|
|
* Not all devices report physical dimensions from HID.
|
|
|
|
* Compute the default from hardcoded logical dimension
|
|
|
|
* and resolution before driver overwrites them.
|
|
|
|
*/
|
|
|
|
static void wacom_set_default_phy(struct wacom_features *features)
|
|
|
|
{
|
|
|
|
if (features->x_resolution) {
|
|
|
|
features->x_phy = (features->x_max * 100) /
|
|
|
|
features->x_resolution;
|
|
|
|
features->y_phy = (features->y_max * 100) /
|
|
|
|
features->y_resolution;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_calculate_res(struct wacom_features *features)
|
|
|
|
{
|
|
|
|
features->x_resolution = wacom_calc_hid_res(features->x_max,
|
|
|
|
features->x_phy,
|
|
|
|
features->unit,
|
|
|
|
features->unitExpo);
|
|
|
|
features->y_resolution = wacom_calc_hid_res(features->y_max,
|
|
|
|
features->y_phy,
|
|
|
|
features->unit,
|
|
|
|
features->unitExpo);
|
|
|
|
}
|
|
|
|
|
2014-07-24 13:59:11 -06:00
|
|
|
static int wacom_hid_report_len(struct hid_report *report)
|
|
|
|
{
|
|
|
|
/* equivalent to DIV_ROUND_UP(report->size, 8) + !!(report->id > 0) */
|
|
|
|
return ((report->size - 1) >> 3) + 1 + (report->id > 0);
|
|
|
|
}
|
|
|
|
|
|
|
|
static size_t wacom_compute_pktlen(struct hid_device *hdev)
|
|
|
|
{
|
|
|
|
struct hid_report_enum *report_enum;
|
|
|
|
struct hid_report *report;
|
|
|
|
size_t size = 0;
|
|
|
|
|
|
|
|
report_enum = hdev->report_enum + HID_INPUT_REPORT;
|
|
|
|
|
|
|
|
list_for_each_entry(report, &report_enum->report_list, list) {
|
|
|
|
size_t report_size = wacom_hid_report_len(report);
|
|
|
|
if (report_size > size)
|
|
|
|
size = report_size;
|
|
|
|
}
|
|
|
|
|
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
static int wacom_probe(struct hid_device *hdev,
|
|
|
|
const struct hid_device_id *id)
|
2006-07-13 19:01:36 -06:00
|
|
|
{
|
2014-07-24 13:52:23 -06:00
|
|
|
struct usb_interface *intf = to_usb_interface(hdev->dev.parent);
|
2006-07-13 19:01:36 -06:00
|
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
|
|
|
struct wacom *wacom;
|
|
|
|
struct wacom_wac *wacom_wac;
|
2010-02-17 23:38:31 -07:00
|
|
|
struct wacom_features *features;
|
|
|
|
int error;
|
2014-09-23 10:08:08 -06:00
|
|
|
unsigned int connect_mask = HID_CONNECT_HIDRAW;
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
if (!id->driver_data)
|
2010-02-11 00:06:23 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
2014-09-16 14:56:39 -06:00
|
|
|
hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
|
|
|
|
|
2006-07-13 19:01:36 -06:00
|
|
|
wacom = kzalloc(sizeof(struct wacom), GFP_KERNEL);
|
2012-03-29 23:38:11 -06:00
|
|
|
if (!wacom)
|
|
|
|
return -ENOMEM;
|
2010-02-17 23:38:31 -07:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
hid_set_drvdata(hdev, wacom);
|
|
|
|
wacom->hdev = hdev;
|
|
|
|
|
2014-07-24 13:58:45 -06:00
|
|
|
/* ask for the report descriptor to be loaded by HID */
|
|
|
|
error = hid_parse(hdev);
|
|
|
|
if (error) {
|
|
|
|
hid_err(hdev, "parse failed\n");
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_parse;
|
2014-07-24 13:58:45 -06:00
|
|
|
}
|
|
|
|
|
2010-03-19 23:18:15 -06:00
|
|
|
wacom_wac = &wacom->wacom_wac;
|
2014-07-24 13:52:23 -06:00
|
|
|
wacom_wac->features = *((struct wacom_features *)id->driver_data);
|
2010-02-17 23:38:31 -07:00
|
|
|
features = &wacom_wac->features;
|
2014-07-24 13:59:11 -06:00
|
|
|
features->pktlen = wacom_compute_pktlen(hdev);
|
2010-02-17 23:38:31 -07:00
|
|
|
if (features->pktlen > WACOM_PKGLEN_MAX) {
|
|
|
|
error = -EINVAL;
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_pktlen;
|
2010-02-17 23:38:31 -07:00
|
|
|
}
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
if (features->check_for_hid_type && features->hid_type != hdev->type) {
|
|
|
|
error = -ENODEV;
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_type;
|
2010-02-17 23:38:31 -07:00
|
|
|
}
|
2006-07-13 19:01:36 -06:00
|
|
|
|
|
|
|
wacom->usbdev = dev;
|
2008-04-14 23:31:57 -06:00
|
|
|
wacom->intf = intf;
|
|
|
|
mutex_init(&wacom->lock);
|
2012-03-26 00:26:20 -06:00
|
|
|
INIT_WORK(&wacom->work, wacom_wireless_work);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-09-23 10:08:07 -06:00
|
|
|
if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
|
|
|
|
error = wacom_allocate_inputs(wacom);
|
|
|
|
if (error)
|
|
|
|
goto fail_allocate_inputs;
|
|
|
|
}
|
|
|
|
|
2013-07-28 01:38:54 -06:00
|
|
|
/* set the default size in case we do not get them from hid */
|
|
|
|
wacom_set_default_phy(features);
|
|
|
|
|
2012-04-29 22:09:17 -06:00
|
|
|
/* Retrieve the physical and logical size for touch devices */
|
2014-07-24 14:02:14 -06:00
|
|
|
wacom_retrieve_hid_descriptor(hdev, features);
|
2008-11-24 09:44:27 -07:00
|
|
|
|
2012-04-03 16:50:40 -06:00
|
|
|
/*
|
|
|
|
* Intuos5 has no useful data about its touch interface in its
|
2014-07-24 13:59:11 -06:00
|
|
|
* HID descriptor. If this is the touch interface (PacketSize
|
2012-04-03 16:50:40 -06:00
|
|
|
* of WACOM_PKGLEN_BBTOUCH3), override the table values.
|
|
|
|
*/
|
2013-11-25 19:44:55 -07:00
|
|
|
if (features->type >= INTUOS5S && features->type <= INTUOSHT) {
|
2014-07-24 13:59:11 -06:00
|
|
|
if (features->pktlen == WACOM_PKGLEN_BBTOUCH3) {
|
2012-04-03 16:50:40 -06:00
|
|
|
features->device_type = BTN_TOOL_FINGER;
|
|
|
|
|
|
|
|
features->x_max = 4096;
|
|
|
|
features->y_max = 4096;
|
|
|
|
} else {
|
|
|
|
features->device_type = BTN_TOOL_PEN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-07-24 14:02:14 -06:00
|
|
|
/*
|
|
|
|
* Same thing for Bamboo 3rd gen.
|
|
|
|
*/
|
|
|
|
if ((features->type == BAMBOO_PT) &&
|
|
|
|
(features->pktlen == WACOM_PKGLEN_BBTOUCH3) &&
|
|
|
|
(features->device_type == BTN_TOOL_PEN)) {
|
|
|
|
features->device_type = BTN_TOOL_FINGER;
|
|
|
|
|
|
|
|
features->x_max = 4096;
|
|
|
|
features->y_max = 4096;
|
|
|
|
}
|
|
|
|
|
2014-08-06 14:48:01 -06:00
|
|
|
if (hdev->bus == BUS_BLUETOOTH)
|
|
|
|
features->quirks |= WACOM_QUIRK_BATTERY;
|
|
|
|
|
2010-09-05 13:26:16 -06:00
|
|
|
wacom_setup_device_quirks(features);
|
|
|
|
|
2013-07-28 01:38:54 -06:00
|
|
|
/* set unit to "100th of a mm" for devices not reported by HID */
|
|
|
|
if (!features->unit) {
|
|
|
|
features->unit = 0x11;
|
2014-07-24 14:02:14 -06:00
|
|
|
features->unitExpo = -3;
|
2013-07-28 01:38:54 -06:00
|
|
|
}
|
|
|
|
wacom_calculate_res(features);
|
|
|
|
|
2010-02-20 01:53:49 -07:00
|
|
|
strlcpy(wacom_wac->name, features->name, sizeof(wacom_wac->name));
|
Input: wacom - create a separate input device for pads
Currently, the pad events are sent through the stylus input device
for the Intuos/Cintiqs, and through the touch input device for the
Bamboos.
To differentiate the buttons pressed on the pad from the ones pressed
on the stylus, the Intuos/Cintiq uses MISC_SERIAL and ABS_MISC. This
lead to a multiplexing of the events into one device, which are then
splitted out in xf86-input-wacom. Bamboos are not using MISC events
because the pad is attached to the touch interface, and only BTN_TOUCH
is used for the finger (and DOUBLE_TAP, etc...). However, the user space
driver still splits out the pad from the touch interface in the same
way it does for the pro line devices.
The other problem we can see with this fact is that some of the Intuos
and Cintiq have a wheel, and the effective range of the reported values
is [0..71]. Unfortunately, the airbrush stylus also sends wheel events
(there is a small wheel on it), but in the range [0..1023]. From the user
space point of view it is kind of difficult to understand that because
the wheel on the pad are quite common, while the airbrush tool is not.
A solution to fix all of these problems is to split out the pad device
from the stylus/touch. This decision makes more sense because the pad is
not linked to the absolute position of the finger or pen, and usually, the
events from the pad are filtered out by the compositor, which then convert
them into actions or keyboard shortcuts.
For backward compatibility with current xf86-input-wacom, the pad devices
still present the ABS_X, ABS_Y and ABS_MISC events, but they can be
completely ignored in the new implementation.
Signed-off-by: Benjamin Tissoires <benjamin.tissoires@redhat.com>
Reviewed-by: Ping Cheng <pingc@wacom.com>
Reviewed-by: Jason Gerecke <killertofu@gmail.com>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>
2014-07-24 13:48:28 -06:00
|
|
|
snprintf(wacom_wac->pad_name, sizeof(wacom_wac->pad_name),
|
|
|
|
"%s Pad", features->name);
|
2010-02-20 01:53:49 -07:00
|
|
|
|
2010-09-05 13:26:16 -06:00
|
|
|
if (features->quirks & WACOM_QUIRK_MULTI_INPUT) {
|
2010-02-20 01:53:49 -07:00
|
|
|
/* Append the device type to the name */
|
2013-10-16 00:44:00 -06:00
|
|
|
if (features->device_type != BTN_TOOL_FINGER)
|
|
|
|
strlcat(wacom_wac->name, " Pen", WACOM_NAME_MAX);
|
|
|
|
else if (features->touch_max)
|
|
|
|
strlcat(wacom_wac->name, " Finger", WACOM_NAME_MAX);
|
|
|
|
else
|
|
|
|
strlcat(wacom_wac->name, " Pad", WACOM_NAME_MAX);
|
2010-03-19 23:18:15 -06:00
|
|
|
|
2014-07-24 14:01:05 -06:00
|
|
|
error = wacom_add_shared_data(hdev);
|
2010-03-19 23:18:15 -06:00
|
|
|
if (error)
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_shared_data;
|
2010-02-20 01:53:49 -07:00
|
|
|
}
|
|
|
|
|
2014-08-06 14:48:01 -06:00
|
|
|
if (!(features->quirks & WACOM_QUIRK_MONITOR) &&
|
|
|
|
(features->quirks & WACOM_QUIRK_BATTERY)) {
|
|
|
|
error = wacom_initialize_battery(wacom);
|
|
|
|
if (error)
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_battery;
|
2014-08-06 14:48:01 -06:00
|
|
|
}
|
|
|
|
|
2012-03-26 00:26:11 -06:00
|
|
|
if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
|
2014-09-23 10:08:07 -06:00
|
|
|
error = wacom_register_inputs(wacom);
|
2012-03-26 00:26:11 -06:00
|
|
|
if (error)
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_register_inputs;
|
2014-08-06 14:48:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
if (hdev->bus == BUS_BLUETOOTH) {
|
|
|
|
error = device_create_file(&hdev->dev, &dev_attr_speed);
|
|
|
|
if (error)
|
|
|
|
hid_warn(hdev,
|
|
|
|
"can't create sysfs speed attribute err: %d\n",
|
|
|
|
error);
|
2012-03-26 00:26:11 -06:00
|
|
|
}
|
2011-09-07 15:08:54 -06:00
|
|
|
|
2009-12-15 01:35:24 -07:00
|
|
|
/* Note that if query fails it is not a hard failure */
|
2014-07-24 13:56:22 -06:00
|
|
|
wacom_query_tablet_data(hdev, features);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-09-23 10:08:08 -06:00
|
|
|
if (features->type == HID_GENERIC)
|
|
|
|
connect_mask |= HID_CONNECT_DRIVER;
|
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
/* Regular HID work starts now */
|
2014-09-23 10:08:08 -06:00
|
|
|
error = hid_hw_start(hdev, connect_mask);
|
2014-07-24 13:52:23 -06:00
|
|
|
if (error) {
|
|
|
|
hid_err(hdev, "hw start failed\n");
|
2014-09-23 10:08:05 -06:00
|
|
|
goto fail_hw_start;
|
2012-03-26 00:26:11 -06:00
|
|
|
}
|
2013-12-05 13:54:53 -07:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
if (features->quirks & WACOM_QUIRK_MONITOR)
|
|
|
|
error = hid_hw_open(hdev);
|
|
|
|
|
2013-12-05 13:54:53 -07:00
|
|
|
if (wacom_wac->features.type == INTUOSHT && wacom_wac->features.touch_max) {
|
|
|
|
if (wacom_wac->features.device_type == BTN_TOOL_FINGER)
|
|
|
|
wacom_wac->shared->touch_input = wacom_wac->input;
|
|
|
|
}
|
|
|
|
|
2006-07-13 19:01:36 -06:00
|
|
|
return 0;
|
|
|
|
|
2014-09-23 10:08:05 -06:00
|
|
|
fail_hw_start:
|
|
|
|
if (hdev->bus == BUS_BLUETOOTH)
|
2014-08-06 14:48:01 -06:00
|
|
|
device_remove_file(&hdev->dev, &dev_attr_speed);
|
2014-09-23 10:08:05 -06:00
|
|
|
fail_register_inputs:
|
2014-09-23 10:08:06 -06:00
|
|
|
wacom_clean_inputs(wacom);
|
2014-09-23 10:08:05 -06:00
|
|
|
wacom_destroy_battery(wacom);
|
|
|
|
fail_battery:
|
|
|
|
wacom_remove_shared_data(wacom_wac);
|
|
|
|
fail_shared_data:
|
2014-09-23 10:08:07 -06:00
|
|
|
wacom_clean_inputs(wacom);
|
|
|
|
fail_allocate_inputs:
|
2014-09-23 10:08:05 -06:00
|
|
|
fail_type:
|
|
|
|
fail_pktlen:
|
|
|
|
fail_parse:
|
|
|
|
kfree(wacom);
|
2014-07-24 13:52:23 -06:00
|
|
|
hid_set_drvdata(hdev, NULL);
|
2007-04-11 23:33:39 -06:00
|
|
|
return error;
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
static void wacom_remove(struct hid_device *hdev)
|
2006-07-13 19:01:36 -06:00
|
|
|
{
|
2014-07-24 13:52:23 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
hid_hw_stop(hdev);
|
2008-04-14 23:31:57 -06:00
|
|
|
|
2012-03-26 00:26:20 -06:00
|
|
|
cancel_work_sync(&wacom->work);
|
2014-09-23 10:08:06 -06:00
|
|
|
wacom_clean_inputs(wacom);
|
2014-08-06 14:48:01 -06:00
|
|
|
if (hdev->bus == BUS_BLUETOOTH)
|
|
|
|
device_remove_file(&hdev->dev, &dev_attr_speed);
|
2012-03-26 00:26:30 -06:00
|
|
|
wacom_destroy_battery(wacom);
|
2010-03-19 23:18:15 -06:00
|
|
|
wacom_remove_shared_data(&wacom->wacom_wac);
|
2008-04-14 23:31:57 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
hid_set_drvdata(hdev, NULL);
|
|
|
|
kfree(wacom);
|
2008-04-14 23:31:57 -06:00
|
|
|
}
|
|
|
|
|
2014-08-11 12:03:19 -06:00
|
|
|
#ifdef CONFIG_PM
|
2014-07-24 13:52:23 -06:00
|
|
|
static int wacom_resume(struct hid_device *hdev)
|
2008-04-14 23:31:57 -06:00
|
|
|
{
|
2014-07-24 13:52:23 -06:00
|
|
|
struct wacom *wacom = hid_get_drvdata(hdev);
|
2010-03-19 23:18:15 -06:00
|
|
|
struct wacom_features *features = &wacom->wacom_wac.features;
|
2008-04-14 23:31:57 -06:00
|
|
|
|
|
|
|
mutex_lock(&wacom->lock);
|
2010-04-14 00:07:52 -06:00
|
|
|
|
|
|
|
/* switch to wacom mode first */
|
2014-07-24 13:56:22 -06:00
|
|
|
wacom_query_tablet_data(hdev, features);
|
2011-09-07 15:08:54 -06:00
|
|
|
wacom_led_control(wacom);
|
2010-04-14 00:07:52 -06:00
|
|
|
|
2008-04-14 23:31:57 -06:00
|
|
|
mutex_unlock(&wacom->lock);
|
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
return 0;
|
2008-04-14 23:31:57 -06:00
|
|
|
}
|
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
static int wacom_reset_resume(struct hid_device *hdev)
|
2008-04-14 23:31:57 -06:00
|
|
|
{
|
2014-07-24 13:52:23 -06:00
|
|
|
return wacom_resume(hdev);
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
2014-08-11 12:03:19 -06:00
|
|
|
#endif /* CONFIG_PM */
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2014-07-24 13:52:23 -06:00
|
|
|
static struct hid_driver wacom_driver = {
|
2006-07-13 19:01:36 -06:00
|
|
|
.name = "wacom",
|
2010-02-11 00:06:23 -07:00
|
|
|
.id_table = wacom_ids,
|
2006-07-13 19:01:36 -06:00
|
|
|
.probe = wacom_probe,
|
2014-07-24 13:52:23 -06:00
|
|
|
.remove = wacom_remove,
|
2014-09-23 10:08:08 -06:00
|
|
|
.event = wacom_wac_event,
|
|
|
|
.report = wacom_wac_report,
|
2014-07-24 13:52:23 -06:00
|
|
|
#ifdef CONFIG_PM
|
2008-04-14 23:31:57 -06:00
|
|
|
.resume = wacom_resume,
|
|
|
|
.reset_resume = wacom_reset_resume,
|
2014-07-24 13:52:23 -06:00
|
|
|
#endif
|
|
|
|
.raw_event = wacom_raw_event,
|
2006-07-13 19:01:36 -06:00
|
|
|
};
|
2014-07-24 13:52:23 -06:00
|
|
|
module_hid_driver(wacom_driver);
|
2014-08-06 15:07:49 -06:00
|
|
|
|
|
|
|
MODULE_VERSION(DRIVER_VERSION);
|
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
|
|
MODULE_LICENSE(DRIVER_LICENSE);
|