ec.c 44.5 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 *  ec.c - ACPI Embedded Controller Driver (v3)
L
Linus Torvalds 已提交
3
 *
4 5
 *  Copyright (C) 2001-2015 Intel Corporation
 *    Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com>
6 7 8 9 10 11
 *            2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
 *            2006       Denis Sadykov <denis.m.sadykov@intel.com>
 *            2004       Luming Yu <luming.yu@intel.com>
 *            2001, 2002 Andy Grover <andrew.grover@intel.com>
 *            2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
 *  Copyright (C) 2008      Alexey Starikovskiy <astarikovskiy@suse.de>
L
Linus Torvalds 已提交
12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 *
 *  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.
 *
 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 */

28
/* Uncomment next line to get verbose printout */
29
/* #define DEBUG */
30
#define pr_fmt(fmt) "ACPI : EC: " fmt
31

L
Linus Torvalds 已提交
32 33 34 35 36
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/types.h>
#include <linux/delay.h>
D
Dmitry Torokhov 已提交
37
#include <linux/interrupt.h>
38
#include <linux/list.h>
39
#include <linux/spinlock.h>
40
#include <linux/slab.h>
41
#include <linux/acpi.h>
42
#include <linux/dmi.h>
43
#include <asm/io.h>
L
Linus Torvalds 已提交
44

45 46
#include "internal.h"

L
Linus Torvalds 已提交
47 48 49
#define ACPI_EC_CLASS			"embedded_controller"
#define ACPI_EC_DEVICE_NAME		"Embedded Controller"
#define ACPI_EC_FILE_INFO		"info"
50

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

58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89
/*
 * The SCI_EVT clearing timing is not defined by the ACPI specification.
 * This leads to lots of practical timing issues for the host EC driver.
 * The following variations are defined (from the target EC firmware's
 * perspective):
 * STATUS: After indicating SCI_EVT edge triggered IRQ to the host, the
 *         target can clear SCI_EVT at any time so long as the host can see
 *         the indication by reading the status register (EC_SC). So the
 *         host should re-check SCI_EVT after the first time the SCI_EVT
 *         indication is seen, which is the same time the query request
 *         (QR_EC) is written to the command register (EC_CMD). SCI_EVT set
 *         at any later time could indicate another event. Normally such
 *         kind of EC firmware has implemented an event queue and will
 *         return 0x00 to indicate "no outstanding event".
 * QUERY: After seeing the query request (QR_EC) written to the command
 *        register (EC_CMD) by the host and having prepared the responding
 *        event value in the data register (EC_DATA), the target can safely
 *        clear SCI_EVT because the target can confirm that the current
 *        event is being handled by the host. The host then should check
 *        SCI_EVT right after reading the event response from the data
 *        register (EC_DATA).
 * EVENT: After seeing the event response read from the data register
 *        (EC_DATA) by the host, the target can clear SCI_EVT. As the
 *        target requires time to notice the change in the data register
 *        (EC_DATA), the host may be required to wait additional guarding
 *        time before checking the SCI_EVT again. Such guarding may not be
 *        necessary if the host is notified via another IRQ.
 */
#define ACPI_EC_EVT_TIMING_STATUS	0x00
#define ACPI_EC_EVT_TIMING_QUERY	0x01
#define ACPI_EC_EVT_TIMING_EVENT	0x02

90
/* EC commands */
91
enum ec_command {
A
Alexey Starikovskiy 已提交
92 93 94 95 96
	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,
97
};
98

99
#define ACPI_EC_DELAY		500	/* Wait 500ms max. during EC ops */
100
#define ACPI_EC_UDELAY_GLK	1000	/* Wait 1ms max. to get global lock */
101
#define ACPI_EC_UDELAY_POLL	550	/* Wait 1ms for EC transaction polling */
102 103
#define ACPI_EC_CLEAR_MAX	100	/* Maximum number of events to query
					 * when trying to clear the EC */
104

105
enum {
106
	EC_FLAGS_QUERY_PENDING,		/* Query is pending */
107
	EC_FLAGS_QUERY_GUARDING,	/* Guard for SCI_EVT check */
108
	EC_FLAGS_HANDLERS_INSTALLED,	/* Handlers for GPE and
109
					 * OpReg are installed */
110 111
	EC_FLAGS_STARTED,		/* Driver is started */
	EC_FLAGS_STOPPED,		/* Driver is stopped */
112 113
	EC_FLAGS_COMMAND_STORM,		/* GPE storms occurred to the
					 * current command processing */
L
Linus Torvalds 已提交
114
};
115

116 117 118
#define ACPI_EC_COMMAND_POLL		0x01 /* Available for command byte */
#define ACPI_EC_COMMAND_COMPLETE	0x02 /* Completed last byte */

119 120 121 122 123
/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
module_param(ec_delay, uint, 0644);
MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");

124 125 126 127 128 129 130 131
static bool ec_busy_polling __read_mostly;
module_param(ec_busy_polling, bool, 0644);
MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");

static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
module_param(ec_polling_guard, uint, 0644);
MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");

132
static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
133

134 135 136 137 138 139 140 141 142
/*
 * If the number of false interrupts per one transaction exceeds
 * this threshold, will think there is a GPE storm happened and
 * will disable the GPE for normal transaction.
 */
static unsigned int ec_storm_threshold  __read_mostly = 8;
module_param(ec_storm_threshold, uint, 0644);
MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");

143 144 145 146 147 148
struct acpi_ec_query_handler {
	struct list_head node;
	acpi_ec_query_func func;
	acpi_handle handle;
	void *data;
	u8 query_bit;
149
	struct kref kref;
150 151
};

152
struct transaction {
153 154 155
	const u8 *wdata;
	u8 *rdata;
	unsigned short irq_count;
156
	u8 command;
157 158
	u8 wi;
	u8 ri;
159 160
	u8 wlen;
	u8 rlen;
161
	u8 flags;
162 163
};

164 165 166 167 168 169
struct acpi_ec_query {
	struct transaction transaction;
	struct work_struct work;
	struct acpi_ec_query_handler *handler;
};

L
Lv Zheng 已提交
170
static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
171
static void advance_transaction(struct acpi_ec *ec);
172 173
static void acpi_ec_event_handler(struct work_struct *work);
static void acpi_ec_event_processor(struct work_struct *work);
174

175 176
struct acpi_ec *boot_ec, *first_ec;
EXPORT_SYMBOL(first_ec);
177

A
Alexey Starikovskiy 已提交
178
static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */
179
static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */
180
static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
181
static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
182

183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
/* --------------------------------------------------------------------------
 *                           Logging/Debugging
 * -------------------------------------------------------------------------- */

/*
 * Splitters used by the developers to track the boundary of the EC
 * handling processes.
 */
#ifdef DEBUG
#define EC_DBG_SEP	" "
#define EC_DBG_DRV	"+++++"
#define EC_DBG_STM	"====="
#define EC_DBG_REQ	"*****"
#define EC_DBG_EVT	"#####"
#else
#define EC_DBG_SEP	""
#define EC_DBG_DRV
#define EC_DBG_STM
#define EC_DBG_REQ
#define EC_DBG_EVT
#endif

