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