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  *  Copyright (C) 2011 Wind River Systems
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, write to the Free Software
  21  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  22  *
  23  *
  24  *  The development page for this driver is located at
  25  *  http://sourceforge.net/projects/acpi4asus/
  26  *
  27  *  Credits:
  28  *  Pontus Fuchs   - Helper functions, cleanup
  29  *  Johann Wiesner - Small compile fixes
  30  *  John Belmonte  - ACPI code for Toshiba laptop was a good starting point.
  31  *  Eric Burghard  - LED display support for W1N
  32  *  Josh Green     - Light Sens support
  33  *  Thomas Tuttle  - His first patch for led support was very helpful
  34  *  Sam Lin        - GPS support
  35  */
  36
  37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  38
  39 #include <linux/kernel.h>
  40 #include <linux/module.h>
  41 #include <linux/init.h>
  42 #include <linux/types.h>
  43 #include <linux/err.h>
  44 #include <linux/proc_fs.h>
  45 #include <linux/backlight.h>
  46 #include <linux/fb.h>
  47 #include <linux/leds.h>
  48 #include <linux/platform_device.h>
  49 #include <linux/uaccess.h>
  50 #include <linux/input.h>
  51 #include <linux/input/sparse-keymap.h>
  52 #include <linux/input-polldev.h>
  53 #include <linux/rfkill.h>
  54 #include <linux/slab.h>
  55 #include <linux/dmi.h>
  56 #include <acpi/acpi_drivers.h>
  57 #include <acpi/acpi_bus.h>
  58
  59 #define ASUS_LAPTOP_VERSION     "0.42"
  60
  61 #define ASUS_LAPTOP_NAME        "Asus Laptop Support"
  62 #define ASUS_LAPTOP_CLASS       "hotkey"
  63 #define ASUS_LAPTOP_DEVICE_NAME "Hotkey"
  64 #define ASUS_LAPTOP_FILE        KBUILD_MODNAME
  65 #define ASUS_LAPTOP_PREFIX      "\\_SB.ATKD."
  66
  67 MODULE_AUTHOR("Julien Lerouge, Karol Kozimor, Corentin Chary");
  68 MODULE_DESCRIPTION(ASUS_LAPTOP_NAME);
  69 MODULE_LICENSE("GPL");
  70
  71 /*
  72  * WAPF defines the behavior of the Fn+Fx wlan key
  73  * The significance of values is yet to be found, but
  74  * most of the time:
  75  * Bit | Bluetooth | WLAN
  76  *  0  | Hardware  | Hardware
  77  *  1  | Hardware  | Software
  78  *  4  | Software  | Software
  79  */
  80 static uint wapf = 1;
  81 module_param(wapf, uint, 0444);
  82 MODULE_PARM_DESC(wapf, "WAPF value");
  83
  84 static int wlan_status = 1;
  85 static int bluetooth_status = 1;
  86 static int wimax_status = -1;
  87 static int wwan_status = -1;
  88 static int als_status;
  89
  90 module_param(wlan_status, int, 0444);
  91 MODULE_PARM_DESC(wlan_status, "Set the wireless status on boot "
  92                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
  93                  "default is -1");
  94
  95 module_param(bluetooth_status, int, 0444);
  96 MODULE_PARM_DESC(bluetooth_status, "Set the wireless status on boot "
  97                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
  98                  "default is -1");
  99
 100 module_param(wimax_status, int, 0444);
 101 MODULE_PARM_DESC(wimax_status, "Set the wireless status on boot "
 102                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
 103                  "default is -1");
 104
 105 module_param(wwan_status, int, 0444);
 106 MODULE_PARM_DESC(wwan_status, "Set the wireless status on boot "
 107                  "(0 = disabled, 1 = enabled, -1 = don't do anything). "
 108                  "default is -1");
 109
 110 module_param(als_status, int, 0444);
 111 MODULE_PARM_DESC(als_status, "Set the ALS status on boot "
 112                  "(0 = disabled, 1 = enabled). "
 113                  "default is 0");
 114
 115 /*
 116  * Some events we use, same for all Asus
 117  */
 118 #define ATKD_BR_UP      0x10    /* (event & ~ATKD_BR_UP) = brightness level */
 119 #define ATKD_BR_DOWN    0x20    /* (event & ~ATKD_BR_DOWN) = britghness level */
 120 #define ATKD_BR_MIN     ATKD_BR_UP
 121 #define ATKD_BR_MAX     (ATKD_BR_DOWN | 0xF)    /* 0x2f */
 122 #define ATKD_LCD_ON     0x33
 123 #define ATKD_LCD_OFF    0x34
 124
 125 /*
 126  * Known bits returned by \_SB.ATKD.HWRS
 127  */
 128 #define WL_HWRS         0x80
 129 #define BT_HWRS         0x100
 130
 131 /*
 132  * Flags for hotk status
 133  * WL_ON and BT_ON are also used for wireless_status()
 134  */
 135 #define WL_RSTS         0x01    /* internal Wifi */
 136 #define BT_RSTS         0x02    /* internal Bluetooth */
 137 #define WM_RSTS         0x08    /* internal wimax */
 138 #define WW_RSTS         0x20    /* internal wwan */
 139
 140 /* LED */
 141 #define METHOD_MLED             "MLED"
 142 #define METHOD_TLED             "TLED"
 143 #define METHOD_RLED             "RLED"  /* W1JC */
 144 #define METHOD_PLED             "PLED"  /* A7J */
 145 #define METHOD_GLED             "GLED"  /* G1, G2 (probably) */
 146
 147 /* LEDD */
 148 #define METHOD_LEDD             "SLCM"
 149
 150 /*
 151  * Bluetooth and WLAN
 152  * WLED and BLED are not handled like other XLED, because in some dsdt
 153  * they also control the WLAN/Bluetooth device.
 154  */
 155 #define METHOD_WLAN             "WLED"
 156 #define METHOD_BLUETOOTH        "BLED"
 157
 158 /* WWAN and WIMAX */
 159 #define METHOD_WWAN             "GSMC"
 160 #define METHOD_WIMAX            "WMXC"
 161
 162 #define METHOD_WL_STATUS        "RSTS"
 163
 164 /* Brightness */
 165 #define METHOD_BRIGHTNESS_SET   "SPLV"
 166 #define METHOD_BRIGHTNESS_GET   "GPLV"
 167
 168 /* Display */
 169 #define METHOD_SWITCH_DISPLAY   "SDSP"
 170
 171 #define METHOD_ALS_CONTROL      "ALSC" /* Z71A Z71V */
 172 #define METHOD_ALS_LEVEL        "ALSL" /* Z71A Z71V */
 173
 174 /* GPS */
 175 /* R2H use different handle for GPS on/off */
 176 #define METHOD_GPS_ON           "SDON"
 177 #define METHOD_GPS_OFF          "SDOF"
 178 #define METHOD_GPS_STATUS       "GPST"
 179
 180 /* Keyboard light */
 181 #define METHOD_KBD_LIGHT_SET    "SLKB"
 182 #define METHOD_KBD_LIGHT_GET    "GLKB"
 183
 184 /* For Pegatron Lucid tablet */
 185 #define DEVICE_NAME_PEGA        "Lucid"
 186
 187 #define METHOD_PEGA_ENABLE      "ENPR"
 188 #define METHOD_PEGA_DISABLE     "DAPR"
 189 #define PEGA_WLAN       0x00
 190 #define PEGA_BLUETOOTH  0x01
 191 #define PEGA_WWAN       0x02
 192 #define PEGA_ALS        0x04
 193 #define PEGA_ALS_POWER  0x05
 194
 195 #define METHOD_PEGA_READ        "RDLN"
 196 #define PEGA_READ_ALS_H 0x02
 197 #define PEGA_READ_ALS_L 0x03
 198
 199 #define PEGA_ACCEL_NAME "pega_accel"
 200 #define PEGA_ACCEL_DESC "Pegatron Lucid Tablet Accelerometer"
 201 #define METHOD_XLRX "XLRX"
 202 #define METHOD_XLRY "XLRY"
 203 #define METHOD_XLRZ "XLRZ"
 204 #define PEGA_ACC_CLAMP 512 /* 1G accel is reported as ~256, so clamp to 2G */
 205 #define PEGA_ACC_RETRIES 3
 206
 207 /*
 208  * Define a specific led structure to keep the main structure clean
 209  */
 210 struct asus_led {
 211         int wk;
 212         struct work_struct work;
 213         struct led_classdev led;
 214         struct asus_laptop *asus;
 215         const char *method;
 216 };
 217
 218 /*
 219  * Same thing for rfkill
 220  */
 221 struct asus_pega_rfkill {
 222         int control_id;         /* type of control. Maps to PEGA_* values */
 223         struct rfkill *rfkill;
 224         struct asus_laptop *asus;
 225 };
 226
 227 /*
 228  * This is the main structure, we can use it to store anything interesting
 229  * about the hotk device
 230  */
 231 struct asus_laptop {
 232         char *name;             /* laptop name */
 233
 234         struct acpi_table_header *dsdt_info;
 235         struct platform_device *platform_device;
 236         struct acpi_device *device;             /* the device we are in */
 237         struct backlight_device *backlight_device;
 238
 239         struct input_dev *inputdev;
 240         struct key_entry *keymap;
 241         struct input_polled_dev *pega_accel_poll;
 242
 243         struct asus_led mled;
 244         struct asus_led tled;
 245         struct asus_led rled;
 246         struct asus_led pled;
 247         struct asus_led gled;
 248         struct asus_led kled;
 249         struct workqueue_struct *led_workqueue;
 250
 251         int wireless_status;
 252         bool have_rsts;
 253         bool is_pega_lucid;
 254         bool pega_acc_live;
 255         int pega_acc_x;
 256         int pega_acc_y;
 257         int pega_acc_z;
 258
 259         struct rfkill *gps_rfkill;
 260
 261         struct asus_pega_rfkill wlanrfk;
 262         struct asus_pega_rfkill btrfk;
 263         struct asus_pega_rfkill wwanrfk;
 264
 265         acpi_handle handle;     /* the handle of the hotk device */
 266         u32 ledd_status;        /* status of the LED display */
 267         u8 light_level;         /* light sensor level */
 268         u8 light_switch;        /* light sensor switch value */
 269         u16 event_count[128];   /* count for each event TODO make this better */
 270 };
 271
 272 static const struct key_entry asus_keymap[] = {
 273         /* Lenovo SL Specific keycodes */
 274         {KE_KEY, 0x02, { KEY_SCREENLOCK } },
 275         {KE_KEY, 0x05, { KEY_WLAN } },
 276         {KE_KEY, 0x08, { KEY_F13 } },
 277         {KE_KEY, 0x17, { KEY_ZOOM } },
 278         {KE_KEY, 0x1f, { KEY_BATTERY } },
 279         /* End of Lenovo SL Specific keycodes */
 280         {KE_KEY, 0x30, { KEY_VOLUMEUP } },
 281         {KE_KEY, 0x31, { KEY_VOLUMEDOWN } },
 282         {KE_KEY, 0x32, { KEY_MUTE } },
 283         {KE_KEY, 0x33, { KEY_SWITCHVIDEOMODE } },
 284         {KE_KEY, 0x34, { KEY_SWITCHVIDEOMODE } },
 285         {KE_KEY, 0x40, { KEY_PREVIOUSSONG } },
 286         {KE_KEY, 0x41, { KEY_NEXTSONG } },
 287         {KE_KEY, 0x43, { KEY_STOPCD } },
 288         {KE_KEY, 0x45, { KEY_PLAYPAUSE } },
 289         {KE_KEY, 0x4c, { KEY_MEDIA } },
 290         {KE_KEY, 0x50, { KEY_EMAIL } },
 291         {KE_KEY, 0x51, { KEY_WWW } },
 292         {KE_KEY, 0x55, { KEY_CALC } },
 293         {KE_KEY, 0x5C, { KEY_SCREENLOCK } },  /* Screenlock */
 294         {KE_KEY, 0x5D, { KEY_WLAN } },
 295         {KE_KEY, 0x5E, { KEY_WLAN } },
 296         {KE_KEY, 0x5F, { KEY_WLAN } },
 297         {KE_KEY, 0x60, { KEY_SWITCHVIDEOMODE } },
 298         {KE_KEY, 0x61, { KEY_SWITCHVIDEOMODE } },
 299         {KE_KEY, 0x62, { KEY_SWITCHVIDEOMODE } },
 300         {KE_KEY, 0x63, { KEY_SWITCHVIDEOMODE } },
 301         {KE_KEY, 0x6B, { KEY_F13 } }, /* Lock Touchpad */
 302         {KE_KEY, 0x7E, { KEY_BLUETOOTH } },
 303         {KE_KEY, 0x7D, { KEY_BLUETOOTH } },
 304         {KE_KEY, 0x82, { KEY_CAMERA } },
 305         {KE_KEY, 0x88, { KEY_WLAN  } },
 306         {KE_KEY, 0x8A, { KEY_PROG1 } },
 307         {KE_KEY, 0x95, { KEY_MEDIA } },
 308         {KE_KEY, 0x99, { KEY_PHONE } },
 309         {KE_KEY, 0xc4, { KEY_KBDILLUMUP } },
 310         {KE_KEY, 0xc5, { KEY_KBDILLUMDOWN } },
 311         {KE_KEY, 0xb5, { KEY_CALC } },
 312         {KE_END, 0},
 313 };
 314
 315
 316 /*
 317  * This function evaluates an ACPI method, given an int as parameter, the
 318  * method is searched within the scope of the handle, can be NULL. The output
 319  * of the method is written is output, which can also be NULL
 320  *
 321  * returns 0 if write is successful, -1 else.
 322  */
 323 static int write_acpi_int_ret(acpi_handle handle, const char *method, int val,
 324                               struct acpi_buffer *output)
 325 {
 326         struct acpi_object_list params; /* list of input parameters (an int) */
 327         union acpi_object in_obj;       /* the only param we use */
 328         acpi_status status;
 329
 330         if (!handle)
 331                 return -1;
 332
 333         params.count = 1;
 334         params.pointer = &in_obj;
 335         in_obj.type = ACPI_TYPE_INTEGER;
 336         in_obj.integer.value = val;
 337
 338         status = acpi_evaluate_object(handle, (char *)method, &params, output);
 339         if (status == AE_OK)
 340                 return 0;
 341         else
 342                 return -1;
 343 }
 344
 345 static int write_acpi_int(acpi_handle handle, const char *method, int val)
 346 {
 347         return write_acpi_int_ret(handle, method, val, NULL);
 348 }
 349
 350 static int acpi_check_handle(acpi_handle handle, const char *method,
 351                              acpi_handle *ret)
 352 {
 353         acpi_status status;
 354
 355         if (method == NULL)
 356                 return -ENODEV;
 357
 358         if (ret)
 359                 status = acpi_get_handle(handle, (char *)method,
 360                                          ret);
 361         else {
 362                 acpi_handle dummy;
 363
 364                 status = acpi_get_handle(handle, (char *)method,
 365                                          &dummy);
 366         }
 367
 368         if (status != AE_OK) {
 369                 if (ret)
 370                         pr_warn("Error finding %s\n", method);
 371                 return -ENODEV;
 372         }
 373         return 0;
 374 }
 375
 376 static bool asus_check_pega_lucid(struct asus_laptop *asus)
 377 {
 378         return !strcmp(asus->name, DEVICE_NAME_PEGA) &&
 379            !acpi_check_handle(asus->handle, METHOD_PEGA_ENABLE, NULL) &&
 380            !acpi_check_handle(asus->handle, METHOD_PEGA_DISABLE, NULL) &&
 381            !acpi_check_handle(asus->handle, METHOD_PEGA_READ, NULL);
 382 }
 383
 384 static int asus_pega_lucid_set(struct asus_laptop *asus, int unit, bool enable)
 385 {
 386         char *method = enable ? METHOD_PEGA_ENABLE : METHOD_PEGA_DISABLE;
 387         return write_acpi_int(asus->handle, method, unit);
 388 }
 389
 390 static int pega_acc_axis(struct asus_laptop *asus, int curr, char *method)
 391 {
 392         int i, delta;
 393         unsigned long long val;
 394         for (i = 0; i < PEGA_ACC_RETRIES; i++) {
 395                 acpi_evaluate_integer(asus->handle, method, NULL, &val);
 396
 397                 /* The output is noisy.  From reading the ASL
 398                  * dissassembly, timeout errors are returned with 1's
 399                  * in the high word, and the lack of locking around
 400                  * thei hi/lo byte reads means that a transition
 401                  * between (for example) -1 and 0 could be read as
 402                  * 0xff00 or 0x00ff. */
 403                 delta = abs(curr - (short)val);
 404                 if (delta < 128 && !(val & ~0xffff))
 405                         break;
 406         }
 407         return clamp_val((short)val, -PEGA_ACC_CLAMP, PEGA_ACC_CLAMP);
 408 }
 409
 410 static void pega_accel_poll(struct input_polled_dev *ipd)
 411 {
 412         struct device *parent = ipd->input->dev.parent;
 413         struct asus_laptop *asus = dev_get_drvdata(parent);
 414
 415         /* In some cases, the very first call to poll causes a
 416          * recursive fault under the polldev worker.  This is
 417          * apparently related to very early userspace access to the
 418          * device, and perhaps a firmware bug. Fake the first report. */
 419         if (!asus->pega_acc_live) {
 420                 asus->pega_acc_live = true;
 421                 input_report_abs(ipd->input, ABS_X, 0);
 422                 input_report_abs(ipd->input, ABS_Y, 0);
 423                 input_report_abs(ipd->input, ABS_Z, 0);
 424                 input_sync(ipd->input);
 425                 return;
 426         }
 427
 428         asus->pega_acc_x = pega_acc_axis(asus, asus->pega_acc_x, METHOD_XLRX);
 429         asus->pega_acc_y = pega_acc_axis(asus, asus->pega_acc_y, METHOD_XLRY);
 430         asus->pega_acc_z = pega_acc_axis(asus, asus->pega_acc_z, METHOD_XLRZ);
 431
 432         /* Note transform, convert to "right/up/out" in the native
 433          * landscape orientation (i.e. the vector is the direction of
 434          * "real up" in the device's cartiesian coordinates). */
 435         input_report_abs(ipd->input, ABS_X, -asus->pega_acc_x);
 436         input_report_abs(ipd->input, ABS_Y, -asus->pega_acc_y);
 437         input_report_abs(ipd->input, ABS_Z,  asus->pega_acc_z);
 438         input_sync(ipd->input);
 439 }
 440
 441 static void pega_accel_exit(struct asus_laptop *asus)
 442 {
 443         if (asus->pega_accel_poll) {
 444                 input_unregister_polled_device(asus->pega_accel_poll);
 445                 input_free_polled_device(asus->pega_accel_poll);
 446         }
 447         asus->pega_accel_poll = NULL;
 448 }
 449
 450 static int pega_accel_init(struct asus_laptop *asus)
 451 {
 452         int err;
 453         struct input_polled_dev *ipd;
 454
 455         if (!asus->is_pega_lucid)
 456                 return -ENODEV;
 457
 458         if (acpi_check_handle(asus->handle, METHOD_XLRX, NULL) ||
 459             acpi_check_handle(asus->handle, METHOD_XLRY, NULL) ||
 460             acpi_check_handle(asus->handle, METHOD_XLRZ, NULL))
 461                 return -ENODEV;
 462
 463         ipd = input_allocate_polled_device();
 464         if (!ipd)
 465                 return -ENOMEM;
 466
 467         ipd->poll = pega_accel_poll;
 468         ipd->poll_interval = 125;
 469         ipd->poll_interval_min = 50;
 470         ipd->poll_interval_max = 2000;
 471
 472         ipd->input->name = PEGA_ACCEL_DESC;
 473         ipd->input->phys = PEGA_ACCEL_NAME "/input0";
 474         ipd->input->dev.parent = &asus->platform_device->dev;
 475         ipd->input->id.bustype = BUS_HOST;
 476
 477         set_bit(EV_ABS, ipd->input->evbit);
 478         input_set_abs_params(ipd->input, ABS_X,
 479                              -PEGA_ACC_CLAMP, PEGA_ACC_CLAMP, 0, 0);
 480         input_set_abs_params(ipd->input, ABS_Y,
 481                              -PEGA_ACC_CLAMP, PEGA_ACC_CLAMP, 0, 0);
 482         input_set_abs_params(ipd->input, ABS_Z,
 483                              -PEGA_ACC_CLAMP, PEGA_ACC_CLAMP, 0, 0);
 484
 485         err = input_register_polled_device(ipd);
 486         if (err)
 487                 goto exit;
 488
 489         asus->pega_accel_poll = ipd;
 490         return 0;
 491
 492 exit:
 493         input_free_polled_device(ipd);
 494         return err;
 495 }
 496
 497 /* Generic LED function */
 498 static int asus_led_set(struct asus_laptop *asus, const char *method,
 499                          int value)
 500 {
 501         if (!strcmp(method, METHOD_MLED))
 502                 value = !value;
 503         else if (!strcmp(method, METHOD_GLED))
 504                 value = !value + 1;
 505         else
 506                 value = !!value;
 507
 508         return write_acpi_int(asus->handle, method, value);
 509 }
 510
 511 /*
 512  * LEDs
 513  */
 514 /* /sys/class/led handlers */
 515 static void asus_led_cdev_set(struct led_classdev *led_cdev,
 516                          enum led_brightness value)
 517 {
 518         struct asus_led *led = container_of(led_cdev, struct asus_led, led);
 519         struct asus_laptop *asus = led->asus;
 520
 521         led->wk = !!value;
 522         queue_work(asus->led_workqueue, &led->work);
 523 }
 524
 525 static void asus_led_cdev_update(struct work_struct *work)
 526 {
 527         struct asus_led *led = container_of(work, struct asus_led, work);
 528         struct asus_laptop *asus = led->asus;
 529
 530         asus_led_set(asus, led->method, led->wk);
 531 }
 532
 533 static enum led_brightness asus_led_cdev_get(struct led_classdev *led_cdev)
 534 {
 535         return led_cdev->brightness;
 536 }
 537
 538 /*
 539  * Keyboard backlight (also a LED)
 540  */
 541 static int asus_kled_lvl(struct asus_laptop *asus)
 542 {
 543         unsigned long long kblv;
 544         struct acpi_object_list params;
 545         union acpi_object in_obj;
 546         acpi_status rv;
 547
 548         params.count = 1;
 549         params.pointer = &in_obj;
 550         in_obj.type = ACPI_TYPE_INTEGER;
 551         in_obj.integer.value = 2;
 552
 553         rv = acpi_evaluate_integer(asus->handle, METHOD_KBD_LIGHT_GET,
 554                                    &params, &kblv);
 555         if (ACPI_FAILURE(rv)) {
 556                 pr_warn("Error reading kled level\n");
 557                 return -ENODEV;
 558         }
 559         return kblv;
 560 }
 561
 562 static int asus_kled_set(struct asus_laptop *asus, int kblv)
 563 {
 564         if (kblv > 0)
 565                 kblv = (1 << 7) | (kblv & 0x7F);
 566         else
 567                 kblv = 0;
 568
 569         if (write_acpi_int(asus->handle, METHOD_KBD_LIGHT_SET, kblv)) {
 570                 pr_warn("Keyboard LED display write failed\n");
 571                 return -EINVAL;
 572         }
 573         return 0;
 574 }
 575
 576 static void asus_kled_cdev_set(struct led_classdev *led_cdev,
 577                               enum led_brightness value)
 578 {
 579         struct asus_led *led = container_of(led_cdev, struct asus_led, led);
 580         struct asus_laptop *asus = led->asus;
 581
 582         led->wk = value;
 583         queue_work(asus->led_workqueue, &led->work);
 584 }
 585
 586 static void asus_kled_cdev_update(struct work_struct *work)
 587 {
 588         struct asus_led *led = container_of(work, struct asus_led, work);
 589         struct asus_laptop *asus = led->asus;
 590
 591         asus_kled_set(asus, led->wk);
 592 }
 593
 594 static enum led_brightness asus_kled_cdev_get(struct led_classdev *led_cdev)
 595 {
 596         struct asus_led *led = container_of(led_cdev, struct asus_led, led);
 597         struct asus_laptop *asus = led->asus;
 598
 599         return asus_kled_lvl(asus);
 600 }
 601
 602 static void asus_led_exit(struct asus_laptop *asus)
 603 {
 604         if (!IS_ERR_OR_NULL(asus->mled.led.dev))
 605                 led_classdev_unregister(&asus->mled.led);
 606         if (!IS_ERR_OR_NULL(asus->tled.led.dev))
 607                 led_classdev_unregister(&asus->tled.led);
 608         if (!IS_ERR_OR_NULL(asus->pled.led.dev))
 609                 led_classdev_unregister(&asus->pled.led);
 610         if (!IS_ERR_OR_NULL(asus->rled.led.dev))
 611                 led_classdev_unregister(&asus->rled.led);
 612         if (!IS_ERR_OR_NULL(asus->gled.led.dev))
 613                 led_classdev_unregister(&asus->gled.led);
 614         if (!IS_ERR_OR_NULL(asus->kled.led.dev))
 615                 led_classdev_unregister(&asus->kled.led);
 616         if (asus->led_workqueue) {
 617                 destroy_workqueue(asus->led_workqueue);
 618                 asus->led_workqueue = NULL;
 619         }
 620 }
 621
 622 /*  Ugly macro, need to fix that later */
 623 static int asus_led_register(struct asus_laptop *asus,
 624                              struct asus_led *led,
 625                              const char *name, const char *method)
 626 {
 627         struct led_classdev *led_cdev = &led->led;
 628
 629         if (!method || acpi_check_handle(asus->handle, method, NULL))
 630                 return 0; /* Led not present */
 631
 632         led->asus = asus;
 633         led->method = method;
 634
 635         INIT_WORK(&led->work, asus_led_cdev_update);
 636         led_cdev->name = name;
 637         led_cdev->brightness_set = asus_led_cdev_set;
 638         led_cdev->brightness_get = asus_led_cdev_get;
 639         led_cdev->max_brightness = 1;
 640         return led_classdev_register(&asus->platform_device->dev, led_cdev);
 641 }
 642
 643 static int asus_led_init(struct asus_laptop *asus)
 644 {
 645         int r;
 646
 647         /*
 648          * The Pegatron Lucid has no physical leds, but all methods are
 649          * available in the DSDT...
 650          */
 651         if (asus->is_pega_lucid)
 652                 return 0;
 653
 654         /*
 655          * Functions that actually update the LED's are called from a
 656          * workqueue. By doing this as separate work rather than when the LED
 657          * subsystem asks, we avoid messing with the Asus ACPI stuff during a
 658          * potentially bad time, such as a timer interrupt.
 659          */
 660         asus->led_workqueue = create_singlethread_workqueue("led_workqueue");
 661         if (!asus->led_workqueue)
 662                 return -ENOMEM;
 663
 664         r = asus_led_register(asus, &asus->mled, "asus::mail", METHOD_MLED);
 665         if (r)
 666                 goto error;
 667         r = asus_led_register(asus, &asus->tled, "asus::touchpad", METHOD_TLED);
 668         if (r)
 669                 goto error;
 670         r = asus_led_register(asus, &asus->rled, "asus::record", METHOD_RLED);
 671         if (r)
 672                 goto error;
 673         r = asus_led_register(asus, &asus->pled, "asus::phone", METHOD_PLED);
 674         if (r)
 675                 goto error;
 676         r = asus_led_register(asus, &asus->gled, "asus::gaming", METHOD_GLED);
 677         if (r)
 678                 goto error;
 679         if (!acpi_check_handle(asus->handle, METHOD_KBD_LIGHT_SET, NULL) &&
 680             !acpi_check_handle(asus->handle, METHOD_KBD_LIGHT_GET, NULL)) {
 681                 struct asus_led *led = &asus->kled;
 682                 struct led_classdev *cdev = &led->led;
 683
 684                 led->asus = asus;
 685
 686                 INIT_WORK(&led->work, asus_kled_cdev_update);
 687                 cdev->name = "asus::kbd_backlight";
 688                 cdev->brightness_set = asus_kled_cdev_set;
 689                 cdev->brightness_get = asus_kled_cdev_get;
 690                 cdev->max_brightness = 3;
 691                 r = led_classdev_register(&asus->platform_device->dev, cdev);
 692         }
 693 error:
 694         if (r)
 695                 asus_led_exit(asus);
 696         return r;
 697 }
 698
 699 /*
 700  * Backlight device
 701  */
 702 static int asus_read_brightness(struct backlight_device *bd)
 703 {
 704         struct asus_laptop *asus = bl_get_data(bd);
 705         unsigned long long value;
 706         acpi_status rv = AE_OK;
 707
 708         rv = acpi_evaluate_integer(asus->handle, METHOD_BRIGHTNESS_GET,
 709                                    NULL, &value);
 710         if (ACPI_FAILURE(rv))
 711                 pr_warn("Error reading brightness\n");
 712
 713         return value;
 714 }
 715
 716 static int asus_set_brightness(struct backlight_device *bd, int value)
 717 {
 718         struct asus_laptop *asus = bl_get_data(bd);
 719
 720         if (write_acpi_int(asus->handle, METHOD_BRIGHTNESS_SET, value)) {
 721                 pr_warn("Error changing brightness\n");
 722                 return -EIO;
 723         }
 724         return 0;
 725 }
 726
 727 static int update_bl_status(struct backlight_device *bd)
 728 {
 729         int value = bd->props.brightness;
 730
 731         return asus_set_brightness(bd, value);
 732 }
 733
 734 static const struct backlight_ops asusbl_ops = {
 735         .get_brightness = asus_read_brightness,
 736         .update_status = update_bl_status,
 737 };
 738
 739 static int asus_backlight_notify(struct asus_laptop *asus)
 740 {
 741         struct backlight_device *bd = asus->backlight_device;
 742         int old = bd->props.brightness;
 743
 744         backlight_force_update(bd, BACKLIGHT_UPDATE_HOTKEY);
 745
 746         return old;
 747 }
 748
 749 static int asus_backlight_init(struct asus_laptop *asus)
 750 {
 751         struct backlight_device *bd;
 752         struct backlight_properties props;
 753
 754         if (acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_GET, NULL) ||
 755             acpi_check_handle(asus->handle, METHOD_BRIGHTNESS_SET, NULL))
 756                 return 0;
 757
 758         memset(&props, 0, sizeof(struct backlight_properties));
 759         props.max_brightness = 15;
 760         props.type = BACKLIGHT_PLATFORM;
 761
 762         bd = backlight_device_register(ASUS_LAPTOP_FILE,
 763                                        &asus->platform_device->dev, asus,
 764                                        &asusbl_ops, &props);
 765         if (IS_ERR(bd)) {
 766                 pr_err("Could not register asus backlight device\n");
 767                 asus->backlight_device = NULL;
 768                 return PTR_ERR(bd);
 769         }
 770
 771         asus->backlight_device = bd;
 772         bd->props.brightness = asus_read_brightness(bd);
 773         bd->props.power = FB_BLANK_UNBLANK;
 774         backlight_update_status(bd);
 775         return 0;
 776 }
 777
 778 static void asus_backlight_exit(struct asus_laptop *asus)
 779 {
 780         if (asus->backlight_device)
 781                 backlight_device_unregister(asus->backlight_device);
 782         asus->backlight_device = NULL;
 783 }
 784
 785 /*
 786  * Platform device handlers
 787  */
 788
 789 /*
 790  * We write our info in page, we begin at offset off and cannot write more
 791  * than count bytes. We set eof to 1 if we handle those 2 values. We return the
 792  * number of bytes written in page
 793  */
 794 static ssize_t show_infos(struct device *dev,
 795                           struct device_attribute *attr, char *page)
 796 {
 797         struct asus_laptop *asus = dev_get_drvdata(dev);
 798         int len = 0;
 799         unsigned long long temp;
 800         char buf[16];           /* enough for all info */
 801         acpi_status rv = AE_OK;
 802
 803         /*
 804          * We use the easy way, we don't care of off and count,
 805          * so we don't set eof to 1
 806          */
 807
 808         len += sprintf(page, ASUS_LAPTOP_NAME " " ASUS_LAPTOP_VERSION "\n");
 809         len += sprintf(page + len, "Model reference    : %s\n", asus->name);
 810         /*
 811          * The SFUN method probably allows the original driver to get the list
 812          * of features supported by a given model. For now, 0x0100 or 0x0800
 813          * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
 814          * The significance of others is yet to be found.
 815          */
 816         rv = acpi_evaluate_integer(asus->handle, "SFUN", NULL, &temp);
 817         if (!ACPI_FAILURE(rv))
 818                 len += sprintf(page + len, "SFUN value         : %#x\n",
 819                                (uint) temp);
 820         /*
 821          * The HWRS method return informations about the hardware.
 822          * 0x80 bit is for WLAN, 0x100 for Bluetooth.
 823          * 0x40 for WWAN, 0x10 for WIMAX.
 824          * The significance of others is yet to be found.
 825          * We don't currently use this for device detection, and it
 826          * takes several seconds to run on some systems.
 827          */
 828         rv = acpi_evaluate_integer(asus->handle, "HWRS", NULL, &temp);
 829         if (!ACPI_FAILURE(rv))
 830                 len += sprintf(page + len, "HWRS value         : %#x\n",
 831                                (uint) temp);
 832         /*
 833          * Another value for userspace: the ASYM method returns 0x02 for
 834          * battery low and 0x04 for battery critical, its readings tend to be
 835          * more accurate than those provided by _BST.
 836          * Note: since not all the laptops provide this method, errors are
 837          * silently ignored.
 838          */
 839         rv = acpi_evaluate_integer(asus->handle, "ASYM", NULL, &temp);
 840         if (!ACPI_FAILURE(rv))
 841                 len += sprintf(page + len, "ASYM value         : %#x\n",
 842                                (uint) temp);
 843         if (asus->dsdt_info) {
 844                 snprintf(buf, 16, "%d", asus->dsdt_info->length);
 845                 len += sprintf(page + len, "DSDT length        : %s\n", buf);
 846                 snprintf(buf, 16, "%d", asus->dsdt_info->checksum);
 847                 len += sprintf(page + len, "DSDT checksum      : %s\n", buf);
 848                 snprintf(buf, 16, "%d", asus->dsdt_info->revision);
 849                 len += sprintf(page + len, "DSDT revision      : %s\n", buf);
 850                 snprintf(buf, 7, "%s", asus->dsdt_info->oem_id);
 851                 len += sprintf(page + len, "OEM id             : %s\n", buf);
 852                 snprintf(buf, 9, "%s", asus->dsdt_info->oem_table_id);
 853                 len += sprintf(page + len, "OEM table id       : %s\n", buf);
 854                 snprintf(buf, 16, "%x", asus->dsdt_info->oem_revision);
 855                 len += sprintf(page + len, "OEM revision       : 0x%s\n", buf);
 856                 snprintf(buf, 5, "%s", asus->dsdt_info->asl_compiler_id);
 857                 len += sprintf(page + len, "ASL comp vendor id : %s\n", buf);
 858                 snprintf(buf, 16, "%x", asus->dsdt_info->asl_compiler_revision);
 859                 len += sprintf(page + len, "ASL comp revision  : 0x%s\n", buf);
 860         }
 861
 862         return len;
 863 }
 864
 865 static int parse_arg(const char *buf, unsigned long count, int *val)
 866 {
 867         if (!count)
 868                 return 0;
 869         if (count > 31)
 870                 return -EINVAL;
 871         if (sscanf(buf, "%i", val) != 1)
 872                 return -EINVAL;
 873         return count;
 874 }
 875
 876 static ssize_t sysfs_acpi_set(struct asus_laptop *asus,
 877                               const char *buf, size_t count,
 878                               const char *method)
 879 {
 880         int rv, value;
 881         int out = 0;
 882
 883         rv = parse_arg(buf, count, &value);
 884         if (rv > 0)
 885                 out = value ? 1 : 0;
 886
 887         if (write_acpi_int(asus->handle, method, value))
 888                 return -ENODEV;
 889         return rv;
 890 }
 891
 892 /*
 893  * LEDD display
 894  */
 895 static ssize_t show_ledd(struct device *dev,
 896                          struct device_attribute *attr, char *buf)
 897 {
 898         struct asus_laptop *asus = dev_get_drvdata(dev);
 899
 900         return sprintf(buf, "0x%08x\n", asus->ledd_status);
 901 }
 902
 903 static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
 904                           const char *buf, size_t count)
 905 {
 906         struct asus_laptop *asus = dev_get_drvdata(dev);
 907         int rv, value;
 908
 909         rv = parse_arg(buf, count, &value);
 910         if (rv > 0) {
 911                 if (write_acpi_int(asus->handle, METHOD_LEDD, value)) {
 912                         pr_warn("LED display write failed\n");
 913                         return -ENODEV;
 914                 }
 915                 asus->ledd_status = (u32) value;
 916         }
 917         return rv;
 918 }
 919
 920 /*
 921  * Wireless
 922  */
 923 static int asus_wireless_status(struct asus_laptop *asus, int mask)
 924 {
 925         unsigned long long status;
 926         acpi_status rv = AE_OK;
 927
 928         if (!asus->have_rsts)
 929                 return (asus->wireless_status & mask) ? 1 : 0;
 930
 931         rv = acpi_evaluate_integer(asus->handle, METHOD_WL_STATUS,
 932                                    NULL, &status);
 933         if (ACPI_FAILURE(rv)) {
 934                 pr_warn("Error reading Wireless status\n");
 935                 return -EINVAL;
 936         }
 937         return !!(status & mask);
 938 }
 939
 940 /*
 941  * WLAN
 942  */
 943 static int asus_wlan_set(struct asus_laptop *asus, int status)
 944 {
 945         if (write_acpi_int(asus->handle, METHOD_WLAN, !!status)) {
 946                 pr_warn("Error setting wlan status to %d\n", status);
 947                 return -EIO;
 948         }
 949         return 0;
 950 }
 951
 952 static ssize_t show_wlan(struct device *dev,
 953                          struct device_attribute *attr, char *buf)
 954 {
 955         struct asus_laptop *asus = dev_get_drvdata(dev);
 956
 957         return sprintf(buf, "%d\n", asus_wireless_status(asus, WL_RSTS));
 958 }
 959
 960 static ssize_t store_wlan(struct device *dev, struct device_attribute *attr,
 961                           const char *buf, size_t count)
 962 {
 963         struct asus_laptop *asus = dev_get_drvdata(dev);
 964
 965         return sysfs_acpi_set(asus, buf, count, METHOD_WLAN);
 966 }
 967
 968 /*
 969  * Bluetooth
 970  */
 971 static int asus_bluetooth_set(struct asus_laptop *asus, int status)
 972 {
 973         if (write_acpi_int(asus->handle, METHOD_BLUETOOTH, !!status)) {
 974                 pr_warn("Error setting bluetooth status to %d\n", status);
 975                 return -EIO;
 976         }
 977         return 0;
 978 }
 979
 980 static ssize_t show_bluetooth(struct device *dev,
 981                               struct device_attribute *attr, char *buf)
 982 {
 983         struct asus_laptop *asus = dev_get_drvdata(dev);
 984
 985         return sprintf(buf, "%d\n", asus_wireless_status(asus, BT_RSTS));
 986 }
 987
 988 static ssize_t store_bluetooth(struct device *dev,
 989                                struct device_attribute *attr, const char *buf,
 990                                size_t count)
 991 {
 992         struct asus_laptop *asus = dev_get_drvdata(dev);
 993
 994         return sysfs_acpi_set(asus, buf, count, METHOD_BLUETOOTH);
 995 }
 996
 997 /*
 998  * Wimax
 999  */