#define ec_log_raw(fmt, ...) \
	pr_info(fmt "\n", ##__VA_ARGS__)
#define ec_dbg_raw(fmt, ...) \
	pr_debug(fmt "\n", ##__VA_ARGS__)
#define ec_log(filter, fmt, ...) \
	ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
#define ec_dbg(filter, fmt, ...) \
	ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)

#define ec_log_drv(fmt, ...) \
	ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
#define ec_dbg_drv(fmt, ...) \
	ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
#define ec_dbg_stm(fmt, ...) \
	ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
#define ec_dbg_req(fmt, ...) \
	ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
#define ec_dbg_evt(fmt, ...) \
	ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
224 225
#define ec_dbg_ref(ec, fmt, ...) \
	ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
226

227 228 229 230 231 232 233 234 235 236
/* --------------------------------------------------------------------------
 *                           Device Flags
 * -------------------------------------------------------------------------- */

static bool acpi_ec_started(struct acpi_ec *ec)
{
	return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
	       !test_bit(EC_FLAGS_STOPPED, &ec->flags);
}

237 238 239 240 241
static bool acpi_ec_flushed(struct acpi_ec *ec)
{
	return ec->reference_count == 1;
}

L
Linus Torvalds 已提交
242
/* --------------------------------------------------------------------------
243
 *                           EC Registers
L
Lv Zheng 已提交
244
 * -------------------------------------------------------------------------- */
L
Linus Torvalds 已提交
245

246
static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
L
Linus Torvalds 已提交
247
{
248
	u8 x = inb(ec->command_addr);
L
Lv Zheng 已提交
249

250 251 252 253 254 255 256 257
	ec_dbg_raw("EC_SC(R) = 0x%2.2x "
		   "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
		   x,
		   !!(x & ACPI_EC_FLAG_SCI),
		   !!(x & ACPI_EC_FLAG_BURST),
		   !!(x & ACPI_EC_FLAG_CMD),
		   !!(x & ACPI_EC_FLAG_IBF),
		   !!(x & ACPI_EC_FLAG_OBF));
258
	return x;
D
Dmitry Torokhov 已提交
259 260
}

261
static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
262
{
263
	u8 x = inb(ec->data_addr);
L
Lv Zheng 已提交
264

265
	ec->timestamp = jiffies;
266
	ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
267
	return x;
268 269
}

270
static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
L
Luming Yu 已提交
271
{
272
	ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
273
	outb(command, ec->command_addr);
274
	ec->timestamp = jiffies;
L
Luming Yu 已提交
275 276
}

277
static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
L
Luming Yu 已提交
278
{
279
	ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
280
	outb(data, ec->data_addr);
281
	ec->timestamp = jiffies;
282
}
L
Luming Yu 已提交
283

284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
#ifdef DEBUG
static const char *acpi_ec_cmd_string(u8 cmd)
{
	switch (cmd) {
	case 0x80:
		return "RD_EC";
	case 0x81:
		return "WR_EC";
	case 0x82:
		return "BE_EC";
	case 0x83:
		return "BD_EC";
	case 0x84:
		return "QR_EC";
	}
	return "UNKNOWN";
}
#else
#define acpi_ec_cmd_string(cmd)		"UNDEF"
#endif

305 306 307 308 309 310 311 312 313
/* --------------------------------------------------------------------------
 *                           GPE Registers
 * -------------------------------------------------------------------------- */

static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
{
	acpi_event_status gpe_status = 0;

	(void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
314
	return (gpe_status & ACPI_EVENT_FLAG_STATUS_SET) ? true : false;
315 316 317 318 319 320
}

static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
{
	if (open)
		acpi_enable_gpe(NULL, ec->gpe);
321 322
	else {
		BUG_ON(ec->reference_count < 1);
323
		acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
324
	}
325 326 327 328 329 330
	if (acpi_ec_is_gpe_raised(ec)) {
		/*
		 * On some platforms, EN=1 writes cannot trigger GPE. So
		 * software need to manually trigger a pseudo GPE event on
		 * EN=1 writes.
		 */
331
		ec_dbg_raw("Polling quirk");
332 333 334 335 336 337 338 339
		advance_transaction(ec);
	}
}

static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
{
	if (close)
		acpi_disable_gpe(NULL, ec->gpe);
340 341
	else {
		BUG_ON(ec->reference_count < 1);
342
		acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
343
	}
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
}

static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
{
	/*
	 * GPE STS is a W1C register, which means:
	 * 1. Software can clear it without worrying about clearing other
	 *    GPEs' STS bits when the hardware sets them in parallel.
	 * 2. As long as software can ensure only clearing it when it is
	 *    set, hardware won't set it in parallel.
	 * So software can clear GPE in any contexts.
	 * Warning: do not move the check into advance_transaction() as the
	 * EC commands will be sent without GPE raised.
	 */
	if (!acpi_ec_is_gpe_raised(ec))
		return;
	acpi_clear_gpe(NULL, ec->gpe);
}

/* --------------------------------------------------------------------------
 *                           Transaction Management
 * -------------------------------------------------------------------------- */

367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
static void acpi_ec_submit_request(struct acpi_ec *ec)
{
	ec->reference_count++;
	if (ec->reference_count == 1)
		acpi_ec_enable_gpe(ec, true);
}

static void acpi_ec_complete_request(struct acpi_ec *ec)
{
	bool flushed = false;

	ec->reference_count--;
	if (ec->reference_count == 0)
		acpi_ec_disable_gpe(ec, true);
	flushed = acpi_ec_flushed(ec);
	if (flushed)
		wake_up(&ec->wait);
}

386 387 388 389
static void acpi_ec_set_storm(struct acpi_ec *ec, u8 flag)
{
	if (!test_bit(flag, &ec->flags)) {
		acpi_ec_disable_gpe(ec, false);
390
		ec_dbg_drv("Polling enabled");
391 392 393 394 395 396 397 398 399
		set_bit(flag, &ec->flags);
	}
}

static void acpi_ec_clear_storm(struct acpi_ec *ec, u8 flag)
{
	if (test_bit(flag, &ec->flags)) {
		clear_bit(flag, &ec->flags);
		acpi_ec_enable_gpe(ec, false);
400
		ec_dbg_drv("Polling disabled");
401 402 403
	}
}

404 405 406 407 408 409 410 411 412 413 414
/*
 * acpi_ec_submit_flushable_request() - Increase the reference count unless
 *                                      the flush operation is not in
 *                                      progress
 * @ec: the EC device
 *
 * This function must be used before taking a new action that should hold
 * the reference count.  If this function returns false, then the action
 * must be discarded or it will prevent the flush operation from being
 * completed.
 */
415
static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
416
{
417 418
	if (!acpi_ec_started(ec))
		return false;
419 420 421 422
	acpi_ec_submit_request(ec);
	return true;
}

423
static void acpi_ec_submit_query(struct acpi_ec *ec)
424
{
425
	if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
426 427 428
		ec_dbg_evt("Command(%s) submitted/blocked",
			   acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
		ec->nr_pending_queries++;
429 430 431 432
		schedule_work(&ec->work);
	}
}

433
static void acpi_ec_complete_query(struct acpi_ec *ec)
434
{
435
	if (test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
436
		clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
437 438
		ec_dbg_evt("Command(%s) unblocked",
			   acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
439 440 441
	}
}

442 443 444 445 446 447 448 449 450 451 452 453 454 455 456
static bool acpi_ec_guard_event(struct acpi_ec *ec)
{
	if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
	    ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY ||
	    !test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags) ||
	    (ec->curr && ec->curr->command == ACPI_EC_COMMAND_QUERY))
		return false;

	/*
	 * Postpone the query submission to allow the firmware to proceed,
	 * we shouldn't check SCI_EVT before the firmware reflagging it.
	 */
	return true;
}

457 458 459 460 461 462 463 464 465 466 467 468
static int ec_transaction_polled(struct acpi_ec *ec)
{
	unsigned long flags;
	int ret = 0;

	spin_lock_irqsave(&ec->lock, flags);
	if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
		ret = 1;
	spin_unlock_irqrestore(&ec->lock, flags);
	return ret;
}

469
static int ec_transaction_completed(struct acpi_ec *ec)
470
{
471 472
	unsigned long flags;
	int ret = 0;
L
Lv Zheng 已提交
473

474
	spin_lock_irqsave(&ec->lock, flags);
475
	if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
476
		ret = 1;
477
	spin_unlock_irqrestore(&ec->lock, flags);
478
	return ret;
L
Luming Yu 已提交
479
}
D
Dmitry Torokhov 已提交
480

481 482 483 484
static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
{
	ec->curr->flags |= flag;
	if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
485 486 487 488 489
		if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS &&
		    flag == ACPI_EC_COMMAND_POLL)
			acpi_ec_complete_query(ec);
		if (ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY &&
		    flag == ACPI_EC_COMMAND_COMPLETE)
490
			acpi_ec_complete_query(ec);
491 492 493
		if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
		    flag == ACPI_EC_COMMAND_COMPLETE)
			set_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
