asus-laptop.c 29.8 KB
Newer Older
C
Corentin Chary 已提交
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42
/*
 *  asus-laptop.c - Asus Laptop Support
 *
 *
 *  Copyright (C) 2002-2005 Julien Lerouge, 2003-2006 Karol Kozimor
 *  Copyright (C) 2006 Corentin Chary
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 *
 *  The development page for this driver is located at
 *  http://sourceforge.net/projects/acpi4asus/
 *
 *  Credits:
 *  Pontus Fuchs   - Helper functions, cleanup
 *  Johann Wiesner - Small compile fixes
 *  John Belmonte  - ACPI code for Toshiba laptop was a good starting point.
 *  Eric Burghard  - LED display support for W1N
 *  Josh Green     - Light Sens support
 *  Thomas Tuttle  - His first patch for led support was very helpfull
 *
 */

#include <linux/autoconf.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/err.h>
#include <linux/proc_fs.h>
43 44
#include <linux/backlight.h>
#include <linux/fb.h>
C
Corentin Chary 已提交
45
#include <linux/leds.h>
C
Corentin Chary 已提交
46 47 48 49 50 51 52 53 54 55 56 57 58 59
#include <linux/platform_device.h>
#include <acpi/acpi_drivers.h>
#include <acpi/acpi_bus.h>
#include <asm/uaccess.h>

#define ASUS_LAPTOP_VERSION "0.40"

#define ASUS_HOTK_NAME          "Asus Laptop Support"
#define ASUS_HOTK_CLASS         "hotkey"
#define ASUS_HOTK_DEVICE_NAME   "Hotkey"
#define ASUS_HOTK_HID           "ATK0100"
#define ASUS_HOTK_FILE          "asus-laptop"
#define ASUS_HOTK_PREFIX        "\\_SB.ATKD."

60 61 62 63 64 65 66 67
/*
 * Some events we use, same for all Asus
 */
#define ATKD_BR_UP       0x10
#define ATKD_BR_DOWN     0x20
#define ATKD_LCD_ON      0x33
#define ATKD_LCD_OFF     0x34

68 69 70 71 72 73
/*
 * Known bits returned by \_SB.ATKD.HWRS
 */
#define WL_HWRS     0x80
#define BT_HWRS     0x100

C
Corentin Chary 已提交
74 75
/*
 * Flags for hotk status
76
 * WL_ON and BT_ON are also used for wireless_status()
C
Corentin Chary 已提交
77
 */
78 79
#define WL_ON       0x01	//internal Wifi
#define BT_ON       0x02	//internal Bluetooth
C
Corentin Chary 已提交
80 81
#define MLED_ON     0x04	//mail LED
#define TLED_ON     0x08	//touchpad LED
L
Len Brown 已提交
82 83 84
#define RLED_ON     0x10	//Record LED
#define PLED_ON     0x20	//Phone LED
#define LCD_ON      0x40	//LCD backlight
C
Corentin Chary 已提交
85

C
Corentin Chary 已提交
86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
#define ASUS_LOG    ASUS_HOTK_FILE ": "
#define ASUS_ERR    KERN_ERR    ASUS_LOG
#define ASUS_WARNING    KERN_WARNING    ASUS_LOG
#define ASUS_NOTICE KERN_NOTICE ASUS_LOG
#define ASUS_INFO   KERN_INFO   ASUS_LOG
#define ASUS_DEBUG  KERN_DEBUG  ASUS_LOG

MODULE_AUTHOR("Julien Lerouge, Karol Kozimor, Corentin Chary");
MODULE_DESCRIPTION(ASUS_HOTK_NAME);
MODULE_LICENSE("GPL");

#define ASUS_HANDLE(object, paths...)					\
	static acpi_handle  object##_handle = NULL;			\
	static char *object##_paths[] = { paths }

C
Corentin Chary 已提交
101 102 103
/* LED */
ASUS_HANDLE(mled_set, ASUS_HOTK_PREFIX "MLED");
ASUS_HANDLE(tled_set, ASUS_HOTK_PREFIX "TLED");
L
Len Brown 已提交
104 105
ASUS_HANDLE(rled_set, ASUS_HOTK_PREFIX "RLED");	/* W1JC */
ASUS_HANDLE(pled_set, ASUS_HOTK_PREFIX "PLED");	/* A7J */
C
Corentin Chary 已提交
106

C
Corentin Chary 已提交
107 108 109
/* LEDD */
ASUS_HANDLE(ledd_set, ASUS_HOTK_PREFIX "SLCM");

110 111 112 113 114 115
/* Bluetooth and WLAN
 * WLED and BLED are not handled like other XLED, because in some dsdt
 * they also control the WLAN/Bluetooth device.
 */
ASUS_HANDLE(wl_switch, ASUS_HOTK_PREFIX "WLED");
ASUS_HANDLE(bt_switch, ASUS_HOTK_PREFIX "BLED");
L
Len Brown 已提交
116
ASUS_HANDLE(wireless_status, ASUS_HOTK_PREFIX "RSTS");	/* All new models */
117

118 119 120 121 122
/* Brightness */
ASUS_HANDLE(brightness_set, ASUS_HOTK_PREFIX "SPLV");
ASUS_HANDLE(brightness_get, ASUS_HOTK_PREFIX "GPLV");

/* Backlight */
L
Len Brown 已提交
123 124 125 126 127 128 129
ASUS_HANDLE(lcd_switch, "\\_SB.PCI0.SBRG.EC0._Q10",	/* All new models */
	    "\\_SB.PCI0.ISA.EC0._Q10",	/* A1x */
	    "\\_SB.PCI0.PX40.ECD0._Q10",	/* L3C */
	    "\\_SB.PCI0.PX40.EC0.Q10",	/* M1A */
	    "\\_SB.PCI0.LPCB.EC0._Q10",	/* P30 */
	    "\\_SB.PCI0.PX40.Q10",	/* S1x */
	    "\\Q10");		/* A2x, L2D, L3D, M2E */
