1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * HID driver for Asus notebook built-in keyboard. 4 * Fixes small logical maximum to match usage maximum. 5 * 6 * Currently supported devices are: 7 * EeeBook X205TA 8 * VivoBook E200HA 9 * 10 * Copyright (c) 2016 Yusuke Fujimaki <usk.fujimaki@gmail.com> 11 * 12 * This module based on hid-ortek by 13 * Copyright (c) 2010 Johnathon Harris <jmharris@gmail.com> 14 * Copyright (c) 2011 Jiri Kosina 15 * 16 * This module has been updated to add support for Asus i2c touchpad. 17 * 18 * Copyright (c) 2016 Brendan McGrath <redmcg@redmandi.dyndns.org> 19 * Copyright (c) 2016 Victor Vlasenko <victor.vlasenko@sysgears.com> 20 * Copyright (c) 2016 Frederik Wenigwieser <frederik.wenigwieser@gmail.com> 21 */ 22 23 #include <linux/acpi.h> 24 #include <linux/cleanup.h> 25 #include <linux/dmi.h> 26 #include <linux/hid.h> 27 #include <linux/module.h> 28 #include <linux/platform_data/x86/asus-wmi.h> 29 #include <linux/input/mt.h> 30 #include <linux/usb.h> /* For to_usb_interface for T100 touchpad intf check */ 31 #include <linux/power_supply.h> 32 #include <linux/leds.h> 33 34 #include "hid-ids.h" 35 36 MODULE_AUTHOR("Yusuke Fujimaki <usk.fujimaki@gmail.com>"); 37 MODULE_AUTHOR("Brendan McGrath <redmcg@redmandi.dyndns.org>"); 38 MODULE_AUTHOR("Victor Vlasenko <victor.vlasenko@sysgears.com>"); 39 MODULE_AUTHOR("Frederik Wenigwieser <frederik.wenigwieser@gmail.com>"); 40 MODULE_DESCRIPTION("Asus HID Keyboard and TouchPad"); 41 42 #define T100_TPAD_INTF 2 43 #define MEDION_E1239T_TPAD_INTF 1 44 45 #define E1239T_TP_TOGGLE_REPORT_ID 0x05 46 #define T100CHI_MOUSE_REPORT_ID 0x06 47 #define FEATURE_REPORT_ID 0x0d 48 #define INPUT_REPORT_ID 0x5d 49 #define FEATURE_KBD_REPORT_ID 0x5a 50 #define FEATURE_KBD_REPORT_SIZE 64 51 #define FEATURE_KBD_LED_REPORT_ID1 0x5d 52 #define FEATURE_KBD_LED_REPORT_ID2 0x5e 53 54 #define ROG_XGM_REPORT_SIZE 300 55 56 #define ROG_ALLY_REPORT_SIZE 64 57 #define ROG_ALLY_X_MIN_MCU 313 58 #define ROG_ALLY_MIN_MCU 319 59 60 /* Spurious HID codes sent by QUIRK_ROG_NKEY_KEYBOARD devices */ 61 #define ASUS_SPURIOUS_CODE_0XEA 0xea 62 #define ASUS_SPURIOUS_CODE_0XEC 0xec 63 #define ASUS_SPURIOUS_CODE_0X02 0x02 64 #define ASUS_SPURIOUS_CODE_0X8A 0x8a 65 #define ASUS_SPURIOUS_CODE_0X9E 0x9e 66 67 /* Special key codes */ 68 #define ASUS_FAN_CTRL_KEY_CODE 0xae 69 70 #define SUPPORT_KBD_BACKLIGHT BIT(0) 71 72 #define MAX_TOUCH_MAJOR 8 73 #define MAX_PRESSURE 128 74 75 #define BTN_LEFT_MASK 0x01 76 #define CONTACT_TOOL_TYPE_MASK 0x80 77 #define CONTACT_X_MSB_MASK 0xf0 78 #define CONTACT_Y_MSB_MASK 0x0f 79 #define CONTACT_TOUCH_MAJOR_MASK 0x07 80 #define CONTACT_PRESSURE_MASK 0x7f 81 82 #define BATTERY_REPORT_ID (0x03) 83 #define BATTERY_REPORT_SIZE (1 + 8) 84 #define BATTERY_LEVEL_MAX ((u8)255) 85 #define BATTERY_STAT_DISCONNECT (0) 86 #define BATTERY_STAT_CHARGING (1) 87 #define BATTERY_STAT_FULL (2) 88 89 #define QUIRK_FIX_NOTEBOOK_REPORT BIT(0) 90 #define QUIRK_NO_INIT_REPORTS BIT(1) 91 #define QUIRK_SKIP_INPUT_MAPPING BIT(2) 92 #define QUIRK_IS_MULTITOUCH BIT(3) 93 #define QUIRK_NO_CONSUMER_USAGES BIT(4) 94 #define QUIRK_USE_KBD_BACKLIGHT BIT(5) 95 #define QUIRK_T100_KEYBOARD BIT(6) 96 #define QUIRK_T100CHI BIT(7) 97 #define QUIRK_G752_KEYBOARD BIT(8) 98 #define QUIRK_T90CHI BIT(9) 99 #define QUIRK_MEDION_E1239T BIT(10) 100 #define QUIRK_ROG_NKEY_KEYBOARD BIT(11) 101 #define QUIRK_ROG_CLAYMORE_II_KEYBOARD BIT(12) 102 #define QUIRK_ROG_ALLY_XPAD BIT(13) 103 #define QUIRK_HID_FN_LOCK BIT(14) 104 #define QUIRK_FILTER_CAMERA_COMPANION BIT(15) 105 106 #define I2C_KEYBOARD_QUIRKS (QUIRK_FIX_NOTEBOOK_REPORT | \ 107 QUIRK_NO_INIT_REPORTS | \ 108 QUIRK_NO_CONSUMER_USAGES) 109 #define I2C_TOUCHPAD_QUIRKS (QUIRK_NO_INIT_REPORTS | \ 110 QUIRK_SKIP_INPUT_MAPPING | \ 111 QUIRK_IS_MULTITOUCH) 112 113 #define TRKID_SGN ((TRKID_MAX + 1) >> 1) 114 115 enum asus_work_action_type { 116 FN_LOCK_SYNC, 117 BRIGHTNESS_SET, 118 WMI_FAN, 119 }; 120 121 struct hid_raw_event_data { 122 u8 report_data[FEATURE_KBD_REPORT_SIZE]; 123 size_t report_size; 124 }; 125 126 struct asus_work_action { 127 struct list_head node; 128 enum asus_work_action_type type; 129 union { 130 /* Data for BRIGHTNESS_SET */ 131 unsigned int brightness; 132 133 /* Data for FN_LOCK_SYNC */ 134 bool fn_lock; 135 136 /* Data for WMI_FAN */ 137 struct hid_raw_event_data fan_hid_data; 138 } data; 139 }; 140 141 struct asus_worker { 142 struct hid_device *hdev; 143 struct work_struct work; 144 struct list_head actions; 145 spinlock_t lock; 146 bool removed; 147 }; 148 149 struct asus_xgm_led { 150 struct led_classdev cdev; 151 struct hid_device *hdev; 152 }; 153 154 struct asus_touchpad_info { 155 int max_x; 156 int max_y; 157 int res_x; 158 int res_y; 159 int contact_size; 160 int max_contacts; 161 int report_size; 162 }; 163 164 struct asus_drvdata { 165 unsigned long quirks; 166 struct hid_device *hdev; 167 struct input_dev *input; 168 struct input_dev *tp_kbd_input; 169 struct asus_worker *worker; 170 unsigned int kbd_backlight_brightness; 171 const struct asus_touchpad_info *tp; 172 struct power_supply *battery; 173 struct power_supply_desc battery_desc; 174 int battery_capacity; 175 int battery_stat; 176 bool battery_in_query; 177 unsigned long battery_next_query; 178 struct asus_hid_listener listener; 179 bool fn_lock; 180 struct asus_xgm_led *xgm_led; 181 }; 182 183 static int asus_report_battery(struct asus_drvdata *, u8 *, int); 184 185 static const struct asus_touchpad_info asus_i2c_tp = { 186 .max_x = 2794, 187 .max_y = 1758, 188 .contact_size = 5, 189 .max_contacts = 5, 190 .report_size = 28 /* 2 byte header + 5 * 5 + 1 byte footer */, 191 }; 192 193 static const struct asus_touchpad_info asus_t100ta_tp = { 194 .max_x = 2240, 195 .max_y = 1120, 196 .res_x = 30, /* units/mm */ 197 .res_y = 27, /* units/mm */ 198 .contact_size = 5, 199 .max_contacts = 5, 200 .report_size = 28 /* 2 byte header + 5 * 5 + 1 byte footer */, 201 }; 202 203 static const struct asus_touchpad_info asus_t100ha_tp = { 204 .max_x = 2640, 205 .max_y = 1320, 206 .res_x = 30, /* units/mm */ 207 .res_y = 29, /* units/mm */ 208 .contact_size = 5, 209 .max_contacts = 5, 210 .report_size = 28 /* 2 byte header + 5 * 5 + 1 byte footer */, 211 }; 212 213 static const struct asus_touchpad_info asus_t200ta_tp = { 214 .max_x = 3120, 215 .max_y = 1716, 216 .res_x = 30, /* units/mm */ 217 .res_y = 28, /* units/mm */ 218 .contact_size = 5, 219 .max_contacts = 5, 220 .report_size = 28 /* 2 byte header + 5 * 5 + 1 byte footer */, 221 }; 222 223 static const struct asus_touchpad_info asus_t100chi_tp = { 224 .max_x = 2640, 225 .max_y = 1320, 226 .res_x = 31, /* units/mm */ 227 .res_y = 29, /* units/mm */ 228 .contact_size = 3, 229 .max_contacts = 4, 230 .report_size = 15 /* 2 byte header + 3 * 4 + 1 byte footer */, 231 }; 232 233 static const struct asus_touchpad_info medion_e1239t_tp = { 234 .max_x = 2640, 235 .max_y = 1380, 236 .res_x = 29, /* units/mm */ 237 .res_y = 28, /* units/mm */ 238 .contact_size = 5, 239 .max_contacts = 5, 240 .report_size = 32 /* 2 byte header + 5 * 5 + 5 byte footer */, 241 }; 242 243 static const u8 asus_report_id_init[] = { 244 FEATURE_KBD_REPORT_ID, 245 FEATURE_KBD_LED_REPORT_ID1, 246 FEATURE_KBD_LED_REPORT_ID2 247 }; 248 249 /* 250 * Send events to asus-wmi driver for handling special keys 251 */ 252 static int asus_wmi_send_event(struct asus_drvdata *drvdata, u8 code) 253 { 254 int err; 255 u32 retval; 256 257 err = asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, 258 ASUS_WMI_METHODID_NOTIF, code, &retval); 259 if (err) { 260 pr_warn("Failed to notify asus-wmi: %d\n", err); 261 return err; 262 } 263 264 if (retval != 0) { 265 pr_warn("Failed to notify asus-wmi (retval): 0x%x\n", retval); 266 return -EIO; 267 } 268 269 return 0; 270 } 271 272 static void asus_report_contact_down(struct asus_drvdata *drvdat, 273 int toolType, u8 *data) 274 { 275 struct input_dev *input = drvdat->input; 276 int touch_major, pressure, x, y; 277 278 x = (data[0] & CONTACT_X_MSB_MASK) << 4 | data[1]; 279 y = drvdat->tp->max_y - ((data[0] & CONTACT_Y_MSB_MASK) << 8 | data[2]); 280 281 input_report_abs(input, ABS_MT_POSITION_X, x); 282 input_report_abs(input, ABS_MT_POSITION_Y, y); 283 284 if (drvdat->tp->contact_size < 5) 285 return; 286 287 if (toolType == MT_TOOL_PALM) { 288 touch_major = MAX_TOUCH_MAJOR; 289 pressure = MAX_PRESSURE; 290 } else { 291 touch_major = (data[3] >> 4) & CONTACT_TOUCH_MAJOR_MASK; 292 pressure = data[4] & CONTACT_PRESSURE_MASK; 293 } 294 295 input_report_abs(input, ABS_MT_TOUCH_MAJOR, touch_major); 296 input_report_abs(input, ABS_MT_PRESSURE, pressure); 297 } 298 299 /* Required for Synaptics Palm Detection */ 300 static void asus_report_tool_width(struct asus_drvdata *drvdat) 301 { 302 struct input_mt *mt = drvdat->input->mt; 303 struct input_mt_slot *oldest; 304 int oldid, i; 305 306 if (drvdat->tp->contact_size < 5) 307 return; 308 309 oldest = NULL; 310 oldid = mt->trkid; 311 312 for (i = 0; i < mt->num_slots; ++i) { 313 struct input_mt_slot *ps = &mt->slots[i]; 314 int id = input_mt_get_value(ps, ABS_MT_TRACKING_ID); 315 316 if (id < 0) 317 continue; 318 if ((id - oldid) & TRKID_SGN) { 319 oldest = ps; 320 oldid = id; 321 } 322 } 323 324 if (oldest) { 325 input_report_abs(drvdat->input, ABS_TOOL_WIDTH, 326 input_mt_get_value(oldest, ABS_MT_TOUCH_MAJOR)); 327 } 328 } 329 330 static int asus_report_input(struct asus_drvdata *drvdat, u8 *data, int size) 331 { 332 int i, toolType = MT_TOOL_FINGER; 333 u8 *contactData = data + 2; 334 335 if (size != drvdat->tp->report_size) 336 return 0; 337 338 for (i = 0; i < drvdat->tp->max_contacts; i++) { 339 bool down = !!(data[1] & BIT(i+3)); 340 341 if (drvdat->tp->contact_size >= 5) 342 toolType = contactData[3] & CONTACT_TOOL_TYPE_MASK ? 343 MT_TOOL_PALM : MT_TOOL_FINGER; 344 345 input_mt_slot(drvdat->input, i); 346 input_mt_report_slot_state(drvdat->input, toolType, down); 347 348 if (down) { 349 asus_report_contact_down(drvdat, toolType, contactData); 350 contactData += drvdat->tp->contact_size; 351 } 352 } 353 354 input_report_key(drvdat->input, BTN_LEFT, data[1] & BTN_LEFT_MASK); 355 asus_report_tool_width(drvdat); 356 357 input_mt_sync_frame(drvdat->input); 358 input_sync(drvdat->input); 359 360 return 1; 361 } 362 363 static int asus_e1239t_event(struct asus_drvdata *drvdat, u8 *data, int size) 364 { 365 if (size != 3) 366 return 0; 367 368 /* Handle broken mute key which only sends press events */ 369 if (!drvdat->tp && 370 data[0] == 0x02 && data[1] == 0xe2 && data[2] == 0x00) { 371 input_report_key(drvdat->input, KEY_MUTE, 1); 372 input_sync(drvdat->input); 373 input_report_key(drvdat->input, KEY_MUTE, 0); 374 input_sync(drvdat->input); 375 return 1; 376 } 377 378 /* Handle custom touchpad toggle key which only sends press events */ 379 if (drvdat->tp_kbd_input && 380 data[0] == 0x05 && data[1] == 0x02 && data[2] == 0x28) { 381 input_report_key(drvdat->tp_kbd_input, KEY_F21, 1); 382 input_sync(drvdat->tp_kbd_input); 383 input_report_key(drvdat->tp_kbd_input, KEY_F21, 0); 384 input_sync(drvdat->tp_kbd_input); 385 return 1; 386 } 387 388 return 0; 389 } 390 391 /* 392 * Used in atomic contexts to schedule work involving sleeps operations or 393 * asus-wmi interactions. 394 * 395 * Caller is responsible to store relevant data in the structure to carry out 396 * the required action. 397 * 398 * This function must be called while the spin lock protecting the workqueue 399 * is already being held. 400 */ 401 static void asus_worker_schedule(struct asus_worker *worker, struct asus_work_action *action) 402 { 403 if (worker->removed) { 404 kfree(action); 405 return; 406 } 407 408 list_add_tail(&action->node, &worker->actions); 409 schedule_work(&worker->work); 410 } 411 412 static int asus_kbd_fn_lock_set(struct asus_drvdata *drvdata, bool enabled) 413 { 414 struct asus_work_action *action; 415 unsigned long flags; 416 417 action = kzalloc_obj(struct asus_work_action, GFP_ATOMIC); 418 if (!action) 419 return -ENOMEM; 420 421 drvdata->fn_lock = enabled; 422 action->type = FN_LOCK_SYNC; 423 action->data.fn_lock = drvdata->fn_lock; 424 INIT_LIST_HEAD(&action->node); 425 426 spin_lock_irqsave(&drvdata->worker->lock, flags); 427 asus_worker_schedule(drvdata->worker, action); 428 spin_unlock_irqrestore(&drvdata->worker->lock, flags); 429 430 return 0; 431 } 432 433 static int asus_kbd_wmi_fan_send(struct asus_drvdata *drvdata, u8 *report_data, 434 size_t report_size) 435 { 436 struct asus_work_action *action; 437 unsigned long flags; 438 439 if (report_size > FEATURE_KBD_REPORT_SIZE) { 440 hid_err(drvdata->hdev, "Invalid report size for fan event: %zu\n", report_size); 441 return -EINVAL; 442 } 443 444 action = kzalloc_obj(struct asus_work_action, GFP_NOWAIT); 445 if (!action) 446 return -ENOMEM; 447 448 action->type = WMI_FAN; 449 action->data.fan_hid_data.report_size = report_size; 450 memcpy(action->data.fan_hid_data.report_data, report_data, report_size); 451 INIT_LIST_HEAD(&action->node); 452 453 spin_lock_irqsave(&drvdata->worker->lock, flags); 454 asus_worker_schedule(drvdata->worker, action); 455 spin_unlock_irqrestore(&drvdata->worker->lock, flags); 456 457 return 0; 458 } 459 460 static int asus_event(struct hid_device *hdev, struct hid_field *field, 461 struct hid_usage *usage, __s32 value) 462 { 463 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 464 int ret; 465 466 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_ASUSVENDOR && 467 (usage->hid & HID_USAGE) != 0x00 && 468 (usage->hid & HID_USAGE) != 0xff && !usage->type) { 469 hid_warn(hdev, "Unmapped Asus vendor usagepage code 0x%02x\n", 470 usage->hid & HID_USAGE); 471 } 472 473 if (usage->type == EV_KEY && value) { 474 switch (usage->code) { 475 case KEY_KBDILLUMUP: 476 return !asus_hid_event(ASUS_EV_BRTUP); 477 case KEY_KBDILLUMDOWN: 478 return !asus_hid_event(ASUS_EV_BRTDOWN); 479 case KEY_KBDILLUMTOGGLE: 480 return !asus_hid_event(ASUS_EV_BRTTOGGLE); 481 case KEY_FN_ESC: 482 if (drvdata->quirks & QUIRK_HID_FN_LOCK) { 483 ret = asus_kbd_fn_lock_set(drvdata, !drvdata->fn_lock); 484 if (ret) { 485 hid_err(hdev, "Error while toggling FN lock: %d\n", ret); 486 return ret; 487 } 488 } 489 break; 490 } 491 } 492 493 return 0; 494 } 495 496 static int asus_raw_event(struct hid_device *hdev, 497 struct hid_report *report, u8 *data, int size) 498 { 499 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 500 int ret; 501 502 if (size < 2) { 503 hid_dbg(hdev, "Unexpected keyboard report size %d\n", size); 504 return 0; 505 } 506 507 if (drvdata->battery && data[0] == BATTERY_REPORT_ID) 508 return asus_report_battery(drvdata, data, size); 509 510 if (drvdata->tp && data[0] == INPUT_REPORT_ID) 511 return asus_report_input(drvdata, data, size); 512 513 if (drvdata->quirks & QUIRK_MEDION_E1239T) 514 return asus_e1239t_event(drvdata, data, size); 515 516 /* 517 * Skip these report ID, the device emits a continuous stream associated 518 * with the AURA mode it is in which looks like an 'echo'. 519 */ 520 if (report->id == FEATURE_KBD_LED_REPORT_ID1 || report->id == FEATURE_KBD_LED_REPORT_ID2) 521 return -1; 522 if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) { 523 if (report->id == FEATURE_KBD_REPORT_ID) { 524 /* 525 * Fn+F5 fan control key - try to send WMI event to toggle fan mode. 526 * If successful, block the event from reaching userspace. 527 * If asus-wmi is unavailable or the call fails, let the event 528 * pass to userspace so it can implement its own fan control. 529 */ 530 if (data[1] == ASUS_FAN_CTRL_KEY_CODE) { 531 ret = asus_kbd_wmi_fan_send(drvdata, data, size); 532 533 /* if execution deferred successfully block event */ 534 if (ret == 0) 535 return -1; 536 537 return ret; 538 } 539 540 /* 541 * ASUS ROG laptops send these codes during normal operation 542 * with no discernable reason. Filter them out to avoid 543 * unmapped warning messages. 544 */ 545 if (data[1] == ASUS_SPURIOUS_CODE_0XEA || 546 data[1] == ASUS_SPURIOUS_CODE_0XEC || 547 data[1] == ASUS_SPURIOUS_CODE_0X02 || 548 data[1] == ASUS_SPURIOUS_CODE_0X8A || 549 data[1] == ASUS_SPURIOUS_CODE_0X9E) { 550 return -1; 551 } 552 } 553 554 /* 555 * G713 and G733 send these codes on some keypresses, depending on 556 * the key pressed it can trigger a shutdown event if not caught. 557 */ 558 if (data[0] == 0x02 && data[1] == 0x30) 559 return -1; 560 } 561 562 if (drvdata->quirks & QUIRK_ROG_CLAYMORE_II_KEYBOARD) { 563 /* 564 * CLAYMORE II keyboard sends this packet when it goes to sleep 565 * this causes the whole system to go into suspend. 566 */ 567 if (size == 2 && data[0] == 0x02 && data[1] == 0x00) 568 return -1; 569 } 570 571 /* 572 * The camera-toggle key reports its vendor usage (0x85) together with a 573 * companion state byte in the same array report, e.g. "5a 85 01" and 574 * "5a 85 10" for the two toggle positions. The 0x10 companion aliases the 575 * brightness-down vendor usage and would spuriously dim the panel, so drop 576 * the companion slots and leave only the camera usage for input mapping. 577 */ 578 if (drvdata->quirks & QUIRK_FILTER_CAMERA_COMPANION && 579 report->id == FEATURE_KBD_REPORT_ID && size >= 3 && data[1] == 0x85) 580 memset(&data[2], 0, size - 2); 581 582 return 0; 583 } 584 585 static int asus_kbd_set_report(struct hid_device *hdev, const u8 *buf, size_t buf_size) 586 { 587 u8 *dmabuf __free(kfree) = kmemdup(buf, buf_size, GFP_KERNEL); 588 if (!dmabuf) 589 return -ENOMEM; 590 591 /* 592 * The report ID should be set from the incoming buffer due to LED and key 593 * interfaces having different pages 594 */ 595 return hid_hw_raw_request(hdev, buf[0], dmabuf, buf_size, HID_FEATURE_REPORT, 596 HID_REQ_SET_REPORT); 597 } 598 599 static int asus_kbd_init(struct hid_device *hdev, u8 report_id) 600 { 601 /* 602 * The handshake is first sent as a set_report, then retrieved 603 * from a get_report. They should be equal. 604 */ 605 const u8 buf[] = { report_id, 0x41, 0x53, 0x55, 0x53, 0x20, 0x54, 606 0x65, 0x63, 0x68, 0x2e, 0x49, 0x6e, 0x63, 0x2e, 0x00 }; 607 int ret; 608 609 ret = asus_kbd_set_report(hdev, buf, sizeof(buf)); 610 if (ret < 0) { 611 hid_err(hdev, "Asus handshake %02x failed to send: %d\n", 612 report_id, ret); 613 return ret; 614 } 615 616 u8 *readbuf __free(kfree) = kzalloc(FEATURE_KBD_REPORT_SIZE, GFP_KERNEL); 617 if (!readbuf) 618 return -ENOMEM; 619 620 ret = hid_hw_raw_request(hdev, report_id, readbuf, 621 FEATURE_KBD_REPORT_SIZE, HID_FEATURE_REPORT, 622 HID_REQ_GET_REPORT); 623 if (ret < 0) { 624 hid_warn(hdev, "Asus handshake %02x failed to receive ack: %d\n", 625 report_id, ret); 626 } else if (memcmp(readbuf, buf, sizeof(buf)) != 0) { 627 hid_warn(hdev, "Asus handshake %02x returned invalid response: %*ph\n", 628 report_id, FEATURE_KBD_REPORT_SIZE, readbuf); 629 } 630 631 /* 632 * Do not return error if handshake is wrong until this is 633 * verified to work for all devices. 634 */ 635 return 0; 636 } 637 638 static int asus_kbd_get_functions(struct hid_device *hdev, 639 unsigned char *kbd_func, 640 u8 report_id) 641 { 642 const u8 buf[] = { report_id, 0x05, 0x20, 0x31, 0x00, 0x08 }; 643 u8 *readbuf; 644 int ret; 645 646 ret = asus_kbd_set_report(hdev, buf, sizeof(buf)); 647 if (ret < 0) { 648 hid_err(hdev, "Asus failed to send configuration command: %d\n", ret); 649 return ret; 650 } 651 652 readbuf = kzalloc(FEATURE_KBD_REPORT_SIZE, GFP_KERNEL); 653 if (!readbuf) 654 return -ENOMEM; 655 656 ret = hid_hw_raw_request(hdev, report_id, readbuf, 657 FEATURE_KBD_REPORT_SIZE, HID_FEATURE_REPORT, 658 HID_REQ_GET_REPORT); 659 if (ret < 0) { 660 hid_err(hdev, "Asus failed to request functions: %d\n", ret); 661 kfree(readbuf); 662 return ret; 663 } 664 665 *kbd_func = readbuf[6]; 666 667 kfree(readbuf); 668 return ret; 669 } 670 671 static int asus_kbd_disable_oobe(struct hid_device *hdev) 672 { 673 const u8 init[][6] = { 674 { FEATURE_KBD_REPORT_ID, 0x05, 0x20, 0x31, 0x00, 0x08 }, 675 { FEATURE_KBD_REPORT_ID, 0xBA, 0xC5, 0xC4 }, 676 { FEATURE_KBD_REPORT_ID, 0xD0, 0x8F, 0x01 }, 677 { FEATURE_KBD_REPORT_ID, 0xD0, 0x85, 0xFF } 678 }; 679 int ret; 680 681 for (size_t i = 0; i < ARRAY_SIZE(init); i++) { 682 ret = asus_kbd_set_report(hdev, init[i], sizeof(init[i])); 683 if (ret < 0) 684 return ret; 685 } 686 687 hid_info(hdev, "Disabled OOBE for keyboard\n"); 688 return 0; 689 } 690 691 static void asus_kbd_set_fn_lock(struct hid_device *hdev, bool enabled) 692 { 693 const u8 buf[FEATURE_KBD_REPORT_SIZE] = { FEATURE_KBD_REPORT_ID, 0xd0, 0x4e, !!enabled }; 694 int ret; 695 696 ret = asus_kbd_set_report(hdev, buf, sizeof(buf)); 697 if (ret < 0) 698 hid_err(hdev, "Asus failed to set fn lock: %d\n", ret); 699 } 700 701 static void asus_kbd_set_brightness(struct hid_device *hdev, u8 brightness) 702 { 703 const u8 buf[FEATURE_KBD_REPORT_SIZE] = { 704 FEATURE_KBD_REPORT_ID, 0xba, 0xc5, 0xc4, brightness 705 }; 706 int ret; 707 708 ret = asus_kbd_set_report(hdev, buf, sizeof(buf)); 709 if (ret < 0) 710 hid_err(hdev, "Asus failed to set keyboard backlight: %d\n", ret); 711 } 712 713 static void asus_kbd_wmi_fan(struct hid_device *hdev, struct hid_raw_event_data *data) 714 { 715 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 716 int ret; 717 718 ret = asus_wmi_send_event(drvdata, ASUS_FAN_CTRL_KEY_CODE); 719 720 /* 721 * Warn if asus-wmi failed (but not if it's unavailable). 722 * Let the event reach userspace in all failure cases. 723 */ 724 switch (ret) { 725 case -ENODEV: 726 break; 727 case 0: 728 return; 729 default: 730 hid_warn(hdev, "Failed to notify asus-wmi: %d\n", ret); 731 break; 732 } 733 734 /* 735 * Fallback: pass the raw event to the HID core; to avoid 736 * racing against the hid_report_raw_event() that generated 737 * this event use the same locking mechanism and wait for 738 * that function to terminate and signal the deferred execution 739 * before raising the stored event. 740 */ 741 down(&hdev->driver_input_lock); 742 hid_report_raw_event(hdev, HID_INPUT_REPORT, 743 data->report_data, data->report_size, 744 data->report_size, 1); 745 up(&hdev->driver_input_lock); 746 } 747 748 static void asus_kbd_backlight_set(struct asus_hid_listener *listener, int brightness) 749 { 750 struct asus_drvdata *drvdata = container_of(listener, struct asus_drvdata, listener); 751 struct asus_worker *worker = drvdata->worker; 752 struct asus_work_action *action; 753 unsigned long flags; 754 755 drvdata->kbd_backlight_brightness = brightness; 756 757 action = kzalloc_obj(struct asus_work_action, GFP_NOWAIT); 758 if (!action) 759 return; 760 761 action->type = BRIGHTNESS_SET; 762 action->data.brightness = brightness; 763 INIT_LIST_HEAD(&action->node); 764 765 spin_lock_irqsave(&worker->lock, flags); 766 asus_worker_schedule(worker, action); 767 spin_unlock_irqrestore(&worker->lock, flags); 768 } 769 770 static void asus_work(struct work_struct *work) 771 { 772 struct asus_worker *worker = container_of(work, struct asus_worker, work); 773 struct asus_work_action *action = NULL; 774 unsigned long flags; 775 776 /* 777 * Dequeue the next action, if any. Once teardown has begun .removed 778 * is set and asus_worker_stop() drains the queue: leave the queued 779 * actions alone, they are dropped instead of being executed against 780 * a device that is being removed. 781 */ 782 spin_lock_irqsave(&worker->lock, flags); 783 if (!worker->removed && !list_empty(&worker->actions)) { 784 action = list_first_entry(&worker->actions, 785 struct asus_work_action, node); 786 list_del(&action->node); 787 } 788 spin_unlock_irqrestore(&worker->lock, flags); 789 790 if (!action) 791 return; 792 793 switch (action->type) { 794 case BRIGHTNESS_SET: 795 asus_kbd_set_brightness(worker->hdev, action->data.brightness); 796 break; 797 case FN_LOCK_SYNC: 798 asus_kbd_set_fn_lock(worker->hdev, action->data.fn_lock); 799 break; 800 case WMI_FAN: 801 asus_kbd_wmi_fan(worker->hdev, &action->data.fan_hid_data); 802 break; 803 default: 804 hid_err(worker->hdev, "Invalid action type: %d\n", action->type); 805 break; 806 } 807 808 kfree(action); 809 810 /* Re-schedule if there are more pending actions */ 811 spin_lock_irqsave(&worker->lock, flags); 812 if (!list_empty(&worker->actions)) 813 schedule_work(&worker->work); 814 spin_unlock_irqrestore(&worker->lock, flags); 815 } 816 817 static int asus_worker_create(struct hid_device *hdev, struct asus_drvdata *drvdata) 818 { 819 drvdata->worker = devm_kzalloc(&hdev->dev, sizeof(struct asus_worker), GFP_KERNEL); 820 if (!drvdata->worker) 821 return -ENOMEM; 822 823 drvdata->worker->removed = false; 824 drvdata->worker->hdev = hdev; 825 INIT_LIST_HEAD(&drvdata->worker->actions); 826 827 INIT_WORK(&drvdata->worker->work, asus_work); 828 spin_lock_init(&drvdata->worker->lock); 829 830 return 0; 831 } 832 833 /** 834 * asus_worker_stop - quiesce the worker 835 * @worker: the worker to quiesce 836 * 837 * Once this function returns no more actions can be queued and no instance 838 * of asus_work() is running or pending. 839 * 840 * Callers must do this before hid_hw_stop(): actions are executed while the 841 * device is fully operational, since they send raw requests to it and, in 842 * the fan-key fallback path, re-inject raw reports into the HID core. After 843 * hid_hw_stop() the transport is gone (usbhid_stop() frees the URBs and the 844 * I/O buffers) and the input devices have been unregistered. 845 * 846 * The quiescing is race free because every site that queues an action holds 847 * worker->lock across the .removed check, the list insertion and 848 * schedule_work(): anything scheduled before .removed is set here is caught 849 * by the cancel_work_sync() below, anything after it is discarded by 850 * asus_worker_schedule(). 851 */ 852 static void asus_worker_stop(struct asus_worker *worker) 853 { 854 struct asus_work_action *action, *tmp; 855 unsigned long flags; 856 857 spin_lock_irqsave(&worker->lock, flags); 858 worker->removed = true; 859 list_for_each_entry_safe(action, tmp, &worker->actions, node) { 860 list_del(&action->node); 861 kfree(action); 862 } 863 spin_unlock_irqrestore(&worker->lock, flags); 864 865 cancel_work_sync(&worker->work); 866 } 867 868 /* 869 * We don't care about any other part of the string except the version section. 870 * Example strings: FGA80100.RC72LA.312_T01, FGA80100.RC71LS.318_T01 871 * The bytes "5a 05 03 31 00 1a 13" and possibly more come before the version 872 * string, and there may be additional bytes after the version string such as 873 * "75 00 74 00 65 00" or a postfix such as "_T01" 874 */ 875 static int mcu_parse_version_string(const u8 *response, size_t response_size) 876 { 877 const u8 *end = response + response_size; 878 const u8 *p = response; 879 int dots, err, version; 880 char buf[4]; 881 882 dots = 0; 883 while (p < end && dots < 2) { 884 if (*p++ == '.') 885 dots++; 886 } 887 888 if (dots != 2 || end - p < 3) 889 return -EINVAL; 890 891 memcpy(buf, p, 3); 892 buf[3] = '\0'; 893 894 err = kstrtoint(buf, 10, &version); 895 if (err || version < 0) 896 return -EINVAL; 897 898 return version; 899 } 900 901 static int mcu_request_version(struct hid_device *hdev) 902 { 903 u8 *response __free(kfree) = kzalloc(ROG_ALLY_REPORT_SIZE, GFP_KERNEL); 904 const u8 request[] = { 0x5a, 0x05, 0x03, 0x31, 0x00, 0x20 }; 905 int ret; 906 907 if (!response) 908 return -ENOMEM; 909 910 ret = asus_kbd_set_report(hdev, request, sizeof(request)); 911 if (ret < 0) 912 return ret; 913 914 ret = hid_hw_raw_request(hdev, FEATURE_REPORT_ID, response, 915 ROG_ALLY_REPORT_SIZE, HID_FEATURE_REPORT, 916 HID_REQ_GET_REPORT); 917 if (ret < 0) 918 return ret; 919 920 ret = mcu_parse_version_string(response, ROG_ALLY_REPORT_SIZE); 921 if (ret < 0) { 922 pr_err("Failed to parse MCU version: %d\n", ret); 923 print_hex_dump(KERN_ERR, "MCU: ", DUMP_PREFIX_NONE, 924 16, 1, response, ROG_ALLY_REPORT_SIZE, false); 925 } 926 927 return ret; 928 } 929 930 static void validate_mcu_fw_version(struct hid_device *hdev, int idProduct) 931 { 932 int min_version, version; 933 934 version = mcu_request_version(hdev); 935 if (version < 0) 936 return; 937 938 switch (idProduct) { 939 case USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY: 940 min_version = ROG_ALLY_MIN_MCU; 941 break; 942 case USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY_X: 943 min_version = ROG_ALLY_X_MIN_MCU; 944 break; 945 default: 946 min_version = 0; 947 } 948 949 if (version < min_version) { 950 hid_warn(hdev, 951 "The MCU firmware version must be %d or greater to avoid issues with suspend.\n", 952 min_version); 953 } else { 954 set_ally_mcu_hack(ASUS_WMI_ALLY_MCU_HACK_DISABLED); 955 set_ally_mcu_powersave(true); 956 } 957 } 958 959 static bool asus_has_report_id(struct hid_device *hdev, u16 report_id) 960 { 961 struct hid_report *report; 962 int t; 963 964 for (t = HID_INPUT_REPORT; t <= HID_FEATURE_REPORT; t++) { 965 list_for_each_entry(report, &hdev->report_enum[t].report_list, list) { 966 if (report->id == report_id) 967 return true; 968 } 969 } 970 971 return false; 972 } 973 974 static int asus_kbd_register_leds(struct hid_device *hdev) 975 { 976 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 977 struct usb_interface *intf; 978 struct usb_device *udev; 979 unsigned char kbd_func; 980 int ret; 981 982 /* Get keyboard functions */ 983 ret = asus_kbd_get_functions(hdev, &kbd_func, FEATURE_KBD_REPORT_ID); 984 if (ret < 0) 985 return ret; 986 987 /* Check for backlight support */ 988 if (!(kbd_func & SUPPORT_KBD_BACKLIGHT)) 989 return -ENODEV; 990 991 if (dmi_match(DMI_PRODUCT_FAMILY, "ProArt P16")) { 992 ret = asus_kbd_disable_oobe(hdev); 993 if (ret < 0) 994 return ret; 995 } 996 997 if ((drvdata->quirks & QUIRK_ROG_ALLY_XPAD) && hid_is_usb(hdev)) { 998 intf = to_usb_interface(hdev->dev.parent); 999 udev = interface_to_usbdev(intf); 1000 validate_mcu_fw_version(hdev, 1001 le16_to_cpu(udev->descriptor.idProduct)); 1002 } 1003 1004 drvdata->listener.brightness_set = asus_kbd_backlight_set; 1005 ret = asus_hid_register_listener(&drvdata->listener); 1006 if (ret < 0) { 1007 hid_err(hdev, "Unable to register kbd brightness listener: %d\n", ret); 1008 drvdata->listener.brightness_set = NULL; 1009 } 1010 1011 return ret; 1012 } 1013 1014 /* 1015 * [0] REPORT_ID (same value defined in report descriptor) 1016 * [1] rest battery level. range [0..255] 1017 * [2]..[7] Bluetooth hardware address (MAC address) 1018 * [8] charging status 1019 * = 0 : AC offline / discharging 1020 * = 1 : AC online / charging 1021 * = 2 : AC online / fully charged 1022 */ 1023 static int asus_parse_battery(struct asus_drvdata *drvdata, u8 *data, int size) 1024 { 1025 u8 sts; 1026 u8 lvl; 1027 int val; 1028 1029 lvl = data[1]; 1030 sts = data[8]; 1031 1032 drvdata->battery_capacity = ((int)lvl * 100) / (int)BATTERY_LEVEL_MAX; 1033 1034 switch (sts) { 1035 case BATTERY_STAT_CHARGING: 1036 val = POWER_SUPPLY_STATUS_CHARGING; 1037 break; 1038 case BATTERY_STAT_FULL: 1039 val = POWER_SUPPLY_STATUS_FULL; 1040 break; 1041 case BATTERY_STAT_DISCONNECT: 1042 default: 1043 val = POWER_SUPPLY_STATUS_DISCHARGING; 1044 break; 1045 } 1046 drvdata->battery_stat = val; 1047 1048 return 0; 1049 } 1050 1051 static int asus_report_battery(struct asus_drvdata *drvdata, u8 *data, int size) 1052 { 1053 /* notify only the autonomous event by device */ 1054 if ((drvdata->battery_in_query == false) && 1055 (size == BATTERY_REPORT_SIZE)) 1056 power_supply_changed(drvdata->battery); 1057 1058 return 0; 1059 } 1060 1061 static int asus_battery_query(struct asus_drvdata *drvdata) 1062 { 1063 u8 *buf; 1064 int ret = 0; 1065 1066 buf = kmalloc(BATTERY_REPORT_SIZE, GFP_KERNEL); 1067 if (!buf) 1068 return -ENOMEM; 1069 1070 drvdata->battery_in_query = true; 1071 ret = hid_hw_raw_request(drvdata->hdev, BATTERY_REPORT_ID, 1072 buf, BATTERY_REPORT_SIZE, 1073 HID_INPUT_REPORT, HID_REQ_GET_REPORT); 1074 drvdata->battery_in_query = false; 1075 if (ret == BATTERY_REPORT_SIZE) 1076 ret = asus_parse_battery(drvdata, buf, BATTERY_REPORT_SIZE); 1077 else 1078 ret = -ENODATA; 1079 1080 kfree(buf); 1081 1082 return ret; 1083 } 1084 1085 static enum power_supply_property asus_battery_props[] = { 1086 POWER_SUPPLY_PROP_STATUS, 1087 POWER_SUPPLY_PROP_PRESENT, 1088 POWER_SUPPLY_PROP_CAPACITY, 1089 POWER_SUPPLY_PROP_SCOPE, 1090 POWER_SUPPLY_PROP_MODEL_NAME, 1091 }; 1092 1093 #define QUERY_MIN_INTERVAL (60 * HZ) /* 60[sec] */ 1094 1095 static int asus_battery_get_property(struct power_supply *psy, 1096 enum power_supply_property psp, 1097 union power_supply_propval *val) 1098 { 1099 struct asus_drvdata *drvdata = power_supply_get_drvdata(psy); 1100 int ret = 0; 1101 1102 switch (psp) { 1103 case POWER_SUPPLY_PROP_STATUS: 1104 case POWER_SUPPLY_PROP_CAPACITY: 1105 if (time_before(drvdata->battery_next_query, jiffies)) { 1106 drvdata->battery_next_query = 1107 jiffies + QUERY_MIN_INTERVAL; 1108 ret = asus_battery_query(drvdata); 1109 if (ret) 1110 return ret; 1111 } 1112 if (psp == POWER_SUPPLY_PROP_STATUS) 1113 val->intval = drvdata->battery_stat; 1114 else 1115 val->intval = drvdata->battery_capacity; 1116 break; 1117 case POWER_SUPPLY_PROP_PRESENT: 1118 val->intval = 1; 1119 break; 1120 case POWER_SUPPLY_PROP_SCOPE: 1121 val->intval = POWER_SUPPLY_SCOPE_DEVICE; 1122 break; 1123 case POWER_SUPPLY_PROP_MODEL_NAME: 1124 val->strval = drvdata->hdev->name; 1125 break; 1126 default: 1127 ret = -EINVAL; 1128 break; 1129 } 1130 1131 return ret; 1132 } 1133 1134 static int asus_battery_probe(struct hid_device *hdev) 1135 { 1136 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 1137 struct power_supply_config pscfg = { .drv_data = drvdata }; 1138 int ret = 0; 1139 1140 drvdata->battery_capacity = 0; 1141 drvdata->battery_stat = POWER_SUPPLY_STATUS_UNKNOWN; 1142 drvdata->battery_in_query = false; 1143 1144 drvdata->battery_desc.properties = asus_battery_props; 1145 drvdata->battery_desc.num_properties = ARRAY_SIZE(asus_battery_props); 1146 drvdata->battery_desc.get_property = asus_battery_get_property; 1147 drvdata->battery_desc.type = POWER_SUPPLY_TYPE_BATTERY; 1148 drvdata->battery_desc.use_for_apm = 0; 1149 drvdata->battery_desc.name = devm_kasprintf(&hdev->dev, GFP_KERNEL, 1150 "asus-keyboard-%s-battery", 1151 strlen(hdev->uniq) ? 1152 hdev->uniq : dev_name(&hdev->dev)); 1153 if (!drvdata->battery_desc.name) 1154 return -ENOMEM; 1155 1156 drvdata->battery_next_query = jiffies; 1157 1158 drvdata->battery = devm_power_supply_register(&hdev->dev, 1159 &(drvdata->battery_desc), &pscfg); 1160 if (IS_ERR(drvdata->battery)) { 1161 ret = PTR_ERR(drvdata->battery); 1162 drvdata->battery = NULL; 1163 hid_err(hdev, "Unable to register battery device\n"); 1164 return ret; 1165 } 1166 1167 power_supply_powers(drvdata->battery, &hdev->dev); 1168 1169 return ret; 1170 } 1171 1172 static int asus_xgm_led_set(struct led_classdev *led_cdev, enum led_brightness value) 1173 { 1174 const u8 buf[ROG_XGM_REPORT_SIZE] = { 1175 FEATURE_KBD_LED_REPORT_ID2, 0xC5, (value) ? 0x50 : 0x00 1176 }; 1177 struct asus_xgm_led *xgm = container_of(led_cdev, struct asus_xgm_led, cdev); 1178 int ret; 1179 1180 ret = asus_kbd_set_report(xgm->hdev, buf, ROG_XGM_REPORT_SIZE); 1181 if (ret < 0) { 1182 hid_err(xgm->hdev, "Unable to set XG mobile led state: %d\n", ret); 1183 return ret; 1184 } else if (ret != ROG_XGM_REPORT_SIZE) { 1185 hid_err(xgm->hdev, "Unexpected partial transfer to XG mobile: %d\n", ret); 1186 return -EIO; 1187 } 1188 1189 return 0; 1190 } 1191 1192 static int asus_input_configured(struct hid_device *hdev, struct hid_input *hi) 1193 { 1194 struct input_dev *input = hi->input; 1195 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 1196 1197 /* T100CHI uses MULTI_INPUT, bind the touchpad to the mouse hid_input */ 1198 if (drvdata->quirks & QUIRK_T100CHI && 1199 hi->report->id != T100CHI_MOUSE_REPORT_ID) 1200 return 0; 1201 1202 /* Handle MULTI_INPUT on E1239T mouse/touchpad USB interface */ 1203 if (drvdata->tp && (drvdata->quirks & QUIRK_MEDION_E1239T)) { 1204 switch (hi->report->id) { 1205 case E1239T_TP_TOGGLE_REPORT_ID: 1206 input_set_capability(input, EV_KEY, KEY_F21); 1207 input->name = "Asus Touchpad Keys"; 1208 drvdata->tp_kbd_input = input; 1209 return 0; 1210 case INPUT_REPORT_ID: 1211 break; /* Touchpad report, handled below */ 1212 default: 1213 return 0; /* Ignore other reports */ 1214 } 1215 } 1216 1217 if (drvdata->tp) { 1218 int ret; 1219 1220 input_set_abs_params(input, ABS_MT_POSITION_X, 0, 1221 drvdata->tp->max_x, 0, 0); 1222 input_set_abs_params(input, ABS_MT_POSITION_Y, 0, 1223 drvdata->tp->max_y, 0, 0); 1224 input_abs_set_res(input, ABS_MT_POSITION_X, drvdata->tp->res_x); 1225 input_abs_set_res(input, ABS_MT_POSITION_Y, drvdata->tp->res_y); 1226 1227 if (drvdata->tp->contact_size >= 5) { 1228 input_set_abs_params(input, ABS_TOOL_WIDTH, 0, 1229 MAX_TOUCH_MAJOR, 0, 0); 1230 input_set_abs_params(input, ABS_MT_TOUCH_MAJOR, 0, 1231 MAX_TOUCH_MAJOR, 0, 0); 1232 input_set_abs_params(input, ABS_MT_PRESSURE, 0, 1233 MAX_PRESSURE, 0, 0); 1234 } 1235 1236 __set_bit(BTN_LEFT, input->keybit); 1237 __set_bit(INPUT_PROP_BUTTONPAD, input->propbit); 1238 1239 ret = input_mt_init_slots(input, drvdata->tp->max_contacts, 1240 INPUT_MT_POINTER); 1241 1242 if (ret) { 1243 hid_err(hdev, "Asus input mt init slots failed: %d\n", ret); 1244 return ret; 1245 } 1246 } 1247 1248 drvdata->input = input; 1249 1250 if ((drvdata->quirks & QUIRK_HID_FN_LOCK) && 1251 (asus_kbd_fn_lock_set(drvdata, true))) 1252 hid_warn(hdev, "Error while setting FN lock to ON\n"); 1253 1254 return 0; 1255 } 1256 1257 #define asus_map_key_clear(c) hid_map_usage_clear(hi, usage, bit, \ 1258 max, EV_KEY, (c)) 1259 static int asus_input_mapping(struct hid_device *hdev, 1260 struct hid_input *hi, struct hid_field *field, 1261 struct hid_usage *usage, unsigned long **bit, 1262 int *max) 1263 { 1264 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 1265 1266 if (drvdata->quirks & QUIRK_SKIP_INPUT_MAPPING) { 1267 /* Don't map anything from the HID report. 1268 * We do it all manually in asus_input_configured 1269 */ 1270 return -1; 1271 } 1272 1273 /* 1274 * Ignore a bunch of bogus collections in the T100CHI descriptor. 1275 * This avoids a bunch of non-functional hid_input devices getting 1276 * created because of the T100CHI using HID_QUIRK_MULTI_INPUT. 1277 */ 1278 if ((drvdata->quirks & (QUIRK_T100CHI | QUIRK_T90CHI)) && 1279 (field->application == (HID_UP_GENDESK | 0x0080) || 1280 field->application == HID_GD_MOUSE || 1281 usage->hid == (HID_UP_GENDEVCTRLS | 0x0024) || 1282 usage->hid == (HID_UP_GENDEVCTRLS | 0x0025) || 1283 usage->hid == (HID_UP_GENDEVCTRLS | 0x0026))) 1284 return -1; 1285 1286 /* ASUS-specific keyboard hotkeys and led backlight */ 1287 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_ASUSVENDOR) { 1288 switch (usage->hid & HID_USAGE) { 1289 case 0x10: asus_map_key_clear(KEY_BRIGHTNESSDOWN); break; 1290 case 0x20: asus_map_key_clear(KEY_BRIGHTNESSUP); break; 1291 case 0x35: asus_map_key_clear(KEY_DISPLAY_OFF); break; 1292 case 0x6c: asus_map_key_clear(KEY_SLEEP); break; 1293 case 0x7c: asus_map_key_clear(KEY_MICMUTE); break; 1294 case 0x82: asus_map_key_clear(KEY_CAMERA); break; 1295 case 0x85: asus_map_key_clear(KEY_CAMERA); break; 1296 case 0x86: asus_map_key_clear(KEY_PROG1); break; /* MyASUS key */ 1297 case 0x88: asus_map_key_clear(KEY_RFKILL); break; 1298 case 0xb5: asus_map_key_clear(KEY_CALC); break; 1299 case 0xc4: asus_map_key_clear(KEY_KBDILLUMUP); break; 1300 case 0xc5: asus_map_key_clear(KEY_KBDILLUMDOWN); break; 1301 case 0xc7: asus_map_key_clear(KEY_KBDILLUMTOGGLE); break; 1302 case 0x4e: asus_map_key_clear(KEY_FN_ESC); break; 1303 case 0x7e: asus_map_key_clear(KEY_EMOJI_PICKER); break; 1304 1305 case 0x8b: asus_map_key_clear(KEY_PROG1); break; /* ProArt Creator Hub key */ 1306 case 0x5f: asus_map_key_clear(KEY_PROG2); break; /* S-shaped programmable key */ 1307 case 0x6b: asus_map_key_clear(KEY_F21); break; /* ASUS touchpad toggle */ 1308 case 0x38: asus_map_key_clear(KEY_PROG1); break; /* ROG key */ 1309 case 0xba: asus_map_key_clear(KEY_PROG2); break; /* Fn+C ASUS Splendid */ 1310 case 0x5c: asus_map_key_clear(KEY_PROG3); break; /* Fn+Space Power4Gear */ 1311 case 0x99: asus_map_key_clear(KEY_PROG4); break; /* Fn+F5 "fan" symbol */ 1312 case 0xae: asus_map_key_clear(KEY_PROG4); break; /* Fn+F5 "fan" symbol */ 1313 case 0x92: asus_map_key_clear(KEY_CALC); break; /* Fn+Ret "Calc" symbol */ 1314 case 0xb2: asus_map_key_clear(KEY_PROG2); break; /* Fn+Left previous aura */ 1315 case 0xb3: asus_map_key_clear(KEY_PROG3); break; /* Fn+Left next aura */ 1316 case 0x6a: asus_map_key_clear(KEY_F13); break; /* Screenpad toggle */ 1317 case 0x4b: asus_map_key_clear(KEY_F14); break; /* Arrows/Pg-Up/Dn toggle */ 1318 case 0xa5: asus_map_key_clear(KEY_F15); break; /* ROG Ally left back */ 1319 case 0xa6: asus_map_key_clear(KEY_F16); break; /* ROG Ally QAM button */ 1320 case 0xa7: asus_map_key_clear(KEY_F17); break; /* ROG Ally ROG long-press */ 1321 case 0xa8: asus_map_key_clear(KEY_F18); break; /* ROG Ally ROG long-press-release */ 1322 1323 default: 1324 /* ASUS lazily declares 256 usages, ignore the rest, 1325 * as some make the keyboard appear as a pointer device. */ 1326 return -1; 1327 } 1328 1329 set_bit(EV_REP, hi->input->evbit); 1330 return 1; 1331 } 1332 1333 if ((usage->hid & HID_USAGE_PAGE) == HID_UP_MSVENDOR) { 1334 switch (usage->hid & HID_USAGE) { 1335 case 0xff01: asus_map_key_clear(BTN_1); break; 1336 case 0xff02: asus_map_key_clear(BTN_2); break; 1337 case 0xff03: asus_map_key_clear(BTN_3); break; 1338 case 0xff04: asus_map_key_clear(BTN_4); break; 1339 case 0xff05: asus_map_key_clear(BTN_5); break; 1340 case 0xff06: asus_map_key_clear(BTN_6); break; 1341 case 0xff07: asus_map_key_clear(BTN_7); break; 1342 case 0xff08: asus_map_key_clear(BTN_8); break; 1343 case 0xff09: asus_map_key_clear(BTN_9); break; 1344 case 0xff0a: asus_map_key_clear(BTN_A); break; 1345 case 0xff0b: asus_map_key_clear(BTN_B); break; 1346 case 0x00f1: asus_map_key_clear(KEY_WLAN); break; 1347 case 0x00f2: asus_map_key_clear(KEY_BRIGHTNESSDOWN); break; 1348 case 0x00f3: asus_map_key_clear(KEY_BRIGHTNESSUP); break; 1349 case 0x00f4: asus_map_key_clear(KEY_DISPLAY_OFF); break; 1350 case 0x00f7: asus_map_key_clear(KEY_CAMERA); break; 1351 case 0x00f8: asus_map_key_clear(KEY_PROG1); break; 1352 default: 1353 return 0; 1354 } 1355 1356 set_bit(EV_REP, hi->input->evbit); 1357 return 1; 1358 } 1359 1360 if (drvdata->quirks & QUIRK_NO_CONSUMER_USAGES && 1361 (usage->hid & HID_USAGE_PAGE) == HID_UP_CONSUMER) { 1362 switch (usage->hid & HID_USAGE) { 1363 case 0xe2: /* Mute */ 1364 case 0xe9: /* Volume up */ 1365 case 0xea: /* Volume down */ 1366 return 0; 1367 default: 1368 /* Ignore dummy Consumer usages which make the 1369 * keyboard incorrectly appear as a pointer device. 1370 */ 1371 return -1; 1372 } 1373 } 1374 1375 /* 1376 * The mute button is broken and only sends press events, we 1377 * deal with this in our raw_event handler, so do not map it. 1378 */ 1379 if ((drvdata->quirks & QUIRK_MEDION_E1239T) && 1380 usage->hid == (HID_UP_CONSUMER | 0xe2)) { 1381 input_set_capability(hi->input, EV_KEY, KEY_MUTE); 1382 return -1; 1383 } 1384 1385 return 0; 1386 } 1387 1388 static int asus_start_multitouch(struct hid_device *hdev) 1389 { 1390 int ret; 1391 static const unsigned char buf[] = { 1392 FEATURE_REPORT_ID, 0x00, 0x03, 0x01, 0x00 1393 }; 1394 unsigned char *dmabuf = kmemdup(buf, sizeof(buf), GFP_KERNEL); 1395 1396 if (!dmabuf) { 1397 ret = -ENOMEM; 1398 hid_err(hdev, "Asus failed to alloc dma buf: %d\n", ret); 1399 return ret; 1400 } 1401 1402 ret = hid_hw_raw_request(hdev, dmabuf[0], dmabuf, sizeof(buf), 1403 HID_FEATURE_REPORT, HID_REQ_SET_REPORT); 1404 1405 kfree(dmabuf); 1406 1407 if (ret != sizeof(buf)) { 1408 hid_err(hdev, "Asus failed to start multitouch: %d\n", ret); 1409 return ret; 1410 } 1411 1412 return 0; 1413 } 1414 1415 /* 1416 * Initialize the reports of the device. 1417 * 1418 * Failures are intentionally not fatal: asus_kbd_init() tolerates a wrong 1419 * handshake until this is verified to work for all devices, so a failure 1420 * is only reported and the initialization of the remaining reports is 1421 * still attempted. 1422 */ 1423 static void asus_initialize_reports(struct hid_device *hdev) 1424 { 1425 int ret; 1426 1427 for (int r = 0; r < ARRAY_SIZE(asus_report_id_init); r++) { 1428 if (asus_has_report_id(hdev, asus_report_id_init[r])) { 1429 ret = asus_kbd_init(hdev, asus_report_id_init[r]); 1430 if (ret < 0) 1431 hid_warn(hdev, "Failed to initialize 0x%x: %d.\n", 1432 asus_report_id_init[r], ret); 1433 } 1434 } 1435 } 1436 1437 static int asus_xgm_init(struct hid_device *hdev, struct asus_drvdata *drvdata) 1438 { 1439 const char *name; 1440 int ret; 1441 1442 drvdata->xgm_led = devm_kzalloc(&hdev->dev, sizeof(*drvdata->xgm_led), GFP_KERNEL); 1443 if (drvdata->xgm_led == NULL) 1444 return -ENOMEM; 1445 1446 name = devm_kasprintf(&hdev->dev, GFP_KERNEL, "asus:xgm-%s:led", 1447 strlen(hdev->uniq) ? hdev->uniq : dev_name(&hdev->dev)); 1448 1449 if (name == NULL) { 1450 ret = -ENOMEM; 1451 goto asus_xgm_init_err; 1452 } 1453 1454 drvdata->xgm_led->hdev = hdev; 1455 drvdata->xgm_led->cdev.name = name; 1456 drvdata->xgm_led->cdev.brightness = 1; 1457 drvdata->xgm_led->cdev.max_brightness = 1; 1458 drvdata->xgm_led->cdev.brightness_set_blocking = asus_xgm_led_set; 1459 drvdata->xgm_led->cdev.flags = LED_CORE_SUSPENDRESUME; 1460 1461 /* LED state is arbitrary on boot, set a default */ 1462 ret = asus_xgm_led_set(&drvdata->xgm_led->cdev, drvdata->xgm_led->cdev.brightness); 1463 if (ret) { 1464 hid_err(hdev, "Asus failed to set xgm led: %d\n", ret); 1465 goto asus_xgm_init_err; 1466 } 1467 1468 ret = devm_led_classdev_register(&hdev->dev, &drvdata->xgm_led->cdev); 1469 if (ret) { 1470 hid_err(hdev, "Asus failed to register xgm led: %d\n", ret); 1471 goto asus_xgm_init_err; 1472 } 1473 1474 return 0; 1475 asus_xgm_init_err: 1476 drvdata->xgm_led = NULL; 1477 return ret; 1478 } 1479 1480 static int __maybe_unused asus_resume(struct hid_device *hdev) 1481 { 1482 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 1483 1484 /* 1485 * If we have a backlight listener registered, restore the previous state, 1486 * in case of error do not fail: most models restore the backlight 1487 * automatically, and the error is non-fatal. 1488 */ 1489 if (drvdata->listener.brightness_set) 1490 asus_kbd_backlight_set(&drvdata->listener, drvdata->kbd_backlight_brightness); 1491 1492 return 0; 1493 } 1494 1495 static int __maybe_unused asus_reset_resume(struct hid_device *hdev) 1496 { 1497 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 1498 1499 if (!drvdata->tp) 1500 asus_initialize_reports(hdev); 1501 1502 if (drvdata->tp) 1503 return asus_start_multitouch(hdev); 1504 1505 return 0; 1506 } 1507 1508 static int asus_probe(struct hid_device *hdev, const struct hid_device_id *id) 1509 { 1510 struct hid_report_enum *rep_enum; 1511 struct asus_drvdata *drvdata; 1512 struct hid_report *rep; 1513 bool is_vendor = false; 1514 int ret; 1515 1516 drvdata = devm_kzalloc(&hdev->dev, sizeof(*drvdata), GFP_KERNEL); 1517 if (drvdata == NULL) 1518 return -ENOMEM; 1519 1520 hid_set_drvdata(hdev, drvdata); 1521 1522 drvdata->quirks = id->driver_data; 1523 1524 /* 1525 * T90CHI's keyboard dock returns same ID values as T100CHI's dock. 1526 * Thus, identify T90CHI dock with product name string. 1527 */ 1528 if (strstr(hdev->name, "T90CHI")) { 1529 drvdata->quirks &= ~QUIRK_T100CHI; 1530 drvdata->quirks |= QUIRK_T90CHI; 1531 } 1532 1533 if (drvdata->quirks & QUIRK_IS_MULTITOUCH) 1534 drvdata->tp = &asus_i2c_tp; 1535 1536 if ((drvdata->quirks & QUIRK_T100_KEYBOARD) && hid_is_usb(hdev)) { 1537 struct usb_interface *intf = to_usb_interface(hdev->dev.parent); 1538 1539 if (intf->altsetting->desc.bInterfaceNumber == T100_TPAD_INTF) { 1540 drvdata->quirks = QUIRK_SKIP_INPUT_MAPPING; 1541 /* 1542 * The T100HA uses the same USB-ids as the T100TAF and 1543 * the T200TA uses the same USB-ids as the T100TA, while 1544 * both have different max x/y values as the T100TA[F]. 1545 */ 1546 if (dmi_match(DMI_PRODUCT_NAME, "T100HAN")) 1547 drvdata->tp = &asus_t100ha_tp; 1548 else if (dmi_match(DMI_PRODUCT_NAME, "T200TA")) 1549 drvdata->tp = &asus_t200ta_tp; 1550 else 1551 drvdata->tp = &asus_t100ta_tp; 1552 } 1553 } 1554 1555 if (drvdata->quirks & QUIRK_T100CHI) { 1556 /* 1557 * All functionality is on a single HID interface and for 1558 * userspace the touchpad must be a separate input_dev. 1559 */ 1560 hdev->quirks |= HID_QUIRK_MULTI_INPUT; 1561 drvdata->tp = &asus_t100chi_tp; 1562 } 1563 1564 if ((drvdata->quirks & QUIRK_MEDION_E1239T) && hid_is_usb(hdev)) { 1565 struct usb_host_interface *alt = 1566 to_usb_interface(hdev->dev.parent)->altsetting; 1567 1568 if (alt->desc.bInterfaceNumber == MEDION_E1239T_TPAD_INTF) { 1569 /* For separate input-devs for tp and tp toggle key */ 1570 hdev->quirks |= HID_QUIRK_MULTI_INPUT; 1571 drvdata->quirks |= QUIRK_SKIP_INPUT_MAPPING; 1572 drvdata->tp = &medion_e1239t_tp; 1573 } 1574 } 1575 1576 if (drvdata->quirks & QUIRK_NO_INIT_REPORTS) 1577 hdev->quirks |= HID_QUIRK_NO_INIT_REPORTS; 1578 1579 drvdata->hdev = hdev; 1580 1581 if (drvdata->quirks & (QUIRK_T100CHI | QUIRK_T90CHI)) { 1582 ret = asus_battery_probe(hdev); 1583 if (ret) { 1584 hid_err(hdev, 1585 "Asus hid battery_probe failed: %d\n", ret); 1586 return ret; 1587 } 1588 } 1589 1590 ret = hid_parse(hdev); 1591 if (ret) { 1592 hid_err(hdev, "Asus hid parse failed: %d\n", ret); 1593 return ret; 1594 } 1595 1596 /* Check for vendor for RGB init and handle generic devices properly. */ 1597 rep_enum = &hdev->report_enum[HID_INPUT_REPORT]; 1598 list_for_each_entry(rep, &rep_enum->report_list, list) { 1599 if ((rep->application & HID_USAGE_PAGE) == HID_UP_ASUSVENDOR) 1600 is_vendor = true; 1601 } 1602 1603 ret = asus_worker_create(hdev, drvdata); 1604 if (ret) { 1605 hid_warn(hdev, "Failed to initialize worker: %d\n", ret); 1606 return ret; 1607 } 1608 1609 ret = hid_hw_start(hdev, HID_CONNECT_DEFAULT); 1610 if (ret) { 1611 asus_worker_stop(drvdata->worker); 1612 hid_err(hdev, "Asus hw start failed: %d\n", ret); 1613 return ret; 1614 } 1615 1616 if (!drvdata->tp) 1617 asus_initialize_reports(hdev); 1618 1619 if (asus_has_report_id(hdev, FEATURE_KBD_REPORT_ID) && 1620 ((hdev->product == USB_DEVICE_ID_ASUSTEK_XGM_2022) || 1621 (hdev->product == USB_DEVICE_ID_ASUSTEK_XGM_2023))) { 1622 ret = asus_xgm_init(hdev, drvdata); 1623 if (ret) { 1624 hid_err(hdev, "Failed to initialize xg mobile: %d\n", ret); 1625 goto err_stop_hw; 1626 } 1627 } 1628 1629 /* Laptops keyboard backlight is always at 0x5a */ 1630 if (is_vendor && (drvdata->quirks & QUIRK_USE_KBD_BACKLIGHT) && 1631 (asus_has_report_id(hdev, FEATURE_KBD_REPORT_ID)) && 1632 (asus_kbd_register_leds(hdev))) 1633 hid_warn(hdev, "Failed to initialize backlight.\n"); 1634 1635 /* 1636 * For ROG keyboards, skip rename for consistency and ->input check as 1637 * some devices do not have inputs. 1638 */ 1639 if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD) 1640 return 0; 1641 1642 /* 1643 * Check that input registration succeeded. Checking that 1644 * HID_CLAIMED_INPUT is set prevents a UAF when all input devices 1645 * were freed during registration due to no usages being mapped, 1646 * leaving drvdata->input pointing to freed memory. 1647 */ 1648 if (drvdata->input && (hdev->claimed & HID_CLAIMED_INPUT)) { 1649 if (drvdata->tp) 1650 drvdata->input->name = "Asus TouchPad"; 1651 else 1652 drvdata->input->name = "Asus Keyboard"; 1653 1654 if (drvdata->tp) { 1655 ret = asus_start_multitouch(hdev); 1656 if (ret) 1657 goto err_stop_hw; 1658 } 1659 } 1660 1661 return 0; 1662 err_stop_hw: 1663 if (drvdata->listener.brightness_set) 1664 asus_hid_unregister_listener(&drvdata->listener); 1665 1666 if (drvdata->xgm_led) 1667 devm_led_classdev_unregister(&hdev->dev, &drvdata->xgm_led->cdev); 1668 1669 asus_worker_stop(drvdata->worker); 1670 hid_hw_stop(hdev); 1671 return ret; 1672 } 1673 1674 static void asus_remove(struct hid_device *hdev) 1675 { 1676 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 1677 1678 if (drvdata->listener.brightness_set) 1679 asus_hid_unregister_listener(&drvdata->listener); 1680 1681 if (drvdata->xgm_led) 1682 devm_led_classdev_unregister(&hdev->dev, &drvdata->xgm_led->cdev); 1683 1684 asus_worker_stop(drvdata->worker); 1685 hid_hw_stop(hdev); 1686 } 1687 1688 static const __u8 asus_g752_fixed_rdesc[] = { 1689 0x19, 0x00, /* Usage Minimum (0x00) */ 1690 0x2A, 0xFF, 0x00, /* Usage Maximum (0xFF) */ 1691 }; 1692 1693 static const __u8 *asus_report_fixup(struct hid_device *hdev, __u8 *rdesc, 1694 unsigned int *rsize) 1695 { 1696 struct asus_drvdata *drvdata = hid_get_drvdata(hdev); 1697 1698 if (drvdata->quirks & QUIRK_FIX_NOTEBOOK_REPORT && 1699 *rsize >= 56 && rdesc[54] == 0x25 && rdesc[55] == 0x65) { 1700 hid_info(hdev, "Fixing up Asus notebook report descriptor\n"); 1701 rdesc[55] = 0xdd; 1702 } 1703 /* For the T100TA/T200TA keyboard dock */ 1704 if (drvdata->quirks & QUIRK_T100_KEYBOARD && 1705 (*rsize == 76 || *rsize == 101) && 1706 rdesc[73] == 0x81 && rdesc[74] == 0x01) { 1707 hid_info(hdev, "Fixing up Asus T100 keyb report descriptor\n"); 1708 rdesc[74] &= ~HID_MAIN_ITEM_CONSTANT; 1709 } 1710 /* For the T100CHI/T90CHI keyboard dock */ 1711 if (drvdata->quirks & (QUIRK_T100CHI | QUIRK_T90CHI)) { 1712 int rsize_orig; 1713 int offs; 1714 1715 if (drvdata->quirks & QUIRK_T100CHI) { 1716 rsize_orig = 403; 1717 offs = 388; 1718 } else { 1719 rsize_orig = 306; 1720 offs = 291; 1721 } 1722 1723 /* 1724 * Change Usage (76h) to Usage Minimum (00h), Usage Maximum 1725 * (FFh) and clear the flags in the Input() byte. 1726 * Note the descriptor has a bogus 0 byte at the end so we 1727 * only need 1 extra byte. 1728 */ 1729 if (*rsize == rsize_orig && 1730 rdesc[offs] == 0x09 && rdesc[offs + 1] == 0x76) { 1731 __u8 *new_rdesc; 1732 1733 new_rdesc = devm_kzalloc(&hdev->dev, rsize_orig + 1, 1734 GFP_KERNEL); 1735 if (!new_rdesc) 1736 return rdesc; 1737 1738 hid_info(hdev, "Fixing up %s keyb report descriptor\n", 1739 drvdata->quirks & QUIRK_T100CHI ? 1740 "T100CHI" : "T90CHI"); 1741 1742 memcpy(new_rdesc, rdesc, rsize_orig); 1743 *rsize = rsize_orig + 1; 1744 rdesc = new_rdesc; 1745 1746 memmove(rdesc + offs + 4, rdesc + offs + 2, 12); 1747 rdesc[offs] = 0x19; 1748 rdesc[offs + 1] = 0x00; 1749 rdesc[offs + 2] = 0x29; 1750 rdesc[offs + 3] = 0xff; 1751 rdesc[offs + 14] = 0x00; 1752 } 1753 } 1754 1755 if (drvdata->quirks & QUIRK_G752_KEYBOARD && 1756 *rsize == 75 && rdesc[61] == 0x15 && rdesc[62] == 0x00) { 1757 /* report is missing usage minimum and maximum */ 1758 __u8 *new_rdesc; 1759 size_t new_size = *rsize + sizeof(asus_g752_fixed_rdesc); 1760 1761 new_rdesc = devm_kzalloc(&hdev->dev, new_size, GFP_KERNEL); 1762 if (new_rdesc == NULL) 1763 return rdesc; 1764 1765 hid_info(hdev, "Fixing up Asus G752 keyb report descriptor\n"); 1766 /* copy the valid part */ 1767 memcpy(new_rdesc, rdesc, 61); 1768 /* insert missing part */ 1769 memcpy(new_rdesc + 61, asus_g752_fixed_rdesc, sizeof(asus_g752_fixed_rdesc)); 1770 /* copy remaining data */ 1771 memcpy(new_rdesc + 61 + sizeof(asus_g752_fixed_rdesc), rdesc + 61, *rsize - 61); 1772 1773 *rsize = new_size; 1774 rdesc = new_rdesc; 1775 } 1776 1777 if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD && 1778 *rsize == 331 && rdesc[190] == 0x85 && rdesc[191] == 0x5a && 1779 rdesc[204] == 0x95 && rdesc[205] == 0x05) { 1780 hid_info(hdev, "Fixing up Asus N-KEY keyb report descriptor\n"); 1781 rdesc[205] = 0x01; 1782 } 1783 1784 /* match many more n-key devices */ 1785 if (drvdata->quirks & QUIRK_ROG_NKEY_KEYBOARD && *rsize > 15) { 1786 for (int i = 0; i < *rsize - 15; i++) { 1787 /* offset to the count from 0x5a report part always 14 */ 1788 if (rdesc[i] == 0x85 && rdesc[i + 1] == 0x5a && 1789 rdesc[i + 14] == 0x95 && rdesc[i + 15] == 0x05) { 1790 hid_info(hdev, "Fixing up Asus N-Key report descriptor\n"); 1791 rdesc[i + 15] = 0x01; 1792 break; 1793 } 1794 } 1795 } 1796 1797 return rdesc; 1798 } 1799 1800 static const struct hid_device_id asus_devices[] = { 1801 { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, 1802 USB_DEVICE_ID_ASUSTEK_I2C_KEYBOARD), I2C_KEYBOARD_QUIRKS}, 1803 { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, 1804 USB_DEVICE_ID_ASUSTEK_I2C_ZENBOOK_KEYBOARD), 1805 I2C_KEYBOARD_QUIRKS | QUIRK_FILTER_CAMERA_COMPANION }, 1806 { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, 1807 USB_DEVICE_ID_ASUSTEK_I2C_TOUCHPAD), I2C_TOUCHPAD_QUIRKS }, 1808 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1809 USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD1), QUIRK_USE_KBD_BACKLIGHT }, 1810 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1811 USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD2), QUIRK_USE_KBD_BACKLIGHT }, 1812 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1813 USB_DEVICE_ID_ASUSTEK_ROG_KEYBOARD3), QUIRK_G752_KEYBOARD }, 1814 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1815 USB_DEVICE_ID_ASUSTEK_FX503VD_KEYBOARD), 1816 QUIRK_USE_KBD_BACKLIGHT }, 1817 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1818 USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD), 1819 QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD }, 1820 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1821 USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD2), 1822 QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD | QUIRK_HID_FN_LOCK }, 1823 { HID_I2C_DEVICE(USB_VENDOR_ID_ASUSTEK, 1824 USB_DEVICE_ID_ASUSTEK_ROG_NKEY_KEYBOARD2), 1825 QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD | QUIRK_HID_FN_LOCK }, 1826 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1827 USB_DEVICE_ID_ASUSTEK_ROG_Z13_LIGHTBAR), 1828 QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD }, 1829 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1830 USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY), 1831 QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD | QUIRK_ROG_ALLY_XPAD}, 1832 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1833 USB_DEVICE_ID_ASUSTEK_ROG_NKEY_ALLY_X), 1834 QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD | QUIRK_ROG_ALLY_XPAD }, 1835 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1836 USB_DEVICE_ID_ASUSTEK_XGM_2022), 1837 }, 1838 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1839 USB_DEVICE_ID_ASUSTEK_XGM_2023), 1840 }, 1841 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1842 USB_DEVICE_ID_ASUSTEK_ROG_CLAYMORE_II_KEYBOARD), 1843 QUIRK_ROG_CLAYMORE_II_KEYBOARD }, 1844 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1845 USB_DEVICE_ID_ASUSTEK_T100TA_KEYBOARD), 1846 QUIRK_T100_KEYBOARD | QUIRK_NO_CONSUMER_USAGES }, 1847 { HID_USB_DEVICE(USB_VENDOR_ID_ASUSTEK, 1848 USB_DEVICE_ID_ASUSTEK_T100TAF_KEYBOARD), 1849 QUIRK_T100_KEYBOARD | QUIRK_NO_CONSUMER_USAGES }, 1850 { HID_USB_DEVICE(USB_VENDOR_ID_CHICONY, USB_DEVICE_ID_ASUS_AK1D) }, 1851 { HID_USB_DEVICE(USB_VENDOR_ID_TURBOX, USB_DEVICE_ID_ASUS_MD_5110) }, 1852 { HID_USB_DEVICE(USB_VENDOR_ID_JESS, USB_DEVICE_ID_ASUS_MD_5112) }, 1853 { HID_BLUETOOTH_DEVICE(USB_VENDOR_ID_ASUSTEK, 1854 USB_DEVICE_ID_ASUSTEK_T100CHI_KEYBOARD), QUIRK_T100CHI }, 1855 { HID_USB_DEVICE(USB_VENDOR_ID_ITE, USB_DEVICE_ID_ITE_MEDION_E1239T), 1856 QUIRK_MEDION_E1239T }, 1857 /* 1858 * Note bind to the HID_GROUP_GENERIC group, so that we only bind to the keyboard 1859 * part, while letting hid-multitouch.c handle the touchpad. 1860 */ 1861 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 1862 USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_ROG_Z13_FOLIO), 1863 QUIRK_USE_KBD_BACKLIGHT | QUIRK_ROG_NKEY_KEYBOARD }, 1864 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 1865 USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_T101HA_KEYBOARD) }, 1866 { HID_DEVICE(BUS_USB, HID_GROUP_GENERIC, 1867 USB_VENDOR_ID_ASUSTEK, USB_DEVICE_ID_ASUSTEK_T302CHI_KEYBOARD) }, 1868 { } 1869 }; 1870 MODULE_DEVICE_TABLE(hid, asus_devices); 1871 1872 static struct hid_driver asus_driver = { 1873 .name = "asus", 1874 .id_table = asus_devices, 1875 .report_fixup = asus_report_fixup, 1876 .probe = asus_probe, 1877 .remove = asus_remove, 1878 .input_mapping = asus_input_mapping, 1879 .input_configured = asus_input_configured, 1880 .reset_resume = pm_ptr(asus_reset_resume), 1881 .resume = pm_ptr(asus_resume), 1882 .event = asus_event, 1883 .raw_event = asus_raw_event 1884 }; 1885 module_hid_driver(asus_driver); 1886 1887 MODULE_IMPORT_NS("ASUS_WMI"); 1888 MODULE_LICENSE("GPL"); 1889