494 495 496
	}
}

497
static void advance_transaction(struct acpi_ec *ec)
498
{
499
	struct transaction *t;
500
	u8 status;
501
	bool wakeup = false;
502

503 504
	ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK",
		   smp_processor_id());
505 506 507 508 509 510
	/*
	 * By always clearing STS before handling all indications, we can
	 * ensure a hardware STS 0->1 change after this clearing can always
	 * trigger a GPE interrupt.
	 */
	acpi_ec_clear_gpe(ec);
511
	status = acpi_ec_read_status(ec);
512
	t = ec->curr;
513 514 515 516 517 518
	/*
	 * Another IRQ or a guarded polling mode advancement is detected,
	 * the next QR_EC submission is then allowed.
	 */
	if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
		if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
519 520
		    (!ec->nr_pending_queries ||
		     test_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags))) {
521 522 523 524
			clear_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
			acpi_ec_complete_query(ec);
		}
	}
525
	if (!t)
526 527 528 529 530 531 532 533 534 535
		goto err;
	if (t->flags & ACPI_EC_COMMAND_POLL) {
		if (t->wlen > t->wi) {
			if ((status & ACPI_EC_FLAG_IBF) == 0)
				acpi_ec_write_data(ec, t->wdata[t->wi++]);
			else
				goto err;
		} else if (t->rlen > t->ri) {
			if ((status & ACPI_EC_FLAG_OBF) == 1) {
				t->rdata[t->ri++] = acpi_ec_read_data(ec);
536
				if (t->rlen == t->ri) {
537
					ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
538
					if (t->command == ACPI_EC_COMMAND_QUERY)
539 540
						ec_dbg_evt("Command(%s) completed by hardware",
							   acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
541 542
					wakeup = true;
				}
543 544 545
			} else
				goto err;
		} else if (t->wlen == t->wi &&
546
			   (status & ACPI_EC_FLAG_IBF) == 0) {
547
			ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
548 549
			wakeup = true;
		}
550
		goto out;
551
	} else {
552 553
		if (EC_FLAGS_QUERY_HANDSHAKE &&
		    !(status & ACPI_EC_FLAG_SCI) &&
554
		    (t->command == ACPI_EC_COMMAND_QUERY)) {
555
			ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
556
			t->rdata[t->ri++] = 0x00;
557
			ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
558 559
			ec_dbg_evt("Command(%s) completed by software",
				   acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
560 561
			wakeup = true;
		} else if ((status & ACPI_EC_FLAG_IBF) == 0) {
562
			acpi_ec_write_cmd(ec, t->command);
563
			ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
564
		} else
565
			goto err;
566
		goto out;
567
	}
568
err:
569 570 571 572
	/*
	 * If SCI bit is set, then don't think it's a false IRQ
	 * otherwise will take a not handled IRQ as a false one.
	 */
573
	if (!(status & ACPI_EC_FLAG_SCI)) {
574 575 576 577 578 579 580
		if (in_interrupt() && t) {
			if (t->irq_count < ec_storm_threshold)
				++t->irq_count;
			/* Allow triggering on 0 threshold */
			if (t->irq_count == ec_storm_threshold)
				acpi_ec_set_storm(ec, EC_FLAGS_COMMAND_STORM);
		}
581
	}
582
out:
583
	if (status & ACPI_EC_FLAG_SCI)
584
		acpi_ec_submit_query(ec);
585 586
	if (wakeup && in_interrupt())
		wake_up(&ec->wait);
587
}
588

589 590 591 592
static void start_transaction(struct acpi_ec *ec)
{
	ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
	ec->curr->flags = 0;
593 594 595 596
}

static int ec_guard(struct acpi_ec *ec)
{
597
	unsigned long guard = usecs_to_jiffies(ec_polling_guard);
598 599 600
	unsigned long timeout = ec->timestamp + guard;

	do {
601
		if (ec_busy_polling) {
602 603 604 605 606 607 608 609
			/* Perform busy polling */
			if (ec_transaction_completed(ec))
				return 0;
			udelay(jiffies_to_usecs(guard));
		} else {
			/*
			 * Perform wait polling
			 *
610 611 612 613
			 * For SCI_EVT clearing timing of "event",
			 * performing guarding before re-checking the
			 * SCI_EVT. Otherwise, such guarding is not needed
			 * due to the old practices.
614
			 */
615 616
			if (!ec_transaction_polled(ec) &&
			    !acpi_ec_guard_event(ec))
617 618 619 620 621 622 623 624 625
				break;
			if (wait_event_timeout(ec->wait,
					       ec_transaction_completed(ec),
					       guard))
				return 0;
		}
		/* Guard the register accesses for the polling modes */
	} while (time_before(jiffies, timeout));
	return -ETIME;
A
Alexey Starikovskiy 已提交
626
}
627

628 629
static int ec_poll(struct acpi_ec *ec)
{
630
	unsigned long flags;
631
	int repeat = 5; /* number of command restarts */
L
Lv Zheng 已提交
632

633 634
	while (repeat--) {
		unsigned long delay = jiffies +
635
			msecs_to_jiffies(ec_delay);
636
		do {
637 638
			if (!ec_guard(ec))
				return 0;
639
			spin_lock_irqsave(&ec->lock, flags);
640
			advance_transaction(ec);
641
			spin_unlock_irqrestore(&ec->lock, flags);
642
		} while (time_before(jiffies, delay));
643
		pr_debug("controller reset, restart transaction\n");
644
		spin_lock_irqsave(&ec->lock, flags);
645
		start_transaction(ec);
646
		spin_unlock_irqrestore(&ec->lock, flags);
647
	}
648
	return -ETIME;
L
Linus Torvalds 已提交
649 650
}

651
static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
652
					struct transaction *t)
