ec.c 24.6 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  ec.c - ACPI Embedded Controller Driver (v2.0)
L
Linus Torvalds 已提交
3
 *
4 5
 *  Copyright (C) 2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
 *  Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com>
L
Linus Torvalds 已提交
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
 *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  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.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/delay.h>
#include <linux/proc_fs.h>
#include <linux/seq_file.h>
D
Dmitry Torokhov 已提交
36
#include <linux/interrupt.h>
37
#include <linux/list.h>
L
Linus Torvalds 已提交
38 39 40 41 42 43 44 45
#include <asm/io.h>
#include <acpi/acpi_bus.h>
#include <acpi/acpi_drivers.h>
#include <acpi/actypes.h>

#define ACPI_EC_CLASS			"embedded_controller"
#define ACPI_EC_DEVICE_NAME		"Embedded Controller"
#define ACPI_EC_FILE_INFO		"info"
46

47 48
#undef PREFIX
#define PREFIX				"ACPI: EC: "
49

50 51 52
/* Uncomment next line to get verbose print outs*/
/* #define DEBUG */

53
/* EC status register */
L
Linus Torvalds 已提交
54 55
#define ACPI_EC_FLAG_OBF	0x01	/* Output buffer full */
#define ACPI_EC_FLAG_IBF	0x02	/* Input buffer full */
D
Dmitry Torokhov 已提交
56
#define ACPI_EC_FLAG_BURST	0x10	/* burst mode */
L
Linus Torvalds 已提交
57
#define ACPI_EC_FLAG_SCI	0x20	/* EC-SCI occurred */
58

59
/* EC commands */
60
enum ec_command {
A
Alexey Starikovskiy 已提交
61 62 63 64 65
	ACPI_EC_COMMAND_READ = 0x80,
	ACPI_EC_COMMAND_WRITE = 0x81,
	ACPI_EC_BURST_ENABLE = 0x82,
	ACPI_EC_BURST_DISABLE = 0x83,
	ACPI_EC_COMMAND_QUERY = 0x84,
66
};
67

68
/* EC events */
69
enum ec_event {
70
	ACPI_EC_EVENT_OBF_1 = 1,	/* Output buffer full */
71
	ACPI_EC_EVENT_IBF_0,		/* Input buffer empty */
72 73
};

74
#define ACPI_EC_DELAY		500	/* Wait 500ms max. during EC ops */
75 76
#define ACPI_EC_UDELAY_GLK	1000	/* Wait 1ms max. to get global lock */

77 78 79
enum {
	EC_FLAGS_WAIT_GPE = 0,		/* Don't check status until GPE arrives */
	EC_FLAGS_QUERY_PENDING,		/* Query is pending */
80
	EC_FLAGS_GPE_MODE,		/* Expect GPE to be sent for status change */
81 82
	EC_FLAGS_NO_ADDRESS_GPE,	/* Expect GPE only for non-address event */
	EC_FLAGS_ADDRESS,		/* Address is being written */
83 84
	EC_FLAGS_NO_WDATA_GPE,		/* Don't expect WDATA GPE event */
	EC_FLAGS_WDATA,			/* Data is being written */
85 86
};

L
Len Brown 已提交
87 88 89
static int acpi_ec_remove(struct acpi_device *device, int type);
static int acpi_ec_start(struct acpi_device *device);
static int acpi_ec_stop(struct acpi_device *device, int type);
90
static int acpi_ec_add(struct acpi_device *device);
L
Linus Torvalds 已提交
91

92 93 94 95 96
static const struct acpi_device_id ec_device_ids[] = {
	{"PNP0C09", 0},
	{"", 0},
};

L
Linus Torvalds 已提交
97
static struct acpi_driver acpi_ec_driver = {
L
Len Brown 已提交
98
	.name = "ec",
L
Len Brown 已提交
99
	.class = ACPI_EC_CLASS,
100
	.ids = ec_device_ids,
L
Len Brown 已提交
101
	.ops = {
102
		.add = acpi_ec_add,
L
Len Brown 已提交
103 104 105 106
		.remove = acpi_ec_remove,
		.start = acpi_ec_start,
		.stop = acpi_ec_stop,
		},
L
Linus Torvalds 已提交
107
};
108 109

/* If we find an EC via the ECDT, we need to keep a ptr to its context */
110
/* External interfaces use first EC only, so remember */
111 112 113 114 115 116 117 118 119 120
typedef int (*acpi_ec_query_func) (void *data);

struct acpi_ec_query_handler {
	struct list_head node;
	acpi_ec_query_func func;
	acpi_handle handle;
	void *data;
	u8 query_bit;
};

121
static struct acpi_ec {
122
	acpi_handle handle;
123
	unsigned long gpe;
124 125
	unsigned long command_addr;
	unsigned long data_addr;
126
	unsigned long global_lock;
127
	unsigned long flags;
128
	struct mutex lock;
129
	wait_queue_head_t wait;
130
	struct list_head list;
131
	u8 handlers_installed;
132
} *boot_ec, *first_ec;
133

