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