L
Luming Yu 已提交
653
{
654 655
	unsigned long tmp;
	int ret = 0;
L
Lv Zheng 已提交
656

657
	/* start transaction */
658
	spin_lock_irqsave(&ec->lock, tmp);
659
	/* Enable GPE for command processing (IBF=0/OBF=1) */
660
	if (!acpi_ec_submit_flushable_request(ec)) {
661 662 663
		ret = -EINVAL;
		goto unlock;
	}
664
	ec_dbg_ref(ec, "Increase command");
665
	/* following two actions should be kept atomic */
666
	ec->curr = t;
667
	ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
668
	start_transaction(ec);
669
	spin_unlock_irqrestore(&ec->lock, tmp);
670

671
	ret = ec_poll(ec);
672

673
	spin_lock_irqsave(&ec->lock, tmp);
674 675
	if (t->irq_count == ec_storm_threshold)
		acpi_ec_clear_storm(ec, EC_FLAGS_COMMAND_STORM);
676
	ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
677
	ec->curr = NULL;
678 679
	/* Disable GPE for command processing (IBF=0/OBF=1) */
	acpi_ec_complete_request(ec);
680
	ec_dbg_ref(ec, "Decrease command");
681
unlock:
682
	spin_unlock_irqrestore(&ec->lock, tmp);
683 684 685
	return ret;
}

686
static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
L
Linus Torvalds 已提交
687
{
688
	int status;
L
Len Brown 已提交
689
	u32 glk;
L
Lv Zheng 已提交
690

691
	if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
692
		return -EINVAL;
693 694
	if (t->rdata)
		memset(t->rdata, 0, t->rlen);
695

696
	mutex_lock(&ec->mutex);
697
	if (ec->global_lock) {
L
Linus Torvalds 已提交
698
		status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
699
		if (ACPI_FAILURE(status)) {
700 701
			status = -ENODEV;
			goto unlock;
702
		}
L
Linus Torvalds 已提交
703
	}
704

705
	status = acpi_ec_transaction_unlocked(ec, t);
706

707
	if (ec->global_lock)
L
Linus Torvalds 已提交
708
		acpi_release_global_lock(glk);
709
unlock:
710
	mutex_unlock(&ec->mutex);
711
	return status;
L
Linus Torvalds 已提交
712 713
}

714
static int acpi_ec_burst_enable(struct acpi_ec *ec)
715 716
{
	u8 d;
717 718 719 720
	struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
				.wdata = NULL, .rdata = &d,
				.wlen = 0, .rlen = 1};

721
	return acpi_ec_transaction(ec, &t);
722 723
}

724
static int acpi_ec_burst_disable(struct acpi_ec *ec)
725
{
726 727 728 729
	struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
				.wdata = NULL, .rdata = NULL,
				.wlen = 0, .rlen = 0};

730
	return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
731
				acpi_ec_transaction(ec, &t) : 0;
732 733
}

L
Lv Zheng 已提交
734
static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
735 736 737
{
	int result;
	u8 d;
738 739 740
	struct transaction t = {.command = ACPI_EC_COMMAND_READ,
				.wdata = &address, .rdata = &d,
				.wlen = 1, .rlen = 1};
741

742
	result = acpi_ec_transaction(ec, &t);
743 744 745
	*data = d;
	return result;
}
746

747 748
static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
{
A
Alexey Starikovskiy 已提交
749
	u8 wdata[2] = { address, data };
750 751 752 753
	struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
				.wdata = wdata, .rdata = NULL,
				.wlen = 2, .rlen = 0};

754
	return acpi_ec_transaction(ec, &t);
755 756
}

757
int ec_read(u8 addr, u8 *val)
L
Linus Torvalds 已提交
758 759
{
	int err;
760
	u8 temp_data;
L
Linus Torvalds 已提交
761 762 763 764

	if (!first_ec)
		return -ENODEV;

765
	err = acpi_ec_read(first_ec, addr, &temp_data);
L
Linus Torvalds 已提交
766 767 768 769

	if (!err) {
		*val = temp_data;
		return 0;
L
Lv Zheng 已提交
770 771
	}
	return err;
L
Linus Torvalds 已提交
772 773 774
}
EXPORT_SYMBOL(ec_read);

L
Len Brown 已提交
775
int ec_write(u8 addr, u8 val)
L
Linus Torvalds 已提交
776 777 778 779 780 781
{
	int err;

	if (!first_ec)
		return -ENODEV;

782
	err = acpi_ec_write(first_ec, addr, val);
L
Linus Torvalds 已提交
783 784 785 786 787

	return err;
}
EXPORT_SYMBOL(ec_write);

788
int ec_transaction(u8 command,
L
Lv Zheng 已提交
789 790
		   const u8 *wdata, unsigned wdata_len,
		   u8 *rdata, unsigned rdata_len)
L
Luming Yu 已提交
791
{
792 793 794
	struct transaction t = {.command = command,
				.wdata = wdata, .rdata = rdata,
				.wlen = wdata_len, .rlen = rdata_len};
L
Lv Zheng 已提交
795

796 797
	if (!first_ec)
		return -ENODEV;
L
Luming Yu 已提交
798

799
	return acpi_ec_transaction(first_ec, &t);
L
Luming Yu 已提交
800
}
801 802
EXPORT_SYMBOL(ec_transaction);

S
Seth Forshee 已提交
803 804 805 806 807 808 809 810 811
/* Get the handle to the EC device */
acpi_handle ec_get_handle(void)
{
	if (!first_ec)
		return NULL;
	return first_ec->handle;
}
EXPORT_SYMBOL(ec_get_handle);

812
/*
813
 * Process _Q events that might have accumulated in the EC.
814 815 816 817 818 819 820 821
 * Run with locked ec mutex.
 */
static void acpi_ec_clear(struct acpi_ec *ec)
{
	int i, status;
	u8 value = 0;

	for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
L
Lv Zheng 已提交
822
		status = acpi_ec_query(ec, &value);
823 824 825 826 827 828 829 830 831 832
		if (status || !value)
			break;
	}

	if (unlikely(i == ACPI_EC_CLEAR_MAX))
		pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
	else
		pr_info("%d stale EC events cleared\n", i);
}

833 834 835 836 837 838
static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
{
	unsigned long flags;

	spin_lock_irqsave(&ec->lock, flags);
	if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
839
		ec_dbg_drv("Starting EC");
840
		/* Enable GPE for event processing (SCI_EVT=1) */
841
		if (!resuming) {
842
			acpi_ec_submit_request(ec);
843 844
			ec_dbg_ref(ec, "Increase driver");
		}
845
		ec_log_drv("EC started");
846 847 848 849
	}
	spin_unlock_irqrestore(&ec->lock, flags);
}

850 851 852 853 854 855 856 857 858 859 860
static bool acpi_ec_stopped(struct acpi_ec *ec)
{
	unsigned long flags;
	bool flushed;

	spin_lock_irqsave(&ec->lock, flags);
	flushed = acpi_ec_flushed(ec);
	spin_unlock_irqrestore(&ec->lock, flags);
	return flushed;
}