L
Linus Torvalds 已提交
134 135 136 137
/* --------------------------------------------------------------------------
                             Transaction Management
   -------------------------------------------------------------------------- */

138
static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
L
Linus Torvalds 已提交
139
{
140 141 142
	u8 x = inb(ec->command_addr);
	pr_debug(PREFIX "---> status = 0x%2x\n", x);
	return x;
D
Dmitry Torokhov 已提交
143 144
}

145
static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
146
{
147 148
	u8 x = inb(ec->data_addr);
	pr_debug(PREFIX "---> data = 0x%2x\n", x);
149
	return inb(ec->data_addr);
150 151
}

152
static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
L
Luming Yu 已提交
153
{
154
	pr_debug(PREFIX "<--- command = 0x%2x\n", command);
155
	outb(command, ec->command_addr);
L
Luming Yu 已提交
156 157
}

158
static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
L
Luming Yu 已提交
159
{
160
	pr_debug(PREFIX "<--- data = 0x%2x\n", data);
161
	outb(data, ec->data_addr);
162
}
L
Luming Yu 已提交
163

164
static inline int acpi_ec_check_status(struct acpi_ec *ec, enum ec_event event)
165
{
166
	if (test_bit(EC_FLAGS_WAIT_GPE, &ec->flags))
167
		return 0;
A
Alexey Starikovskiy 已提交
168
	if (event == ACPI_EC_EVENT_OBF_1) {
169
		if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF)
170
			return 1;
A
Alexey Starikovskiy 已提交
171
	} else if (event == ACPI_EC_EVENT_IBF_0) {
172
		if (!(acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF))
173
			return 1;
L
Luming Yu 已提交
174 175
	}

176
	return 0;
L
Luming Yu 已提交
177
}
D
Dmitry Torokhov 已提交
178

179
static int acpi_ec_wait(struct acpi_ec *ec, enum ec_event event, int force_poll)
180
{
181 182 183 184
	int ret = 0;
	if (unlikely(test_bit(EC_FLAGS_ADDRESS, &ec->flags) &&
		     test_bit(EC_FLAGS_NO_ADDRESS_GPE, &ec->flags)))
		force_poll = 1;
185 186 187
	if (unlikely(test_bit(EC_FLAGS_WDATA, &ec->flags) &&
		     test_bit(EC_FLAGS_NO_WDATA_GPE, &ec->flags)))
		force_poll = 1;
188 189
	if (likely(test_bit(EC_FLAGS_GPE_MODE, &ec->flags)) &&
	    likely(!force_poll)) {
190 191
		if (wait_event_timeout(ec->wait, acpi_ec_check_status(ec, event),
				       msecs_to_jiffies(ACPI_EC_DELAY)))
192
			goto end;
193 194
		clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
		if (acpi_ec_check_status(ec, event)) {
195 196
			if (test_bit(EC_FLAGS_ADDRESS, &ec->flags)) {
				/* miss address GPE, don't expect it anymore */
197
				pr_info(PREFIX "missing address confirmation, "
198 199
					"don't expect it any longer.\n");
				set_bit(EC_FLAGS_NO_ADDRESS_GPE, &ec->flags);
200 201 202 203 204
			} else if (test_bit(EC_FLAGS_WDATA, &ec->flags)) {
				/* miss write data GPE, don't expect it */
				pr_info(PREFIX "missing write data confirmation, "
					"don't expect it any longer.\n");
				set_bit(EC_FLAGS_NO_WDATA_GPE, &ec->flags);
205
			} else {
206
				/* missing GPEs, switch back to poll mode */
207
				if (printk_ratelimit())
208
					pr_info(PREFIX "missing confirmations, "
209
						"switch off interrupt mode.\n");
210
				clear_bit(EC_FLAGS_GPE_MODE, &ec->flags);
211
			}
212
			goto end;
213
		}
214 215 216 217 218
	} else {
		unsigned long delay = jiffies + msecs_to_jiffies(ACPI_EC_DELAY);
		clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
		while (time_before(jiffies, delay)) {
			if (acpi_ec_check_status(ec, event))
219
				goto end;
220
		}
221
	}
222
	pr_err(PREFIX "acpi_ec_wait timeout,"
223 224
			       " status = %d, expect_event = %d\n",
			       acpi_ec_read_status(ec), event);
225 226 227 228
	ret = -ETIME;
      end:
	clear_bit(EC_FLAGS_ADDRESS, &ec->flags);
	return ret;
L
Linus Torvalds 已提交
229 230
}

231
static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command,
A
Alexey Starikovskiy 已提交
232
					const u8 * wdata, unsigned wdata_len,
233 234
					u8 * rdata, unsigned rdata_len,
					int force_poll)
