asus-laptop.c revision 91687cc89af4c447483ec65097809c38c8622639
1/* 2 * asus-laptop.c - Asus Laptop Support 3 * 4 * 5 * Copyright (C) 2002-2005 Julien Lerouge, 2003-2006 Karol Kozimor 6 * Copyright (C) 2006-2007 Corentin Chary 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU General Public License as published by 10 * the Free Software Foundation; either version 2 of the License, or 11 * (at your option) any later version. 12 * 13 * This program is distributed in the hope that it will be useful, 14 * but WITHOUT ANY WARRANTY; without even the implied warranty of 15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 * GNU General Public License for more details. 17 * 18 * You should have received a copy of the GNU General Public License 19 * along with this program; if not, write to the Free Software 20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 * 22 * 23 * The development page for this driver is located at 24 * http://sourceforge.net/projects/acpi4asus/ 25 * 26 * Credits: 27 * Pontus Fuchs - Helper functions, cleanup 28 * Johann Wiesner - Small compile fixes 29 * John Belmonte - ACPI code for Toshiba laptop was a good starting point. 30 * Eric Burghard - LED display support for W1N 31 * Josh Green - Light Sens support 32 * Thomas Tuttle - His first patch for led support was very helpfull 33 * Sam Lin - GPS support 34 */ 35 36#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt 37 38#include <linux/kernel.h> 39#include <linux/module.h> 40#include <linux/init.h> 41#include <linux/types.h> 42#include <linux/err.h> 43#include <linux/proc_fs.h> 44#include <linux/backlight.h> 45#include <linux/fb.h> 46#include <linux/leds.h> 47#include <linux/platform_device.h> 48#include <acpi/acpi_drivers.h> 49#include <acpi/acpi_bus.h> 50#include <asm/uaccess.h> 51#include <linux/input.h> 52 53#define ASUS_LAPTOP_VERSION "0.42" 54 55#define ASUS_HOTK_NAME "Asus Laptop Support" 56#define ASUS_HOTK_CLASS "hotkey" 57#define ASUS_HOTK_DEVICE_NAME "Hotkey" 58#define ASUS_HOTK_FILE KBUILD_MODNAME 59#define ASUS_HOTK_PREFIX "\\_SB.ATKD." 60 61 62/* 63 * Some events we use, same for all Asus 64 */ 65#define ATKD_BR_UP 0x10 66#define ATKD_BR_DOWN 0x20 67#define ATKD_LCD_ON 0x33 68#define ATKD_LCD_OFF 0x34 69 70/* 71 * Known bits returned by \_SB.ATKD.HWRS 72 */ 73#define WL_HWRS 0x80 74#define BT_HWRS 0x100 75 76/* 77 * Flags for hotk status 78 * WL_ON and BT_ON are also used for wireless_status() 79 */ 80#define WL_ON 0x01 /* internal Wifi */ 81#define BT_ON 0x02 /* internal Bluetooth */ 82#define MLED_ON 0x04 /* mail LED */ 83#define TLED_ON 0x08 /* touchpad LED */ 84#define RLED_ON 0x10 /* Record LED */ 85#define PLED_ON 0x20 /* Phone LED */ 86#define GLED_ON 0x40 /* Gaming LED */ 87#define LCD_ON 0x80 /* LCD backlight */ 88#define GPS_ON 0x100 /* GPS */ 89#define KEY_ON 0x200 /* Keyboard backlight */ 90 91MODULE_AUTHOR("Julien Lerouge, Karol Kozimor, Corentin Chary"); 92MODULE_DESCRIPTION(ASUS_HOTK_NAME); 93MODULE_LICENSE("GPL"); 94 95/* 96 * WAPF defines the behavior of the Fn+Fx wlan key 97 * The significance of values is yet to be found, but 98 * most of the time: 99 * 0x0 will do nothing 100 * 0x1 will allow to control the device with Fn+Fx key. 101 * 0x4 will send an ACPI event (0x88) while pressing the Fn+Fx key 102 * 0x5 like 0x1 or 0x4 103 * So, if something doesn't work as you want, just try other values =) 104 */ 105static uint wapf = 1; 106module_param(wapf, uint, 0644); 107MODULE_PARM_DESC(wapf, "WAPF value"); 108 109static uint wireless_status = 1; 110static uint bluetooth_status = 1; 111 112module_param(wireless_status, uint, 0644); 113MODULE_PARM_DESC(wireless_status, "Set the wireless status on boot " 114 "(0 = disabled, 1 = enabled, -1 = don't do anything). " 115 "default is 1"); 116 117module_param(bluetooth_status, uint, 0644); 118MODULE_PARM_DESC(bluetooth_status, "Set the wireless status on boot " 119 "(0 = disabled, 1 = enabled, -1 = don't do anything). " 120 "default is 1"); 121 122#define ASUS_HANDLE(object, paths...) \ 123 static acpi_handle object##_handle = NULL; \ 124 static char *object##_paths[] = { paths } 125 126/* LED */ 127ASUS_HANDLE(mled_set, ASUS_HOTK_PREFIX "MLED"); 128ASUS_HANDLE(tled_set, ASUS_HOTK_PREFIX "TLED"); 129ASUS_HANDLE(rled_set, ASUS_HOTK_PREFIX "RLED"); /* W1JC */ 130ASUS_HANDLE(pled_set, ASUS_HOTK_PREFIX "PLED"); /* A7J */ 131ASUS_HANDLE(gled_set, ASUS_HOTK_PREFIX "GLED"); /* G1, G2 (probably) */ 132 133/* LEDD */ 134ASUS_HANDLE(ledd_set, ASUS_HOTK_PREFIX "SLCM"); 135 136/* 137 * Bluetooth and WLAN 138 * WLED and BLED are not handled like other XLED, because in some dsdt 139 * they also control the WLAN/Bluetooth device. 140 */ 141ASUS_HANDLE(wl_switch, ASUS_HOTK_PREFIX "WLED"); 142ASUS_HANDLE(bt_switch, ASUS_HOTK_PREFIX "BLED"); 143ASUS_HANDLE(wireless_status, ASUS_HOTK_PREFIX "RSTS"); /* All new models */ 144 145/* Brightness */ 146ASUS_HANDLE(brightness_set, ASUS_HOTK_PREFIX "SPLV"); 147ASUS_HANDLE(brightness_get, ASUS_HOTK_PREFIX "GPLV"); 148 149/* Backlight */ 150ASUS_HANDLE(lcd_switch, "\\_SB.PCI0.SBRG.EC0._Q10", /* All new models */ 151 "\\_SB.PCI0.ISA.EC0._Q10", /* A1x */ 152 "\\_SB.PCI0.PX40.ECD0._Q10", /* L3C */ 153 "\\_SB.PCI0.PX40.EC0.Q10", /* M1A */ 154 "\\_SB.PCI0.LPCB.EC0._Q10", /* P30 */ 155 "\\_SB.PCI0.LPCB.EC0._Q0E", /* P30/P35 */ 156 "\\_SB.PCI0.PX40.Q10", /* S1x */ 157 "\\Q10"); /* A2x, L2D, L3D, M2E */ 158 159/* Display */ 160ASUS_HANDLE(display_set, ASUS_HOTK_PREFIX "SDSP"); 161ASUS_HANDLE(display_get, 162 /* A6B, A6K A6R A7D F3JM L4R M6R A3G M6A M6V VX-1 V6J V6V W3Z */ 163 "\\_SB.PCI0.P0P1.VGA.GETD", 164 /* A3E A4K, A4D A4L A6J A7J A8J Z71V M9V S5A M5A z33A W1Jc W2V G1 */ 165 "\\_SB.PCI0.P0P2.VGA.GETD", 166 /* A6V A6Q */ 167 "\\_SB.PCI0.P0P3.VGA.GETD", 168 /* A6T, A6M */ 169 "\\_SB.PCI0.P0PA.VGA.GETD", 170 /* L3C */ 171 "\\_SB.PCI0.PCI1.VGAC.NMAP", 172 /* Z96F */ 173 "\\_SB.PCI0.VGA.GETD", 174 /* A2D */ 175 "\\ACTD", 176 /* A4G Z71A W1N W5A W5F M2N M3N M5N M6N S1N S5N */ 177 "\\ADVG", 178 /* P30 */ 179 "\\DNXT", 180 /* A2H D1 L2D L3D L3H L2E L5D L5C M1A M2E L4L W3V */ 181 "\\INFB", 182 /* A3F A6F A3N A3L M6N W3N W6A */ 183 "\\SSTE"); 184 185ASUS_HANDLE(ls_switch, ASUS_HOTK_PREFIX "ALSC"); /* Z71A Z71V */ 186ASUS_HANDLE(ls_level, ASUS_HOTK_PREFIX "ALSL"); /* Z71A Z71V */ 187 188/* GPS */ 189/* R2H use different handle for GPS on/off */ 190ASUS_HANDLE(gps_on, ASUS_HOTK_PREFIX "SDON"); /* R2H */ 191ASUS_HANDLE(gps_off, ASUS_HOTK_PREFIX "SDOF"); /* R2H */ 192ASUS_HANDLE(gps_status, ASUS_HOTK_PREFIX "GPST"); 193 194/* Keyboard light */ 195ASUS_HANDLE(kled_set, ASUS_HOTK_PREFIX "SLKB"); 196ASUS_HANDLE(kled_get, ASUS_HOTK_PREFIX "GLKB"); 197 198/* 199 * This is the main structure, we can use it to store anything interesting 200 * about the hotk device 201 */ 202struct asus_hotk { 203 char *name; /* laptop name */ 204 struct acpi_device *device; /* the device we are in */ 205 acpi_handle handle; /* the handle of the hotk device */ 206 char status; /* status of the hotk, for LEDs, ... */ 207 u32 ledd_status; /* status of the LED display */ 208 u8 light_level; /* light sensor level */ 209 u8 light_switch; /* light sensor switch value */ 210 u16 event_count[128]; /* count for each event TODO make this better */ 211 struct input_dev *inputdev; 212 u16 *keycode_map; 213}; 214 215/* 216 * This header is made available to allow proper configuration given model, 217 * revision number , ... this info cannot go in struct asus_hotk because it is 218 * available before the hotk 219 */ 220static struct acpi_table_header *asus_info; 221 222/* The actual device the driver binds to */ 223static struct asus_hotk *hotk; 224 225/* 226 * The hotkey driver declaration 227 */ 228static const struct acpi_device_id asus_device_ids[] = { 229 {"ATK0100", 0}, 230 {"ATK0101", 0}, 231 {"", 0}, 232}; 233MODULE_DEVICE_TABLE(acpi, asus_device_ids); 234 235static int asus_hotk_add(struct acpi_device *device); 236static int asus_hotk_remove(struct acpi_device *device, int type); 237static void asus_hotk_notify(struct acpi_device *device, u32 event); 238 239static struct acpi_driver asus_hotk_driver = { 240 .name = ASUS_HOTK_NAME, 241 .class = ASUS_HOTK_CLASS, 242 .owner = THIS_MODULE, 243 .ids = asus_device_ids, 244 .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS, 245 .ops = { 246 .add = asus_hotk_add, 247 .remove = asus_hotk_remove, 248 .notify = asus_hotk_notify, 249 }, 250}; 251 252/* The backlight device /sys/class/backlight */ 253static struct backlight_device *asus_backlight_device; 254 255/* 256 * The backlight class declaration 257 */ 258static int read_brightness(struct backlight_device *bd); 259static int update_bl_status(struct backlight_device *bd); 260static struct backlight_ops asusbl_ops = { 261 .get_brightness = read_brightness, 262 .update_status = update_bl_status, 263}; 264 265/* 266 * These functions actually update the LED's, and are called from a 267 * workqueue. By doing this as separate work rather than when the LED 268 * subsystem asks, we avoid messing with the Asus ACPI stuff during a 269 * potentially bad time, such as a timer interrupt. 270 */ 271static struct workqueue_struct *led_workqueue; 272 273#define ASUS_LED(object, ledname, max) \ 274 static void object##_led_set(struct led_classdev *led_cdev, \ 275 enum led_brightness value); \ 276 static enum led_brightness object##_led_get( \ 277 struct led_classdev *led_cdev); \ 278 static void object##_led_update(struct work_struct *ignored); \ 279 static int object##_led_wk; \ 280 static DECLARE_WORK(object##_led_work, object##_led_update); \ 281 static struct led_classdev object##_led = { \ 282 .name = "asus::" ledname, \ 283 .brightness_set = object##_led_set, \ 284 .brightness_get = object##_led_get, \ 285 .max_brightness = max \ 286 } 287 288ASUS_LED(mled, "mail", 1); 289ASUS_LED(tled, "touchpad", 1); 290ASUS_LED(rled, "record", 1); 291ASUS_LED(pled, "phone", 1); 292ASUS_LED(gled, "gaming", 1); 293ASUS_LED(kled, "kbd_backlight", 3); 294 295struct key_entry { 296 char type; 297 u8 code; 298 u16 keycode; 299}; 300 301enum { KE_KEY, KE_END }; 302 303static struct key_entry asus_keymap[] = { 304 {KE_KEY, 0x02, KEY_SCREENLOCK}, 305 {KE_KEY, 0x05, KEY_WLAN}, 306 {KE_KEY, 0x08, KEY_F13}, 307 {KE_KEY, 0x17, KEY_ZOOM}, 308 {KE_KEY, 0x1f, KEY_BATTERY}, 309 {KE_KEY, 0x30, KEY_VOLUMEUP}, 310 {KE_KEY, 0x31, KEY_VOLUMEDOWN}, 311 {KE_KEY, 0x32, KEY_MUTE}, 312 {KE_KEY, 0x33, KEY_SWITCHVIDEOMODE}, 313 {KE_KEY, 0x34, KEY_SWITCHVIDEOMODE}, 314 {KE_KEY, 0x40, KEY_PREVIOUSSONG}, 315 {KE_KEY, 0x41, KEY_NEXTSONG}, 316 {KE_KEY, 0x43, KEY_STOPCD}, 317 {KE_KEY, 0x45, KEY_PLAYPAUSE}, 318 {KE_KEY, 0x4c, KEY_MEDIA}, 319 {KE_KEY, 0x50, KEY_EMAIL}, 320 {KE_KEY, 0x51, KEY_WWW}, 321 {KE_KEY, 0x55, KEY_CALC}, 322 {KE_KEY, 0x5C, KEY_SCREENLOCK}, /* Screenlock */ 323 {KE_KEY, 0x5D, KEY_WLAN}, 324 {KE_KEY, 0x5E, KEY_WLAN}, 325 {KE_KEY, 0x5F, KEY_WLAN}, 326 {KE_KEY, 0x60, KEY_SWITCHVIDEOMODE}, 327 {KE_KEY, 0x61, KEY_SWITCHVIDEOMODE}, 328 {KE_KEY, 0x62, KEY_SWITCHVIDEOMODE}, 329 {KE_KEY, 0x63, KEY_SWITCHVIDEOMODE}, 330 {KE_KEY, 0x6B, KEY_F13}, /* Lock Touchpad */ 331 {KE_KEY, 0x82, KEY_CAMERA}, 332 {KE_KEY, 0x88, KEY_WLAN }, 333 {KE_KEY, 0x8A, KEY_PROG1}, 334 {KE_KEY, 0x95, KEY_MEDIA}, 335 {KE_KEY, 0x99, KEY_PHONE}, 336 {KE_KEY, 0xc4, KEY_KBDILLUMUP}, 337 {KE_KEY, 0xc5, KEY_KBDILLUMDOWN}, 338 {KE_END, 0}, 339}; 340 341/* 342 * This function evaluates an ACPI method, given an int as parameter, the 343 * method is searched within the scope of the handle, can be NULL. The output 344 * of the method is written is output, which can also be NULL 345 * 346 * returns 0 if write is successful, -1 else. 347 */ 348static int write_acpi_int_ret(acpi_handle handle, const char *method, int val, 349 struct acpi_buffer *output) 350{ 351 struct acpi_object_list params; /* list of input parameters (an int) */ 352 union acpi_object in_obj; /* the only param we use */ 353 acpi_status status; 354 355 if (!handle) 356 return 0; 357 358 params.count = 1; 359 params.pointer = &in_obj; 360 in_obj.type = ACPI_TYPE_INTEGER; 361 in_obj.integer.value = val; 362 363 status = acpi_evaluate_object(handle, (char *)method, ¶ms, output); 364 if (status == AE_OK) 365 return 0; 366 else 367 return -1; 368} 369 370static int write_acpi_int(acpi_handle handle, const char *method, int val) 371{ 372 return write_acpi_int_ret(handle, method, val, NULL); 373} 374 375static int read_wireless_status(int mask) 376{ 377 unsigned long long status; 378 acpi_status rv = AE_OK; 379 380 if (!wireless_status_handle) 381 return (hotk->status & mask) ? 1 : 0; 382 383 rv = acpi_evaluate_integer(wireless_status_handle, NULL, NULL, &status); 384 if (ACPI_FAILURE(rv)) 385 pr_warning("Error reading Wireless status\n"); 386 else 387 return (status & mask) ? 1 : 0; 388 389 return (hotk->status & mask) ? 1 : 0; 390} 391 392static int read_gps_status(void) 393{ 394 unsigned long long status; 395 acpi_status rv = AE_OK; 396 397 rv = acpi_evaluate_integer(gps_status_handle, NULL, NULL, &status); 398 if (ACPI_FAILURE(rv)) 399 pr_warning("Error reading GPS status\n"); 400 else 401 return status ? 1 : 0; 402 403 return (hotk->status & GPS_ON) ? 1 : 0; 404} 405 406/* Generic LED functions */ 407static int read_status(int mask) 408{ 409 /* There is a special method for both wireless devices */ 410 if (mask == BT_ON || mask == WL_ON) 411 return read_wireless_status(mask); 412 else if (mask == GPS_ON) 413 return read_gps_status(); 414 415 return (hotk->status & mask) ? 1 : 0; 416} 417 418static void write_status(acpi_handle handle, int out, int mask) 419{ 420 hotk->status = (out) ? (hotk->status | mask) : (hotk->status & ~mask); 421 422 switch (mask) { 423 case MLED_ON: 424 out = !(out & 0x1); 425 break; 426 case GLED_ON: 427 out = (out & 0x1) + 1; 428 break; 429 case GPS_ON: 430 handle = (out) ? gps_on_handle : gps_off_handle; 431 out = 0x02; 432 break; 433 default: 434 out &= 0x1; 435 break; 436 } 437 438 if (write_acpi_int(handle, NULL, out)) 439 pr_warning(" write failed %x\n", mask); 440} 441 442/* /sys/class/led handlers */ 443#define ASUS_LED_HANDLER(object, mask) \ 444 static void object##_led_set(struct led_classdev *led_cdev, \ 445 enum led_brightness value) \ 446 { \ 447 object##_led_wk = (value > 0) ? 1 : 0; \ 448 queue_work(led_workqueue, &object##_led_work); \ 449 } \ 450 static void object##_led_update(struct work_struct *ignored) \ 451 { \ 452 int value = object##_led_wk; \ 453 write_status(object##_set_handle, value, (mask)); \ 454 } \ 455 static enum led_brightness object##_led_get( \ 456 struct led_classdev *led_cdev) \ 457 { \ 458 return led_cdev->brightness; \ 459 } 460 461ASUS_LED_HANDLER(mled, MLED_ON); 462ASUS_LED_HANDLER(pled, PLED_ON); 463ASUS_LED_HANDLER(rled, RLED_ON); 464ASUS_LED_HANDLER(tled, TLED_ON); 465ASUS_LED_HANDLER(gled, GLED_ON); 466 467/* 468 * Keyboard backlight 469 */ 470static int get_kled_lvl(void) 471{ 472 unsigned long long kblv; 473 struct acpi_object_list params; 474 union acpi_object in_obj; 475 acpi_status rv; 476 477 params.count = 1; 478 params.pointer = &in_obj; 479 in_obj.type = ACPI_TYPE_INTEGER; 480 in_obj.integer.value = 2; 481 482 rv = acpi_evaluate_integer(kled_get_handle, NULL, ¶ms, &kblv); 483 if (ACPI_FAILURE(rv)) { 484 pr_warning("Error reading kled level\n"); 485 return 0; 486 } 487 return kblv; 488} 489 490static int set_kled_lvl(int kblv) 491{ 492 if (kblv > 0) 493 kblv = (1 << 7) | (kblv & 0x7F); 494 else 495 kblv = 0; 496 497 if (write_acpi_int(kled_set_handle, NULL, kblv)) { 498 pr_warning("Keyboard LED display write failed\n"); 499 return -EINVAL; 500 } 501 return 0; 502} 503 504static void kled_led_set(struct led_classdev *led_cdev, 505 enum led_brightness value) 506{ 507 kled_led_wk = value; 508 queue_work(led_workqueue, &kled_led_work); 509} 510 511static void kled_led_update(struct work_struct *ignored) 512{ 513 set_kled_lvl(kled_led_wk); 514} 515 516static enum led_brightness kled_led_get(struct led_classdev *led_cdev) 517{ 518 return get_kled_lvl(); 519} 520 521static int get_lcd_state(void) 522{ 523 return read_status(LCD_ON); 524} 525 526static int set_lcd_state(int value) 527{ 528 int lcd = 0; 529 acpi_status status = 0; 530 531 lcd = value ? 1 : 0; 532 533 if (lcd == get_lcd_state()) 534 return 0; 535 536 if (lcd_switch_handle) { 537 status = acpi_evaluate_object(lcd_switch_handle, 538 NULL, NULL, NULL); 539 540 if (ACPI_FAILURE(status)) 541 pr_warning("Error switching LCD\n"); 542 } 543 544 write_status(NULL, lcd, LCD_ON); 545 return 0; 546} 547 548static void lcd_blank(int blank) 549{ 550 struct backlight_device *bd = asus_backlight_device; 551 552 if (bd) { 553 bd->props.power = blank; 554 backlight_update_status(bd); 555 } 556} 557 558static int read_brightness(struct backlight_device *bd) 559{ 560 unsigned long long value; 561 acpi_status rv = AE_OK; 562 563 rv = acpi_evaluate_integer(brightness_get_handle, NULL, NULL, &value); 564 if (ACPI_FAILURE(rv)) 565 pr_warning("Error reading brightness\n"); 566 567 return value; 568} 569 570static int set_brightness(struct backlight_device *bd, int value) 571{ 572 if (write_acpi_int(brightness_set_handle, NULL, value)) { 573 pr_warning("Error changing brightness\n"); 574 return -EIO; 575 } 576 return 0; 577} 578 579static int update_bl_status(struct backlight_device *bd) 580{ 581 int rv; 582 int value = bd->props.brightness; 583 584 rv = set_brightness(bd, value); 585 if (rv) 586 return rv; 587 588 value = (bd->props.power == FB_BLANK_UNBLANK) ? 1 : 0; 589 return set_lcd_state(value); 590} 591 592/* 593 * Platform device handlers 594 */ 595 596/* 597 * We write our info in page, we begin at offset off and cannot write more 598 * than count bytes. We set eof to 1 if we handle those 2 values. We return the 599 * number of bytes written in page 600 */ 601static ssize_t show_infos(struct device *dev, 602 struct device_attribute *attr, char *page) 603{ 604 int len = 0; 605 unsigned long long temp; 606 char buf[16]; /* enough for all info */ 607 acpi_status rv = AE_OK; 608 609 /* 610 * We use the easy way, we don't care of off and count, so we don't set eof 611 * to 1 612 */ 613 614 len += sprintf(page, ASUS_HOTK_NAME " " ASUS_LAPTOP_VERSION "\n"); 615 len += sprintf(page + len, "Model reference : %s\n", hotk->name); 616 /* 617 * The SFUN method probably allows the original driver to get the list 618 * of features supported by a given model. For now, 0x0100 or 0x0800 619 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card. 620 * The significance of others is yet to be found. 621 */ 622 rv = acpi_evaluate_integer(hotk->handle, "SFUN", NULL, &temp); 623 if (!ACPI_FAILURE(rv)) 624 len += sprintf(page + len, "SFUN value : %#x\n", 625 (uint) temp); 626 /* 627 * The HWRS method return informations about the hardware. 628 * 0x80 bit is for WLAN, 0x100 for Bluetooth. 629 * The significance of others is yet to be found. 630 * If we don't find the method, we assume the device are present. 631 */ 632 rv = acpi_evaluate_integer(hotk->handle, "HRWS", NULL, &temp); 633 if (!ACPI_FAILURE(rv)) 634 len += sprintf(page + len, "HRWS value : %#x\n", 635 (uint) temp); 636 /* 637 * Another value for userspace: the ASYM method returns 0x02 for 638 * battery low and 0x04 for battery critical, its readings tend to be 639 * more accurate than those provided by _BST. 640 * Note: since not all the laptops provide this method, errors are 641 * silently ignored. 642 */ 643 rv = acpi_evaluate_integer(hotk->handle, "ASYM", NULL, &temp); 644 if (!ACPI_FAILURE(rv)) 645 len += sprintf(page + len, "ASYM value : %#x\n", 646 (uint) temp); 647 if (asus_info) { 648 snprintf(buf, 16, "%d", asus_info->length); 649 len += sprintf(page + len, "DSDT length : %s\n", buf); 650 snprintf(buf, 16, "%d", asus_info->checksum); 651 len += sprintf(page + len, "DSDT checksum : %s\n", buf); 652 snprintf(buf, 16, "%d", asus_info->revision); 653 len += sprintf(page + len, "DSDT revision : %s\n", buf); 654 snprintf(buf, 7, "%s", asus_info->oem_id); 655 len += sprintf(page + len, "OEM id : %s\n", buf); 656 snprintf(buf, 9, "%s", asus_info->oem_table_id); 657 len += sprintf(page + len, "OEM table id : %s\n", buf); 658 snprintf(buf, 16, "%x", asus_info->oem_revision); 659 len += sprintf(page + len, "OEM revision : 0x%s\n", buf); 660 snprintf(buf, 5, "%s", asus_info->asl_compiler_id); 661 len += sprintf(page + len, "ASL comp vendor id : %s\n", buf); 662 snprintf(buf, 16, "%x", asus_info->asl_compiler_revision); 663 len += sprintf(page + len, "ASL comp revision : 0x%s\n", buf); 664 } 665 666 return len; 667} 668 669static int parse_arg(const char *buf, unsigned long count, int *val) 670{ 671 if (!count) 672 return 0; 673 if (count > 31) 674 return -EINVAL; 675 if (sscanf(buf, "%i", val) != 1) 676 return -EINVAL; 677 return count; 678} 679 680static ssize_t store_status(const char *buf, size_t count, 681 acpi_handle handle, int mask) 682{ 683 int rv, value; 684 int out = 0; 685 686 rv = parse_arg(buf, count, &value); 687 if (rv > 0) 688 out = value ? 1 : 0; 689 690 write_status(handle, out, mask); 691 692 return rv; 693} 694 695/* 696 * LEDD display 697 */ 698static ssize_t show_ledd(struct device *dev, 699 struct device_attribute *attr, char *buf) 700{ 701 return sprintf(buf, "0x%08x\n", hotk->ledd_status); 702} 703 704static ssize_t store_ledd(struct device *dev, struct device_attribute *attr, 705 const char *buf, size_t count) 706{ 707 int rv, value; 708 709 rv = parse_arg(buf, count, &value); 710 if (rv > 0) { 711 if (write_acpi_int(ledd_set_handle, NULL, value)) 712 pr_warning("LED display write failed\n"); 713 else 714 hotk->ledd_status = (u32) value; 715 } 716 return rv; 717} 718 719/* 720 * WLAN 721 */ 722static ssize_t show_wlan(struct device *dev, 723 struct device_attribute *attr, char *buf) 724{ 725 return sprintf(buf, "%d\n", read_status(WL_ON)); 726} 727 728static ssize_t store_wlan(struct device *dev, struct device_attribute *attr, 729 const char *buf, size_t count) 730{ 731 return store_status(buf, count, wl_switch_handle, WL_ON); 732} 733 734/* 735 * Bluetooth 736 */ 737static ssize_t show_bluetooth(struct device *dev, 738 struct device_attribute *attr, char *buf) 739{ 740 return sprintf(buf, "%d\n", read_status(BT_ON)); 741} 742 743static ssize_t store_bluetooth(struct device *dev, 744 struct device_attribute *attr, const char *buf, 745 size_t count) 746{ 747 return store_status(buf, count, bt_switch_handle, BT_ON); 748} 749 750/* 751 * Display 752 */ 753static void set_display(int value) 754{ 755 /* no sanity check needed for now */ 756 if (write_acpi_int(display_set_handle, NULL, value)) 757 pr_warning("Error setting display\n"); 758 return; 759} 760 761static int read_display(void) 762{ 763 unsigned long long value = 0; 764 acpi_status rv = AE_OK; 765 766 /* 767 * In most of the case, we know how to set the display, but sometime 768 * we can't read it 769 */ 770 if (display_get_handle) { 771 rv = acpi_evaluate_integer(display_get_handle, NULL, 772 NULL, &value); 773 if (ACPI_FAILURE(rv)) 774 pr_warning("Error reading display status\n"); 775 } 776 777 value &= 0x0F; /* needed for some models, shouldn't hurt others */ 778 779 return value; 780} 781 782/* 783 * Now, *this* one could be more user-friendly, but so far, no-one has 784 * complained. The significance of bits is the same as in store_disp() 785 */ 786static ssize_t show_disp(struct device *dev, 787 struct device_attribute *attr, char *buf) 788{ 789 return sprintf(buf, "%d\n", read_display()); 790} 791 792/* 793 * Experimental support for display switching. As of now: 1 should activate 794 * the LCD output, 2 should do for CRT, 4 for TV-Out and 8 for DVI. 795 * Any combination (bitwise) of these will suffice. I never actually tested 4 796 * displays hooked up simultaneously, so be warned. See the acpi4asus README 797 * for more info. 798 */ 799static ssize_t store_disp(struct device *dev, struct device_attribute *attr, 800 const char *buf, size_t count) 801{ 802 int rv, value; 803 804 rv = parse_arg(buf, count, &value); 805 if (rv > 0) 806 set_display(value); 807 return rv; 808} 809 810/* 811 * Light Sens 812 */ 813static void set_light_sens_switch(int value) 814{ 815 if (write_acpi_int(ls_switch_handle, NULL, value)) 816 pr_warning("Error setting light sensor switch\n"); 817 hotk->light_switch = value; 818} 819 820static ssize_t show_lssw(struct device *dev, 821 struct device_attribute *attr, char *buf) 822{ 823 return sprintf(buf, "%d\n", hotk->light_switch); 824} 825 826static ssize_t store_lssw(struct device *dev, struct device_attribute *attr, 827 const char *buf, size_t count) 828{ 829 int rv, value; 830 831 rv = parse_arg(buf, count, &value); 832 if (rv > 0) 833 set_light_sens_switch(value ? 1 : 0); 834 835 return rv; 836} 837 838static void set_light_sens_level(int value) 839{ 840 if (write_acpi_int(ls_level_handle, NULL, value)) 841 pr_warning("Error setting light sensor level\n"); 842 hotk->light_level = value; 843} 844 845static ssize_t show_lslvl(struct device *dev, 846 struct device_attribute *attr, char *buf) 847{ 848 return sprintf(buf, "%d\n", hotk->light_level); 849} 850 851static ssize_t store_lslvl(struct device *dev, struct device_attribute *attr, 852 const char *buf, size_t count) 853{ 854 int rv, value; 855 856 rv = parse_arg(buf, count, &value); 857 if (rv > 0) { 858 value = (0 < value) ? ((15 < value) ? 15 : value) : 0; 859 /* 0 <= value <= 15 */ 860 set_light_sens_level(value); 861 } 862 863 return rv; 864} 865 866/* 867 * GPS 868 */ 869static ssize_t show_gps(struct device *dev, 870 struct device_attribute *attr, char *buf) 871{ 872 return sprintf(buf, "%d\n", read_status(GPS_ON)); 873} 874 875static ssize_t store_gps(struct device *dev, struct device_attribute *attr, 876 const char *buf, size_t count) 877{ 878 return store_status(buf, count, NULL, GPS_ON); 879} 880 881/* 882 * Hotkey functions 883 */ 884static struct key_entry *asus_get_entry_by_scancode(int code) 885{ 886 struct key_entry *key; 887 888 for (key = asus_keymap; key->type != KE_END; key++) 889 if (code == key->code) 890 return key; 891 892 return NULL; 893} 894 895static struct key_entry *asus_get_entry_by_keycode(int code) 896{ 897 struct key_entry *key; 898 899 for (key = asus_keymap; key->type != KE_END; key++) 900 if (code == key->keycode && key->type == KE_KEY) 901 return key; 902 903 return NULL; 904} 905 906static int asus_getkeycode(struct input_dev *dev, int scancode, int *keycode) 907{ 908 struct key_entry *key = asus_get_entry_by_scancode(scancode); 909 910 if (key && key->type == KE_KEY) { 911 *keycode = key->keycode; 912 return 0; 913 } 914 915 return -EINVAL; 916} 917 918static int asus_setkeycode(struct input_dev *dev, int scancode, int keycode) 919{ 920 struct key_entry *key; 921 int old_keycode; 922 923 if (keycode < 0 || keycode > KEY_MAX) 924 return -EINVAL; 925 926 key = asus_get_entry_by_scancode(scancode); 927 if (key && key->type == KE_KEY) { 928 old_keycode = key->keycode; 929 key->keycode = keycode; 930 set_bit(keycode, dev->keybit); 931 if (!asus_get_entry_by_keycode(old_keycode)) 932 clear_bit(old_keycode, dev->keybit); 933 return 0; 934 } 935 936 return -EINVAL; 937} 938 939static void asus_hotk_notify(struct acpi_device *device, u32 event) 940{ 941 static struct key_entry *key; 942 u16 count; 943 944 /* TODO Find a better way to handle events count. */ 945 if (!hotk) 946 return; 947 948 /* 949 * We need to tell the backlight device when the backlight power is 950 * switched 951 */ 952 if (event == ATKD_LCD_ON) { 953 write_status(NULL, 1, LCD_ON); 954 lcd_blank(FB_BLANK_UNBLANK); 955 } else if (event == ATKD_LCD_OFF) { 956 write_status(NULL, 0, LCD_ON); 957 lcd_blank(FB_BLANK_POWERDOWN); 958 } 959 960 count = hotk->event_count[event % 128]++; 961 acpi_bus_generate_proc_event(hotk->device, event, count); 962 acpi_bus_generate_netlink_event(hotk->device->pnp.device_class, 963 dev_name(&hotk->device->dev), event, 964 count); 965 966 if (hotk->inputdev) { 967 key = asus_get_entry_by_scancode(event); 968 if (!key) 969 return ; 970 971 switch (key->type) { 972 case KE_KEY: 973 input_report_key(hotk->inputdev, key->keycode, 1); 974 input_sync(hotk->inputdev); 975 input_report_key(hotk->inputdev, key->keycode, 0); 976 input_sync(hotk->inputdev); 977 break; 978 } 979 } 980} 981 982#define ASUS_CREATE_DEVICE_ATTR(_name) \ 983 struct device_attribute dev_attr_##_name = { \ 984 .attr = { \ 985 .name = __stringify(_name), \ 986 .mode = 0 }, \ 987 .show = NULL, \ 988 .store = NULL, \ 989 } 990 991#define ASUS_SET_DEVICE_ATTR(_name, _mode, _show, _store) \ 992 do { \ 993 dev_attr_##_name.attr.mode = _mode; \ 994 dev_attr_##_name.show = _show; \ 995 dev_attr_##_name.store = _store; \ 996 } while(0) 997 998static ASUS_CREATE_DEVICE_ATTR(infos); 999static ASUS_CREATE_DEVICE_ATTR(wlan); 1000static ASUS_CREATE_DEVICE_ATTR(bluetooth); 1001static ASUS_CREATE_DEVICE_ATTR(display); 1002static ASUS_CREATE_DEVICE_ATTR(ledd); 1003static ASUS_CREATE_DEVICE_ATTR(ls_switch); 1004static ASUS_CREATE_DEVICE_ATTR(ls_level); 1005static ASUS_CREATE_DEVICE_ATTR(gps); 1006 1007static struct attribute *asuspf_attributes[] = { 1008 &dev_attr_infos.attr, 1009 &dev_attr_wlan.attr, 1010 &dev_attr_bluetooth.attr, 1011 &dev_attr_display.attr, 1012 &dev_attr_ledd.attr, 1013 &dev_attr_ls_switch.attr, 1014 &dev_attr_ls_level.attr, 1015 &dev_attr_gps.attr, 1016 NULL 1017}; 1018 1019static struct attribute_group asuspf_attribute_group = { 1020 .attrs = asuspf_attributes 1021}; 1022 1023static struct platform_driver asuspf_driver = { 1024 .driver = { 1025 .name = ASUS_HOTK_FILE, 1026 .owner = THIS_MODULE, 1027 } 1028}; 1029 1030static struct platform_device *asuspf_device; 1031 1032static void asus_hotk_add_fs(void) 1033{ 1034 ASUS_SET_DEVICE_ATTR(infos, 0444, show_infos, NULL); 1035 1036 if (wl_switch_handle) 1037 ASUS_SET_DEVICE_ATTR(wlan, 0644, show_wlan, store_wlan); 1038 1039 if (bt_switch_handle) 1040 ASUS_SET_DEVICE_ATTR(bluetooth, 0644, 1041 show_bluetooth, store_bluetooth); 1042 1043 if (display_set_handle && display_get_handle) 1044 ASUS_SET_DEVICE_ATTR(display, 0644, show_disp, store_disp); 1045 else if (display_set_handle) 1046 ASUS_SET_DEVICE_ATTR(display, 0200, NULL, store_disp); 1047 1048 if (ledd_set_handle) 1049 ASUS_SET_DEVICE_ATTR(ledd, 0644, show_ledd, store_ledd); 1050 1051 if (ls_switch_handle && ls_level_handle) { 1052 ASUS_SET_DEVICE_ATTR(ls_level, 0644, show_lslvl, store_lslvl); 1053 ASUS_SET_DEVICE_ATTR(ls_switch, 0644, show_lssw, store_lssw); 1054 } 1055 1056 if (gps_status_handle && gps_on_handle && gps_off_handle) 1057 ASUS_SET_DEVICE_ATTR(gps, 0644, show_gps, store_gps); 1058} 1059 1060static int asus_handle_init(char *name, acpi_handle * handle, 1061 char **paths, int num_paths) 1062{ 1063 int i; 1064 acpi_status status; 1065 1066 for (i = 0; i < num_paths; i++) { 1067 status = acpi_get_handle(NULL, paths[i], handle); 1068 if (ACPI_SUCCESS(status)) 1069 return 0; 1070 } 1071 1072 *handle = NULL; 1073 return -ENODEV; 1074} 1075 1076#define ASUS_HANDLE_INIT(object) \ 1077 asus_handle_init(#object, &object##_handle, object##_paths, \ 1078 ARRAY_SIZE(object##_paths)) 1079 1080/* 1081 * This function is used to initialize the hotk with right values. In this 1082 * method, we can make all the detection we want, and modify the hotk struct 1083 */ 1084static int asus_hotk_get_info(void) 1085{ 1086 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL }; 1087 union acpi_object *model = NULL; 1088 unsigned long long bsts_result, hwrs_result; 1089 char *string = NULL; 1090 acpi_status status; 1091 1092 /* 1093 * Get DSDT headers early enough to allow for differentiating between 1094 * models, but late enough to allow acpi_bus_register_driver() to fail 1095 * before doing anything ACPI-specific. Should we encounter a machine, 1096 * which needs special handling (i.e. its hotkey device has a different 1097 * HID), this bit will be moved. A global variable asus_info contains 1098 * the DSDT header. 1099 */ 1100 status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus_info); 1101 if (ACPI_FAILURE(status)) 1102 pr_warning("Couldn't get the DSDT table header\n"); 1103 1104 /* We have to write 0 on init this far for all ASUS models */ 1105 if (write_acpi_int_ret(hotk->handle, "INIT", 0, &buffer)) { 1106 pr_err("Hotkey initialization failed\n"); 1107 return -ENODEV; 1108 } 1109 1110 /* This needs to be called for some laptops to init properly */ 1111 status = 1112 acpi_evaluate_integer(hotk->handle, "BSTS", NULL, &bsts_result); 1113 if (ACPI_FAILURE(status)) 1114 pr_warning("Error calling BSTS\n"); 1115 else if (bsts_result) 1116 pr_notice("BSTS called, 0x%02x returned\n", 1117 (uint) bsts_result); 1118 1119 /* This too ... */ 1120 write_acpi_int(hotk->handle, "CWAP", wapf); 1121 1122 /* 1123 * Try to match the object returned by INIT to the specific model. 1124 * Handle every possible object (or the lack of thereof) the DSDT 1125 * writers might throw at us. When in trouble, we pass NULL to 1126 * asus_model_match() and try something completely different. 1127 */ 1128 if (buffer.pointer) { 1129 model = buffer.pointer; 1130 switch (model->type) { 1131 case ACPI_TYPE_STRING: 1132 string = model->string.pointer; 1133 break; 1134 case ACPI_TYPE_BUFFER: 1135 string = model->buffer.pointer; 1136 break; 1137 default: 1138 string = ""; 1139 break; 1140 } 1141 } 1142 hotk->name = kstrdup(string, GFP_KERNEL); 1143 if (!hotk->name) 1144 return -ENOMEM; 1145 1146 if (*string) 1147 pr_notice(" %s model detected\n", string); 1148 1149 ASUS_HANDLE_INIT(mled_set); 1150 ASUS_HANDLE_INIT(tled_set); 1151 ASUS_HANDLE_INIT(rled_set); 1152 ASUS_HANDLE_INIT(pled_set); 1153 ASUS_HANDLE_INIT(gled_set); 1154 1155 ASUS_HANDLE_INIT(ledd_set); 1156 1157 ASUS_HANDLE_INIT(kled_set); 1158 ASUS_HANDLE_INIT(kled_get); 1159 1160 /* 1161 * The HWRS method return informations about the hardware. 1162 * 0x80 bit is for WLAN, 0x100 for Bluetooth. 1163 * The significance of others is yet to be found. 1164 * If we don't find the method, we assume the device are present. 1165 */ 1166 status = 1167 acpi_evaluate_integer(hotk->handle, "HRWS", NULL, &hwrs_result); 1168 if (ACPI_FAILURE(status)) 1169 hwrs_result = WL_HWRS | BT_HWRS; 1170 1171 if (hwrs_result & WL_HWRS) 1172 ASUS_HANDLE_INIT(wl_switch); 1173 if (hwrs_result & BT_HWRS) 1174 ASUS_HANDLE_INIT(bt_switch); 1175 1176 ASUS_HANDLE_INIT(wireless_status); 1177 1178 ASUS_HANDLE_INIT(brightness_set); 1179 ASUS_HANDLE_INIT(brightness_get); 1180 1181 ASUS_HANDLE_INIT(lcd_switch); 1182 1183 ASUS_HANDLE_INIT(display_set); 1184 ASUS_HANDLE_INIT(display_get); 1185 1186 /* 1187 * There is a lot of models with "ALSL", but a few get 1188 * a real light sens, so we need to check it. 1189 */ 1190 if (!ASUS_HANDLE_INIT(ls_switch)) 1191 ASUS_HANDLE_INIT(ls_level); 1192 1193 ASUS_HANDLE_INIT(gps_on); 1194 ASUS_HANDLE_INIT(gps_off); 1195 ASUS_HANDLE_INIT(gps_status); 1196 1197 kfree(model); 1198 1199 return AE_OK; 1200} 1201 1202static int asus_input_init(void) 1203{ 1204 const struct key_entry *key; 1205 int result; 1206 1207 hotk->inputdev = input_allocate_device(); 1208 if (!hotk->inputdev) { 1209 pr_info("Unable to allocate input device\n"); 1210 return 0; 1211 } 1212 hotk->inputdev->name = "Asus Laptop extra buttons"; 1213 hotk->inputdev->phys = ASUS_HOTK_FILE "/input0"; 1214 hotk->inputdev->id.bustype = BUS_HOST; 1215 hotk->inputdev->getkeycode = asus_getkeycode; 1216 hotk->inputdev->setkeycode = asus_setkeycode; 1217 1218 for (key = asus_keymap; key->type != KE_END; key++) { 1219 switch (key->type) { 1220 case KE_KEY: 1221 set_bit(EV_KEY, hotk->inputdev->evbit); 1222 set_bit(key->keycode, hotk->inputdev->keybit); 1223 break; 1224 } 1225 } 1226 result = input_register_device(hotk->inputdev); 1227 if (result) { 1228 pr_info("Unable to register input device\n"); 1229 input_free_device(hotk->inputdev); 1230 } 1231 return result; 1232} 1233 1234static int asus_hotk_check(void) 1235{ 1236 int result = 0; 1237 1238 result = acpi_bus_get_status(hotk->device); 1239 if (result) 1240 return result; 1241 1242 if (hotk->device->status.present) { 1243 result = asus_hotk_get_info(); 1244 } else { 1245 pr_err("Hotkey device not present, aborting\n"); 1246 return -EINVAL; 1247 } 1248 1249 return result; 1250} 1251 1252static int asus_hotk_found; 1253 1254static int asus_hotk_add(struct acpi_device *device) 1255{ 1256 int result; 1257 1258 pr_notice("Asus Laptop Support version %s\n", 1259 ASUS_LAPTOP_VERSION); 1260 1261 hotk = kzalloc(sizeof(struct asus_hotk), GFP_KERNEL); 1262 if (!hotk) 1263 return -ENOMEM; 1264 1265 hotk->handle = device->handle; 1266 strcpy(acpi_device_name(device), ASUS_HOTK_DEVICE_NAME); 1267 strcpy(acpi_device_class(device), ASUS_HOTK_CLASS); 1268 device->driver_data = hotk; 1269 hotk->device = device; 1270 1271 result = asus_hotk_check(); 1272 if (result) 1273 goto end; 1274 1275 asus_hotk_add_fs(); 1276 1277 asus_hotk_found = 1; 1278 1279 /* WLED and BLED are on by default */ 1280 if (bluetooth_status != -1) 1281 write_status(bt_switch_handle, !!bluetooth_status, BT_ON); 1282 if (wireless_status != -1) 1283 write_status(wl_switch_handle, !!wireless_status, WL_ON); 1284 1285 /* If the h/w switch is off, we need to check the real status */ 1286 write_status(NULL, read_status(BT_ON), BT_ON); 1287 write_status(NULL, read_status(WL_ON), WL_ON); 1288 1289 /* LCD Backlight is on by default */ 1290 write_status(NULL, 1, LCD_ON); 1291 1292 /* Keyboard Backlight is on by default */ 1293 if (kled_set_handle) 1294 set_kled_lvl(1); 1295 1296 /* LED display is off by default */ 1297 hotk->ledd_status = 0xFFF; 1298 1299 /* Set initial values of light sensor and level */ 1300 hotk->light_switch = 0; /* Default to light sensor disabled */ 1301 hotk->light_level = 5; /* level 5 for sensor sensitivity */ 1302 1303 if (ls_switch_handle) 1304 set_light_sens_switch(hotk->light_switch); 1305 1306 if (ls_level_handle) 1307 set_light_sens_level(hotk->light_level); 1308 1309 /* GPS is on by default */ 1310 write_status(NULL, 1, GPS_ON); 1311 1312end: 1313 if (result) { 1314 kfree(hotk->name); 1315 kfree(hotk); 1316 } 1317 1318 return result; 1319} 1320 1321static int asus_hotk_remove(struct acpi_device *device, int type) 1322{ 1323 kfree(hotk->name); 1324 kfree(hotk); 1325 1326 return 0; 1327} 1328 1329static void asus_backlight_exit(void) 1330{ 1331 if (asus_backlight_device) 1332 backlight_device_unregister(asus_backlight_device); 1333} 1334 1335#define ASUS_LED_UNREGISTER(object) \ 1336 if (object##_led.dev) \ 1337 led_classdev_unregister(&object##_led) 1338 1339static void asus_led_exit(void) 1340{ 1341 destroy_workqueue(led_workqueue); 1342 ASUS_LED_UNREGISTER(mled); 1343 ASUS_LED_UNREGISTER(tled); 1344 ASUS_LED_UNREGISTER(pled); 1345 ASUS_LED_UNREGISTER(rled); 1346 ASUS_LED_UNREGISTER(gled); 1347 ASUS_LED_UNREGISTER(kled); 1348} 1349 1350static void asus_input_exit(void) 1351{ 1352 if (hotk->inputdev) 1353 input_unregister_device(hotk->inputdev); 1354} 1355 1356static void __exit asus_laptop_exit(void) 1357{ 1358 asus_backlight_exit(); 1359 asus_led_exit(); 1360 asus_input_exit(); 1361 1362 acpi_bus_unregister_driver(&asus_hotk_driver); 1363 sysfs_remove_group(&asuspf_device->dev.kobj, &asuspf_attribute_group); 1364 platform_device_unregister(asuspf_device); 1365 platform_driver_unregister(&asuspf_driver); 1366} 1367 1368static int asus_backlight_init(struct device *dev) 1369{ 1370 struct backlight_device *bd; 1371 1372 if (brightness_set_handle && lcd_switch_handle) { 1373 bd = backlight_device_register(ASUS_HOTK_FILE, dev, 1374 NULL, &asusbl_ops); 1375 if (IS_ERR(bd)) { 1376 pr_err("Could not register asus backlight device\n"); 1377 asus_backlight_device = NULL; 1378 return PTR_ERR(bd); 1379 } 1380 1381 asus_backlight_device = bd; 1382 1383 bd->props.max_brightness = 15; 1384 bd->props.brightness = read_brightness(NULL); 1385 bd->props.power = FB_BLANK_UNBLANK; 1386 backlight_update_status(bd); 1387 } 1388 return 0; 1389} 1390 1391static int asus_led_register(acpi_handle handle, 1392 struct led_classdev *ldev, struct device *dev) 1393{ 1394 if (!handle) 1395 return 0; 1396 1397 return led_classdev_register(dev, ldev); 1398} 1399 1400#define ASUS_LED_REGISTER(object, device) \ 1401 asus_led_register(object##_set_handle, &object##_led, device) 1402 1403static int asus_led_init(struct device *dev) 1404{ 1405 int rv; 1406 1407 rv = ASUS_LED_REGISTER(mled, dev); 1408 if (rv) 1409 goto out; 1410 1411 rv = ASUS_LED_REGISTER(tled, dev); 1412 if (rv) 1413 goto out1; 1414 1415 rv = ASUS_LED_REGISTER(rled, dev); 1416 if (rv) 1417 goto out2; 1418 1419 rv = ASUS_LED_REGISTER(pled, dev); 1420 if (rv) 1421 goto out3; 1422 1423 rv = ASUS_LED_REGISTER(gled, dev); 1424 if (rv) 1425 goto out4; 1426 1427 if (kled_set_handle && kled_get_handle) 1428 rv = ASUS_LED_REGISTER(kled, dev); 1429 if (rv) 1430 goto out5; 1431 1432 led_workqueue = create_singlethread_workqueue("led_workqueue"); 1433 if (!led_workqueue) 1434 goto out6; 1435 1436 return 0; 1437out6: 1438 rv = -ENOMEM; 1439 ASUS_LED_UNREGISTER(kled); 1440out5: 1441 ASUS_LED_UNREGISTER(gled); 1442out4: 1443 ASUS_LED_UNREGISTER(pled); 1444out3: 1445 ASUS_LED_UNREGISTER(rled); 1446out2: 1447 ASUS_LED_UNREGISTER(tled); 1448out1: 1449 ASUS_LED_UNREGISTER(mled); 1450out: 1451 return rv; 1452} 1453 1454static int __init asus_laptop_init(void) 1455{ 1456 int result; 1457 1458 result = acpi_bus_register_driver(&asus_hotk_driver); 1459 if (result < 0) 1460 return result; 1461 1462 /* 1463 * This is a bit of a kludge. We only want this module loaded 1464 * for ASUS systems, but there's currently no way to probe the 1465 * ACPI namespace for ASUS HIDs. So we just return failure if 1466 * we didn't find one, which will cause the module to be 1467 * unloaded. 1468 */ 1469 if (!asus_hotk_found) { 1470 acpi_bus_unregister_driver(&asus_hotk_driver); 1471 return -ENODEV; 1472 } 1473 1474 result = asus_input_init(); 1475 if (result) 1476 goto fail_input; 1477 1478 /* Register platform stuff */ 1479 result = platform_driver_register(&asuspf_driver); 1480 if (result) 1481 goto fail_platform_driver; 1482 1483 asuspf_device = platform_device_alloc(ASUS_HOTK_FILE, -1); 1484 if (!asuspf_device) { 1485 result = -ENOMEM; 1486 goto fail_platform_device1; 1487 } 1488 1489 result = platform_device_add(asuspf_device); 1490 if (result) 1491 goto fail_platform_device2; 1492 1493 result = sysfs_create_group(&asuspf_device->dev.kobj, 1494 &asuspf_attribute_group); 1495 if (result) 1496 goto fail_sysfs; 1497 1498 result = asus_led_init(&asuspf_device->dev); 1499 if (result) 1500 goto fail_led; 1501 1502 if (!acpi_video_backlight_support()) { 1503 result = asus_backlight_init(&asuspf_device->dev); 1504 if (result) 1505 goto fail_backlight; 1506 } else 1507 pr_info("Brightness ignored, must be controlled by " 1508 "ACPI video driver\n"); 1509 1510 return 0; 1511 1512fail_backlight: 1513 asus_led_exit(); 1514 1515fail_led: 1516 sysfs_remove_group(&asuspf_device->dev.kobj, 1517 &asuspf_attribute_group); 1518 1519fail_sysfs: 1520 platform_device_del(asuspf_device); 1521 1522fail_platform_device2: 1523 platform_device_put(asuspf_device); 1524 1525fail_platform_device1: 1526 platform_driver_unregister(&asuspf_driver); 1527 1528fail_platform_driver: 1529 asus_input_exit(); 1530 1531fail_input: 1532 1533 return result; 1534} 1535 1536module_init(asus_laptop_init); 1537module_exit(asus_laptop_exit); 1538