nathan/Chromebook-Device-Nyan-NVIDIA-Tegra-K1-T124-Upstream-Linux-3.10-LTS-Kernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Chromebook-Device-Nyan-NVID.../drivers/hid/hid-logitech-wtp.c

990 lines
26 KiB
C
Raw Permalink Blame History

/*
* HID driver for Logitech Wireless Touchpad device
*
* Copyright (c) 2011 Logitech (c)
*/
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
* published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Should you need to contact me, the author, you can do so by e-mail send
* your message to Benjamin Tissoires <benjamin.tissoires at gmail com>
*
*/
#include <linux/device.h>
#include <linux/hid.h>
#include <linux/module.h>
#include <linux/slab.h>
#include <linux/input/mt.h>
MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>");
MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>");
MODULE_DESCRIPTION("Logitech Wireless Touchpad");
MODULE_LICENSE("GPL");
#include "hid-ids.h"
#include "hid-logitech-hidpp.h"
#define SOFTWARE_ID 0xB
#define ORIGIN_LOWER_LEFT 0x1
#define ORIGIN_LOWER_RIGHT 0x2
#define ORIGIN_UPPER_LEFT 0x3
#define ORIGIN_UPPER_RIGHT 0x4
#define ORIGIN_IS_HIGH(origin) ((origin - 1) & 2)
#define ORIGIN_IS_RIGHT(origin) ((origin - 1) & 1)
/* Converts a value in DPI to dots-per-millimeter */
#define DPI_TO_DPMM(dpi) (((dpi) * 5) / 127)
#define SLOT_COUNT 16
#define CONTACT_STATUS_RELEASED 0
#define CONTACT_STATUS_TOUCH 1
#define CONTACT_STATUS_HOVER 2
#define CONTACT_STATUS_RESERVED 3
#define BUTTON_LEFT 0
#define BUTTON_RIGHT 1
#define BUTTON_MIDDLE 2
/* T400 reports 2 different buttons for middle clicks,
but we report both as BTN_MIDDLE input_event */
#define BUTTON_MIDDLE_ALT 3
#define BUTTON_LEFT_MASK (1 << BUTTON_LEFT)
#define BUTTON_RIGHT_MASK (1 << BUTTON_RIGHT)
#define BUTTON_MIDDLE_MASK (1 << BUTTON_MIDDLE)
#define BUTTON_MIDDLE_ALT_MASK (1 << BUTTON_MIDDLE_ALT)
#define UNIFYING_KBD_INPUT_REPORT_SIZE 8
#define ARRAYSIZE(array) (sizeof(array) / sizeof(*(array)))
/* Supported Devices */
static const struct hid_device_id wtp_devices[] = {
{HID_DJ_DEVICE(USB_VENDOR_ID_LOGITECH, UNIFYING_DEVICE_ID_WIRELESS_TOUCHPAD) },
{HID_DJ_DEVICE(USB_VENDOR_ID_LOGITECH, UNIFYING_DEVICE_ID_WIRELESS_TOUCHPAD_T650) },
{HID_DJ_DEVICE(USB_VENDOR_ID_LOGITECH, UNIFYING_DEVICE_ID_ALLINONE_KBD_TK820) },
{HID_DJ_DEVICE(USB_VENDOR_ID_LOGITECH, UNIFYING_DEVICE_ID_ZONE_MOUSE_T400) },
{HID_DJ_DEVICE(USB_VENDOR_ID_LOGITECH, UNIFYING_DEVICE_ID_TOUCH_MOUSE_T620) },
{HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_WIRELESS_TOUCHPAD_T651) },
{HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, USB_DEVICE_ID_BLUETOOTH_TOUCHMOUSE) },
{ }
};
MODULE_DEVICE_TABLE(hid, wtp_devices);
/* This struct represents a finger including location, pressure and
its status */
struct wtp_event_finger {
u8 status;
u16 abs_x;
u16 abs_y;
u8 pressure;
u8 id;
};
/* This struct represents a touch data message from a touchpad */
struct wtp_event {
struct wtp_event_finger fingers[4];
/* relative mouse movement */
s16 rel_x;
s16 rel_y;
/* bitmask of button states. 1=down, 0=up. */
u8 buttons;
/* stores an incoming keyboard report to transmit to hid_input */
u8 kbd_report[UNIFYING_KBD_INPUT_REPORT_SIZE];
/* bitmask of buttons included within this event */
u8 has_buttons;
/* true if this event includes finger data */
bool has_abs:1;
/* true if this event includes mouse movement data */
bool has_rel:1;
/* true if this event includes keyboard input */
bool has_keys:1;
/* false if there are events following with more data,
true if this is the last one */
bool end_of_frame:1;
};
/* Struct describing the touch devices axis properties */
struct wtp_device_info {
u16 abs_max_x;
u16 abs_res_x;
u16 abs_max_y;
u16 abs_res_y;
bool has_rel:1;
u8 origin;
u16 abs_min_pressure;
u16 abs_max_pressure;
u8 max_contacts;
};
struct wtp_data;
/* Struct storing feature-specific information. Each feature_id
has methods assigned that process messages from this feature. */
struct wtp_feature {
u16 id;
u8 index;
u8 event_format;
int (*init)(struct hidpp_device *);
int (*probe)(struct hidpp_device *, struct wtp_device_info *);
int (*parse_feature_event)(struct wtp_data *, struct hidpp_report *,
struct wtp_event *);
int (*parse_other_event)(struct wtp_data *, struct hidpp_report *,
struct wtp_event *);
};
/* Structure containing device data */
struct wtp_data {
struct input_dev *input;
struct wtp_device_info info;
/* the touch feature supported by this device */
struct wtp_feature feature;
/* keep track of which buttons are down */
u8 buttons;
/* For assigning tracking IDs for MT-B protocol. */
u16 next_tracking_id;
u16 current_slots_used; /* slots = device IDs. Bitmask. */
u16 prev_slots_used; /* slots = device IDs. Bitmask. */
u8 fingers_seen_this_frame;
};
/* Bit Operations Helper */
static u16 make_u16(u8 high, u8 low)
{
return (high << 8) | low;
}
static u8 low_nib(u8 val)
{
return val & 0xf;
}
static u8 high_nib(u8 val)
{
return val >> 4;
}
static bool get_bit(u8 mask, u8 idx)
{
return mask & (1 << idx);
}
static u16 make_u12_4_8(u8 high, u8 low)
{
return make_u16(high, low) & 0x0fff;
}
static u16 make_u12_8_4(u8 high, u8 low)
{
return make_u16(high, low << 4) >> 4;
}
static s16 u12_to_s12(u16 val)
{
return ((s16)(val << 4)) >> 4;
}
/*
Helper methods for parsing mouse events. Some devices
use mouse events to report buttons.
*/
#define GENERIC_EVENT_MOUSE 0x02
#define GENERIC_EVENT_KEYBOARD 0x01
static void generic_parse_mouse_button(u8 raw,
struct wtp_event *event) {
event->has_buttons = BUTTON_LEFT_MASK | BUTTON_RIGHT_MASK |
BUTTON_MIDDLE_MASK;
event->buttons = raw & event->has_buttons;
}
static void generic_parse_mouse_rel(u8 *raw,
struct wtp_event *event) {
event->rel_x = u12_to_s12(make_u12_4_8(low_nib(raw[1]), raw[0]));
event->rel_y = u12_to_s12(make_u12_8_4(raw[2], high_nib(raw[1])));
event->has_rel = true;
}
static void generic_parse_kbd_keys(u8 *raw,
struct wtp_event *event) {
dbg_hid("%s\n", __func__);
memcpy(event->kbd_report, raw, UNIFYING_KBD_INPUT_REPORT_SIZE);
event->has_keys = true;
}
/*
TouchPadRawXY (TPRXY) Feature
*/
#define TPRXY_FEATURE 0x6100
#define TPRXY_CMD_GET_TOUCHPAD_INFO (0x00 | SOFTWARE_ID)
#define TPRXY_CMD_GET_RAW_REPORT_STATE (0x10 | SOFTWARE_ID)
#define TPRXY_CMD_SET_RAW_REPORT_STATE (0x20 | SOFTWARE_ID)
#define TPRXY_EVENT_TOUCHPAD_RAW_TOUCH_POINTS 0x00
#define TPRXY_FORMAT_RAW 0x01
#define TPRXY_FORMAT_RAW_SEPARATE_BUTTON_REPORT 0x02
#define TPRXY_FORMAT_MOUSE_EXTENDED 0x03
#define TPRXY_DEFAULT_RES 1000 /* DPI */
#define TPRXY_SLOTS_PER_FRAME 2
/* Initialize TouchPadRawXY feature:
Set touchpad into raw mode (except for T651, which allows for raw touch
data appended to mouse events). */
static int tprxy_init(struct hidpp_device *hidpp_dev)
{
struct wtp_data *fd = hidpp_dev->driver_data;
struct hidpp_report response;
int ret;
u8 params;
dbg_hid("%s\n", __func__);
if (hidpp_dev->hid_dev->product ==
USB_DEVICE_ID_WIRELESS_TOUCHPAD_T651) {
params = 0x4; /* enhanced sensitivity */
fd->feature.event_format = TPRXY_FORMAT_MOUSE_EXTENDED;
} else {
params = 0x5; /* enhanced sensitivity + raw */
fd->feature.event_format = TPRXY_FORMAT_RAW;
if (hidpp_dev->hid_dev->product == UNIFYING_DEVICE_ID_WIRELESS_TOUCHPAD)
fd->feature.event_format = TPRXY_FORMAT_RAW_SEPARATE_BUTTON_REPORT;
}
ret = hidpp_send_fap_command_sync(hidpp_dev, fd->feature.index,
TPRXY_CMD_SET_RAW_REPORT_STATE, &params, 1, &response);
return -ret;
}
/* Probe TouchPadRawXY feature */
static int tprxy_probe(struct hidpp_device *hidpp_dev,
struct wtp_device_info *info)
{
struct wtp_data *fd = hidpp_dev->driver_data;
struct hidpp_report response;
int ret;
u16 res;
u8 *params = (u8 *)response.fap.params;
dbg_hid("%s\n", __func__);
ret = hidpp_send_fap_command_sync(hidpp_dev, fd->feature.index,
TPRXY_CMD_GET_TOUCHPAD_INFO, NULL, 0, &response);
if (ret)
return -ret;
info->abs_max_x = make_u16(params[0], params[1]);
info->abs_max_y = make_u16(params[2], params[3]);
info->abs_max_pressure = params[5];
info->max_contacts = params[7];
info->origin = params[8];
res = make_u16(params[13], params[14]);
if (!res)
res = TPRXY_DEFAULT_RES;
info->abs_res_x = res;
info->abs_res_y = res;
return ret;
}
/* Parse other events while using TouchPadRawXY feature:
Mouse events might still be received in the following cases:
- Touchpad with separate buttons send mouse events on click
- Touchpad using extended mouse events send touch data as
mouse events */
static int tprxy_parse_other_event(struct wtp_data *wtp,
struct hidpp_report *report,
struct wtp_event *event) {
int i;
u8 *raw = (u8 *)report;
u8 *buf = &report->rap.params[0];
dbg_hid("%s:report_id:%x\n", __func__,report->report_id);
if (report->report_id == GENERIC_EVENT_KEYBOARD) {
generic_parse_kbd_keys(&raw[0], event);
return 0;
}
if (report->report_id != GENERIC_EVENT_MOUSE)
return -1;
if (wtp->feature.event_format != TPRXY_FORMAT_RAW)
generic_parse_mouse_button(raw[1], event);
if (wtp->feature.event_format != TPRXY_FORMAT_MOUSE_EXTENDED)
return 0;
for (i = 0; i < TPRXY_SLOTS_PER_FRAME; ++i) {
struct wtp_event_finger *finger = &event->fingers[i];
u8 *raw = buf + (5 + i * 6);
u8 width = low_nib(raw[5]);
u8 height = high_nib(raw[5]);
finger->pressure = (width * width + height * height) / 2;
finger->status = finger->pressure > 0;
finger->abs_x = make_u16(raw[2], raw[1]);
finger->abs_y = make_u16(raw[4], raw[3]);
finger->id = raw[0];
}
event->end_of_frame = !get_bit(buf[3], 7);
event->has_abs = true;
return 0;
}
/* Parse TouchPadRawXY events */
static int tprxy_parse_feature_event(struct wtp_data *wtp,
struct hidpp_report *report,
struct wtp_event *event) {
int i;
u8 *buf = &report->rap.params[0];
u8 fingers_this_frame;
dbg_hid("%s\n", __func__);
if (wtp->feature.event_format == TPRXY_FORMAT_MOUSE_EXTENDED)
return -1;
for (i = 0; i < TPRXY_SLOTS_PER_FRAME; ++i) {
u8 *raw = buf + (2 + i * 7);
event->fingers[i].status = get_bit(raw[2], 6);
event->fingers[i].abs_x = make_u16(raw[0] & 0x3f, raw[1]);
event->fingers[i].abs_y = make_u16(raw[2] & 0x3f, raw[3]);
event->fingers[i].pressure = raw[5];
event->fingers[i].id = high_nib(raw[6]);
}
event->buttons = get_bit(buf[8], 2);
event->end_of_frame = get_bit(buf[8], 0);
/* For single event frames, the end of frame flag is implied. */
fingers_this_frame = low_nib(buf[15]);
if (fingers_this_frame <= TPRXY_SLOTS_PER_FRAME)
event->end_of_frame = true;
event->has_abs = true;
if (wtp->feature.event_format == TPRXY_FORMAT_RAW)
event->has_buttons = 0x1;
return 0;
}
/*
TouchMouseRawTouchPoints (TMRTP) Feature
*/
#define TMRTP_FEATURE 0x6110
#define TMRTP_CMD_GET_TOUCHPAD_INFO (0x00 | SOFTWARE_ID)
#define TMRTP_CMD_GET_RAW_MODE (0x10 | SOFTWARE_ID)
#define TMRTP_CMD_SET_RAW_MODE (0x20 | SOFTWARE_ID)
#define TMRTP_EVENT_TOUCH_MOUSE_RAW_TOUCH_POINTS 0x00
#define TMRTP_EVENT_STATUS_CHANGED 0x01
static int tmrtp_init(struct hidpp_device *hidpp_dev)
{
struct wtp_data *fd = hidpp_dev->driver_data;
struct hidpp_report response;
int ret;
u8 params = 2; /* raw data NOT filtered */
dbg_hid("%s\n", __func__);
ret = hidpp_send_fap_command_sync(hidpp_dev, fd->feature.index,
TMRTP_CMD_SET_RAW_MODE, &params, 1, &response);
return -ret;
}
static int tmrtp_probe(struct hidpp_device *hidpp_dev,
struct wtp_device_info *info)
{
struct wtp_data *fd = hidpp_dev->driver_data;
struct hidpp_report response;
int ret;
u16 res;
u8 *params = (u8 *)response.fap.params;
dbg_hid("%s\n", __func__);
ret = hidpp_send_fap_command_sync(hidpp_dev, fd->feature.index,
TMRTP_CMD_GET_TOUCHPAD_INFO, NULL, 0, &response);
if (ret)
return -ret;
info->abs_max_x = make_u16(params[0], params[1]);
info->abs_max_y = make_u16(params[2], params[3]);
info->abs_max_pressure = params[8];
info->max_contacts = params[7];
info->origin = params[6];
res = make_u16(params[4], params[5]);
info->abs_res_x = res;
info->abs_res_y = res;
info->has_rel = true;
return ret;
}
static int tmrtp_parse_other_event(struct wtp_data *wtp,
struct hidpp_report *report,
struct wtp_event *event) {
u8 *raw = (u8 *)report;
if (report->report_id == GENERIC_EVENT_MOUSE) {
generic_parse_mouse_rel(&raw[3], event);
generic_parse_mouse_button(raw[1], event);
} else if (report->report_id == GENERIC_EVENT_KEYBOARD) {
/* In some cases T400 sends keyboard events for middle buttons */
event->has_buttons = BUTTON_MIDDLE_ALT_MASK;
event->buttons = raw[1] & BUTTON_MIDDLE_ALT_MASK;
} else {
return -1;
}
return 0;
}
static int tmrtp_parse_feature_event(struct wtp_data *wtp,
struct hidpp_report *report,
struct wtp_event *event) {
int i;
u8 *buf = &report->rap.params[0];
dbg_hid("%s\n", __func__);
if (high_nib(report->fap.funcindex_clientid) !=
TMRTP_EVENT_TOUCH_MOUSE_RAW_TOUCH_POINTS)
return 0;
for (i = 0; i < ARRAYSIZE(event->fingers); ++i) {
u8 *raw = buf + i * 4;
event->fingers[i].status = (raw[3] != 0xff);
event->fingers[i].abs_x =
make_u12_8_4(raw[0], low_nib(raw[2]));
event->fingers[i].abs_y =
make_u12_8_4(raw[1], high_nib(raw[2]));
event->fingers[i].pressure = raw[3];
event->fingers[i].id = i + 1;
}
event->has_abs = true;
event->end_of_frame = true;
return 0;
}
/*
BTTouchMouseSettings (BTTMS) Feature
*/
#define BTTMS_FEATURE 0x6120
#define BTTMS_CMD_GET_TOUCHPAD_INFO (0x00 | SOFTWARE_ID)
#define BTTMS_CMD_GET_RAW_MODE (0x10 | SOFTWARE_ID)
#define BTTMS_CMD_SET_RAW_MODE (0x20 | SOFTWARE_ID)
#define BTTMS_FORMAT_01 0x01
#define BTTMS_NUM_SLOTS 6
static int bttms_init(struct hidpp_device *hidpp_dev)
{
/* We do not use RAW mode in this feature */
return 0;
}
static int bttms_probe(struct hidpp_device *hidpp_dev,
struct wtp_device_info *info)
{
struct wtp_data *fd = hidpp_dev->driver_data;
struct hidpp_report response;
int ret;
u16 res;
u8 *params = (u8 *)response.fap.params;
dbg_hid("%s\n", __func__);
ret = hidpp_send_fap_command_sync(hidpp_dev, fd->feature.index,
BTTMS_CMD_GET_TOUCHPAD_INFO, NULL, 0, &response);
if (ret)
return -ret;
info->abs_max_x = make_u16(params[0], params[1]);
info->abs_max_y = make_u16(params[2], params[3]);
info->abs_max_pressure = params[5];
info->max_contacts = params[7];
info->origin = params[6];
fd->feature.event_format = params[9];
res = make_u16(params[4], params[5]);
info->abs_res_x = res;
info->abs_res_y = res;
info->has_rel = true;
return ret;
}
static int bttms_parse_other_event(struct wtp_data *wtp,
struct hidpp_report *report,
struct wtp_event *event) {
int id;
u8 *raw = (u8 *)report;
u8 map = raw[8];
int current_finger = 0;
dbg_hid("%s\n", __func__);
if (report->report_id != GENERIC_EVENT_MOUSE &&
wtp->feature.event_format != BTTMS_FORMAT_01)
return -1;
generic_parse_mouse_rel(&raw[2], event);
generic_parse_mouse_button(raw[1], event);
for (id = 0; id < BTTMS_NUM_SLOTS; ++id) {
if (get_bit(map, id)) {
struct wtp_event_finger *finger =
&event->fingers[current_finger];
u8 *f_raw = raw + (9 + current_finger * 4);
u8 width = low_nib(f_raw[3]);
u8 height = high_nib(f_raw[3]);
finger->status = CONTACT_STATUS_TOUCH;
finger->pressure = (width * width +
height * height) / 2;
finger->abs_x = make_u12_8_4(f_raw[0],
low_nib(f_raw[2]));
finger->abs_y = make_u12_8_4(f_raw[1],
high_nib(f_raw[2]));
finger->id = id + 1;
current_finger++;
}
}
event->has_abs = true;
event->end_of_frame = !get_bit(raw[7], 7);
return 0;
}
static int bttms_parse_feature_event(struct wtp_data *wtp,
struct hidpp_report *report,
struct wtp_event *event) {
/* We are not using raw events */
return -1;
}
/* Array enumerating all supported hidpp features */
static struct wtp_feature wtp_supported_features[] = {
{
TPRXY_FEATURE,
0, 0,
&tprxy_init,
&tprxy_probe,
&tprxy_parse_feature_event,
&tprxy_parse_other_event
},
{
TMRTP_FEATURE,
0, 0,
&tmrtp_init,
&tmrtp_probe,
&tmrtp_parse_feature_event,
&tmrtp_parse_other_event
},
{
BTTMS_FEATURE,
0, 0,
&bttms_init,
&bttms_probe,
&bttms_parse_feature_event,
&bttms_parse_other_event
},
{ }
};
/*
Common code for all devices/features
*/
/* Report a single finger as input_events. This method will also assign
tracking ids to each new finger. */
static void wtp_process_event_finger(struct wtp_data *fd,
struct wtp_event_finger *finger)
{
int slot = finger->id - 1;
bool new_finger = !(fd->prev_slots_used & (1 << slot));
fd->current_slots_used |= 1 << slot;
fd->fingers_seen_this_frame++;
dbg_hid("Finger %d: (%d,%d,%d) s=%d\n",
slot,
finger->abs_x,
finger->abs_y,
finger->pressure,
finger->status);
input_mt_slot(fd->input, slot);
if (new_finger) {
input_event(fd->input, EV_ABS, ABS_MT_TRACKING_ID,
fd->next_tracking_id++);
if (fd->next_tracking_id == 0xffff)
fd->next_tracking_id = 1;
}
input_mt_report_slot_state(fd->input, MT_TOOL_FINGER, 1);
input_event(fd->input, EV_ABS, ABS_MT_POSITION_X,
ORIGIN_IS_RIGHT(fd->info.origin) ?
fd->info.abs_max_x - finger->abs_x : finger->abs_x);
input_event(fd->input, EV_ABS, ABS_MT_POSITION_Y,
ORIGIN_IS_HIGH(fd->info.origin) ?
finger->abs_y : fd->info.abs_max_y - finger->abs_y);
input_event(fd->input, EV_ABS, ABS_MT_PRESSURE, finger->pressure);
}
/* Report an event as input_events */
static int wtp_process_event(struct hidpp_device *hidpp_dev,
struct wtp_event *event)
{
struct wtp_data *fd = (struct wtp_data *)hidpp_dev->driver_data;
int i;
if (!hidpp_dev->initialized)
return -1;
/* report buttons */
if (event->has_buttons != 0) {
fd->buttons &= ~event->has_buttons;
fd->buttons |= event->buttons & event->has_buttons;
dbg_hid("Button: 0x%x\n", fd->buttons);
input_report_key(fd->input, BTN_LEFT,
get_bit(fd->buttons, BUTTON_LEFT));
input_report_key(fd->input, BTN_RIGHT,
get_bit(fd->buttons, BUTTON_RIGHT));
input_report_key(fd->input, BTN_MIDDLE,
get_bit(fd->buttons, BUTTON_MIDDLE) |
get_bit(fd->buttons, BUTTON_MIDDLE_ALT));
}
if (event->has_keys) {
hid_report_raw_event(hidpp_dev->hid_dev, HID_INPUT_REPORT,
event->kbd_report, UNIFYING_KBD_INPUT_REPORT_SIZE, 1);
input_sync(fd->input);
return 1;
}
/* report relative mouse movement */
if (event->has_rel) {
dbg_hid("REL: (%d, %d)\n", event->rel_x, event->rel_y);
input_report_rel(fd->input, REL_X, event->rel_x);
input_report_rel(fd->input, REL_Y, event->rel_y);
}
/* sync now if there is no touch data following */
if (!event->has_abs) {
input_sync(fd->input);
return 1; /* we successfully consumed the event */
}
/* update fingers */
for (i = 0; i < ARRAYSIZE(event->fingers); i++) {
if (event->fingers[i].status != CONTACT_STATUS_RELEASED)
wtp_process_event_finger(fd, &event->fingers[i]);
}
/* update released fingers and sync */
if (event->end_of_frame) {
for (i = 0; i < SLOT_COUNT; i++) {
__u16 slot_mask = 1 << i;
bool released = (fd->prev_slots_used & slot_mask) &&
!(fd->current_slots_used & slot_mask);
if (!released)
continue;
dbg_hid("Finger %d: released\n", i);
input_mt_slot(fd->input, i);
input_event(fd->input, EV_ABS, ABS_MT_TRACKING_ID, -1);
input_mt_report_slot_state(fd->input, MT_TOOL_FINGER, 0);
}
input_mt_report_pointer_emulation(fd->input, true);
input_sync(fd->input);
fd->prev_slots_used = fd->current_slots_used;
fd->current_slots_used = 0;
fd->fingers_seen_this_frame = 0;
}
return 1; /* we successfully consumed the event */
}
/* dispatches events to feature event parsing methods and reports
the result as input_events */
static int wtp_hidpp_event_handler(struct hidpp_device *hidpp_device,
struct hidpp_report *report)
{
struct wtp_event event;
struct wtp_data *fd = (struct wtp_data *)hidpp_device->driver_data;
int ret;
memset(&event, 0, sizeof(event));
if (report->report_id == REPORT_ID_HIDPP_LONG &&
report->rap.sub_id == fd->feature.index) {
ret = (*fd->feature.parse_feature_event)(fd, report, &event);
} else {
ret = (*fd->feature.parse_other_event)(fd, report, &event);
}
if (ret)
return ret;
return wtp_process_event(hidpp_device, &event);
}
/* report device info */
static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi,
struct hid_field *field, struct hid_usage *usage,
unsigned long **bit, int *max)
{
struct hidpp_device *hidpp_dev = hid_get_drvdata(hdev);
struct wtp_data *fd = (struct wtp_data *)hidpp_dev->driver_data;
struct input_dev *input = hi->input;
int res_x_mm, res_y_mm;
dbg_hid("%s:\n", __func__);
if ( ((usage->hid & HID_USAGE_PAGE) == HID_UP_KEYBOARD) ||
((usage->hid & HID_USAGE_PAGE) == HID_UP_LED) )
return 0;
if ((usage->hid & HID_USAGE_PAGE) != HID_UP_BUTTON)
return -1;
fd->input = hi->input;
__set_bit(BTN_TOUCH, input->keybit);
__set_bit(BTN_TOOL_FINGER, input->keybit);
__set_bit(BTN_TOOL_DOUBLETAP, input->keybit);
__set_bit(BTN_TOOL_TRIPLETAP, input->keybit);
__set_bit(BTN_TOOL_QUADTAP, input->keybit);
__set_bit(BTN_TOOL_QUINTTAP, input->keybit);
__set_bit(EV_ABS, input->evbit);
input_mt_init_slots(input, SLOT_COUNT, 0);
input_set_capability(input, EV_KEY, BTN_TOUCH);
input_set_abs_params(input, ABS_MT_PRESSURE, 0, 255, 0, 0);
input_set_abs_params(input, ABS_MT_POSITION_X,
0, fd->info.abs_max_x, 0, 0);
input_set_abs_params(input, ABS_MT_POSITION_Y,
0, fd->info.abs_max_y, 0, 0);
input_set_abs_params(input, ABS_X, 0, fd->info.abs_max_x, 0, 0);
input_set_abs_params(input, ABS_Y, 0, fd->info.abs_max_y, 0, 0);
if (fd->info.has_rel) {
input_set_capability(input, EV_REL, REL_X);
input_set_capability(input, EV_REL, REL_Y);
}
res_x_mm = DPI_TO_DPMM(fd->info.abs_res_x);
res_y_mm = DPI_TO_DPMM(fd->info.abs_res_y);
input_abs_set_res(input, ABS_MT_POSITION_X, res_x_mm);
input_abs_set_res(input, ABS_MT_POSITION_Y, res_y_mm);
input_abs_set_res(input, ABS_X, res_x_mm);
input_abs_set_res(input, ABS_Y, res_y_mm);
return 0;
}
/* probes for all supported features and uses the first available
to initialize the device */
static int wtp_init_feature(struct hidpp_device *hidpp_device)
{
struct wtp_feature *feature = wtp_supported_features;
struct wtp_data *fd = (struct wtp_data *)hidpp_device->driver_data;
dbg_hid("%s\n", __func__);
while (feature->id) {
int ret;
dbg_hid("Probing feature 0x%x\n", feature->id);
ret = hidpp_get_hidpp2_feature_index(hidpp_device,
SOFTWARE_ID,
feature->id,
&feature->index);
if (ret)
return -ENODEV;
if (feature->index != 0) {
dbg_hid("Feature found at index: %d\n", feature->index);
fd->feature = *feature;
ret = (*fd->feature.probe)(hidpp_device, &fd->info);
if (ret)
return ret;
ret = (*fd->feature.init)(hidpp_device);
return ret;
} else {
dbg_hid("unavailable feature 0x%x\n", feature->id);
}
++feature;
}
/* no supported feature found on this device */
return -ENODEV;
}
static void wtp_connect_change(struct hidpp_device *hidpp_dev, bool connected)
{
struct wtp_data *fd = (struct wtp_data *)hidpp_dev->driver_data;
dbg_hid("%s: connected:%d\n", __func__, connected);
if (connected && hidpp_dev->initialized && fd->feature.init)
(*fd->feature.init)(hidpp_dev);
}
static int wtp_probe(struct hid_device *hdev, const struct hid_device_id *id)
{
struct wtp_data *fd = NULL;
struct hidpp_device *hidpp_device = NULL;
int ret;
struct hidpp_report response;
dbg_hid("%s\n", __func__);
hidpp_device = kzalloc(sizeof(struct hidpp_device), GFP_KERNEL);
if (!hidpp_device) {
hid_err(hdev, "cannot allocate hidpp_device\n");
ret = -ENOMEM;
goto hidpp_alloc_failed;
}
fd = kzalloc(sizeof(struct wtp_data), GFP_KERNEL);
if (!fd) {
hid_err(hdev, "cannot allocate wtp Touch data\n");
ret = -ENOMEM;
goto fd_alloc_failed;
}
fd->next_tracking_id = 1;
hidpp_device->driver_data = (void *)fd;
hid_set_drvdata(hdev, hidpp_device);
hidpp_device->connect_change = wtp_connect_change;
ret = hid_parse(hdev);
if (ret) {
ret = -ENODEV;
goto failed;
}
ret = hidpp_init(hidpp_device, hdev);
if (ret) {
ret = -ENODEV;
goto failed;
}
hid_device_io_start(hdev);
/* Get hid++ version number */
ret = hidpp_send_hidpp2_sync(hidpp_device, REPORT_ID_HIDPP_LONG,
0, 1,
SOFTWARE_ID,
NULL, 0, &response);
if (ret) {
dbg_hid("send root cmd returned: %d", ret);
ret = -ENODEV;
goto failed;
}
dbg_hid("HID++ version: %d.%d\n", response.rap.params[0],
response.rap.params[1]);
/* TODO(adlr): Consider requiring a specific/minimum HID++ version. */
ret = wtp_init_feature(hidpp_device);
if (ret) {
dbg_hid("wtp_init_feature returned: %d", ret);
ret = -ENODEV;
goto failed;
}
hid_device_io_stop(hdev);
hidpp_device->raw_event = wtp_hidpp_event_handler;
hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS;
ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT);
if (ret) {
ret = -ENODEV;
goto failed;
}
return 0;
failed:
hid_set_drvdata(hdev, NULL);
kfree(fd);
fd_alloc_failed:
kfree(hidpp_device);
hidpp_alloc_failed:
return ret;
}
static void wtp_remove(struct hid_device *hdev)
{
struct hidpp_device *hidpp_dev = hid_get_drvdata(hdev);
struct wtp_data *fd = hidpp_dev->driver_data;
dbg_hid("%s\n", __func__);
hid_hw_stop(hdev);
hidpp_remove(hidpp_dev);
kfree(fd);
kfree(hidpp_dev);
hid_set_drvdata(hdev, NULL);
}
static struct hid_driver wtp_driver = {
.name = "wtp-touch",
.id_table = wtp_devices,
.probe = wtp_probe,
.remove = wtp_remove,
.input_mapping = wtp_input_mapping,
.raw_event = hidpp_raw_event,
};
static int __init wtp_init(void)
{
return hid_register_driver(&wtp_driver);
}
static void __exit wtp_exit(void)
{
hid_unregister_driver(&wtp_driver);
}
module_init(wtp_init);
module_exit(wtp_exit);
Reference in New Issue View Git Blame Copy Permalink