861 862 863 864 865 866
static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
{
	unsigned long flags;

	spin_lock_irqsave(&ec->lock, flags);
	if (acpi_ec_started(ec)) {
867
		ec_dbg_drv("Stopping EC");
868
		set_bit(EC_FLAGS_STOPPED, &ec->flags);
869 870 871 872
		spin_unlock_irqrestore(&ec->lock, flags);
		wait_event(ec->wait, acpi_ec_stopped(ec));
		spin_lock_irqsave(&ec->lock, flags);
		/* Disable GPE for event processing (SCI_EVT=1) */
873
		if (!suspending) {
874
			acpi_ec_complete_request(ec);
875 876
			ec_dbg_ref(ec, "Decrease driver");
		}
877 878
		clear_bit(EC_FLAGS_STARTED, &ec->flags);
		clear_bit(EC_FLAGS_STOPPED, &ec->flags);
879
		ec_log_drv("EC stopped");
880 881 882 883
	}
	spin_unlock_irqrestore(&ec->lock, flags);
}

884
void acpi_ec_block_transactions(void)
885 886 887 888 889 890
{
	struct acpi_ec *ec = first_ec;

	if (!ec)
		return;

891
	mutex_lock(&ec->mutex);
892
	/* Prevent transactions from being carried out */
893
	acpi_ec_stop(ec, true);
894
	mutex_unlock(&ec->mutex);
895 896
}

897
void acpi_ec_unblock_transactions(void)
898 899 900 901 902 903 904
{
	struct acpi_ec *ec = first_ec;

	if (!ec)
		return;

	/* Allow transactions to be carried out again */
905
	acpi_ec_start(ec, true);
906 907 908

	if (EC_FLAGS_CLEAR_ON_RESUME)
		acpi_ec_clear(ec);
909 910
}

911
void acpi_ec_unblock_transactions_early(void)
912 913 914 915 916 917
{
	/*
	 * Allow transactions to happen again (this function is called from
	 * atomic context during wakeup, so we don't need to acquire the mutex).
	 */
	if (first_ec)
918
		acpi_ec_start(first_ec, true);
919 920
}

L
Linus Torvalds 已提交
921 922 923
/* --------------------------------------------------------------------------
                                Event Management
   -------------------------------------------------------------------------- */
924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944
static struct acpi_ec_query_handler *
acpi_ec_get_query_handler(struct acpi_ec_query_handler *handler)
{
	if (handler)
		kref_get(&handler->kref);
	return handler;
}

static void acpi_ec_query_handler_release(struct kref *kref)
{
	struct acpi_ec_query_handler *handler =
		container_of(kref, struct acpi_ec_query_handler, kref);

	kfree(handler);
}

static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
{
	kref_put(&handler->kref, acpi_ec_query_handler_release);
}

945 946 947 948 949 950
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);
L
Lv Zheng 已提交
951

952 953 954 955 956 957 958
	if (!handler)
		return -ENOMEM;

	handler->query_bit = query_bit;
	handler->handle = handle;
	handler->func = func;
	handler->data = data;
959
	mutex_lock(&ec->mutex);
960
	kref_init(&handler->kref);
961
	list_add(&handler->node, &ec->list);
962
	mutex_unlock(&ec->mutex);
963 964 965 966 967 968
	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 已提交
969
	struct acpi_ec_query_handler *handler, *tmp;
970
	LIST_HEAD(free_list);
L
Lv Zheng 已提交
971

972
	mutex_lock(&ec->mutex);
A
Adrian Bunk 已提交
973
	list_for_each_entry_safe(handler, tmp, &ec->list, node) {
974
		if (query_bit == handler->query_bit) {
975 976
			list_del_init(&handler->node);
			list_add(&handler->node, &free_list);
977 978
		}
	}
979
	mutex_unlock(&ec->mutex);
980
	list_for_each_entry_safe(handler, tmp, &free_list, node)
981
		acpi_ec_put_query_handler(handler);
982 983
}
EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
L
Linus Torvalds 已提交
984

985
static struct acpi_ec_query *acpi_ec_create_query(u8 *pval)
L
Luming Yu 已提交
986
{
987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013
	struct acpi_ec_query *q;
	struct transaction *t;

	q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
	if (!q)
		return NULL;
	INIT_WORK(&q->work, acpi_ec_event_processor);
	t = &q->transaction;
	t->command = ACPI_EC_COMMAND_QUERY;
	t->rdata = pval;
	t->rlen = 1;
	return q;
}

static void acpi_ec_delete_query(struct acpi_ec_query *q)
{
	if (q) {
		if (q->handler)
			acpi_ec_put_query_handler(q->handler);
		kfree(q);
	}
}

static void acpi_ec_event_processor(struct work_struct *work)
{
	struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
	struct acpi_ec_query_handler *handler = q->handler;
L
Lv Zheng 已提交
1014

1015
	ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
1016 1017 1018 1019
	if (handler->func)
		handler->func(handler->data);
	else if (handler->handle)
		acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
1020
	ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
1021
	acpi_ec_delete_query(q);
1022 1023
}

L
Lv Zheng 已提交
1024
static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
1025 1026
{
	u8 value = 0;
1027
	int result;
1028
	struct acpi_ec_query_handler *handler;
1029 1030 1031 1032 1033
	struct acpi_ec_query *q;

	q = acpi_ec_create_query(&value);
	if (!q)
		return -ENOMEM;
1034

L
Lv Zheng 已提交
1035 1036 1037 1038 1039
	/*
	 * 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).
	 */
1040
	result = acpi_ec_transaction(ec, &q->transaction);
L
Lv Zheng 已提交
1041
	if (!value)
1042 1043 1044
		result = -ENODATA;
	if (result)
		goto err_exit;
1045

L
Lv Zheng 已提交
1046
	mutex_lock(&ec->mutex);
1047
	result = -ENODATA;
1048 1049
	list_for_each_entry(handler, &ec->list, node) {
		if (value == handler->query_bit) {
1050
			result = 0;
1051
			q->handler = acpi_ec_get_query_handler(handler);
1052
			ec_dbg_evt("Query(0x%02x) scheduled",
1053 1054 1055 1056 1057 1058 1059
				   q->handler->query_bit);
			/*
			 * It is reported that _Qxx are evaluated in a
			 * parallel way on Windows:
			 * https://bugzilla.kernel.org/show_bug.cgi?id=94411
			 */
			if (!schedule_work(&q->work))
1060 1061
				result = -EBUSY;
			break;
1062 1063
		}
	}
L
Lv Zheng 已提交
1064
	mutex_unlock(&ec->mutex);
1065 1066 1067 1068 1069 1070

err_exit:
	if (result && q)
		acpi_ec_delete_query(q);
	if (data)
		*data = value;
1071
	return result;
1072 1073
}

1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091
static void acpi_ec_check_event(struct acpi_ec *ec)
{
	unsigned long flags;

	if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
		if (ec_guard(ec)) {
			spin_lock_irqsave(&ec->lock, flags);
			/*
			 * Take care of the SCI_EVT unless no one else is
			 * taking care of it.
			 */
			if (!ec->curr)
				advance_transaction(ec);
			spin_unlock_irqrestore(&ec->lock, flags);
		}
	}
}