L
Luming Yu 已提交
235
{
236
	int result = 0;
237
	set_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
238
	acpi_ec_write_cmd(ec, command);
239
	pr_debug(PREFIX "transaction start\n");
A
Alexey Starikovskiy 已提交
240
	for (; wdata_len > 0; --wdata_len) {
241
		result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, force_poll);
242
		if (result) {
243
			pr_err(PREFIX
A
Alexey Starikovskiy 已提交
244
			       "write_cmd timeout, command = %d\n", command);
245 246
			goto end;
		}
247 248 249
		/* mark the address byte written to EC */
		if (rdata_len + wdata_len > 1)
			set_bit(EC_FLAGS_ADDRESS, &ec->flags);
250
		set_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
251
		acpi_ec_write_data(ec, *(wdata++));
252
	}
L
Luming Yu 已提交
253

254
	if (!rdata_len) {
255
		set_bit(EC_FLAGS_WDATA, &ec->flags);
256
		result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, force_poll);
257
		if (result) {
258
			pr_err(PREFIX
A
Alexey Starikovskiy 已提交
259
			       "finish-write timeout, command = %d\n", command);
260 261
			goto end;
		}
262 263
	} else if (command == ACPI_EC_COMMAND_QUERY)
		clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
L
Luming Yu 已提交
264

A
Alexey Starikovskiy 已提交
265
	for (; rdata_len > 0; --rdata_len) {
266
		result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1, force_poll);
267
		if (result) {
268
			pr_err(PREFIX "read timeout, command = %d\n", command);
269 270
			goto end;
		}
271 272 273
		/* Don't expect GPE after last read */
		if (rdata_len > 1)
			set_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
274
		*(rdata++) = acpi_ec_read_data(ec);
275
	}
276
      end:
277
	pr_debug(PREFIX "transaction end\n");
278
	return result;
L
Luming Yu 已提交
279 280
}

281
static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
A
Alexey Starikovskiy 已提交
282
			       const u8 * wdata, unsigned wdata_len,
283 284
			       u8 * rdata, unsigned rdata_len,
			       int force_poll)
L
Linus Torvalds 已提交
285
{
286
	int status;
L
Len Brown 已提交
287
	u32 glk;
L
Linus Torvalds 已提交
288

289
	if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata))
290
		return -EINVAL;
L
Linus Torvalds 已提交
291

A
Alexey Starikovskiy 已提交
292 293
	if (rdata)
		memset(rdata, 0, rdata_len);
L
Linus Torvalds 已提交
294

295
	mutex_lock(&ec->lock);
296
	if (ec->global_lock) {
L
Linus Torvalds 已提交
297
		status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
298 299
		if (ACPI_FAILURE(status)) {
			mutex_unlock(&ec->lock);
300
			return -ENODEV;
301
		}
L
Linus Torvalds 已提交
302
	}
D
Dmitry Torokhov 已提交
303

304
	status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0, 0);
305
	if (status) {
306 307
		pr_err(PREFIX "input buffer is not empty, "
				"aborting transaction\n");
D
Dmitry Torokhov 已提交
308
		goto end;
309
	}
L
Linus Torvalds 已提交
310

A
Alexey Starikovskiy 已提交
311 312
	status = acpi_ec_transaction_unlocked(ec, command,
					      wdata, wdata_len,
313 314
					      rdata, rdata_len,
					      force_poll);
L
Linus Torvalds 已提交
315

A
Alexey Starikovskiy 已提交
316
      end:
L
Linus Torvalds 已提交
317

318
	if (ec->global_lock)
L
Linus Torvalds 已提交
319
		acpi_release_global_lock(glk);
320
	mutex_unlock(&ec->lock);
L
Linus Torvalds 已提交
321

322
	return status;
L
Linus Torvalds 已提交
323 324
}

325 326 327 328 329 330 331
/*
 * Note: samsung nv5000 doesn't work with ec burst mode.
 * http://bugzilla.kernel.org/show_bug.cgi?id=4980
 */
int acpi_ec_burst_enable(struct acpi_ec *ec)
{
	u8 d;
332
	return acpi_ec_transaction(ec, ACPI_EC_BURST_ENABLE, NULL, 0, &d, 1, 0);
333 334 335 336
}

int acpi_ec_burst_disable(struct acpi_ec *ec)
{
337
	return acpi_ec_transaction(ec, ACPI_EC_BURST_DISABLE, NULL, 0, NULL, 0, 0);
338 339
}

A
Alexey Starikovskiy 已提交
340
static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
341 342 343 344 345
{
	int result;
	u8 d;

	result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_READ,
346
				     &address, 1, &d, 1, 0);
347 348 349
	*data = d;
	return result;
}
350

351 352
static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
{
A
Alexey Starikovskiy 已提交
353 354
	u8 wdata[2] = { address, data };
	return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
355
				   wdata, 2, NULL, 0, 0);