130

131 132
/* Display */
ASUS_HANDLE(display_set, ASUS_HOTK_PREFIX "SDSP");
L
Len Brown 已提交
133 134 135
ASUS_HANDLE(display_get, "\\_SB.PCI0.P0P1.VGA.GETD",	/*  A6B, A6K A6R A7D F3JM L4R M6R A3G
							   M6A M6V VX-1 V6J V6V W3Z */
	    "\\_SB.PCI0.P0P2.VGA.GETD",	/* A3E A4K, A4D A4L A6J A7J A8J Z71V M9V
136
					   S5A M5A z33A W1Jc W2V */
L
Len Brown 已提交
137 138 139 140 141 142 143 144 145 146 147 148
	    "\\_SB.PCI0.P0P3.VGA.GETD",	/* A6V A6Q */
	    "\\_SB.PCI0.P0PA.VGA.GETD",	/* A6T, A6M */
	    "\\_SB.PCI0.PCI1.VGAC.NMAP",	/* L3C */
	    "\\_SB.PCI0.VGA.GETD",	/* Z96F */
	    "\\ACTD",		/* A2D */
	    "\\ADVG",		/* A4G Z71A W1N W5A W5F M2N M3N M5N M6N S1N S5N */
	    "\\DNXT",		/* P30 */
	    "\\INFB",		/* A2H D1 L2D L3D L3H L2E L5D L5C M1A M2E L4L W3V */
	    "\\SSTE");		/* A3F A6F A3N A3L M6N W3N W6A */

ASUS_HANDLE(ls_switch, ASUS_HOTK_PREFIX "ALSC");	/* Z71A Z71V */
ASUS_HANDLE(ls_level, ASUS_HOTK_PREFIX "ALSL");	/* Z71A Z71V */
149

C
Corentin Chary 已提交
150 151 152 153 154
/*
 * This is the main structure, we can use it to store anything interesting
 * about the hotk device
 */
struct asus_hotk {
L
Len Brown 已提交
155
	char *name;		//laptop name
C
Corentin Chary 已提交
156 157 158
	struct acpi_device *device;	//the device we are in
	acpi_handle handle;	//the handle of the hotk device
	char status;		//status of the hotk, for LEDs, ...
C
Corentin Chary 已提交
159
	u32 ledd_status;	//status of the LED display
L
Len Brown 已提交
160 161
	u8 light_level;		//light sensor level
	u8 light_switch;	//light sensor switch value
C
Corentin Chary 已提交
162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
	u16 event_count[128];	//count for each event TODO make this better
};

/*
 * This header is made available to allow proper configuration given model,
 * revision number , ... this info cannot go in struct asus_hotk because it is
 * available before the hotk
 */
static struct acpi_table_header *asus_info;

/* The actual device the driver binds to */
static struct asus_hotk *hotk;

/*
 * The hotkey driver declaration
 */
static int asus_hotk_add(struct acpi_device *device);
static int asus_hotk_remove(struct acpi_device *device, int type);
static struct acpi_driver asus_hotk_driver = {
	.name = ASUS_HOTK_NAME,
	.class = ASUS_HOTK_CLASS,
	.ids = ASUS_HOTK_HID,
	.ops = {
		.add = asus_hotk_add,
		.remove = asus_hotk_remove,
		},
};

190 191 192 193 194 195 196 197
/* The backlight device /sys/class/backlight */
static struct backlight_device *asus_backlight_device;

/*
 * The backlight class declaration
 */
static int read_brightness(struct backlight_device *bd);
static int update_bl_status(struct backlight_device *bd);
198
static struct backlight_ops asusbl_ops = {
L
Len Brown 已提交
199 200
	.get_brightness = read_brightness,
	.update_status = update_bl_status,
201 202
};

C
Corentin Chary 已提交
203 204 205 206 207 208 209 210 211 212 213
/* These functions actually update the LED's, and are called from a
 * workqueue. By doing this as separate work rather than when the LED
 * subsystem asks, we avoid messing with the Asus ACPI stuff during a
 * potentially bad time, such as a timer interrupt. */
static struct workqueue_struct *led_workqueue;

#define ASUS_LED(object, ledname)					\
	static void object##_led_set(struct led_classdev *led_cdev,	\
				     enum led_brightness value);	\
	static void object##_led_update(struct work_struct *ignored);	\
	static int object##_led_wk;					\
A
Adrian Bunk 已提交
214
	static DECLARE_WORK(object##_led_work, object##_led_update);	\
C
Corentin Chary 已提交
215 216 217 218 219 220 221 222 223 224
	static struct led_classdev object##_led = {			\
		.name           = "asus:" ledname,			\
		.brightness_set = object##_led_set,			\
	}

ASUS_LED(mled, "mail");
ASUS_LED(tled, "touchpad");
ASUS_LED(rled, "record");
ASUS_LED(pled, "phone");

C
Corentin Chary 已提交
225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
/*
 * This function evaluates an ACPI method, given an int as parameter, the
 * method is searched within the scope of the handle, can be NULL. The output
 * of the method is written is output, which can also be NULL
 *
 * returns 1 if write is successful, 0 else.
 */
static int write_acpi_int(acpi_handle handle, const char *method, int val,
			  struct acpi_buffer *output)
{
	struct acpi_object_list params;	//list of input parameters (an int here)
	union acpi_object in_obj;	//the only param we use
	acpi_status status;

	params.count = 1;
	params.pointer = &in_obj;
	in_obj.type = ACPI_TYPE_INTEGER;
	in_obj.integer.value = val;