1092
static void acpi_ec_event_handler(struct work_struct *work)
1093
{
1094
	unsigned long flags;
1095
	struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
L
Lv Zheng 已提交
1096

1097 1098 1099 1100 1101 1102 1103 1104
	ec_dbg_evt("Event started");

	spin_lock_irqsave(&ec->lock, flags);
	while (ec->nr_pending_queries) {
		spin_unlock_irqrestore(&ec->lock, flags);
		(void)acpi_ec_query(ec, NULL);
		spin_lock_irqsave(&ec->lock, flags);
		ec->nr_pending_queries--;
1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115
		/*
		 * Before exit, make sure that this work item can be
		 * scheduled again. There might be QR_EC failures, leaving
		 * EC_FLAGS_QUERY_PENDING uncleared and preventing this work
		 * item from being scheduled again.
		 */
		if (!ec->nr_pending_queries) {
			if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
			    ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY)
				acpi_ec_complete_query(ec);
		}
1116 1117 1118 1119
	}
	spin_unlock_irqrestore(&ec->lock, flags);

	ec_dbg_evt("Event stopped");
1120 1121

	acpi_ec_check_event(ec);
L
Luming Yu 已提交
1122
}
L
Linus Torvalds 已提交
1123

1124 1125
static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
	u32 gpe_number, void *data)
L
Linus Torvalds 已提交
1126
{
1127
	unsigned long flags;
1128
	struct acpi_ec *ec = data;
1129

1130
	spin_lock_irqsave(&ec->lock, flags);
1131
	advance_transaction(ec);
1132
	spin_unlock_irqrestore(&ec->lock, flags);
1133
	return ACPI_INTERRUPT_HANDLED;
A
Alexey Starikovskiy 已提交
1134 1135
}

L
Linus Torvalds 已提交
1136
/* --------------------------------------------------------------------------
L
Lv Zheng 已提交
1137 1138
 *                           Address Space Management
 * -------------------------------------------------------------------------- */
L
Linus Torvalds 已提交
1139 1140

static acpi_status
1141
acpi_ec_space_handler(u32 function, acpi_physical_address address,
1142
		      u32 bits, u64 *value64,
L
Len Brown 已提交
1143
		      void *handler_context, void *region_context)
L
Linus Torvalds 已提交
1144
{
1145
	struct acpi_ec *ec = handler_context;
1146 1147
	int result = 0, i, bytes = bits / 8;
	u8 *value = (u8 *)value64;
L
Linus Torvalds 已提交
1148 1149

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

1152
	if (function != ACPI_READ && function != ACPI_WRITE)
1153
		return AE_BAD_PARAMETER;
L
Linus Torvalds 已提交
1154

1155
	if (ec_busy_polling || bits > 8)
1156
		acpi_ec_burst_enable(ec);
1157

1158 1159 1160 1161
	for (i = 0; i < bytes; ++i, ++address, ++value)
		result = (function == ACPI_READ) ?
			acpi_ec_read(ec, address, value) :
			acpi_ec_write(ec, address, *value);
L
Linus Torvalds 已提交
1162

1163
	if (ec_busy_polling || bits > 8)
1164
		acpi_ec_burst_disable(ec);
1165

L
Linus Torvalds 已提交
1166 1167
	switch (result) {
	case -EINVAL:
1168
		return AE_BAD_PARAMETER;
L
Linus Torvalds 已提交
1169
	case -ENODEV:
1170
		return AE_NOT_FOUND;
L
Linus Torvalds 已提交
1171
	case -ETIME:
1172
		return AE_TIME;
L
Linus Torvalds 已提交
1173
	default:
1174
		return AE_OK;
L
Linus Torvalds 已提交
1175 1176 1177 1178
	}
}

/* --------------------------------------------------------------------------
L
Lv Zheng 已提交
1179 1180 1181
 *                             Driver Interface
 * -------------------------------------------------------------------------- */

1182 1183 1184 1185 1186 1187
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);
L
Lv Zheng 已提交
1188

1189 1190
	if (!ec)
		return NULL;
1191
	ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
1192
	mutex_init(&ec->mutex);
1193
	init_waitqueue_head(&ec->wait);
1194
	INIT_LIST_HEAD(&ec->list);
1195
	spin_lock_init(&ec->lock);
1196
	INIT_WORK(&ec->work, acpi_ec_event_handler);
1197
	ec->timestamp = jiffies;
1198 1199
	return ec;
}
1200

1201 1202 1203 1204
static acpi_status
acpi_ec_register_query_methods(acpi_handle handle, u32 level,
			       void *context, void **return_value)
{
1205 1206
	char node_name[5];
	struct acpi_buffer buffer = { sizeof(node_name), node_name };
1207 1208
	struct acpi_ec *ec = context;
	int value = 0;
1209 1210 1211 1212
	acpi_status status;

	status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);

L
Lv Zheng 已提交
1213
	if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
1214 1215 1216 1217
		acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
	return AE_OK;
}

1218 1219
static acpi_status
ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
1220
{
1221
	acpi_status status;
1222
	unsigned long long tmp = 0;
1223
	struct acpi_ec *ec = context;
1224 1225 1226 1227

	/* clear addr values, ec_parse_io_ports depend on it */
	ec->command_addr = ec->data_addr = 0;

1228 1229 1230 1231
	status = acpi_walk_resources(handle, METHOD_NAME__CRS,
				     ec_parse_io_ports, ec);
	if (ACPI_FAILURE(status))
		return status;
1232 1233 1234

	/* Get GPE bit assignment (EC events). */
	/* TODO: Add support for _GPE returning a package */
1235
	status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1236 1237
	if (ACPI_FAILURE(status))
		return status;
1238
	ec->gpe = tmp;
1239
	/* Use the global lock for all EC transactions? */
1240
	tmp = 0;
1241 1242
	acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
	ec->global_lock = tmp;
1243
	ec->handle = handle;
1244
	return AE_CTRL_TERMINATE;
1245 1246
}

1247 1248 1249
static int ec_install_handlers(struct acpi_ec *ec)
{
	acpi_status status;
L
Lv Zheng 已提交
1250

1251 1252
	if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
		return 0;
1253
	status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1254 1255 1256 1257
				  ACPI_GPE_EDGE_TRIGGERED,
				  &acpi_ec_gpe_handler, ec);
	if (ACPI_FAILURE(status))
		return -ENODEV;
1258

1259
	acpi_ec_start(ec, false);
1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
	status = acpi_install_address_space_handler(ec->handle,
						    ACPI_ADR_SPACE_EC,
						    &acpi_ec_space_handler,
						    NULL, ec);
	if (ACPI_FAILURE(status)) {
		if (status == AE_NOT_FOUND) {
			/*
			 * Maybe OS fails in evaluating the _REG object.
			 * The AE_NOT_FOUND error will be ignored and OS
			 * continue to initialize EC.
			 */
1271
			pr_err("Fail in evaluating the _REG object"
1272 1273
				" of EC device. Broken bios is suspected.\n");
		} else {
1274
			acpi_ec_stop(ec, false);
1275 1276 1277 1278 1279 1280 1281 1282 1283 1284
			acpi_remove_gpe_handler(NULL, ec->gpe,
				&acpi_ec_gpe_handler);
			return -ENODEV;
		}
	}

	set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
	return 0;
}

