drivers/platform/x86/asus-laptop.c

   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 helpful
  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 <linux/uaccess.h>
  49 #include <linux/input.h>
  50 #include <linux/input/sparse-keymap.h>
  51 #include <linux/rfkill.h>
  52 #include <linux/slab.h>
  53 #include <linux/dmi.h>
  54 #include <acpi/acpi_drivers.h>
  55 #include <acpi/acpi_bus.h>
  56
  57 #define ASUS_LAPTOP_VERSION     "0.42"
  58
  59 #define ASUS_LAPTOP_NAME        "Asus Laptop Support"
  60 #define ASUS_LAPTOP_CLASS       "hotkey"
  61 #define ASUS_LAPTOP_DEVICE_NAME "Hotkey"
  62 #define ASUS_LAPTOP_FILE        KBUILD_MODNAME
  63 #define ASUS_LAPTOP_PREFIX      "\\_SB.ATKD."
  64
  65 MODULE_AUTHOR("Julien Lerouge, Karol Kozimor, Corentin Chary");
  66 MODULE_DESCRIPTION(ASUS_LAPTOP_NAME);
  67 MODULE_LICENSE("GPL");
  68
  69 /*
  70  * WAPF defines the behavior of the Fn+Fx wlan key
  71  * The significance of values is yet to be found, but
  72  * most of the time:
  73  * Bit | Bluetooth | WLAN
  74  *  0  | Hardware  | Hardware
  75  *  1  | Hardware  | Software
  76  *  4  | Software  | Software
  77  */
  78 static uint wapf = 1;
  79 module_param(wapf, uint, 0444);
  80 MODULE_PARM_DESC(wapf, "WAPF value");
  81
  82 static int wlan_status = 1;
  83 static int bluetooth_status = 1;
  84 static int wimax_status = -1;
  85 static int wwan_status = -1;
  86
  87 module_param(wlan_status, int, 0444);
  88 MODULE_PARM_DESC(wlan_status, "Set the wireless status on boot "
  89                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
  90                  "default is 1");
  91
  92 module_param(bluetooth_status, int, 0444);
  93 MODULE_PARM_DESC(bluetooth_status, "Set the wireless status on boot "
  94                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
  95                  "default is 1");
  96
  97 module_param(wimax_status, int, 0444);
  98 MODULE_PARM_DESC(wimax_status, "Set the wireless status on boot "
  99                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
 100                  "default is 1");
 101
 102 module_param(wwan_status, int, 0444);
 103 MODULE_PARM_DESC(wwan_status, "Set the wireless status on boot "
 104                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
 105                  "default is 1");
 106
 107 /*
 108  * Some events we use, same for all Asus
 109  */
 110 #define ATKD_BR_UP      0x10    /* (event & ~ATKD_BR_UP) = brightness level */
 111 #define ATKD_BR_DOWN    0x20    /* (event & ~ATKD_BR_DOWN) = britghness level */
 112 #define ATKD_BR_MIN     ATKD_BR_UP
 113 #define ATKD_BR_MAX     (ATKD_BR_DOWN | 0xF)    /* 0x2f */
 114 #define ATKD_LCD_ON     0x33
 115 #define ATKD_LCD_OFF    0x34
 116
 117 /*
 118  * Known bits returned by \_SB.ATKD.HWRS
 119  */
 120 #define WL_HWRS         0x80
 121 #define BT_HWRS         0x100
 122
 123 /*
 124  * Flags for hotk status
 125  * WL_ON and BT_ON are also used for wireless_status()
 126  */
 127 #define WL_RSTS         0x01    /* internal Wifi */
 128 #define BT_RSTS         0x02    /* internal Bluetooth */
 129 #define WM_RSTS         0x08    /* internal wimax */
 130 #define WW_RSTS         0x20    /* internal wwan */
 131
 132 /* LED */
 133 #define METHOD_MLED             "MLED"
 134 #define METHOD_TLED             "TLED"
 135 #define METHOD_RLED             "RLED"  /* W1JC */
 136 #define METHOD_PLED             "PLED"  /* A7J */
 137 #define METHOD_GLED             "GLED"  /* G1, G2 (probably) */
 138
 139 /* LEDD */
 140 #define METHOD_LEDD             "SLCM"
 141
 142 /*
 143  * Bluetooth and WLAN
 144  * WLED and BLED are not handled like other XLED, because in some dsdt
 145  * they also control the WLAN/Bluetooth device.
 146  */
 147 #define METHOD_WLAN             "WLED"
 148 #define METHOD_BLUETOOTH        "BLED"
 149
 150 /* WWAN and WIMAX */
 151 #define METHOD_WWAN             "GSMC"
 152 #define METHOD_WIMAX            "WMXC"
 153
 154 #define METHOD_WL_STATUS        "RSTS"
 155
 156 /* Brightness */
 157 #define METHOD_BRIGHTNESS_SET   "SPLV"
 158 #define METHOD_BRIGHTNESS_GET   "GPLV"
 159
 160 /* Display */
 161 #define METHOD_SWITCH_DISPLAY   "SDSP"
 162
 163 #define METHOD_ALS_CONTROL      "ALSC" /* Z71A Z71V */
 164 #define METHOD_ALS_LEVEL        "ALSL" /* Z71A Z71V */
 165
 166 /* GPS */
 167 /* R2H use different handle for GPS on/off */
 168 #define METHOD_GPS_ON           "SDON"
 169 #define METHOD_GPS_OFF          "SDOF"
 170 #define METHOD_GPS_STATUS       "GPST"
 171
 172 /* Keyboard light */
 173 #define METHOD_KBD_LIGHT_SET    "SLKB"
 174 #define METHOD_KBD_LIGHT_GET    "GLKB"
 175
 176 /*
 177  * Define a specific led structure to keep the main structure clean
 178  */
 179 struct asus_led {
 180         int wk;
 181         struct work_struct work;
 182         struct led_classdev led;
 183         struct asus_laptop *asus;
 184         const char *method;
 185 };
 186
 187 /*
 188  * This is the main structure, we can use it to store anything interesting
 189  * about the hotk device
 190  */
 191 struct asus_laptop {
 192         char *name;             /* laptop name */
 193
 194         struct acpi_table_header *dsdt_info;
 195         struct platform_device *platform_device;
 196         struct acpi_device *device;             /* the device we are in */
 197         struct backlight_device *backlight_device;
 198
 199         struct input_dev *inputdev;
 200         struct key_entry *keymap;
 201
 202         struct asus_led mled;
 203         struct asus_led tled;
 204         struct asus_led rled;
 205         struct asus_led pled;
 206         struct asus_led gled;
 207         struct asus_led kled;
 208         struct workqueue_struct *led_workqueue;
 209
 210         int wireless_status;
 211         bool have_rsts;
 212
 213         struct rfkill *gps_rfkill;
 214
 215         acpi_handle handle;     /* the handle of the hotk device */
 216         u32 ledd_status;        /* status of the LED display */
 217         u8 light_level;         /* light sensor level */
 218         u8 light_switch;        /* light sensor switch value */
 219         u16 event_count[128];   /* count for each event TODO make this better */
 220 };
 221
 222 static const struct key_entry asus_keymap[] = {
 223         /* Lenovo SL Specific keycodes */
 224         {KE_KEY, 0x02, { KEY_SCREENLOCK } },
 225         {KE_KEY, 0x05, { KEY_WLAN } },
 226         {KE_KEY, 0x08, { KEY_F13 } },
 227         {KE_KEY, 0x17, { KEY_ZOOM } },
 228         {KE_KEY, 0x1f, { KEY_BATTERY } },
 229         /* End of Lenovo SL Specific keycodes */
 230         {KE_KEY, 0x30, { KEY_VOLUMEUP } },
 231         {KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
 232         {KE_KEY, 0x32, { KEY_MUTE } },
 233         {KE_KEY, 0x33, { KEY_SWITCHVIDEOMODE } },
 234         {KE_KEY, 0x34, { KEY_SWITCHVIDEOMODE } },
 235         {KE_KEY, 0x40, { KEY_PREVIOUSSONG } },
 236         {KE_KEY, 0x41, { KEY_NEXTSONG } },
 237         {KE_KEY, 0x43, { KEY_STOPCD } },
 238         {KE_KEY, 0x45, { KEY_PLAYPAUSE } },
 239         {KE_KEY, 0x4c, { KEY_MEDIA } },
 240         {KE_KEY, 0x50, { KEY_EMAIL } },
 241         {KE_KEY, 0x51, { KEY_WWW } },
 242         {KE_KEY, 0x55, { KEY_CALC } },
 243         {KE_KEY, 0x5C, { KEY_SCREENLOCK } },  /* Screenlock */
 244         {KE_KEY, 0x5D, { KEY_WLAN } },
 245         {KE_KEY, 0x5E, { KEY_WLAN } },
 246         {KE_KEY, 0x5F, { KEY_WLAN } },
 247         {KE_KEY, 0x60, { KEY_SWITCHVIDEOMODE } },
 248         {KE_KEY, 0x61, { KEY_SWITCHVIDEOMODE } },
 249         {KE_KEY, 0x62, { KEY_SWITCHVIDEOMODE } },
 250         {KE_KEY, 0x63, { KEY_SWITCHVIDEOMODE } },
 251         {KE_KEY, 0x6B, { KEY_F13 } }, /* Lock Touchpad */
 252         {KE_KEY, 0x7E, { KEY_BLUETOOTH } },
 253         {KE_KEY, 0x7D, { KEY_BLUETOOTH } },
 254         {KE_KEY, 0x82, { KEY_CAMERA } },
 255         {KE_KEY, 0x88, { KEY_WLAN  } },
 256         {KE_KEY, 0x8A, { KEY_PROG1 } },
 257         {KE_KEY, 0x95, { KEY_MEDIA } },
 258         {KE_KEY, 0x99, { KEY_PHONE } },
 259         {KE_KEY, 0xc4, { KEY_KBDILLUMUP } },
 260         {KE_KEY, 0xc5, { KEY_KBDILLUMDOWN } },
 261         {KE_KEY, 0xb5, { KEY_CALC } },
 262         {KE_END, 0},
 263 };
 264
 265
 266 /*
 267  * This function evaluates an ACPI method, given an int as parameter, the
 268  * method is searched within the scope of the handle, can be NULL. The output
 269  * of the method is written is output, which can also be NULL
 270  *
 271  * returns 0 if write is successful, -1 else.
 272  */
 273 static int write_acpi_int_ret(acpi_handle handle, const char *method, int val,
 274                               struct acpi_buffer *output)
 275 {
 276         struct acpi_object_list params; /* list of input parameters (an int) */
 277         union acpi_object in_obj;       /* the only param we use */
 278         acpi_status status;
 279
 280         if (!handle)
 281                 return -1;
 282
 283         params.count = 1;
 284         params.pointer = &in_obj;
 285         in_obj.type = ACPI_TYPE_INTEGER;
 286         in_obj.integer.value = val;
 287
 288         status = acpi_evaluate_object(handle, (char *)method, &params, output);
 289         if (status == AE_OK)
 290                 return 0;
 291         else
 292                 return -1;
 293 }
 294
 295 static int write_acpi_int(acpi_handle handle, const char *method, int val)
 296 {
 297         return write_acpi_int_ret(handle, method, val, NULL);
 298 }
 299
 300 static int acpi_check_handle(acpi_handle handle, const char *method,
 301                              acpi_handle *ret)
 302 {
 303         acpi_status status;
 304
 305         if (method == NULL)
 306                 return -ENODEV;
 307
 308         if (ret)
 309                 status = acpi_get_handle(handle, (char *)method,
 310                                          ret);
 311         else {
 312                 acpi_handle dummy;
 313
 314                 status = acpi_get_handle(handle, (char *)method,
 315                                          &dummy);
 316         }
 317
 318         if (status != AE_OK) {
 319                 if (ret)
 320                         pr_warn("Error finding %s\n", method);
 321                 return -ENODEV;
 322         }
 323         return 0;
 324 }
 325
 326 /* Generic LED function */
 327 static int asus_led_set(struct asus_laptop *asus, const char *method,
 328                          int value)
 329 {
 330         if (!strcmp(method, METHOD_MLED))
 331                 value = !value;
 332         else if (!strcmp(method, METHOD_GLED))
 333                 value = !value + 1;
 334         else
 335                 value = !!value;
 336
 337         return write_acpi_int(asus->handle, method, value);
 338 }
 339
 340 /*
 341  * LEDs
 342  */
 343 /* /sys/class/led handlers */
 344 static void asus_led_cdev_set(struct led_classdev *led_cdev,
 345                          enum led_brightness value)
 346 {
 347         struct asus_led *led = container_of(led_cdev, struct asus_led, led);
 348         struct asus_laptop *asus = led->asus;
 349
 350         led->wk = !!value;
 351         queue_work(asus->led_workqueue, &led->work);
 352 }
 353
 354 static void asus_led_cdev_update(struct work_struct *work)
 355 {
 356         struct asus_led *led = container_of(work, struct asus_led, work);
 357         struct asus_laptop *asus = led->asus;
 358
 359         asus_led_set(asus, led->method, led->wk);
 360 }
 361
 362 static enum led_brightness asus_led_cdev_get(struct led_classdev *led_cdev)
 363 {
 364         return led_cdev->brightness;
 365 }
 366
 367 /*
 368  * Keyboard backlight (also a LED)
 369  */
 370 static int asus_kled_lvl(struct asus_laptop *asus)
 371 {
 372         unsigned long long kblv;
 373         struct acpi_object_list params;
 374         union acpi_object in_obj;
 375         acpi_status rv;
 376
 377         params.count = 1;
 378         params.pointer = &in_obj;
 379         in_obj.type = ACPI_TYPE_INTEGER;
 380         in_obj.integer.value = 2;
 381
 382         rv = acpi_evaluate_integer(asus->handle, METHOD_KBD_LIGHT_GET,
 383                                    &params, &kblv);
 384         if (ACPI_FAILURE(rv)) {
 385                 pr_warn("Error reading kled level\n");
 386                 return -ENODEV;
 387         }
 388         return kblv;
 389 }
 390
 391 static int asus_kled_set(struct asus_laptop *asus, int kblv)
 392 {
 393         if (kblv > 0)
 394                 kblv = (1 << 7) | (kblv & 0x7F);
 395         else
 396                 kblv = 0;
 397
 398         if (write_acpi_int(asus->handle, METHOD_KBD_LIGHT_SET, kblv)) {
 399                 pr_warn("Keyboard LED display write failed\n");
 400                 return -EINVAL;
 401         }
 402         return 0;
 403 }
 404
 405 static void asus_kled_cdev_set(struct led_classdev *led_cdev,
 406                               enum led_brightness value)
 407 {
 408         struct asus_led *led = container_of(led_cdev, struct asus_led, led);
 409         struct asus_laptop *asus = led->asus;
 410
 411         led->wk = value;
 412         queue_work(asus->led_workqueue, &led->work);
 413 }
 414
 415 static void asus_kled_cdev_update(struct work_struct *work)
 416 {
 417         struct asus_led *led = container_of(work, struct asus_led, work);
 418         struct asus_laptop *asus = led->asus;
 419
 420         asus_kled_set(asus, led->wk);
 421 }
 422
 423 static enum led_brightness asus_kled_cdev_get(struct led_classdev *led_cdev)
 424 {
 425         struct asus_led *led = container_of(led_cdev, struct asus_led, led);
 426         struct asus_laptop *asus = led->asus;
 427
 428         return asus_kled_lvl(asus);
 429 }
 430
 431 static void asus_led_exit(struct asus_laptop *asus)
 432 {
 433         if (asus->mled.led.dev)
 434                 led_classdev_unregister(&asus->mled.led);
 435         if (asus->tled.led.dev)
 436                 led_classdev_unregister(&asus->tled.led);
 437         if (asus->pled.led.dev)
 438                 led_classdev_unregister(&asus->pled.led);
 439         if (asus->rled.led.dev)
 440                 led_classdev_unregister(&asus->rled.led);
 441         if (asus->gled.led.dev)
 442                 led_classdev_unregister(&asus->gled.led);
 443         if (asus->kled.led.dev)
 444                 led_classdev_unregister(&asus->kled.led);
 445         if (asus->led_workqueue) {
 446                 destroy_workqueue(asus->led_workqueue);
 447                 asus->led_workqueue = NULL;
 448         }
 449 }
 450
 451 /*  Ugly macro, need to fix that later */
 452 static int asus_led_register(struct asus_laptop *asus,
 453                              struct asus_led *led,
 454                              const char *name, const char *method)
 455 {
 456         struct led_classdev *led_cdev = &led->led;
 457
 458         if (!method || acpi_check_handle(asus->handle, method, NULL))
 459                 return 0; /* Led not present */
 460
 461         led->asus = asus;
 462         led->method = method;
 463
 464         INIT_WORK(&led->work, asus_led_cdev_update);
 465         led_cdev->name = name;
 466         led_cdev->brightness_set = asus_led_cdev_set;
 467         led_cdev->brightness_get = asus_led_cdev_get;
 468         led_cdev->max_brightness = 1;
 469         return led_classdev_register(&asus->platform_device->dev, led_cdev);
 470 }
 471
 472 static int asus_led_init(struct asus_laptop *asus)
 473 {
 474         int r;
 475
 476         /*
 477          * Functions that actually update the LED's are called from a
 478          * workqueue. By doing this as separate work rather than when the LED
 479          * subsystem asks, we avoid messing with the Asus ACPI stuff during a
 480          * potentially bad time, such as a timer interrupt.
 481          */
 482         asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
 483         if (!asus->led_workqueue)
 484                 return -ENOMEM;
 485
 486         r = asus_led_register(asus, &asus->mled, "asus::mail", METHOD_MLED);
 487         if (r)
 488                 goto error;
 489         r = asus_led_register(asus, &asus->tled, "asus::touchpad", METHOD_TLED);
 490         if (r)
 491                 goto error;
 492         r = asus_led_register(asus, &asus->rled, "asus::record", METHOD_RLED);
 493         if (r)
 494                 goto error;
 495         r = asus_led_register(asus, &asus->pled, "asus::phone", METHOD_PLED);
 496         if (r)
 497                 goto error;
 498         r = asus_led_register(asus, &asus->gled, "asus::gaming", METHOD_GLED);
 499         if (r)
 500                 goto error;
 501         if (!acpi_check_handle(asus->handle, METHOD_KBD_LIGHT_SET, NULL) &&
 502             !acpi_check_handle(asus->handle, METHOD_KBD_LIGHT_GET, NULL)) {
 503                 struct asus_led *led = &asus->kled;
 504                 struct led_classdev *cdev = &led->led;
 505
 506                 led->asus = asus;
 507
 508                 INIT_WORK(&led->work, asus_kled_cdev_update);
 509                 cdev->name = "asus::kbd_backlight";
 510                 cdev->brightness_set = asus_kled_cdev_set;
 511                 cdev->brightness_get = asus_kled_cdev_get;
 512                 cdev->max_brightness = 3;
 513                 r = led_classdev_register(&asus->platform_device->dev, cdev);
 514         }
 515 error:
 516         if (r)
 517                 asus_led_exit(asus);
 518         return r;
 519 }
 520
 521 /*
 522  * Backlight device
 523  */
 524 static int asus_read_brightness(struct backlight_device *bd)
 525 {
 526         struct asus_laptop *asus = bl_get_data(bd);
 527         unsigned long long value;
 528         acpi_status rv = AE_OK;
 529
 530         rv = acpi_evaluate_integer(asus->handle, METHOD_BRIGHTNESS_GET,
 531                                    NULL, &value);
 532         if (ACPI_FAILURE(rv))
 533                 pr_warn("Error reading brightness\n");
 534
 535         return value;
 536 }
 537
 538 static int asus_set_brightness(struct backlight_device *bd, int value)
 539 {
 540         struct asus_laptop *asus = bl_get_data(bd);
 541
 542         if (write_acpi_int(asus->handle, METHOD_BRIGHTNESS_SET, value)) {
 543                 pr_warn("Error changing brightness\n");
 544                 return -EIO;
 545         }
 546         return 0;
 547 }
 548
 549 static int update_bl_status(struct backlight_device *bd)
 550 {
 551         int value = bd->props.brightness;
 552
 553         return asus_set_brightness(bd, value);
 554 }
 555
 556 static const struct backlight_ops asusbl_ops = {
 557         .get_brightness = asus_read_brightness,
 558         .update_status = update_bl_status,
 559 };
 560
 561 static int asus_backlight_notify(struct asus_laptop *asus)
 562 {
 563         struct backlight_device *bd = asus->backlight_device;
 564         int old = bd->props.brightness;
 565
 566         backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
 567
 568         return old;
 569 }
 570
 571 static int asus_backlight_init(struct asus_laptop *asus)
 572 {
 573         struct backlight_device *bd;
 574         struct backlight_properties props;
 575
 576         if (acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_GET, NULL) ||
 577             acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL))
 578                 return 0;
 579
 580         memset(&props, 0, sizeof(struct backlight_properties));
 581         props.max_brightness = 15;
 582         props.type = BACKLIGHT_PLATFORM;
 583
 584         bd = backlight_device_register(ASUS_LAPTOP_FILE,
 585                                        &asus->platform_device->dev, asus,
 586                                        &asusbl_ops, &props);
 587         if (IS_ERR(bd)) {
 588                 pr_err("Could not register asus backlight device\n");
 589                 asus->backlight_device = NULL;
 590                 return PTR_ERR(bd);
 591         }
 592
 593         asus->backlight_device = bd;
 594         bd->props.brightness = asus_read_brightness(bd);
 595         bd->props.power = FB_BLANK_UNBLANK;
 596         backlight_update_status(bd);
 597         return 0;
 598 }
 599
 600 static void asus_backlight_exit(struct asus_laptop *asus)
 601 {
 602         if (asus->backlight_device)
 603                 backlight_device_unregister(asus->backlight_device);
 604         asus->backlight_device = NULL;
 605 }
 606
 607 /*
 608  * Platform device handlers
 609  */
 610
 611 /*
 612  * We write our info in page, we begin at offset off and cannot write more
 613  * than count bytes. We set eof to 1 if we handle those 2 values. We return the
 614  * number of bytes written in page
 615  */
 616 static ssize_t show_infos(struct device *dev,
 617                           struct device_attribute *attr, char *page)
 618 {
 619         struct asus_laptop *asus = dev_get_drvdata(dev);
 620         int len = 0;
 621         unsigned long long temp;
 622         char buf[16];           /* enough for all info */
 623         acpi_status rv = AE_OK;
 624
 625         /*
 626          * We use the easy way, we don't care of off and count,
 627          * so we don't set eof to 1
 628          */
 629
 630         len += sprintf(page, ASUS_LAPTOP_NAME " " ASUS_LAPTOP_VERSION "\n");
 631         len += sprintf(page + len, "Model reference    : %s\n", asus->name);
 632         /*
 633          * The SFUN method probably allows the original driver to get the list
 634          * of features supported by a given model. For now, 0x0100 or 0x0800
 635          * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
 636          * The significance of others is yet to be found.
 637          */
 638         rv = acpi_evaluate_integer(asus->handle, "SFUN", NULL, &temp);
 639         if (!ACPI_FAILURE(rv))
 640                 len += sprintf(page + len, "SFUN value         : %#x\n",
 641                                (uint) temp);
 642         /*
 643          * The HWRS method return informations about the hardware.
 644          * 0x80 bit is for WLAN, 0x100 for Bluetooth.
 645          * The significance of others is yet to be found.
 646          * If we don't find the method, we assume the device are present.
 647          */
 648         rv = acpi_evaluate_integer(asus->handle, "HRWS", NULL, &temp);
 649         if (!ACPI_FAILURE(rv))
 650                 len += sprintf(page + len, "HRWS value         : %#x\n",
 651                                (uint) temp);
 652         /*
 653          * Another value for userspace: the ASYM method returns 0x02 for
 654          * battery low and 0x04 for battery critical, its readings tend to be
 655          * more accurate than those provided by _BST.
 656          * Note: since not all the laptops provide this method, errors are
 657          * silently ignored.
 658          */
 659         rv = acpi_evaluate_integer(asus->handle, "ASYM", NULL, &temp);
 660         if (!ACPI_FAILURE(rv))
 661                 len += sprintf(page + len, "ASYM value         : %#x\n",
 662                                (uint) temp);
 663         if (asus->dsdt_info) {
 664                 snprintf(buf, 16, "%d", asus->dsdt_info->length);
 665                 len += sprintf(page + len, "DSDT length        : %s\n", buf);
 666                 snprintf(buf, 16, "%d", asus->dsdt_info->checksum);
 667                 len += sprintf(page + len, "DSDT checksum      : %s\n", buf);
 668                 snprintf(buf, 16, "%d", asus->dsdt_info->revision);
 669                 len += sprintf(page + len, "DSDT revision      : %s\n", buf);
 670                 snprintf(buf, 7, "%s", asus->dsdt_info->oem_id);
 671                 len += sprintf(page + len, "OEM id             : %s\n", buf);
 672                 snprintf(buf, 9, "%s", asus->dsdt_info->oem_table_id);
 673                 len += sprintf(page + len, "OEM table id       : %s\n", buf);
 674                 snprintf(buf, 16, "%x", asus->dsdt_info->oem_revision);
 675                 len += sprintf(page + len, "OEM revision       : 0x%s\n", buf);
 676                 snprintf(buf, 5, "%s", asus->dsdt_info->asl_compiler_id);
 677                 len += sprintf(page + len, "ASL comp vendor id : %s\n", buf);
 678                 snprintf(buf, 16, "%x", asus->dsdt_info->asl_compiler_revision);
 679                 len += sprintf(page + len, "ASL comp revision  : 0x%s\n", buf);
 680         }
 681
 682         return len;
 683 }
 684
 685 static int parse_arg(const char *buf, unsigned long count, int *val)
 686 {
 687         if (!count)
 688                 return 0;
 689         if (count > 31)
 690                 return -EINVAL;
 691         if (sscanf(buf, "%i", val) != 1)
 692                 return -EINVAL;
 693         return count;
 694 }
 695
 696 static ssize_t sysfs_acpi_set(struct asus_laptop *asus,
 697                               const char *buf, size_t count,
 698                               const char *method)
 699 {
 700         int rv, value;
 701         int out = 0;
 702
 703         rv = parse_arg(buf, count, &value);
 704         if (rv > 0)
 705                 out = value ? 1 : 0;
 706
 707         if (write_acpi_int(asus->handle, method, value))
 708                 return -ENODEV;
 709         return rv;
 710 }
 711
 712 /*
 713  * LEDD display
 714  */
 715 static ssize_t show_ledd(struct device *dev,
 716                          struct device_attribute *attr, char *buf)
 717 {
 718         struct asus_laptop *asus = dev_get_drvdata(dev);
 719
 720         return sprintf(buf, "0x%08x\n", asus->ledd_status);
 721 }
 722
 723 static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
 724                           const char *buf, size_t count)
 725 {
 726         struct asus_laptop *asus = dev_get_drvdata(dev);
 727         int rv, value;
 728
 729         rv = parse_arg(buf, count, &value);
 730         if (rv > 0) {
 731                 if (write_acpi_int(asus->handle, METHOD_LEDD, value)) {
 732                         pr_warn("LED display write failed\n");
 733                         return -ENODEV;
 734                 }
 735                 asus->ledd_status = (u32) value;
 736         }
 737         return rv;
 738 }
 739
 740 /*
 741  * Wireless
 742  */
 743 static int asus_wireless_status(struct asus_laptop *asus, int mask)
 744 {
 745         unsigned long long status;
 746         acpi_status rv = AE_OK;
 747
 748         if (!asus->have_rsts)
 749                 return (asus->wireless_status & mask) ? 1 : 0;
 750
 751         rv = acpi_evaluate_integer(asus->handle, METHOD_WL_STATUS,
 752                                    NULL, &status);
 753         if (ACPI_FAILURE(rv)) {
 754                 pr_warn("Error reading Wireless status\n");
 755                 return -EINVAL;
 756         }
 757         return !!(status & mask);
 758 }
 759
 760 /*
 761  * WLAN
 762  */
 763 static int asus_wlan_set(struct asus_laptop *asus, int status)
 764 {
 765         if (write_acpi_int(asus->handle, METHOD_WLAN, !!status)) {
 766                 pr_warn("Error setting wlan status to %d\n", status);
 767                 return -EIO;
 768         }
 769         return 0;
 770 }
 771
 772 static ssize_t show_wlan(struct device *dev,
 773                          struct device_attribute *attr, char *buf)
 774 {
 775         struct asus_laptop *asus = dev_get_drvdata(dev);
 776
 777         return sprintf(buf, "%d\n", asus_wireless_status(asus, WL_RSTS));
 778 }
 779
 780 static ssize_t store_wlan(struct device *dev, struct device_attribute *attr,
 781                           const char *buf, size_t count)
 782 {
 783         struct asus_laptop *asus = dev_get_drvdata(dev);
 784
 785         return sysfs_acpi_set(asus, buf, count, METHOD_WLAN);
 786 }
 787
 788 /*
 789  * Bluetooth
 790  */
 791 static int asus_bluetooth_set(struct asus_laptop *asus, int status)
 792 {
 793         if (write_acpi_int(asus->handle, METHOD_BLUETOOTH, !!status)) {
 794                 pr_warn("Error setting bluetooth status to %d\n", status);
 795                 return -EIO;
 796         }
 797         return 0;
 798 }
 799
 800 static ssize_t show_bluetooth(struct device *dev,
 801                               struct device_attribute *attr, char *buf)
 802 {
 803         struct asus_laptop *asus = dev_get_drvdata(dev);
 804
 805         return sprintf(buf, "%d\n", asus_wireless_status(asus, BT_RSTS));
 806 }
 807
 808 static ssize_t store_bluetooth(struct device *dev,
 809                                struct device_attribute *attr, const char *buf,
 810                                size_t count)
 811 {
 812         struct asus_laptop *asus = dev_get_drvdata(dev);
 813
 814         return sysfs_acpi_set(asus, buf, count, METHOD_BLUETOOTH);
 815 }
 816
 817 /*
 818  * Wimax
 819  */
 820 static int asus_wimax_set(struct asus_laptop *asus, int status)
 821 {
 822         if (write_acpi_int(asus->handle, METHOD_WIMAX, !!status)) {
 823                 pr_warn("Error setting wimax status to %d\n", status);
 824                 return -EIO;
 825         }
 826         return 0;
 827 }
 828
 829 static ssize_t show_wimax(struct device *dev,
 830                               struct device_attribute *attr, char *buf)
 831 {
 832         struct asus_laptop *asus = dev_get_drvdata(dev);
 833
 834         return sprintf(buf, "%d\n", asus_wireless_status(asus, WM_RSTS));
 835 }
 836
 837 static ssize_t store_wimax(struct device *dev,
 838                                struct device_attribute *attr, const char *buf,
 839                                size_t count)
 840 {
 841         struct asus_laptop *asus = dev_get_drvdata(dev);
 842
 843         return sysfs_acpi_set(asus, buf, count, METHOD_WIMAX);
 844 }
 845
 846 /*
 847  * Wwan
 848  */
 849 static int asus_wwan_set(struct asus_laptop *asus, int status)
 850 {
 851         if (write_acpi_int(asus->handle, METHOD_WWAN, !!status)) {
 852                 pr_warn("Error setting wwan status to %d\n", status);
 853                 return -EIO;
 854         }
 855         return 0;
 856 }
 857
 858 static ssize_t show_wwan(struct device *dev,
 859                               struct device_attribute *attr, char *buf)
 860 {
 861         struct asus_laptop *asus = dev_get_drvdata(dev);
 862
 863         return sprintf(buf, "%d\n", asus_wireless_status(asus, WW_RSTS));
 864 }
 865
 866 static ssize_t store_wwan(struct device *dev,
 867                                struct device_attribute *attr, const char *buf,
 868                                size_t count)
 869 {
 870         struct asus_laptop *asus = dev_get_drvdata(dev);
 871
 872         return sysfs_acpi_set(asus, buf, count, METHOD_WWAN);
 873 }
 874
 875 /*
 876  * Display
 877  */
 878 static void asus_set_display(struct asus_laptop *asus, int value)
 879 {
 880         /* no sanity check needed for now */
 881         if (write_acpi_int(asus->handle, METHOD_SWITCH_DISPLAY, value))
 882                 pr_warn("Error setting display\n");
 883         return;
 884 }
 885
 886 /*
 887  * Experimental support for display switching. As of now: 1 should activate
 888  * the LCD output, 2 should do for CRT, 4 for TV-Out and 8 for DVI.
 889  * Any combination (bitwise) of these will suffice. I never actually tested 4
 890  * displays hooked up simultaneously, so be warned. See the acpi4asus README
 891  * for more info.
 892  */
 893 static ssize_t store_disp(struct device *dev, struct device_attribute *attr,
 894                           const char *buf, size_t count)
 895 {
 896         struct asus_laptop *asus = dev_get_drvdata(dev);
 897         int rv, value;
 898
 899         rv = parse_arg(buf, count, &value);
 900         if (rv > 0)
 901                 asus_set_display(asus, value);
 902         return rv;
 903 }
 904
 905 /*
 906  * Light Sens
 907  */
 908 static void asus_als_switch(struct asus_laptop *asus, int value)
 909 {
 910         if (write_acpi_int(asus->handle, METHOD_ALS_CONTROL, value))
 911                 pr_warn("Error setting light sensor switch\n");
 912         asus->light_switch = value;
 913 }
 914
 915 static ssize_t show_lssw(struct device *dev,
 916                          struct device_attribute *attr, char *buf)
 917 {
 918         struct asus_laptop *asus = dev_get_drvdata(dev);
 919
 920         return sprintf(buf, "%d\n", asus->light_switch);
 921 }
 922
 923 static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
 924                           const char *buf, size_t count)
 925 {
 926         struct asus_laptop *asus = dev_get_drvdata(dev);
 927         int rv, value;
 928
 929         rv = parse_arg(buf, count, &value);
 930         if (rv > 0)
 931                 asus_als_switch(asus, value ? 1 : 0);
 932
 933         return rv;
 934 }
 935
 936 static void asus_als_level(struct asus_laptop *asus, int value)
 937 {
 938         if (write_acpi_int(asus->handle, METHOD_ALS_LEVEL, value))
 939                 pr_warn("Error setting light sensor level\n");
 940         asus->light_level = value;
 941 }
 942
 943 static ssize_t show_lslvl(struct device *dev,
 944                           struct device_attribute *attr, char *buf)
 945 {
 946         struct asus_laptop *asus = dev_get_drvdata(dev);
 947
 948         return sprintf(buf, "%d\n", asus->light_level);
 949 }
 950
 951 static ssize_t store_lslvl(struct device *dev, struct device_attribute *attr,
 952                            const char *buf, size_t count)
 953 {
 954         struct asus_laptop *asus = dev_get_drvdata(dev);
 955         int rv, value;
 956
 957         rv = parse_arg(buf, count, &value);
 958         if (rv > 0) {
 959                 value = (0 < value) ? ((15 < value) ? 15 : value) : 0;
 960                 /* 0 <= value <= 15 */
 961                 asus_als_level(asus, value);
 962         }
 963
 964         return rv;
 965 }
 966
 967 /*
 968  * GPS
 969  */
 970 static int asus_gps_status(struct asus_laptop *asus)
 971 {
 972         unsigned long long status;
 973         acpi_status rv = AE_OK;
 974
 975         rv = acpi_evaluate_integer(asus->handle, METHOD_GPS_STATUS,
 976                                    NULL, &status);
 977         if (ACPI_FAILURE(rv)) {
 978                 pr_warn("Error reading GPS status\n");
 979                 return -ENODEV;
 980         }
 981         return !!status;
 982 }
 983
 984 static int asus_gps_switch(struct asus_laptop *asus, int status)
 985 {
 986         const char *meth = status ? METHOD_GPS_ON : METHOD_GPS_OFF;
 987
 988         if (write_acpi_int(asus->handle, meth, 0x02))
 989                 return -ENODEV;
 990         return 0;
 991 }
 992
 993 static ssize_t show_gps(struct device *dev,
 994                         struct device_attribute *attr, char *buf)
 995 {
 996         struct asus_laptop *asus = dev_get_drvdata(dev);
 997
 998         return sprintf(buf, "%d\n", asus_gps_status(asus));
 999 }
