2 * asus-laptop.c - Asus Laptop Support
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
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.
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.
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
24 * The development page for this driver is located at
25 * http://sourceforge.net/projects/acpi4asus/
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
37 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
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>
59 #define ASUS_LAPTOP_VERSION "0.42"
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."
67 MODULE_AUTHOR("Julien Lerouge, Karol Kozimor, Corentin Chary");
68 MODULE_DESCRIPTION(ASUS_LAPTOP_NAME
);
69 MODULE_LICENSE("GPL");
72 * WAPF defines the behavior of the Fn+Fx wlan key
73 * The significance of values is yet to be found, but
75 * Bit | Bluetooth | WLAN
76 * 0 | Hardware | Hardware
77 * 1 | Hardware | Software
78 * 4 | Software | Software
81 module_param(wapf
, uint
, 0444);
82 MODULE_PARM_DESC(wapf
, "WAPF value");
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
;
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). "
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). "
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). "
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). "
110 module_param(als_status
, int, 0444);
111 MODULE_PARM_DESC(als_status
, "Set the ALS status on boot "
112 "(0 = disabled, 1 = enabled). "
116 * Some events we use, same for all Asus
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
126 * Known bits returned by \_SB.ATKD.HWRS
129 #define BT_HWRS 0x100
132 * Flags for hotk status
133 * WL_ON and BT_ON are also used for wireless_status()
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 */
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) */
148 #define METHOD_LEDD "SLCM"
152 * WLED and BLED are not handled like other XLED, because in some dsdt
153 * they also control the WLAN/Bluetooth device.
155 #define METHOD_WLAN "WLED"
156 #define METHOD_BLUETOOTH "BLED"
159 #define METHOD_WWAN "GSMC"
160 #define METHOD_WIMAX "WMXC"
162 #define METHOD_WL_STATUS "RSTS"
165 #define METHOD_BRIGHTNESS_SET "SPLV"
166 #define METHOD_BRIGHTNESS_GET "GPLV"
169 #define METHOD_SWITCH_DISPLAY "SDSP"
171 #define METHOD_ALS_CONTROL "ALSC" /* Z71A Z71V */
172 #define METHOD_ALS_LEVEL "ALSL" /* Z71A Z71V */
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"
181 #define METHOD_KBD_LIGHT_SET "SLKB"
182 #define METHOD_KBD_LIGHT_GET "GLKB"
184 /* For Pegatron Lucid tablet */
185 #define DEVICE_NAME_PEGA "Lucid"
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
195 #define METHOD_PEGA_READ "RDLN"
196 #define PEGA_READ_ALS_H 0x02
197 #define PEGA_READ_ALS_L 0x03
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
208 * Define a specific led structure to keep the main structure clean
212 struct work_struct work
;
213 struct led_classdev led
;
214 struct asus_laptop
*asus
;
219 * Same thing for rfkill
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
;
228 * This is the main structure, we can use it to store anything interesting
229 * about the hotk device
232 char *name
; /* laptop name */
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
;
239 struct input_dev
*inputdev
;
240 struct key_entry
*keymap
;
241 struct input_polled_dev
*pega_accel_poll
;
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
;
259 struct rfkill
*gps_rfkill
;
261 struct asus_pega_rfkill wlanrfk
;
262 struct asus_pega_rfkill btrfk
;
263 struct asus_pega_rfkill wwanrfk
;
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 */
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
} },
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
321 * returns 0 if write is successful, -1 else.
323 static int write_acpi_int_ret(acpi_handle handle
, const char *method
, int val
,
324 struct acpi_buffer
*output
)
326 struct acpi_object_list params
; /* list of input parameters (an int) */
327 union acpi_object in_obj
; /* the only param we use */
334 params
.pointer
= &in_obj
;
335 in_obj
.type
= ACPI_TYPE_INTEGER
;
336 in_obj
.integer
.value
= val
;
338 status
= acpi_evaluate_object(handle
, (char *)method
, ¶ms
, output
);
345 static int write_acpi_int(acpi_handle handle
, const char *method
, int val
)
347 return write_acpi_int_ret(handle
, method
, val
, NULL
);
350 static int acpi_check_handle(acpi_handle handle
, const char *method
,
359 status
= acpi_get_handle(handle
, (char *)method
,
364 status
= acpi_get_handle(handle
, (char *)method
,
368 if (status
!= AE_OK
) {
370 pr_warn("Error finding %s\n", method
);
376 static bool asus_check_pega_lucid(struct asus_laptop
*asus
)
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
);
384 static int asus_pega_lucid_set(struct asus_laptop
*asus
, int unit
, bool enable
)
386 char *method
= enable
? METHOD_PEGA_ENABLE
: METHOD_PEGA_DISABLE
;
387 return write_acpi_int(asus
->handle
, method
, unit
);
390 static int pega_acc_axis(struct asus_laptop
*asus
, int curr
, char *method
)
393 unsigned long long val
;
394 for (i
= 0; i
< PEGA_ACC_RETRIES
; i
++) {
395 acpi_evaluate_integer(asus
->handle
, method
, NULL
, &val
);
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))
407 return clamp_val((short)val
, -PEGA_ACC_CLAMP
, PEGA_ACC_CLAMP
);
410 static void pega_accel_poll(struct input_polled_dev
*ipd
)
412 struct device
*parent
= ipd
->input
->dev
.parent
;
413 struct asus_laptop
*asus
= dev_get_drvdata(parent
);
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
);
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
);
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
);
441 static void pega_accel_exit(struct asus_laptop
*asus
)
443 if (asus
->pega_accel_poll
) {
444 input_unregister_polled_device(asus
->pega_accel_poll
);
445 input_free_polled_device(asus
->pega_accel_poll
);
447 asus
->pega_accel_poll
= NULL
;
450 static int pega_accel_init(struct asus_laptop
*asus
)
453 struct input_polled_dev
*ipd
;
455 if (!asus
->is_pega_lucid
)
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
))
463 ipd
= input_allocate_polled_device();
467 ipd
->poll
= pega_accel_poll
;
468 ipd
->poll_interval
= 125;
469 ipd
->poll_interval_min
= 50;
470 ipd
->poll_interval_max
= 2000;
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
;
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);
485 err
= input_register_polled_device(ipd
);
489 asus
->pega_accel_poll
= ipd
;
493 input_free_polled_device(ipd
);
497 /* Generic LED function */
498 static int asus_led_set(struct asus_laptop
*asus
, const char *method
,
501 if (!strcmp(method
, METHOD_MLED
))
503 else if (!strcmp(method
, METHOD_GLED
))
508 return write_acpi_int(asus
->handle
, method
, value
);
514 /* /sys/class/led handlers */
515 static void asus_led_cdev_set(struct led_classdev
*led_cdev
,
516 enum led_brightness value
)
518 struct asus_led
*led
= container_of(led_cdev
, struct asus_led
, led
);
519 struct asus_laptop
*asus
= led
->asus
;
522 queue_work(asus
->led_workqueue
, &led
->work
);
525 static void asus_led_cdev_update(struct work_struct
*work
)
527 struct asus_led
*led
= container_of(work
, struct asus_led
, work
);
528 struct asus_laptop
*asus
= led
->asus
;
530 asus_led_set(asus
, led
->method
, led
->wk
);
533 static enum led_brightness
asus_led_cdev_get(struct led_classdev
*led_cdev
)
535 return led_cdev
->brightness
;
539 * Keyboard backlight (also a LED)
541 static int asus_kled_lvl(struct asus_laptop
*asus
)
543 unsigned long long kblv
;
544 struct acpi_object_list params
;
545 union acpi_object in_obj
;
549 params
.pointer
= &in_obj
;
550 in_obj
.type
= ACPI_TYPE_INTEGER
;
551 in_obj
.integer
.value
= 2;
553 rv
= acpi_evaluate_integer(asus
->handle
, METHOD_KBD_LIGHT_GET
,
555 if (ACPI_FAILURE(rv
)) {
556 pr_warn("Error reading kled level\n");
562 static int asus_kled_set(struct asus_laptop
*asus
, int kblv
)
565 kblv
= (1 << 7) | (kblv
& 0x7F);
569 if (write_acpi_int(asus
->handle
, METHOD_KBD_LIGHT_SET
, kblv
)) {
570 pr_warn("Keyboard LED display write failed\n");
576 static void asus_kled_cdev_set(struct led_classdev
*led_cdev
,
577 enum led_brightness value
)
579 struct asus_led
*led
= container_of(led_cdev
, struct asus_led
, led
);
580 struct asus_laptop
*asus
= led
->asus
;
583 queue_work(asus
->led_workqueue
, &led
->work
);
586 static void asus_kled_cdev_update(struct work_struct
*work
)
588 struct asus_led
*led
= container_of(work
, struct asus_led
, work
);
589 struct asus_laptop
*asus
= led
->asus
;
591 asus_kled_set(asus
, led
->wk
);
594 static enum led_brightness
asus_kled_cdev_get(struct led_classdev
*led_cdev
)
596 struct asus_led
*led
= container_of(led_cdev
, struct asus_led
, led
);
597 struct asus_laptop
*asus
= led
->asus
;
599 return asus_kled_lvl(asus
);
602 static void asus_led_exit(struct asus_laptop
*asus
)
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
;
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
)
627 struct led_classdev
*led_cdev
= &led
->led
;
629 if (!method
|| acpi_check_handle(asus
->handle
, method
, NULL
))
630 return 0; /* Led not present */
633 led
->method
= method
;
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
);
643 static int asus_led_init(struct asus_laptop
*asus
)
648 * The Pegatron Lucid has no physical leds, but all methods are
649 * available in the DSDT...
651 if (asus
->is_pega_lucid
)
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.
660 asus
->led_workqueue
= create_singlethread_workqueue("led_workqueue");
661 if (!asus
->led_workqueue
)
664 r
= asus_led_register(asus
, &asus
->mled
, "asus::mail", METHOD_MLED
);
667 r
= asus_led_register(asus
, &asus
->tled
, "asus::touchpad", METHOD_TLED
);
670 r
= asus_led_register(asus
, &asus
->rled
, "asus::record", METHOD_RLED
);
673 r
= asus_led_register(asus
, &asus
->pled
, "asus::phone", METHOD_PLED
);
676 r
= asus_led_register(asus
, &asus
->gled
, "asus::gaming", METHOD_GLED
);
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
;
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
);
702 static int asus_read_brightness(struct backlight_device
*bd
)
704 struct asus_laptop
*asus
= bl_get_data(bd
);
705 unsigned long long value
;
706 acpi_status rv
= AE_OK
;
708 rv
= acpi_evaluate_integer(asus
->handle
, METHOD_BRIGHTNESS_GET
,
710 if (ACPI_FAILURE(rv
))
711 pr_warn("Error reading brightness\n");
716 static int asus_set_brightness(struct backlight_device
*bd
, int value
)
718 struct asus_laptop
*asus
= bl_get_data(bd
);
720 if (write_acpi_int(asus
->handle
, METHOD_BRIGHTNESS_SET
, value
)) {
721 pr_warn("Error changing brightness\n");
727 static int update_bl_status(struct backlight_device
*bd
)
729 int value
= bd
->props
.brightness
;
731 return asus_set_brightness(bd
, value
);
734 static const struct backlight_ops asusbl_ops
= {
735 .get_brightness
= asus_read_brightness
,
736 .update_status
= update_bl_status
,
739 static int asus_backlight_notify(struct asus_laptop
*asus
)
741 struct backlight_device
*bd
= asus
->backlight_device
;
742 int old
= bd
->props
.brightness
;
744 backlight_force_update(bd
, BACKLIGHT_UPDATE_HOTKEY
);
749 static int asus_backlight_init(struct asus_laptop
*asus
)
751 struct backlight_device
*bd
;
752 struct backlight_properties props
;
754 if (acpi_check_handle(asus
->handle
, METHOD_BRIGHTNESS_GET
, NULL
) ||
755 acpi_check_handle(asus
->handle
, METHOD_BRIGHTNESS_SET
, NULL
))
758 memset(&props
, 0, sizeof(struct backlight_properties
));
759 props
.max_brightness
= 15;
760 props
.type
= BACKLIGHT_PLATFORM
;
762 bd
= backlight_device_register(ASUS_LAPTOP_FILE
,
763 &asus
->platform_device
->dev
, asus
,
764 &asusbl_ops
, &props
);
766 pr_err("Could not register asus backlight device\n");
767 asus
->backlight_device
= NULL
;
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
);
778 static void asus_backlight_exit(struct asus_laptop
*asus
)
780 if (asus
->backlight_device
)
781 backlight_device_unregister(asus
->backlight_device
);
782 asus
->backlight_device
= NULL
;
786 * Platform device handlers
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
794 static ssize_t
show_infos(struct device
*dev
,
795 struct device_attribute
*attr
, char *page
)
797 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
799 unsigned long long temp
;
800 char buf
[16]; /* enough for all info */
801 acpi_status rv
= AE_OK
;
804 * We use the easy way, we don't care of off and count,
805 * so we don't set eof to 1
808 len
+= sprintf(page
, ASUS_LAPTOP_NAME
" " ASUS_LAPTOP_VERSION
"\n");
809 len
+= sprintf(page
+ len
, "Model reference : %s\n", asus
->name
);
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.
816 rv
= acpi_evaluate_integer(asus
->handle
, "SFUN", NULL
, &temp
);
817 if (!ACPI_FAILURE(rv
))
818 len
+= sprintf(page
+ len
, "SFUN value : %#x\n",
821 * The HWRS method return informations about the hardware.
822 * 0x80 bit is for WLAN, 0x100 for Bluetooth.
823 * The significance of others is yet to be found.
824 * If we don't find the method, we assume the device are present.
826 rv
= acpi_evaluate_integer(asus
->handle
, "HRWS", NULL
, &temp
);
827 if (!ACPI_FAILURE(rv
))
828 len
+= sprintf(page
+ len
, "HRWS value : %#x\n",
831 * Another value for userspace: the ASYM method returns 0x02 for
832 * battery low and 0x04 for battery critical, its readings tend to be
833 * more accurate than those provided by _BST.
834 * Note: since not all the laptops provide this method, errors are
837 rv
= acpi_evaluate_integer(asus
->handle
, "ASYM", NULL
, &temp
);
838 if (!ACPI_FAILURE(rv
))
839 len
+= sprintf(page
+ len
, "ASYM value : %#x\n",
841 if (asus
->dsdt_info
) {
842 snprintf(buf
, 16, "%d", asus
->dsdt_info
->length
);
843 len
+= sprintf(page
+ len
, "DSDT length : %s\n", buf
);
844 snprintf(buf
, 16, "%d", asus
->dsdt_info
->checksum
);
845 len
+= sprintf(page
+ len
, "DSDT checksum : %s\n", buf
);
846 snprintf(buf
, 16, "%d", asus
->dsdt_info
->revision
);
847 len
+= sprintf(page
+ len
, "DSDT revision : %s\n", buf
);
848 snprintf(buf
, 7, "%s", asus
->dsdt_info
->oem_id
);
849 len
+= sprintf(page
+ len
, "OEM id : %s\n", buf
);
850 snprintf(buf
, 9, "%s", asus
->dsdt_info
->oem_table_id
);
851 len
+= sprintf(page
+ len
, "OEM table id : %s\n", buf
);
852 snprintf(buf
, 16, "%x", asus
->dsdt_info
->oem_revision
);
853 len
+= sprintf(page
+ len
, "OEM revision : 0x%s\n", buf
);
854 snprintf(buf
, 5, "%s", asus
->dsdt_info
->asl_compiler_id
);
855 len
+= sprintf(page
+ len
, "ASL comp vendor id : %s\n", buf
);
856 snprintf(buf
, 16, "%x", asus
->dsdt_info
->asl_compiler_revision
);
857 len
+= sprintf(page
+ len
, "ASL comp revision : 0x%s\n", buf
);
863 static int parse_arg(const char *buf
, unsigned long count
, int *val
)
869 if (sscanf(buf
, "%i", val
) != 1)
874 static ssize_t
sysfs_acpi_set(struct asus_laptop
*asus
,
875 const char *buf
, size_t count
,
881 rv
= parse_arg(buf
, count
, &value
);
885 if (write_acpi_int(asus
->handle
, method
, value
))
893 static ssize_t
show_ledd(struct device
*dev
,
894 struct device_attribute
*attr
, char *buf
)
896 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
898 return sprintf(buf
, "0x%08x\n", asus
->ledd_status
);
901 static ssize_t
store_ledd(struct device
*dev
, struct device_attribute
*attr
,
902 const char *buf
, size_t count
)
904 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
907 rv
= parse_arg(buf
, count
, &value
);
909 if (write_acpi_int(asus
->handle
, METHOD_LEDD
, value
)) {
910 pr_warn("LED display write failed\n");
913 asus
->ledd_status
= (u32
) value
;
921 static int asus_wireless_status(struct asus_laptop
*asus
, int mask
)
923 unsigned long long status
;
924 acpi_status rv
= AE_OK
;
926 if (!asus
->have_rsts
)
927 return (asus
->wireless_status
& mask
) ? 1 : 0;
929 rv
= acpi_evaluate_integer(asus
->handle
, METHOD_WL_STATUS
,
931 if (ACPI_FAILURE(rv
)) {
932 pr_warn("Error reading Wireless status\n");
935 return !!(status
& mask
);
941 static int asus_wlan_set(struct asus_laptop
*asus
, int status
)
943 if (write_acpi_int(asus
->handle
, METHOD_WLAN
, !!status
)) {
944 pr_warn("Error setting wlan status to %d\n", status
);
950 static ssize_t
show_wlan(struct device
*dev
,
951 struct device_attribute
*attr
, char *buf
)
953 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
955 return sprintf(buf
, "%d\n", asus_wireless_status(asus
, WL_RSTS
));
958 static ssize_t
store_wlan(struct device
*dev
, struct device_attribute
*attr
,
959 const char *buf
, size_t count
)
961 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
963 return sysfs_acpi_set(asus
, buf
, count
, METHOD_WLAN
);
969 static int asus_bluetooth_set(struct asus_laptop
*asus
, int status
)
971 if (write_acpi_int(asus
->handle
, METHOD_BLUETOOTH
, !!status
)) {
972 pr_warn("Error setting bluetooth status to %d\n", status
);
978 static ssize_t
show_bluetooth(struct device
*dev
,
979 struct device_attribute
*attr
, char *buf
)
981 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
983 return sprintf(buf
, "%d\n", asus_wireless_status(asus
, BT_RSTS
));
986 static ssize_t
store_bluetooth(struct device
*dev
,
987 struct device_attribute
*attr
, const char *buf
,
990 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
992 return sysfs_acpi_set(asus
, buf
, count
, METHOD_BLUETOOTH
);
998 static int asus_wimax_set(struct asus_laptop
*asus
, int status
)
1000 if (write_acpi_int(asus
->handle
, METHOD_WIMAX
, !!status
)) {
1001 pr_warn("Error setting wimax status to %d\n", status
);
1007 static ssize_t
show_wimax(struct device
*dev
,
1008 struct device_attribute
*attr
, char *buf
)
1010 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1012 return sprintf(buf
, "%d\n", asus_wireless_status(asus
, WM_RSTS
));
1015 static ssize_t
store_wimax(struct device
*dev
,
1016 struct device_attribute
*attr
, const char *buf
,
1019 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1021 return sysfs_acpi_set(asus
, buf
, count
, METHOD_WIMAX
);
1027 static int asus_wwan_set(struct asus_laptop
*asus
, int status
)
1029 if (write_acpi_int(asus
->handle
, METHOD_WWAN
, !!status
)) {
1030 pr_warn("Error setting wwan status to %d\n", status
);
1036 static ssize_t
show_wwan(struct device
*dev
,
1037 struct device_attribute
*attr
, char *buf
)
1039 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1041 return sprintf(buf
, "%d\n", asus_wireless_status(asus
, WW_RSTS
));
1044 static ssize_t
store_wwan(struct device
*dev
,
1045 struct device_attribute
*attr
, const char *buf
,
1048 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1050 return sysfs_acpi_set(asus
, buf
, count
, METHOD_WWAN
);
1056 static void asus_set_display(struct asus_laptop
*asus
, int value
)
1058 /* no sanity check needed for now */
1059 if (write_acpi_int(asus
->handle
, METHOD_SWITCH_DISPLAY
, value
))
1060 pr_warn("Error setting display\n");
1065 * Experimental support for display switching. As of now: 1 should activate
1066 * the LCD output, 2 should do for CRT, 4 for TV-Out and 8 for DVI.
1067 * Any combination (bitwise) of these will suffice. I never actually tested 4
1068 * displays hooked up simultaneously, so be warned. See the acpi4asus README
1071 static ssize_t
store_disp(struct device
*dev
, struct device_attribute
*attr
,
1072 const char *buf
, size_t count
)
1074 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1077 rv
= parse_arg(buf
, count
, &value
);
1079 asus_set_display(asus
, value
);
1086 static void asus_als_switch(struct asus_laptop
*asus
, int value
)
1090 if (asus
->is_pega_lucid
) {
1091 ret
= asus_pega_lucid_set(asus
, PEGA_ALS
, value
);
1093 ret
= asus_pega_lucid_set(asus
, PEGA_ALS_POWER
, value
);
1095 ret
= write_acpi_int(asus
->handle
, METHOD_ALS_CONTROL
, value
);
1098 pr_warning("Error setting light sensor switch\n");
1100 asus
->light_switch
= value
;
1103 static ssize_t
show_lssw(struct device
*dev
,
1104 struct device_attribute
*attr
, char *buf
)
1106 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1108 return sprintf(buf
, "%d\n", asus
->light_switch
);
1111 static ssize_t
store_lssw(struct device
*dev
, struct device_attribute
*attr
,
1112 const char *buf
, size_t count
)
1114 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1117 rv
= parse_arg(buf
, count
, &value
);
1119 asus_als_switch(asus
, value
? 1 : 0);
1124 static void asus_als_level(struct asus_laptop
*asus
, int value
)
1126 if (write_acpi_int(asus
->handle
, METHOD_ALS_LEVEL
, value
))
1127 pr_warn("Error setting light sensor level\n");
1128 asus
->light_level
= value
;
1131 static ssize_t
show_lslvl(struct device
*dev
,
1132 struct device_attribute
*attr
, char *buf
)
1134 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1136 return sprintf(buf
, "%d\n", asus
->light_level
);
1139 static ssize_t
store_lslvl(struct device
*dev
, struct device_attribute
*attr
,
1140 const char *buf
, size_t count
)
1142 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1145 rv
= parse_arg(buf
, count
, &value
);
1147 value
= (0 < value
) ? ((15 < value
) ? 15 : value
) : 0;
1148 /* 0 <= value <= 15 */
1149 asus_als_level(asus
, value
);
1155 static int pega_int_read(struct asus_laptop
*asus
, int arg
, int *result
)
1157 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1158 int err
= write_acpi_int_ret(asus
->handle
, METHOD_PEGA_READ
, arg
,
1161 union acpi_object
*obj
= buffer
.pointer
;
1162 if (obj
&& obj
->type
== ACPI_TYPE_INTEGER
)
1163 *result
= obj
->integer
.value
;
1170 static ssize_t
show_lsvalue(struct device
*dev
,
1171 struct device_attribute
*attr
, char *buf
)
1173 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1176 err
= pega_int_read(asus
, PEGA_READ_ALS_H
, &hi
);
1178 err
= pega_int_read(asus
, PEGA_READ_ALS_L
, &lo
);
1180 return sprintf(buf
, "%d\n", 10 * hi
+ lo
);
1187 static int asus_gps_status(struct asus_laptop
*asus
)
1189 unsigned long long status
;
1190 acpi_status rv
= AE_OK
;
1192 rv
= acpi_evaluate_integer(asus
->handle
, METHOD_GPS_STATUS
,
1194 if (ACPI_FAILURE(rv
)) {
1195 pr_warn("Error reading GPS status\n");
1201 static int asus_gps_switch(struct asus_laptop
*asus
, int status
)
1203 const char *meth
= status
? METHOD_GPS_ON
: METHOD_GPS_OFF
;
1205 if (write_acpi_int(asus
->handle
, meth
, 0x02))
1210 static ssize_t
show_gps(struct device
*dev
,
1211 struct device_attribute
*attr
, char *buf
)
1213 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1215 return sprintf(buf
, "%d\n", asus_gps_status(asus
));
1218 static ssize_t
store_gps(struct device
*dev
, struct device_attribute
*attr
,
1219 const char *buf
, size_t count
)
1221 struct asus_laptop
*asus
= dev_get_drvdata(dev
);
1225 rv
= parse_arg(buf
, count
, &value
);
1228 ret
= asus_gps_switch(asus
, !!value
);
1231 rfkill_set_sw_state(asus
->gps_rfkill
, !value
);
1238 static int asus_gps_rfkill_set(void *data
, bool blocked
)
1240 struct asus_laptop
*asus
= data
;
1242 return asus_gps_switch(asus
, !blocked
);
1245 static const struct rfkill_ops asus_gps_rfkill_ops
= {
1246 .set_block
= asus_gps_rfkill_set
,
1249 static void asus_rfkill_exit(struct asus_laptop
*asus
)
1251 if (asus
->gps_rfkill
) {
1252 rfkill_unregister(asus
->gps_rfkill
);
1253 rfkill_destroy(asus
->gps_rfkill
);
1254 asus
->gps_rfkill
= NULL
;
1258 static int asus_rfkill_init(struct asus_laptop
*asus
)
1262 if (acpi_check_handle(asus
->handle
, METHOD_GPS_ON
, NULL
) ||
1263 acpi_check_handle(asus
->handle
, METHOD_GPS_OFF
, NULL
) ||
1264 acpi_check_handle(asus
->handle
, METHOD_GPS_STATUS
, NULL
))
1267 asus
->gps_rfkill
= rfkill_alloc("asus-gps", &asus
->platform_device
->dev
,
1269 &asus_gps_rfkill_ops
, asus
);
1270 if (!asus
->gps_rfkill
)
1273 result
= rfkill_register(asus
->gps_rfkill
);
1275 rfkill_destroy(asus
->gps_rfkill
);
1276 asus
->gps_rfkill
= NULL
;
1282 static int pega_rfkill_set(void *data
, bool blocked
)
1284 struct asus_pega_rfkill
*pega_rfk
= data
;
1286 int ret
= asus_pega_lucid_set(pega_rfk
->asus
, pega_rfk
->control_id
, !blocked
);
1287 pr_warn("Setting rfkill %d, to %d; returned %d\n", pega_rfk
->control_id
, !blocked
, ret
);
1292 static const struct rfkill_ops pega_rfkill_ops
= {
1293 .set_block
= pega_rfkill_set
,
1296 static void pega_rfkill_terminate(struct asus_pega_rfkill
*pega_rfk
)
1298 pr_warn("Terminating %d\n", pega_rfk
->control_id
);
1299 if (pega_rfk
->rfkill
) {
1300 rfkill_unregister(pega_rfk
->rfkill
);
1301 rfkill_destroy(pega_rfk
->rfkill
);
1302 pega_rfk
->rfkill
= NULL
;
1306 static void pega_rfkill_exit(struct asus_laptop
*asus
)
1308 pega_rfkill_terminate(&asus
->wwanrfk
);
1309 pega_rfkill_terminate(&asus
->btrfk
);
1310 pega_rfkill_terminate(&asus
->wlanrfk
);
1313 static int pega_rfkill_setup(struct asus_laptop
*asus
, struct asus_pega_rfkill
*pega_rfk
,
1314 const char *name
, int controlid
, int rfkill_type
)
1318 pr_warn("Setting up rfk %s, control %d, type %d\n", name
, controlid
, rfkill_type
);
1319 pega_rfk
->control_id
= controlid
;
1320 pega_rfk
->asus
= asus
;
1321 pega_rfk
->rfkill
= rfkill_alloc(name
, &asus
->platform_device
->dev
,
1322 rfkill_type
, &pega_rfkill_ops
, pega_rfk
);
1323 if (!pega_rfk
->rfkill
)
1326 result
= rfkill_register(pega_rfk
->rfkill
);
1328 rfkill_destroy(pega_rfk
->rfkill
);
1329 pega_rfk
->rfkill
= NULL
;
1335 static int pega_rfkill_init(struct asus_laptop
*asus
)
1339 if(!asus
->is_pega_lucid
)
1342 ret
= pega_rfkill_setup(asus
, &asus
->wlanrfk
, "pega-wlan", PEGA_WLAN
, RFKILL_TYPE_WLAN
);
1345 ret
= pega_rfkill_setup(asus
, &asus
->btrfk
, "pega-bt", PEGA_BLUETOOTH
, RFKILL_TYPE_BLUETOOTH
);
1348 ret
= pega_rfkill_setup(asus
, &asus
->wwanrfk
, "pega-wwan", PEGA_WWAN
, RFKILL_TYPE_WWAN
);
1352 pr_warn("Pega rfkill init succeeded\n");
1355 pega_rfkill_terminate(&asus
->btrfk
);
1357 pega_rfkill_terminate(&asus
->wlanrfk
);
1363 * Input device (i.e. hotkeys)
1365 static void asus_input_notify(struct asus_laptop
*asus
, int event
)
1368 sparse_keymap_report_event(asus
->inputdev
, event
, 1, true);
1371 static int asus_input_init(struct asus_laptop
*asus
)
1373 struct input_dev
*input
;
1376 input
= input_allocate_device();
1378 pr_info("Unable to allocate input device\n");
1381 input
->name
= "Asus Laptop extra buttons";
1382 input
->phys
= ASUS_LAPTOP_FILE
"/input0";
1383 input
->id
.bustype
= BUS_HOST
;
1384 input
->dev
.parent
= &asus
->platform_device
->dev
;
1386 error
= sparse_keymap_setup(input
, asus_keymap
, NULL
);
1388 pr_err("Unable to setup input device keymap\n");
1391 error
= input_register_device(input
);
1393 pr_info("Unable to register input device\n");
1394 goto err_free_keymap
;
1397 asus
->inputdev
= input
;
1401 sparse_keymap_free(input
);
1403 input_free_device(input
);
1407 static void asus_input_exit(struct asus_laptop
*asus
)
1409 if (asus
->inputdev
) {
1410 sparse_keymap_free(asus
->inputdev
);
1411 input_unregister_device(asus
->inputdev
);
1413 asus
->inputdev
= NULL
;
1419 static void asus_acpi_notify(struct acpi_device
*device
, u32 event
)
1421 struct asus_laptop
*asus
= acpi_driver_data(device
);
1424 /* TODO Find a better way to handle events count. */
1425 count
= asus
->event_count
[event
% 128]++;
1426 acpi_bus_generate_proc_event(asus
->device
, event
, count
);
1427 acpi_bus_generate_netlink_event(asus
->device
->pnp
.device_class
,
1428 dev_name(&asus
->device
->dev
), event
,
1431 /* Brightness events are special */
1432 if (event
>= ATKD_BR_MIN
&& event
<= ATKD_BR_MAX
) {
1434 /* Ignore them completely if the acpi video driver is used */
1435 if (asus
->backlight_device
!= NULL
) {
1436 /* Update the backlight device. */
1437 asus_backlight_notify(asus
);
1442 /* Accelerometer "coarse orientation change" event */
1443 if (asus
->pega_accel_poll
&& event
== 0xEA) {
1444 kobject_uevent(&asus
->pega_accel_poll
->input
->dev
.kobj
,
1449 asus_input_notify(asus
, event
);
1452 static DEVICE_ATTR(infos
, S_IRUGO
, show_infos
, NULL
);
1453 static DEVICE_ATTR(wlan
, S_IRUGO
| S_IWUSR
, show_wlan
, store_wlan
);
1454 static DEVICE_ATTR(bluetooth
, S_IRUGO
| S_IWUSR
,
1455 show_bluetooth
, store_bluetooth
);
1456 static DEVICE_ATTR(wimax
, S_IRUGO
| S_IWUSR
, show_wimax
, store_wimax
);
1457 static DEVICE_ATTR(wwan
, S_IRUGO
| S_IWUSR
, show_wwan
, store_wwan
);
1458 static DEVICE_ATTR(display
, S_IWUSR
, NULL
, store_disp
);
1459 static DEVICE_ATTR(ledd
, S_IRUGO
| S_IWUSR
, show_ledd
, store_ledd
);
1460 static DEVICE_ATTR(ls_value
, S_IRUGO
, show_lsvalue
, NULL
);
1461 static DEVICE_ATTR(ls_level
, S_IRUGO
| S_IWUSR
, show_lslvl
, store_lslvl
);
1462 static DEVICE_ATTR(ls_switch
, S_IRUGO
| S_IWUSR
, show_lssw
, store_lssw
);
1463 static DEVICE_ATTR(gps
, S_IRUGO
| S_IWUSR
, show_gps
, store_gps
);
1465 static struct attribute
*asus_attributes
[] = {
1466 &dev_attr_infos
.attr
,
1467 &dev_attr_wlan
.attr
,
1468 &dev_attr_bluetooth
.attr
,
1469 &dev_attr_wimax
.attr
,
1470 &dev_attr_wwan
.attr
,
1471 &dev_attr_display
.attr
,
1472 &dev_attr_ledd
.attr
,
1473 &dev_attr_ls_value
.attr
,
1474 &dev_attr_ls_level
.attr
,
1475 &dev_attr_ls_switch
.attr
,
1480 static umode_t
asus_sysfs_is_visible(struct kobject
*kobj
,
1481 struct attribute
*attr
,
1484 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
1485 struct platform_device
*pdev
= to_platform_device(dev
);
1486 struct asus_laptop
*asus
= platform_get_drvdata(pdev
);
1487 acpi_handle handle
= asus
->handle
;
1490 if (asus
->is_pega_lucid
) {
1491 /* no ls_level interface on the Lucid */
1492 if (attr
== &dev_attr_ls_switch
.attr
)
1494 else if (attr
== &dev_attr_ls_level
.attr
)
1503 if (attr
== &dev_attr_wlan
.attr
) {
1504 supported
= !acpi_check_handle(handle
, METHOD_WLAN
, NULL
);
1506 } else if (attr
== &dev_attr_bluetooth
.attr
) {
1507 supported
= !acpi_check_handle(handle
, METHOD_BLUETOOTH
, NULL
);
1509 } else if (attr
== &dev_attr_display
.attr
) {
1510 supported
= !acpi_check_handle(handle
, METHOD_SWITCH_DISPLAY
, NULL
);
1512 } else if (attr
== &dev_attr_wimax
.attr
) {
1514 !acpi_check_handle(asus
->handle
, METHOD_WIMAX
, NULL
);
1516 } else if (attr
== &dev_attr_wwan
.attr
) {
1517 supported
= !acpi_check_handle(asus
->handle
, METHOD_WWAN
, NULL
);
1519 } else if (attr
== &dev_attr_ledd
.attr
) {
1520 supported
= !acpi_check_handle(handle
, METHOD_LEDD
, NULL
);
1522 } else if (attr
== &dev_attr_ls_switch
.attr
||
1523 attr
== &dev_attr_ls_level
.attr
) {
1524 supported
= !acpi_check_handle(handle
, METHOD_ALS_CONTROL
, NULL
) &&
1525 !acpi_check_handle(handle
, METHOD_ALS_LEVEL
, NULL
);
1526 } else if (attr
== &dev_attr_ls_value
.attr
) {
1527 supported
= asus
->is_pega_lucid
;
1528 } else if (attr
== &dev_attr_gps
.attr
) {
1529 supported
= !acpi_check_handle(handle
, METHOD_GPS_ON
, NULL
) &&
1530 !acpi_check_handle(handle
, METHOD_GPS_OFF
, NULL
) &&
1531 !acpi_check_handle(handle
, METHOD_GPS_STATUS
, NULL
);
1536 return supported
? attr
->mode
: 0;
1540 static const struct attribute_group asus_attr_group
= {
1541 .is_visible
= asus_sysfs_is_visible
,
1542 .attrs
= asus_attributes
,
1545 static int asus_platform_init(struct asus_laptop
*asus
)
1549 asus
->platform_device
= platform_device_alloc(ASUS_LAPTOP_FILE
, -1);
1550 if (!asus
->platform_device
)
1552 platform_set_drvdata(asus
->platform_device
, asus
);
1554 result
= platform_device_add(asus
->platform_device
);
1556 goto fail_platform_device
;
1558 result
= sysfs_create_group(&asus
->platform_device
->dev
.kobj
,
1566 platform_device_del(asus
->platform_device
);
1567 fail_platform_device
:
1568 platform_device_put(asus
->platform_device
);
1572 static void asus_platform_exit(struct asus_laptop
*asus
)
1574 sysfs_remove_group(&asus
->platform_device
->dev
.kobj
, &asus_attr_group
);
1575 platform_device_unregister(asus
->platform_device
);
1578 static struct platform_driver platform_driver
= {
1580 .name
= ASUS_LAPTOP_FILE
,
1581 .owner
= THIS_MODULE
,
1586 * This function is used to initialize the context with right values. In this
1587 * method, we can make all the detection we want, and modify the asus_laptop
1590 static int asus_laptop_get_info(struct asus_laptop
*asus
)
1592 struct acpi_buffer buffer
= { ACPI_ALLOCATE_BUFFER
, NULL
};
1593 union acpi_object
*model
= NULL
;
1594 unsigned long long bsts_result
, hwrs_result
;
1595 char *string
= NULL
;
1599 * Get DSDT headers early enough to allow for differentiating between
1600 * models, but late enough to allow acpi_bus_register_driver() to fail
1601 * before doing anything ACPI-specific. Should we encounter a machine,
1602 * which needs special handling (i.e. its hotkey device has a different
1603 * HID), this bit will be moved.
1605 status
= acpi_get_table(ACPI_SIG_DSDT
, 1, &asus
->dsdt_info
);
1606 if (ACPI_FAILURE(status
))
1607 pr_warn("Couldn't get the DSDT table header\n");
1609 /* We have to write 0 on init this far for all ASUS models */
1610 if (write_acpi_int_ret(asus
->handle
, "INIT", 0, &buffer
)) {
1611 pr_err("Hotkey initialization failed\n");
1615 /* This needs to be called for some laptops to init properly */
1617 acpi_evaluate_integer(asus
->handle
, "BSTS", NULL
, &bsts_result
);
1618 if (ACPI_FAILURE(status
))
1619 pr_warn("Error calling BSTS\n");
1620 else if (bsts_result
)
1621 pr_notice("BSTS called, 0x%02x returned\n",
1622 (uint
) bsts_result
);
1625 if (write_acpi_int(asus
->handle
, "CWAP", wapf
))
1626 pr_err("Error calling CWAP(%d)\n", wapf
);
1628 * Try to match the object returned by INIT to the specific model.
1629 * Handle every possible object (or the lack of thereof) the DSDT
1630 * writers might throw at us. When in trouble, we pass NULL to
1631 * asus_model_match() and try something completely different.
1633 if (buffer
.pointer
) {
1634 model
= buffer
.pointer
;
1635 switch (model
->type
) {
1636 case ACPI_TYPE_STRING
:
1637 string
= model
->string
.pointer
;
1639 case ACPI_TYPE_BUFFER
:
1640 string
= model
->buffer
.pointer
;
1647 asus
->name
= kstrdup(string
, GFP_KERNEL
);
1649 kfree(buffer
.pointer
);
1654 pr_notice(" %s model detected\n", string
);
1657 * The HWRS method return informations about the hardware.
1658 * 0x80 bit is for WLAN, 0x100 for Bluetooth,
1659 * 0x40 for WWAN, 0x10 for WIMAX.
1660 * The significance of others is yet to be found.
1663 acpi_evaluate_integer(asus
->handle
, "HRWS", NULL
, &hwrs_result
);
1664 if (!ACPI_FAILURE(status
))
1665 pr_notice(" HRWS returned %x", (int)hwrs_result
);
1667 if (!acpi_check_handle(asus
->handle
, METHOD_WL_STATUS
, NULL
))
1668 asus
->have_rsts
= true;
1675 static int __devinit
asus_acpi_init(struct asus_laptop
*asus
)
1679 result
= acpi_bus_get_status(asus
->device
);
1682 if (!asus
->device
->status
.present
) {
1683 pr_err("Hotkey device not present, aborting\n");
1687 result
= asus_laptop_get_info(asus
);
1691 /* WLED and BLED are on by default */
1692 if (bluetooth_status
>= 0)
1693 asus_bluetooth_set(asus
, !!bluetooth_status
);
1695 if (wlan_status
>= 0)
1696 asus_wlan_set(asus
, !!wlan_status
);
1698 if (wimax_status
>= 0)
1699 asus_wimax_set(asus
, !!wimax_status
);
1701 if (wwan_status
>= 0)
1702 asus_wwan_set(asus
, !!wwan_status
);
1704 /* Keyboard Backlight is on by default */
1705 if (!acpi_check_handle(asus
->handle
, METHOD_KBD_LIGHT_SET
, NULL
))
1706 asus_kled_set(asus
, 1);
1708 /* LED display is off by default */
1709 asus
->ledd_status
= 0xFFF;
1711 /* Set initial values of light sensor and level */
1712 asus
->light_switch
= !!als_status
;
1713 asus
->light_level
= 5; /* level 5 for sensor sensitivity */
1715 if (asus
->is_pega_lucid
) {
1716 asus_als_switch(asus
, asus
->light_switch
);
1717 } else if (!acpi_check_handle(asus
->handle
, METHOD_ALS_CONTROL
, NULL
) &&
1718 !acpi_check_handle(asus
->handle
, METHOD_ALS_LEVEL
, NULL
)) {
1719 asus_als_switch(asus
, asus
->light_switch
);
1720 asus_als_level(asus
, asus
->light_level
);
1726 static void __devinit
asus_dmi_check(void)
1730 model
= dmi_get_system_info(DMI_PRODUCT_NAME
);
1734 /* On L1400B WLED control the sound card, don't mess with it ... */
1735 if (strncmp(model
, "L1400B", 6) == 0) {
1740 static bool asus_device_present
;
1742 static int __devinit
asus_acpi_add(struct acpi_device
*device
)
1744 struct asus_laptop
*asus
;
1747 pr_notice("Asus Laptop Support version %s\n",
1748 ASUS_LAPTOP_VERSION
);
1749 asus
= kzalloc(sizeof(struct asus_laptop
), GFP_KERNEL
);
1752 asus
->handle
= device
->handle
;
1753 strcpy(acpi_device_name(device
), ASUS_LAPTOP_DEVICE_NAME
);
1754 strcpy(acpi_device_class(device
), ASUS_LAPTOP_CLASS
);
1755 device
->driver_data
= asus
;
1756 asus
->device
= device
;
1760 result
= asus_acpi_init(asus
);
1765 * Need platform type detection first, then the platform
1766 * device. It is used as a parent for the sub-devices below.
1768 asus
->is_pega_lucid
= asus_check_pega_lucid(asus
);
1769 result
= asus_platform_init(asus
);
1773 if (!acpi_video_backlight_support()) {
1774 result
= asus_backlight_init(asus
);
1776 goto fail_backlight
;
1778 pr_info("Backlight controlled by ACPI video driver\n");
1780 result
= asus_input_init(asus
);
1784 result
= asus_led_init(asus
);
1788 result
= asus_rfkill_init(asus
);
1792 result
= pega_accel_init(asus
);
1793 if (result
&& result
!= -ENODEV
)
1794 goto fail_pega_accel
;
1796 result
= pega_rfkill_init(asus
);
1797 if (result
&& result
!= -ENODEV
)
1798 goto fail_pega_rfkill
;
1800 asus_device_present
= true;
1804 pega_accel_exit(asus
);
1806 asus_rfkill_exit(asus
);
1808 asus_led_exit(asus
);
1810 asus_input_exit(asus
);
1812 asus_backlight_exit(asus
);
1814 asus_platform_exit(asus
);
1822 static int asus_acpi_remove(struct acpi_device
*device
, int type
)
1824 struct asus_laptop
*asus
= acpi_driver_data(device
);
1826 asus_backlight_exit(asus
);
1827 asus_rfkill_exit(asus
);
1828 asus_led_exit(asus
);
1829 asus_input_exit(asus
);
1830 pega_accel_exit(asus
);
1831 pega_rfkill_exit(asus
);
1832 asus_platform_exit(asus
);
1839 static const struct acpi_device_id asus_device_ids
[] = {
1844 MODULE_DEVICE_TABLE(acpi
, asus_device_ids
);
1846 static struct acpi_driver asus_acpi_driver
= {
1847 .name
= ASUS_LAPTOP_NAME
,
1848 .class = ASUS_LAPTOP_CLASS
,
1849 .owner
= THIS_MODULE
,
1850 .ids
= asus_device_ids
,
1851 .flags
= ACPI_DRIVER_ALL_NOTIFY_EVENTS
,
1853 .add
= asus_acpi_add
,
1854 .remove
= asus_acpi_remove
,
1855 .notify
= asus_acpi_notify
,
1859 static int __init
asus_laptop_init(void)
1863 result
= platform_driver_register(&platform_driver
);
1867 result
= acpi_bus_register_driver(&asus_acpi_driver
);
1869 goto fail_acpi_driver
;
1870 if (!asus_device_present
) {
1872 goto fail_no_device
;
1877 acpi_bus_unregister_driver(&asus_acpi_driver
);
1879 platform_driver_unregister(&platform_driver
);
1883 static void __exit
asus_laptop_exit(void)
1885 acpi_bus_unregister_driver(&asus_acpi_driver
);
1886 platform_driver_unregister(&platform_driver
);
1889 module_init(asus_laptop_init
);
1890 module_exit(asus_laptop_exit
);