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"
|
2014-07-24 13:52:00 -06:00
|
|
|
#include <linux/hid.h>
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2008-11-24 09:44:27 -07:00
|
|
|
/* defines to get HID report descriptor */
|
|
|
|
#define HID_DEVICET_HID (USB_TYPE_CLASS | 0x01)
|
|
|
|
#define HID_DEVICET_REPORT (USB_TYPE_CLASS | 0x02)
|
2014-07-24 13:52:00 -06:00
|
|
|
#define HID_HDESC_USAGE_UNDEFINED 0x00
|
|
|
|
#define HID_HDESC_USAGE_PAGE 0x05
|
|
|
|
#define HID_HDESC_USAGE 0x09
|
|
|
|
#define HID_HDESC_COLLECTION 0xa1
|
|
|
|
#define HID_HDESC_COLLECTION_LOGICAL 0x02
|
|
|
|
#define HID_HDESC_COLLECTION_END 0xc0
|
|
|
|
|
|
|
|
struct wac_hid_descriptor {
|
2008-11-24 09:44:27 -07:00
|
|
|
struct usb_descriptor_header header;
|
|
|
|
__le16 bcdHID;
|
|
|
|
u8 bCountryCode;
|
|
|
|
u8 bNumDescriptors;
|
|
|
|
u8 bDescriptorType;
|
|
|
|
__le16 wDescriptorLength;
|
|
|
|
} __attribute__ ((packed));
|
|
|
|
|
|
|
|
/* defines to get/set USB message */
|
2006-07-13 19:01:36 -06:00
|
|
|
#define USB_REQ_GET_REPORT 0x01
|
|
|
|
#define USB_REQ_SET_REPORT 0x09
|
2011-09-07 15:08:54 -06:00
|
|
|
|
2008-11-24 09:44:27 -07:00
|
|
|
#define WAC_HID_FEATURE_REPORT 0x03
|
2011-08-16 01:17:56 -06:00
|
|
|
#define WAC_MSG_RETRIES 5
|
2006-07-13 19:01:36 -06:00
|
|
|
|
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
|
|
|
|
#define WAC_CMD_RETRIES 10
|
|
|
|
|
|
|
|
static int wacom_get_report(struct usb_interface *intf, u8 type, u8 id,
|
|
|
|
void *buf, size_t size, unsigned int retries)
|
2006-07-13 19:01:36 -06:00
|
|
|
{
|
2011-09-07 15:08:54 -06:00
|
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
do {
|
|
|
|
retval = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
|
|
|
|
USB_REQ_GET_REPORT,
|
2011-10-26 23:24:22 -06:00
|
|
|
USB_DIR_IN | USB_TYPE_CLASS |
|
|
|
|
USB_RECIP_INTERFACE,
|
2011-09-07 15:08:54 -06:00
|
|
|
(type << 8) + id,
|
|
|
|
intf->altsetting[0].desc.bInterfaceNumber,
|
|
|
|
buf, size, 100);
|
|
|
|
} while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
|
|
|
|
|
|
|
|
return retval;
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
2011-09-07 15:08:54 -06:00
|
|
|
static int wacom_set_report(struct usb_interface *intf, u8 type, u8 id,
|
|
|
|
void *buf, size_t size, unsigned int retries)
|
2006-07-13 19:01:36 -06:00
|
|
|
{
|
2011-09-07 15:08:54 -06:00
|
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
|
|
|
int retval;
|
|
|
|
|
|
|
|
do {
|
|
|
|
retval = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
|
|
|
|
USB_REQ_SET_REPORT,
|
|
|
|
USB_TYPE_CLASS | USB_RECIP_INTERFACE,
|
|
|
|
(type << 8) + id,
|
|
|
|
intf->altsetting[0].desc.bInterfaceNumber,
|
|
|
|
buf, size, 1000);
|
|
|
|
} while ((retval == -ETIMEDOUT || retval == -EPIPE) && --retries);
|
|
|
|
|
|
|
|
return retval;
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
2006-11-19 19:23:58 -07:00
|
|
|
static void wacom_sys_irq(struct urb *urb)
|
2006-07-13 19:01:36 -06:00
|
|
|
{
|
|
|
|
struct wacom *wacom = urb->context;
|
2012-05-04 16:33:13 -06:00
|
|
|
struct device *dev = &wacom->intf->dev;
|
2006-07-13 19:01:36 -06:00
|
|
|
int retval;
|
|
|
|
|
|
|
|
switch (urb->status) {
|
|
|
|
case 0:
|
|
|
|
/* success */
|
|
|
|
break;
|
|
|
|
case -ECONNRESET:
|
|
|
|
case -ENOENT:
|
|
|
|
case -ESHUTDOWN:
|
|
|
|
/* this urb is terminated, clean up */
|
2012-05-01 22:24:28 -06:00
|
|
|
dev_dbg(dev, "%s - urb shutting down with status: %d\n",
|
|
|
|
__func__, urb->status);
|
2006-07-13 19:01:36 -06:00
|
|
|
return;
|
|
|
|
default:
|
2012-05-01 22:24:28 -06:00
|
|
|
dev_dbg(dev, "%s - nonzero urb status received: %d\n",
|
|
|
|
__func__, urb->status);
|
2006-07-13 19:01:36 -06:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
2010-03-19 23:18:15 -06:00
|
|
|
wacom_wac_irq(&wacom->wacom_wac, urb->actual_length);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
|
|
|
exit:
|
2008-04-14 23:31:57 -06:00
|
|
|
usb_mark_last_busy(wacom->usbdev);
|
2010-03-19 23:18:15 -06:00
|
|
|
retval = usb_submit_urb(urb, GFP_ATOMIC);
|
2006-07-13 19:01:36 -06:00
|
|
|
if (retval)
|
2012-05-01 22:24:28 -06:00
|
|
|
dev_err(dev, "%s - usb_submit_urb failed with result %d\n",
|
2012-04-25 15:48:44 -06:00
|
|
|
__func__, retval);
|
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);
|
2010-10-04 22:46:11 -06:00
|
|
|
int retval = 0;
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2010-10-04 22:46:11 -06:00
|
|
|
if (usb_autopm_get_interface(wacom->intf) < 0)
|
2006-07-13 19:01:36 -06:00
|
|
|
return -EIO;
|
2010-10-04 22:46:11 -06:00
|
|
|
|
|
|
|
mutex_lock(&wacom->lock);
|
2008-04-14 23:31:57 -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
|
|
|
if (wacom->open)
|
|
|
|
goto out;
|
|
|
|
|
2008-04-14 23:31:57 -06:00
|
|
|
if (usb_submit_urb(wacom->irq, GFP_KERNEL)) {
|
2010-10-04 22:46:11 -06:00
|
|
|
retval = -EIO;
|
|
|
|
goto out;
|
2008-04-14 23:31:57 -06:00
|
|
|
}
|
|
|
|
|
2010-03-19 23:18:15 -06:00
|
|
|
wacom->open = true;
|
2008-04-14 23:31:57 -06:00
|
|
|
wacom->intf->needs_remote_wakeup = 1;
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2010-10-04 22:46:11 -06:00
|
|
|
out:
|
2008-04-14 23:31:57 -06:00
|
|
|
mutex_unlock(&wacom->lock);
|
2010-10-10 15:24:16 -06:00
|
|
|
usb_autopm_put_interface(wacom->intf);
|
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);
|
2010-10-10 15:24:16 -06:00
|
|
|
int autopm_error;
|
|
|
|
|
|
|
|
autopm_error = usb_autopm_get_interface(wacom->intf);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2008-04-14 23:31:57 -06:00
|
|
|
mutex_lock(&wacom->lock);
|
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 (!wacom->open)
|
|
|
|
goto out;
|
|
|
|
|
2006-07-13 19:01:36 -06:00
|
|
|
usb_kill_urb(wacom->irq);
|
2010-03-19 23:18:15 -06:00
|
|
|
wacom->open = false;
|
2008-04-14 23:31:57 -06:00
|
|
|
wacom->intf->needs_remote_wakeup = 0;
|
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
|
|
|
|
|
|
|
out:
|
2008-04-14 23:31:57 -06:00
|
|
|
mutex_unlock(&wacom->lock);
|
2010-10-04 22:46:11 -06:00
|
|
|
|
2010-10-10 15:24:16 -06:00
|
|
|
if (!autopm_error)
|
|
|
|
usb_autopm_put_interface(wacom->intf);
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
2012-10-03 18:24:32 -06:00
|
|
|
/*
|
|
|
|
* Calculate the resolution of the X or Y axis, given appropriate HID data.
|
|
|
|
* This function is little more than hidinput_calc_abs_res stripped down.
|
|
|
|
*/
|
|
|
|
static int wacom_calc_hid_res(int logical_extents, int physical_extents,
|
|
|
|
unsigned char unit, unsigned char exponent)
|
|
|
|
{
|
|
|
|
int prev, unit_exponent;
|
|
|
|
|
|
|
|
/* Check if the extents are sane */
|
|
|
|
if (logical_extents <= 0 || physical_extents <= 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
/* Get signed value of nybble-sized twos-compliment exponent */
|
|
|
|
unit_exponent = exponent;
|
|
|
|
if (unit_exponent > 7)
|
|
|
|
unit_exponent -= 16;
|
|
|
|
|
|
|
|
/* Convert physical_extents to millimeters */
|
|
|
|
if (unit == 0x11) { /* If centimeters */
|
|
|
|
unit_exponent += 1;
|
|
|
|
} else if (unit == 0x13) { /* If inches */
|
|
|
|
prev = physical_extents;
|
|
|
|
physical_extents *= 254;
|
|
|
|
if (physical_extents < prev)
|
|
|
|
return 0;
|
|
|
|
unit_exponent -= 1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Apply negative unit exponent */
|
|
|
|
for (; unit_exponent < 0; unit_exponent++) {
|
|
|
|
prev = logical_extents;
|
|
|
|
logical_extents *= 10;
|
|
|
|
if (logical_extents < prev)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
/* Apply positive unit exponent */
|
|
|
|
for (; unit_exponent > 0; unit_exponent--) {
|
|
|
|
prev = physical_extents;
|
|
|
|
physical_extents *= 10;
|
|
|
|
if (physical_extents < prev)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Calculate resolution */
|
|
|
|
return logical_extents / physical_extents;
|
|
|
|
}
|
|
|
|
|
2011-10-26 23:32:52 -06:00
|
|
|
static int wacom_parse_logical_collection(unsigned char *report,
|
|
|
|
struct wacom_features *features)
|
|
|
|
{
|
|
|
|
int length = 0;
|
|
|
|
|
|
|
|
if (features->type == BAMBOO_PT) {
|
|
|
|
|
|
|
|
/* Logical collection is only used by 3rd gen Bamboo Touch */
|
|
|
|
features->pktlen = WACOM_PKGLEN_BBTOUCH3;
|
2012-01-31 01:07:33 -07:00
|
|
|
features->device_type = BTN_TOOL_FINGER;
|
2011-10-26 23:32:52 -06:00
|
|
|
|
|
|
|
features->x_max = features->y_max =
|
|
|
|
get_unaligned_le16(&report[10]);
|
|
|
|
|
|
|
|
length = 11;
|
|
|
|
}
|
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
2012-04-29 22:09:17 -06:00
|
|
|
static void wacom_retrieve_report_data(struct usb_interface *intf,
|
|
|
|
struct wacom_features *features)
|
|
|
|
{
|
|
|
|
int result = 0;
|
|
|
|
unsigned char *rep_data;
|
|
|
|
|
|
|
|
rep_data = kmalloc(2, GFP_KERNEL);
|
|
|
|
if (rep_data) {
|
|
|
|
|
|
|
|
rep_data[0] = 12;
|
|
|
|
result = wacom_get_report(intf, WAC_HID_FEATURE_REPORT,
|
2012-06-28 17:46:27 -06:00
|
|
|
rep_data[0], rep_data, 2,
|
2012-04-29 22:09:17 -06:00
|
|
|
WAC_MSG_RETRIES);
|
|
|
|
|
|
|
|
if (result >= 0 && rep_data[1] > 2)
|
|
|
|
features->touch_max = rep_data[1];
|
|
|
|
|
|
|
|
kfree(rep_data);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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
|
|
|
*
|
|
|
|
* 3rd gen Bamboo Touch no longer define a Digitizer-Finger Pysical
|
|
|
|
* Collection. Instead they define a Logical Collection with a single
|
|
|
|
* Logical Maximum for both X and Y.
|
2012-04-03 16:50:40 -06:00
|
|
|
*
|
|
|
|
* Intuos5 touch interface does not contain useful data. We deal with
|
|
|
|
* this after returning from this function.
|
2011-10-26 23:26:59 -06:00
|
|
|
*/
|
|
|
|
static int wacom_parse_hid(struct usb_interface *intf,
|
2014-07-24 13:52:00 -06:00
|
|
|
struct wac_hid_descriptor *hid_desc,
|
2009-12-15 01:35:24 -07:00
|
|
|
struct wacom_features *features)
|
2008-11-24 09:44:27 -07:00
|
|
|
{
|
|
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
2009-12-15 01:35:24 -07:00
|
|
|
char limit = 0;
|
|
|
|
/* result has to be defined as int for some devices */
|
2013-11-25 19:43:45 -07:00
|
|
|
int result = 0, touch_max = 0;
|
2014-04-19 14:46:40 -06:00
|
|
|
int i = 0, page = 0, finger = 0, pen = 0;
|
2008-11-24 09:44:27 -07:00
|
|
|
unsigned char *report;
|
|
|
|
|
|
|
|
report = kzalloc(hid_desc->wDescriptorLength, GFP_KERNEL);
|
|
|
|
if (!report)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* retrive report descriptors */
|
|
|
|
do {
|
|
|
|
result = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
|
|
|
|
USB_REQ_GET_DESCRIPTOR,
|
|
|
|
USB_RECIP_INTERFACE | USB_DIR_IN,
|
|
|
|
HID_DEVICET_REPORT << 8,
|
|
|
|
intf->altsetting[0].desc.bInterfaceNumber, /* interface */
|
|
|
|
report,
|
|
|
|
hid_desc->wDescriptorLength,
|
|
|
|
5000); /* 5 secs */
|
2011-08-16 01:17:56 -06:00
|
|
|
} while (result < 0 && limit++ < WAC_MSG_RETRIES);
|
2008-11-24 09:44:27 -07:00
|
|
|
|
2009-04-28 08:49:54 -06:00
|
|
|
/* No need to parse the Descriptor. It isn't an error though */
|
2008-11-24 09:44:27 -07:00
|
|
|
if (result < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
for (i = 0; i < hid_desc->wDescriptorLength; i++) {
|
|
|
|
|
|
|
|
switch (report[i]) {
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_HDESC_USAGE_PAGE:
|
2014-04-19 14:46:40 -06:00
|
|
|
page = report[i + 1];
|
|
|
|
i++;
|
2008-11-24 09:44:27 -07:00
|
|
|
break;
|
|
|
|
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_HDESC_USAGE:
|
2014-04-19 14:46:40 -06:00
|
|
|
switch (page << 16 | report[i + 1]) {
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_GD_X:
|
2014-04-19 14:46:40 -06:00
|
|
|
if (finger) {
|
|
|
|
features->device_type = BTN_TOOL_FINGER;
|
|
|
|
/* touch device at least supports one touch point */
|
|
|
|
touch_max = 1;
|
|
|
|
switch (features->type) {
|
|
|
|
case TABLETPC2FG:
|
|
|
|
features->pktlen = WACOM_PKGLEN_TPC2FG;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MTSCREEN:
|
|
|
|
case WACOM_24HDT:
|
|
|
|
features->pktlen = WACOM_PKGLEN_MTOUCH;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case MTTPC:
|
2014-05-14 18:14:29 -06:00
|
|
|
case MTTPC_B:
|
2014-04-19 14:46:40 -06:00
|
|
|
features->pktlen = WACOM_PKGLEN_MTTPC;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BAMBOO_PT:
|
|
|
|
features->pktlen = WACOM_PKGLEN_BBTOUCH;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
features->pktlen = WACOM_PKGLEN_GRAPHIRE;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
switch (features->type) {
|
|
|
|
case BAMBOO_PT:
|
|
|
|
features->x_phy =
|
|
|
|
get_unaligned_le16(&report[i + 5]);
|
|
|
|
features->x_max =
|
|
|
|
get_unaligned_le16(&report[i + 8]);
|
|
|
|
i += 15;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WACOM_24HDT:
|
2008-11-24 09:44:27 -07:00
|
|
|
features->x_max =
|
2010-03-19 23:33:38 -06:00
|
|
|
get_unaligned_le16(&report[i + 3]);
|
2014-04-19 14:46:40 -06:00
|
|
|
features->x_phy =
|
|
|
|
get_unaligned_le16(&report[i + 8]);
|
|
|
|
features->unit = report[i - 1];
|
|
|
|
features->unitExpo = report[i - 3];
|
|
|
|
i += 12;
|
|
|
|
break;
|
|
|
|
|
2014-05-14 18:14:29 -06:00
|
|
|
case MTTPC_B:
|
|
|
|
features->x_max =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
features->x_phy =
|
|
|
|
get_unaligned_le16(&report[i + 6]);
|
|
|
|
features->unit = report[i - 5];
|
|
|
|
features->unitExpo = report[i - 3];
|
|
|
|
i += 9;
|
|
|
|
break;
|
|
|
|
|
2014-04-19 14:46:40 -06:00
|
|
|
default:
|
|
|
|
features->x_max =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
features->x_phy =
|
|
|
|
get_unaligned_le16(&report[i + 6]);
|
|
|
|
features->unit = report[i + 9];
|
|
|
|
features->unitExpo = report[i + 11];
|
|
|
|
i += 12;
|
|
|
|
break;
|
2008-11-24 09:44:27 -07:00
|
|
|
}
|
2014-04-19 14:46:40 -06:00
|
|
|
} else if (pen) {
|
|
|
|
/* penabled only accepts exact bytes of data */
|
|
|
|
if (features->type >= TABLETPC)
|
|
|
|
features->pktlen = WACOM_PKGLEN_GRAPHIRE;
|
|
|
|
features->device_type = BTN_TOOL_PEN;
|
|
|
|
features->x_max =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
i += 4;
|
2008-11-24 09:44:27 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_GD_Y:
|
2014-04-19 14:46:40 -06:00
|
|
|
if (finger) {
|
|
|
|
switch (features->type) {
|
|
|
|
case TABLETPC2FG:
|
|
|
|
case MTSCREEN:
|
|
|
|
case MTTPC:
|
|
|
|
features->y_max =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
features->y_phy =
|
|
|
|
get_unaligned_le16(&report[i + 6]);
|
|
|
|
i += 7;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case WACOM_24HDT:
|
|
|
|
features->y_max =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
features->y_phy =
|
|
|
|
get_unaligned_le16(&report[i - 2]);
|
|
|
|
i += 7;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case BAMBOO_PT:
|
|
|
|
features->y_phy =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
features->y_max =
|
|
|
|
get_unaligned_le16(&report[i + 6]);
|
|
|
|
i += 12;
|
|
|
|
break;
|
|
|
|
|
2014-05-14 18:14:29 -06:00
|
|
|
case MTTPC_B:
|
|
|
|
features->y_max =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
features->y_phy =
|
|
|
|
get_unaligned_le16(&report[i + 6]);
|
|
|
|
i += 9;
|
|
|
|
break;
|
|
|
|
|
2014-04-19 14:46:40 -06:00
|
|
|
default:
|
2009-12-15 01:35:24 -07:00
|
|
|
features->y_max =
|
2014-04-19 14:46:40 -06:00
|
|
|
features->x_max;
|
|
|
|
features->y_phy =
|
2010-03-19 23:33:38 -06:00
|
|
|
get_unaligned_le16(&report[i + 3]);
|
2009-12-15 01:35:24 -07:00
|
|
|
i += 4;
|
2014-04-19 14:46:40 -06:00
|
|
|
break;
|
2009-12-15 01:35:24 -07:00
|
|
|
}
|
2014-04-19 14:46:40 -06:00
|
|
|
} else if (pen) {
|
|
|
|
features->y_max =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
i += 4;
|
2009-12-15 01:35:24 -07:00
|
|
|
}
|
2008-11-24 09:44:27 -07:00
|
|
|
break;
|
|
|
|
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_DG_FINGER:
|
2008-11-24 09:44:27 -07:00
|
|
|
finger = 1;
|
|
|
|
i++;
|
|
|
|
break;
|
|
|
|
|
2011-10-26 23:26:59 -06:00
|
|
|
/*
|
|
|
|
* Requiring Stylus Usage will ignore boot mouse
|
|
|
|
* X/Y values and some cases of invalid Digitizer X/Y
|
|
|
|
* values commonly reported.
|
|
|
|
*/
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_DG_STYLUS:
|
2008-11-24 09:44:27 -07:00
|
|
|
pen = 1;
|
|
|
|
i++;
|
|
|
|
break;
|
2012-04-29 22:09:17 -06:00
|
|
|
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_DG_CONTACTMAX:
|
2012-06-28 17:47:30 -06:00
|
|
|
/* leave touch_max as is if predefined */
|
|
|
|
if (!features->touch_max)
|
|
|
|
wacom_retrieve_report_data(intf, features);
|
2012-04-29 22:09:17 -06:00
|
|
|
i++;
|
|
|
|
break;
|
2014-04-19 14:49:37 -06:00
|
|
|
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_DG_TIPPRESSURE:
|
2014-04-19 14:49:37 -06:00
|
|
|
if (pen) {
|
|
|
|
features->pressure_max =
|
|
|
|
get_unaligned_le16(&report[i + 3]);
|
|
|
|
i += 4;
|
|
|
|
}
|
|
|
|
break;
|
2008-11-24 09:44:27 -07:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_HDESC_COLLECTION_END:
|
2009-12-15 01:35:24 -07:00
|
|
|
/* reset UsagePage and Finger */
|
2014-04-19 14:46:40 -06:00
|
|
|
finger = page = 0;
|
2008-11-24 09:44:27 -07:00
|
|
|
break;
|
2011-10-26 23:32:52 -06:00
|
|
|
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_HDESC_COLLECTION:
|
2011-10-26 23:32:52 -06:00
|
|
|
i++;
|
|
|
|
switch (report[i]) {
|
2014-07-24 13:52:00 -06:00
|
|
|
case HID_HDESC_COLLECTION_LOGICAL:
|
2011-10-26 23:32:52 -06:00
|
|
|
i += wacom_parse_logical_collection(&report[i],
|
|
|
|
features);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
break;
|
2008-11-24 09:44:27 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
out:
|
2013-11-25 19:43:45 -07:00
|
|
|
if (!features->touch_max && touch_max)
|
|
|
|
features->touch_max = touch_max;
|
2009-04-28 08:49:54 -06:00
|
|
|
result = 0;
|
2008-11-24 09:44:27 -07:00
|
|
|
kfree(report);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2012-10-03 18:25:35 -06:00
|
|
|
static int wacom_set_device_mode(struct usb_interface *intf, 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;
|
|
|
|
|
2012-10-03 18:25:35 -06:00
|
|
|
error = wacom_set_report(intf, WAC_HID_FEATURE_REPORT,
|
|
|
|
report_id, rep_data, length, 1);
|
2014-07-24 13:47:47 -06:00
|
|
|
if (error >= 0)
|
|
|
|
error = wacom_get_report(intf, WAC_HID_FEATURE_REPORT,
|
|
|
|
report_id, 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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
static int wacom_query_tablet_data(struct usb_interface *intf, struct wacom_features *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 */
|
|
|
|
return wacom_set_device_mode(intf, 3, 4, 4);
|
|
|
|
}
|
2013-09-20 10:47:35 -06:00
|
|
|
else if (features->type == WACOM_24HDT || features->type == CINTIQ_HYBRID) {
|
2012-10-21 01:38:04 -06:00
|
|
|
return wacom_set_device_mode(intf, 18, 3, 2);
|
|
|
|
}
|
2012-10-03 18:25:35 -06:00
|
|
|
} else if (features->device_type == BTN_TOOL_PEN) {
|
|
|
|
if (features->type <= BAMBOO_PT && features->type != WIRELESS) {
|
|
|
|
return wacom_set_device_mode(intf, 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
|
|
|
}
|
|
|
|
|
2009-12-15 01:35:24 -07:00
|
|
|
static int wacom_retrieve_hid_descriptor(struct usb_interface *intf,
|
2012-04-29 22:09:18 -06:00
|
|
|
struct wacom_features *features)
|
2009-12-15 01:35:24 -07:00
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
struct usb_host_interface *interface = intf->cur_altsetting;
|
2014-07-24 13:52:00 -06:00
|
|
|
struct wac_hid_descriptor *hid_desc;
|
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 */
|
2012-06-12 01:14:12 -06:00
|
|
|
if (features->type < BAMBOO_PT) {
|
2009-12-15 01:35:24 -07:00
|
|
|
goto out;
|
2012-04-29 22:09:18 -06:00
|
|
|
}
|
2009-12-15 01:35:24 -07:00
|
|
|
|
2012-05-02 01:13:38 -06:00
|
|
|
error = usb_get_extra_descriptor(interface, HID_DEVICET_HID, &hid_desc);
|
|
|
|
if (error) {
|
|
|
|
error = usb_get_extra_descriptor(&interface->endpoint[0],
|
|
|
|
HID_DEVICET_REPORT, &hid_desc);
|
|
|
|
if (error) {
|
2012-05-02 01:13:38 -06:00
|
|
|
dev_err(&intf->dev,
|
|
|
|
"can not retrieve extra class descriptor\n");
|
2009-12-15 01:35:24 -07:00
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
error = wacom_parse_hid(intf, hid_desc, features);
|
|
|
|
|
|
|
|
out:
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
2010-03-19 23:18:15 -06:00
|
|
|
struct wacom_usbdev_data {
|
|
|
|
struct list_head list;
|
|
|
|
struct kref kref;
|
|
|
|
struct usb_device *dev;
|
|
|
|
struct wacom_shared shared;
|
|
|
|
};
|
|
|
|
|
|
|
|
static LIST_HEAD(wacom_udev_list);
|
|
|
|
static DEFINE_MUTEX(wacom_udev_list_lock);
|
|
|
|
|
2012-10-21 01:38:03 -06:00
|
|
|
static struct usb_device *wacom_get_sibling(struct usb_device *dev, int vendor, int product)
|
|
|
|
{
|
|
|
|
int port1;
|
|
|
|
struct usb_device *sibling;
|
|
|
|
|
|
|
|
if (vendor == 0 && product == 0)
|
|
|
|
return dev;
|
|
|
|
|
|
|
|
if (dev->parent == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
usb_hub_for_each_child(dev->parent, port1, sibling) {
|
|
|
|
struct usb_device_descriptor *d;
|
|
|
|
if (sibling == NULL)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
d = &sibling->descriptor;
|
|
|
|
if (d->idVendor == vendor && d->idProduct == product)
|
|
|
|
return sibling;
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-03-19 23:18:15 -06:00
|
|
|
static struct wacom_usbdev_data *wacom_get_usbdev_data(struct usb_device *dev)
|
|
|
|
{
|
|
|
|
struct wacom_usbdev_data *data;
|
|
|
|
|
|
|
|
list_for_each_entry(data, &wacom_udev_list, list) {
|
|
|
|
if (data->dev == dev) {
|
|
|
|
kref_get(&data->kref);
|
|
|
|
return data;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_add_shared_data(struct wacom_wac *wacom,
|
|
|
|
struct usb_device *dev)
|
|
|
|
{
|
|
|
|
struct wacom_usbdev_data *data;
|
|
|
|
int retval = 0;
|
|
|
|
|
|
|
|
mutex_lock(&wacom_udev_list_lock);
|
|
|
|
|
|
|
|
data = wacom_get_usbdev_data(dev);
|
|
|
|
if (!data) {
|
|
|
|
data = kzalloc(sizeof(struct wacom_usbdev_data), GFP_KERNEL);
|
|
|
|
if (!data) {
|
|
|
|
retval = -ENOMEM;
|
|
|
|
goto out;
|
|
|
|
}
|
|
|
|
|
|
|
|
kref_init(&data->kref);
|
|
|
|
data->dev = dev;
|
|
|
|
list_add_tail(&data->list, &wacom_udev_list);
|
|
|
|
}
|
|
|
|
|
|
|
|
wacom->shared = &data->shared;
|
|
|
|
|
|
|
|
out:
|
|
|
|
mutex_unlock(&wacom_udev_list_lock);
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_release_shared_data(struct kref *kref)
|
|
|
|
{
|
|
|
|
struct wacom_usbdev_data *data =
|
|
|
|
container_of(kref, struct wacom_usbdev_data, kref);
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
struct wacom_usbdev_data *data;
|
|
|
|
|
|
|
|
if (wacom->shared) {
|
|
|
|
data = container_of(wacom->shared, struct wacom_usbdev_data, shared);
|
|
|
|
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;
|
2011-09-07 15:08:54 -06:00
|
|
|
|
|
|
|
buf = kzalloc(9, GFP_KERNEL);
|
|
|
|
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;
|
|
|
|
|
|
|
|
buf[0] = WAC_CMD_LED_CONTROL;
|
|
|
|
buf[1] = (crop_lum << 4) | (ring_lum << 2) | (ring_led);
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
|
|
|
buf[0] = WAC_CMD_LED_CONTROL;
|
|
|
|
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
|
|
|
|
|
|
|
retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_LED_CONTROL,
|
|
|
|
buf, 9, WAC_CMD_RETRIES);
|
|
|
|
kfree(buf);
|
|
|
|
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_led_putimage(struct wacom *wacom, int button_id, const void *img)
|
|
|
|
{
|
|
|
|
unsigned char *buf;
|
|
|
|
int i, retval;
|
|
|
|
|
|
|
|
buf = kzalloc(259, GFP_KERNEL);
|
|
|
|
if (!buf)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
|
|
|
/* Send 'start' command */
|
|
|
|
buf[0] = WAC_CMD_ICON_START;
|
|
|
|
buf[1] = 1;
|
|
|
|
retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_START,
|
|
|
|
buf, 2, WAC_CMD_RETRIES);
|
|
|
|
if (retval < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
buf[0] = WAC_CMD_ICON_XFER;
|
|
|
|
buf[1] = button_id & 0x07;
|
|
|
|
for (i = 0; i < 4; i++) {
|
|
|
|
buf[2] = i;
|
|
|
|
memcpy(buf + 3, img + i * 256, 256);
|
|
|
|
|
|
|
|
retval = wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_XFER,
|
|
|
|
buf, 259, WAC_CMD_RETRIES);
|
|
|
|
if (retval < 0)
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Send 'stop' */
|
|
|
|
buf[0] = WAC_CMD_ICON_START;
|
|
|
|
buf[1] = 0;
|
|
|
|
wacom_set_report(wacom->intf, 0x03, WAC_CMD_ICON_START,
|
|
|
|
buf, 2, WAC_CMD_RETRIES);
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
struct wacom *wacom = dev_get_drvdata(dev);
|
|
|
|
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) \
|
|
|
|
{ \
|
|
|
|
struct wacom *wacom = dev_get_drvdata(dev); \
|
|
|
|
return snprintf(buf, 2, "%d\n", wacom->led.select[SET_ID]); \
|
|
|
|
} \
|
|
|
|
static DEVICE_ATTR(status_led##SET_ID##_select, S_IWUSR | S_IRUSR, \
|
|
|
|
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) \
|
|
|
|
{ \
|
|
|
|
struct wacom *wacom = dev_get_drvdata(dev); \
|
|
|
|
\
|
|
|
|
return wacom_luminance_store(wacom, &wacom->led.field, \
|
|
|
|
buf, count); \
|
|
|
|
} \
|
|
|
|
static DEVICE_ATTR(name##_luminance, S_IWUSR, \
|
|
|
|
NULL, wacom_##name##_luminance_store)
|
|
|
|
|
|
|
|
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)
|
|
|
|
{
|
|
|
|
struct wacom *wacom = dev_get_drvdata(dev);
|
|
|
|
int err;
|
|
|
|
|
|
|
|
if (count != 1024)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
mutex_lock(&wacom->lock);
|
|
|
|
|
|
|
|
err = wacom_led_putimage(wacom, button_id, buf);
|
|
|
|
|
|
|
|
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); \
|
|
|
|
} \
|
|
|
|
static DEVICE_ATTR(button##BUTTON_ID##_rawimg, S_IWUSR, \
|
|
|
|
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:
|
|
|
|
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;
|
2011-10-05 00:51:14 -06:00
|
|
|
error = sysfs_create_group(&wacom->intf->dev.kobj,
|
|
|
|
&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
|
|
|
|
|
|
|
error = sysfs_create_group(&wacom->intf->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;
|
|
|
|
|
|
|
|
error = sysfs_create_group(&wacom->intf->dev.kobj,
|
|
|
|
&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) {
|
|
|
|
dev_err(&wacom->intf->dev,
|
|
|
|
"cannot create sysfs group err: %d\n", error);
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
wacom_led_control(wacom);
|
|
|
|
|
2011-09-07 15:08:54 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_destroy_leds(struct wacom *wacom)
|
|
|
|
{
|
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:
|
|
|
|
case INTUOS4L:
|
2011-09-07 15:08:54 -06:00
|
|
|
sysfs_remove_group(&wacom->intf->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:
|
|
|
|
sysfs_remove_group(&wacom->intf->dev.kobj,
|
|
|
|
&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)
|
|
|
|
sysfs_remove_group(&wacom->intf->dev.kobj,
|
|
|
|
&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[] = {
|
2013-10-16 00:33:00 -06:00
|
|
|
POWER_SUPPLY_PROP_SCOPE,
|
2012-03-26 00:26:30 -06:00
|
|
|
POWER_SUPPLY_PROP_CAPACITY
|
|
|
|
};
|
|
|
|
|
|
|
|
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 =
|
|
|
|
wacom->wacom_wac.battery_capacity * 100 / 31;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ret = -EINVAL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_initialize_battery(struct wacom *wacom)
|
|
|
|
{
|
|
|
|
int error = 0;
|
|
|
|
|
|
|
|
if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_MONITOR) {
|
|
|
|
wacom->battery.properties = wacom_battery_props;
|
|
|
|
wacom->battery.num_properties = ARRAY_SIZE(wacom_battery_props);
|
|
|
|
wacom->battery.get_property = wacom_battery_get_property;
|
|
|
|
wacom->battery.name = "wacom_battery";
|
|
|
|
wacom->battery.type = POWER_SUPPLY_TYPE_BATTERY;
|
|
|
|
wacom->battery.use_for_apm = 0;
|
|
|
|
|
|
|
|
error = power_supply_register(&wacom->usbdev->dev,
|
|
|
|
&wacom->battery);
|
2012-06-12 01:25:23 -06:00
|
|
|
|
|
|
|
if (!error)
|
|
|
|
power_supply_powers(&wacom->battery,
|
|
|
|
&wacom->usbdev->dev);
|
2012-03-26 00:26:30 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
return error;
|
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_destroy_battery(struct wacom *wacom)
|
|
|
|
{
|
2012-06-12 01:25:23 -06:00
|
|
|
if (wacom->wacom_wac.features.quirks & WACOM_QUIRK_MONITOR &&
|
|
|
|
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;
|
|
|
|
}
|
2012-03-26 00:26:30 -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
|
|
|
static struct input_dev *wacom_allocate_input(struct wacom *wacom)
|
2012-03-26 00:25:45 -06:00
|
|
|
{
|
|
|
|
struct input_dev *input_dev;
|
|
|
|
struct usb_interface *intf = wacom->intf;
|
|
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
|
|
|
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 13:48:06 -06:00
|
|
|
input_dev->phys = wacom->phys;
|
2012-03-26 00:25:45 -06:00
|
|
|
input_dev->dev.parent = &intf->dev;
|
|
|
|
input_dev->open = wacom_open;
|
|
|
|
input_dev->close = wacom_close;
|
|
|
|
usb_to_input_id(dev, &input_dev->id);
|
|
|
|
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-07-24 13:51:26 -06:00
|
|
|
static void wacom_unregister_inputs(struct wacom *wacom)
|
|
|
|
{
|
|
|
|
if (wacom->wacom_wac.input)
|
|
|
|
input_unregister_device(wacom->wacom_wac.input);
|
|
|
|
if (wacom->wacom_wac.pad_input)
|
|
|
|
input_unregister_device(wacom->wacom_wac.pad_input);
|
|
|
|
wacom->wacom_wac.input = NULL;
|
|
|
|
wacom->wacom_wac.pad_input = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_register_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);
|
|
|
|
int error;
|
|
|
|
|
|
|
|
input_dev = wacom_allocate_input(wacom);
|
|
|
|
pad_input_dev = wacom_allocate_input(wacom);
|
|
|
|
if (!input_dev || !pad_input_dev) {
|
|
|
|
error = -ENOMEM;
|
|
|
|
goto fail1;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2012-04-29 22:09:18 -06:00
|
|
|
error = wacom_setup_input_capabilities(input_dev, wacom_wac);
|
|
|
|
if (error)
|
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
|
|
|
goto fail2;
|
2012-03-26 00:25:45 -06:00
|
|
|
|
|
|
|
error = input_register_device(input_dev);
|
2012-04-29 22:09:18 -06:00
|
|
|
if (error)
|
|
|
|
goto fail2;
|
|
|
|
|
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)
|
|
|
|
goto fail3;
|
|
|
|
}
|
|
|
|
|
2012-04-29 22:09:18 -06:00
|
|
|
return 0;
|
2012-03-26 00:25:45 -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
|
|
|
fail3:
|
|
|
|
input_unregister_device(input_dev);
|
|
|
|
input_dev = NULL;
|
2012-04-29 22:09:18 -06:00
|
|
|
fail2:
|
|
|
|
wacom_wac->input = NULL;
|
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 = NULL;
|
2012-04-29 22:09:18 -06:00
|
|
|
fail1:
|
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)
|
|
|
|
input_free_device(input_dev);
|
|
|
|
if (pad_input_dev)
|
|
|
|
input_free_device(pad_input_dev);
|
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;
|
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 */
|
2012-06-12 01:25:23 -06:00
|
|
|
wacom1 = usb_get_intfdata(usbdev->config->interface[1]);
|
|
|
|
wacom_wac1 = &(wacom1->wacom_wac);
|
2014-07-24 13:51:26 -06:00
|
|
|
wacom_unregister_inputs(wacom1);
|
2012-03-26 00:26:20 -06:00
|
|
|
|
|
|
|
/* Touch interface */
|
2012-06-12 01:25:23 -06:00
|
|
|
wacom2 = usb_get_intfdata(usbdev->config->interface[2]);
|
|
|
|
wacom_wac2 = &(wacom2->wacom_wac);
|
2014-07-24 13:51:26 -06:00
|
|
|
wacom_unregister_inputs(wacom2);
|
2012-03-26 00:26:20 -06:00
|
|
|
|
|
|
|
if (wacom_wac->pid == 0) {
|
2012-05-02 01:13:38 -06:00
|
|
|
dev_info(&wacom->intf->dev, "wireless tablet disconnected\n");
|
2012-03-26 00:26:20 -06:00
|
|
|
} else {
|
|
|
|
const struct usb_device_id *id = wacom_ids;
|
|
|
|
|
2012-05-02 01:13:38 -06:00
|
|
|
dev_info(&wacom->intf->dev,
|
|
|
|
"wireless tablet connected with PID %x\n",
|
|
|
|
wacom_wac->pid);
|
2012-03-26 00:26:20 -06:00
|
|
|
|
|
|
|
while (id->match_flags) {
|
|
|
|
if (id->idVendor == USB_VENDOR_ID_WACOM &&
|
|
|
|
id->idProduct == wacom_wac->pid)
|
|
|
|
break;
|
|
|
|
id++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!id->match_flags) {
|
2012-05-02 01:13:38 -06:00
|
|
|
dev_info(&wacom->intf->dev,
|
|
|
|
"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 =
|
2012-03-26 00:26:20 -06:00
|
|
|
*((struct wacom_features *)id->driver_info);
|
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-07-24 13:51:26 -06:00
|
|
|
error = 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 =
|
|
|
|
*((struct wacom_features *)id->driver_info);
|
|
|
|
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);
|
|
|
|
error = 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-07-24 13:51:26 -06:00
|
|
|
wacom_unregister_inputs(wacom1);
|
|
|
|
wacom_unregister_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);
|
|
|
|
}
|
|
|
|
|
2006-07-13 19:01:36 -06:00
|
|
|
static int wacom_probe(struct usb_interface *intf, const struct usb_device_id *id)
|
|
|
|
{
|
|
|
|
struct usb_device *dev = interface_to_usbdev(intf);
|
|
|
|
struct usb_endpoint_descriptor *endpoint;
|
|
|
|
struct wacom *wacom;
|
|
|
|
struct wacom_wac *wacom_wac;
|
2010-02-17 23:38:31 -07:00
|
|
|
struct wacom_features *features;
|
|
|
|
int error;
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2010-02-17 23:38:31 -07:00
|
|
|
if (!id->driver_info)
|
2010-02-11 00:06:23 -07:00
|
|
|
return -EINVAL;
|
|
|
|
|
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
|
|
|
|
2010-03-19 23:18:15 -06:00
|
|
|
wacom_wac = &wacom->wacom_wac;
|
2010-02-17 23:38:31 -07:00
|
|
|
wacom_wac->features = *((struct wacom_features *)id->driver_info);
|
|
|
|
features = &wacom_wac->features;
|
|
|
|
if (features->pktlen > WACOM_PKGLEN_MAX) {
|
|
|
|
error = -EINVAL;
|
2006-07-13 19:01:36 -06:00
|
|
|
goto fail1;
|
2010-02-17 23:38:31 -07:00
|
|
|
}
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2010-04-12 05:17:25 -06:00
|
|
|
wacom_wac->data = usb_alloc_coherent(dev, WACOM_PKGLEN_MAX,
|
|
|
|
GFP_KERNEL, &wacom->data_dma);
|
2010-02-17 23:38:31 -07:00
|
|
|
if (!wacom_wac->data) {
|
|
|
|
error = -ENOMEM;
|
2006-07-13 19:01:36 -06:00
|
|
|
goto fail1;
|
2010-02-17 23:38:31 -07:00
|
|
|
}
|
2006-07-13 19:01:36 -06:00
|
|
|
|
|
|
|
wacom->irq = usb_alloc_urb(0, GFP_KERNEL);
|
2010-02-17 23:38:31 -07:00
|
|
|
if (!wacom->irq) {
|
|
|
|
error = -ENOMEM;
|
2006-07-13 19:01:36 -06:00
|
|
|
goto fail2;
|
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
|
|
|
usb_make_path(dev, wacom->phys, sizeof(wacom->phys));
|
|
|
|
strlcat(wacom->phys, "/input0", sizeof(wacom->phys));
|
|
|
|
|
2008-11-24 09:44:27 -07:00
|
|
|
endpoint = &intf->cur_altsetting->endpoint[0].desc;
|
|
|
|
|
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 */
|
2009-12-15 01:35:24 -07:00
|
|
|
error = wacom_retrieve_hid_descriptor(intf, features);
|
|
|
|
if (error)
|
2011-02-11 01:44:41 -07:00
|
|
|
goto fail3;
|
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
|
|
|
|
* HID descriptor. If this is the touch interface (wMaxPacketSize
|
|
|
|
* of WACOM_PKGLEN_BBTOUCH3), override the table values.
|
|
|
|
*/
|
2013-11-25 19:44:55 -07:00
|
|
|
if (features->type >= INTUOS5S && features->type <= INTUOSHT) {
|
2012-04-03 16:50:40 -06:00
|
|
|
if (endpoint->wMaxPacketSize == WACOM_PKGLEN_BBTOUCH3) {
|
|
|
|
features->device_type = BTN_TOOL_FINGER;
|
|
|
|
features->pktlen = WACOM_PKGLEN_BBTOUCH3;
|
|
|
|
|
|
|
|
features->x_max = 4096;
|
|
|
|
features->y_max = 4096;
|
|
|
|
} else {
|
|
|
|
features->device_type = BTN_TOOL_PEN;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
features->unitExpo = 16 - 3;
|
|
|
|
}
|
|
|
|
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) {
|
2012-10-21 01:38:03 -06:00
|
|
|
struct usb_device *other_dev;
|
|
|
|
|
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
|
|
|
|
2012-10-21 01:38:03 -06:00
|
|
|
other_dev = wacom_get_sibling(dev, features->oVid, features->oPid);
|
|
|
|
if (other_dev == NULL || wacom_get_usbdev_data(other_dev) == NULL)
|
|
|
|
other_dev = dev;
|
|
|
|
error = wacom_add_shared_data(wacom_wac, other_dev);
|
2010-03-19 23:18:15 -06:00
|
|
|
if (error)
|
|
|
|
goto fail3;
|
2010-02-20 01:53:49 -07:00
|
|
|
}
|
|
|
|
|
2006-07-13 19:01:36 -06:00
|
|
|
usb_fill_int_urb(wacom->irq, dev,
|
|
|
|
usb_rcvintpipe(dev, endpoint->bEndpointAddress),
|
2009-12-15 01:35:24 -07:00
|
|
|
wacom_wac->data, features->pktlen,
|
2006-09-26 14:34:47 -06:00
|
|
|
wacom_sys_irq, wacom, endpoint->bInterval);
|
2006-07-13 19:01:36 -06:00
|
|
|
wacom->irq->transfer_dma = wacom->data_dma;
|
|
|
|
wacom->irq->transfer_flags |= URB_NO_TRANSFER_DMA_MAP;
|
|
|
|
|
2011-09-07 15:08:54 -06:00
|
|
|
error = wacom_initialize_leds(wacom);
|
2007-04-11 23:33:39 -06:00
|
|
|
if (error)
|
2010-03-19 23:18:15 -06:00
|
|
|
goto fail4;
|
2006-07-13 19:01:36 -06:00
|
|
|
|
2012-03-26 00:26:11 -06:00
|
|
|
if (!(features->quirks & WACOM_QUIRK_NO_INPUT)) {
|
2014-07-24 13:51:26 -06:00
|
|
|
error = wacom_register_inputs(wacom);
|
2012-03-26 00:26:11 -06:00
|
|
|
if (error)
|
2012-06-12 01:25:23 -06:00
|
|
|
goto fail5;
|
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 */
|
|
|
|
wacom_query_tablet_data(intf, features);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
|
|
|
usb_set_intfdata(intf, wacom);
|
2012-03-26 00:26:11 -06:00
|
|
|
|
|
|
|
if (features->quirks & WACOM_QUIRK_MONITOR) {
|
2013-08-24 17:41:56 -06:00
|
|
|
if (usb_submit_urb(wacom->irq, GFP_KERNEL)) {
|
|
|
|
error = -EIO;
|
2012-03-26 00:26:11 -06:00
|
|
|
goto fail5;
|
2013-08-24 17:41:56 -06:00
|
|
|
}
|
2012-03-26 00:26:11 -06:00
|
|
|
}
|
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;
|
|
|
|
|
2011-09-07 15:08:54 -06:00
|
|
|
fail5: wacom_destroy_leds(wacom);
|
2010-03-19 23:18:15 -06:00
|
|
|
fail4: wacom_remove_shared_data(wacom_wac);
|
2007-04-11 23:33:39 -06:00
|
|
|
fail3: usb_free_urb(wacom->irq);
|
2010-04-12 05:17:25 -06:00
|
|
|
fail2: usb_free_coherent(dev, WACOM_PKGLEN_MAX, wacom_wac->data, wacom->data_dma);
|
2012-03-26 00:25:45 -06:00
|
|
|
fail1: kfree(wacom);
|
2007-04-11 23:33:39 -06:00
|
|
|
return error;
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static void wacom_disconnect(struct usb_interface *intf)
|
|
|
|
{
|
2008-04-14 23:31:57 -06:00
|
|
|
struct wacom *wacom = usb_get_intfdata(intf);
|
2006-07-13 19:01:36 -06:00
|
|
|
|
|
|
|
usb_set_intfdata(intf, NULL);
|
2008-04-14 23:31:57 -06:00
|
|
|
|
|
|
|
usb_kill_urb(wacom->irq);
|
2012-03-26 00:26:20 -06:00
|
|
|
cancel_work_sync(&wacom->work);
|
2014-07-24 13:51:26 -06:00
|
|
|
wacom_unregister_inputs(wacom);
|
2012-03-26 00:26:30 -06:00
|
|
|
wacom_destroy_battery(wacom);
|
2011-09-07 15:08:54 -06:00
|
|
|
wacom_destroy_leds(wacom);
|
2008-04-14 23:31:57 -06:00
|
|
|
usb_free_urb(wacom->irq);
|
2010-04-12 05:17:25 -06:00
|
|
|
usb_free_coherent(interface_to_usbdev(intf), WACOM_PKGLEN_MAX,
|
2010-03-19 23:18:15 -06:00
|
|
|
wacom->wacom_wac.data, wacom->data_dma);
|
|
|
|
wacom_remove_shared_data(&wacom->wacom_wac);
|
2008-04-14 23:31:57 -06:00
|
|
|
kfree(wacom);
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_suspend(struct usb_interface *intf, pm_message_t message)
|
|
|
|
{
|
|
|
|
struct wacom *wacom = usb_get_intfdata(intf);
|
|
|
|
|
|
|
|
mutex_lock(&wacom->lock);
|
|
|
|
usb_kill_urb(wacom->irq);
|
|
|
|
mutex_unlock(&wacom->lock);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_resume(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
struct wacom *wacom = usb_get_intfdata(intf);
|
2010-03-19 23:18:15 -06:00
|
|
|
struct wacom_features *features = &wacom->wacom_wac.features;
|
2011-09-07 15:08:54 -06:00
|
|
|
int rv = 0;
|
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 */
|
|
|
|
wacom_query_tablet_data(intf, features);
|
2011-09-07 15:08:54 -06:00
|
|
|
wacom_led_control(wacom);
|
2010-04-14 00:07:52 -06:00
|
|
|
|
2013-08-24 17:41:56 -06:00
|
|
|
if ((wacom->open || (features->quirks & WACOM_QUIRK_MONITOR)) &&
|
|
|
|
usb_submit_urb(wacom->irq, GFP_NOIO) < 0)
|
2011-09-07 15:08:54 -06:00
|
|
|
rv = -EIO;
|
2010-04-14 00:07:52 -06:00
|
|
|
|
2008-04-14 23:31:57 -06:00
|
|
|
mutex_unlock(&wacom->lock);
|
|
|
|
|
|
|
|
return rv;
|
|
|
|
}
|
|
|
|
|
|
|
|
static int wacom_reset_resume(struct usb_interface *intf)
|
|
|
|
{
|
|
|
|
return wacom_resume(intf);
|
2006-07-13 19:01:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static struct usb_driver wacom_driver = {
|
|
|
|
.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,
|
|
|
|
.disconnect = wacom_disconnect,
|
2008-04-14 23:31:57 -06:00
|
|
|
.suspend = wacom_suspend,
|
|
|
|
.resume = wacom_resume,
|
|
|
|
.reset_resume = wacom_reset_resume,
|
|
|
|
.supports_autosuspend = 1,
|
2006-07-13 19:01:36 -06:00
|
|
|
};
|
|
|
|
|
2011-11-18 10:48:31 -07:00
|
|
|
module_usb_driver(wacom_driver);
|