1/* 2 * HIDPP protocol for Logitech Unifying receivers 3 * 4 * Copyright (c) 2011 Logitech (c) 5 * Copyright (c) 2012-2013 Google (c) 6 * Copyright (c) 2013-2014 Red Hat Inc. 7 */ 8 9/* 10 * This program is free software; you can redistribute it and/or modify it 11 * under the terms of the GNU General Public License as published by the Free 12 * Software Foundation; version 2 of the License. 13 */ 14 15#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 16 17#include <linux/device.h> 18#include <linux/hid.h> 19#include <linux/module.h> 20#include <linux/slab.h> 21#include <linux/sched.h> 22#include <linux/kfifo.h> 23#include <linux/input/mt.h> 24#include <asm/unaligned.h> 25#include "hid-ids.h" 26 27MODULE_LICENSE("GPL"); 28MODULE_AUTHOR("Benjamin Tissoires <benjamin.tissoires@gmail.com>"); 29MODULE_AUTHOR("Nestor Lopez Casado <nlopezcasad@logitech.com>"); 30 31static bool disable_raw_mode; 32module_param(disable_raw_mode, bool, 0644); 33MODULE_PARM_DESC(disable_raw_mode, 34 "Disable Raw mode reporting for touchpads and keep firmware gestures."); 35 36static bool disable_tap_to_click; 37module_param(disable_tap_to_click, bool, 0644); 38MODULE_PARM_DESC(disable_tap_to_click, 39 "Disable Tap-To-Click mode reporting for touchpads (only on the K400 currently)."); 40 41#define REPORT_ID_HIDPP_SHORT 0x10 42#define REPORT_ID_HIDPP_LONG 0x11 43 44#define HIDPP_REPORT_SHORT_LENGTH 7 45#define HIDPP_REPORT_LONG_LENGTH 20 46 47#define HIDPP_QUIRK_CLASS_WTP BIT(0) 48#define HIDPP_QUIRK_CLASS_M560 BIT(1) 49#define HIDPP_QUIRK_CLASS_K400 BIT(2) 50 51/* bits 2..20 are reserved for classes */ 52#define HIDPP_QUIRK_CONNECT_EVENTS BIT(21) 53#define HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS BIT(22) 54#define HIDPP_QUIRK_NO_HIDINPUT BIT(23) 55 56#define HIDPP_QUIRK_DELAYED_INIT (HIDPP_QUIRK_NO_HIDINPUT | \ 57 HIDPP_QUIRK_CONNECT_EVENTS) 58 59/* 60 * There are two hidpp protocols in use, the first version hidpp10 is known 61 * as register access protocol or RAP, the second version hidpp20 is known as 62 * feature access protocol or FAP 63 * 64 * Most older devices (including the Unifying usb receiver) use the RAP protocol 65 * where as most newer devices use the FAP protocol. Both protocols are 66 * compatible with the underlying transport, which could be usb, Unifiying, or 67 * bluetooth. The message lengths are defined by the hid vendor specific report 68 * descriptor for the HIDPP_SHORT report type (total message lenth 7 bytes) and 69 * the HIDPP_LONG report type (total message length 20 bytes) 70 * 71 * The RAP protocol uses both report types, whereas the FAP only uses HIDPP_LONG 72 * messages. The Unifying receiver itself responds to RAP messages (device index 73 * is 0xFF for the receiver), and all messages (short or long) with a device 74 * index between 1 and 6 are passed untouched to the corresponding paired 75 * Unifying device. 76 * 77 * The paired device can be RAP or FAP, it will receive the message untouched 78 * from the Unifiying receiver. 79 */ 80 81struct fap { 82 u8 feature_index; 83 u8 funcindex_clientid; 84 u8 params[HIDPP_REPORT_LONG_LENGTH - 4U]; 85}; 86 87struct rap { 88 u8 sub_id; 89 u8 reg_address; 90 u8 params[HIDPP_REPORT_LONG_LENGTH - 4U]; 91}; 92 93struct hidpp_report { 94 u8 report_id; 95 u8 device_index; 96 union { 97 struct fap fap; 98 struct rap rap; 99 u8 rawbytes[sizeof(struct fap)]; 100 }; 101} __packed; 102 103struct hidpp_device { 104 struct hid_device *hid_dev; 105 struct mutex send_mutex; 106 void *send_receive_buf; 107 char *name; /* will never be NULL and should not be freed */ 108 wait_queue_head_t wait; 109 bool answer_available; 110 u8 protocol_major; 111 u8 protocol_minor; 112 113 void *private_data; 114 115 struct work_struct work; 116 struct kfifo delayed_work_fifo; 117 atomic_t connected; 118 struct input_dev *delayed_input; 119 120 unsigned long quirks; 121}; 122 123 124/* HID++ 1.0 error codes */ 125#define HIDPP_ERROR 0x8f 126#define HIDPP_ERROR_SUCCESS 0x00 127#define HIDPP_ERROR_INVALID_SUBID 0x01 128#define HIDPP_ERROR_INVALID_ADRESS 0x02 129#define HIDPP_ERROR_INVALID_VALUE 0x03 130#define HIDPP_ERROR_CONNECT_FAIL 0x04 131#define HIDPP_ERROR_TOO_MANY_DEVICES 0x05 132#define HIDPP_ERROR_ALREADY_EXISTS 0x06 133#define HIDPP_ERROR_BUSY 0x07 134#define HIDPP_ERROR_UNKNOWN_DEVICE 0x08 135#define HIDPP_ERROR_RESOURCE_ERROR 0x09 136#define HIDPP_ERROR_REQUEST_UNAVAILABLE 0x0a 137#define HIDPP_ERROR_INVALID_PARAM_VALUE 0x0b 138#define HIDPP_ERROR_WRONG_PIN_CODE 0x0c 139/* HID++ 2.0 error codes */ 140#define HIDPP20_ERROR 0xff 141 142static void hidpp_connect_event(struct hidpp_device *hidpp_dev); 143 144static int __hidpp_send_report(struct hid_device *hdev, 145 struct hidpp_report *hidpp_report) 146{ 147 int fields_count, ret; 148 149 switch (hidpp_report->report_id) { 150 case REPORT_ID_HIDPP_SHORT: 151 fields_count = HIDPP_REPORT_SHORT_LENGTH; 152 break; 153 case REPORT_ID_HIDPP_LONG: 154 fields_count = HIDPP_REPORT_LONG_LENGTH; 155 break; 156 default: 157 return -ENODEV; 158 } 159 160 /* 161 * set the device_index as the receiver, it will be overwritten by 162 * hid_hw_request if needed 163 */ 164 hidpp_report->device_index = 0xff; 165 166 ret = hid_hw_raw_request(hdev, hidpp_report->report_id, 167 (u8 *)hidpp_report, fields_count, HID_OUTPUT_REPORT, 168 HID_REQ_SET_REPORT); 169 170 return ret == fields_count ? 0 : -1; 171} 172 173/** 174 * hidpp_send_message_sync() returns 0 in case of success, and something else 175 * in case of a failure. 176 * - If ' something else' is positive, that means that an error has been raised 177 * by the protocol itself. 178 * - If ' something else' is negative, that means that we had a classic error 179 * (-ENOMEM, -EPIPE, etc...) 180 */ 181static int hidpp_send_message_sync(struct hidpp_device *hidpp, 182 struct hidpp_report *message, 183 struct hidpp_report *response) 184{ 185 int ret; 186 187 mutex_lock(&hidpp->send_mutex); 188 189 hidpp->send_receive_buf = response; 190 hidpp->answer_available = false; 191 192 /* 193 * So that we can later validate the answer when it arrives 194 * in hidpp_raw_event 195 */ 196 *response = *message; 197 198 ret = __hidpp_send_report(hidpp->hid_dev, message); 199 200 if (ret) { 201 dbg_hid("__hidpp_send_report returned err: %d\n", ret); 202 memset(response, 0, sizeof(struct hidpp_report)); 203 goto exit; 204 } 205 206 if (!wait_event_timeout(hidpp->wait, hidpp->answer_available, 207 5*HZ)) { 208 dbg_hid("%s:timeout waiting for response\n", __func__); 209 memset(response, 0, sizeof(struct hidpp_report)); 210 ret = -ETIMEDOUT; 211 } 212 213 if (response->report_id == REPORT_ID_HIDPP_SHORT && 214 response->rap.sub_id == HIDPP_ERROR) { 215 ret = response->rap.params[1]; 216 dbg_hid("%s:got hidpp error %02X\n", __func__, ret); 217 goto exit; 218 } 219 220 if (response->report_id == REPORT_ID_HIDPP_LONG && 221 response->fap.feature_index == HIDPP20_ERROR) { 222 ret = response->fap.params[1]; 223 dbg_hid("%s:got hidpp 2.0 error %02X\n", __func__, ret); 224 goto exit; 225 } 226 227exit: 228 mutex_unlock(&hidpp->send_mutex); 229 return ret; 230 231} 232 233static int hidpp_send_fap_command_sync(struct hidpp_device *hidpp, 234 u8 feat_index, u8 funcindex_clientid, u8 *params, int param_count, 235 struct hidpp_report *response) 236{ 237 struct hidpp_report *message; 238 int ret; 239 240 if (param_count > sizeof(message->fap.params)) 241 return -EINVAL; 242 243 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL); 244 if (!message) 245 return -ENOMEM; 246 message->report_id = REPORT_ID_HIDPP_LONG; 247 message->fap.feature_index = feat_index; 248 message->fap.funcindex_clientid = funcindex_clientid; 249 memcpy(&message->fap.params, params, param_count); 250 251 ret = hidpp_send_message_sync(hidpp, message, response); 252 kfree(message); 253 return ret; 254} 255 256static int hidpp_send_rap_command_sync(struct hidpp_device *hidpp_dev, 257 u8 report_id, u8 sub_id, u8 reg_address, u8 *params, int param_count, 258 struct hidpp_report *response) 259{ 260 struct hidpp_report *message; 261 int ret; 262 263 if ((report_id != REPORT_ID_HIDPP_SHORT) && 264 (report_id != REPORT_ID_HIDPP_LONG)) 265 return -EINVAL; 266 267 if (param_count > sizeof(message->rap.params)) 268 return -EINVAL; 269 270 message = kzalloc(sizeof(struct hidpp_report), GFP_KERNEL); 271 if (!message) 272 return -ENOMEM; 273 message->report_id = report_id; 274 message->rap.sub_id = sub_id; 275 message->rap.reg_address = reg_address; 276 memcpy(&message->rap.params, params, param_count); 277 278 ret = hidpp_send_message_sync(hidpp_dev, message, response); 279 kfree(message); 280 return ret; 281} 282 283static void delayed_work_cb(struct work_struct *work) 284{ 285 struct hidpp_device *hidpp = container_of(work, struct hidpp_device, 286 work); 287 hidpp_connect_event(hidpp); 288} 289 290static inline bool hidpp_match_answer(struct hidpp_report *question, 291 struct hidpp_report *answer) 292{ 293 return (answer->fap.feature_index == question->fap.feature_index) && 294 (answer->fap.funcindex_clientid == question->fap.funcindex_clientid); 295} 296 297static inline bool hidpp_match_error(struct hidpp_report *question, 298 struct hidpp_report *answer) 299{ 300 return ((answer->rap.sub_id == HIDPP_ERROR) || 301 (answer->fap.feature_index == HIDPP20_ERROR)) && 302 (answer->fap.funcindex_clientid == question->fap.feature_index) && 303 (answer->fap.params[0] == question->fap.funcindex_clientid); 304} 305 306static inline bool hidpp_report_is_connect_event(struct hidpp_report *report) 307{ 308 return (report->report_id == REPORT_ID_HIDPP_SHORT) && 309 (report->rap.sub_id == 0x41); 310} 311 312/** 313 * hidpp_prefix_name() prefixes the current given name with "Logitech ". 314 */ 315static void hidpp_prefix_name(char **name, int name_length) 316{ 317#define PREFIX_LENGTH 9 /* "Logitech " */ 318 319 int new_length; 320 char *new_name; 321 322 if (name_length > PREFIX_LENGTH && 323 strncmp(*name, "Logitech ", PREFIX_LENGTH) == 0) 324 /* The prefix has is already in the name */ 325 return; 326 327 new_length = PREFIX_LENGTH + name_length; 328 new_name = kzalloc(new_length, GFP_KERNEL); 329 if (!new_name) 330 return; 331 332 snprintf(new_name, new_length, "Logitech %s", *name); 333 334 kfree(*name); 335 336 *name = new_name; 337} 338 339/* -------------------------------------------------------------------------- */ 340/* HIDP++ 1.0 commands */ 341/* -------------------------------------------------------------------------- */ 342 343#define HIDPP_SET_REGISTER 0x80 344#define HIDPP_GET_REGISTER 0x81 345#define HIDPP_SET_LONG_REGISTER 0x82 346#define HIDPP_GET_LONG_REGISTER 0x83 347 348#define HIDPP_REG_PAIRING_INFORMATION 0xB5 349#define DEVICE_NAME 0x40 350 351static char *hidpp_get_unifying_name(struct hidpp_device *hidpp_dev) 352{ 353 struct hidpp_report response; 354 int ret; 355 /* hid-logitech-dj is in charge of setting the right device index */ 356 u8 params[1] = { DEVICE_NAME }; 357 char *name; 358 int len; 359 360 ret = hidpp_send_rap_command_sync(hidpp_dev, 361 REPORT_ID_HIDPP_SHORT, 362 HIDPP_GET_LONG_REGISTER, 363 HIDPP_REG_PAIRING_INFORMATION, 364 params, 1, &response); 365 if (ret) 366 return NULL; 367 368 len = response.rap.params[1]; 369 370 if (2 + len > sizeof(response.rap.params)) 371 return NULL; 372 373 name = kzalloc(len + 1, GFP_KERNEL); 374 if (!name) 375 return NULL; 376 377 memcpy(name, &response.rap.params[2], len); 378 379 /* include the terminating '\0' */ 380 hidpp_prefix_name(&name, len + 1); 381 382 return name; 383} 384 385/* -------------------------------------------------------------------------- */ 386/* 0x0000: Root */ 387/* -------------------------------------------------------------------------- */ 388 389#define HIDPP_PAGE_ROOT 0x0000 390#define HIDPP_PAGE_ROOT_IDX 0x00 391 392#define CMD_ROOT_GET_FEATURE 0x01 393#define CMD_ROOT_GET_PROTOCOL_VERSION 0x11 394 395static int hidpp_root_get_feature(struct hidpp_device *hidpp, u16 feature, 396 u8 *feature_index, u8 *feature_type) 397{ 398 struct hidpp_report response; 399 int ret; 400 u8 params[2] = { feature >> 8, feature & 0x00FF }; 401 402 ret = hidpp_send_fap_command_sync(hidpp, 403 HIDPP_PAGE_ROOT_IDX, 404 CMD_ROOT_GET_FEATURE, 405 params, 2, &response); 406 if (ret) 407 return ret; 408 409 *feature_index = response.fap.params[0]; 410 *feature_type = response.fap.params[1]; 411 412 return ret; 413} 414 415static int hidpp_root_get_protocol_version(struct hidpp_device *hidpp) 416{ 417 struct hidpp_report response; 418 int ret; 419 420 ret = hidpp_send_fap_command_sync(hidpp, 421 HIDPP_PAGE_ROOT_IDX, 422 CMD_ROOT_GET_PROTOCOL_VERSION, 423 NULL, 0, &response); 424 425 if (ret == HIDPP_ERROR_INVALID_SUBID) { 426 hidpp->protocol_major = 1; 427 hidpp->protocol_minor = 0; 428 return 0; 429 } 430 431 /* the device might not be connected */ 432 if (ret == HIDPP_ERROR_RESOURCE_ERROR) 433 return -EIO; 434 435 if (ret > 0) { 436 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n", 437 __func__, ret); 438 return -EPROTO; 439 } 440 if (ret) 441 return ret; 442 443 hidpp->protocol_major = response.fap.params[0]; 444 hidpp->protocol_minor = response.fap.params[1]; 445 446 return ret; 447} 448 449static bool hidpp_is_connected(struct hidpp_device *hidpp) 450{ 451 int ret; 452 453 ret = hidpp_root_get_protocol_version(hidpp); 454 if (!ret) 455 hid_dbg(hidpp->hid_dev, "HID++ %u.%u device connected.\n", 456 hidpp->protocol_major, hidpp->protocol_minor); 457 return ret == 0; 458} 459 460/* -------------------------------------------------------------------------- */ 461/* 0x0005: GetDeviceNameType */ 462/* -------------------------------------------------------------------------- */ 463 464#define HIDPP_PAGE_GET_DEVICE_NAME_TYPE 0x0005 465 466#define CMD_GET_DEVICE_NAME_TYPE_GET_COUNT 0x01 467#define CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME 0x11 468#define CMD_GET_DEVICE_NAME_TYPE_GET_TYPE 0x21 469 470static int hidpp_devicenametype_get_count(struct hidpp_device *hidpp, 471 u8 feature_index, u8 *nameLength) 472{ 473 struct hidpp_report response; 474 int ret; 475 476 ret = hidpp_send_fap_command_sync(hidpp, feature_index, 477 CMD_GET_DEVICE_NAME_TYPE_GET_COUNT, NULL, 0, &response); 478 479 if (ret > 0) { 480 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n", 481 __func__, ret); 482 return -EPROTO; 483 } 484 if (ret) 485 return ret; 486 487 *nameLength = response.fap.params[0]; 488 489 return ret; 490} 491 492static int hidpp_devicenametype_get_device_name(struct hidpp_device *hidpp, 493 u8 feature_index, u8 char_index, char *device_name, int len_buf) 494{ 495 struct hidpp_report response; 496 int ret, i; 497 int count; 498 499 ret = hidpp_send_fap_command_sync(hidpp, feature_index, 500 CMD_GET_DEVICE_NAME_TYPE_GET_DEVICE_NAME, &char_index, 1, 501 &response); 502 503 if (ret > 0) { 504 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n", 505 __func__, ret); 506 return -EPROTO; 507 } 508 if (ret) 509 return ret; 510 511 if (response.report_id == REPORT_ID_HIDPP_LONG) 512 count = HIDPP_REPORT_LONG_LENGTH - 4; 513 else 514 count = HIDPP_REPORT_SHORT_LENGTH - 4; 515 516 if (len_buf < count) 517 count = len_buf; 518 519 for (i = 0; i < count; i++) 520 device_name[i] = response.fap.params[i]; 521 522 return count; 523} 524 525static char *hidpp_get_device_name(struct hidpp_device *hidpp) 526{ 527 u8 feature_type; 528 u8 feature_index; 529 u8 __name_length; 530 char *name; 531 unsigned index = 0; 532 int ret; 533 534 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_GET_DEVICE_NAME_TYPE, 535 &feature_index, &feature_type); 536 if (ret) 537 return NULL; 538 539 ret = hidpp_devicenametype_get_count(hidpp, feature_index, 540 &__name_length); 541 if (ret) 542 return NULL; 543 544 name = kzalloc(__name_length + 1, GFP_KERNEL); 545 if (!name) 546 return NULL; 547 548 while (index < __name_length) { 549 ret = hidpp_devicenametype_get_device_name(hidpp, 550 feature_index, index, name + index, 551 __name_length - index); 552 if (ret <= 0) { 553 kfree(name); 554 return NULL; 555 } 556 index += ret; 557 } 558 559 /* include the terminating '\0' */ 560 hidpp_prefix_name(&name, __name_length + 1); 561 562 return name; 563} 564 565/* -------------------------------------------------------------------------- */ 566/* 0x6010: Touchpad FW items */ 567/* -------------------------------------------------------------------------- */ 568 569#define HIDPP_PAGE_TOUCHPAD_FW_ITEMS 0x6010 570 571#define CMD_TOUCHPAD_FW_ITEMS_SET 0x10 572 573struct hidpp_touchpad_fw_items { 574 uint8_t presence; 575 uint8_t desired_state; 576 uint8_t state; 577 uint8_t persistent; 578}; 579 580/** 581 * send a set state command to the device by reading the current items->state 582 * field. items is then filled with the current state. 583 */ 584static int hidpp_touchpad_fw_items_set(struct hidpp_device *hidpp, 585 u8 feature_index, 586 struct hidpp_touchpad_fw_items *items) 587{ 588 struct hidpp_report response; 589 int ret; 590 u8 *params = (u8 *)response.fap.params; 591 592 ret = hidpp_send_fap_command_sync(hidpp, feature_index, 593 CMD_TOUCHPAD_FW_ITEMS_SET, &items->state, 1, &response); 594 595 if (ret > 0) { 596 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n", 597 __func__, ret); 598 return -EPROTO; 599 } 600 if (ret) 601 return ret; 602 603 items->presence = params[0]; 604 items->desired_state = params[1]; 605 items->state = params[2]; 606 items->persistent = params[3]; 607 608 return 0; 609} 610 611/* -------------------------------------------------------------------------- */ 612/* 0x6100: TouchPadRawXY */ 613/* -------------------------------------------------------------------------- */ 614 615#define HIDPP_PAGE_TOUCHPAD_RAW_XY 0x6100 616 617#define CMD_TOUCHPAD_GET_RAW_INFO 0x01 618#define CMD_TOUCHPAD_SET_RAW_REPORT_STATE 0x21 619 620#define EVENT_TOUCHPAD_RAW_XY 0x00 621 622#define TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT 0x01 623#define TOUCHPAD_RAW_XY_ORIGIN_UPPER_LEFT 0x03 624 625struct hidpp_touchpad_raw_info { 626 u16 x_size; 627 u16 y_size; 628 u8 z_range; 629 u8 area_range; 630 u8 timestamp_unit; 631 u8 maxcontacts; 632 u8 origin; 633 u16 res; 634}; 635 636struct hidpp_touchpad_raw_xy_finger { 637 u8 contact_type; 638 u8 contact_status; 639 u16 x; 640 u16 y; 641 u8 z; 642 u8 area; 643 u8 finger_id; 644}; 645 646struct hidpp_touchpad_raw_xy { 647 u16 timestamp; 648 struct hidpp_touchpad_raw_xy_finger fingers[2]; 649 u8 spurious_flag; 650 u8 end_of_frame; 651 u8 finger_count; 652 u8 button; 653}; 654 655static int hidpp_touchpad_get_raw_info(struct hidpp_device *hidpp, 656 u8 feature_index, struct hidpp_touchpad_raw_info *raw_info) 657{ 658 struct hidpp_report response; 659 int ret; 660 u8 *params = (u8 *)response.fap.params; 661 662 ret = hidpp_send_fap_command_sync(hidpp, feature_index, 663 CMD_TOUCHPAD_GET_RAW_INFO, NULL, 0, &response); 664 665 if (ret > 0) { 666 hid_err(hidpp->hid_dev, "%s: received protocol error 0x%02x\n", 667 __func__, ret); 668 return -EPROTO; 669 } 670 if (ret) 671 return ret; 672 673 raw_info->x_size = get_unaligned_be16(¶ms[0]); 674 raw_info->y_size = get_unaligned_be16(¶ms[2]); 675 raw_info->z_range = params[4]; 676 raw_info->area_range = params[5]; 677 raw_info->maxcontacts = params[7]; 678 raw_info->origin = params[8]; 679 /* res is given in unit per inch */ 680 raw_info->res = get_unaligned_be16(¶ms[13]) * 2 / 51; 681 682 return ret; 683} 684 685static int hidpp_touchpad_set_raw_report_state(struct hidpp_device *hidpp_dev, 686 u8 feature_index, bool send_raw_reports, 687 bool sensor_enhanced_settings) 688{ 689 struct hidpp_report response; 690 691 /* 692 * Params: 693 * bit 0 - enable raw 694 * bit 1 - 16bit Z, no area 695 * bit 2 - enhanced sensitivity 696 * bit 3 - width, height (4 bits each) instead of area 697 * bit 4 - send raw + gestures (degrades smoothness) 698 * remaining bits - reserved 699 */ 700 u8 params = send_raw_reports | (sensor_enhanced_settings << 2); 701 702 return hidpp_send_fap_command_sync(hidpp_dev, feature_index, 703 CMD_TOUCHPAD_SET_RAW_REPORT_STATE, ¶ms, 1, &response); 704} 705 706static void hidpp_touchpad_touch_event(u8 *data, 707 struct hidpp_touchpad_raw_xy_finger *finger) 708{ 709 u8 x_m = data[0] << 2; 710 u8 y_m = data[2] << 2; 711 712 finger->x = x_m << 6 | data[1]; 713 finger->y = y_m << 6 | data[3]; 714 715 finger->contact_type = data[0] >> 6; 716 finger->contact_status = data[2] >> 6; 717 718 finger->z = data[4]; 719 finger->area = data[5]; 720 finger->finger_id = data[6] >> 4; 721} 722 723static void hidpp_touchpad_raw_xy_event(struct hidpp_device *hidpp_dev, 724 u8 *data, struct hidpp_touchpad_raw_xy *raw_xy) 725{ 726 memset(raw_xy, 0, sizeof(struct hidpp_touchpad_raw_xy)); 727 raw_xy->end_of_frame = data[8] & 0x01; 728 raw_xy->spurious_flag = (data[8] >> 1) & 0x01; 729 raw_xy->finger_count = data[15] & 0x0f; 730 raw_xy->button = (data[8] >> 2) & 0x01; 731 732 if (raw_xy->finger_count) { 733 hidpp_touchpad_touch_event(&data[2], &raw_xy->fingers[0]); 734 hidpp_touchpad_touch_event(&data[9], &raw_xy->fingers[1]); 735 } 736} 737 738/* ************************************************************************** */ 739/* */ 740/* Device Support */ 741/* */ 742/* ************************************************************************** */ 743 744/* -------------------------------------------------------------------------- */ 745/* Touchpad HID++ devices */ 746/* -------------------------------------------------------------------------- */ 747 748#define WTP_MANUAL_RESOLUTION 39 749 750struct wtp_data { 751 struct input_dev *input; 752 u16 x_size, y_size; 753 u8 finger_count; 754 u8 mt_feature_index; 755 u8 button_feature_index; 756 u8 maxcontacts; 757 bool flip_y; 758 unsigned int resolution; 759}; 760 761static int wtp_input_mapping(struct hid_device *hdev, struct hid_input *hi, 762 struct hid_field *field, struct hid_usage *usage, 763 unsigned long **bit, int *max) 764{ 765 return -1; 766} 767 768static void wtp_populate_input(struct hidpp_device *hidpp, 769 struct input_dev *input_dev, bool origin_is_hid_core) 770{ 771 struct wtp_data *wd = hidpp->private_data; 772 773 __set_bit(EV_ABS, input_dev->evbit); 774 __set_bit(EV_KEY, input_dev->evbit); 775 __clear_bit(EV_REL, input_dev->evbit); 776 __clear_bit(EV_LED, input_dev->evbit); 777 778 input_set_abs_params(input_dev, ABS_MT_POSITION_X, 0, wd->x_size, 0, 0); 779 input_abs_set_res(input_dev, ABS_MT_POSITION_X, wd->resolution); 780 input_set_abs_params(input_dev, ABS_MT_POSITION_Y, 0, wd->y_size, 0, 0); 781 input_abs_set_res(input_dev, ABS_MT_POSITION_Y, wd->resolution); 782 783 /* Max pressure is not given by the devices, pick one */ 784 input_set_abs_params(input_dev, ABS_MT_PRESSURE, 0, 50, 0, 0); 785 786 input_set_capability(input_dev, EV_KEY, BTN_LEFT); 787 788 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) 789 input_set_capability(input_dev, EV_KEY, BTN_RIGHT); 790 else 791 __set_bit(INPUT_PROP_BUTTONPAD, input_dev->propbit); 792 793 input_mt_init_slots(input_dev, wd->maxcontacts, INPUT_MT_POINTER | 794 INPUT_MT_DROP_UNUSED); 795 796 wd->input = input_dev; 797} 798 799static void wtp_touch_event(struct wtp_data *wd, 800 struct hidpp_touchpad_raw_xy_finger *touch_report) 801{ 802 int slot; 803 804 if (!touch_report->finger_id || touch_report->contact_type) 805 /* no actual data */ 806 return; 807 808 slot = input_mt_get_slot_by_key(wd->input, touch_report->finger_id); 809 810 input_mt_slot(wd->input, slot); 811 input_mt_report_slot_state(wd->input, MT_TOOL_FINGER, 812 touch_report->contact_status); 813 if (touch_report->contact_status) { 814 input_event(wd->input, EV_ABS, ABS_MT_POSITION_X, 815 touch_report->x); 816 input_event(wd->input, EV_ABS, ABS_MT_POSITION_Y, 817 wd->flip_y ? wd->y_size - touch_report->y : 818 touch_report->y); 819 input_event(wd->input, EV_ABS, ABS_MT_PRESSURE, 820 touch_report->area); 821 } 822} 823 824static void wtp_send_raw_xy_event(struct hidpp_device *hidpp, 825 struct hidpp_touchpad_raw_xy *raw) 826{ 827 struct wtp_data *wd = hidpp->private_data; 828 int i; 829 830 for (i = 0; i < 2; i++) 831 wtp_touch_event(wd, &(raw->fingers[i])); 832 833 if (raw->end_of_frame && 834 !(hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS)) 835 input_event(wd->input, EV_KEY, BTN_LEFT, raw->button); 836 837 if (raw->end_of_frame || raw->finger_count <= 2) { 838 input_mt_sync_frame(wd->input); 839 input_sync(wd->input); 840 } 841} 842 843static int wtp_mouse_raw_xy_event(struct hidpp_device *hidpp, u8 *data) 844{ 845 struct wtp_data *wd = hidpp->private_data; 846 u8 c1_area = ((data[7] & 0xf) * (data[7] & 0xf) + 847 (data[7] >> 4) * (data[7] >> 4)) / 2; 848 u8 c2_area = ((data[13] & 0xf) * (data[13] & 0xf) + 849 (data[13] >> 4) * (data[13] >> 4)) / 2; 850 struct hidpp_touchpad_raw_xy raw = { 851 .timestamp = data[1], 852 .fingers = { 853 { 854 .contact_type = 0, 855 .contact_status = !!data[7], 856 .x = get_unaligned_le16(&data[3]), 857 .y = get_unaligned_le16(&data[5]), 858 .z = c1_area, 859 .area = c1_area, 860 .finger_id = data[2], 861 }, { 862 .contact_type = 0, 863 .contact_status = !!data[13], 864 .x = get_unaligned_le16(&data[9]), 865 .y = get_unaligned_le16(&data[11]), 866 .z = c2_area, 867 .area = c2_area, 868 .finger_id = data[8], 869 } 870 }, 871 .finger_count = wd->maxcontacts, 872 .spurious_flag = 0, 873 .end_of_frame = (data[0] >> 7) == 0, 874 .button = data[0] & 0x01, 875 }; 876 877 wtp_send_raw_xy_event(hidpp, &raw); 878 879 return 1; 880} 881 882static int wtp_raw_event(struct hid_device *hdev, u8 *data, int size) 883{ 884 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 885 struct wtp_data *wd = hidpp->private_data; 886 struct hidpp_report *report = (struct hidpp_report *)data; 887 struct hidpp_touchpad_raw_xy raw; 888 889 if (!wd || !wd->input) 890 return 1; 891 892 switch (data[0]) { 893 case 0x02: 894 if (size < 2) { 895 hid_err(hdev, "Received HID report of bad size (%d)", 896 size); 897 return 1; 898 } 899 if (hidpp->quirks & HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS) { 900 input_event(wd->input, EV_KEY, BTN_LEFT, 901 !!(data[1] & 0x01)); 902 input_event(wd->input, EV_KEY, BTN_RIGHT, 903 !!(data[1] & 0x02)); 904 input_sync(wd->input); 905 return 0; 906 } else { 907 if (size < 21) 908 return 1; 909 return wtp_mouse_raw_xy_event(hidpp, &data[7]); 910 } 911 case REPORT_ID_HIDPP_LONG: 912 /* size is already checked in hidpp_raw_event. */ 913 if ((report->fap.feature_index != wd->mt_feature_index) || 914 (report->fap.funcindex_clientid != EVENT_TOUCHPAD_RAW_XY)) 915 return 1; 916 hidpp_touchpad_raw_xy_event(hidpp, data + 4, &raw); 917 918 wtp_send_raw_xy_event(hidpp, &raw); 919 return 0; 920 } 921 922 return 0; 923} 924 925static int wtp_get_config(struct hidpp_device *hidpp) 926{ 927 struct wtp_data *wd = hidpp->private_data; 928 struct hidpp_touchpad_raw_info raw_info = {0}; 929 u8 feature_type; 930 int ret; 931 932 ret = hidpp_root_get_feature(hidpp, HIDPP_PAGE_TOUCHPAD_RAW_XY, 933 &wd->mt_feature_index, &feature_type); 934 if (ret) 935 /* means that the device is not powered up */ 936 return ret; 937 938 ret = hidpp_touchpad_get_raw_info(hidpp, wd->mt_feature_index, 939 &raw_info); 940 if (ret) 941 return ret; 942 943 wd->x_size = raw_info.x_size; 944 wd->y_size = raw_info.y_size; 945 wd->maxcontacts = raw_info.maxcontacts; 946 wd->flip_y = raw_info.origin == TOUCHPAD_RAW_XY_ORIGIN_LOWER_LEFT; 947 wd->resolution = raw_info.res; 948 if (!wd->resolution) 949 wd->resolution = WTP_MANUAL_RESOLUTION; 950 951 return 0; 952} 953 954static int wtp_allocate(struct hid_device *hdev, const struct hid_device_id *id) 955{ 956 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 957 struct wtp_data *wd; 958 959 wd = devm_kzalloc(&hdev->dev, sizeof(struct wtp_data), 960 GFP_KERNEL); 961 if (!wd) 962 return -ENOMEM; 963 964 hidpp->private_data = wd; 965 966 return 0; 967}; 968 969static int wtp_connect(struct hid_device *hdev, bool connected) 970{ 971 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 972 struct wtp_data *wd = hidpp->private_data; 973 int ret; 974 975 if (!connected) 976 return 0; 977 978 if (!wd->x_size) { 979 ret = wtp_get_config(hidpp); 980 if (ret) { 981 hid_err(hdev, "Can not get wtp config: %d\n", ret); 982 return ret; 983 } 984 } 985 986 return hidpp_touchpad_set_raw_report_state(hidpp, wd->mt_feature_index, 987 true, true); 988} 989 990/* ------------------------------------------------------------------------- */ 991/* Logitech M560 devices */ 992/* ------------------------------------------------------------------------- */ 993 994/* 995 * Logitech M560 protocol overview 996 * 997 * The Logitech M560 mouse, is designed for windows 8. When the middle and/or 998 * the sides buttons are pressed, it sends some keyboard keys events 999 * instead of buttons ones. 1000 * To complicate things further, the middle button keys sequence 1001 * is different from the odd press and the even press. 1002 * 1003 * forward button -> Super_R 1004 * backward button -> Super_L+'d' (press only) 1005 * middle button -> 1st time: Alt_L+SuperL+XF86TouchpadOff (press only) 1006 * 2nd time: left-click (press only) 1007 * NB: press-only means that when the button is pressed, the 1008 * KeyPress/ButtonPress and KeyRelease/ButtonRelease events are generated 1009 * together sequentially; instead when the button is released, no event is 1010 * generated ! 1011 * 1012 * With the command 1013 * 10<xx>0a 3500af03 (where <xx> is the mouse id), 1014 * the mouse reacts differently: 1015 * - it never sends a keyboard key event 1016 * - for the three mouse button it sends: 1017 * middle button press 11<xx>0a 3500af00... 1018 * side 1 button (forward) press 11<xx>0a 3500b000... 1019 * side 2 button (backward) press 11<xx>0a 3500ae00... 1020 * middle/side1/side2 button release 11<xx>0a 35000000... 1021 */ 1022 1023static const u8 m560_config_parameter[] = {0x00, 0xaf, 0x03}; 1024 1025struct m560_private_data { 1026 struct input_dev *input; 1027}; 1028 1029/* how buttons are mapped in the report */ 1030#define M560_MOUSE_BTN_LEFT 0x01 1031#define M560_MOUSE_BTN_RIGHT 0x02 1032#define M560_MOUSE_BTN_WHEEL_LEFT 0x08 1033#define M560_MOUSE_BTN_WHEEL_RIGHT 0x10 1034 1035#define M560_SUB_ID 0x0a 1036#define M560_BUTTON_MODE_REGISTER 0x35 1037 1038static int m560_send_config_command(struct hid_device *hdev, bool connected) 1039{ 1040 struct hidpp_report response; 1041 struct hidpp_device *hidpp_dev; 1042 1043 hidpp_dev = hid_get_drvdata(hdev); 1044 1045 if (!connected) 1046 return -ENODEV; 1047 1048 return hidpp_send_rap_command_sync( 1049 hidpp_dev, 1050 REPORT_ID_HIDPP_SHORT, 1051 M560_SUB_ID, 1052 M560_BUTTON_MODE_REGISTER, 1053 (u8 *)m560_config_parameter, 1054 sizeof(m560_config_parameter), 1055 &response 1056 ); 1057} 1058 1059static int m560_allocate(struct hid_device *hdev) 1060{ 1061 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1062 struct m560_private_data *d; 1063 1064 d = devm_kzalloc(&hdev->dev, sizeof(struct m560_private_data), 1065 GFP_KERNEL); 1066 if (!d) 1067 return -ENOMEM; 1068 1069 hidpp->private_data = d; 1070 1071 return 0; 1072}; 1073 1074static int m560_raw_event(struct hid_device *hdev, u8 *data, int size) 1075{ 1076 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1077 struct m560_private_data *mydata = hidpp->private_data; 1078 1079 /* sanity check */ 1080 if (!mydata || !mydata->input) { 1081 hid_err(hdev, "error in parameter\n"); 1082 return -EINVAL; 1083 } 1084 1085 if (size < 7) { 1086 hid_err(hdev, "error in report\n"); 1087 return 0; 1088 } 1089 1090 if (data[0] == REPORT_ID_HIDPP_LONG && 1091 data[2] == M560_SUB_ID && data[6] == 0x00) { 1092 /* 1093 * m560 mouse report for middle, forward and backward button 1094 * 1095 * data[0] = 0x11 1096 * data[1] = device-id 1097 * data[2] = 0x0a 1098 * data[5] = 0xaf -> middle 1099 * 0xb0 -> forward 1100 * 0xae -> backward 1101 * 0x00 -> release all 1102 * data[6] = 0x00 1103 */ 1104 1105 switch (data[5]) { 1106 case 0xaf: 1107 input_report_key(mydata->input, BTN_MIDDLE, 1); 1108 break; 1109 case 0xb0: 1110 input_report_key(mydata->input, BTN_FORWARD, 1); 1111 break; 1112 case 0xae: 1113 input_report_key(mydata->input, BTN_BACK, 1); 1114 break; 1115 case 0x00: 1116 input_report_key(mydata->input, BTN_BACK, 0); 1117 input_report_key(mydata->input, BTN_FORWARD, 0); 1118 input_report_key(mydata->input, BTN_MIDDLE, 0); 1119 break; 1120 default: 1121 hid_err(hdev, "error in report\n"); 1122 return 0; 1123 } 1124 input_sync(mydata->input); 1125 1126 } else if (data[0] == 0x02) { 1127 /* 1128 * Logitech M560 mouse report 1129 * 1130 * data[0] = type (0x02) 1131 * data[1..2] = buttons 1132 * data[3..5] = xy 1133 * data[6] = wheel 1134 */ 1135 1136 int v; 1137 1138 input_report_key(mydata->input, BTN_LEFT, 1139 !!(data[1] & M560_MOUSE_BTN_LEFT)); 1140 input_report_key(mydata->input, BTN_RIGHT, 1141 !!(data[1] & M560_MOUSE_BTN_RIGHT)); 1142 1143 if (data[1] & M560_MOUSE_BTN_WHEEL_LEFT) 1144 input_report_rel(mydata->input, REL_HWHEEL, -1); 1145 else if (data[1] & M560_MOUSE_BTN_WHEEL_RIGHT) 1146 input_report_rel(mydata->input, REL_HWHEEL, 1); 1147 1148 v = hid_snto32(hid_field_extract(hdev, data+3, 0, 12), 12); 1149 input_report_rel(mydata->input, REL_X, v); 1150 1151 v = hid_snto32(hid_field_extract(hdev, data+3, 12, 12), 12); 1152 input_report_rel(mydata->input, REL_Y, v); 1153 1154 v = hid_snto32(data[6], 8); 1155 input_report_rel(mydata->input, REL_WHEEL, v); 1156 1157 input_sync(mydata->input); 1158 } 1159 1160 return 1; 1161} 1162 1163static void m560_populate_input(struct hidpp_device *hidpp, 1164 struct input_dev *input_dev, bool origin_is_hid_core) 1165{ 1166 struct m560_private_data *mydata = hidpp->private_data; 1167 1168 mydata->input = input_dev; 1169 1170 __set_bit(EV_KEY, mydata->input->evbit); 1171 __set_bit(BTN_MIDDLE, mydata->input->keybit); 1172 __set_bit(BTN_RIGHT, mydata->input->keybit); 1173 __set_bit(BTN_LEFT, mydata->input->keybit); 1174 __set_bit(BTN_BACK, mydata->input->keybit); 1175 __set_bit(BTN_FORWARD, mydata->input->keybit); 1176 1177 __set_bit(EV_REL, mydata->input->evbit); 1178 __set_bit(REL_X, mydata->input->relbit); 1179 __set_bit(REL_Y, mydata->input->relbit); 1180 __set_bit(REL_WHEEL, mydata->input->relbit); 1181 __set_bit(REL_HWHEEL, mydata->input->relbit); 1182} 1183 1184static int m560_input_mapping(struct hid_device *hdev, struct hid_input *hi, 1185 struct hid_field *field, struct hid_usage *usage, 1186 unsigned long **bit, int *max) 1187{ 1188 return -1; 1189} 1190 1191/* ------------------------------------------------------------------------- */ 1192/* Logitech K400 devices */ 1193/* ------------------------------------------------------------------------- */ 1194 1195/* 1196 * The Logitech K400 keyboard has an embedded touchpad which is seen 1197 * as a mouse from the OS point of view. There is a hardware shortcut to disable 1198 * tap-to-click but the setting is not remembered accross reset, annoying some 1199 * users. 1200 * 1201 * We can toggle this feature from the host by using the feature 0x6010: 1202 * Touchpad FW items 1203 */ 1204 1205struct k400_private_data { 1206 u8 feature_index; 1207}; 1208 1209static int k400_disable_tap_to_click(struct hidpp_device *hidpp) 1210{ 1211 struct k400_private_data *k400 = hidpp->private_data; 1212 struct hidpp_touchpad_fw_items items = {}; 1213 int ret; 1214 u8 feature_type; 1215 1216 if (!k400->feature_index) { 1217 ret = hidpp_root_get_feature(hidpp, 1218 HIDPP_PAGE_TOUCHPAD_FW_ITEMS, 1219 &k400->feature_index, &feature_type); 1220 if (ret) 1221 /* means that the device is not powered up */ 1222 return ret; 1223 } 1224 1225 ret = hidpp_touchpad_fw_items_set(hidpp, k400->feature_index, &items); 1226 if (ret) 1227 return ret; 1228 1229 return 0; 1230} 1231 1232static int k400_allocate(struct hid_device *hdev) 1233{ 1234 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1235 struct k400_private_data *k400; 1236 1237 k400 = devm_kzalloc(&hdev->dev, sizeof(struct k400_private_data), 1238 GFP_KERNEL); 1239 if (!k400) 1240 return -ENOMEM; 1241 1242 hidpp->private_data = k400; 1243 1244 return 0; 1245}; 1246 1247static int k400_connect(struct hid_device *hdev, bool connected) 1248{ 1249 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1250 1251 if (!connected) 1252 return 0; 1253 1254 if (!disable_tap_to_click) 1255 return 0; 1256 1257 return k400_disable_tap_to_click(hidpp); 1258} 1259 1260/* -------------------------------------------------------------------------- */ 1261/* Generic HID++ devices */ 1262/* -------------------------------------------------------------------------- */ 1263 1264static int hidpp_input_mapping(struct hid_device *hdev, struct hid_input *hi, 1265 struct hid_field *field, struct hid_usage *usage, 1266 unsigned long **bit, int *max) 1267{ 1268 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1269 1270 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) 1271 return wtp_input_mapping(hdev, hi, field, usage, bit, max); 1272 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560 && 1273 field->application != HID_GD_MOUSE) 1274 return m560_input_mapping(hdev, hi, field, usage, bit, max); 1275 1276 return 0; 1277} 1278 1279static void hidpp_populate_input(struct hidpp_device *hidpp, 1280 struct input_dev *input, bool origin_is_hid_core) 1281{ 1282 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) 1283 wtp_populate_input(hidpp, input, origin_is_hid_core); 1284 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) 1285 m560_populate_input(hidpp, input, origin_is_hid_core); 1286} 1287 1288static int hidpp_input_configured(struct hid_device *hdev, 1289 struct hid_input *hidinput) 1290{ 1291 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1292 struct input_dev *input = hidinput->input; 1293 1294 hidpp_populate_input(hidpp, input, true); 1295 1296 return 0; 1297} 1298 1299static int hidpp_raw_hidpp_event(struct hidpp_device *hidpp, u8 *data, 1300 int size) 1301{ 1302 struct hidpp_report *question = hidpp->send_receive_buf; 1303 struct hidpp_report *answer = hidpp->send_receive_buf; 1304 struct hidpp_report *report = (struct hidpp_report *)data; 1305 1306 /* 1307 * If the mutex is locked then we have a pending answer from a 1308 * previously sent command. 1309 */ 1310 if (unlikely(mutex_is_locked(&hidpp->send_mutex))) { 1311 /* 1312 * Check for a correct hidpp20 answer or the corresponding 1313 * error 1314 */ 1315 if (hidpp_match_answer(question, report) || 1316 hidpp_match_error(question, report)) { 1317 *answer = *report; 1318 hidpp->answer_available = true; 1319 wake_up(&hidpp->wait); 1320 /* 1321 * This was an answer to a command that this driver sent 1322 * We return 1 to hid-core to avoid forwarding the 1323 * command upstream as it has been treated by the driver 1324 */ 1325 1326 return 1; 1327 } 1328 } 1329 1330 if (unlikely(hidpp_report_is_connect_event(report))) { 1331 atomic_set(&hidpp->connected, 1332 !(report->rap.params[0] & (1 << 6))); 1333 if ((hidpp->quirks & HIDPP_QUIRK_CONNECT_EVENTS) && 1334 (schedule_work(&hidpp->work) == 0)) 1335 dbg_hid("%s: connect event already queued\n", __func__); 1336 return 1; 1337 } 1338 1339 return 0; 1340} 1341 1342static int hidpp_raw_event(struct hid_device *hdev, struct hid_report *report, 1343 u8 *data, int size) 1344{ 1345 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1346 int ret = 0; 1347 1348 /* Generic HID++ processing. */ 1349 switch (data[0]) { 1350 case REPORT_ID_HIDPP_LONG: 1351 if (size != HIDPP_REPORT_LONG_LENGTH) { 1352 hid_err(hdev, "received hid++ report of bad size (%d)", 1353 size); 1354 return 1; 1355 } 1356 ret = hidpp_raw_hidpp_event(hidpp, data, size); 1357 break; 1358 case REPORT_ID_HIDPP_SHORT: 1359 if (size != HIDPP_REPORT_SHORT_LENGTH) { 1360 hid_err(hdev, "received hid++ report of bad size (%d)", 1361 size); 1362 return 1; 1363 } 1364 ret = hidpp_raw_hidpp_event(hidpp, data, size); 1365 break; 1366 } 1367 1368 /* If no report is available for further processing, skip calling 1369 * raw_event of subclasses. */ 1370 if (ret != 0) 1371 return ret; 1372 1373 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) 1374 return wtp_raw_event(hdev, data, size); 1375 else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) 1376 return m560_raw_event(hdev, data, size); 1377 1378 return 0; 1379} 1380 1381static void hidpp_overwrite_name(struct hid_device *hdev, bool use_unifying) 1382{ 1383 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1384 char *name; 1385 1386 if (use_unifying) 1387 /* 1388 * the device is connected through an Unifying receiver, and 1389 * might not be already connected. 1390 * Ask the receiver for its name. 1391 */ 1392 name = hidpp_get_unifying_name(hidpp); 1393 else 1394 name = hidpp_get_device_name(hidpp); 1395 1396 if (!name) 1397 hid_err(hdev, "unable to retrieve the name of the device"); 1398 else 1399 snprintf(hdev->name, sizeof(hdev->name), "%s", name); 1400 1401 kfree(name); 1402} 1403 1404static int hidpp_input_open(struct input_dev *dev) 1405{ 1406 struct hid_device *hid = input_get_drvdata(dev); 1407 1408 return hid_hw_open(hid); 1409} 1410 1411static void hidpp_input_close(struct input_dev *dev) 1412{ 1413 struct hid_device *hid = input_get_drvdata(dev); 1414 1415 hid_hw_close(hid); 1416} 1417 1418static struct input_dev *hidpp_allocate_input(struct hid_device *hdev) 1419{ 1420 struct input_dev *input_dev = devm_input_allocate_device(&hdev->dev); 1421 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1422 1423 if (!input_dev) 1424 return NULL; 1425 1426 input_set_drvdata(input_dev, hdev); 1427 input_dev->open = hidpp_input_open; 1428 input_dev->close = hidpp_input_close; 1429 1430 input_dev->name = hidpp->name; 1431 input_dev->phys = hdev->phys; 1432 input_dev->uniq = hdev->uniq; 1433 input_dev->id.bustype = hdev->bus; 1434 input_dev->id.vendor = hdev->vendor; 1435 input_dev->id.product = hdev->product; 1436 input_dev->id.version = hdev->version; 1437 input_dev->dev.parent = &hdev->dev; 1438 1439 return input_dev; 1440} 1441 1442static void hidpp_connect_event(struct hidpp_device *hidpp) 1443{ 1444 struct hid_device *hdev = hidpp->hid_dev; 1445 int ret = 0; 1446 bool connected = atomic_read(&hidpp->connected); 1447 struct input_dev *input; 1448 char *name, *devm_name; 1449 1450 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) { 1451 ret = wtp_connect(hdev, connected); 1452 if (ret) 1453 return; 1454 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) { 1455 ret = m560_send_config_command(hdev, connected); 1456 if (ret) 1457 return; 1458 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) { 1459 ret = k400_connect(hdev, connected); 1460 if (ret) 1461 return; 1462 } 1463 1464 if (!connected || hidpp->delayed_input) 1465 return; 1466 1467 /* the device is already connected, we can ask for its name and 1468 * protocol */ 1469 if (!hidpp->protocol_major) { 1470 ret = !hidpp_is_connected(hidpp); 1471 if (ret) { 1472 hid_err(hdev, "Can not get the protocol version.\n"); 1473 return; 1474 } 1475 hid_info(hdev, "HID++ %u.%u device connected.\n", 1476 hidpp->protocol_major, hidpp->protocol_minor); 1477 } 1478 1479 if (!(hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT)) 1480 /* if HID created the input nodes for us, we can stop now */ 1481 return; 1482 1483 if (!hidpp->name || hidpp->name == hdev->name) { 1484 name = hidpp_get_device_name(hidpp); 1485 if (!name) { 1486 hid_err(hdev, 1487 "unable to retrieve the name of the device"); 1488 return; 1489 } 1490 1491 devm_name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "%s", name); 1492 kfree(name); 1493 if (!devm_name) 1494 return; 1495 1496 hidpp->name = devm_name; 1497 } 1498 1499 input = hidpp_allocate_input(hdev); 1500 if (!input) { 1501 hid_err(hdev, "cannot allocate new input device: %d\n", ret); 1502 return; 1503 } 1504 1505 hidpp_populate_input(hidpp, input, false); 1506 1507 ret = input_register_device(input); 1508 if (ret) 1509 input_free_device(input); 1510 1511 hidpp->delayed_input = input; 1512} 1513 1514static int hidpp_probe(struct hid_device *hdev, const struct hid_device_id *id) 1515{ 1516 struct hidpp_device *hidpp; 1517 int ret; 1518 bool connected; 1519 unsigned int connect_mask = HID_CONNECT_DEFAULT; 1520 1521 hidpp = devm_kzalloc(&hdev->dev, sizeof(struct hidpp_device), 1522 GFP_KERNEL); 1523 if (!hidpp) 1524 return -ENOMEM; 1525 1526 hidpp->hid_dev = hdev; 1527 hidpp->name = hdev->name; 1528 hid_set_drvdata(hdev, hidpp); 1529 1530 hidpp->quirks = id->driver_data; 1531 1532 if (disable_raw_mode) { 1533 hidpp->quirks &= ~HIDPP_QUIRK_CLASS_WTP; 1534 hidpp->quirks &= ~HIDPP_QUIRK_CONNECT_EVENTS; 1535 hidpp->quirks &= ~HIDPP_QUIRK_NO_HIDINPUT; 1536 } 1537 1538 if (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP) { 1539 ret = wtp_allocate(hdev, id); 1540 if (ret) 1541 goto allocate_fail; 1542 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_M560) { 1543 ret = m560_allocate(hdev); 1544 if (ret) 1545 goto allocate_fail; 1546 } else if (hidpp->quirks & HIDPP_QUIRK_CLASS_K400) { 1547 ret = k400_allocate(hdev); 1548 if (ret) 1549 goto allocate_fail; 1550 } 1551 1552 INIT_WORK(&hidpp->work, delayed_work_cb); 1553 mutex_init(&hidpp->send_mutex); 1554 init_waitqueue_head(&hidpp->wait); 1555 1556 ret = hid_parse(hdev); 1557 if (ret) { 1558 hid_err(hdev, "%s:parse failed\n", __func__); 1559 goto hid_parse_fail; 1560 } 1561 1562 /* Allow incoming packets */ 1563 hid_device_io_start(hdev); 1564 1565 connected = hidpp_is_connected(hidpp); 1566 if (id->group != HID_GROUP_LOGITECH_DJ_DEVICE) { 1567 if (!connected) { 1568 ret = -ENODEV; 1569 hid_err(hdev, "Device not connected"); 1570 hid_device_io_stop(hdev); 1571 goto hid_parse_fail; 1572 } 1573 1574 hid_info(hdev, "HID++ %u.%u device connected.\n", 1575 hidpp->protocol_major, hidpp->protocol_minor); 1576 } 1577 1578 hidpp_overwrite_name(hdev, id->group == HID_GROUP_LOGITECH_DJ_DEVICE); 1579 atomic_set(&hidpp->connected, connected); 1580 1581 if (connected && (hidpp->quirks & HIDPP_QUIRK_CLASS_WTP)) { 1582 ret = wtp_get_config(hidpp); 1583 if (ret) 1584 goto hid_parse_fail; 1585 } 1586 1587 /* Block incoming packets */ 1588 hid_device_io_stop(hdev); 1589 1590 if (hidpp->quirks & HIDPP_QUIRK_NO_HIDINPUT) 1591 connect_mask &= ~HID_CONNECT_HIDINPUT; 1592 1593 ret = hid_hw_start(hdev, connect_mask); 1594 if (ret) { 1595 hid_err(hdev, "%s:hid_hw_start returned error\n", __func__); 1596 goto hid_hw_start_fail; 1597 } 1598 1599 if (hidpp->quirks & HIDPP_QUIRK_CONNECT_EVENTS) { 1600 /* Allow incoming packets */ 1601 hid_device_io_start(hdev); 1602 1603 hidpp_connect_event(hidpp); 1604 } 1605 1606 return ret; 1607 1608hid_hw_start_fail: 1609hid_parse_fail: 1610 cancel_work_sync(&hidpp->work); 1611 mutex_destroy(&hidpp->send_mutex); 1612allocate_fail: 1613 hid_set_drvdata(hdev, NULL); 1614 return ret; 1615} 1616 1617static void hidpp_remove(struct hid_device *hdev) 1618{ 1619 struct hidpp_device *hidpp = hid_get_drvdata(hdev); 1620 1621 cancel_work_sync(&hidpp->work); 1622 mutex_destroy(&hidpp->send_mutex); 1623 hid_hw_stop(hdev); 1624} 1625 1626static const struct hid_device_id hidpp_devices[] = { 1627 { /* wireless touchpad */ 1628 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, 1629 USB_VENDOR_ID_LOGITECH, 0x4011), 1630 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT | 1631 HIDPP_QUIRK_WTP_PHYSICAL_BUTTONS }, 1632 { /* wireless touchpad T650 */ 1633 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, 1634 USB_VENDOR_ID_LOGITECH, 0x4101), 1635 .driver_data = HIDPP_QUIRK_CLASS_WTP | HIDPP_QUIRK_DELAYED_INIT }, 1636 { /* wireless touchpad T651 */ 1637 HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_LOGITECH, 1638 USB_DEVICE_ID_LOGITECH_T651), 1639 .driver_data = HIDPP_QUIRK_CLASS_WTP }, 1640 { /* Mouse logitech M560 */ 1641 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, 1642 USB_VENDOR_ID_LOGITECH, 0x402d), 1643 .driver_data = HIDPP_QUIRK_DELAYED_INIT | HIDPP_QUIRK_CLASS_M560 }, 1644 { /* Keyboard logitech K400 */ 1645 HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, 1646 USB_VENDOR_ID_LOGITECH, 0x4024), 1647 .driver_data = HIDPP_QUIRK_CONNECT_EVENTS | HIDPP_QUIRK_CLASS_K400 }, 1648 1649 { HID_DEVICE(BUS_USB, HID_GROUP_LOGITECH_DJ_DEVICE, 1650 USB_VENDOR_ID_LOGITECH, HID_ANY_ID)}, 1651 {} 1652}; 1653 1654MODULE_DEVICE_TABLE(hid, hidpp_devices); 1655 1656static struct hid_driver hidpp_driver = { 1657 .name = "logitech-hidpp-device", 1658 .id_table = hidpp_devices, 1659 .probe = hidpp_probe, 1660 .remove = hidpp_remove, 1661 .raw_event = hidpp_raw_event, 1662 .input_configured = hidpp_input_configured, 1663 .input_mapping = hidpp_input_mapping, 1664}; 1665 1666module_hid_driver(hidpp_driver); 1667