356 357
}

L
Linus Torvalds 已提交
358 359 360
/*
 * Externally callable EC access functions. For now, assume 1 EC only
 */
361 362 363 364
int ec_burst_enable(void)
{
	if (!first_ec)
		return -ENODEV;
365
	return acpi_ec_burst_enable(first_ec);
366 367 368 369 370 371 372 373
}

EXPORT_SYMBOL(ec_burst_enable);

int ec_burst_disable(void)
{
	if (!first_ec)
		return -ENODEV;
374
	return acpi_ec_burst_disable(first_ec);
375 376 377 378
}

EXPORT_SYMBOL(ec_burst_disable);

A
Alexey Starikovskiy 已提交
379
int ec_read(u8 addr, u8 * val)
L
Linus Torvalds 已提交
380 381
{
	int err;
382
	u8 temp_data;
L
Linus Torvalds 已提交
383 384 385 386

	if (!first_ec)
		return -ENODEV;

387
	err = acpi_ec_read(first_ec, addr, &temp_data);
L
Linus Torvalds 已提交
388 389 390 391

	if (!err) {
		*val = temp_data;
		return 0;
L
Len Brown 已提交
392
	} else
L
Linus Torvalds 已提交
393 394
		return err;
}
L
Len Brown 已提交
395

L
Linus Torvalds 已提交
396 397
EXPORT_SYMBOL(ec_read);

L
Len Brown 已提交
398
int ec_write(u8 addr, u8 val)
L
Linus Torvalds 已提交
399 400 401 402 403 404
{
	int err;

	if (!first_ec)
		return -ENODEV;

405
	err = acpi_ec_write(first_ec, addr, val);
L
Linus Torvalds 已提交
406 407 408

	return err;
}
L
Len Brown 已提交
409

L
Linus Torvalds 已提交
410 411
EXPORT_SYMBOL(ec_write);

412
int ec_transaction(u8 command,
413
		   const u8 * wdata, unsigned wdata_len,
414 415
		   u8 * rdata, unsigned rdata_len,
		   int force_poll)
L
Luming Yu 已提交
416
{
417 418
	if (!first_ec)
		return -ENODEV;
L
Luming Yu 已提交
419

420
	return acpi_ec_transaction(first_ec, command, wdata,
421 422
				   wdata_len, rdata, rdata_len,
				   force_poll);
L
Luming Yu 已提交
423
}
L
Linus Torvalds 已提交
424

425 426
EXPORT_SYMBOL(ec_transaction);

A
Alexey Starikovskiy 已提交
427
static int acpi_ec_query(struct acpi_ec *ec, u8 * data)
428 429
{
	int result;
A
Alexey Starikovskiy 已提交
430
	u8 d;
L
Linus Torvalds 已提交
431

A
Alexey Starikovskiy 已提交
432 433
	if (!ec || !data)
		return -EINVAL;
L
Linus Torvalds 已提交
434

A
Alexey Starikovskiy 已提交
435 436 437 438 439
	/*
	 * Query the EC to find out which _Qxx method we need to evaluate.
	 * Note that successful completion of the query causes the ACPI_EC_SCI
	 * bit to be cleared (and thus clearing the interrupt source).
	 */
440

441
	result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1, 0);
A
Alexey Starikovskiy 已提交
442 443
	if (result)
		return result;
L
Linus Torvalds 已提交
444

A
Alexey Starikovskiy 已提交
445 446
	if (!d)
		return -ENODATA;
L
Linus Torvalds 已提交
447

A
Alexey Starikovskiy 已提交
448 449
	*data = d;
	return 0;
L
Linus Torvalds 已提交
450 451 452 453 454
}

/* --------------------------------------------------------------------------
                                Event Management
   -------------------------------------------------------------------------- */
455 456 457 458 459 460 461 462 463 464 465 466 467 468
int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
			      acpi_handle handle, acpi_ec_query_func func,
			      void *data)
{
	struct acpi_ec_query_handler *handler =
	    kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
	if (!handler)
		return -ENOMEM;

	handler->query_bit = query_bit;
	handler->handle = handle;
	handler->func = func;
	handler->data = data;
	mutex_lock(&ec->lock);
469
	list_add(&handler->node, &ec->list);
470 471 472 473 474 475 476 477
	mutex_unlock(&ec->lock);
	return 0;
}

EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);

void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
{
A
Adrian Bunk 已提交
478
	struct acpi_ec_query_handler *handler, *tmp;
479
	mutex_lock(&ec->lock);
A
Adrian Bunk 已提交
480
	list_for_each_entry_safe(handler, tmp, &ec->list, node) {
481 482 483 484 485 486 487 488 489
		if (query_bit == handler->query_bit) {
			list_del(&handler->node);
			kfree(handler);
		}
	}
	mutex_unlock(&ec->lock);
}

EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
L
Linus Torvalds 已提交
490

L
Len Brown 已提交
491
static void acpi_ec_gpe_query(void *ec_cxt)
L
Luming Yu 已提交
492
{
493
	struct acpi_ec *ec = ec_cxt;
494
	u8 value = 0;
495
	struct acpi_ec_query_handler *handler, copy;
L
Luming Yu 已提交
496

497
	if (!ec || acpi_ec_query(ec, &value))
498
		return;
499 500 501 502 503 504 505 506 507 508 509 510 511 512 513
	mutex_lock(&ec->lock);
	list_for_each_entry(handler, &ec->list, node) {
		if (value == handler->query_bit) {
			/* have custom handler for this bit */
			memcpy(&copy, handler, sizeof(copy));
			mutex_unlock(&ec->lock);
			if (copy.func) {
				copy.func(copy.data);
			} else if (copy.handle) {
				acpi_evaluate_object(copy.handle, NULL, NULL, NULL);
			}
			return;
		}
	}
	mutex_unlock(&ec->lock);
L
Luming Yu 已提交
514
}
L
Linus Torvalds 已提交
515

L
Len Brown 已提交
516
static u32 acpi_ec_gpe_handler(void *data)
L
Linus Torvalds 已提交
517
{
L
Len Brown 已提交
518
	acpi_status status = AE_OK;
519
	struct acpi_ec *ec = data;
520

521
	pr_debug(PREFIX "~~~> interrupt\n");
522
	clear_bit(EC_FLAGS_WAIT_GPE, &ec->flags);
523
	if (test_bit(EC_FLAGS_GPE_MODE, &ec->flags))
524
		wake_up(&ec->wait);
D
Dmitry Torokhov 已提交
525

526 527 528 529
	if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI) {
		if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
			status = acpi_os_execute(OSL_EC_BURST_HANDLER,
				acpi_ec_gpe_query, ec);
530 531
	} else if (unlikely(!test_bit(EC_FLAGS_GPE_MODE, &ec->flags))) {
		/* this is non-query, must be confirmation */
532 533 534
		if (printk_ratelimit())
			pr_info(PREFIX "non-query interrupt received,"
				" switching to interrupt mode\n");
535
		set_bit(EC_FLAGS_GPE_MODE, &ec->flags);
536
	}
537

538
	return ACPI_SUCCESS(status) ?
L
Len Brown 已提交
539
	    ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
L
Linus Torvalds 已提交
540 541 542 543 544 545 546
}

/* --------------------------------------------------------------------------
                             Address Space Management
   -------------------------------------------------------------------------- */

static acpi_status
L
Len Brown 已提交
547 548
acpi_ec_space_setup(acpi_handle region_handle,
		    u32 function, void *handler_context, void **return_context)
L
Linus Torvalds 已提交
549 550 551 552 553
{
	/*
	 * The EC object is in the handler context and is needed
	 * when calling the acpi_ec_space_handler.
	 */
L
Len Brown 已提交
554 555
	*return_context = (function != ACPI_REGION_DEACTIVATE) ?
	    handler_context : NULL;
L
Linus Torvalds 已提交
556 557 558 559 560

	return AE_OK;
}

static acpi_status
561 562
acpi_ec_space_handler(u32 function, acpi_physical_address address,
		      u32 bits, acpi_integer *value,
L
Len Brown 已提交
563
		      void *handler_context, void *region_context)
L
Linus Torvalds 已提交
564
{
565
	struct acpi_ec *ec = handler_context;
566 567
	int result = 0, i = 0;
	u8 temp = 0;
L
Linus Torvalds 已提交
568 569

	if ((address > 0xFF) || !value || !handler_context)
570
		return AE_BAD_PARAMETER;
L
Linus Torvalds 已提交
571

572
	if (function != ACPI_READ && function != ACPI_WRITE)
573
		return AE_BAD_PARAMETER;
L
Linus Torvalds 已提交
574

575 576
	if (bits != 8 && acpi_strict)
		return AE_BAD_PARAMETER;
L
Linus Torvalds 已提交
577

578 579 580 581 582 583 584 585 586 587
	while (bits - i > 0) {
		if (function == ACPI_READ) {
			result = acpi_ec_read(ec, address, &temp);
			(*value) |= ((acpi_integer)temp) << i;
		} else {
			temp = 0xff & ((*value) >> i);
			result = acpi_ec_write(ec, address, temp);
		}
		i += 8;
		++address;
L
Linus Torvalds 已提交
588 589 590 591
	}

	switch (result) {
	case -EINVAL:
592
		return AE_BAD_PARAMETER;
L
Linus Torvalds 已提交
593 594
		break;
	case -ENODEV:
595
		return AE_NOT_FOUND;
L
Linus Torvalds 已提交
596 597
		break;
	case -ETIME:
598
		return AE_TIME;
L
Linus Torvalds 已提交
599 600
		break;
	default:
601
		return AE_OK;
L
Linus Torvalds 已提交
602 603 604 605 606 607 608
	}
}