	status = acpi_evaluate_object(handle, (char *)method, &params, output);
	return (status == AE_OK);
}

L
Len Brown 已提交
248 249
static int read_wireless_status(int mask)
{
250 251
	ulong status;
	acpi_status rv = AE_OK;
252 253 254 255

	if (!wireless_status_handle)
		return (hotk->status & mask) ? 1 : 0;

256 257
	rv = acpi_evaluate_integer(wireless_status_handle, NULL, NULL, &status);
	if (ACPI_FAILURE(rv))
258
		printk(ASUS_WARNING "Error reading Wireless status\n");
259 260
	else
		return (status & mask) ? 1 : 0;
261 262 263 264

	return (hotk->status & mask) ? 1 : 0;
}

C
Corentin Chary 已提交
265 266 267
/* Generic LED functions */
static int read_status(int mask)
{
268 269 270 271
	/* There is a special method for both wireless devices */
	if (mask == BT_ON || mask == WL_ON)
		return read_wireless_status(mask);

C
Corentin Chary 已提交
272 273 274
	return (hotk->status & mask) ? 1 : 0;
}

C
Corentin Chary 已提交
275
static void write_status(acpi_handle handle, int out, int mask)
C
Corentin Chary 已提交
276 277 278
{
	hotk->status = (out) ? (hotk->status | mask) : (hotk->status & ~mask);

C
Corentin Chary 已提交
279 280
	switch (mask) {
	case MLED_ON:
C
Corentin Chary 已提交
281
		out = !out & 0x1;
C
Corentin Chary 已提交
282 283 284 285 286
		break;
	default:
		out &= 0x1;
		break;
	}
C
Corentin Chary 已提交
287 288

	if (handle && !write_acpi_int(handle, NULL, out, NULL))
C
Corentin Chary 已提交
289
		printk(ASUS_WARNING " write failed %x\n", mask);
C
Corentin Chary 已提交
290 291 292
}

