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