/* --------------------------------------------------------------------------
                              FS Interface (/proc)
   -------------------------------------------------------------------------- */

L
Len Brown 已提交
609
static struct proc_dir_entry *acpi_ec_dir;
L
Linus Torvalds 已提交
610

L
Len Brown 已提交
611
static int acpi_ec_read_info(struct seq_file *seq, void *offset)
L
Linus Torvalds 已提交
612
{
613
	struct acpi_ec *ec = seq->private;
L
Linus Torvalds 已提交
614 615 616 617

	if (!ec)
		goto end;

618 619 620 621
	seq_printf(seq, "gpe:\t\t\t0x%02x\n", (u32) ec->gpe);
	seq_printf(seq, "ports:\t\t\t0x%02x, 0x%02x\n",
		   (unsigned)ec->command_addr, (unsigned)ec->data_addr);
	seq_printf(seq, "use global lock:\t%s\n",
622
		   ec->global_lock ? "yes" : "no");
L
Len Brown 已提交
623
      end:
624
	return 0;
L
Linus Torvalds 已提交
625 626 627 628 629 630 631
}

static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
{
	return single_open(file, acpi_ec_read_info, PDE(inode)->data);
}

632
static struct file_operations acpi_ec_info_ops = {
L
Len Brown 已提交
633 634 635 636
	.open = acpi_ec_info_open_fs,
	.read = seq_read,
	.llseek = seq_lseek,
	.release = single_release,
L
Linus Torvalds 已提交
637 638 639
	.owner = THIS_MODULE,
};

L
Len Brown 已提交
640
static int acpi_ec_add_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
641
{
L
Len Brown 已提交
642
	struct proc_dir_entry *entry = NULL;
L
Linus Torvalds 已提交
643 644 645

	if (!acpi_device_dir(device)) {
		acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
L
Len Brown 已提交
646
						     acpi_ec_dir);
L
Linus Torvalds 已提交
647
		if (!acpi_device_dir(device))
648
			return -ENODEV;
L
Linus Torvalds 已提交
649 650 651
	}

	entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
L
Len Brown 已提交
652
				  acpi_device_dir(device));
L
Linus Torvalds 已提交
653
	if (!entry)
654
		return -ENODEV;
L
Linus Torvalds 已提交
655 656 657 658 659 660
	else {
		entry->proc_fops = &acpi_ec_info_ops;
		entry->data = acpi_driver_data(device);
		entry->owner = THIS_MODULE;
	}

661
	return 0;
L
Linus Torvalds 已提交
662 663
}

L
Len Brown 已提交
664
static int acpi_ec_remove_fs(struct acpi_device *device)
L
Linus Torvalds 已提交
665 666 667 668 669 670 671 672
{

	if (acpi_device_dir(device)) {
		remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
		remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
		acpi_device_dir(device) = NULL;
	}

673
	return 0;
L
Linus Torvalds 已提交
674 675 676 677 678
}

/* --------------------------------------------------------------------------
                               Driver Interface
   -------------------------------------------------------------------------- */
679 680 681 682 683 684 685 686
static acpi_status
ec_parse_io_ports(struct acpi_resource *resource, void *context);

static struct acpi_ec *make_acpi_ec(void)
{
	struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
	if (!ec)
		return NULL;
687
	ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
688 689
	mutex_init(&ec->lock);
	init_waitqueue_head(&ec->wait);
690
	INIT_LIST_HEAD(&ec->list);
691 692
	return ec;
}
693

694 695 696 697 698 699 700 701 702 703 704 705 706
static acpi_status
acpi_ec_register_query_methods(acpi_handle handle, u32 level,
			       void *context, void **return_value)
{
	struct acpi_namespace_node *node = handle;
	struct acpi_ec *ec = context;
	int value = 0;
	if (sscanf(node->name.ascii, "_Q%x", &value) == 1) {
		acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
	}
	return AE_OK;
}

707 708
static acpi_status
ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
709
{
710 711 712 713 714 715 716
	acpi_status status;

	struct acpi_ec *ec = context;
	status = acpi_walk_resources(handle, METHOD_NAME__CRS,
				     ec_parse_io_ports, ec);
	if (ACPI_FAILURE(status))
		return status;
717 718 719

	/* Get GPE bit assignment (EC events). */
	/* TODO: Add support for _GPE returning a package */
720 721 722
	status = acpi_evaluate_integer(handle, "_GPE", NULL, &ec->gpe);
	if (ACPI_FAILURE(status))
		return status;
723 724 725
	/* Find and register all query methods */
	acpi_walk_namespace(ACPI_TYPE_METHOD, handle, 1,
			    acpi_ec_register_query_methods, ec, NULL);
726 727 728
	/* Use the global lock for all EC transactions? */
	acpi_evaluate_integer(handle, "_GLK", NULL, &ec->global_lock);
	ec->handle = handle;
729
	return AE_CTRL_TERMINATE;
730 731
}