1285 1286
static void ec_remove_handlers(struct acpi_ec *ec)
{
1287 1288
	if (!test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
		return;
1289
	acpi_ec_stop(ec, false);
1290 1291
	if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
				ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1292
		pr_err("failed to remove space handler\n");
1293 1294
	if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
				&acpi_ec_gpe_handler)))
1295
		pr_err("failed to remove gpe handler\n");
1296
	clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
1297 1298
}

1299
static int acpi_ec_add(struct acpi_device *device)
L
Linus Torvalds 已提交
1300
{
1301
	struct acpi_ec *ec = NULL;
B
Bjorn Helgaas 已提交
1302
	int ret;
L
Luming Yu 已提交
1303

1304 1305 1306
	strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
	strcpy(acpi_device_class(device), ACPI_EC_CLASS);

1307
	/* Check for boot EC */
1308 1309 1310 1311 1312 1313 1314 1315 1316
	if (boot_ec &&
	    (boot_ec->handle == device->handle ||
	     boot_ec->handle == ACPI_ROOT_OBJECT)) {
		ec = boot_ec;
		boot_ec = NULL;
	} else {
		ec = make_acpi_ec();
		if (!ec)
			return -ENOMEM;
1317 1318 1319
	}
	if (ec_parse_device(device->handle, 0, ec, NULL) !=
		AE_CTRL_TERMINATE) {
1320 1321
			kfree(ec);
			return -EINVAL;
1322 1323
	}

1324 1325
	/* Find and register all query methods */
	acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1326
			    acpi_ec_register_query_methods, NULL, ec, NULL);
1327

1328 1329
	if (!first_ec)
		first_ec = ec;
1330
	device->driver_data = ec;
1331

1332 1333 1334 1335
	ret = !!request_region(ec->data_addr, 1, "EC data");
	WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
	ret = !!request_region(ec->command_addr, 1, "EC cmd");
	WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
1336

1337
	pr_info("GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
1338
			  ec->gpe, ec->command_addr, ec->data_addr);
1339 1340 1341

	ret = ec_install_handlers(ec);

1342 1343 1344
	/* Reprobe devices depending on the EC */
	acpi_walk_dep_device_list(ec->handle);

1345
	/* EC is fully operational, allow queries */
1346
	clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
1347 1348

	/* Clear stale _Q events if hardware might require that */
L
Lv Zheng 已提交
1349
	if (EC_FLAGS_CLEAR_ON_RESUME)
1350
		acpi_ec_clear(ec);
1351
	return ret;
L
Linus Torvalds 已提交
1352 1353
}

1354
static int acpi_ec_remove(struct acpi_device *device)
L
Linus Torvalds 已提交
1355
{
1356
	struct acpi_ec *ec;
1357
	struct acpi_ec_query_handler *handler, *tmp;
L
Linus Torvalds 已提交
1358 1359

	if (!device)
1360
		return -EINVAL;
L
Linus Torvalds 已提交
1361 1362

	ec = acpi_driver_data(device);
B
Bjorn Helgaas 已提交
1363
	ec_remove_handlers(ec);
1364
	mutex_lock(&ec->mutex);
1365
	list_for_each_entry_safe(handler, tmp, &ec->list, node) {
1366 1367 1368
		list_del(&handler->node);
		kfree(handler);
	}
1369
	mutex_unlock(&ec->mutex);
1370 1371
	release_region(ec->data_addr, 1);
	release_region(ec->command_addr, 1);
1372
	device->driver_data = NULL;
1373
	if (ec == first_ec)
1374
		first_ec = NULL;
1375
	kfree(ec);
1376
	return 0;
L
Linus Torvalds 已提交
1377 1378 1379
}

static acpi_status
1380
ec_parse_io_ports(struct acpi_resource *resource, void *context)
L
Linus Torvalds 已提交
1381
{
1382
	struct acpi_ec *ec = context;
L
Linus Torvalds 已提交
1383

1384
	if (resource->type != ACPI_RESOURCE_TYPE_IO)
L
Linus Torvalds 已提交
1385 1386 1387 1388 1389 1390 1391
		return AE_OK;

	/*
	 * The first address region returned is the data port, and
	 * the second address region returned is the status/command
	 * port.
	 */
1392
	if (ec->data_addr == 0)
1393
		ec->data_addr = resource->data.io.minimum;
1394
	else if (ec->command_addr == 0)
1395
		ec->command_addr = resource->data.io.minimum;
1396
	else
L
Linus Torvalds 已提交
1397 1398 1399 1400 1401
		return AE_CTRL_TERMINATE;

	return AE_OK;
}

1402 1403
int __init acpi_boot_ec_enable(void)
{
1404
	if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
1405 1406 1407 1408 1409 1410 1411 1412
		return 0;
	if (!ec_install_handlers(boot_ec)) {
		first_ec = boot_ec;
		return 0;
	}
	return -EFAULT;
}

1413 1414 1415 1416 1417
static const struct acpi_device_id ec_device_ids[] = {
	{"PNP0C09", 0},
	{"", 0},
};

1418 1419 1420 1421 1422 1423 1424
/* Some BIOS do not survive early DSDT scan, skip it */
static int ec_skip_dsdt_scan(const struct dmi_system_id *id)
{
	EC_FLAGS_SKIP_DSDT_SCAN = 1;
	return 0;
}

A
Alexey Starikovskiy 已提交
1425 1426 1427 1428 1429 1430 1431
/* ASUStek often supplies us with broken ECDT, validate it */
static int ec_validate_ecdt(const struct dmi_system_id *id)
{
	EC_FLAGS_VALIDATE_ECDT = 1;
	return 0;
}

1432
#if 0
1433
/*
1434 1435 1436 1437 1438
 * Some EC firmware variations refuses to respond QR_EC when SCI_EVT is not
 * set, for which case, we complete the QR_EC without issuing it to the
 * firmware.
 * https://bugzilla.kernel.org/show_bug.cgi?id=82611
 * https://bugzilla.kernel.org/show_bug.cgi?id=97381
1439 1440 1441 1442 1443 1444 1445
 */
static int ec_flag_query_handshake(const struct dmi_system_id *id)
{
	pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
	EC_FLAGS_QUERY_HANDSHAKE = 1;
	return 0;
}
1446
#endif
1447

1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468
/*
 * On some hardware it is necessary to clear events accumulated by the EC during
 * sleep. These ECs stop reporting GPEs until they are manually polled, if too
 * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
 *
 * https://bugzilla.kernel.org/show_bug.cgi?id=44161
 *
 * Ideally, the EC should also be instructed NOT to accumulate events during
 * sleep (which Windows seems to do somehow), but the interface to control this
 * behaviour is not known at this time.
 *
 * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
 * however it is very likely that other Samsung models are affected.
 *
 * On systems which don't accumulate _Q events during sleep, this extra check
 * should be harmless.
 */