/* /sys/class/led handlers */
C
Corentin Chary 已提交
293
#define ASUS_LED_HANDLER(object, mask)					\
C
Corentin Chary 已提交
294 295 296 297 298 299 300 301 302
	static void object##_led_set(struct led_classdev *led_cdev,	\
				     enum led_brightness value)		\
	{								\
		object##_led_wk = value;				\
		queue_work(led_workqueue, &object##_led_work);		\
	}								\
	static void object##_led_update(struct work_struct *ignored)	\
	{								\
		int value = object##_led_wk;				\
C
Corentin Chary 已提交
303
		write_status(object##_set_handle, value, (mask));	\
C
Corentin Chary 已提交
304 305
	}

C
Corentin Chary 已提交
306 307 308 309
ASUS_LED_HANDLER(mled, MLED_ON);
ASUS_LED_HANDLER(pled, PLED_ON);
ASUS_LED_HANDLER(rled, RLED_ON);
ASUS_LED_HANDLER(tled, TLED_ON);
C
Corentin Chary 已提交
310

311 312 313 314 315 316 317 318 319 320 321 322 323 324 325
static int get_lcd_state(void)
{
	return read_status(LCD_ON);
}

static int set_lcd_state(int value)
{
	int lcd = 0;
	acpi_status status = 0;

	lcd = value ? 1 : 0;

	if (lcd == get_lcd_state())
		return 0;

L
Len Brown 已提交
326
	if (lcd_switch_handle) {
327 328 329 330 331 332 333
		status = acpi_evaluate_object(lcd_switch_handle,
					      NULL, NULL, NULL);

		if (ACPI_FAILURE(status))
			printk(ASUS_WARNING "Error switching LCD\n");
	}

C
Corentin Chary 已提交
334
	write_status(NULL, lcd, LCD_ON);
335 336 337 338 339 340 341
	return 0;
}

static void lcd_blank(int blank)
{
	struct backlight_device *bd = asus_backlight_device;

L
Len Brown 已提交
342
	if (bd) {
343
		bd->props.power = blank;
344
		backlight_update_status(bd);
345 346 347 348 349
	}
}

static int read_brightness(struct backlight_device *bd)
{
350 351
	ulong value;
	acpi_status rv = AE_OK;
352

353 354
	rv = acpi_evaluate_integer(brightness_get_handle, NULL, NULL, &value);
	if (ACPI_FAILURE(rv))
355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377
		printk(ASUS_WARNING "Error reading brightness\n");

	return value;
}

static int set_brightness(struct backlight_device *bd, int value)
{
	int ret = 0;

	value = (0 < value) ? ((15 < value) ? 15 : value) : 0;
	/* 0 <= value <= 15 */

	if (!write_acpi_int(brightness_set_handle, NULL, value, NULL)) {
		printk(ASUS_WARNING "Error changing brightness\n");
		ret = -EIO;
	}

	return ret;
}

static int update_bl_status(struct backlight_device *bd)
{
	int rv;
378
	int value = bd->props.brightness;
379 380

	rv = set_brightness(bd, value);
L
Len Brown 已提交
381
	if (rv)
382 383
		return rv;

384
	value = (bd->props.power == FB_BLANK_UNBLANK) ? 1 : 0;
385 386 387
	return set_lcd_state(value);
}

C
Corentin Chary 已提交
388 389 390 391 392 393 394 395 396 397
/*
 * Platform device handlers
 */

/*
 * We write our info in page, we begin at offset off and cannot write more
 * than count bytes. We set eof to 1 if we handle those 2 values. We return the
 * number of bytes written in page
 */
static ssize_t show_infos(struct device *dev,
L
Len Brown 已提交
398
			  struct device_attribute *attr, char *page)
C
Corentin Chary 已提交
399 400
{
	int len = 0;
401
	ulong temp;
C
Corentin Chary 已提交
402
	char buf[16];		//enough for all info
403 404
	acpi_status rv = AE_OK;

C
Corentin Chary 已提交
405 406 407 408 409 410 411 412 413 414 415 416 417
	/*
	 * We use the easy way, we don't care of off and count, so we don't set eof
	 * to 1
	 */

	len += sprintf(page, ASUS_HOTK_NAME " " ASUS_LAPTOP_VERSION "\n");
	len += sprintf(page + len, "Model reference    : %s\n", hotk->name);
	/*
	 * The SFUN method probably allows the original driver to get the list
	 * of features supported by a given model. For now, 0x0100 or 0x0800
	 * bit signifies that the laptop is equipped with a Wi-Fi MiniPCI card.
	 * The significance of others is yet to be found.
	 */
418 419 420 421
	rv = acpi_evaluate_integer(hotk->handle, "SFUN", NULL, &temp);
	if (!ACPI_FAILURE(rv))
		len += sprintf(page + len, "SFUN value         : 0x%04x\n",
			       (uint) temp);
C
Corentin Chary 已提交
422 423 424 425 426 427 428
	/*
	 * Another value for userspace: the ASYM method returns 0x02 for
	 * battery low and 0x04 for battery critical, its readings tend to be
	 * more accurate than those provided by _BST.
	 * Note: since not all the laptops provide this method, errors are
	 * silently ignored.
	 */
429 430 431 432
	rv = acpi_evaluate_integer(hotk->handle, "ASYM", NULL, &temp);
	if (!ACPI_FAILURE(rv))
		len += sprintf(page + len, "ASYM value         : 0x%04x\n",
			       (uint) temp);
C
Corentin Chary 已提交
433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
	if (asus_info) {
		snprintf(buf, 16, "%d", asus_info->length);
		len += sprintf(page + len, "DSDT length        : %s\n", buf);
		snprintf(buf, 16, "%d", asus_info->checksum);
		len += sprintf(page + len, "DSDT checksum      : %s\n", buf);
		snprintf(buf, 16, "%d", asus_info->revision);
		len += sprintf(page + len, "DSDT revision      : %s\n", buf);
		snprintf(buf, 7, "%s", asus_info->oem_id);
		len += sprintf(page + len, "OEM id             : %s\n", buf);
		snprintf(buf, 9, "%s", asus_info->oem_table_id);
		len += sprintf(page + len, "OEM table id       : %s\n", buf);
		snprintf(buf, 16, "%x", asus_info->oem_revision);
		len += sprintf(page + len, "OEM revision       : 0x%s\n", buf);
		snprintf(buf, 5, "%s", asus_info->asl_compiler_id);
		len += sprintf(page + len, "ASL comp vendor id : %s\n", buf);
		snprintf(buf, 16, "%x", asus_info->asl_compiler_revision);
		len += sprintf(page + len, "ASL comp revision  : 0x%s\n", buf);
	}

	return len;
}

static int parse_arg(const char *buf, unsigned long count, int *val)
{
	if (!count)
		return 0;
	if (count > 31)
		return -EINVAL;
	if (sscanf(buf, "%i", val) != 1)
		return -EINVAL;
	return count;
}

466
static ssize_t store_status(const char *buf, size_t count,
C
Corentin Chary 已提交
467
			    acpi_handle handle, int mask)
468 469 470 471 472 473 474 475
{
	int rv, value;
	int out = 0;

	rv = parse_arg(buf, count, &value);
	if (rv > 0)
		out = value ? 1 : 0;

C
Corentin Chary 已提交
476
	write_status(handle, out, mask);
477 478 479 480

	return rv;
}

C
Corentin Chary 已提交
481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504
/*
 * LEDD display
 */
static ssize_t show_ledd(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "0x%08x\n", hotk->ledd_status);
}

static ssize_t store_ledd(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	int rv, value;

	rv = parse_arg(buf, count, &value);
	if (rv > 0) {
		if (!write_acpi_int(ledd_set_handle, NULL, value, NULL))
			printk(ASUS_WARNING "LED display write failed\n");
		else
			hotk->ledd_status = (u32) value;
	}
	return rv;
}

505 506 507 508 509 510 511 512 513 514 515 516
/*
 * WLAN
 */
static ssize_t show_wlan(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", read_status(WL_ON));
}

static ssize_t store_wlan(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
C
Corentin Chary 已提交
517
	return store_status(buf, count, wl_switch_handle, WL_ON);
518 519 520 521 522 523 524 525 526 527 528
}

/*
 * Bluetooth
 */
static ssize_t show_bluetooth(struct device *dev,
			      struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", read_status(BT_ON));
}

L
Len Brown 已提交
529 530 531
static ssize_t store_bluetooth(struct device *dev,
			       struct device_attribute *attr, const char *buf,
			       size_t count)
532
{
C
Corentin Chary 已提交
533
	return store_status(buf, count, bt_switch_handle, BT_ON);
534 535
}

536 537 538 539 540 541 542 543 544 545 546 547 548
/*
 * Display
 */
static void set_display(int value)
{
	/* no sanity check needed for now */
	if (!write_acpi_int(display_set_handle, NULL, value, NULL))
		printk(ASUS_WARNING "Error setting display\n");
	return;
}

static int read_display(void)
{
549 550
	ulong value = 0;
	acpi_status rv = AE_OK;
551 552 553

	/* In most of the case, we know how to set the display, but sometime
	   we can't read it */
L
Len Brown 已提交
554
	if (display_get_handle) {
555 556 557
		rv = acpi_evaluate_integer(display_get_handle, NULL,
					   NULL, &value);
		if (ACPI_FAILURE(rv))
558 559 560 561 562 563 564
			printk(ASUS_WARNING "Error reading display status\n");
	}

	value &= 0x0F;		/* needed for some models, shouldn't hurt others */

	return value;
}
L
Len Brown 已提交
565

566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
/*
 * Now, *this* one could be more user-friendly, but so far, no-one has
 * complained. The significance of bits is the same as in store_disp()
 */
static ssize_t show_disp(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", read_display());
}

/*
 * Experimental support for display switching. As of now: 1 should activate
 * the LCD output, 2 should do for CRT, 4 for TV-Out and 8 for DVI.
 * Any combination (bitwise) of these will suffice. I never actually tested 4
 * displays hooked up simultaneously, so be warned. See the acpi4asus README
 * for more info.
 */
static ssize_t store_disp(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	int rv, value;

	rv = parse_arg(buf, count, &value);
	if (rv > 0)
		set_display(value);
	return rv;
}

594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649
/*
 * Light Sens
 */
static void set_light_sens_switch(int value)
{
	if (!write_acpi_int(ls_switch_handle, NULL, value, NULL))
		printk(ASUS_WARNING "Error setting light sensor switch\n");
	hotk->light_switch = value;
}

static ssize_t show_lssw(struct device *dev,
			 struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", hotk->light_switch);
}

static ssize_t store_lssw(struct device *dev, struct device_attribute *attr,
			  const char *buf, size_t count)
{
	int rv, value;

	rv = parse_arg(buf, count, &value);
	if (rv > 0)
		set_light_sens_switch(value ? 1 : 0);

	return rv;
}

static void set_light_sens_level(int value)
{
	if (!write_acpi_int(ls_level_handle, NULL, value, NULL))
		printk(ASUS_WARNING "Error setting light sensor level\n");
	hotk->light_level = value;
}

static ssize_t show_lslvl(struct device *dev,
			  struct device_attribute *attr, char *buf)
{
	return sprintf(buf, "%d\n", hotk->light_level);
}

static ssize_t store_lslvl(struct device *dev, struct device_attribute *attr,
			   const char *buf, size_t count)
{
	int rv, value;

	rv = parse_arg(buf, count, &value);
	if (rv > 0) {
		value = (0 < value) ? ((15 < value) ? 15 : value) : 0;
		/* 0 <= value <= 15 */
		set_light_sens_level(value);
	}

	return rv;
}

C
Corentin Chary 已提交
650 651 652 653 654 655
static void asus_hotk_notify(acpi_handle handle, u32 event, void *data)
{
	/* TODO Find a better way to handle events count. */
	if (!hotk)
		return;

656 657 658 659 660
	/*
	 * We need to tell the backlight device when the backlight power is
	 * switched
	 */
	if (event == ATKD_LCD_ON) {
C
Corentin Chary 已提交
661
		write_status(NULL, 1, LCD_ON);
662
		lcd_blank(FB_BLANK_UNBLANK);
L
Len Brown 已提交
663
	} else if (event == ATKD_LCD_OFF) {
C
Corentin Chary 已提交
664
		write_status(NULL, 0, LCD_ON);
665 666 667
		lcd_blank(FB_BLANK_POWERDOWN);
	}

C
Corentin Chary 已提交
668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691
	acpi_bus_generate_event(hotk->device, event,
				hotk->event_count[event % 128]++);

	return;
}

#define ASUS_CREATE_DEVICE_ATTR(_name)					\
	struct device_attribute dev_attr_##_name = {			\
		.attr = {						\
			.name = __stringify(_name),			\
			.mode = 0,					\
			.owner = THIS_MODULE },				\
		.show   = NULL,						\
		.store  = NULL,						\
	}