1000
1001 static ssize_t store_gps(struct device *dev, struct device_attribute *attr,
1002                          const char *buf, size_t count)
1003 {
1004         struct asus_laptop *asus = dev_get_drvdata(dev);
1005         int rv, value;
1006         int ret;
1007
1008         rv = parse_arg(buf, count, &value);
1009         if (rv <= 0)
1010                 return -EINVAL;
1011         ret = asus_gps_switch(asus, !!value);
1012         if (ret)
1013                 return ret;
1014         rfkill_set_sw_state(asus->gps_rfkill, !value);
1015         return rv;
1016 }
1017
1018 /*
1019  * rfkill
1020  */
1021 static int asus_gps_rfkill_set(void *data, bool blocked)
1022 {
1023         struct asus_laptop *asus = data;
1024
1025         return asus_gps_switch(asus, !blocked);
1026 }
1027
1028 static const struct rfkill_ops asus_gps_rfkill_ops = {
1029         .set_block = asus_gps_rfkill_set,
1030 };
1031
1032 static void asus_rfkill_exit(struct asus_laptop *asus)
1033 {
1034         if (asus->gps_rfkill) {
1035                 rfkill_unregister(asus->gps_rfkill);
1036                 rfkill_destroy(asus->gps_rfkill);
1037                 asus->gps_rfkill = NULL;
1038         }
1039 }
1040
1041 static int asus_rfkill_init(struct asus_laptop *asus)
1042 {
1043         int result;
1044
1045         if (acpi_check_handle(asus->handle, METHOD_GPS_ON, NULL) ||
1046             acpi_check_handle(asus->handle, METHOD_GPS_OFF, NULL) ||
1047             acpi_check_handle(asus->handle, METHOD_GPS_STATUS, NULL))
1048                 return 0;
1049
1050         asus->gps_rfkill = rfkill_alloc("asus-gps", &asus->platform_device->dev,
1051                                         RFKILL_TYPE_GPS,
1052                                         &asus_gps_rfkill_ops, asus);
1053         if (!asus->gps_rfkill)
1054                 return -EINVAL;
1055
1056         result = rfkill_register(asus->gps_rfkill);
1057         if (result) {
1058                 rfkill_destroy(asus->gps_rfkill);
1059                 asus->gps_rfkill = NULL;
1060         }
1061
1062         return result;
1063 }
1064
1065 /*
1066  * Input device (i.e. hotkeys)
1067  */
1068 static void asus_input_notify(struct asus_laptop *asus, int event)
1069 {
1070         if (asus->inputdev)
1071                 sparse_keymap_report_event(asus->inputdev, event, 1, true);
1072 }
1073
1074 static int asus_input_init(struct asus_laptop *asus)
1075 {
1076         struct input_dev *input;
1077         int error;
1078
1079         input = input_allocate_device();
1080         if (!input) {
1081                 pr_info("Unable to allocate input device\n");
1082                 return -ENOMEM;
1083         }
1084         input->name = "Asus Laptop extra buttons";
1085         input->phys = ASUS_LAPTOP_FILE "/input0";
1086         input->id.bustype = BUS_HOST;
1087         input->dev.parent = &asus->platform_device->dev;
1088
1089         error = sparse_keymap_setup(input, asus_keymap, NULL);
1090         if (error) {
1091                 pr_err("Unable to setup input device keymap\n");
1092                 goto err_free_dev;
1093         }
1094         error = input_register_device(input);
1095         if (error) {
1096                 pr_info("Unable to register input device\n");
1097                 goto err_free_keymap;
1098         }
1099
1100         asus->inputdev = input;
1101         return 0;
1102
1103 err_free_keymap:
1104         sparse_keymap_free(input);
1105 err_free_dev:
1106         input_free_device(input);
1107         return error;
1108 }
1109
1110 static void asus_input_exit(struct asus_laptop *asus)
1111 {
1112         if (asus->inputdev) {
1113                 sparse_keymap_free(asus->inputdev);
1114                 input_unregister_device(asus->inputdev);
1115         }
1116         asus->inputdev = NULL;
1117 }
1118
1119 /*
1120  * ACPI driver
1121  */
1122 static void asus_acpi_notify(struct acpi_device *device, u32 event)
1123 {
1124         struct asus_laptop *asus = acpi_driver_data(device);
1125         u16 count;
1126
1127         /* TODO Find a better way to handle events count. */
1128         count = asus->event_count[event % 128]++;
1129         acpi_bus_generate_proc_event(asus->device, event, count);
1130         acpi_bus_generate_netlink_event(asus->device->pnp.device_class,
1131                                         dev_name(&asus->device->dev), event,
1132                                         count);
1133
1134         /* Brightness events are special */
1135         if (event >= ATKD_BR_MIN && event <= ATKD_BR_MAX) {
1136
1137                 /* Ignore them completely if the acpi video driver is used */
1138                 if (asus->backlight_device != NULL) {
1139                         /* Update the backlight device. */
1140                         asus_backlight_notify(asus);
1141                 }
1142                 return ;
1143         }
1144         asus_input_notify(asus, event);
1145 }
1146
1147 static DEVICE_ATTR(infos, S_IRUGO, show_infos, NULL);
1148 static DEVICE_ATTR(wlan, S_IRUGO | S_IWUSR, show_wlan, store_wlan);
1149 static DEVICE_ATTR(bluetooth, S_IRUGO | S_IWUSR,
1150                    show_bluetooth, store_bluetooth);
1151 static DEVICE_ATTR(wimax, S_IRUGO | S_IWUSR, show_wimax, store_wimax);
1152 static DEVICE_ATTR(wwan, S_IRUGO | S_IWUSR, show_wwan, store_wwan);
1153 static DEVICE_ATTR(display, S_IWUSR, NULL, store_disp);
1154 static DEVICE_ATTR(ledd, S_IRUGO | S_IWUSR, show_ledd, store_ledd);
1155 static DEVICE_ATTR(ls_level, S_IRUGO | S_IWUSR, show_lslvl, store_lslvl);
1156 static DEVICE_ATTR(ls_switch, S_IRUGO | S_IWUSR, show_lssw, store_lssw);
1157 static DEVICE_ATTR(gps, S_IRUGO | S_IWUSR, show_gps, store_gps);
1158
1159 static struct attribute *asus_attributes[] = {
1160         &dev_attr_infos.attr,
1161         &dev_attr_wlan.attr,
1162         &dev_attr_bluetooth.attr,
1163         &dev_attr_wimax.attr,
1164         &dev_attr_wwan.attr,
1165         &dev_attr_display.attr,
1166         &dev_attr_ledd.attr,
1167         &dev_attr_ls_level.attr,
1168         &dev_attr_ls_switch.attr,
1169         &dev_attr_gps.attr,
1170         NULL
1171 };
1172
1173 static mode_t asus_sysfs_is_visible(struct kobject *kobj,
1174                                     struct attribute *attr,
1175                                     int idx)
1176 {
1177         struct device *dev = container_of(kobj, struct device, kobj);
1178         struct platform_device *pdev = to_platform_device(dev);
1179         struct asus_laptop *asus = platform_get_drvdata(pdev);
1180         acpi_handle handle = asus->handle;
1181         bool supported;
1182
1183         if (attr == &dev_attr_wlan.attr) {
1184                 supported = !acpi_check_handle(handle, METHOD_WLAN, NULL);
1185
1186         } else if (attr == &dev_attr_bluetooth.attr) {
1187                 supported = !acpi_check_handle(handle, METHOD_BLUETOOTH, NULL);
1188
1189         } else if (attr == &dev_attr_display.attr) {
1190                 supported = !acpi_check_handle(handle, METHOD_SWITCH_DISPLAY, NULL);
1191
1192         } else if (attr == &dev_attr_wimax.attr) {
1193                 supported =
1194                         !acpi_check_handle(asus->handle, METHOD_WIMAX, NULL);
1195
1196         } else if (attr == &dev_attr_wwan.attr) {
1197                 supported = !acpi_check_handle(asus->handle, METHOD_WWAN, NULL);
1198
1199         } else if (attr == &dev_attr_ledd.attr) {
1200                 supported = !acpi_check_handle(handle, METHOD_LEDD, NULL);
1201
1202         } else if (attr == &dev_attr_ls_switch.attr ||
1203                    attr == &dev_attr_ls_level.attr) {
1204                 supported = !acpi_check_handle(handle, METHOD_ALS_CONTROL, NULL) &&
1205                             !acpi_check_handle(handle, METHOD_ALS_LEVEL, NULL);
1206
1207         } else if (attr == &dev_attr_gps.attr) {
1208                 supported = !acpi_check_handle(handle, METHOD_GPS_ON, NULL) &&
1209                             !acpi_check_handle(handle, METHOD_GPS_OFF, NULL) &&
1210                             !acpi_check_handle(handle, METHOD_GPS_STATUS, NULL);
1211         } else {
1212                 supported = true;
1213         }
1214
1215         return supported ? attr->mode : 0;
1216 }
1217
1218
1219 static const struct attribute_group asus_attr_group = {
1220         .is_visible     = asus_sysfs_is_visible,
1221         .attrs          = asus_attributes,
1222 };
1223
1224 static int asus_platform_init(struct asus_laptop *asus)
1225 {
1226         int result;
1227
1228         asus->platform_device = platform_device_alloc(ASUS_LAPTOP_FILE, -1);
1229         if (!asus->platform_device)
1230                 return -ENOMEM;
1231         platform_set_drvdata(asus->platform_device, asus);
1232
1233         result = platform_device_add(asus->platform_device);
1234         if (result)
1235                 goto fail_platform_device;
1236
1237         result = sysfs_create_group(&asus->platform_device->dev.kobj,
1238                                     &asus_attr_group);
1239         if (result)
1240                 goto fail_sysfs;
1241
1242         return 0;
1243
1244 fail_sysfs:
1245         platform_device_del(asus->platform_device);
1246 fail_platform_device:
1247         platform_device_put(asus->platform_device);
1248         return result;
1249 }
1250
1251 static void asus_platform_exit(struct asus_laptop *asus)
1252 {
1253         sysfs_remove_group(&asus->platform_device->dev.kobj, &asus_attr_group);
1254         platform_device_unregister(asus->platform_device);
1255 }
1256
1257 static struct platform_driver platform_driver = {
1258         .driver = {
1259                 .name = ASUS_LAPTOP_FILE,
1260                 .owner = THIS_MODULE,
1261         }
1262 };
1263
1264 /*
1265  * This function is used to initialize the context with right values. In this
1266  * method, we can make all the detection we want, and modify the asus_laptop
1267  * struct
1268  */
1269 static int asus_laptop_get_info(struct asus_laptop *asus)
1270 {
1271         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1272         union acpi_object *model = NULL;
1273         unsigned long long bsts_result, hwrs_result;
1274         char *string = NULL;
1275         acpi_status status;
1276
1277         /*
1278          * Get DSDT headers early enough to allow for differentiating between
1279          * models, but late enough to allow acpi_bus_register_driver() to fail
1280          * before doing anything ACPI-specific. Should we encounter a machine,
1281          * which needs special handling (i.e. its hotkey device has a different
1282          * HID), this bit will be moved.
1283          */
1284         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus->dsdt_info);
1285         if (ACPI_FAILURE(status))
1286                 pr_warn("Couldn't get the DSDT table header\n");
1287
1288         /* We have to write 0 on init this far for all ASUS models */
1289         if (write_acpi_int_ret(asus->handle, "INIT", 0, &buffer)) {
1290                 pr_err("Hotkey initialization failed\n");
1291                 return -ENODEV;
1292         }
1293
1294         /* This needs to be called for some laptops to init properly */
1295         status =
1296             acpi_evaluate_integer(asus->handle, "BSTS", NULL, &bsts_result);
1297         if (ACPI_FAILURE(status))
1298                 pr_warn("Error calling BSTS\n");
1299         else if (bsts_result)
1300                 pr_notice("BSTS called, 0x%02x returned\n",
1301                        (uint) bsts_result);
1302
1303         /* This too ... */
1304         if (write_acpi_int(asus->handle, "CWAP", wapf))
1305                 pr_err("Error calling CWAP(%d)\n", wapf);
1306         /*
1307          * Try to match the object returned by INIT to the specific model.
1308          * Handle every possible object (or the lack of thereof) the DSDT
1309          * writers might throw at us. When in trouble, we pass NULL to
1310          * asus_model_match() and try something completely different.
1311          */
1312         if (buffer.pointer) {
1313                 model = buffer.pointer;
1314                 switch (model->type) {
1315                 case ACPI_TYPE_STRING:
1316                         string = model->string.pointer;
1317                         break;
1318                 case ACPI_TYPE_BUFFER:
1319                         string = model->buffer.pointer;
1320                         break;
1321                 default:
1322                         string = "";
1323                         break;
1324                 }
1325         }
1326         asus->name = kstrdup(string, GFP_KERNEL);
1327         if (!asus->name) {
1328                 kfree(buffer.pointer);
1329                 return -ENOMEM;
1330         }
1331
1332         if (*string)
1333                 pr_notice("  %s model detected\n", string);
1334
1335         /*
1336          * The HWRS method return informations about the hardware.
1337          * 0x80 bit is for WLAN, 0x100 for Bluetooth,
1338          * 0x40 for WWAN, 0x10 for WIMAX.
1339          * The significance of others is yet to be found.
1340          */
1341         status =
1342             acpi_evaluate_integer(asus->handle, "HRWS", NULL, &hwrs_result);
1343         if (!ACPI_FAILURE(status))
1344                 pr_notice("  HRWS returned %x", (int)hwrs_result);
1345
1346         if (!acpi_check_handle(asus->handle, METHOD_WL_STATUS, NULL))
1347                 asus->have_rsts = true;
1348
1349         kfree(model);
1350
1351         return AE_OK;
1352 }
1353
1354 static int __devinit asus_acpi_init(struct asus_laptop *asus)
1355 {
1356         int result = 0;
1357
1358         result = acpi_bus_get_status(asus->device);
1359         if (result)
1360                 return result;
1361         if (!asus->device->status.present) {
1362                 pr_err("Hotkey device not present, aborting\n");
1363                 return -ENODEV;
1364         }
1365
1366         result = asus_laptop_get_info(asus);
1367         if (result)
1368                 return result;
1369
1370         /* WLED and BLED are on by default */
1371         if (bluetooth_status >= 0)
1372                 asus_bluetooth_set(asus, !!bluetooth_status);
1373
1374         if (wlan_status >= 0)
1375                 asus_wlan_set(asus, !!wlan_status);
1376
1377         if (wimax_status >= 0)
1378                 asus_wimax_set(asus, !!wimax_status);
1379
1380         if (wwan_status >= 0)
1381                 asus_wwan_set(asus, !!wwan_status);
1382
1383         /* Keyboard Backlight is on by default */
1384         if (!acpi_check_handle(asus->handle, METHOD_KBD_LIGHT_SET, NULL))
1385                 asus_kled_set(asus, 1);
1386
1387         /* LED display is off by default */
1388         asus->ledd_status = 0xFFF;
1389
1390         /* Set initial values of light sensor and level */
1391         asus->light_switch = 0; /* Default to light sensor disabled */
1392         asus->light_level = 5;  /* level 5 for sensor sensitivity */
1393
1394         if (!acpi_check_handle(asus->handle, METHOD_ALS_CONTROL, NULL) &&
1395             !acpi_check_handle(asus->handle, METHOD_ALS_LEVEL, NULL)) {
1396                 asus_als_switch(asus, asus->light_switch);
1397                 asus_als_level(asus, asus->light_level);
1398         }
1399
1400         return result;
1401 }
1402
1403 static void __devinit asus_dmi_check(void)
1404 {
1405         const char *model;
1406
1407         model = dmi_get_system_info(DMI_PRODUCT_NAME);
1408         if (!model)
1409                 return;
1410
1411         /* On L1400B WLED control the sound card, don't mess with it ... */
1412         if (strncmp(model, "L1400B", 6) == 0) {
1413                 wlan_status = -1;
1414         }
1415 }
1416
1417 static bool asus_device_present;
1418
1419 static int __devinit asus_acpi_add(struct acpi_device *device)
1420 {
1421         struct asus_laptop *asus;
1422         int result;
1423
1424         pr_notice("Asus Laptop Support version %s\n",
1425                   ASUS_LAPTOP_VERSION);
1426         asus = kzalloc(sizeof(struct asus_laptop), GFP_KERNEL);
1427         if (!asus)
1428                 return -ENOMEM;
1429         asus->handle = device->handle;
1430         strcpy(acpi_device_name(device), ASUS_LAPTOP_DEVICE_NAME);
1431         strcpy(acpi_device_class(device), ASUS_LAPTOP_CLASS);
1432         device->driver_data = asus;
1433         asus->device = device;
1434
1435         asus_dmi_check();
1436
1437         result = asus_acpi_init(asus);
1438         if (result)
1439                 goto fail_platform;
1440
1441         /*
1442          * Register the platform device first.  It is used as a parent for the
1443          * sub-devices below.
1444          */
1445         result = asus_platform_init(asus);
1446         if (result)
1447                 goto fail_platform;
1448
1449         if (!acpi_video_backlight_support()) {
1450                 result = asus_backlight_init(asus);
1451                 if (result)
1452                         goto fail_backlight;
1453         } else
1454                 pr_info("Backlight controlled by ACPI video driver\n");
1455
1456         result = asus_input_init(asus);
1457         if (result)
1458                 goto fail_input;
1459
1460         result = asus_led_init(asus);
1461         if (result)
1462                 goto fail_led;
1463
1464         result = asus_rfkill_init(asus);
1465         if (result)
1466                 goto fail_rfkill;
1467
1468         asus_device_present = true;
1469         return 0;
1470
1471 fail_rfkill:
1472         asus_led_exit(asus);
1473 fail_led:
1474         asus_input_exit(asus);
1475 fail_input:
1476         asus_backlight_exit(asus);
1477 fail_backlight:
1478         asus_platform_exit(asus);
1479 fail_platform:
1480         kfree(asus->name);
1481         kfree(asus);
1482
1483         return result;
1484 }
1485
1486 static int asus_acpi_remove(struct acpi_device *device, int type)
1487 {
1488         struct asus_laptop *asus = acpi_driver_data(device);
1489
1490         asus_backlight_exit(asus);
1491         asus_rfkill_exit(asus);
1492         asus_led_exit(asus);
1493         asus_input_exit(asus);
1494         asus_platform_exit(asus);
1495
1496         kfree(asus->name);
1497         kfree(asus);
1498         return 0;
1499 }
1500
1501 static const struct acpi_device_id asus_device_ids[] = {
1502         {"ATK0100", 0},
1503         {"ATK0101", 0},
1504         {"", 0},
1505 };
1506 MODULE_DEVICE_TABLE(acpi, asus_device_ids);
1507
1508 static struct acpi_driver asus_acpi_driver = {
1509         .name = ASUS_LAPTOP_NAME,
1510         .class = ASUS_LAPTOP_CLASS,
1511         .owner = THIS_MODULE,
1512         .ids = asus_device_ids,
1513         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1514         .ops = {
1515                 .add = asus_acpi_add,
1516                 .remove = asus_acpi_remove,
1517                 .notify = asus_acpi_notify,
1518                 },
1519 };
1520
1521 static int __init asus_laptop_init(void)
1522 {
1523         int result;
1524
1525         result = platform_driver_register(&platform_driver);
1526         if (result < 0)
1527                 return result;
1528
1529         result = acpi_bus_register_driver(&asus_acpi_driver);
1530         if (result < 0)
1531                 goto fail_acpi_driver;
1532         if (!asus_device_present) {
1533                 result = -ENODEV;
1534                 goto fail_no_device;
1535         }
1536         return 0;
1537
1538 fail_no_device:
1539         acpi_bus_unregister_driver(&asus_acpi_driver);
1540 fail_acpi_driver:
1541         platform_driver_unregister(&platform_driver);
1542         return result;
1543 }
1544
1545 static void __exit asus_laptop_exit(void)
1546 {
1547         acpi_bus_unregister_driver(&asus_acpi_driver);
1548         platform_driver_unregister(&platform_driver);
1549 }
1550
1551 module_init(asus_laptop_init);
1552 module_exit(asus_laptop_exit);