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