732 733 734 735
static void ec_remove_handlers(struct acpi_ec *ec)
{
	if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
				ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
736
		pr_err(PREFIX "failed to remove space handler\n");
737 738
	if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
				&acpi_ec_gpe_handler)))
739
		pr_err(PREFIX "failed to remove gpe handler\n");
740 741 742
	ec->handlers_installed = 0;
}

743
static int acpi_ec_add(struct acpi_device *device)
L
Linus Torvalds 已提交
744
{
745
	struct acpi_ec *ec = NULL;
L
Luming Yu 已提交
746 747

	if (!device)
748
		return -EINVAL;
749 750 751
	strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_EC_CLASS);

752 753 754 755 756 757 758 759 760 761 762 763 764 765 766
	/* Check for boot EC */
	if (boot_ec) {
		if (boot_ec->handle == device->handle) {
			/* Pre-loaded EC from DSDT, just move pointer */
			ec = boot_ec;
			boot_ec = NULL;
			goto end;
		} else if (boot_ec->handle == ACPI_ROOT_OBJECT) {
			/* ECDT-based EC, time to shut it down */
			ec_remove_handlers(boot_ec);
			kfree(boot_ec);
			first_ec = boot_ec = NULL;
		}
	}

767
	ec = make_acpi_ec();
L
Luming Yu 已提交
768
	if (!ec)
769
		return -ENOMEM;
770

771 772
	if (ec_parse_device(device->handle, 0, ec, NULL) !=
	    AE_CTRL_TERMINATE) {
773 774
		kfree(ec);
		return -EINVAL;
L
Luming Yu 已提交
775
	}
776
	ec->handle = device->handle;
777 778 779
      end:
	if (!first_ec)
		first_ec = ec;
780 781
	acpi_driver_data(device) = ec;
	acpi_ec_add_fs(device);
782
	pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
783
			  ec->gpe, ec->command_addr, ec->data_addr);
784
	pr_info(PREFIX "driver started in %s mode\n",
785
		(test_bit(EC_FLAGS_GPE_MODE, &ec->flags))?"interrupt":"poll");
786
	return 0;
L
Linus Torvalds 已提交
787 788
}