#define ASUS_SET_DEVICE_ATTR(_name, _mode, _show, _store)		\
	do {								\
		dev_attr_##_name.attr.mode = _mode;			\
		dev_attr_##_name.show = _show;				\
		dev_attr_##_name.store = _store;			\
	} while(0)

static ASUS_CREATE_DEVICE_ATTR(infos);
692 693
static ASUS_CREATE_DEVICE_ATTR(wlan);
static ASUS_CREATE_DEVICE_ATTR(bluetooth);
694
static ASUS_CREATE_DEVICE_ATTR(display);
C
Corentin Chary 已提交
695
static ASUS_CREATE_DEVICE_ATTR(ledd);
696 697
static ASUS_CREATE_DEVICE_ATTR(ls_switch);
static ASUS_CREATE_DEVICE_ATTR(ls_level);
C
Corentin Chary 已提交
698 699

static struct attribute *asuspf_attributes[] = {
L
Len Brown 已提交
700 701 702 703 704 705 706 707
	&dev_attr_infos.attr,
	&dev_attr_wlan.attr,
	&dev_attr_bluetooth.attr,
	&dev_attr_display.attr,
	&dev_attr_ledd.attr,
	&dev_attr_ls_switch.attr,
	&dev_attr_ls_level.attr,
	NULL
C
Corentin Chary 已提交
708 709 710
};

static struct attribute_group asuspf_attribute_group = {
L
Len Brown 已提交
711
	.attrs = asuspf_attributes
C
Corentin Chary 已提交
712 713 714
};

static struct platform_driver asuspf_driver = {
L
Len Brown 已提交
715 716 717 718
	.driver = {
		   .name = ASUS_HOTK_FILE,
		   .owner = THIS_MODULE,
		   }
C
Corentin Chary 已提交
719 720 721 722 723 724 725
};

static struct platform_device *asuspf_device;

