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