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