static void asus_hotk_add_fs(void)
{
	ASUS_SET_DEVICE_ATTR(infos, 0444, show_infos, NULL);
726 727 728 729 730 731 732

	if (wl_switch_handle)
		ASUS_SET_DEVICE_ATTR(wlan, 0644, show_wlan, store_wlan);

	if (bt_switch_handle)
		ASUS_SET_DEVICE_ATTR(bluetooth, 0644,
				     show_bluetooth, store_bluetooth);
733 734 735

	if (display_set_handle && display_get_handle)
		ASUS_SET_DEVICE_ATTR(display, 0644, show_disp, store_disp);
L
Len Brown 已提交
736
	else if (display_set_handle)
737 738
		ASUS_SET_DEVICE_ATTR(display, 0200, NULL, store_disp);

C
Corentin Chary 已提交
739 740 741
	if (ledd_set_handle)
		ASUS_SET_DEVICE_ATTR(ledd, 0644, show_ledd, store_ledd);

742 743 744 745
	if (ls_switch_handle && ls_level_handle) {
		ASUS_SET_DEVICE_ATTR(ls_level, 0644, show_lslvl, store_lslvl);
		ASUS_SET_DEVICE_ATTR(ls_switch, 0644, show_lssw, store_lssw);
	}
C
Corentin Chary 已提交
746 747
}

L
Len Brown 已提交
748
static int asus_handle_init(char *name, acpi_handle * handle,
C
Corentin Chary 已提交
749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774 775
			    char **paths, int num_paths)
{
	int i;
	acpi_status status;

	for (i = 0; i < num_paths; i++) {
		status = acpi_get_handle(NULL, paths[i], handle);
		if (ACPI_SUCCESS(status))
			return 0;
	}

	*handle = NULL;
	return -ENODEV;
}