1000 static int asus_wimax_set(struct asus_laptop *asus, int status)
1001 {
1002         if (write_acpi_int(asus->handle, METHOD_WIMAX, !!status)) {
1003                 pr_warn("Error setting wimax status to %d\n", status);
1004                 return -EIO;
1005         }
1006         return 0;
1007 }
1008
1009 static ssize_t show_wimax(struct device *dev,
1010                               struct device_attribute *attr, char *buf)
1011 {
1012         struct asus_laptop *asus = dev_get_drvdata(dev);
1013
1014         return sprintf(buf, "%d\n", asus_wireless_status(asus, WM_RSTS));
1015 }
1016
1017 static ssize_t store_wimax(struct device *dev,
1018                                struct device_attribute *attr, const char *buf,
1019                                size_t count)
1020 {
1021         struct asus_laptop *asus = dev_get_drvdata(dev);
1022
1023         return sysfs_acpi_set(asus, buf, count, METHOD_WIMAX);
1024 }
1025
1026 /*
1027  * Wwan
1028  */
1029 static int asus_wwan_set(struct asus_laptop *asus, int status)
1030 {
1031         if (write_acpi_int(asus->handle, METHOD_WWAN, !!status)) {
1032                 pr_warn("Error setting wwan status to %d\n", status);
1033                 return -EIO;
1034         }
1035         return 0;
1036 }
1037
1038 static ssize_t show_wwan(struct device *dev,
1039                               struct device_attribute *attr, char *buf)
1040 {
1041         struct asus_laptop *asus = dev_get_drvdata(dev);
1042
1043         return sprintf(buf, "%d\n", asus_wireless_status(asus, WW_RSTS));
1044 }
1045
1046 static ssize_t store_wwan(struct device *dev,
1047                                struct device_attribute *attr, const char *buf,
1048                                size_t count)
1049 {
1050         struct asus_laptop *asus = dev_get_drvdata(dev);
1051
1052         return sysfs_acpi_set(asus, buf, count, METHOD_WWAN);
1053 }
1054
1055 /*
1056  * Display
1057  */
1058 static void asus_set_display(struct asus_laptop *asus, int value)
1059 {
1060         /* no sanity check needed for now */
1061         if (write_acpi_int(asus->handle, METHOD_SWITCH_DISPLAY, value))
1062                 pr_warn("Error setting display\n");
1063         return;
1064 }
1065
1066 /*
1067  * Experimental support for display switching. As of now: 1 should activate
1068  * the LCD output, 2 should do for CRT, 4 for TV-Out and 8 for DVI.
1069  * Any combination (bitwise) of these will suffice. I never actually tested 4
1070  * displays hooked up simultaneously, so be warned. See the acpi4asus README
1071  * for more info.
1072  */
1073 static ssize_t store_disp(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                 asus_set_display(asus, value);
1082         return rv;
1083 }
1084
1085 /*
1086  * Light Sens
1087  */
1088 static void asus_als_switch(struct asus_laptop *asus, int value)
1089 {
1090         int ret;
1091
1092         if (asus->is_pega_lucid) {
1093                 ret = asus_pega_lucid_set(asus, PEGA_ALS, value);
1094                 if (!ret)
1095                         ret = asus_pega_lucid_set(asus, PEGA_ALS_POWER, value);
1096         } else {
1097                 ret = write_acpi_int(asus->handle, METHOD_ALS_CONTROL, value);
1098         }
1099         if (ret)
1100                 pr_warning("Error setting light sensor switch\n");
1101
1102         asus->light_switch = value;
1103 }
1104
1105 static ssize_t show_lssw(struct device *dev,
1106                          struct device_attribute *attr, char *buf)
1107 {
1108         struct asus_laptop *asus = dev_get_drvdata(dev);
1109
1110         return sprintf(buf, "%d\n", asus->light_switch);
1111 }
1112
1113 static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
1114                           const char *buf, size_t count)
1115 {
1116         struct asus_laptop *asus = dev_get_drvdata(dev);
1117         int rv, value;
1118
1119         rv = parse_arg(buf, count, &value);
1120         if (rv > 0)
1121                 asus_als_switch(asus, value ? 1 : 0);
1122
1123         return rv;
1124 }
1125
1126 static void asus_als_level(struct asus_laptop *asus, int value)
1127 {
1128         if (write_acpi_int(asus->handle, METHOD_ALS_LEVEL, value))
1129                 pr_warn("Error setting light sensor level\n");
1130         asus->light_level = value;
1131 }
1132
1133 static ssize_t show_lslvl(struct device *dev,
1134                           struct device_attribute *attr, char *buf)
1135 {
1136         struct asus_laptop *asus = dev_get_drvdata(dev);
1137
1138         return sprintf(buf, "%d\n", asus->light_level);
1139 }
1140
1141 static ssize_t store_lslvl(struct device *dev, struct device_attribute *attr,
1142                            const char *buf, size_t count)
1143 {
1144         struct asus_laptop *asus = dev_get_drvdata(dev);
1145         int rv, value;
1146
1147         rv = parse_arg(buf, count, &value);
1148         if (rv > 0) {
1149                 value = (0 < value) ? ((15 < value) ? 15 : value) : 0;
1150                 /* 0 <= value <= 15 */
1151                 asus_als_level(asus, value);
1152         }
1153
1154         return rv;
1155 }
1156
1157 static int pega_int_read(struct asus_laptop *asus, int arg, int *result)
1158 {
1159         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1160         int err = write_acpi_int_ret(asus->handle, METHOD_PEGA_READ, arg,
1161                                      &buffer);
1162         if (!err) {
1163                 union acpi_object *obj = buffer.pointer;
1164                 if (obj && obj->type == ACPI_TYPE_INTEGER)
1165                         *result = obj->integer.value;
1166                 else
1167                         err = -EIO;
1168         }
1169         return err;
1170 }
1171
1172 static ssize_t show_lsvalue(struct device *dev,
1173                             struct device_attribute *attr, char *buf)
1174 {
1175         struct asus_laptop *asus = dev_get_drvdata(dev);
1176         int err, hi, lo;
1177
1178         err = pega_int_read(asus, PEGA_READ_ALS_H, &hi);
1179         if (!err)
1180                 err = pega_int_read(asus, PEGA_READ_ALS_L, &lo);
1181         if (!err)
1182                 return sprintf(buf, "%d\n", 10 * hi + lo);
1183         return err;
1184 }
1185
1186 /*
1187  * GPS
1188  */
1189 static int asus_gps_status(struct asus_laptop *asus)
1190 {
1191         unsigned long long status;
1192         acpi_status rv = AE_OK;
1193
1194         rv = acpi_evaluate_integer(asus->handle, METHOD_GPS_STATUS,
1195                                    NULL, &status);
1196         if (ACPI_FAILURE(rv)) {
1197                 pr_warn("Error reading GPS status\n");
1198                 return -ENODEV;
1199         }
1200         return !!status;
1201 }
1202
1203 static int asus_gps_switch(struct asus_laptop *asus, int status)
1204 {
1205         const char *meth = status ? METHOD_GPS_ON : METHOD_GPS_OFF;
1206
1207         if (write_acpi_int(asus->handle, meth, 0x02))
1208                 return -ENODEV;
1209         return 0;
1210 }
1211
1212 static ssize_t show_gps(struct device *dev,
1213                         struct device_attribute *attr, char *buf)
1214 {
1215         struct asus_laptop *asus = dev_get_drvdata(dev);
1216
1217         return sprintf(buf, "%d\n", asus_gps_status(asus));
1218 }
1219
1220 static ssize_t store_gps(struct device *dev, struct device_attribute *attr,
1221                          const char *buf, size_t count)
1222 {
1223         struct asus_laptop *asus = dev_get_drvdata(dev);
1224         int rv, value;
1225         int ret;
1226
1227         rv = parse_arg(buf, count, &value);
1228         if (rv <= 0)
1229                 return -EINVAL;
1230         ret = asus_gps_switch(asus, !!value);
1231         if (ret)
1232                 return ret;
1233         rfkill_set_sw_state(asus->gps_rfkill, !value);
1234         return rv;
1235 }
1236
1237 /*
1238  * rfkill
1239  */
1240 static int asus_gps_rfkill_set(void *data, bool blocked)
1241 {
1242         struct asus_laptop *asus = data;
1243
1244         return asus_gps_switch(asus, !blocked);
1245 }
1246
1247 static const struct rfkill_ops asus_gps_rfkill_ops = {
1248         .set_block = asus_gps_rfkill_set,
1249 };
1250
1251 static void asus_rfkill_exit(struct asus_laptop *asus)
1252 {
1253         if (asus->gps_rfkill) {
1254                 rfkill_unregister(asus->gps_rfkill);
1255                 rfkill_destroy(asus->gps_rfkill);
1256                 asus->gps_rfkill = NULL;
1257         }
1258 }
1259
1260 static int asus_rfkill_init(struct asus_laptop *asus)
1261 {
1262         int result;
1263
1264         if (acpi_check_handle(asus->handle, METHOD_GPS_ON, NULL) ||
1265             acpi_check_handle(asus->handle, METHOD_GPS_OFF, NULL) ||
1266             acpi_check_handle(asus->handle, METHOD_GPS_STATUS, NULL))
1267                 return 0;
1268
1269         asus->gps_rfkill = rfkill_alloc("asus-gps", &asus->platform_device->dev,
1270                                         RFKILL_TYPE_GPS,
1271                                         &asus_gps_rfkill_ops, asus);
1272         if (!asus->gps_rfkill)
1273                 return -EINVAL;
1274
1275         result = rfkill_register(asus->gps_rfkill);
1276         if (result) {
1277                 rfkill_destroy(asus->gps_rfkill);
1278                 asus->gps_rfkill = NULL;
1279         }
1280
1281         return result;
1282 }
1283
1284 static int pega_rfkill_set(void *data, bool blocked)
1285 {
1286         struct asus_pega_rfkill *pega_rfk = data;
1287
1288         int ret = asus_pega_lucid_set(pega_rfk->asus, pega_rfk->control_id, !blocked);
1289         pr_warn("Setting rfkill %d, to %d; returned %d\n", pega_rfk->control_id, !blocked, ret);
1290
1291         return ret;
1292 }
1293
1294 static const struct rfkill_ops pega_rfkill_ops = {
1295         .set_block = pega_rfkill_set,
1296 };
1297
1298 static void pega_rfkill_terminate(struct asus_pega_rfkill *pega_rfk)
1299 {
1300         pr_warn("Terminating %d\n", pega_rfk->control_id);
1301         if (pega_rfk->rfkill) {
1302                 rfkill_unregister(pega_rfk->rfkill);
1303                 rfkill_destroy(pega_rfk->rfkill);
1304                 pega_rfk->rfkill = NULL;
1305         }
1306 }
1307
1308 static void pega_rfkill_exit(struct asus_laptop *asus)
1309 {
1310         pega_rfkill_terminate(&asus->wwanrfk);
1311         pega_rfkill_terminate(&asus->btrfk);
1312         pega_rfkill_terminate(&asus->wlanrfk);
1313 }
1314
1315 static int pega_rfkill_setup(struct asus_laptop *asus, struct asus_pega_rfkill *pega_rfk,
1316                 const char *name, int controlid, int rfkill_type)
1317 {
1318         int result;
1319
1320         pr_warn("Setting up rfk %s, control %d, type %d\n", name, controlid, rfkill_type);
1321         pega_rfk->control_id = controlid;
1322         pega_rfk->asus = asus;
1323         pega_rfk->rfkill = rfkill_alloc(name, &asus->platform_device->dev,
1324                                         rfkill_type, &pega_rfkill_ops, pega_rfk);
1325         if (!pega_rfk->rfkill)
1326                 return -EINVAL;
1327
1328         result = rfkill_register(pega_rfk->rfkill);
1329         if (result) {
1330                 rfkill_destroy(pega_rfk->rfkill);
1331                 pega_rfk->rfkill = NULL;
1332         }
1333
1334         return result;
1335 }
1336
1337 static int pega_rfkill_init(struct asus_laptop *asus)
1338 {
1339         int ret = 0;
1340
1341         if(!asus->is_pega_lucid)
1342                 return -ENODEV;
1343
1344         ret = pega_rfkill_setup(asus, &asus->wlanrfk, "pega-wlan", PEGA_WLAN, RFKILL_TYPE_WLAN);
1345         if(ret)
1346                 return ret;
1347         ret = pega_rfkill_setup(asus, &asus->btrfk, "pega-bt", PEGA_BLUETOOTH, RFKILL_TYPE_BLUETOOTH);
1348         if(ret)
1349                 goto err_btrfk;
1350         ret = pega_rfkill_setup(asus, &asus->wwanrfk, "pega-wwan", PEGA_WWAN, RFKILL_TYPE_WWAN);
1351         if(ret)
1352                 goto err_wwanrfk;
1353
1354         pr_warn("Pega rfkill init succeeded\n");
1355         return 0;
1356 err_wwanrfk:
1357         pega_rfkill_terminate(&asus->btrfk);
1358 err_btrfk:
1359         pega_rfkill_terminate(&asus->wlanrfk);
1360
1361         return ret;
1362 }
1363
1364 /*
1365  * Input device (i.e. hotkeys)
1366  */
1367 static void asus_input_notify(struct asus_laptop *asus, int event)
1368 {
1369         if (asus->inputdev)
1370                 sparse_keymap_report_event(asus->inputdev, event, 1, true);
1371 }
1372
1373 static int asus_input_init(struct asus_laptop *asus)
1374 {
1375         struct input_dev *input;
1376         int error;
1377
1378         input = input_allocate_device();
1379         if (!input) {
1380                 pr_info("Unable to allocate input device\n");
1381                 return -ENOMEM;
1382         }
1383         input->name = "Asus Laptop extra buttons";
1384         input->phys = ASUS_LAPTOP_FILE "/input0";
1385         input->id.bustype = BUS_HOST;
1386         input->dev.parent = &asus->platform_device->dev;
1387
1388         error = sparse_keymap_setup(input, asus_keymap, NULL);
1389         if (error) {
1390                 pr_err("Unable to setup input device keymap\n");
1391                 goto err_free_dev;
1392         }
1393         error = input_register_device(input);
1394         if (error) {
1395                 pr_info("Unable to register input device\n");
1396                 goto err_free_keymap;
1397         }
1398
1399         asus->inputdev = input;
1400         return 0;
1401
1402 err_free_keymap:
1403         sparse_keymap_free(input);
1404 err_free_dev:
1405         input_free_device(input);
1406         return error;
1407 }
1408
1409 static void asus_input_exit(struct asus_laptop *asus)
1410 {
1411         if (asus->inputdev) {
1412                 sparse_keymap_free(asus->inputdev);
1413                 input_unregister_device(asus->inputdev);
1414         }
1415         asus->inputdev = NULL;
1416 }
1417
1418 /*
1419  * ACPI driver
1420  */
1421 static void asus_acpi_notify(struct acpi_device *device, u32 event)
1422 {
1423         struct asus_laptop *asus = acpi_driver_data(device);
1424         u16 count;
1425
1426         /* TODO Find a better way to handle events count. */
1427         count = asus->event_count[event % 128]++;
1428         acpi_bus_generate_proc_event(asus->device, event, count);
1429         acpi_bus_generate_netlink_event(asus->device->pnp.device_class,
1430                                         dev_name(&asus->device->dev), event,
1431                                         count);
1432
1433         /* Brightness events are special */
1434         if (event >= ATKD_BR_MIN && event <= ATKD_BR_MAX) {
1435
1436                 /* Ignore them completely if the acpi video driver is used */
1437                 if (asus->backlight_device != NULL) {
1438                         /* Update the backlight device. */
1439                         asus_backlight_notify(asus);
1440                 }
1441                 return ;
1442         }
1443
1444         /* Accelerometer "coarse orientation change" event */
1445         if (asus->pega_accel_poll && event == 0xEA) {
1446                 kobject_uevent(&asus->pega_accel_poll->input->dev.kobj,
1447                                KOBJ_CHANGE);
1448                 return ;
1449         }
1450
1451         asus_input_notify(asus, event);
1452 }
1453
1454 static DEVICE_ATTR(infos, S_IRUGO, show_infos, NULL);
1455 static DEVICE_ATTR(wlan, S_IRUGO | S_IWUSR, show_wlan, store_wlan);
1456 static DEVICE_ATTR(bluetooth, S_IRUGO | S_IWUSR,
1457                    show_bluetooth, store_bluetooth);
1458 static DEVICE_ATTR(wimax, S_IRUGO | S_IWUSR, show_wimax, store_wimax);
1459 static DEVICE_ATTR(wwan, S_IRUGO | S_IWUSR, show_wwan, store_wwan);
1460 static DEVICE_ATTR(display, S_IWUSR, NULL, store_disp);
1461 static DEVICE_ATTR(ledd, S_IRUGO | S_IWUSR, show_ledd, store_ledd);
1462 static DEVICE_ATTR(ls_value, S_IRUGO, show_lsvalue, NULL);
1463 static DEVICE_ATTR(ls_level, S_IRUGO | S_IWUSR, show_lslvl, store_lslvl);
1464 static DEVICE_ATTR(ls_switch, S_IRUGO | S_IWUSR, show_lssw, store_lssw);
1465 static DEVICE_ATTR(gps, S_IRUGO | S_IWUSR, show_gps, store_gps);
1466
1467 static struct attribute *asus_attributes[] = {
1468         &dev_attr_infos.attr,
1469         &dev_attr_wlan.attr,
1470         &dev_attr_bluetooth.attr,
1471         &dev_attr_wimax.attr,
1472         &dev_attr_wwan.attr,
1473         &dev_attr_display.attr,
1474         &dev_attr_ledd.attr,
1475         &dev_attr_ls_value.attr,
1476         &dev_attr_ls_level.attr,
1477         &dev_attr_ls_switch.attr,
1478         &dev_attr_gps.attr,
1479         NULL
1480 };
1481
1482 static mode_t asus_sysfs_is_visible(struct kobject *kobj,
1483                                     struct attribute *attr,
1484                                     int idx)
1485 {
1486         struct device *dev = container_of(kobj, struct device, kobj);
1487         struct platform_device *pdev = to_platform_device(dev);
1488         struct asus_laptop *asus = platform_get_drvdata(pdev);
1489         acpi_handle handle = asus->handle;
1490         bool supported;
1491
1492         if (asus->is_pega_lucid) {
1493                 /* no ls_level interface on the Lucid */
1494                 if (attr == &dev_attr_ls_switch.attr)
1495                         supported = true;
1496                 else if (attr == &dev_attr_ls_level.attr)
1497                         supported = false;
1498                 else
1499                         goto normal;
1500
1501                 return supported;
1502         }
1503
1504 normal:
1505         if (attr == &dev_attr_wlan.attr) {
1506                 supported = !acpi_check_handle(handle, METHOD_WLAN, NULL);
1507
1508         } else if (attr == &dev_attr_bluetooth.attr) {
1509                 supported = !acpi_check_handle(handle, METHOD_BLUETOOTH, NULL);
1510
1511         } else if (attr == &dev_attr_display.attr) {
1512                 supported = !acpi_check_handle(handle, METHOD_SWITCH_DISPLAY, NULL);
1513
1514         } else if (attr == &dev_attr_wimax.attr) {
1515                 supported =
1516                         !acpi_check_handle(asus->handle, METHOD_WIMAX, NULL);
1517
1518         } else if (attr == &dev_attr_wwan.attr) {
1519                 supported = !acpi_check_handle(asus->handle, METHOD_WWAN, NULL);
1520
1521         } else if (attr == &dev_attr_ledd.attr) {
1522                 supported = !acpi_check_handle(handle, METHOD_LEDD, NULL);
1523
1524         } else if (attr == &dev_attr_ls_switch.attr ||
1525                    attr == &dev_attr_ls_level.attr) {
1526                 supported = !acpi_check_handle(handle, METHOD_ALS_CONTROL, NULL) &&
1527                         !acpi_check_handle(handle, METHOD_ALS_LEVEL, NULL);
1528         } else if (attr == &dev_attr_ls_value.attr) {
1529                 supported = asus->is_pega_lucid;
1530         } else if (attr == &dev_attr_gps.attr) {
1531                 supported = !acpi_check_handle(handle, METHOD_GPS_ON, NULL) &&
1532                             !acpi_check_handle(handle, METHOD_GPS_OFF, NULL) &&
1533                             !acpi_check_handle(handle, METHOD_GPS_STATUS, NULL);
1534         } else {
1535                 supported = true;
1536         }
1537
1538         return supported ? attr->mode : 0;
1539 }
1540
1541
1542 static const struct attribute_group asus_attr_group = {
1543         .is_visible     = asus_sysfs_is_visible,
1544         .attrs          = asus_attributes,
1545 };
1546
1547 static int asus_platform_init(struct asus_laptop *asus)
1548 {
1549         int result;
1550
1551         asus->platform_device = platform_device_alloc(ASUS_LAPTOP_FILE, -1);
1552         if (!asus->platform_device)
1553                 return -ENOMEM;
1554         platform_set_drvdata(asus->platform_device, asus);
1555
1556         result = platform_device_add(asus->platform_device);
1557         if (result)
1558                 goto fail_platform_device;
1559
1560         result = sysfs_create_group(&asus->platform_device->dev.kobj,
1561                                     &asus_attr_group);
1562         if (result)
1563                 goto fail_sysfs;
1564
1565         return 0;
1566
1567 fail_sysfs:
1568         platform_device_del(asus->platform_device);
1569 fail_platform_device:
1570         platform_device_put(asus->platform_device);
1571         return result;
1572 }
1573
1574 static void asus_platform_exit(struct asus_laptop *asus)
1575 {
1576         sysfs_remove_group(&asus->platform_device->dev.kobj, &asus_attr_group);
1577         platform_device_unregister(asus->platform_device);
1578 }
1579
1580 static struct platform_driver platform_driver = {
1581         .driver = {
1582                 .name = ASUS_LAPTOP_FILE,
1583                 .owner = THIS_MODULE,
1584         },
1585 };
1586
1587 /*
1588  * This function is used to initialize the context with right values. In this
1589  * method, we can make all the detection we want, and modify the asus_laptop
1590  * struct
1591  */
1592 static int asus_laptop_get_info(struct asus_laptop *asus)
1593 {
1594         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
1595         union acpi_object *model = NULL;
1596         unsigned long long bsts_result;
1597         char *string = NULL;
1598         acpi_status status;
1599
1600         /*
1601          * Get DSDT headers early enough to allow for differentiating between
1602          * models, but late enough to allow acpi_bus_register_driver() to fail
1603          * before doing anything ACPI-specific. Should we encounter a machine,
1604          * which needs special handling (i.e. its hotkey device has a different
1605          * HID), this bit will be moved.
1606          */
1607         status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus->dsdt_info);
1608         if (ACPI_FAILURE(status))
1609                 pr_warn("Couldn't get the DSDT table header\n");
1610
1611         /* We have to write 0 on init this far for all ASUS models */
1612         if (write_acpi_int_ret(asus->handle, "INIT", 0, &buffer)) {
1613                 pr_err("Hotkey initialization failed\n");
1614                 return -ENODEV;
1615         }
1616
1617         /* This needs to be called for some laptops to init properly */
1618         status =
1619             acpi_evaluate_integer(asus->handle, "BSTS", NULL, &bsts_result);
1620         if (ACPI_FAILURE(status))
1621                 pr_warn("Error calling BSTS\n");
1622         else if (bsts_result)
1623                 pr_notice("BSTS called, 0x%02x returned\n",
1624                        (uint) bsts_result);
1625
1626         /* This too ... */
1627         if (write_acpi_int(asus->handle, "CWAP", wapf))
1628                 pr_err("Error calling CWAP(%d)\n", wapf);
1629         /*
1630          * Try to match the object returned by INIT to the specific model.
1631          * Handle every possible object (or the lack of thereof) the DSDT
1632          * writers might throw at us. When in trouble, we pass NULL to
1633          * asus_model_match() and try something completely different.
1634          */
1635         if (buffer.pointer) {
1636                 model = buffer.pointer;
1637                 switch (model->type) {
1638                 case ACPI_TYPE_STRING:
1639                         string = model->string.pointer;
1640                         break;
1641                 case ACPI_TYPE_BUFFER:
1642                         string = model->buffer.pointer;
1643                         break;
1644                 default:
1645                         string = "";
1646                         break;
1647                 }
1648         }
1649         asus->name = kstrdup(string, GFP_KERNEL);
1650         if (!asus->name) {
1651                 kfree(buffer.pointer);
1652                 return -ENOMEM;
1653         }
1654
1655         if (*string)
1656                 pr_notice("  %s model detected\n", string);
1657
1658         if (!acpi_check_handle(asus->handle, METHOD_WL_STATUS, NULL))
1659                 asus->have_rsts = true;
1660
1661         kfree(model);
1662
1663         return AE_OK;
1664 }
1665
1666 static int __devinit asus_acpi_init(struct asus_laptop *asus)
1667 {
1668         int result = 0;
1669
1670         result = acpi_bus_get_status(asus->device);
1671         if (result)
1672                 return result;
1673         if (!asus->device->status.present) {
1674                 pr_err("Hotkey device not present, aborting\n");
1675                 return -ENODEV;
1676         }
1677
1678         result = asus_laptop_get_info(asus);
1679         if (result)
1680                 return result;
1681
1682         /* WLED and BLED are on by default */
1683         if (bluetooth_status >= 0)
1684                 asus_bluetooth_set(asus, !!bluetooth_status);
1685
1686         if (wlan_status >= 0)
1687                 asus_wlan_set(asus, !!wlan_status);
1688
1689         if (wimax_status >= 0)
1690                 asus_wimax_set(asus, !!wimax_status);
1691
1692         if (wwan_status >= 0)
1693                 asus_wwan_set(asus, !!wwan_status);
1694
1695         /* Keyboard Backlight is on by default */
1696         if (!acpi_check_handle(asus->handle, METHOD_KBD_LIGHT_SET, NULL))
1697                 asus_kled_set(asus, 1);
1698
1699         /* LED display is off by default */
1700         asus->ledd_status = 0xFFF;
1701
1702         /* Set initial values of light sensor and level */
1703         asus->light_switch = !!als_status;
1704         asus->light_level = 5;  /* level 5 for sensor sensitivity */
1705
1706         if (asus->is_pega_lucid) {
1707                 asus_als_switch(asus, asus->light_switch);
1708         } else if (!acpi_check_handle(asus->handle, METHOD_ALS_CONTROL, NULL) &&
1709                    !acpi_check_handle(asus->handle, METHOD_ALS_LEVEL, NULL)) {
1710                 asus_als_switch(asus, asus->light_switch);
1711                 asus_als_level(asus, asus->light_level);
1712         }
1713
1714         return result;
1715 }
1716
1717 static void __devinit asus_dmi_check(void)
1718 {
1719         const char *model;
1720
1721         model = dmi_get_system_info(DMI_PRODUCT_NAME);
1722         if (!model)
1723                 return;
1724
1725         /* On L1400B WLED control the sound card, don't mess with it ... */
1726         if (strncmp(model, "L1400B", 6) == 0) {
1727                 wlan_status = -1;
1728         }
1729 }
1730
1731 static bool asus_device_present;
1732
1733 static int __devinit asus_acpi_add(struct acpi_device *device)
1734 {
1735         struct asus_laptop *asus;
1736         int result;
1737
1738         pr_notice("Asus Laptop Support version %s\n",
1739                   ASUS_LAPTOP_VERSION);
1740         asus = kzalloc(sizeof(struct asus_laptop), GFP_KERNEL);
1741         if (!asus)
1742                 return -ENOMEM;
1743         asus->handle = device->handle;
1744         strcpy(acpi_device_name(device), ASUS_LAPTOP_DEVICE_NAME);
1745         strcpy(acpi_device_class(device), ASUS_LAPTOP_CLASS);
1746         device->driver_data = asus;
1747         asus->device = device;
1748
1749         asus_dmi_check();
1750
1751         result = asus_acpi_init(asus);
1752         if (result)
1753                 goto fail_platform;
1754
1755         /*
1756          * Need platform type detection first, then the platform
1757          * device.  It is used as a parent for the sub-devices below.
1758          */
1759         asus->is_pega_lucid = asus_check_pega_lucid(asus);
1760         result = asus_platform_init(asus);
1761         if (result)
1762                 goto fail_platform;
1763
1764         if (!acpi_video_backlight_support()) {
1765                 result = asus_backlight_init(asus);
1766                 if (result)
1767                         goto fail_backlight;
1768         } else
1769                 pr_info("Backlight controlled by ACPI video driver\n");
1770
1771         result = asus_input_init(asus);
1772         if (result)
1773                 goto fail_input;
1774
1775         result = asus_led_init(asus);
1776         if (result)
1777                 goto fail_led;
1778
1779         result = asus_rfkill_init(asus);
1780         if (result)
1781                 goto fail_rfkill;
1782
1783         result = pega_accel_init(asus);
1784         if (result && result != -ENODEV)
1785                 goto fail_pega_accel;
1786
1787         result = pega_rfkill_init(asus);
1788         if (result && result != -ENODEV)
1789                 goto fail_pega_rfkill;
1790
1791         asus_device_present = true;
1792         return 0;
1793
1794 fail_pega_rfkill:
1795         pega_accel_exit(asus);
1796 fail_pega_accel:
1797         asus_rfkill_exit(asus);
1798 fail_rfkill:
1799         asus_led_exit(asus);
1800 fail_led:
1801         asus_input_exit(asus);
1802 fail_input:
1803         asus_backlight_exit(asus);
1804 fail_backlight:
1805         asus_platform_exit(asus);
1806 fail_platform:
1807         kfree(asus->name);
1808         kfree(asus);
1809
1810         return result;
1811 }
1812
1813 static int asus_acpi_remove(struct acpi_device *device, int type)
1814 {
1815         struct asus_laptop *asus = acpi_driver_data(device);
1816
1817         asus_backlight_exit(asus);
1818         asus_rfkill_exit(asus);
1819         asus_led_exit(asus);
1820         asus_input_exit(asus);
1821         pega_accel_exit(asus);
1822         pega_rfkill_exit(asus);
1823         asus_platform_exit(asus);
1824
1825         kfree(asus->name);
1826         kfree(asus);
1827         return 0;
1828 }
1829
1830 static const struct acpi_device_id asus_device_ids[] = {
1831         {"ATK0100", 0},
1832         {"ATK0101", 0},
1833         {"", 0},
1834 };
1835 MODULE_DEVICE_TABLE(acpi, asus_device_ids);
1836
1837 static struct acpi_driver asus_acpi_driver = {
1838         .name = ASUS_LAPTOP_NAME,
1839         .class = ASUS_LAPTOP_CLASS,
1840         .owner = THIS_MODULE,
1841         .ids = asus_device_ids,
1842         .flags = ACPI_DRIVER_ALL_NOTIFY_EVENTS,
1843         .ops = {
1844                 .add = asus_acpi_add,
1845                 .remove = asus_acpi_remove,
1846                 .notify = asus_acpi_notify,
1847                 },
1848 };
1849
1850 static int __init asus_laptop_init(void)
1851 {
1852         int result;
1853
1854         result = platform_driver_register(&platform_driver);
1855         if (result < 0)
1856                 return result;
1857
1858         result = acpi_bus_register_driver(&asus_acpi_driver);
1859         if (result < 0)
1860                 goto fail_acpi_driver;
1861         if (!asus_device_present) {
1862                 result = -ENODEV;
1863                 goto fail_no_device;
1864         }
1865         return 0;
1866
1867 fail_no_device:
1868         acpi_bus_unregister_driver(&asus_acpi_driver);
1869 fail_acpi_driver:
1870         platform_driver_unregister(&platform_driver);
1871         return result;
1872 }
1873
1874 static void __exit asus_laptop_exit(void)
1875 {
1876         acpi_bus_unregister_driver(&asus_acpi_driver);
1877         platform_driver_unregister(&platform_driver);
1878 }
1879
1880 module_init(asus_laptop_init);
1881 module_exit(asus_laptop_exit);