L
Len Brown 已提交
789
static int acpi_ec_remove(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
790
{
791
	struct acpi_ec *ec;
792
	struct acpi_ec_query_handler *handler, *tmp;
L
Linus Torvalds 已提交
793 794

	if (!device)
795
		return -EINVAL;
L
Linus Torvalds 已提交
796 797

	ec = acpi_driver_data(device);
798
	mutex_lock(&ec->lock);
799
	list_for_each_entry_safe(handler, tmp, &ec->list, node) {
800 801 802 803
		list_del(&handler->node);
		kfree(handler);
	}
	mutex_unlock(&ec->lock);
L
Linus Torvalds 已提交
804
	acpi_ec_remove_fs(device);
805
	acpi_driver_data(device) = NULL;
806
	if (ec == first_ec)
807
		first_ec = NULL;
808
	kfree(ec);
809
	return 0;
L
Linus Torvalds 已提交
810 811 812
}

static acpi_status
813
ec_parse_io_ports(struct acpi_resource *resource, void *context)
L
Linus Torvalds 已提交
814
{
815
	struct acpi_ec *ec = context;
L
Linus Torvalds 已提交
816

817
	if (resource->type != ACPI_RESOURCE_TYPE_IO)
L
Linus Torvalds 已提交
818 819 820 821 822 823 824
		return AE_OK;

	/*
	 * The first address region returned is the data port, and
	 * the second address region returned is the status/command
	 * port.
	 */
825
	if (ec->data_addr == 0)
826
		ec->data_addr = resource->data.io.minimum;
827
	else if (ec->command_addr == 0)
828
		ec->command_addr = resource->data.io.minimum;
829
	else
L
Linus Torvalds 已提交
830 831 832 833 834
		return AE_CTRL_TERMINATE;

	return AE_OK;
}

835 836
static int ec_install_handlers(struct acpi_ec *ec)
{
837
	acpi_status status;
838 839
	if (ec->handlers_installed)
		return 0;
840 841 842
	status = acpi_install_gpe_handler(NULL, ec->gpe,
					  ACPI_GPE_EDGE_TRIGGERED,
					  &acpi_ec_gpe_handler, ec);
843 844
	if (ACPI_FAILURE(status))
		return -ENODEV;
845

846 847 848 849 850 851 852 853 854 855 856 857
	acpi_set_gpe_type(NULL, ec->gpe, ACPI_GPE_TYPE_RUNTIME);
	acpi_enable_gpe(NULL, ec->gpe, ACPI_NOT_ISR);

	status = acpi_install_address_space_handler(ec->handle,
						    ACPI_ADR_SPACE_EC,
						    &acpi_ec_space_handler,
						    &acpi_ec_space_setup, ec);
	if (ACPI_FAILURE(status)) {
		acpi_remove_gpe_handler(NULL, ec->gpe, &acpi_ec_gpe_handler);
		return -ENODEV;
	}

858
	ec->handlers_installed = 1;
859 860 861
	return 0;
}

L
Len Brown 已提交
862
static int acpi_ec_start(struct acpi_device *device)
L
Linus Torvalds 已提交
863
{
864
	struct acpi_ec *ec;
865
	int ret = 0;
L
Linus Torvalds 已提交
866 867

	if (!device)
868
		return -EINVAL;
L
Linus Torvalds 已提交
869 870 871 872

	ec = acpi_driver_data(device);

	if (!ec)
873
		return -EINVAL;
L
Linus Torvalds 已提交
874

875
	ret = ec_install_handlers(ec);
876 877

	/* EC is fully operational, allow queries */
878
	clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
879
	return ret;
L
Linus Torvalds 已提交
880 881
}

L
Len Brown 已提交
882
static int acpi_ec_stop(struct acpi_device *device, int type)
L
Linus Torvalds 已提交
883
{
884
	struct acpi_ec *ec;
L
Linus Torvalds 已提交
885
	if (!device)
886
		return -EINVAL;
L
Linus Torvalds 已提交
887
	ec = acpi_driver_data(device);
888 889
	if (!ec)
		return -EINVAL;
890
	ec_remove_handlers(ec);
891

892
	return 0;
L
Linus Torvalds 已提交
893 894
}

895 896 897 898
int __init acpi_ec_ecdt_probe(void)
{
	int ret;
	acpi_status status;
L
Len Brown 已提交
899
	struct acpi_table_ecdt *ecdt_ptr;
L
Luming Yu 已提交
900

901 902
	boot_ec = make_acpi_ec();
	if (!boot_ec)
903 904 905 906
		return -ENOMEM;
	/*
	 * Generate a boot ec context
	 */
907 908
	status = acpi_get_table(ACPI_SIG_ECDT, 1,
				(struct acpi_table_header **)&ecdt_ptr);
909
	if (ACPI_SUCCESS(status)) {
910
		pr_info(PREFIX "EC description table is found, configuring boot EC\n");
911 912 913 914 915
		boot_ec->command_addr = ecdt_ptr->control.address;
		boot_ec->data_addr = ecdt_ptr->data.address;
		boot_ec->gpe = ecdt_ptr->gpe;
		boot_ec->handle = ACPI_ROOT_OBJECT;
	} else {
916 917 918
		/* This workaround is needed only on some broken machines,
		 * which require early EC, but fail to provide ECDT */
		acpi_handle x;
919 920 921
		printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n");
		status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
						boot_ec, NULL);
922 923
		/* Check that acpi_get_devices actually find something */
		if (ACPI_FAILURE(status) || !boot_ec->handle)
924
			goto error;
925 926 927 928 929
		/* We really need to limit this workaround, the only ASUS,
		 * which needs it, has fake EC._INI method, so use it as flag.
		 */
		if (ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI", &x)))
			goto error;
930
	}
L
Linus Torvalds 已提交
931

932
	ret = ec_install_handlers(boot_ec);
933 934
	if (!ret) {
		first_ec = boot_ec;
935
		return 0;
936
	}
937
      error:
938 939
	kfree(boot_ec);
	boot_ec = NULL;
L
Linus Torvalds 已提交
940 941 942
	return -ENODEV;
}

L
Len Brown 已提交
943
static int __init acpi_ec_init(void)
L
Linus Torvalds 已提交
944
{
L
Len Brown 已提交
945
	int result = 0;
L
Linus Torvalds 已提交
946 947

	if (acpi_disabled)
948
		return 0;
L
Linus Torvalds 已提交
949 950 951

	acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
	if (!acpi_ec_dir)
952
		return -ENODEV;
L
Linus Torvalds 已提交
953 954 955 956 957

	/* Now register the driver for the EC */
	result = acpi_bus_register_driver(&acpi_ec_driver);
	if (result < 0) {
		remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
958
		return -ENODEV;
L
Linus Torvalds 已提交
959 960
	}

961
	return result;
L
Linus Torvalds 已提交
962 963 964 965 966 967
}

subsys_initcall(acpi_ec_init);

/* EC driver currently not unloadable */
#if 0
L
Len Brown 已提交
968
static void __exit acpi_ec_exit(void)
L
Linus Torvalds 已提交
969 970 971 972 973 974
{

	acpi_bus_unregister_driver(&acpi_ec_driver);

	remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);

975
	return;
L
Linus Torvalds 已提交
976
}
977
#endif	/* 0 */