#define ASUS_HANDLE_INIT(object)					\
	asus_handle_init(#object, &object##_handle, object##_paths,	\
			 ARRAY_SIZE(object##_paths))

/*
 * This function is used to initialize the hotk with right values. In this
 * method, we can make all the detection we want, and modify the hotk struct
 */
static int asus_hotk_get_info(void)
{
	struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
	union acpi_object *model = NULL;
776
	ulong bsts_result, hwrs_result;
C
Corentin Chary 已提交
777 778 779 780 781 782 783 784 785 786 787
	char *string = NULL;
	acpi_status status;

	/*
	 * Get DSDT headers early enough to allow for differentiating between
	 * models, but late enough to allow acpi_bus_register_driver() to fail
	 * before doing anything ACPI-specific. Should we encounter a machine,
	 * which needs special handling (i.e. its hotkey device has a different
	 * HID), this bit will be moved. A global variable asus_info contains
	 * the DSDT header.
	 */
788
	status = acpi_get_table(ACPI_SIG_DSDT, 1, &asus_info);
C
Corentin Chary 已提交
789 790 791 792 793 794 795 796 797 798
	if (ACPI_FAILURE(status))
		printk(ASUS_WARNING "Couldn't get the DSDT table header\n");

	/* We have to write 0 on init this far for all ASUS models */
	if (!write_acpi_int(hotk->handle, "INIT", 0, &buffer)) {
		printk(ASUS_ERR "Hotkey initialization failed\n");
		return -ENODEV;
	}

	/* This needs to be called for some laptops to init properly */
799 800 801
	status =
	    acpi_evaluate_integer(hotk->handle, "BSTS", NULL, &bsts_result);
	if (ACPI_FAILURE(status))
C
Corentin Chary 已提交
802 803 804
		printk(ASUS_WARNING "Error calling BSTS\n");
	else if (bsts_result)
		printk(ASUS_NOTICE "BSTS called, 0x%02x returned\n",
805
		       (uint) bsts_result);
C
Corentin Chary 已提交
806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830

	/*
	 * Try to match the object returned by INIT to the specific model.
	 * Handle every possible object (or the lack of thereof) the DSDT
	 * writers might throw at us. When in trouble, we pass NULL to
	 * asus_model_match() and try something completely different.
	 */
	if (buffer.pointer) {
		model = buffer.pointer;
		switch (model->type) {
		case ACPI_TYPE_STRING:
			string = model->string.pointer;
			break;
		case ACPI_TYPE_BUFFER:
			string = model->buffer.pointer;
			break;
		default:
			string = "";
			break;
		}
	}
	hotk->name = kstrdup(string, GFP_KERNEL);
	if (!hotk->name)
		return -ENOMEM;

L
Len Brown 已提交
831
	if (*string)
C
Corentin Chary 已提交
832 833
		printk(ASUS_NOTICE "  %s model detected\n", string);

C
Corentin Chary 已提交
834 835 836 837 838
	ASUS_HANDLE_INIT(mled_set);
	ASUS_HANDLE_INIT(tled_set);
	ASUS_HANDLE_INIT(rled_set);
	ASUS_HANDLE_INIT(pled_set);

C
Corentin Chary 已提交
839 840
	ASUS_HANDLE_INIT(ledd_set);

841 842 843 844 845 846
	/*
	 * The HWRS method return informations about the hardware.
	 * 0x80 bit is for WLAN, 0x100 for Bluetooth.
	 * The significance of others is yet to be found.
	 * If we don't find the method, we assume the device are present.
	 */
847 848 849
	status =
	    acpi_evaluate_integer(hotk->handle, "HRWS", NULL, &hwrs_result);
	if (ACPI_FAILURE(status))
850 851
		hwrs_result = WL_HWRS | BT_HWRS;

L
Len Brown 已提交
852
	if (hwrs_result & WL_HWRS)
853
		ASUS_HANDLE_INIT(wl_switch);
L
Len Brown 已提交
854
	if (hwrs_result & BT_HWRS)
855 856 857 858
		ASUS_HANDLE_INIT(bt_switch);

	ASUS_HANDLE_INIT(wireless_status);

859 860 861 862 863
	ASUS_HANDLE_INIT(brightness_set);
	ASUS_HANDLE_INIT(brightness_get);

	ASUS_HANDLE_INIT(lcd_switch);

864 865 866
	ASUS_HANDLE_INIT(display_set);
	ASUS_HANDLE_INIT(display_get);

867 868
	/* There is a lot of models with "ALSL", but a few get
	   a real light sens, so we need to check it. */
L
Len Brown 已提交
869
	if (ASUS_HANDLE_INIT(ls_switch))
870 871
		ASUS_HANDLE_INIT(ls_level);

C
Corentin Chary 已提交
872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
	kfree(model);

	return AE_OK;
}

static int asus_hotk_check(void)
{
	int result = 0;

	result = acpi_bus_get_status(hotk->device);
	if (result)
		return result;

	if (hotk->device->status.present) {
		result = asus_hotk_get_info();
	} else {
		printk(ASUS_ERR "Hotkey device not present, aborting\n");
		return -EINVAL;
	}

	return result;
}

static int asus_hotk_found;

static int asus_hotk_add(struct acpi_device *device)
{
	acpi_status status = AE_OK;
	int result;

	if (!device)
		return -EINVAL;

	printk(ASUS_NOTICE "Asus Laptop Support version %s\n",
	       ASUS_LAPTOP_VERSION);

	hotk = kmalloc(sizeof(struct asus_hotk), GFP_KERNEL);
	if (!hotk)
		return -ENOMEM;
	memset(hotk, 0, sizeof(struct asus_hotk));

	hotk->handle = device->handle;
	strcpy(acpi_device_name(device), ASUS_HOTK_DEVICE_NAME);
	strcpy(acpi_device_class(device), ASUS_HOTK_CLASS);
	acpi_driver_data(device) = hotk;
	hotk->device = device;

	result = asus_hotk_check();
	if (result)
		goto end;

	asus_hotk_add_fs();

	/*
	 * We install the handler, it will receive the hotk in parameter, so, we
	 * could add other data to the hotk struct
	 */
	status = acpi_install_notify_handler(hotk->handle, ACPI_SYSTEM_NOTIFY,
					     asus_hotk_notify, hotk);
	if (ACPI_FAILURE(status))
		printk(ASUS_ERR "Error installing notify handler\n");

	asus_hotk_found = 1;

936
	/* WLED and BLED are on by default */
C
Corentin Chary 已提交
937 938 939 940 941 942
	write_status(bt_switch_handle, 1, BT_ON);
	write_status(wl_switch_handle, 1, WL_ON);

	/* If the h/w switch is off, we need to check the real status */
	write_status(NULL, read_status(BT_ON), BT_ON);
	write_status(NULL, read_status(WL_ON), WL_ON);
943

944
	/* LCD Backlight is on by default */
C
Corentin Chary 已提交
945
	write_status(NULL, 1, LCD_ON);
946

C
Corentin Chary 已提交
947 948 949
	/* LED display is off by default */
	hotk->ledd_status = 0xFFF;

L
Len Brown 已提交
950 951 952
	/* Set initial values of light sensor and level */
	hotk->light_switch = 1;	/* Default to light sensor disabled */
	hotk->light_level = 0;	/* level 5 for sensor sensitivity */
953

L
Len Brown 已提交
954 955
	if (ls_switch_handle)
		set_light_sens_switch(hotk->light_switch);
956

L
Len Brown 已提交
957 958
	if (ls_level_handle)
		set_light_sens_level(hotk->light_level);
959

C
Corentin Chary 已提交
960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986
      end:
	if (result) {
		kfree(hotk->name);
		kfree(hotk);
	}

	return result;
}

static int asus_hotk_remove(struct acpi_device *device, int type)
{
	acpi_status status = 0;

	if (!device || !acpi_driver_data(device))
		return -EINVAL;

	status = acpi_remove_notify_handler(hotk->handle, ACPI_SYSTEM_NOTIFY,
					    asus_hotk_notify);
	if (ACPI_FAILURE(status))
		printk(ASUS_ERR "Error removing notify handler\n");

	kfree(hotk->name);
	kfree(hotk);

	return 0;
}

987 988
static void asus_backlight_exit(void)
{
L
Len Brown 已提交
989
	if (asus_backlight_device)
990 991 992
		backlight_device_unregister(asus_backlight_device);
}

C
Corentin Chary 已提交
993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007
#define  ASUS_LED_UNREGISTER(object)				\
	if(object##_led.class_dev				\
	   && !IS_ERR(object##_led.class_dev))			\
		led_classdev_unregister(&object##_led)

static void asus_led_exit(void)
{
	ASUS_LED_UNREGISTER(mled);
	ASUS_LED_UNREGISTER(tled);
	ASUS_LED_UNREGISTER(pled);
	ASUS_LED_UNREGISTER(rled);

	destroy_workqueue(led_workqueue);
}

C
Corentin Chary 已提交
1008 1009
static void __exit asus_laptop_exit(void)
{
1010
	asus_backlight_exit();
C
Corentin Chary 已提交
1011 1012
	asus_led_exit();

C
Corentin Chary 已提交
1013
	acpi_bus_unregister_driver(&asus_hotk_driver);
L
Len Brown 已提交
1014 1015 1016
	sysfs_remove_group(&asuspf_device->dev.kobj, &asuspf_attribute_group);
	platform_device_unregister(asuspf_device);
	platform_driver_unregister(&asuspf_driver);
C
Corentin Chary 已提交
1017 1018
}

L
Len Brown 已提交
1019
static int asus_backlight_init(struct device *dev)
1020 1021 1022
{
	struct backlight_device *bd;

L
Len Brown 已提交
1023 1024
	if (brightness_set_handle && lcd_switch_handle) {
		bd = backlight_device_register(ASUS_HOTK_FILE, dev,
1025
					       NULL, &asusbl_ops);
L
Len Brown 已提交
1026
		if (IS_ERR(bd)) {
1027 1028 1029 1030 1031 1032 1033 1034
			printk(ASUS_ERR
			       "Could not register asus backlight device\n");
			asus_backlight_device = NULL;
			return PTR_ERR(bd);
		}

		asus_backlight_device = bd;

1035 1036 1037
		bd->props.max_brightness = 15;
		bd->props.brightness = read_brightness(NULL);
		bd->props.power = FB_BLANK_UNBLANK;
1038
		backlight_update_status(bd);
1039 1040 1041 1042
	}
	return 0;
}

C
Corentin Chary 已提交
1043
static int asus_led_register(acpi_handle handle,
L
Len Brown 已提交
1044
			     struct led_classdev *ldev, struct device *dev)
C
Corentin Chary 已提交
1045
{
L
Len Brown 已提交
1046
	if (!handle)
C
Corentin Chary 已提交
1047 1048 1049 1050
		return 0;

	return led_classdev_register(dev, ldev);
}
L
Len Brown 已提交
1051

C
Corentin Chary 已提交
1052 1053 1054
#define ASUS_LED_REGISTER(object, device)				\
	asus_led_register(object##_set_handle, &object##_led, device)

L
Len Brown 已提交
1055
static int asus_led_init(struct device *dev)
C
Corentin Chary 已提交
1056 1057 1058 1059
{
	int rv;

	rv = ASUS_LED_REGISTER(mled, dev);
L
Len Brown 已提交
1060
	if (rv)
C
Corentin Chary 已提交
1061 1062 1063
		return rv;

	rv = ASUS_LED_REGISTER(tled, dev);
L
Len Brown 已提交
1064
	if (rv)
C
Corentin Chary 已提交
1065 1066 1067
		return rv;

	rv = ASUS_LED_REGISTER(rled, dev);
L
Len Brown 已提交
1068
	if (rv)
C
Corentin Chary 已提交
1069 1070 1071
		return rv;

	rv = ASUS_LED_REGISTER(pled, dev);
L
Len Brown 已提交
1072
	if (rv)
C
Corentin Chary 已提交
1073 1074 1075
		return rv;

	led_workqueue = create_singlethread_workqueue("led_workqueue");
L
Len Brown 已提交
1076
	if (!led_workqueue)
C
Corentin Chary 已提交
1077 1078 1079 1080 1081
		return -ENOMEM;

	return 0;
}

C
Corentin Chary 已提交
1082 1083
static int __init asus_laptop_init(void)
{
C
Corentin Chary 已提交
1084
	struct device *dev;
C
Corentin Chary 已提交
1085 1086 1087 1088 1089 1090 1091 1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105
	int result;

	if (acpi_disabled)
		return -ENODEV;

	result = acpi_bus_register_driver(&asus_hotk_driver);
	if (result < 0)
		return result;

	/*
	 * This is a bit of a kludge.  We only want this module loaded
	 * for ASUS systems, but there's currently no way to probe the
	 * ACPI namespace for ASUS HIDs.  So we just return failure if
	 * we didn't find one, which will cause the module to be
	 * unloaded.
	 */
	if (!asus_hotk_found) {
		acpi_bus_unregister_driver(&asus_hotk_driver);
		return -ENODEV;
	}

C
Corentin Chary 已提交
1106 1107
	dev = acpi_get_physical_device(hotk->device->handle);

1108
	result = asus_backlight_init(dev);
L
Len Brown 已提交
1109
	if (result)
1110 1111
		goto fail_backlight;

C
Corentin Chary 已提交
1112
	result = asus_led_init(dev);
L
Len Brown 已提交
1113
	if (result)
C
Corentin Chary 已提交
1114 1115
		goto fail_led;

L
Len Brown 已提交
1116
	/* Register platform stuff */
C
Corentin Chary 已提交
1117
	result = platform_driver_register(&asuspf_driver);
L
Len Brown 已提交
1118 1119
	if (result)
		goto fail_platform_driver;
C
Corentin Chary 已提交
1120

L
Len Brown 已提交
1121 1122 1123 1124 1125
	asuspf_device = platform_device_alloc(ASUS_HOTK_FILE, -1);
	if (!asuspf_device) {
		result = -ENOMEM;
		goto fail_platform_device1;
	}
C
Corentin Chary 已提交
1126

L
Len Brown 已提交
1127 1128 1129
	result = platform_device_add(asuspf_device);
	if (result)
		goto fail_platform_device2;
C
Corentin Chary 已提交
1130

L
Len Brown 已提交
1131
	result = sysfs_create_group(&asuspf_device->dev.kobj,
C
Corentin Chary 已提交
1132
				    &asuspf_attribute_group);
L
Len Brown 已提交
1133 1134
	if (result)
		goto fail_sysfs;
C
Corentin Chary 已提交
1135

L
Len Brown 已提交
1136
	return 0;
C
Corentin Chary 已提交
1137

L
Len Brown 已提交
1138 1139
      fail_sysfs:
	platform_device_del(asuspf_device);
C
Corentin Chary 已提交
1140

L
Len Brown 已提交
1141
      fail_platform_device2:
C
Corentin Chary 已提交
1142 1143
	platform_device_put(asuspf_device);

L
Len Brown 已提交
1144 1145
      fail_platform_device1:
	platform_driver_unregister(&asuspf_driver);
C
Corentin Chary 已提交
1146

L
Len Brown 已提交
1147
      fail_platform_driver:
C
Corentin Chary 已提交
1148 1149
	asus_led_exit();

L
Len Brown 已提交
1150
      fail_led:
1151 1152
	asus_backlight_exit();

L
Len Brown 已提交
1153
      fail_backlight:
C
Corentin Chary 已提交
1154 1155 1156 1157 1158 1159

	return result;
}

module_init(asus_laptop_init);
module_exit(asus_laptop_exit);