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