static int ec_clear_on_resume(const struct dmi_system_id *id)
{
	pr_debug("Detected system needing EC poll on resume.\n");
	EC_FLAGS_CLEAR_ON_RESUME = 1;
1469
	ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1470 1471 1472
	return 0;
}

1473
static struct dmi_system_id ec_dmi_table[] __initdata = {
1474 1475 1476 1477
	{
	ec_skip_dsdt_scan, "Compal JFL92", {
	DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
	DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL},
A
Alexey Starikovskiy 已提交
1478
	{
1479 1480 1481
	ec_validate_ecdt, "MSI MS-171F", {
	DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
	DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),}, NULL},
1482
	{
A
Alexey Starikovskiy 已提交
1483 1484
	ec_validate_ecdt, "ASUS hardware", {
	DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
1485 1486 1487
	{
	ec_validate_ecdt, "ASUS hardware", {
	DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
1488
	{
1489 1490 1491
	ec_skip_dsdt_scan, "HP Folio 13", {
	DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
	DMI_MATCH(DMI_PRODUCT_NAME, "HP Folio 13"),}, NULL},
1492 1493 1494 1495
	{
	ec_validate_ecdt, "ASUS hardware", {
	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek Computer Inc."),
	DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),}, NULL},
1496 1497 1498
	{
	ec_clear_on_resume, "Samsung hardware", {
	DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
A
Alexey Starikovskiy 已提交
1499 1500 1501
	{},
};

1502 1503 1504
int __init acpi_ec_ecdt_probe(void)
{
	acpi_status status;
1505
	struct acpi_ec *saved_ec = NULL;
L
Len Brown 已提交
1506
	struct acpi_table_ecdt *ecdt_ptr;
L
Luming Yu 已提交
1507

1508 1509
	boot_ec = make_acpi_ec();
	if (!boot_ec)
1510 1511 1512 1513
		return -ENOMEM;
	/*
	 * Generate a boot ec context
	 */
A
Alexey Starikovskiy 已提交
1514
	dmi_check_system(ec_dmi_table);
1515 1516
	status = acpi_get_table(ACPI_SIG_ECDT, 1,
				(struct acpi_table_header **)&ecdt_ptr);
1517
	if (ACPI_SUCCESS(status)) {
1518
		pr_info("EC description table is found, configuring boot EC\n");
1519 1520 1521
		boot_ec->command_addr = ecdt_ptr->control.address;
		boot_ec->data_addr = ecdt_ptr->data.address;
		boot_ec->gpe = ecdt_ptr->gpe;
1522
		boot_ec->handle = ACPI_ROOT_OBJECT;
L
Lv Zheng 已提交
1523 1524
		acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id,
				&boot_ec->handle);
1525
		/* Don't trust ECDT, which comes from ASUSTek */
A
Alexey Starikovskiy 已提交
1526
		if (!EC_FLAGS_VALIDATE_ECDT)
1527
			goto install;
J
Julia Lawall 已提交
1528
		saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL);
1529 1530
		if (!saved_ec)
			return -ENOMEM;
1531
	/* fall through */
1532
	}
A
Alexey Starikovskiy 已提交
1533

1534 1535
	if (EC_FLAGS_SKIP_DSDT_SCAN) {
		kfree(saved_ec);
1536
		return -ENODEV;
1537
	}
1538

1539 1540
	/* This workaround is needed only on some broken machines,
	 * which require early EC, but fail to provide ECDT */
1541
	pr_debug("Look up EC in DSDT\n");
1542 1543 1544 1545 1546
	status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
					boot_ec, NULL);
	/* Check that acpi_get_devices actually find something */
	if (ACPI_FAILURE(status) || !boot_ec->handle)
		goto error;
1547 1548 1549 1550 1551 1552
	if (saved_ec) {
		/* try to find good ECDT from ASUSTek */
		if (saved_ec->command_addr != boot_ec->command_addr ||
		    saved_ec->data_addr != boot_ec->data_addr ||
		    saved_ec->gpe != boot_ec->gpe ||
		    saved_ec->handle != boot_ec->handle)
1553
			pr_info("ASUSTek keeps feeding us with broken "
1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564
			"ECDT tables, which are very hard to workaround. "
			"Trying to use DSDT EC info instead. Please send "
			"output of acpidump to linux-acpi@vger.kernel.org\n");
		kfree(saved_ec);
		saved_ec = NULL;
	} else {
		/* We really need to limit this workaround, the only ASUS,
		* which needs it, has fake EC._INI method, so use it as flag.
		* Keep boot_ec struct as it will be needed soon.
		*/
		if (!dmi_name_in_vendors("ASUS") ||
1565
		    !acpi_has_method(boot_ec->handle, "_INI"))
1566 1567
			return -ENODEV;
	}
1568 1569
install:
	if (!ec_install_handlers(boot_ec)) {
1570
		first_ec = boot_ec;
1571
		return 0;
1572
	}
1573
error:
1574
	kfree(boot_ec);
1575
	kfree(saved_ec);
1576
	boot_ec = NULL;
L
Linus Torvalds 已提交
1577 1578 1579
	return -ENODEV;
}

1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616
static int param_set_event_clearing(const char *val, struct kernel_param *kp)
{
	int result = 0;

	if (!strncmp(val, "status", sizeof("status") - 1)) {
		ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
		pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
	} else if (!strncmp(val, "query", sizeof("query") - 1)) {
		ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
		pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
	} else if (!strncmp(val, "event", sizeof("event") - 1)) {
		ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
		pr_info("Assuming SCI_EVT clearing on event reads\n");
	} else
		result = -EINVAL;
	return result;
}

static int param_get_event_clearing(char *buffer, struct kernel_param *kp)
{
	switch (ec_event_clearing) {
	case ACPI_EC_EVT_TIMING_STATUS:
		return sprintf(buffer, "status");
	case ACPI_EC_EVT_TIMING_QUERY:
		return sprintf(buffer, "query");
	case ACPI_EC_EVT_TIMING_EVENT:
		return sprintf(buffer, "event");
	default:
		return sprintf(buffer, "invalid");
	}
	return 0;
}

module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
		  NULL, 0644);
MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");

1617 1618 1619 1620 1621 1622 1623 1624 1625 1626
static struct acpi_driver acpi_ec_driver = {
	.name = "ec",
	.class = ACPI_EC_CLASS,
	.ids = ec_device_ids,
	.ops = {
		.add = acpi_ec_add,
		.remove = acpi_ec_remove,
		},
};

1627
int __init acpi_ec_init(void)
L
Linus Torvalds 已提交
1628
{
L
Len Brown 已提交
1629
	int result = 0;
L
Linus Torvalds 已提交
1630 1631 1632

	/* Now register the driver for the EC */
	result = acpi_bus_register_driver(&acpi_ec_driver);
1633
	if (result < 0)
1634
		return -ENODEV;
L
Linus Torvalds 已提交
1635

1636
	return result;
L
Linus Torvalds 已提交
1637 1638 1639 1640
}

/* EC driver currently not unloadable */
#if 0
L
Len Brown 已提交
1641
static void __exit acpi_ec_exit(void)
L
Linus Torvalds 已提交
1642 1643 1644 1645
{

	acpi_bus_unregister_driver(&acpi_ec_driver);
}
1646
#endif	/* 0 */