1 /* 2 * Asus PC WMI hotkey driver 3 * 4 * Copyright(C) 2010 Intel Corporation. 5 * Copyright(C) 2010-2011 Corentin Chary <corentin.chary@gmail.com> 6 * 7 * Portions based on wistron_btns.c: 8 * Copyright (C) 2005 Miloslav Trmac <mitr@volny.cz> 9 * Copyright (C) 2005 Bernhard Rosenkraenzer <bero@arklinux.org> 10 * Copyright (C) 2005 Dmitry Torokhov <dtor@mail.ru> 11 * 12 * This program is free software; you can redistribute it and/or modify 13 * it under the terms of the GNU General Public License as published by 14 * the Free Software Foundation; either version 2 of the License, or 15 * (at your option) any later version. 16 * 17 * This program is distributed in the hope that it will be useful, 18 * but WITHOUT ANY WARRANTY; without even the implied warranty of 19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 * GNU General Public License for more details. 21 * 22 * You should have received a copy of the GNU General Public License 23 * along with this program; if not, write to the Free Software 24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 25 */ 26 27 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 28 29 #include <linux/kernel.h> 30 #include <linux/module.h> 31 #include <linux/init.h> 32 #include <linux/types.h> 33 #include <linux/slab.h> 34 #include <linux/input.h> 35 #include <linux/input/sparse-keymap.h> 36 #include <linux/fb.h> 37 #include <linux/backlight.h> 38 #include <linux/leds.h> 39 #include <linux/rfkill.h> 40 #include <linux/pci.h> 41 #include <linux/pci_hotplug.h> 42 #include <linux/hwmon.h> 43 #include <linux/hwmon-sysfs.h> 44 #include <linux/debugfs.h> 45 #include <linux/seq_file.h> 46 #include <linux/platform_data/x86/asus-wmi.h> 47 #include <linux/platform_device.h> 48 #include <linux/thermal.h> 49 #include <linux/acpi.h> 50 #include <linux/dmi.h> 51 #include <acpi/video.h> 52 53 #include "asus-wmi.h" 54 55 MODULE_AUTHOR("Corentin Chary <corentin.chary@gmail.com>, " 56 "Yong Wang <yong.y.wang@intel.com>"); 57 MODULE_DESCRIPTION("Asus Generic WMI Driver"); 58 MODULE_LICENSE("GPL"); 59 60 #define to_asus_wmi_driver(pdrv) \ 61 (container_of((pdrv), struct asus_wmi_driver, platform_driver)) 62 63 #define ASUS_WMI_MGMT_GUID "97845ED0-4E6D-11DE-8A39-0800200C9A66" 64 65 #define NOTIFY_BRNUP_MIN 0x11 66 #define NOTIFY_BRNUP_MAX 0x1f 67 #define NOTIFY_BRNDOWN_MIN 0x20 68 #define NOTIFY_BRNDOWN_MAX 0x2e 69 #define NOTIFY_KBD_BRTUP 0xc4 70 #define NOTIFY_KBD_BRTDWN 0xc5 71 #define NOTIFY_KBD_BRTTOGGLE 0xc7 72 73 #define ASUS_FAN_DESC "cpu_fan" 74 #define ASUS_FAN_MFUN 0x13 75 #define ASUS_FAN_SFUN_READ 0x06 76 #define ASUS_FAN_SFUN_WRITE 0x07 77 #define ASUS_FAN_CTRL_MANUAL 1 78 #define ASUS_FAN_CTRL_AUTO 2 79 80 #define USB_INTEL_XUSB2PR 0xD0 81 #define PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI 0x9c31 82 83 static const char * const ashs_ids[] = { "ATK4001", "ATK4002", NULL }; 84 85 static bool ashs_present(void) 86 { 87 int i = 0; 88 while (ashs_ids[i]) { 89 if (acpi_dev_found(ashs_ids[i++])) 90 return true; 91 } 92 return false; 93 } 94 95 struct bios_args { 96 u32 arg0; 97 u32 arg1; 98 } __packed; 99 100 /* 101 * Struct that's used for all methods called via AGFN. Naming is 102 * identically to the AML code. 103 */ 104 struct agfn_args { 105 u16 mfun; /* probably "Multi-function" to be called */ 106 u16 sfun; /* probably "Sub-function" to be called */ 107 u16 len; /* size of the hole struct, including subfunction fields */ 108 u8 stas; /* not used by now */ 109 u8 err; /* zero on success */ 110 } __packed; 111 112 /* struct used for calling fan read and write methods */ 113 struct fan_args { 114 struct agfn_args agfn; /* common fields */ 115 u8 fan; /* fan number: 0: set auto mode 1: 1st fan */ 116 u32 speed; /* read: RPM/100 - write: 0-255 */ 117 } __packed; 118 119 /* 120 * <platform>/ - debugfs root directory 121 * dev_id - current dev_id 122 * ctrl_param - current ctrl_param 123 * method_id - current method_id 124 * devs - call DEVS(dev_id, ctrl_param) and print result 125 * dsts - call DSTS(dev_id) and print result 126 * call - call method_id(dev_id, ctrl_param) and print result 127 */ 128 struct asus_wmi_debug { 129 struct dentry *root; 130 u32 method_id; 131 u32 dev_id; 132 u32 ctrl_param; 133 }; 134 135 struct asus_rfkill { 136 struct asus_wmi *asus; 137 struct rfkill *rfkill; 138 u32 dev_id; 139 }; 140 141 struct asus_wmi { 142 int dsts_id; 143 int spec; 144 int sfun; 145 146 struct input_dev *inputdev; 147 struct backlight_device *backlight_device; 148 struct platform_device *platform_device; 149 150 struct led_classdev wlan_led; 151 int wlan_led_wk; 152 struct led_classdev tpd_led; 153 int tpd_led_wk; 154 struct led_classdev kbd_led; 155 int kbd_led_wk; 156 struct led_classdev lightbar_led; 157 int lightbar_led_wk; 158 struct workqueue_struct *led_workqueue; 159 struct work_struct tpd_led_work; 160 struct work_struct wlan_led_work; 161 struct work_struct lightbar_led_work; 162 163 struct asus_rfkill wlan; 164 struct asus_rfkill bluetooth; 165 struct asus_rfkill wimax; 166 struct asus_rfkill wwan3g; 167 struct asus_rfkill gps; 168 struct asus_rfkill uwb; 169 170 bool asus_hwmon_fan_manual_mode; 171 int asus_hwmon_num_fans; 172 int asus_hwmon_pwm; 173 174 struct hotplug_slot hotplug_slot; 175 struct mutex hotplug_lock; 176 struct mutex wmi_lock; 177 struct workqueue_struct *hotplug_workqueue; 178 struct work_struct hotplug_work; 179 180 struct asus_wmi_debug debug; 181 182 struct asus_wmi_driver *driver; 183 }; 184 185 static int asus_wmi_input_init(struct asus_wmi *asus) 186 { 187 int err; 188 189 asus->inputdev = input_allocate_device(); 190 if (!asus->inputdev) 191 return -ENOMEM; 192 193 asus->inputdev->name = asus->driver->input_name; 194 asus->inputdev->phys = asus->driver->input_phys; 195 asus->inputdev->id.bustype = BUS_HOST; 196 asus->inputdev->dev.parent = &asus->platform_device->dev; 197 set_bit(EV_REP, asus->inputdev->evbit); 198 199 err = sparse_keymap_setup(asus->inputdev, asus->driver->keymap, NULL); 200 if (err) 201 goto err_free_dev; 202 203 err = input_register_device(asus->inputdev); 204 if (err) 205 goto err_free_dev; 206 207 return 0; 208 209 err_free_dev: 210 input_free_device(asus->inputdev); 211 return err; 212 } 213 214 static void asus_wmi_input_exit(struct asus_wmi *asus) 215 { 216 if (asus->inputdev) 217 input_unregister_device(asus->inputdev); 218 219 asus->inputdev = NULL; 220 } 221 222 int asus_wmi_evaluate_method(u32 method_id, u32 arg0, u32 arg1, u32 *retval) 223 { 224 struct bios_args args = { 225 .arg0 = arg0, 226 .arg1 = arg1, 227 }; 228 struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; 229 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 230 acpi_status status; 231 union acpi_object *obj; 232 u32 tmp = 0; 233 234 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 0, method_id, 235 &input, &output); 236 237 if (ACPI_FAILURE(status)) 238 goto exit; 239 240 obj = (union acpi_object *)output.pointer; 241 if (obj && obj->type == ACPI_TYPE_INTEGER) 242 tmp = (u32) obj->integer.value; 243 244 if (retval) 245 *retval = tmp; 246 247 kfree(obj); 248 249 exit: 250 if (ACPI_FAILURE(status)) 251 return -EIO; 252 253 if (tmp == ASUS_WMI_UNSUPPORTED_METHOD) 254 return -ENODEV; 255 256 return 0; 257 } 258 EXPORT_SYMBOL_GPL(asus_wmi_evaluate_method); 259 260 static int asus_wmi_evaluate_method_agfn(const struct acpi_buffer args) 261 { 262 struct acpi_buffer input; 263 u64 phys_addr; 264 u32 retval; 265 u32 status = -1; 266 267 /* 268 * Copy to dma capable address otherwise memory corruption occurs as 269 * bios has to be able to access it. 270 */ 271 input.pointer = kzalloc(args.length, GFP_DMA | GFP_KERNEL); 272 input.length = args.length; 273 if (!input.pointer) 274 return -ENOMEM; 275 phys_addr = virt_to_phys(input.pointer); 276 memcpy(input.pointer, args.pointer, args.length); 277 278 status = asus_wmi_evaluate_method(ASUS_WMI_METHODID_AGFN, 279 phys_addr, 0, &retval); 280 if (!status) 281 memcpy(args.pointer, input.pointer, args.length); 282 283 kfree(input.pointer); 284 if (status) 285 return -ENXIO; 286 287 return retval; 288 } 289 290 static int asus_wmi_get_devstate(struct asus_wmi *asus, u32 dev_id, u32 *retval) 291 { 292 return asus_wmi_evaluate_method(asus->dsts_id, dev_id, 0, retval); 293 } 294 295 static int asus_wmi_set_devstate(u32 dev_id, u32 ctrl_param, 296 u32 *retval) 297 { 298 return asus_wmi_evaluate_method(ASUS_WMI_METHODID_DEVS, dev_id, 299 ctrl_param, retval); 300 } 301 302 /* Helper for special devices with magic return codes */ 303 static int asus_wmi_get_devstate_bits(struct asus_wmi *asus, 304 u32 dev_id, u32 mask) 305 { 306 u32 retval = 0; 307 int err; 308 309 err = asus_wmi_get_devstate(asus, dev_id, &retval); 310 311 if (err < 0) 312 return err; 313 314 if (!(retval & ASUS_WMI_DSTS_PRESENCE_BIT)) 315 return -ENODEV; 316 317 if (mask == ASUS_WMI_DSTS_STATUS_BIT) { 318 if (retval & ASUS_WMI_DSTS_UNKNOWN_BIT) 319 return -ENODEV; 320 } 321 322 return retval & mask; 323 } 324 325 static int asus_wmi_get_devstate_simple(struct asus_wmi *asus, u32 dev_id) 326 { 327 return asus_wmi_get_devstate_bits(asus, dev_id, 328 ASUS_WMI_DSTS_STATUS_BIT); 329 } 330 331 /* 332 * LEDs 333 */ 334 /* 335 * These functions actually update the LED's, and are called from a 336 * workqueue. By doing this as separate work rather than when the LED 337 * subsystem asks, we avoid messing with the Asus ACPI stuff during a 338 * potentially bad time, such as a timer interrupt. 339 */ 340 static void tpd_led_update(struct work_struct *work) 341 { 342 int ctrl_param; 343 struct asus_wmi *asus; 344 345 asus = container_of(work, struct asus_wmi, tpd_led_work); 346 347 ctrl_param = asus->tpd_led_wk; 348 asus_wmi_set_devstate(ASUS_WMI_DEVID_TOUCHPAD_LED, ctrl_param, NULL); 349 } 350 351 static void tpd_led_set(struct led_classdev *led_cdev, 352 enum led_brightness value) 353 { 354 struct asus_wmi *asus; 355 356 asus = container_of(led_cdev, struct asus_wmi, tpd_led); 357 358 asus->tpd_led_wk = !!value; 359 queue_work(asus->led_workqueue, &asus->tpd_led_work); 360 } 361 362 static int read_tpd_led_state(struct asus_wmi *asus) 363 { 364 return asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_TOUCHPAD_LED); 365 } 366 367 static enum led_brightness tpd_led_get(struct led_classdev *led_cdev) 368 { 369 struct asus_wmi *asus; 370 371 asus = container_of(led_cdev, struct asus_wmi, tpd_led); 372 373 return read_tpd_led_state(asus); 374 } 375 376 static void kbd_led_update(struct asus_wmi *asus) 377 { 378 int ctrl_param = 0; 379 380 /* 381 * bits 0-2: level 382 * bit 7: light on/off 383 */ 384 if (asus->kbd_led_wk > 0) 385 ctrl_param = 0x80 | (asus->kbd_led_wk & 0x7F); 386 387 asus_wmi_set_devstate(ASUS_WMI_DEVID_KBD_BACKLIGHT, ctrl_param, NULL); 388 } 389 390 static int kbd_led_read(struct asus_wmi *asus, int *level, int *env) 391 { 392 int retval; 393 394 /* 395 * bits 0-2: level 396 * bit 7: light on/off 397 * bit 8-10: environment (0: dark, 1: normal, 2: light) 398 * bit 17: status unknown 399 */ 400 retval = asus_wmi_get_devstate_bits(asus, ASUS_WMI_DEVID_KBD_BACKLIGHT, 401 0xFFFF); 402 403 /* Unknown status is considered as off */ 404 if (retval == 0x8000) 405 retval = 0; 406 407 if (retval >= 0) { 408 if (level) 409 *level = retval & 0x7F; 410 if (env) 411 *env = (retval >> 8) & 0x7F; 412 retval = 0; 413 } 414 415 return retval; 416 } 417 418 static void do_kbd_led_set(struct led_classdev *led_cdev, int value) 419 { 420 struct asus_wmi *asus; 421 int max_level; 422 423 asus = container_of(led_cdev, struct asus_wmi, kbd_led); 424 max_level = asus->kbd_led.max_brightness; 425 426 if (value > max_level) 427 value = max_level; 428 else if (value < 0) 429 value = 0; 430 431 asus->kbd_led_wk = value; 432 kbd_led_update(asus); 433 } 434 435 static void kbd_led_set(struct led_classdev *led_cdev, 436 enum led_brightness value) 437 { 438 do_kbd_led_set(led_cdev, value); 439 } 440 441 static void kbd_led_set_by_kbd(struct asus_wmi *asus, enum led_brightness value) 442 { 443 struct led_classdev *led_cdev = &asus->kbd_led; 444 445 do_kbd_led_set(led_cdev, value); 446 led_classdev_notify_brightness_hw_changed(led_cdev, asus->kbd_led_wk); 447 } 448 449 static enum led_brightness kbd_led_get(struct led_classdev *led_cdev) 450 { 451 struct asus_wmi *asus; 452 int retval, value; 453 454 asus = container_of(led_cdev, struct asus_wmi, kbd_led); 455 456 retval = kbd_led_read(asus, &value, NULL); 457 458 if (retval < 0) 459 return retval; 460 461 return value; 462 } 463 464 static int wlan_led_unknown_state(struct asus_wmi *asus) 465 { 466 u32 result; 467 468 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result); 469 470 return result & ASUS_WMI_DSTS_UNKNOWN_BIT; 471 } 472 473 static int wlan_led_presence(struct asus_wmi *asus) 474 { 475 u32 result; 476 477 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result); 478 479 return result & ASUS_WMI_DSTS_PRESENCE_BIT; 480 } 481 482 static void wlan_led_update(struct work_struct *work) 483 { 484 int ctrl_param; 485 struct asus_wmi *asus; 486 487 asus = container_of(work, struct asus_wmi, wlan_led_work); 488 489 ctrl_param = asus->wlan_led_wk; 490 asus_wmi_set_devstate(ASUS_WMI_DEVID_WIRELESS_LED, ctrl_param, NULL); 491 } 492 493 static void wlan_led_set(struct led_classdev *led_cdev, 494 enum led_brightness value) 495 { 496 struct asus_wmi *asus; 497 498 asus = container_of(led_cdev, struct asus_wmi, wlan_led); 499 500 asus->wlan_led_wk = !!value; 501 queue_work(asus->led_workqueue, &asus->wlan_led_work); 502 } 503 504 static enum led_brightness wlan_led_get(struct led_classdev *led_cdev) 505 { 506 struct asus_wmi *asus; 507 u32 result; 508 509 asus = container_of(led_cdev, struct asus_wmi, wlan_led); 510 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WIRELESS_LED, &result); 511 512 return result & ASUS_WMI_DSTS_BRIGHTNESS_MASK; 513 } 514 515 static void lightbar_led_update(struct work_struct *work) 516 { 517 struct asus_wmi *asus; 518 int ctrl_param; 519 520 asus = container_of(work, struct asus_wmi, lightbar_led_work); 521 522 ctrl_param = asus->lightbar_led_wk; 523 asus_wmi_set_devstate(ASUS_WMI_DEVID_LIGHTBAR, ctrl_param, NULL); 524 } 525 526 static void lightbar_led_set(struct led_classdev *led_cdev, 527 enum led_brightness value) 528 { 529 struct asus_wmi *asus; 530 531 asus = container_of(led_cdev, struct asus_wmi, lightbar_led); 532 533 asus->lightbar_led_wk = !!value; 534 queue_work(asus->led_workqueue, &asus->lightbar_led_work); 535 } 536 537 static enum led_brightness lightbar_led_get(struct led_classdev *led_cdev) 538 { 539 struct asus_wmi *asus; 540 u32 result; 541 542 asus = container_of(led_cdev, struct asus_wmi, lightbar_led); 543 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result); 544 545 return result & ASUS_WMI_DSTS_LIGHTBAR_MASK; 546 } 547 548 static int lightbar_led_presence(struct asus_wmi *asus) 549 { 550 u32 result; 551 552 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_LIGHTBAR, &result); 553 554 return result & ASUS_WMI_DSTS_PRESENCE_BIT; 555 } 556 557 static void asus_wmi_led_exit(struct asus_wmi *asus) 558 { 559 if (!IS_ERR_OR_NULL(asus->kbd_led.dev)) 560 led_classdev_unregister(&asus->kbd_led); 561 if (!IS_ERR_OR_NULL(asus->tpd_led.dev)) 562 led_classdev_unregister(&asus->tpd_led); 563 if (!IS_ERR_OR_NULL(asus->wlan_led.dev)) 564 led_classdev_unregister(&asus->wlan_led); 565 if (!IS_ERR_OR_NULL(asus->lightbar_led.dev)) 566 led_classdev_unregister(&asus->lightbar_led); 567 if (asus->led_workqueue) 568 destroy_workqueue(asus->led_workqueue); 569 } 570 571 static int asus_wmi_led_init(struct asus_wmi *asus) 572 { 573 int rv = 0, led_val; 574 575 asus->led_workqueue = create_singlethread_workqueue("led_workqueue"); 576 if (!asus->led_workqueue) 577 return -ENOMEM; 578 579 if (read_tpd_led_state(asus) >= 0) { 580 INIT_WORK(&asus->tpd_led_work, tpd_led_update); 581 582 asus->tpd_led.name = "asus::touchpad"; 583 asus->tpd_led.brightness_set = tpd_led_set; 584 asus->tpd_led.brightness_get = tpd_led_get; 585 asus->tpd_led.max_brightness = 1; 586 587 rv = led_classdev_register(&asus->platform_device->dev, 588 &asus->tpd_led); 589 if (rv) 590 goto error; 591 } 592 593 led_val = kbd_led_read(asus, NULL, NULL); 594 if (led_val >= 0) { 595 asus->kbd_led_wk = led_val; 596 asus->kbd_led.name = "asus::kbd_backlight"; 597 asus->kbd_led.flags = LED_BRIGHT_HW_CHANGED; 598 asus->kbd_led.brightness_set = kbd_led_set; 599 asus->kbd_led.brightness_get = kbd_led_get; 600 asus->kbd_led.max_brightness = 3; 601 602 rv = led_classdev_register(&asus->platform_device->dev, 603 &asus->kbd_led); 604 if (rv) 605 goto error; 606 } 607 608 if (wlan_led_presence(asus) && (asus->driver->quirks->wapf > 0)) { 609 INIT_WORK(&asus->wlan_led_work, wlan_led_update); 610 611 asus->wlan_led.name = "asus::wlan"; 612 asus->wlan_led.brightness_set = wlan_led_set; 613 if (!wlan_led_unknown_state(asus)) 614 asus->wlan_led.brightness_get = wlan_led_get; 615 asus->wlan_led.flags = LED_CORE_SUSPENDRESUME; 616 asus->wlan_led.max_brightness = 1; 617 asus->wlan_led.default_trigger = "asus-wlan"; 618 619 rv = led_classdev_register(&asus->platform_device->dev, 620 &asus->wlan_led); 621 if (rv) 622 goto error; 623 } 624 625 if (lightbar_led_presence(asus)) { 626 INIT_WORK(&asus->lightbar_led_work, lightbar_led_update); 627 628 asus->lightbar_led.name = "asus::lightbar"; 629 asus->lightbar_led.brightness_set = lightbar_led_set; 630 asus->lightbar_led.brightness_get = lightbar_led_get; 631 asus->lightbar_led.max_brightness = 1; 632 633 rv = led_classdev_register(&asus->platform_device->dev, 634 &asus->lightbar_led); 635 } 636 637 error: 638 if (rv) 639 asus_wmi_led_exit(asus); 640 641 return rv; 642 } 643 644 645 /* 646 * PCI hotplug (for wlan rfkill) 647 */ 648 static bool asus_wlan_rfkill_blocked(struct asus_wmi *asus) 649 { 650 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN); 651 652 if (result < 0) 653 return false; 654 return !result; 655 } 656 657 static void asus_rfkill_hotplug(struct asus_wmi *asus) 658 { 659 struct pci_dev *dev; 660 struct pci_bus *bus; 661 bool blocked; 662 bool absent; 663 u32 l; 664 665 mutex_lock(&asus->wmi_lock); 666 blocked = asus_wlan_rfkill_blocked(asus); 667 mutex_unlock(&asus->wmi_lock); 668 669 mutex_lock(&asus->hotplug_lock); 670 pci_lock_rescan_remove(); 671 672 if (asus->wlan.rfkill) 673 rfkill_set_sw_state(asus->wlan.rfkill, blocked); 674 675 if (asus->hotplug_slot.ops) { 676 bus = pci_find_bus(0, 1); 677 if (!bus) { 678 pr_warn("Unable to find PCI bus 1?\n"); 679 goto out_unlock; 680 } 681 682 if (pci_bus_read_config_dword(bus, 0, PCI_VENDOR_ID, &l)) { 683 pr_err("Unable to read PCI config space?\n"); 684 goto out_unlock; 685 } 686 absent = (l == 0xffffffff); 687 688 if (blocked != absent) { 689 pr_warn("BIOS says wireless lan is %s, " 690 "but the pci device is %s\n", 691 blocked ? "blocked" : "unblocked", 692 absent ? "absent" : "present"); 693 pr_warn("skipped wireless hotplug as probably " 694 "inappropriate for this model\n"); 695 goto out_unlock; 696 } 697 698 if (!blocked) { 699 dev = pci_get_slot(bus, 0); 700 if (dev) { 701 /* Device already present */ 702 pci_dev_put(dev); 703 goto out_unlock; 704 } 705 dev = pci_scan_single_device(bus, 0); 706 if (dev) { 707 pci_bus_assign_resources(bus); 708 pci_bus_add_device(dev); 709 } 710 } else { 711 dev = pci_get_slot(bus, 0); 712 if (dev) { 713 pci_stop_and_remove_bus_device(dev); 714 pci_dev_put(dev); 715 } 716 } 717 } 718 719 out_unlock: 720 pci_unlock_rescan_remove(); 721 mutex_unlock(&asus->hotplug_lock); 722 } 723 724 static void asus_rfkill_notify(acpi_handle handle, u32 event, void *data) 725 { 726 struct asus_wmi *asus = data; 727 728 if (event != ACPI_NOTIFY_BUS_CHECK) 729 return; 730 731 /* 732 * We can't call directly asus_rfkill_hotplug because most 733 * of the time WMBC is still being executed and not reetrant. 734 * There is currently no way to tell ACPICA that we want this 735 * method to be serialized, we schedule a asus_rfkill_hotplug 736 * call later, in a safer context. 737 */ 738 queue_work(asus->hotplug_workqueue, &asus->hotplug_work); 739 } 740 741 static int asus_register_rfkill_notifier(struct asus_wmi *asus, char *node) 742 { 743 acpi_status status; 744 acpi_handle handle; 745 746 status = acpi_get_handle(NULL, node, &handle); 747 748 if (ACPI_SUCCESS(status)) { 749 status = acpi_install_notify_handler(handle, 750 ACPI_SYSTEM_NOTIFY, 751 asus_rfkill_notify, asus); 752 if (ACPI_FAILURE(status)) 753 pr_warn("Failed to register notify on %s\n", node); 754 } else 755 return -ENODEV; 756 757 return 0; 758 } 759 760 static void asus_unregister_rfkill_notifier(struct asus_wmi *asus, char *node) 761 { 762 acpi_status status = AE_OK; 763 acpi_handle handle; 764 765 status = acpi_get_handle(NULL, node, &handle); 766 767 if (ACPI_SUCCESS(status)) { 768 status = acpi_remove_notify_handler(handle, 769 ACPI_SYSTEM_NOTIFY, 770 asus_rfkill_notify); 771 if (ACPI_FAILURE(status)) 772 pr_err("Error removing rfkill notify handler %s\n", 773 node); 774 } 775 } 776 777 static int asus_get_adapter_status(struct hotplug_slot *hotplug_slot, 778 u8 *value) 779 { 780 struct asus_wmi *asus = container_of(hotplug_slot, 781 struct asus_wmi, hotplug_slot); 782 int result = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN); 783 784 if (result < 0) 785 return result; 786 787 *value = !!result; 788 return 0; 789 } 790 791 static const struct hotplug_slot_ops asus_hotplug_slot_ops = { 792 .get_adapter_status = asus_get_adapter_status, 793 .get_power_status = asus_get_adapter_status, 794 }; 795 796 static void asus_hotplug_work(struct work_struct *work) 797 { 798 struct asus_wmi *asus; 799 800 asus = container_of(work, struct asus_wmi, hotplug_work); 801 asus_rfkill_hotplug(asus); 802 } 803 804 static int asus_setup_pci_hotplug(struct asus_wmi *asus) 805 { 806 int ret = -ENOMEM; 807 struct pci_bus *bus = pci_find_bus(0, 1); 808 809 if (!bus) { 810 pr_err("Unable to find wifi PCI bus\n"); 811 return -ENODEV; 812 } 813 814 asus->hotplug_workqueue = 815 create_singlethread_workqueue("hotplug_workqueue"); 816 if (!asus->hotplug_workqueue) 817 goto error_workqueue; 818 819 INIT_WORK(&asus->hotplug_work, asus_hotplug_work); 820 821 asus->hotplug_slot.ops = &asus_hotplug_slot_ops; 822 823 ret = pci_hp_register(&asus->hotplug_slot, bus, 0, "asus-wifi"); 824 if (ret) { 825 pr_err("Unable to register hotplug slot - %d\n", ret); 826 goto error_register; 827 } 828 829 return 0; 830 831 error_register: 832 asus->hotplug_slot.ops = NULL; 833 destroy_workqueue(asus->hotplug_workqueue); 834 error_workqueue: 835 return ret; 836 } 837 838 /* 839 * Rfkill devices 840 */ 841 static int asus_rfkill_set(void *data, bool blocked) 842 { 843 struct asus_rfkill *priv = data; 844 u32 ctrl_param = !blocked; 845 u32 dev_id = priv->dev_id; 846 847 /* 848 * If the user bit is set, BIOS can't set and record the wlan status, 849 * it will report the value read from id ASUS_WMI_DEVID_WLAN_LED 850 * while we query the wlan status through WMI(ASUS_WMI_DEVID_WLAN). 851 * So, we have to record wlan status in id ASUS_WMI_DEVID_WLAN_LED 852 * while setting the wlan status through WMI. 853 * This is also the behavior that windows app will do. 854 */ 855 if ((dev_id == ASUS_WMI_DEVID_WLAN) && 856 priv->asus->driver->wlan_ctrl_by_user) 857 dev_id = ASUS_WMI_DEVID_WLAN_LED; 858 859 return asus_wmi_set_devstate(dev_id, ctrl_param, NULL); 860 } 861 862 static void asus_rfkill_query(struct rfkill *rfkill, void *data) 863 { 864 struct asus_rfkill *priv = data; 865 int result; 866 867 result = asus_wmi_get_devstate_simple(priv->asus, priv->dev_id); 868 869 if (result < 0) 870 return; 871 872 rfkill_set_sw_state(priv->rfkill, !result); 873 } 874 875 static int asus_rfkill_wlan_set(void *data, bool blocked) 876 { 877 struct asus_rfkill *priv = data; 878 struct asus_wmi *asus = priv->asus; 879 int ret; 880 881 /* 882 * This handler is enabled only if hotplug is enabled. 883 * In this case, the asus_wmi_set_devstate() will 884 * trigger a wmi notification and we need to wait 885 * this call to finish before being able to call 886 * any wmi method 887 */ 888 mutex_lock(&asus->wmi_lock); 889 ret = asus_rfkill_set(data, blocked); 890 mutex_unlock(&asus->wmi_lock); 891 return ret; 892 } 893 894 static const struct rfkill_ops asus_rfkill_wlan_ops = { 895 .set_block = asus_rfkill_wlan_set, 896 .query = asus_rfkill_query, 897 }; 898 899 static const struct rfkill_ops asus_rfkill_ops = { 900 .set_block = asus_rfkill_set, 901 .query = asus_rfkill_query, 902 }; 903 904 static int asus_new_rfkill(struct asus_wmi *asus, 905 struct asus_rfkill *arfkill, 906 const char *name, enum rfkill_type type, int dev_id) 907 { 908 int result = asus_wmi_get_devstate_simple(asus, dev_id); 909 struct rfkill **rfkill = &arfkill->rfkill; 910 911 if (result < 0) 912 return result; 913 914 arfkill->dev_id = dev_id; 915 arfkill->asus = asus; 916 917 if (dev_id == ASUS_WMI_DEVID_WLAN && 918 asus->driver->quirks->hotplug_wireless) 919 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type, 920 &asus_rfkill_wlan_ops, arfkill); 921 else 922 *rfkill = rfkill_alloc(name, &asus->platform_device->dev, type, 923 &asus_rfkill_ops, arfkill); 924 925 if (!*rfkill) 926 return -EINVAL; 927 928 if ((dev_id == ASUS_WMI_DEVID_WLAN) && 929 (asus->driver->quirks->wapf > 0)) 930 rfkill_set_led_trigger_name(*rfkill, "asus-wlan"); 931 932 rfkill_init_sw_state(*rfkill, !result); 933 result = rfkill_register(*rfkill); 934 if (result) { 935 rfkill_destroy(*rfkill); 936 *rfkill = NULL; 937 return result; 938 } 939 return 0; 940 } 941 942 static void asus_wmi_rfkill_exit(struct asus_wmi *asus) 943 { 944 if (asus->driver->wlan_ctrl_by_user && ashs_present()) 945 return; 946 947 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P5"); 948 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P6"); 949 asus_unregister_rfkill_notifier(asus, "\\_SB.PCI0.P0P7"); 950 if (asus->wlan.rfkill) { 951 rfkill_unregister(asus->wlan.rfkill); 952 rfkill_destroy(asus->wlan.rfkill); 953 asus->wlan.rfkill = NULL; 954 } 955 /* 956 * Refresh pci hotplug in case the rfkill state was changed after 957 * asus_unregister_rfkill_notifier() 958 */ 959 asus_rfkill_hotplug(asus); 960 if (asus->hotplug_slot.ops) 961 pci_hp_deregister(&asus->hotplug_slot); 962 if (asus->hotplug_workqueue) 963 destroy_workqueue(asus->hotplug_workqueue); 964 965 if (asus->bluetooth.rfkill) { 966 rfkill_unregister(asus->bluetooth.rfkill); 967 rfkill_destroy(asus->bluetooth.rfkill); 968 asus->bluetooth.rfkill = NULL; 969 } 970 if (asus->wimax.rfkill) { 971 rfkill_unregister(asus->wimax.rfkill); 972 rfkill_destroy(asus->wimax.rfkill); 973 asus->wimax.rfkill = NULL; 974 } 975 if (asus->wwan3g.rfkill) { 976 rfkill_unregister(asus->wwan3g.rfkill); 977 rfkill_destroy(asus->wwan3g.rfkill); 978 asus->wwan3g.rfkill = NULL; 979 } 980 if (asus->gps.rfkill) { 981 rfkill_unregister(asus->gps.rfkill); 982 rfkill_destroy(asus->gps.rfkill); 983 asus->gps.rfkill = NULL; 984 } 985 if (asus->uwb.rfkill) { 986 rfkill_unregister(asus->uwb.rfkill); 987 rfkill_destroy(asus->uwb.rfkill); 988 asus->uwb.rfkill = NULL; 989 } 990 } 991 992 static int asus_wmi_rfkill_init(struct asus_wmi *asus) 993 { 994 int result = 0; 995 996 mutex_init(&asus->hotplug_lock); 997 mutex_init(&asus->wmi_lock); 998 999 result = asus_new_rfkill(asus, &asus->wlan, "asus-wlan", 1000 RFKILL_TYPE_WLAN, ASUS_WMI_DEVID_WLAN); 1001 1002 if (result && result != -ENODEV) 1003 goto exit; 1004 1005 result = asus_new_rfkill(asus, &asus->bluetooth, 1006 "asus-bluetooth", RFKILL_TYPE_BLUETOOTH, 1007 ASUS_WMI_DEVID_BLUETOOTH); 1008 1009 if (result && result != -ENODEV) 1010 goto exit; 1011 1012 result = asus_new_rfkill(asus, &asus->wimax, "asus-wimax", 1013 RFKILL_TYPE_WIMAX, ASUS_WMI_DEVID_WIMAX); 1014 1015 if (result && result != -ENODEV) 1016 goto exit; 1017 1018 result = asus_new_rfkill(asus, &asus->wwan3g, "asus-wwan3g", 1019 RFKILL_TYPE_WWAN, ASUS_WMI_DEVID_WWAN3G); 1020 1021 if (result && result != -ENODEV) 1022 goto exit; 1023 1024 result = asus_new_rfkill(asus, &asus->gps, "asus-gps", 1025 RFKILL_TYPE_GPS, ASUS_WMI_DEVID_GPS); 1026 1027 if (result && result != -ENODEV) 1028 goto exit; 1029 1030 result = asus_new_rfkill(asus, &asus->uwb, "asus-uwb", 1031 RFKILL_TYPE_UWB, ASUS_WMI_DEVID_UWB); 1032 1033 if (result && result != -ENODEV) 1034 goto exit; 1035 1036 if (!asus->driver->quirks->hotplug_wireless) 1037 goto exit; 1038 1039 result = asus_setup_pci_hotplug(asus); 1040 /* 1041 * If we get -EBUSY then something else is handling the PCI hotplug - 1042 * don't fail in this case 1043 */ 1044 if (result == -EBUSY) 1045 result = 0; 1046 1047 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P5"); 1048 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P6"); 1049 asus_register_rfkill_notifier(asus, "\\_SB.PCI0.P0P7"); 1050 /* 1051 * Refresh pci hotplug in case the rfkill state was changed during 1052 * setup. 1053 */ 1054 asus_rfkill_hotplug(asus); 1055 1056 exit: 1057 if (result && result != -ENODEV) 1058 asus_wmi_rfkill_exit(asus); 1059 1060 if (result == -ENODEV) 1061 result = 0; 1062 1063 return result; 1064 } 1065 1066 static void asus_wmi_set_xusb2pr(struct asus_wmi *asus) 1067 { 1068 struct pci_dev *xhci_pdev; 1069 u32 orig_ports_available; 1070 u32 ports_available = asus->driver->quirks->xusb2pr; 1071 1072 xhci_pdev = pci_get_device(PCI_VENDOR_ID_INTEL, 1073 PCI_DEVICE_ID_INTEL_LYNXPOINT_LP_XHCI, 1074 NULL); 1075 1076 if (!xhci_pdev) 1077 return; 1078 1079 pci_read_config_dword(xhci_pdev, USB_INTEL_XUSB2PR, 1080 &orig_ports_available); 1081 1082 pci_write_config_dword(xhci_pdev, USB_INTEL_XUSB2PR, 1083 cpu_to_le32(ports_available)); 1084 1085 pr_info("set USB_INTEL_XUSB2PR old: 0x%04x, new: 0x%04x\n", 1086 orig_ports_available, ports_available); 1087 } 1088 1089 /* 1090 * Some devices dont support or have borcken get_als method 1091 * but still support set method. 1092 */ 1093 static void asus_wmi_set_als(void) 1094 { 1095 asus_wmi_set_devstate(ASUS_WMI_DEVID_ALS_ENABLE, 1, NULL); 1096 } 1097 1098 /* 1099 * Hwmon device 1100 */ 1101 static int asus_hwmon_agfn_fan_speed_read(struct asus_wmi *asus, int fan, 1102 int *speed) 1103 { 1104 struct fan_args args = { 1105 .agfn.len = sizeof(args), 1106 .agfn.mfun = ASUS_FAN_MFUN, 1107 .agfn.sfun = ASUS_FAN_SFUN_READ, 1108 .fan = fan, 1109 .speed = 0, 1110 }; 1111 struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; 1112 int status; 1113 1114 if (fan != 1) 1115 return -EINVAL; 1116 1117 status = asus_wmi_evaluate_method_agfn(input); 1118 1119 if (status || args.agfn.err) 1120 return -ENXIO; 1121 1122 if (speed) 1123 *speed = args.speed; 1124 1125 return 0; 1126 } 1127 1128 static int asus_hwmon_agfn_fan_speed_write(struct asus_wmi *asus, int fan, 1129 int *speed) 1130 { 1131 struct fan_args args = { 1132 .agfn.len = sizeof(args), 1133 .agfn.mfun = ASUS_FAN_MFUN, 1134 .agfn.sfun = ASUS_FAN_SFUN_WRITE, 1135 .fan = fan, 1136 .speed = speed ? *speed : 0, 1137 }; 1138 struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; 1139 int status; 1140 1141 /* 1: for setting 1st fan's speed 0: setting auto mode */ 1142 if (fan != 1 && fan != 0) 1143 return -EINVAL; 1144 1145 status = asus_wmi_evaluate_method_agfn(input); 1146 1147 if (status || args.agfn.err) 1148 return -ENXIO; 1149 1150 if (speed && fan == 1) 1151 asus->asus_hwmon_pwm = *speed; 1152 1153 return 0; 1154 } 1155 1156 /* 1157 * Check if we can read the speed of one fan. If true we assume we can also 1158 * control it. 1159 */ 1160 static int asus_hwmon_get_fan_number(struct asus_wmi *asus, int *num_fans) 1161 { 1162 int status; 1163 int speed = 0; 1164 1165 *num_fans = 0; 1166 1167 status = asus_hwmon_agfn_fan_speed_read(asus, 1, &speed); 1168 if (!status) 1169 *num_fans = 1; 1170 1171 return 0; 1172 } 1173 1174 static int asus_hwmon_fan_set_auto(struct asus_wmi *asus) 1175 { 1176 int status; 1177 1178 status = asus_hwmon_agfn_fan_speed_write(asus, 0, NULL); 1179 if (status) 1180 return -ENXIO; 1181 1182 asus->asus_hwmon_fan_manual_mode = false; 1183 1184 return 0; 1185 } 1186 1187 static int asus_hwmon_fan_rpm_show(struct device *dev, int fan) 1188 { 1189 struct asus_wmi *asus = dev_get_drvdata(dev); 1190 int value; 1191 int ret; 1192 1193 /* no speed readable on manual mode */ 1194 if (asus->asus_hwmon_fan_manual_mode) 1195 return -ENXIO; 1196 1197 ret = asus_hwmon_agfn_fan_speed_read(asus, fan+1, &value); 1198 if (ret) { 1199 pr_warn("reading fan speed failed: %d\n", ret); 1200 return -ENXIO; 1201 } 1202 1203 return value; 1204 } 1205 1206 static void asus_hwmon_pwm_show(struct asus_wmi *asus, int fan, int *value) 1207 { 1208 int err; 1209 1210 if (asus->asus_hwmon_pwm >= 0) { 1211 *value = asus->asus_hwmon_pwm; 1212 return; 1213 } 1214 1215 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_FAN_CTRL, value); 1216 if (err < 0) 1217 return; 1218 1219 *value &= 0xFF; 1220 1221 if (*value == 1) /* Low Speed */ 1222 *value = 85; 1223 else if (*value == 2) 1224 *value = 170; 1225 else if (*value == 3) 1226 *value = 255; 1227 else if (*value) { 1228 pr_err("Unknown fan speed %#x\n", *value); 1229 *value = -1; 1230 } 1231 } 1232 1233 static ssize_t pwm1_show(struct device *dev, 1234 struct device_attribute *attr, 1235 char *buf) 1236 { 1237 struct asus_wmi *asus = dev_get_drvdata(dev); 1238 int value; 1239 1240 asus_hwmon_pwm_show(asus, 0, &value); 1241 1242 return sprintf(buf, "%d\n", value); 1243 } 1244 1245 static ssize_t pwm1_store(struct device *dev, 1246 struct device_attribute *attr, 1247 const char *buf, size_t count) { 1248 struct asus_wmi *asus = dev_get_drvdata(dev); 1249 int value; 1250 int state; 1251 int ret; 1252 1253 ret = kstrtouint(buf, 10, &value); 1254 1255 if (ret) 1256 return ret; 1257 1258 value = clamp(value, 0, 255); 1259 1260 state = asus_hwmon_agfn_fan_speed_write(asus, 1, &value); 1261 if (state) 1262 pr_warn("Setting fan speed failed: %d\n", state); 1263 else 1264 asus->asus_hwmon_fan_manual_mode = true; 1265 1266 return count; 1267 } 1268 1269 static ssize_t fan1_input_show(struct device *dev, 1270 struct device_attribute *attr, 1271 char *buf) 1272 { 1273 int value = asus_hwmon_fan_rpm_show(dev, 0); 1274 1275 return sprintf(buf, "%d\n", value < 0 ? -1 : value*100); 1276 1277 } 1278 1279 static ssize_t pwm1_enable_show(struct device *dev, 1280 struct device_attribute *attr, 1281 char *buf) 1282 { 1283 struct asus_wmi *asus = dev_get_drvdata(dev); 1284 1285 if (asus->asus_hwmon_fan_manual_mode) 1286 return sprintf(buf, "%d\n", ASUS_FAN_CTRL_MANUAL); 1287 1288 return sprintf(buf, "%d\n", ASUS_FAN_CTRL_AUTO); 1289 } 1290 1291 static ssize_t pwm1_enable_store(struct device *dev, 1292 struct device_attribute *attr, 1293 const char *buf, size_t count) 1294 { 1295 struct asus_wmi *asus = dev_get_drvdata(dev); 1296 int status = 0; 1297 int state; 1298 int ret; 1299 1300 ret = kstrtouint(buf, 10, &state); 1301 1302 if (ret) 1303 return ret; 1304 1305 if (state == ASUS_FAN_CTRL_MANUAL) 1306 asus->asus_hwmon_fan_manual_mode = true; 1307 else 1308 status = asus_hwmon_fan_set_auto(asus); 1309 1310 if (status) 1311 return status; 1312 1313 return count; 1314 } 1315 1316 static ssize_t fan1_label_show(struct device *dev, 1317 struct device_attribute *attr, 1318 char *buf) 1319 { 1320 return sprintf(buf, "%s\n", ASUS_FAN_DESC); 1321 } 1322 1323 static ssize_t asus_hwmon_temp1(struct device *dev, 1324 struct device_attribute *attr, 1325 char *buf) 1326 { 1327 struct asus_wmi *asus = dev_get_drvdata(dev); 1328 u32 value; 1329 int err; 1330 1331 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_THERMAL_CTRL, &value); 1332 1333 if (err < 0) 1334 return err; 1335 1336 value = DECI_KELVIN_TO_CELSIUS((value & 0xFFFF)) * 1000; 1337 1338 return sprintf(buf, "%d\n", value); 1339 } 1340 1341 /* Fan1 */ 1342 static DEVICE_ATTR_RW(pwm1); 1343 static DEVICE_ATTR_RW(pwm1_enable); 1344 static DEVICE_ATTR_RO(fan1_input); 1345 static DEVICE_ATTR_RO(fan1_label); 1346 1347 /* Temperature */ 1348 static DEVICE_ATTR(temp1_input, S_IRUGO, asus_hwmon_temp1, NULL); 1349 1350 static struct attribute *hwmon_attributes[] = { 1351 &dev_attr_pwm1.attr, 1352 &dev_attr_pwm1_enable.attr, 1353 &dev_attr_fan1_input.attr, 1354 &dev_attr_fan1_label.attr, 1355 1356 &dev_attr_temp1_input.attr, 1357 NULL 1358 }; 1359 1360 static umode_t asus_hwmon_sysfs_is_visible(struct kobject *kobj, 1361 struct attribute *attr, int idx) 1362 { 1363 struct device *dev = container_of(kobj, struct device, kobj); 1364 struct platform_device *pdev = to_platform_device(dev->parent); 1365 struct asus_wmi *asus = platform_get_drvdata(pdev); 1366 int dev_id = -1; 1367 int fan_attr = -1; 1368 u32 value = ASUS_WMI_UNSUPPORTED_METHOD; 1369 bool ok = true; 1370 1371 if (attr == &dev_attr_pwm1.attr) 1372 dev_id = ASUS_WMI_DEVID_FAN_CTRL; 1373 else if (attr == &dev_attr_temp1_input.attr) 1374 dev_id = ASUS_WMI_DEVID_THERMAL_CTRL; 1375 1376 1377 if (attr == &dev_attr_fan1_input.attr 1378 || attr == &dev_attr_fan1_label.attr 1379 || attr == &dev_attr_pwm1.attr 1380 || attr == &dev_attr_pwm1_enable.attr) { 1381 fan_attr = 1; 1382 } 1383 1384 if (dev_id != -1) { 1385 int err = asus_wmi_get_devstate(asus, dev_id, &value); 1386 1387 if (err < 0 && fan_attr == -1) 1388 return 0; /* can't return negative here */ 1389 } 1390 1391 if (dev_id == ASUS_WMI_DEVID_FAN_CTRL) { 1392 /* 1393 * We need to find a better way, probably using sfun, 1394 * bits or spec ... 1395 * Currently we disable it if: 1396 * - ASUS_WMI_UNSUPPORTED_METHOD is returned 1397 * - reverved bits are non-zero 1398 * - sfun and presence bit are not set 1399 */ 1400 if (value == ASUS_WMI_UNSUPPORTED_METHOD || value & 0xFFF80000 1401 || (!asus->sfun && !(value & ASUS_WMI_DSTS_PRESENCE_BIT))) 1402 ok = false; 1403 else 1404 ok = fan_attr <= asus->asus_hwmon_num_fans; 1405 } else if (dev_id == ASUS_WMI_DEVID_THERMAL_CTRL) { 1406 /* If value is zero, something is clearly wrong */ 1407 if (!value) 1408 ok = false; 1409 } else if (fan_attr <= asus->asus_hwmon_num_fans && fan_attr != -1) { 1410 ok = true; 1411 } else { 1412 ok = false; 1413 } 1414 1415 return ok ? attr->mode : 0; 1416 } 1417 1418 static const struct attribute_group hwmon_attribute_group = { 1419 .is_visible = asus_hwmon_sysfs_is_visible, 1420 .attrs = hwmon_attributes 1421 }; 1422 __ATTRIBUTE_GROUPS(hwmon_attribute); 1423 1424 static int asus_wmi_hwmon_init(struct asus_wmi *asus) 1425 { 1426 struct device *hwmon; 1427 1428 hwmon = hwmon_device_register_with_groups(&asus->platform_device->dev, 1429 "asus", asus, 1430 hwmon_attribute_groups); 1431 if (IS_ERR(hwmon)) { 1432 pr_err("Could not register asus hwmon device\n"); 1433 return PTR_ERR(hwmon); 1434 } 1435 return 0; 1436 } 1437 1438 /* 1439 * Backlight 1440 */ 1441 static int read_backlight_power(struct asus_wmi *asus) 1442 { 1443 int ret; 1444 if (asus->driver->quirks->store_backlight_power) 1445 ret = !asus->driver->panel_power; 1446 else 1447 ret = asus_wmi_get_devstate_simple(asus, 1448 ASUS_WMI_DEVID_BACKLIGHT); 1449 1450 if (ret < 0) 1451 return ret; 1452 1453 return ret ? FB_BLANK_UNBLANK : FB_BLANK_POWERDOWN; 1454 } 1455 1456 static int read_brightness_max(struct asus_wmi *asus) 1457 { 1458 u32 retval; 1459 int err; 1460 1461 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval); 1462 1463 if (err < 0) 1464 return err; 1465 1466 retval = retval & ASUS_WMI_DSTS_MAX_BRIGTH_MASK; 1467 retval >>= 8; 1468 1469 if (!retval) 1470 return -ENODEV; 1471 1472 return retval; 1473 } 1474 1475 static int read_brightness(struct backlight_device *bd) 1476 { 1477 struct asus_wmi *asus = bl_get_data(bd); 1478 u32 retval; 1479 int err; 1480 1481 err = asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_BRIGHTNESS, &retval); 1482 1483 if (err < 0) 1484 return err; 1485 1486 return retval & ASUS_WMI_DSTS_BRIGHTNESS_MASK; 1487 } 1488 1489 static u32 get_scalar_command(struct backlight_device *bd) 1490 { 1491 struct asus_wmi *asus = bl_get_data(bd); 1492 u32 ctrl_param = 0; 1493 1494 if ((asus->driver->brightness < bd->props.brightness) || 1495 bd->props.brightness == bd->props.max_brightness) 1496 ctrl_param = 0x00008001; 1497 else if ((asus->driver->brightness > bd->props.brightness) || 1498 bd->props.brightness == 0) 1499 ctrl_param = 0x00008000; 1500 1501 asus->driver->brightness = bd->props.brightness; 1502 1503 return ctrl_param; 1504 } 1505 1506 static int update_bl_status(struct backlight_device *bd) 1507 { 1508 struct asus_wmi *asus = bl_get_data(bd); 1509 u32 ctrl_param; 1510 int power, err = 0; 1511 1512 power = read_backlight_power(asus); 1513 if (power != -ENODEV && bd->props.power != power) { 1514 ctrl_param = !!(bd->props.power == FB_BLANK_UNBLANK); 1515 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 1516 ctrl_param, NULL); 1517 if (asus->driver->quirks->store_backlight_power) 1518 asus->driver->panel_power = bd->props.power; 1519 1520 /* When using scalar brightness, updating the brightness 1521 * will mess with the backlight power */ 1522 if (asus->driver->quirks->scalar_panel_brightness) 1523 return err; 1524 } 1525 1526 if (asus->driver->quirks->scalar_panel_brightness) 1527 ctrl_param = get_scalar_command(bd); 1528 else 1529 ctrl_param = bd->props.brightness; 1530 1531 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BRIGHTNESS, 1532 ctrl_param, NULL); 1533 1534 return err; 1535 } 1536 1537 static const struct backlight_ops asus_wmi_bl_ops = { 1538 .get_brightness = read_brightness, 1539 .update_status = update_bl_status, 1540 }; 1541 1542 static int asus_wmi_backlight_notify(struct asus_wmi *asus, int code) 1543 { 1544 struct backlight_device *bd = asus->backlight_device; 1545 int old = bd->props.brightness; 1546 int new = old; 1547 1548 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX) 1549 new = code - NOTIFY_BRNUP_MIN + 1; 1550 else if (code >= NOTIFY_BRNDOWN_MIN && code <= NOTIFY_BRNDOWN_MAX) 1551 new = code - NOTIFY_BRNDOWN_MIN; 1552 1553 bd->props.brightness = new; 1554 backlight_update_status(bd); 1555 backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY); 1556 1557 return old; 1558 } 1559 1560 static int asus_wmi_backlight_init(struct asus_wmi *asus) 1561 { 1562 struct backlight_device *bd; 1563 struct backlight_properties props; 1564 int max; 1565 int power; 1566 1567 max = read_brightness_max(asus); 1568 if (max < 0) 1569 return max; 1570 1571 power = read_backlight_power(asus); 1572 1573 if (power == -ENODEV) 1574 power = FB_BLANK_UNBLANK; 1575 else if (power < 0) 1576 return power; 1577 1578 memset(&props, 0, sizeof(struct backlight_properties)); 1579 props.type = BACKLIGHT_PLATFORM; 1580 props.max_brightness = max; 1581 bd = backlight_device_register(asus->driver->name, 1582 &asus->platform_device->dev, asus, 1583 &asus_wmi_bl_ops, &props); 1584 if (IS_ERR(bd)) { 1585 pr_err("Could not register backlight device\n"); 1586 return PTR_ERR(bd); 1587 } 1588 1589 asus->backlight_device = bd; 1590 1591 if (asus->driver->quirks->store_backlight_power) 1592 asus->driver->panel_power = power; 1593 1594 bd->props.brightness = read_brightness(bd); 1595 bd->props.power = power; 1596 backlight_update_status(bd); 1597 1598 asus->driver->brightness = bd->props.brightness; 1599 1600 return 0; 1601 } 1602 1603 static void asus_wmi_backlight_exit(struct asus_wmi *asus) 1604 { 1605 backlight_device_unregister(asus->backlight_device); 1606 1607 asus->backlight_device = NULL; 1608 } 1609 1610 static int is_display_toggle(int code) 1611 { 1612 /* display toggle keys */ 1613 if ((code >= 0x61 && code <= 0x67) || 1614 (code >= 0x8c && code <= 0x93) || 1615 (code >= 0xa0 && code <= 0xa7) || 1616 (code >= 0xd0 && code <= 0xd5)) 1617 return 1; 1618 1619 return 0; 1620 } 1621 1622 static void asus_wmi_notify(u32 value, void *context) 1623 { 1624 struct asus_wmi *asus = context; 1625 struct acpi_buffer response = { ACPI_ALLOCATE_BUFFER, NULL }; 1626 union acpi_object *obj; 1627 acpi_status status; 1628 int code; 1629 int orig_code; 1630 unsigned int key_value = 1; 1631 bool autorelease = 1; 1632 1633 status = wmi_get_event_data(value, &response); 1634 if (status != AE_OK) { 1635 pr_err("bad event status 0x%x\n", status); 1636 return; 1637 } 1638 1639 obj = (union acpi_object *)response.pointer; 1640 1641 if (!obj || obj->type != ACPI_TYPE_INTEGER) 1642 goto exit; 1643 1644 code = obj->integer.value; 1645 orig_code = code; 1646 1647 if (asus->driver->key_filter) { 1648 asus->driver->key_filter(asus->driver, &code, &key_value, 1649 &autorelease); 1650 if (code == ASUS_WMI_KEY_IGNORE) 1651 goto exit; 1652 } 1653 1654 if (code >= NOTIFY_BRNUP_MIN && code <= NOTIFY_BRNUP_MAX) 1655 code = ASUS_WMI_BRN_UP; 1656 else if (code >= NOTIFY_BRNDOWN_MIN && 1657 code <= NOTIFY_BRNDOWN_MAX) 1658 code = ASUS_WMI_BRN_DOWN; 1659 1660 if (code == ASUS_WMI_BRN_DOWN || code == ASUS_WMI_BRN_UP) { 1661 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) { 1662 asus_wmi_backlight_notify(asus, orig_code); 1663 goto exit; 1664 } 1665 } 1666 1667 if (code == NOTIFY_KBD_BRTUP) { 1668 kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1); 1669 goto exit; 1670 } 1671 if (code == NOTIFY_KBD_BRTDWN) { 1672 kbd_led_set_by_kbd(asus, asus->kbd_led_wk - 1); 1673 goto exit; 1674 } 1675 if (code == NOTIFY_KBD_BRTTOGGLE) { 1676 if (asus->kbd_led_wk == asus->kbd_led.max_brightness) 1677 kbd_led_set_by_kbd(asus, 0); 1678 else 1679 kbd_led_set_by_kbd(asus, asus->kbd_led_wk + 1); 1680 goto exit; 1681 } 1682 1683 if (is_display_toggle(code) && 1684 asus->driver->quirks->no_display_toggle) 1685 goto exit; 1686 1687 if (!sparse_keymap_report_event(asus->inputdev, code, 1688 key_value, autorelease)) 1689 pr_info("Unknown key %x pressed\n", code); 1690 1691 exit: 1692 kfree(obj); 1693 } 1694 1695 /* 1696 * Sys helpers 1697 */ 1698 static int parse_arg(const char *buf, unsigned long count, int *val) 1699 { 1700 if (!count) 1701 return 0; 1702 if (sscanf(buf, "%i", val) != 1) 1703 return -EINVAL; 1704 return count; 1705 } 1706 1707 static ssize_t store_sys_wmi(struct asus_wmi *asus, int devid, 1708 const char *buf, size_t count) 1709 { 1710 u32 retval; 1711 int rv, err, value; 1712 1713 value = asus_wmi_get_devstate_simple(asus, devid); 1714 if (value < 0) 1715 return value; 1716 1717 rv = parse_arg(buf, count, &value); 1718 err = asus_wmi_set_devstate(devid, value, &retval); 1719 1720 if (err < 0) 1721 return err; 1722 1723 return rv; 1724 } 1725 1726 static ssize_t show_sys_wmi(struct asus_wmi *asus, int devid, char *buf) 1727 { 1728 int value = asus_wmi_get_devstate_simple(asus, devid); 1729 1730 if (value < 0) 1731 return value; 1732 1733 return sprintf(buf, "%d\n", value); 1734 } 1735 1736 #define ASUS_WMI_CREATE_DEVICE_ATTR(_name, _mode, _cm) \ 1737 static ssize_t show_##_name(struct device *dev, \ 1738 struct device_attribute *attr, \ 1739 char *buf) \ 1740 { \ 1741 struct asus_wmi *asus = dev_get_drvdata(dev); \ 1742 \ 1743 return show_sys_wmi(asus, _cm, buf); \ 1744 } \ 1745 static ssize_t store_##_name(struct device *dev, \ 1746 struct device_attribute *attr, \ 1747 const char *buf, size_t count) \ 1748 { \ 1749 struct asus_wmi *asus = dev_get_drvdata(dev); \ 1750 \ 1751 return store_sys_wmi(asus, _cm, buf, count); \ 1752 } \ 1753 static struct device_attribute dev_attr_##_name = { \ 1754 .attr = { \ 1755 .name = __stringify(_name), \ 1756 .mode = _mode }, \ 1757 .show = show_##_name, \ 1758 .store = store_##_name, \ 1759 } 1760 1761 ASUS_WMI_CREATE_DEVICE_ATTR(touchpad, 0644, ASUS_WMI_DEVID_TOUCHPAD); 1762 ASUS_WMI_CREATE_DEVICE_ATTR(camera, 0644, ASUS_WMI_DEVID_CAMERA); 1763 ASUS_WMI_CREATE_DEVICE_ATTR(cardr, 0644, ASUS_WMI_DEVID_CARDREADER); 1764 ASUS_WMI_CREATE_DEVICE_ATTR(lid_resume, 0644, ASUS_WMI_DEVID_LID_RESUME); 1765 ASUS_WMI_CREATE_DEVICE_ATTR(als_enable, 0644, ASUS_WMI_DEVID_ALS_ENABLE); 1766 1767 static ssize_t cpufv_store(struct device *dev, struct device_attribute *attr, 1768 const char *buf, size_t count) 1769 { 1770 int value, rv; 1771 1772 if (!count || sscanf(buf, "%i", &value) != 1) 1773 return -EINVAL; 1774 if (value < 0 || value > 2) 1775 return -EINVAL; 1776 1777 rv = asus_wmi_evaluate_method(ASUS_WMI_METHODID_CFVS, value, 0, NULL); 1778 if (rv < 0) 1779 return rv; 1780 1781 return count; 1782 } 1783 1784 static DEVICE_ATTR_WO(cpufv); 1785 1786 static struct attribute *platform_attributes[] = { 1787 &dev_attr_cpufv.attr, 1788 &dev_attr_camera.attr, 1789 &dev_attr_cardr.attr, 1790 &dev_attr_touchpad.attr, 1791 &dev_attr_lid_resume.attr, 1792 &dev_attr_als_enable.attr, 1793 NULL 1794 }; 1795 1796 static umode_t asus_sysfs_is_visible(struct kobject *kobj, 1797 struct attribute *attr, int idx) 1798 { 1799 struct device *dev = container_of(kobj, struct device, kobj); 1800 struct asus_wmi *asus = dev_get_drvdata(dev); 1801 bool ok = true; 1802 int devid = -1; 1803 1804 if (attr == &dev_attr_camera.attr) 1805 devid = ASUS_WMI_DEVID_CAMERA; 1806 else if (attr == &dev_attr_cardr.attr) 1807 devid = ASUS_WMI_DEVID_CARDREADER; 1808 else if (attr == &dev_attr_touchpad.attr) 1809 devid = ASUS_WMI_DEVID_TOUCHPAD; 1810 else if (attr == &dev_attr_lid_resume.attr) 1811 devid = ASUS_WMI_DEVID_LID_RESUME; 1812 else if (attr == &dev_attr_als_enable.attr) 1813 devid = ASUS_WMI_DEVID_ALS_ENABLE; 1814 1815 if (devid != -1) 1816 ok = !(asus_wmi_get_devstate_simple(asus, devid) < 0); 1817 1818 return ok ? attr->mode : 0; 1819 } 1820 1821 static const struct attribute_group platform_attribute_group = { 1822 .is_visible = asus_sysfs_is_visible, 1823 .attrs = platform_attributes 1824 }; 1825 1826 static void asus_wmi_sysfs_exit(struct platform_device *device) 1827 { 1828 sysfs_remove_group(&device->dev.kobj, &platform_attribute_group); 1829 } 1830 1831 static int asus_wmi_sysfs_init(struct platform_device *device) 1832 { 1833 return sysfs_create_group(&device->dev.kobj, &platform_attribute_group); 1834 } 1835 1836 /* 1837 * Platform device 1838 */ 1839 static int asus_wmi_platform_init(struct asus_wmi *asus) 1840 { 1841 int rv; 1842 1843 /* INIT enable hotkeys on some models */ 1844 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_INIT, 0, 0, &rv)) 1845 pr_info("Initialization: %#x\n", rv); 1846 1847 /* We don't know yet what to do with this version... */ 1848 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SPEC, 0, 0x9, &rv)) { 1849 pr_info("BIOS WMI version: %d.%d\n", rv >> 16, rv & 0xFF); 1850 asus->spec = rv; 1851 } 1852 1853 /* 1854 * The SFUN method probably allows the original driver to get the list 1855 * of features supported by a given model. For now, 0x0100 or 0x0800 1856 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card. 1857 * The significance of others is yet to be found. 1858 */ 1859 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_SFUN, 0, 0, &rv)) { 1860 pr_info("SFUN value: %#x\n", rv); 1861 asus->sfun = rv; 1862 } 1863 1864 /* 1865 * Eee PC and Notebooks seems to have different method_id for DSTS, 1866 * but it may also be related to the BIOS's SPEC. 1867 * Note, on most Eeepc, there is no way to check if a method exist 1868 * or note, while on notebooks, they returns 0xFFFFFFFE on failure, 1869 * but once again, SPEC may probably be used for that kind of things. 1870 */ 1871 if (!asus_wmi_evaluate_method(ASUS_WMI_METHODID_DSTS, 0, 0, NULL)) 1872 asus->dsts_id = ASUS_WMI_METHODID_DSTS; 1873 else 1874 asus->dsts_id = ASUS_WMI_METHODID_DSTS2; 1875 1876 /* CWAP allow to define the behavior of the Fn+F2 key, 1877 * this method doesn't seems to be present on Eee PCs */ 1878 if (asus->driver->quirks->wapf >= 0) 1879 asus_wmi_set_devstate(ASUS_WMI_DEVID_CWAP, 1880 asus->driver->quirks->wapf, NULL); 1881 1882 return asus_wmi_sysfs_init(asus->platform_device); 1883 } 1884 1885 static void asus_wmi_platform_exit(struct asus_wmi *asus) 1886 { 1887 asus_wmi_sysfs_exit(asus->platform_device); 1888 } 1889 1890 /* 1891 * debugfs 1892 */ 1893 struct asus_wmi_debugfs_node { 1894 struct asus_wmi *asus; 1895 char *name; 1896 int (*show) (struct seq_file *m, void *data); 1897 }; 1898 1899 static int show_dsts(struct seq_file *m, void *data) 1900 { 1901 struct asus_wmi *asus = m->private; 1902 int err; 1903 u32 retval = -1; 1904 1905 err = asus_wmi_get_devstate(asus, asus->debug.dev_id, &retval); 1906 1907 if (err < 0) 1908 return err; 1909 1910 seq_printf(m, "DSTS(%#x) = %#x\n", asus->debug.dev_id, retval); 1911 1912 return 0; 1913 } 1914 1915 static int show_devs(struct seq_file *m, void *data) 1916 { 1917 struct asus_wmi *asus = m->private; 1918 int err; 1919 u32 retval = -1; 1920 1921 err = asus_wmi_set_devstate(asus->debug.dev_id, asus->debug.ctrl_param, 1922 &retval); 1923 1924 if (err < 0) 1925 return err; 1926 1927 seq_printf(m, "DEVS(%#x, %#x) = %#x\n", asus->debug.dev_id, 1928 asus->debug.ctrl_param, retval); 1929 1930 return 0; 1931 } 1932 1933 static int show_call(struct seq_file *m, void *data) 1934 { 1935 struct asus_wmi *asus = m->private; 1936 struct bios_args args = { 1937 .arg0 = asus->debug.dev_id, 1938 .arg1 = asus->debug.ctrl_param, 1939 }; 1940 struct acpi_buffer input = { (acpi_size) sizeof(args), &args }; 1941 struct acpi_buffer output = { ACPI_ALLOCATE_BUFFER, NULL }; 1942 union acpi_object *obj; 1943 acpi_status status; 1944 1945 status = wmi_evaluate_method(ASUS_WMI_MGMT_GUID, 1946 0, asus->debug.method_id, 1947 &input, &output); 1948 1949 if (ACPI_FAILURE(status)) 1950 return -EIO; 1951 1952 obj = (union acpi_object *)output.pointer; 1953 if (obj && obj->type == ACPI_TYPE_INTEGER) 1954 seq_printf(m, "%#x(%#x, %#x) = %#x\n", asus->debug.method_id, 1955 asus->debug.dev_id, asus->debug.ctrl_param, 1956 (u32) obj->integer.value); 1957 else 1958 seq_printf(m, "%#x(%#x, %#x) = t:%d\n", asus->debug.method_id, 1959 asus->debug.dev_id, asus->debug.ctrl_param, 1960 obj ? obj->type : -1); 1961 1962 kfree(obj); 1963 1964 return 0; 1965 } 1966 1967 static struct asus_wmi_debugfs_node asus_wmi_debug_files[] = { 1968 {NULL, "devs", show_devs}, 1969 {NULL, "dsts", show_dsts}, 1970 {NULL, "call", show_call}, 1971 }; 1972 1973 static int asus_wmi_debugfs_open(struct inode *inode, struct file *file) 1974 { 1975 struct asus_wmi_debugfs_node *node = inode->i_private; 1976 1977 return single_open(file, node->show, node->asus); 1978 } 1979 1980 static const struct file_operations asus_wmi_debugfs_io_ops = { 1981 .owner = THIS_MODULE, 1982 .open = asus_wmi_debugfs_open, 1983 .read = seq_read, 1984 .llseek = seq_lseek, 1985 .release = single_release, 1986 }; 1987 1988 static void asus_wmi_debugfs_exit(struct asus_wmi *asus) 1989 { 1990 debugfs_remove_recursive(asus->debug.root); 1991 } 1992 1993 static int asus_wmi_debugfs_init(struct asus_wmi *asus) 1994 { 1995 struct dentry *dent; 1996 int i; 1997 1998 asus->debug.root = debugfs_create_dir(asus->driver->name, NULL); 1999 if (!asus->debug.root) { 2000 pr_err("failed to create debugfs directory\n"); 2001 goto error_debugfs; 2002 } 2003 2004 dent = debugfs_create_x32("method_id", S_IRUGO | S_IWUSR, 2005 asus->debug.root, &asus->debug.method_id); 2006 if (!dent) 2007 goto error_debugfs; 2008 2009 dent = debugfs_create_x32("dev_id", S_IRUGO | S_IWUSR, 2010 asus->debug.root, &asus->debug.dev_id); 2011 if (!dent) 2012 goto error_debugfs; 2013 2014 dent = debugfs_create_x32("ctrl_param", S_IRUGO | S_IWUSR, 2015 asus->debug.root, &asus->debug.ctrl_param); 2016 if (!dent) 2017 goto error_debugfs; 2018 2019 for (i = 0; i < ARRAY_SIZE(asus_wmi_debug_files); i++) { 2020 struct asus_wmi_debugfs_node *node = &asus_wmi_debug_files[i]; 2021 2022 node->asus = asus; 2023 dent = debugfs_create_file(node->name, S_IFREG | S_IRUGO, 2024 asus->debug.root, node, 2025 &asus_wmi_debugfs_io_ops); 2026 if (!dent) { 2027 pr_err("failed to create debug file: %s\n", node->name); 2028 goto error_debugfs; 2029 } 2030 } 2031 2032 return 0; 2033 2034 error_debugfs: 2035 asus_wmi_debugfs_exit(asus); 2036 return -ENOMEM; 2037 } 2038 2039 static int asus_wmi_fan_init(struct asus_wmi *asus) 2040 { 2041 int status; 2042 2043 asus->asus_hwmon_pwm = -1; 2044 asus->asus_hwmon_num_fans = -1; 2045 asus->asus_hwmon_fan_manual_mode = false; 2046 2047 status = asus_hwmon_get_fan_number(asus, &asus->asus_hwmon_num_fans); 2048 if (status) { 2049 asus->asus_hwmon_num_fans = 0; 2050 pr_warn("Could not determine number of fans: %d\n", status); 2051 return -ENXIO; 2052 } 2053 2054 pr_info("Number of fans: %d\n", asus->asus_hwmon_num_fans); 2055 return 0; 2056 } 2057 2058 /* 2059 * WMI Driver 2060 */ 2061 static int asus_wmi_add(struct platform_device *pdev) 2062 { 2063 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver); 2064 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv); 2065 struct asus_wmi *asus; 2066 const char *chassis_type; 2067 acpi_status status; 2068 int err; 2069 u32 result; 2070 2071 asus = kzalloc(sizeof(struct asus_wmi), GFP_KERNEL); 2072 if (!asus) 2073 return -ENOMEM; 2074 2075 asus->driver = wdrv; 2076 asus->platform_device = pdev; 2077 wdrv->platform_device = pdev; 2078 platform_set_drvdata(asus->platform_device, asus); 2079 2080 if (wdrv->detect_quirks) 2081 wdrv->detect_quirks(asus->driver); 2082 2083 err = asus_wmi_platform_init(asus); 2084 if (err) 2085 goto fail_platform; 2086 2087 err = asus_wmi_input_init(asus); 2088 if (err) 2089 goto fail_input; 2090 2091 err = asus_wmi_fan_init(asus); /* probably no problems on error */ 2092 asus_hwmon_fan_set_auto(asus); 2093 2094 err = asus_wmi_hwmon_init(asus); 2095 if (err) 2096 goto fail_hwmon; 2097 2098 err = asus_wmi_led_init(asus); 2099 if (err) 2100 goto fail_leds; 2101 2102 asus_wmi_get_devstate(asus, ASUS_WMI_DEVID_WLAN, &result); 2103 if (result & (ASUS_WMI_DSTS_PRESENCE_BIT | ASUS_WMI_DSTS_USER_BIT)) 2104 asus->driver->wlan_ctrl_by_user = 1; 2105 2106 if (!(asus->driver->wlan_ctrl_by_user && ashs_present())) { 2107 err = asus_wmi_rfkill_init(asus); 2108 if (err) 2109 goto fail_rfkill; 2110 } 2111 2112 if (asus->driver->quirks->wmi_force_als_set) 2113 asus_wmi_set_als(); 2114 2115 /* Some Asus desktop boards export an acpi-video backlight interface, 2116 stop this from showing up */ 2117 chassis_type = dmi_get_system_info(DMI_CHASSIS_TYPE); 2118 if (chassis_type && !strcmp(chassis_type, "3")) 2119 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); 2120 2121 if (asus->driver->quirks->wmi_backlight_power) 2122 acpi_video_set_dmi_backlight_type(acpi_backlight_vendor); 2123 2124 if (asus->driver->quirks->wmi_backlight_native) 2125 acpi_video_set_dmi_backlight_type(acpi_backlight_native); 2126 2127 if (asus->driver->quirks->xusb2pr) 2128 asus_wmi_set_xusb2pr(asus); 2129 2130 if (acpi_video_get_backlight_type() == acpi_backlight_vendor) { 2131 err = asus_wmi_backlight_init(asus); 2132 if (err && err != -ENODEV) 2133 goto fail_backlight; 2134 } else 2135 err = asus_wmi_set_devstate(ASUS_WMI_DEVID_BACKLIGHT, 2, NULL); 2136 2137 status = wmi_install_notify_handler(asus->driver->event_guid, 2138 asus_wmi_notify, asus); 2139 if (ACPI_FAILURE(status)) { 2140 pr_err("Unable to register notify handler - %d\n", status); 2141 err = -ENODEV; 2142 goto fail_wmi_handler; 2143 } 2144 2145 err = asus_wmi_debugfs_init(asus); 2146 if (err) 2147 goto fail_debugfs; 2148 2149 return 0; 2150 2151 fail_debugfs: 2152 wmi_remove_notify_handler(asus->driver->event_guid); 2153 fail_wmi_handler: 2154 asus_wmi_backlight_exit(asus); 2155 fail_backlight: 2156 asus_wmi_rfkill_exit(asus); 2157 fail_rfkill: 2158 asus_wmi_led_exit(asus); 2159 fail_leds: 2160 fail_hwmon: 2161 asus_wmi_input_exit(asus); 2162 fail_input: 2163 asus_wmi_platform_exit(asus); 2164 fail_platform: 2165 kfree(asus); 2166 return err; 2167 } 2168 2169 static int asus_wmi_remove(struct platform_device *device) 2170 { 2171 struct asus_wmi *asus; 2172 2173 asus = platform_get_drvdata(device); 2174 wmi_remove_notify_handler(asus->driver->event_guid); 2175 asus_wmi_backlight_exit(asus); 2176 asus_wmi_input_exit(asus); 2177 asus_wmi_led_exit(asus); 2178 asus_wmi_rfkill_exit(asus); 2179 asus_wmi_debugfs_exit(asus); 2180 asus_wmi_platform_exit(asus); 2181 asus_hwmon_fan_set_auto(asus); 2182 2183 kfree(asus); 2184 return 0; 2185 } 2186 2187 /* 2188 * Platform driver - hibernate/resume callbacks 2189 */ 2190 static int asus_hotk_thaw(struct device *device) 2191 { 2192 struct asus_wmi *asus = dev_get_drvdata(device); 2193 2194 if (asus->wlan.rfkill) { 2195 bool wlan; 2196 2197 /* 2198 * Work around bios bug - acpi _PTS turns off the wireless led 2199 * during suspend. Normally it restores it on resume, but 2200 * we should kick it ourselves in case hibernation is aborted. 2201 */ 2202 wlan = asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WLAN); 2203 asus_wmi_set_devstate(ASUS_WMI_DEVID_WLAN, wlan, NULL); 2204 } 2205 2206 return 0; 2207 } 2208 2209 static int asus_hotk_resume(struct device *device) 2210 { 2211 struct asus_wmi *asus = dev_get_drvdata(device); 2212 2213 if (!IS_ERR_OR_NULL(asus->kbd_led.dev)) 2214 kbd_led_update(asus); 2215 2216 return 0; 2217 } 2218 2219 static int asus_hotk_restore(struct device *device) 2220 { 2221 struct asus_wmi *asus = dev_get_drvdata(device); 2222 int bl; 2223 2224 /* Refresh both wlan rfkill state and pci hotplug */ 2225 if (asus->wlan.rfkill) 2226 asus_rfkill_hotplug(asus); 2227 2228 if (asus->bluetooth.rfkill) { 2229 bl = !asus_wmi_get_devstate_simple(asus, 2230 ASUS_WMI_DEVID_BLUETOOTH); 2231 rfkill_set_sw_state(asus->bluetooth.rfkill, bl); 2232 } 2233 if (asus->wimax.rfkill) { 2234 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WIMAX); 2235 rfkill_set_sw_state(asus->wimax.rfkill, bl); 2236 } 2237 if (asus->wwan3g.rfkill) { 2238 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_WWAN3G); 2239 rfkill_set_sw_state(asus->wwan3g.rfkill, bl); 2240 } 2241 if (asus->gps.rfkill) { 2242 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_GPS); 2243 rfkill_set_sw_state(asus->gps.rfkill, bl); 2244 } 2245 if (asus->uwb.rfkill) { 2246 bl = !asus_wmi_get_devstate_simple(asus, ASUS_WMI_DEVID_UWB); 2247 rfkill_set_sw_state(asus->uwb.rfkill, bl); 2248 } 2249 if (!IS_ERR_OR_NULL(asus->kbd_led.dev)) 2250 kbd_led_update(asus); 2251 2252 return 0; 2253 } 2254 2255 static const struct dev_pm_ops asus_pm_ops = { 2256 .thaw = asus_hotk_thaw, 2257 .restore = asus_hotk_restore, 2258 .resume = asus_hotk_resume, 2259 }; 2260 2261 static int asus_wmi_probe(struct platform_device *pdev) 2262 { 2263 struct platform_driver *pdrv = to_platform_driver(pdev->dev.driver); 2264 struct asus_wmi_driver *wdrv = to_asus_wmi_driver(pdrv); 2265 int ret; 2266 2267 if (!wmi_has_guid(ASUS_WMI_MGMT_GUID)) { 2268 pr_warn("ASUS Management GUID not found\n"); 2269 return -ENODEV; 2270 } 2271 2272 if (wdrv->event_guid && !wmi_has_guid(wdrv->event_guid)) { 2273 pr_warn("ASUS Event GUID not found\n"); 2274 return -ENODEV; 2275 } 2276 2277 if (wdrv->probe) { 2278 ret = wdrv->probe(pdev); 2279 if (ret) 2280 return ret; 2281 } 2282 2283 return asus_wmi_add(pdev); 2284 } 2285 2286 static bool used; 2287 2288 int __init_or_module asus_wmi_register_driver(struct asus_wmi_driver *driver) 2289 { 2290 struct platform_driver *platform_driver; 2291 struct platform_device *platform_device; 2292 2293 if (used) 2294 return -EBUSY; 2295 2296 platform_driver = &driver->platform_driver; 2297 platform_driver->remove = asus_wmi_remove; 2298 platform_driver->driver.owner = driver->owner; 2299 platform_driver->driver.name = driver->name; 2300 platform_driver->driver.pm = &asus_pm_ops; 2301 2302 platform_device = platform_create_bundle(platform_driver, 2303 asus_wmi_probe, 2304 NULL, 0, NULL, 0); 2305 if (IS_ERR(platform_device)) 2306 return PTR_ERR(platform_device); 2307 2308 used = true; 2309 return 0; 2310 } 2311 EXPORT_SYMBOL_GPL(asus_wmi_register_driver); 2312 2313 void asus_wmi_unregister_driver(struct asus_wmi_driver *driver) 2314 { 2315 platform_device_unregister(driver->platform_device); 2316 platform_driver_unregister(&driver->platform_driver); 2317 used = false; 2318 } 2319 EXPORT_SYMBOL_GPL(asus_wmi_unregister_driver); 2320 2321 static int __init asus_wmi_init(void) 2322 { 2323 pr_info("ASUS WMI generic driver loaded\n"); 2324 return 0; 2325 } 2326 2327 static void __exit asus_wmi_exit(void) 2328 { 2329 pr_info("ASUS WMI generic driver unloaded\n"); 2330 } 2331 2332 module_init(asus_wmi_init); 2333 module_exit(asus_wmi_exit); 2334