1// SPDX-License-Identifier: GPL-2.0-or-later
   2/*
   3 *  ec.c - ACPI Embedded Controller Driver (v3)
   4 *
   5 *  Copyright (C) 2001-2015 Intel Corporation
   6 *    Author: 2014, 2015 Lv Zheng <lv.zheng@intel.com>
   7 *            2006, 2007 Alexey Starikovskiy <alexey.y.starikovskiy@intel.com>
   8 *            2006       Denis Sadykov <denis.m.sadykov@intel.com>
   9 *            2004       Luming Yu <luming.yu@intel.com>
  10 *            2001, 2002 Andy Grover <andrew.grover@intel.com>
  11 *            2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
  12 *  Copyright (C) 2008      Alexey Starikovskiy <astarikovskiy@suse.de>
  13 */
  14
  15/* Uncomment next line to get verbose printout */
  16/* #define DEBUG */
  17#define pr_fmt(fmt) "ACPI: EC: " fmt
  18
  19#include <linux/kernel.h>
  20#include <linux/module.h>
  21#include <linux/init.h>
  22#include <linux/types.h>
  23#include <linux/delay.h>
  24#include <linux/interrupt.h>
  25#include <linux/list.h>
  26#include <linux/spinlock.h>
  27#include <linux/slab.h>
  28#include <linux/suspend.h>
  29#include <linux/acpi.h>
  30#include <linux/dmi.h>
  31#include <asm/io.h>
  32
  33#include "internal.h"
  34
  35#define ACPI_EC_CLASS			"embedded_controller"
  36#define ACPI_EC_DEVICE_NAME		"Embedded Controller"
  37#define ACPI_EC_FILE_INFO		"info"
  38
  39/* EC status register */
  40#define ACPI_EC_FLAG_OBF	0x01	/* Output buffer full */
  41#define ACPI_EC_FLAG_IBF	0x02	/* Input buffer full */
  42#define ACPI_EC_FLAG_CMD	0x08	/* Input buffer contains a command */
  43#define ACPI_EC_FLAG_BURST	0x10	/* burst mode */
  44#define ACPI_EC_FLAG_SCI	0x20	/* EC-SCI occurred */
  45
  46/*
  47 * The SCI_EVT clearing timing is not defined by the ACPI specification.
  48 * This leads to lots of practical timing issues for the host EC driver.
  49 * The following variations are defined (from the target EC firmware's
  50 * perspective):
  51 * STATUS: After indicating SCI_EVT edge triggered IRQ to the host, the
  52 *         target can clear SCI_EVT at any time so long as the host can see
  53 *         the indication by reading the status register (EC_SC). So the
  54 *         host should re-check SCI_EVT after the first time the SCI_EVT
  55 *         indication is seen, which is the same time the query request
  56 *         (QR_EC) is written to the command register (EC_CMD). SCI_EVT set
  57 *         at any later time could indicate another event. Normally such
  58 *         kind of EC firmware has implemented an event queue and will
  59 *         return 0x00 to indicate "no outstanding event".
  60 * QUERY: After seeing the query request (QR_EC) written to the command
  61 *        register (EC_CMD) by the host and having prepared the responding
  62 *        event value in the data register (EC_DATA), the target can safely
  63 *        clear SCI_EVT because the target can confirm that the current
  64 *        event is being handled by the host. The host then should check
  65 *        SCI_EVT right after reading the event response from the data
  66 *        register (EC_DATA).
  67 * EVENT: After seeing the event response read from the data register
  68 *        (EC_DATA) by the host, the target can clear SCI_EVT. As the
  69 *        target requires time to notice the change in the data register
  70 *        (EC_DATA), the host may be required to wait additional guarding
  71 *        time before checking the SCI_EVT again. Such guarding may not be
  72 *        necessary if the host is notified via another IRQ.
  73 */
  74#define ACPI_EC_EVT_TIMING_STATUS	0x00
  75#define ACPI_EC_EVT_TIMING_QUERY	0x01
  76#define ACPI_EC_EVT_TIMING_EVENT	0x02
  77
  78/* EC commands */
  79enum ec_command {
  80	ACPI_EC_COMMAND_READ = 0x80,
  81	ACPI_EC_COMMAND_WRITE = 0x81,
  82	ACPI_EC_BURST_ENABLE = 0x82,
  83	ACPI_EC_BURST_DISABLE = 0x83,
  84	ACPI_EC_COMMAND_QUERY = 0x84,
  85};
  86
  87#define ACPI_EC_DELAY		500	/* Wait 500ms max. during EC ops */
  88#define ACPI_EC_UDELAY_GLK	1000	/* Wait 1ms max. to get global lock */
  89#define ACPI_EC_UDELAY_POLL	550	/* Wait 1ms for EC transaction polling */
  90#define ACPI_EC_CLEAR_MAX	100	/* Maximum number of events to query
  91					 * when trying to clear the EC */
  92#define ACPI_EC_MAX_QUERIES	16	/* Maximum number of parallel queries */
  93
  94enum {
  95	EC_FLAGS_QUERY_ENABLED,		/* Query is enabled */
  96	EC_FLAGS_QUERY_PENDING,		/* Query is pending */
  97	EC_FLAGS_QUERY_GUARDING,	/* Guard for SCI_EVT check */
  98	EC_FLAGS_GPE_HANDLER_INSTALLED,	/* GPE handler installed */
  99	EC_FLAGS_EC_HANDLER_INSTALLED,	/* OpReg handler installed */
 100	EC_FLAGS_EVT_HANDLER_INSTALLED, /* _Qxx handlers installed */
 101	EC_FLAGS_STARTED,		/* Driver is started */
 102	EC_FLAGS_STOPPED,		/* Driver is stopped */
 103	EC_FLAGS_GPE_MASKED,		/* GPE masked */
 104};
 105
 106#define ACPI_EC_COMMAND_POLL		0x01 /* Available for command byte */
 107#define ACPI_EC_COMMAND_COMPLETE	0x02 /* Completed last byte */
 108
 109/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
 110static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
 111module_param(ec_delay, uint, 0644);
 112MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
 113
 114static unsigned int ec_max_queries __read_mostly = ACPI_EC_MAX_QUERIES;
 115module_param(ec_max_queries, uint, 0644);
 116MODULE_PARM_DESC(ec_max_queries, "Maximum parallel _Qxx evaluations");
 117
 118static bool ec_busy_polling __read_mostly;
 119module_param(ec_busy_polling, bool, 0644);
 120MODULE_PARM_DESC(ec_busy_polling, "Use busy polling to advance EC transaction");
 121
 122static unsigned int ec_polling_guard __read_mostly = ACPI_EC_UDELAY_POLL;
 123module_param(ec_polling_guard, uint, 0644);
 124MODULE_PARM_DESC(ec_polling_guard, "Guard time(us) between EC accesses in polling modes");
 125
 126static unsigned int ec_event_clearing __read_mostly = ACPI_EC_EVT_TIMING_QUERY;
 127
 128/*
 129 * If the number of false interrupts per one transaction exceeds
 130 * this threshold, will think there is a GPE storm happened and
 131 * will disable the GPE for normal transaction.
 132 */
 133static unsigned int ec_storm_threshold  __read_mostly = 8;
 134module_param(ec_storm_threshold, uint, 0644);
 135MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
 136
 137static bool ec_freeze_events __read_mostly = false;
 138module_param(ec_freeze_events, bool, 0644);
 139MODULE_PARM_DESC(ec_freeze_events, "Disabling event handling during suspend/resume");
 140
 141static bool ec_no_wakeup __read_mostly;
 142module_param(ec_no_wakeup, bool, 0644);
 143MODULE_PARM_DESC(ec_no_wakeup, "Do not wake up from suspend-to-idle");
 144
 145struct acpi_ec_query_handler {
 146	struct list_head node;
 147	acpi_ec_query_func func;
 148	acpi_handle handle;
 149	void *data;
 150	u8 query_bit;
 151	struct kref kref;
 152};
 153
 154struct transaction {
 155	const u8 *wdata;
 156	u8 *rdata;
 157	unsigned short irq_count;
 158	u8 command;
 159	u8 wi;
 160	u8 ri;
 161	u8 wlen;
 162	u8 rlen;
 163	u8 flags;
 164};
 165
 166struct acpi_ec_query {
 167	struct transaction transaction;
 168	struct work_struct work;
 169	struct acpi_ec_query_handler *handler;
 170};
 171
 172static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
 173static void advance_transaction(struct acpi_ec *ec);
 174static void acpi_ec_event_handler(struct work_struct *work);
 175static void acpi_ec_event_processor(struct work_struct *work);
 176
 177struct acpi_ec *first_ec;
 178EXPORT_SYMBOL(first_ec);
 179
 180static struct acpi_ec *boot_ec;
 181static bool boot_ec_is_ecdt = false;
 
 182static struct workqueue_struct *ec_query_wq;
 183
 184static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
 185static int EC_FLAGS_CORRECT_ECDT; /* Needs ECDT port address correction */
 186static int EC_FLAGS_IGNORE_DSDT_GPE; /* Needs ECDT GPE as correction setting */
 
 187static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
 188
 189/* --------------------------------------------------------------------------
 190 *                           Logging/Debugging
 191 * -------------------------------------------------------------------------- */
 192
 193/*
 194 * Splitters used by the developers to track the boundary of the EC
 195 * handling processes.
 196 */
 197#ifdef DEBUG
 198#define EC_DBG_SEP	" "
 199#define EC_DBG_DRV	"+++++"
 200#define EC_DBG_STM	"====="
 201#define EC_DBG_REQ	"*****"
 202#define EC_DBG_EVT	"#####"
 203#else
 204#define EC_DBG_SEP	""
 205#define EC_DBG_DRV
 206#define EC_DBG_STM
 207#define EC_DBG_REQ
 208#define EC_DBG_EVT
 209#endif
 210
 211#define ec_log_raw(fmt, ...) \
 212	pr_info(fmt "\n", ##__VA_ARGS__)
 213#define ec_dbg_raw(fmt, ...) \
 214	pr_debug(fmt "\n", ##__VA_ARGS__)
 215#define ec_log(filter, fmt, ...) \
 216	ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
 217#define ec_dbg(filter, fmt, ...) \
 218	ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
 219
 220#define ec_log_drv(fmt, ...) \
 221	ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
 222#define ec_dbg_drv(fmt, ...) \
 223	ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
 224#define ec_dbg_stm(fmt, ...) \
 225	ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
 226#define ec_dbg_req(fmt, ...) \
 227	ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
 228#define ec_dbg_evt(fmt, ...) \
 229	ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
 230#define ec_dbg_ref(ec, fmt, ...) \
 231	ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
 232
 233/* --------------------------------------------------------------------------
 234 *                           Device Flags
 235 * -------------------------------------------------------------------------- */
 236
 237static bool acpi_ec_started(struct acpi_ec *ec)
 238{
 239	return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
 240	       !test_bit(EC_FLAGS_STOPPED, &ec->flags);
 241}
 242
 243static bool acpi_ec_event_enabled(struct acpi_ec *ec)
 244{
 245	/*
 246	 * There is an OSPM early stage logic. During the early stages
 247	 * (boot/resume), OSPMs shouldn't enable the event handling, only
 248	 * the EC transactions are allowed to be performed.
 249	 */
 250	if (!test_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
 251		return false;
 252	/*
 253	 * However, disabling the event handling is experimental for late
 254	 * stage (suspend), and is controlled by the boot parameter of
 255	 * "ec_freeze_events":
 256	 * 1. true:  The EC event handling is disabled before entering
 257	 *           the noirq stage.
 258	 * 2. false: The EC event handling is automatically disabled as
 259	 *           soon as the EC driver is stopped.
 260	 */
 261	if (ec_freeze_events)
 262		return acpi_ec_started(ec);
 263	else
 264		return test_bit(EC_FLAGS_STARTED, &ec->flags);
 265}
 266
 267static bool acpi_ec_flushed(struct acpi_ec *ec)
 268{
 269	return ec->reference_count == 1;
 270}
 271
 272/* --------------------------------------------------------------------------
 273 *                           EC Registers
 274 * -------------------------------------------------------------------------- */
 275
 276static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
 277{
 278	u8 x = inb(ec->command_addr);
 279
 280	ec_dbg_raw("EC_SC(R) = 0x%2.2x "
 281		   "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
 282		   x,
 283		   !!(x & ACPI_EC_FLAG_SCI),
 284		   !!(x & ACPI_EC_FLAG_BURST),
 285		   !!(x & ACPI_EC_FLAG_CMD),
 286		   !!(x & ACPI_EC_FLAG_IBF),
 287		   !!(x & ACPI_EC_FLAG_OBF));
 288	return x;
 289}
 290
 291static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
 292{
 293	u8 x = inb(ec->data_addr);
 294
 295	ec->timestamp = jiffies;
 296	ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
 297	return x;
 298}
 299
 300static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
 301{
 302	ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
 303	outb(command, ec->command_addr);
 304	ec->timestamp = jiffies;
 305}
 306
 307static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
 308{
 309	ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
 310	outb(data, ec->data_addr);
 311	ec->timestamp = jiffies;
 312}
 313
 314#if defined(DEBUG) || defined(CONFIG_DYNAMIC_DEBUG)
 315static const char *acpi_ec_cmd_string(u8 cmd)
 316{
 317	switch (cmd) {
 318	case 0x80:
 319		return "RD_EC";
 320	case 0x81:
 321		return "WR_EC";
 322	case 0x82:
 323		return "BE_EC";
 324	case 0x83:
 325		return "BD_EC";
 326	case 0x84:
 327		return "QR_EC";
 328	}
 329	return "UNKNOWN";
 330}
 331#else
 332#define acpi_ec_cmd_string(cmd)		"UNDEF"
 333#endif
 334
 335/* --------------------------------------------------------------------------
 336 *                           GPE Registers
 337 * -------------------------------------------------------------------------- */
 338
 339static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
 340{
 341	acpi_event_status gpe_status = 0;
 342
 343	(void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
 344	return (gpe_status & ACPI_EVENT_FLAG_STATUS_SET) ? true : false;
 345}
 346
 347static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
 348{
 349	if (open)
 350		acpi_enable_gpe(NULL, ec->gpe);
 351	else {
 352		BUG_ON(ec->reference_count < 1);
 353		acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
 354	}
 355	if (acpi_ec_is_gpe_raised(ec)) {
 356		/*
 357		 * On some platforms, EN=1 writes cannot trigger GPE. So
 358		 * software need to manually trigger a pseudo GPE event on
 359		 * EN=1 writes.
 360		 */
 361		ec_dbg_raw("Polling quirk");
 362		advance_transaction(ec);
 363	}
 364}
 365
 366static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
 367{
 368	if (close)
 369		acpi_disable_gpe(NULL, ec->gpe);
 370	else {
 371		BUG_ON(ec->reference_count < 1);
 372		acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
 373	}
 374}
 375
 376static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
 377{
 378	/*
 379	 * GPE STS is a W1C register, which means:
 380	 * 1. Software can clear it without worrying about clearing other
 381	 *    GPEs' STS bits when the hardware sets them in parallel.
 382	 * 2. As long as software can ensure only clearing it when it is
 383	 *    set, hardware won't set it in parallel.
 384	 * So software can clear GPE in any contexts.
 385	 * Warning: do not move the check into advance_transaction() as the
 386	 * EC commands will be sent without GPE raised.
 387	 */
 388	if (!acpi_ec_is_gpe_raised(ec))
 389		return;
 390	acpi_clear_gpe(NULL, ec->gpe);
 391}
 392
 393/* --------------------------------------------------------------------------
 394 *                           Transaction Management
 395 * -------------------------------------------------------------------------- */
 396
 397static void acpi_ec_submit_request(struct acpi_ec *ec)
 398{
 399	ec->reference_count++;
 400	if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags) &&
 401	    ec->reference_count == 1)
 402		acpi_ec_enable_gpe(ec, true);
 403}
 404
 405static void acpi_ec_complete_request(struct acpi_ec *ec)
 406{
 407	bool flushed = false;
 408
 409	ec->reference_count--;
 410	if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags) &&
 411	    ec->reference_count == 0)
 412		acpi_ec_disable_gpe(ec, true);
 413	flushed = acpi_ec_flushed(ec);
 414	if (flushed)
 415		wake_up(&ec->wait);
 416}
 417
 418static void acpi_ec_mask_gpe(struct acpi_ec *ec)
 419{
 420	if (!test_bit(EC_FLAGS_GPE_MASKED, &ec->flags)) {
 421		acpi_ec_disable_gpe(ec, false);
 
 
 
 
 422		ec_dbg_drv("Polling enabled");
 423		set_bit(EC_FLAGS_GPE_MASKED, &ec->flags);
 424	}
 425}
 426
 427static void acpi_ec_unmask_gpe(struct acpi_ec *ec)
 428{
 429	if (test_bit(EC_FLAGS_GPE_MASKED, &ec->flags)) {
 430		clear_bit(EC_FLAGS_GPE_MASKED, &ec->flags);
 431		acpi_ec_enable_gpe(ec, false);
 
 
 
 
 432		ec_dbg_drv("Polling disabled");
 433	}
 434}
 435
 436/*
 437 * acpi_ec_submit_flushable_request() - Increase the reference count unless
 438 *                                      the flush operation is not in
 439 *                                      progress
 440 * @ec: the EC device
 441 *
 442 * This function must be used before taking a new action that should hold
 443 * the reference count.  If this function returns false, then the action
 444 * must be discarded or it will prevent the flush operation from being
 445 * completed.
 446 */
 447static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
 448{
 449	if (!acpi_ec_started(ec))
 450		return false;
 451	acpi_ec_submit_request(ec);
 452	return true;
 453}
 454
 455static void acpi_ec_submit_query(struct acpi_ec *ec)
 456{
 457	acpi_ec_mask_gpe(ec);
 458	if (!acpi_ec_event_enabled(ec))
 459		return;
 460	if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
 461		ec_dbg_evt("Command(%s) submitted/blocked",
 462			   acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
 463		ec->nr_pending_queries++;
 464		schedule_work(&ec->work);
 465	}
 466}
 467
 468static void acpi_ec_complete_query(struct acpi_ec *ec)
 469{
 470	if (test_and_clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
 471		ec_dbg_evt("Command(%s) unblocked",
 472			   acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
 473	acpi_ec_unmask_gpe(ec);
 474}
 475
 476static inline void __acpi_ec_enable_event(struct acpi_ec *ec)
 477{
 478	if (!test_and_set_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
 479		ec_log_drv("event unblocked");
 480	/*
 481	 * Unconditionally invoke this once after enabling the event
 482	 * handling mechanism to detect the pending events.
 483	 */
 484	advance_transaction(ec);
 485}
 486
 487static inline void __acpi_ec_disable_event(struct acpi_ec *ec)
 488{
 489	if (test_and_clear_bit(EC_FLAGS_QUERY_ENABLED, &ec->flags))
 490		ec_log_drv("event blocked");
 491}
 492
 493/*
 494 * Process _Q events that might have accumulated in the EC.
 495 * Run with locked ec mutex.
 496 */
 497static void acpi_ec_clear(struct acpi_ec *ec)
 498{
 499	int i, status;
 500	u8 value = 0;
 501
 502	for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
 503		status = acpi_ec_query(ec, &value);
 504		if (status || !value)
 505			break;
 506	}
 507	if (unlikely(i == ACPI_EC_CLEAR_MAX))
 508		pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
 509	else
 510		pr_info("%d stale EC events cleared\n", i);
 511}
 512
 513static void acpi_ec_enable_event(struct acpi_ec *ec)
 514{
 515	unsigned long flags;
 516
 517	spin_lock_irqsave(&ec->lock, flags);
 518	if (acpi_ec_started(ec))
 519		__acpi_ec_enable_event(ec);
 520	spin_unlock_irqrestore(&ec->lock, flags);
 521
 522	/* Drain additional events if hardware requires that */
 523	if (EC_FLAGS_CLEAR_ON_RESUME)
 524		acpi_ec_clear(ec);
 525}
 526
 527#ifdef CONFIG_PM_SLEEP
 528static bool acpi_ec_query_flushed(struct acpi_ec *ec)
 529{
 530	bool flushed;
 531	unsigned long flags;
 532
 533	spin_lock_irqsave(&ec->lock, flags);
 534	flushed = !ec->nr_pending_queries;
 535	spin_unlock_irqrestore(&ec->lock, flags);
 536	return flushed;
 537}
 538
 539static void __acpi_ec_flush_event(struct acpi_ec *ec)
 540{
 541	/*
 542	 * When ec_freeze_events is true, we need to flush events in
 543	 * the proper position before entering the noirq stage.
 544	 */
 545	wait_event(ec->wait, acpi_ec_query_flushed(ec));
 546	if (ec_query_wq)
 547		flush_workqueue(ec_query_wq);
 548}
 549
 550static void acpi_ec_disable_event(struct acpi_ec *ec)
 551{
 552	unsigned long flags;
 553
 554	spin_lock_irqsave(&ec->lock, flags);
 555	__acpi_ec_disable_event(ec);
 556	spin_unlock_irqrestore(&ec->lock, flags);
 557	__acpi_ec_flush_event(ec);
 
 
 
 
 
 558}
 559
 560void acpi_ec_flush_work(void)
 561{
 562	if (first_ec)
 563		__acpi_ec_flush_event(first_ec);
 
 564
 565	flush_scheduled_work();
 566}
 567#endif /* CONFIG_PM_SLEEP */
 568
 569static bool acpi_ec_guard_event(struct acpi_ec *ec)
 570{
 571	bool guarded = true;
 572	unsigned long flags;
 573
 574	spin_lock_irqsave(&ec->lock, flags);
 575	/*
 576	 * If firmware SCI_EVT clearing timing is "event", we actually
 577	 * don't know when the SCI_EVT will be cleared by firmware after
 578	 * evaluating _Qxx, so we need to re-check SCI_EVT after waiting an
 579	 * acceptable period.
 580	 *
 581	 * The guarding period begins when EC_FLAGS_QUERY_PENDING is
 582	 * flagged, which means SCI_EVT check has just been performed.
 583	 * But if the current transaction is ACPI_EC_COMMAND_QUERY, the
 584	 * guarding should have already been performed (via
 585	 * EC_FLAGS_QUERY_GUARDING) and should not be applied so that the
 586	 * ACPI_EC_COMMAND_QUERY transaction can be transitioned into
 587	 * ACPI_EC_COMMAND_POLL state immediately.
 588	 */
 589	if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
 590	    ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY ||
 591	    !test_bit(EC_FLAGS_QUERY_PENDING, &ec->flags) ||
 592	    (ec->curr && ec->curr->command == ACPI_EC_COMMAND_QUERY))
 593		guarded = false;
 594	spin_unlock_irqrestore(&ec->lock, flags);
 595	return guarded;
 596}
 597
 598static int ec_transaction_polled(struct acpi_ec *ec)
 599{
 600	unsigned long flags;
 601	int ret = 0;
 602
 603	spin_lock_irqsave(&ec->lock, flags);
 604	if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_POLL))
 605		ret = 1;
 606	spin_unlock_irqrestore(&ec->lock, flags);
 607	return ret;
 608}
 609
 610static int ec_transaction_completed(struct acpi_ec *ec)
 611{
 612	unsigned long flags;
 613	int ret = 0;
 614
 615	spin_lock_irqsave(&ec->lock, flags);
 616	if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
 617		ret = 1;
 618	spin_unlock_irqrestore(&ec->lock, flags);
 619	return ret;
 620}
 621
 622static inline void ec_transaction_transition(struct acpi_ec *ec, unsigned long flag)
 623{
 624	ec->curr->flags |= flag;
 625	if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
 626		if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS &&
 627		    flag == ACPI_EC_COMMAND_POLL)
 628			acpi_ec_complete_query(ec);
 629		if (ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY &&
 630		    flag == ACPI_EC_COMMAND_COMPLETE)
 631			acpi_ec_complete_query(ec);
 632		if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
 633		    flag == ACPI_EC_COMMAND_COMPLETE)
 634			set_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
 635	}
 636}
 637
 638static void advance_transaction(struct acpi_ec *ec)
 639{
 640	struct transaction *t;
 641	u8 status;
 
 
 
 
 
 
 
 
 
 642	bool wakeup = false;
 
 
 
 643
 644	ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK",
 645		   smp_processor_id());
 646	/*
 647	 * By always clearing STS before handling all indications, we can
 648	 * ensure a hardware STS 0->1 change after this clearing can always
 649	 * trigger a GPE interrupt.
 
 
 
 
 
 
 
 650	 */
 651	acpi_ec_clear_gpe(ec);
 
 
 652	status = acpi_ec_read_status(ec);
 653	t = ec->curr;
 654	/*
 655	 * Another IRQ or a guarded polling mode advancement is detected,
 656	 * the next QR_EC submission is then allowed.
 657	 */
 658	if (!t || !(t->flags & ACPI_EC_COMMAND_POLL)) {
 659		if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT &&
 660		    (!ec->nr_pending_queries ||
 661		     test_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags))) {
 662			clear_bit(EC_FLAGS_QUERY_GUARDING, &ec->flags);
 663			acpi_ec_complete_query(ec);
 664		}
 
 
 665	}
 666	if (!t)
 667		goto err;
 668	if (t->flags & ACPI_EC_COMMAND_POLL) {
 669		if (t->wlen > t->wi) {
 670			if ((status & ACPI_EC_FLAG_IBF) == 0)
 671				acpi_ec_write_data(ec, t->wdata[t->wi++]);
 672			else
 673				goto err;
 674		} else if (t->rlen > t->ri) {
 675			if ((status & ACPI_EC_FLAG_OBF) == 1) {
 676				t->rdata[t->ri++] = acpi_ec_read_data(ec);
 677				if (t->rlen == t->ri) {
 678					ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
 
 679					if (t->command == ACPI_EC_COMMAND_QUERY)
 680						ec_dbg_evt("Command(%s) completed by hardware",
 681							   acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
 682					wakeup = true;
 683				}
 684			} else
 685				goto err;
 686		} else if (t->wlen == t->wi &&
 687			   (status & ACPI_EC_FLAG_IBF) == 0) {
 688			ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
 689			wakeup = true;
 690		}
 691		goto out;
 692	} else {
 693		if (EC_FLAGS_QUERY_HANDSHAKE &&
 694		    !(status & ACPI_EC_FLAG_SCI) &&
 695		    (t->command == ACPI_EC_COMMAND_QUERY)) {
 696			ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
 697			t->rdata[t->ri++] = 0x00;
 698			ec_transaction_transition(ec, ACPI_EC_COMMAND_COMPLETE);
 699			ec_dbg_evt("Command(%s) completed by software",
 700				   acpi_ec_cmd_string(ACPI_EC_COMMAND_QUERY));
 701			wakeup = true;
 702		} else if ((status & ACPI_EC_FLAG_IBF) == 0) {
 703			acpi_ec_write_cmd(ec, t->command);
 704			ec_transaction_transition(ec, ACPI_EC_COMMAND_POLL);
 705		} else
 706			goto err;
 707		goto out;
 708	}
 709err:
 710	/*
 711	 * If SCI bit is set, then don't think it's a false IRQ
 712	 * otherwise will take a not handled IRQ as a false one.
 713	 */
 714	if (!(status & ACPI_EC_FLAG_SCI)) {
 715		if (in_interrupt() && t) {
 716			if (t->irq_count < ec_storm_threshold)
 717				++t->irq_count;
 718			/* Allow triggering on 0 threshold */
 719			if (t->irq_count == ec_storm_threshold)
 720				acpi_ec_mask_gpe(ec);
 721		}
 722	}
 
 723out:
 724	if (status & ACPI_EC_FLAG_SCI)
 725		acpi_ec_submit_query(ec);
 726	if (wakeup && in_interrupt())
 
 727		wake_up(&ec->wait);
 728}
 729
 730static void start_transaction(struct acpi_ec *ec)
 731{
 732	ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
 733	ec->curr->flags = 0;
 734}
 735
 736static int ec_guard(struct acpi_ec *ec)
 737{
 738	unsigned long guard = usecs_to_jiffies(ec->polling_guard);
 739	unsigned long timeout = ec->timestamp + guard;
 740
 741	/* Ensure guarding period before polling EC status */
 742	do {
 743		if (ec->busy_polling) {
 744			/* Perform busy polling */
 745			if (ec_transaction_completed(ec))
 746				return 0;
 747			udelay(jiffies_to_usecs(guard));
 748		} else {
 749			/*
 750			 * Perform wait polling
 751			 * 1. Wait the transaction to be completed by the
 752			 *    GPE handler after the transaction enters
 753			 *    ACPI_EC_COMMAND_POLL state.
 754			 * 2. A special guarding logic is also required
 755			 *    for event clearing mode "event" before the
 756			 *    transaction enters ACPI_EC_COMMAND_POLL
 757			 *    state.
 758			 */
 759			if (!ec_transaction_polled(ec) &&
 760			    !acpi_ec_guard_event(ec))
 761				break;
 762			if (wait_event_timeout(ec->wait,
 763					       ec_transaction_completed(ec),
 764					       guard))
 765				return 0;
 766		}
 767	} while (time_before(jiffies, timeout));
 768	return -ETIME;
 769}
 770
 771static int ec_poll(struct acpi_ec *ec)
 772{
 773	unsigned long flags;
 774	int repeat = 5; /* number of command restarts */
 775
 776	while (repeat--) {
 777		unsigned long delay = jiffies +
 778			msecs_to_jiffies(ec_delay);
 779		do {
 780			if (!ec_guard(ec))
 781				return 0;
 782			spin_lock_irqsave(&ec->lock, flags);
 783			advance_transaction(ec);
 784			spin_unlock_irqrestore(&ec->lock, flags);
 785		} while (time_before(jiffies, delay));
 786		pr_debug("controller reset, restart transaction\n");
 787		spin_lock_irqsave(&ec->lock, flags);
 788		start_transaction(ec);
 789		spin_unlock_irqrestore(&ec->lock, flags);
 790	}
 791	return -ETIME;
 792}
 793
 794static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
 795					struct transaction *t)
 796{
 797	unsigned long tmp;
 798	int ret = 0;
 799
 800	/* start transaction */
 801	spin_lock_irqsave(&ec->lock, tmp);
 802	/* Enable GPE for command processing (IBF=0/OBF=1) */
 803	if (!acpi_ec_submit_flushable_request(ec)) {
 804		ret = -EINVAL;
 805		goto unlock;
 806	}
 807	ec_dbg_ref(ec, "Increase command");
 808	/* following two actions should be kept atomic */
 809	ec->curr = t;
 810	ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
 811	start_transaction(ec);
 812	spin_unlock_irqrestore(&ec->lock, tmp);
 813
 814	ret = ec_poll(ec);
 815
 816	spin_lock_irqsave(&ec->lock, tmp);
 817	if (t->irq_count == ec_storm_threshold)
 818		acpi_ec_unmask_gpe(ec);
 819	ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
 820	ec->curr = NULL;
 821	/* Disable GPE for command processing (IBF=0/OBF=1) */
 822	acpi_ec_complete_request(ec);
 823	ec_dbg_ref(ec, "Decrease command");
 824unlock:
 825	spin_unlock_irqrestore(&ec->lock, tmp);
 826	return ret;
 827}
 828
 829static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
 830{
 831	int status;
 832	u32 glk;
 833
 834	if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
 835		return -EINVAL;
 836	if (t->rdata)
 837		memset(t->rdata, 0, t->rlen);
 838
 839	mutex_lock(&ec->mutex);
 840	if (ec->global_lock) {
 841		status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 842		if (ACPI_FAILURE(status)) {
 843			status = -ENODEV;
 844			goto unlock;
 845		}
 846	}
 847
 848	status = acpi_ec_transaction_unlocked(ec, t);
 849
 850	if (ec->global_lock)
 851		acpi_release_global_lock(glk);
 852unlock:
 853	mutex_unlock(&ec->mutex);
 854	return status;
 855}
 856
 857static int acpi_ec_burst_enable(struct acpi_ec *ec)
 858{
 859	u8 d;
 860	struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
 861				.wdata = NULL, .rdata = &d,
 862				.wlen = 0, .rlen = 1};
 863
 864	return acpi_ec_transaction(ec, &t);
 865}
 866
 867static int acpi_ec_burst_disable(struct acpi_ec *ec)
 868{
 869	struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
 870				.wdata = NULL, .rdata = NULL,
 871				.wlen = 0, .rlen = 0};
 872
 873	return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
 874				acpi_ec_transaction(ec, &t) : 0;
 875}
 876
 877static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
 878{
 879	int result;
 880	u8 d;
 881	struct transaction t = {.command = ACPI_EC_COMMAND_READ,
 882				.wdata = &address, .rdata = &d,
 883				.wlen = 1, .rlen = 1};
 884
 885	result = acpi_ec_transaction(ec, &t);
 886	*data = d;
 887	return result;
 888}
 889
 890static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
 891{
 892	u8 wdata[2] = { address, data };
 893	struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
 894				.wdata = wdata, .rdata = NULL,
 895				.wlen = 2, .rlen = 0};
 896
 897	return acpi_ec_transaction(ec, &t);
 898}
 899
 900int ec_read(u8 addr, u8 *val)
 901{
 902	int err;
 903	u8 temp_data;
 904
 905	if (!first_ec)
 906		return -ENODEV;
 907
 908	err = acpi_ec_read(first_ec, addr, &temp_data);
 909
 910	if (!err) {
 911		*val = temp_data;
 912		return 0;
 913	}
 914	return err;
 915}
 916EXPORT_SYMBOL(ec_read);
 917
 918int ec_write(u8 addr, u8 val)
 919{
 920	int err;
 921
 922	if (!first_ec)
 923		return -ENODEV;
 924
 925	err = acpi_ec_write(first_ec, addr, val);
 926
 927	return err;
 928}
 929EXPORT_SYMBOL(ec_write);
 930
 931int ec_transaction(u8 command,
 932		   const u8 *wdata, unsigned wdata_len,
 933		   u8 *rdata, unsigned rdata_len)
 934{
 935	struct transaction t = {.command = command,
 936				.wdata = wdata, .rdata = rdata,
 937				.wlen = wdata_len, .rlen = rdata_len};
 938
 939	if (!first_ec)
 940		return -ENODEV;
 941
 942	return acpi_ec_transaction(first_ec, &t);
 943}
 944EXPORT_SYMBOL(ec_transaction);
 945
 946/* Get the handle to the EC device */
 947acpi_handle ec_get_handle(void)
 948{
 949	if (!first_ec)
 950		return NULL;
 951	return first_ec->handle;
 952}
 953EXPORT_SYMBOL(ec_get_handle);
 954
 955static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
 956{
 957	unsigned long flags;
 958
 959	spin_lock_irqsave(&ec->lock, flags);
 960	if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
 961		ec_dbg_drv("Starting EC");
 962		/* Enable GPE for event processing (SCI_EVT=1) */
 963		if (!resuming) {
 964			acpi_ec_submit_request(ec);
 965			ec_dbg_ref(ec, "Increase driver");
 966		}
 967		ec_log_drv("EC started");
 968	}
 969	spin_unlock_irqrestore(&ec->lock, flags);
 970}
 971
 972static bool acpi_ec_stopped(struct acpi_ec *ec)
 973{
 974	unsigned long flags;
 975	bool flushed;
 976
 977	spin_lock_irqsave(&ec->lock, flags);
 978	flushed = acpi_ec_flushed(ec);
 979	spin_unlock_irqrestore(&ec->lock, flags);
 980	return flushed;
 981}
 982
 983static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
 984{
 985	unsigned long flags;
 986
 987	spin_lock_irqsave(&ec->lock, flags);
 988	if (acpi_ec_started(ec)) {
 989		ec_dbg_drv("Stopping EC");
 990		set_bit(EC_FLAGS_STOPPED, &ec->flags);
 991		spin_unlock_irqrestore(&ec->lock, flags);
 992		wait_event(ec->wait, acpi_ec_stopped(ec));
 993		spin_lock_irqsave(&ec->lock, flags);
 994		/* Disable GPE for event processing (SCI_EVT=1) */
 995		if (!suspending) {
 996			acpi_ec_complete_request(ec);
 997			ec_dbg_ref(ec, "Decrease driver");
 998		} else if (!ec_freeze_events)
 999			__acpi_ec_disable_event(ec);
1000		clear_bit(EC_FLAGS_STARTED, &ec->flags);
1001		clear_bit(EC_FLAGS_STOPPED, &ec->flags);
1002		ec_log_drv("EC stopped");
1003	}
1004	spin_unlock_irqrestore(&ec->lock, flags);
1005}
1006
1007static void acpi_ec_enter_noirq(struct acpi_ec *ec)
1008{
1009	unsigned long flags;
1010
1011	spin_lock_irqsave(&ec->lock, flags);
1012	ec->busy_polling = true;
1013	ec->polling_guard = 0;
1014	ec_log_drv("interrupt blocked");
1015	spin_unlock_irqrestore(&ec->lock, flags);
1016}
1017
1018static void acpi_ec_leave_noirq(struct acpi_ec *ec)
1019{
1020	unsigned long flags;
1021
1022	spin_lock_irqsave(&ec->lock, flags);
1023	ec->busy_polling = ec_busy_polling;
1024	ec->polling_guard = ec_polling_guard;
1025	ec_log_drv("interrupt unblocked");
1026	spin_unlock_irqrestore(&ec->lock, flags);
1027}
1028
1029void acpi_ec_block_transactions(void)
1030{
1031	struct acpi_ec *ec = first_ec;
1032
1033	if (!ec)
1034		return;
1035
1036	mutex_lock(&ec->mutex);
1037	/* Prevent transactions from being carried out */
1038	acpi_ec_stop(ec, true);
1039	mutex_unlock(&ec->mutex);
1040}
1041
1042void acpi_ec_unblock_transactions(void)
1043{
1044	/*
1045	 * Allow transactions to happen again (this function is called from
1046	 * atomic context during wakeup, so we don't need to acquire the mutex).
1047	 */
1048	if (first_ec)
1049		acpi_ec_start(first_ec, true);
1050}
1051
1052/* --------------------------------------------------------------------------
1053                                Event Management
1054   -------------------------------------------------------------------------- */
1055static struct acpi_ec_query_handler *
1056acpi_ec_get_query_handler(struct acpi_ec_query_handler *handler)
1057{
1058	if (handler)
1059		kref_get(&handler->kref);
1060	return handler;
1061}
1062
1063static struct acpi_ec_query_handler *
1064acpi_ec_get_query_handler_by_value(struct acpi_ec *ec, u8 value)
1065{
1066	struct acpi_ec_query_handler *handler;
1067	bool found = false;
1068
1069	mutex_lock(&ec->mutex);
1070	list_for_each_entry(handler, &ec->list, node) {
1071		if (value == handler->query_bit) {
1072			found = true;
1073			break;
 
1074		}
1075	}
1076	mutex_unlock(&ec->mutex);
1077	return found ? acpi_ec_get_query_handler(handler) : NULL;
1078}
1079
1080static void acpi_ec_query_handler_release(struct kref *kref)
1081{
1082	struct acpi_ec_query_handler *handler =
1083		container_of(kref, struct acpi_ec_query_handler, kref);
1084
1085	kfree(handler);
1086}
1087
1088static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
1089{
1090	kref_put(&handler->kref, acpi_ec_query_handler_release);
1091}
1092
1093int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
1094			      acpi_handle handle, acpi_ec_query_func func,
1095			      void *data)
1096{
1097	struct acpi_ec_query_handler *handler =
1098	    kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
1099
1100	if (!handler)
1101		return -ENOMEM;
1102
1103	handler->query_bit = query_bit;
1104	handler->handle = handle;
1105	handler->func = func;
1106	handler->data = data;
1107	mutex_lock(&ec->mutex);
1108	kref_init(&handler->kref);
1109	list_add(&handler->node, &ec->list);
1110	mutex_unlock(&ec->mutex);
1111	return 0;
1112}
1113EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
1114
1115static void acpi_ec_remove_query_handlers(struct acpi_ec *ec,
1116					  bool remove_all, u8 query_bit)
1117{
1118	struct acpi_ec_query_handler *handler, *tmp;
1119	LIST_HEAD(free_list);
1120
1121	mutex_lock(&ec->mutex);
1122	list_for_each_entry_safe(handler, tmp, &ec->list, node) {
1123		if (remove_all || query_bit == handler->query_bit) {
1124			list_del_init(&handler->node);
1125			list_add(&handler->node, &free_list);
1126		}
1127	}
1128	mutex_unlock(&ec->mutex);
1129	list_for_each_entry_safe(handler, tmp, &free_list, node)
1130		acpi_ec_put_query_handler(handler);
1131}
1132
1133void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
1134{
1135	acpi_ec_remove_query_handlers(ec, false, query_bit);
1136}
1137EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
1138
1139static struct acpi_ec_query *acpi_ec_create_query(u8 *pval)
1140{
1141	struct acpi_ec_query *q;
1142	struct transaction *t;
1143
1144	q = kzalloc(sizeof (struct acpi_ec_query), GFP_KERNEL);
1145	if (!q)
1146		return NULL;
1147	INIT_WORK(&q->work, acpi_ec_event_processor);
1148	t = &q->transaction;
1149	t->command = ACPI_EC_COMMAND_QUERY;
1150	t->rdata = pval;
1151	t->rlen = 1;
1152	return q;
1153}
1154
1155static void acpi_ec_delete_query(struct acpi_ec_query *q)
1156{
1157	if (q) {
1158		if (q->handler)
1159			acpi_ec_put_query_handler(q->handler);
1160		kfree(q);
1161	}
1162}
1163
1164static void acpi_ec_event_processor(struct work_struct *work)
1165{
1166	struct acpi_ec_query *q = container_of(work, struct acpi_ec_query, work);
1167	struct acpi_ec_query_handler *handler = q->handler;
1168
1169	ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
1170	if (handler->func)
1171		handler->func(handler->data);
1172	else if (handler->handle)
1173		acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
1174	ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
1175	acpi_ec_delete_query(q);
1176}
1177
1178static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
1179{
1180	u8 value = 0;
1181	int result;
1182	struct acpi_ec_query *q;
1183
1184	q = acpi_ec_create_query(&value);
1185	if (!q)
1186		return -ENOMEM;
1187
1188	/*
1189	 * Query the EC to find out which _Qxx method we need to evaluate.
1190	 * Note that successful completion of the query causes the ACPI_EC_SCI
1191	 * bit to be cleared (and thus clearing the interrupt source).
1192	 */
1193	result = acpi_ec_transaction(ec, &q->transaction);
1194	if (!value)
1195		result = -ENODATA;
1196	if (result)
1197		goto err_exit;
1198
1199	q->handler = acpi_ec_get_query_handler_by_value(ec, value);
1200	if (!q->handler) {
1201		result = -ENODATA;
1202		goto err_exit;
1203	}
1204
1205	/*
1206	 * It is reported that _Qxx are evaluated in a parallel way on
1207	 * Windows:
1208	 * https://bugzilla.kernel.org/show_bug.cgi?id=94411
1209	 *
1210	 * Put this log entry before schedule_work() in order to make
1211	 * it appearing before any other log entries occurred during the
1212	 * work queue execution.
1213	 */
1214	ec_dbg_evt("Query(0x%02x) scheduled", value);
1215	if (!queue_work(ec_query_wq, &q->work)) {
1216		ec_dbg_evt("Query(0x%02x) overlapped", value);
1217		result = -EBUSY;
1218	}
1219
1220err_exit:
1221	if (result)
1222		acpi_ec_delete_query(q);
1223	if (data)
1224		*data = value;
1225	return result;
1226}
1227
1228static void acpi_ec_check_event(struct acpi_ec *ec)
1229{
1230	unsigned long flags;
1231
1232	if (ec_event_clearing == ACPI_EC_EVT_TIMING_EVENT) {
1233		if (ec_guard(ec)) {
1234			spin_lock_irqsave(&ec->lock, flags);
1235			/*
1236			 * Take care of the SCI_EVT unless no one else is
1237			 * taking care of it.
1238			 */
1239			if (!ec->curr)
1240				advance_transaction(ec);
1241			spin_unlock_irqrestore(&ec->lock, flags);
1242		}
1243	}
1244}
1245
1246static void acpi_ec_event_handler(struct work_struct *work)
1247{
1248	unsigned long flags;
1249	struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
1250
1251	ec_dbg_evt("Event started");
1252
1253	spin_lock_irqsave(&ec->lock, flags);
1254	while (ec->nr_pending_queries) {
1255		spin_unlock_irqrestore(&ec->lock, flags);
1256		(void)acpi_ec_query(ec, NULL);
1257		spin_lock_irqsave(&ec->lock, flags);
1258		ec->nr_pending_queries--;
1259		/*
1260		 * Before exit, make sure that this work item can be
1261		 * scheduled again. There might be QR_EC failures, leaving
1262		 * EC_FLAGS_QUERY_PENDING uncleared and preventing this work
1263		 * item from being scheduled again.
1264		 */
1265		if (!ec->nr_pending_queries) {
1266			if (ec_event_clearing == ACPI_EC_EVT_TIMING_STATUS ||
1267			    ec_event_clearing == ACPI_EC_EVT_TIMING_QUERY)
1268				acpi_ec_complete_query(ec);
1269		}
1270	}
1271	spin_unlock_irqrestore(&ec->lock, flags);
1272
1273	ec_dbg_evt("Event stopped");
1274
1275	acpi_ec_check_event(ec);
1276}
1277
1278static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
1279	u32 gpe_number, void *data)
1280{
1281	unsigned long flags;
1282	struct acpi_ec *ec = data;
1283
1284	spin_lock_irqsave(&ec->lock, flags);
1285	advance_transaction(ec);
1286	spin_unlock_irqrestore(&ec->lock, flags);
 
 
 
 
 
 
1287	return ACPI_INTERRUPT_HANDLED;
1288}
1289
 
 
 
 
 
 
1290/* --------------------------------------------------------------------------
1291 *                           Address Space Management
1292 * -------------------------------------------------------------------------- */
1293
1294static acpi_status
1295acpi_ec_space_handler(u32 function, acpi_physical_address address,
1296		      u32 bits, u64 *value64,
1297		      void *handler_context, void *region_context)
1298{
1299	struct acpi_ec *ec = handler_context;
1300	int result = 0, i, bytes = bits / 8;
1301	u8 *value = (u8 *)value64;
1302
1303	if ((address > 0xFF) || !value || !handler_context)
1304		return AE_BAD_PARAMETER;
1305
1306	if (function != ACPI_READ && function != ACPI_WRITE)
1307		return AE_BAD_PARAMETER;
1308
1309	if (ec->busy_polling || bits > 8)
1310		acpi_ec_burst_enable(ec);
1311
1312	for (i = 0; i < bytes; ++i, ++address, ++value)
1313		result = (function == ACPI_READ) ?
1314			acpi_ec_read(ec, address, value) :
1315			acpi_ec_write(ec, address, *value);
1316
1317	if (ec->busy_polling || bits > 8)
1318		acpi_ec_burst_disable(ec);
1319
1320	switch (result) {
1321	case -EINVAL:
1322		return AE_BAD_PARAMETER;
1323	case -ENODEV:
1324		return AE_NOT_FOUND;
1325	case -ETIME:
1326		return AE_TIME;
1327	default:
1328		return AE_OK;
1329	}
1330}
1331
1332/* --------------------------------------------------------------------------
1333 *                             Driver Interface
1334 * -------------------------------------------------------------------------- */
1335
1336static acpi_status
1337ec_parse_io_ports(struct acpi_resource *resource, void *context);
1338
1339static void acpi_ec_free(struct acpi_ec *ec)
1340{
1341	if (first_ec == ec)
1342		first_ec = NULL;
1343	if (boot_ec == ec)
1344		boot_ec = NULL;
1345	kfree(ec);
1346}
1347
1348static struct acpi_ec *acpi_ec_alloc(void)
1349{
1350	struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
1351
1352	if (!ec)
1353		return NULL;
1354	mutex_init(&ec->mutex);
1355	init_waitqueue_head(&ec->wait);
1356	INIT_LIST_HEAD(&ec->list);
1357	spin_lock_init(&ec->lock);
1358	INIT_WORK(&ec->work, acpi_ec_event_handler);
1359	ec->timestamp = jiffies;
1360	ec->busy_polling = true;
1361	ec->polling_guard = 0;
 
 
1362	return ec;
1363}
1364
1365static acpi_status
1366acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1367			       void *context, void **return_value)
1368{
1369	char node_name[5];
1370	struct acpi_buffer buffer = { sizeof(node_name), node_name };
1371	struct acpi_ec *ec = context;
1372	int value = 0;
1373	acpi_status status;
1374
1375	status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1376
1377	if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
1378		acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
1379	return AE_OK;
1380}
1381
1382static acpi_status
1383ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
1384{
1385	acpi_status status;
1386	unsigned long long tmp = 0;
1387	struct acpi_ec *ec = context;
1388
1389	/* clear addr values, ec_parse_io_ports depend on it */
1390	ec->command_addr = ec->data_addr = 0;
1391
1392	status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1393				     ec_parse_io_ports, ec);
1394	if (ACPI_FAILURE(status))
1395		return status;
1396	if (ec->data_addr == 0 || ec->command_addr == 0)
1397		return AE_OK;
1398
1399	if (boot_ec && boot_ec_is_ecdt && EC_FLAGS_IGNORE_DSDT_GPE) {
1400		/*
1401		 * Always inherit the GPE number setting from the ECDT
1402		 * EC.
1403		 */
1404		ec->gpe = boot_ec->gpe;
1405	} else {
1406		/* Get GPE bit assignment (EC events). */
1407		/* TODO: Add support for _GPE returning a package */
1408		status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1409		if (ACPI_FAILURE(status))
1410			return status;
1411		ec->gpe = tmp;
 
 
 
 
1412	}
1413	/* Use the global lock for all EC transactions? */
1414	tmp = 0;
1415	acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1416	ec->global_lock = tmp;
1417	ec->handle = handle;
1418	return AE_CTRL_TERMINATE;
1419}
1420
1421/*
1422 * Note: This function returns an error code only when the address space
1423 *       handler is not installed, which means "not able to handle
1424 *       transactions".
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1425 */
1426static int ec_install_handlers(struct acpi_ec *ec, bool handle_events)
1427{
1428	acpi_status status;
1429
1430	acpi_ec_start(ec, false);
1431
1432	if (!test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1433		acpi_ec_enter_noirq(ec);
1434		status = acpi_install_address_space_handler(ec->handle,
1435							    ACPI_ADR_SPACE_EC,
1436							    &acpi_ec_space_handler,
1437							    NULL, ec);
1438		if (ACPI_FAILURE(status)) {
1439			if (status == AE_NOT_FOUND) {
1440				/*
1441				 * Maybe OS fails in evaluating the _REG
1442				 * object. The AE_NOT_FOUND error will be
1443				 * ignored and OS * continue to initialize
1444				 * EC.
1445				 */
1446				pr_err("Fail in evaluating the _REG object"
1447					" of EC device. Broken bios is suspected.\n");
1448			} else {
1449				acpi_ec_stop(ec, false);
1450				return -ENODEV;
1451			}
1452		}
1453		set_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1454	}
1455
1456	if (!handle_events)
1457		return 0;
1458
1459	if (!test_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags)) {
 
 
 
 
 
 
 
 
 
 
 
 
 
1460		/* Find and register all query methods */
1461		acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1462				    acpi_ec_register_query_methods,
1463				    NULL, ec, NULL);
1464		set_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags);
1465	}
1466	if (!test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags)) {
1467		status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1468					  ACPI_GPE_EDGE_TRIGGERED,
1469					  &acpi_ec_gpe_handler, ec);
1470		/* This is not fatal as we can poll EC events */
1471		if (ACPI_SUCCESS(status)) {
1472			set_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags);
 
 
 
1473			acpi_ec_leave_noirq(ec);
1474			if (test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1475			    ec->reference_count >= 1)
1476				acpi_ec_enable_gpe(ec, true);
1477		}
 
 
 
 
1478	}
1479	/* EC is fully operational, allow queries */
1480	acpi_ec_enable_event(ec);
1481
1482	return 0;
1483}
1484
1485static void ec_remove_handlers(struct acpi_ec *ec)
1486{
1487	if (test_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags)) {
1488		if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1489					ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1490			pr_err("failed to remove space handler\n");
1491		clear_bit(EC_FLAGS_EC_HANDLER_INSTALLED, &ec->flags);
1492	}
1493
1494	/*
1495	 * Stops handling the EC transactions after removing the operation
1496	 * region handler. This is required because _REG(DISCONNECT)
1497	 * invoked during the removal can result in new EC transactions.
1498	 *
1499	 * Flushes the EC requests and thus disables the GPE before
1500	 * removing the GPE handler. This is required by the current ACPICA
1501	 * GPE core. ACPICA GPE core will automatically disable a GPE when
1502	 * it is indicated but there is no way to handle it. So the drivers
1503	 * must disable the GPEs prior to removing the GPE handlers.
1504	 */
1505	acpi_ec_stop(ec, false);
1506
1507	if (test_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags)) {
1508		if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1509					&acpi_ec_gpe_handler)))
 
1510			pr_err("failed to remove gpe handler\n");
1511		clear_bit(EC_FLAGS_GPE_HANDLER_INSTALLED, &ec->flags);
 
 
 
 
1512	}
1513	if (test_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags)) {
1514		acpi_ec_remove_query_handlers(ec, true, 0);
1515		clear_bit(EC_FLAGS_EVT_HANDLER_INSTALLED, &ec->flags);
1516	}
1517}
1518
1519static int acpi_ec_setup(struct acpi_ec *ec, bool handle_events)
1520{
1521	int ret;
1522
1523	ret = ec_install_handlers(ec, handle_events);
1524	if (ret)
1525		return ret;
1526
1527	/* First EC capable of handling transactions */
1528	if (!first_ec) {
1529		first_ec = ec;
1530		acpi_handle_info(first_ec->handle, "Used as first EC\n");
1531	}
1532
1533	acpi_handle_info(ec->handle,
1534			 "GPE=0x%x, EC_CMD/EC_SC=0x%lx, EC_DATA=0x%lx\n",
1535			 ec->gpe, ec->command_addr, ec->data_addr);
1536	return ret;
1537}
1538
1539static bool acpi_ec_ecdt_get_handle(acpi_handle *phandle)
1540{
1541	struct acpi_table_ecdt *ecdt_ptr;
1542	acpi_status status;
1543	acpi_handle handle;
1544
1545	status = acpi_get_table(ACPI_SIG_ECDT, 1,
1546				(struct acpi_table_header **)&ecdt_ptr);
1547	if (ACPI_FAILURE(status))
1548		return false;
1549
1550	status = acpi_get_handle(NULL, ecdt_ptr->id, &handle);
1551	if (ACPI_FAILURE(status))
1552		return false;
1553
1554	*phandle = handle;
1555	return true;
1556}
1557
1558static int acpi_ec_add(struct acpi_device *device)
1559{
1560	struct acpi_ec *ec = NULL;
1561	bool dep_update = true;
1562	acpi_status status;
1563	int ret;
1564
1565	strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1566	strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1567
1568	if (!strcmp(acpi_device_hid(device), ACPI_ECDT_HID)) {
1569		boot_ec_is_ecdt = true;
 
1570		ec = boot_ec;
1571		dep_update = false;
1572	} else {
 
 
1573		ec = acpi_ec_alloc();
1574		if (!ec)
1575			return -ENOMEM;
1576
1577		status = ec_parse_device(device->handle, 0, ec, NULL);
1578		if (status != AE_CTRL_TERMINATE) {
1579			ret = -EINVAL;
1580			goto err_alloc;
1581		}
1582
1583		if (boot_ec && ec->command_addr == boot_ec->command_addr &&
1584		    ec->data_addr == boot_ec->data_addr) {
1585			boot_ec_is_ecdt = false;
1586			/*
1587			 * Trust PNP0C09 namespace location rather than
1588			 * ECDT ID. But trust ECDT GPE rather than _GPE
1589			 * because of ASUS quirks, so do not change
1590			 * boot_ec->gpe to ec->gpe.
1591			 */
1592			boot_ec->handle = ec->handle;
1593			acpi_handle_debug(ec->handle, "duplicated.\n");
1594			acpi_ec_free(ec);
1595			ec = boot_ec;
1596		}
1597	}
1598
1599	ret = acpi_ec_setup(ec, true);
1600	if (ret)
1601		goto err_query;
1602
1603	if (ec == boot_ec)
1604		acpi_handle_info(boot_ec->handle,
1605				 "Boot %s EC used to handle transactions and events\n",
1606				 boot_ec_is_ecdt ? "ECDT" : "DSDT");
1607
 
 
 
1608	device->driver_data = ec;
1609
1610	ret = !!request_region(ec->data_addr, 1, "EC data");
1611	WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1612	ret = !!request_region(ec->command_addr, 1, "EC cmd");
1613	WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
1614
1615	if (dep_update) {
1616		/* Reprobe devices depending on the EC */
1617		acpi_walk_dep_device_list(ec->handle);
1618	}
1619	acpi_handle_debug(ec->handle, "enumerated.\n");
1620	return 0;
1621
1622err_query:
1623	if (ec != boot_ec)
1624		acpi_ec_remove_query_handlers(ec, true, 0);
1625err_alloc:
1626	if (ec != boot_ec)
1627		acpi_ec_free(ec);
 
1628	return ret;
1629}
1630
1631static int acpi_ec_remove(struct acpi_device *device)
1632{
1633	struct acpi_ec *ec;
1634
1635	if (!device)
1636		return -EINVAL;
1637
1638	ec = acpi_driver_data(device);
1639	release_region(ec->data_addr, 1);
1640	release_region(ec->command_addr, 1);
1641	device->driver_data = NULL;
1642	if (ec != boot_ec) {
1643		ec_remove_handlers(ec);
1644		acpi_ec_free(ec);
1645	}
1646	return 0;
1647}
1648
1649static acpi_status
1650ec_parse_io_ports(struct acpi_resource *resource, void *context)
1651{
1652	struct acpi_ec *ec = context;
1653
1654	if (resource->type != ACPI_RESOURCE_TYPE_IO)
1655		return AE_OK;
1656
1657	/*
1658	 * The first address region returned is the data port, and
1659	 * the second address region returned is the status/command
1660	 * port.
1661	 */
1662	if (ec->data_addr == 0)
1663		ec->data_addr = resource->data.io.minimum;
1664	else if (ec->command_addr == 0)
1665		ec->command_addr = resource->data.io.minimum;
1666	else
1667		return AE_CTRL_TERMINATE;
1668
1669	return AE_OK;
1670}
1671
1672static const struct acpi_device_id ec_device_ids[] = {
1673	{"PNP0C09", 0},
1674	{ACPI_ECDT_HID, 0},
1675	{"", 0},
1676};
1677
1678/*
1679 * This function is not Windows-compatible as Windows never enumerates the
1680 * namespace EC before the main ACPI device enumeration process. It is
1681 * retained for historical reason and will be deprecated in the future.
1682 */
1683void __init acpi_ec_dsdt_probe(void)
1684{
1685	struct acpi_ec *ec;
1686	acpi_status status;
1687	int ret;
1688
1689	/*
1690	 * If a platform has ECDT, there is no need to proceed as the
1691	 * following probe is not a part of the ACPI device enumeration,
1692	 * executing _STA is not safe, and thus this probe may risk of
1693	 * picking up an invalid EC device.
1694	 */
1695	if (boot_ec)
1696		return;
1697
1698	ec = acpi_ec_alloc();
1699	if (!ec)
1700		return;
1701
1702	/*
1703	 * At this point, the namespace is initialized, so start to find
1704	 * the namespace objects.
1705	 */
1706	status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device, ec, NULL);
1707	if (ACPI_FAILURE(status) || !ec->handle) {
1708		acpi_ec_free(ec);
1709		return;
1710	}
1711
1712	/*
1713	 * When the DSDT EC is available, always re-configure boot EC to
1714	 * have _REG evaluated. _REG can only be evaluated after the
1715	 * namespace initialization.
1716	 * At this point, the GPE is not fully initialized, so do not to
1717	 * handle the events.
1718	 */
1719	ret = acpi_ec_setup(ec, false);
1720	if (ret) {
1721		acpi_ec_free(ec);
1722		return;
1723	}
1724
1725	boot_ec = ec;
1726
1727	acpi_handle_info(ec->handle,
1728			 "Boot DSDT EC used to handle transactions\n");
1729}
1730
1731/*
1732 * If the DSDT EC is not functioning, we still need to prepare a fully
1733 * functioning ECDT EC first in order to handle the events.
1734 * https://bugzilla.kernel.org/show_bug.cgi?id=115021
 
 
 
 
 
 
 
 
1735 */
1736static int __init acpi_ec_ecdt_start(void)
1737{
 
1738	acpi_handle handle;
 
1739
1740	if (!boot_ec)
1741		return -ENODEV;
1742	/* In case acpi_ec_ecdt_start() is called after acpi_ec_add() */
1743	if (!boot_ec_is_ecdt)
1744		return -ENODEV;
1745
1746	/*
1747	 * At this point, the namespace and the GPE is initialized, so
1748	 * start to find the namespace objects and handle the events.
1749	 *
1750	 * Note: ec->handle can be valid if this function is called after
1751	 * acpi_ec_add(), hence the fast path.
1752	 */
1753	if (boot_ec->handle == ACPI_ROOT_OBJECT) {
1754		if (!acpi_ec_ecdt_get_handle(&handle))
1755			return -ENODEV;
1756		boot_ec->handle = handle;
 
 
 
1757	}
1758
1759	/* Register to ACPI bus with PM ops attached */
1760	return acpi_bus_register_early_device(ACPI_BUS_TYPE_ECDT_EC);
1761}
1762
1763#if 0
1764/*
1765 * Some EC firmware variations refuses to respond QR_EC when SCI_EVT is not
1766 * set, for which case, we complete the QR_EC without issuing it to the
1767 * firmware.
1768 * https://bugzilla.kernel.org/show_bug.cgi?id=82611
1769 * https://bugzilla.kernel.org/show_bug.cgi?id=97381
1770 */
1771static int ec_flag_query_handshake(const struct dmi_system_id *id)
1772{
1773	pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
1774	EC_FLAGS_QUERY_HANDSHAKE = 1;
1775	return 0;
1776}
1777#endif
1778
1779/*
1780 * On some hardware it is necessary to clear events accumulated by the EC during
1781 * sleep. These ECs stop reporting GPEs until they are manually polled, if too
1782 * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
1783 *
1784 * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1785 *
1786 * Ideally, the EC should also be instructed NOT to accumulate events during
1787 * sleep (which Windows seems to do somehow), but the interface to control this
1788 * behaviour is not known at this time.
1789 *
1790 * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
1791 * however it is very likely that other Samsung models are affected.
1792 *
1793 * On systems which don't accumulate _Q events during sleep, this extra check
1794 * should be harmless.
1795 */
1796static int ec_clear_on_resume(const struct dmi_system_id *id)
1797{
1798	pr_debug("Detected system needing EC poll on resume.\n");
1799	EC_FLAGS_CLEAR_ON_RESUME = 1;
1800	ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
1801	return 0;
1802}
1803
1804/*
1805 * Some ECDTs contain wrong register addresses.
1806 * MSI MS-171F
1807 * https://bugzilla.kernel.org/show_bug.cgi?id=12461
1808 */
1809static int ec_correct_ecdt(const struct dmi_system_id *id)
1810{
1811	pr_debug("Detected system needing ECDT address correction.\n");
1812	EC_FLAGS_CORRECT_ECDT = 1;
1813	return 0;
1814}
1815
1816/*
 
 
 
 
 
 
 
 
 
 
 
 
1817 * Some DSDTs contain wrong GPE setting.
1818 * Asus FX502VD/VE, GL702VMK, X550VXK, X580VD
1819 * https://bugzilla.kernel.org/show_bug.cgi?id=195651
1820 */
1821static int ec_honor_ecdt_gpe(const struct dmi_system_id *id)
1822{
1823	pr_debug("Detected system needing ignore DSDT GPE setting.\n");
1824	EC_FLAGS_IGNORE_DSDT_GPE = 1;
1825	return 0;
1826}
1827
1828static const struct dmi_system_id ec_dmi_table[] __initconst = {
1829	{
1830	ec_correct_ecdt, "MSI MS-171F", {
1831	DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star"),
1832	DMI_MATCH(DMI_PRODUCT_NAME, "MS-171F"),}, NULL},
1833	{
1834	ec_honor_ecdt_gpe, "ASUS FX502VD", {
1835	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1836	DMI_MATCH(DMI_PRODUCT_NAME, "FX502VD"),}, NULL},
1837	{
1838	ec_honor_ecdt_gpe, "ASUS FX502VE", {
1839	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1840	DMI_MATCH(DMI_PRODUCT_NAME, "FX502VE"),}, NULL},
1841	{
1842	ec_honor_ecdt_gpe, "ASUS GL702VMK", {
1843	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1844	DMI_MATCH(DMI_PRODUCT_NAME, "GL702VMK"),}, NULL},
1845	{
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1846	ec_honor_ecdt_gpe, "ASUS X550VXK", {
1847	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1848	DMI_MATCH(DMI_PRODUCT_NAME, "X550VXK"),}, NULL},
1849	{
1850	ec_honor_ecdt_gpe, "ASUS X580VD", {
1851	DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK COMPUTER INC."),
1852	DMI_MATCH(DMI_PRODUCT_NAME, "X580VD"),}, NULL},
1853	{
 
 
 
 
 
1854	ec_clear_on_resume, "Samsung hardware", {
1855	DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
1856	{},
1857};
1858
1859void __init acpi_ec_ecdt_probe(void)
1860{
1861	struct acpi_table_ecdt *ecdt_ptr;
1862	struct acpi_ec *ec;
1863	acpi_status status;
1864	int ret;
1865
1866	/* Generate a boot ec context. */
1867	dmi_check_system(ec_dmi_table);
1868	status = acpi_get_table(ACPI_SIG_ECDT, 1,
1869				(struct acpi_table_header **)&ecdt_ptr);
1870	if (ACPI_FAILURE(status))
1871		return;
1872
1873	if (!ecdt_ptr->control.address || !ecdt_ptr->data.address) {
1874		/*
1875		 * Asus X50GL:
1876		 * https://bugzilla.kernel.org/show_bug.cgi?id=11880
1877		 */
1878		return;
1879	}
1880
1881	ec = acpi_ec_alloc();
1882	if (!ec)
1883		return;
1884
1885	if (EC_FLAGS_CORRECT_ECDT) {
1886		ec->command_addr = ecdt_ptr->data.address;
1887		ec->data_addr = ecdt_ptr->control.address;
1888	} else {
1889		ec->command_addr = ecdt_ptr->control.address;
1890		ec->data_addr = ecdt_ptr->data.address;
1891	}
1892	ec->gpe = ecdt_ptr->gpe;
 
 
 
 
 
 
 
1893	ec->handle = ACPI_ROOT_OBJECT;
1894
1895	/*
1896	 * At this point, the namespace is not initialized, so do not find
1897	 * the namespace objects, or handle the events.
1898	 */
1899	ret = acpi_ec_setup(ec, false);
1900	if (ret) {
1901		acpi_ec_free(ec);
1902		return;
1903	}
1904
1905	boot_ec = ec;
1906	boot_ec_is_ecdt = true;
1907
1908	pr_info("Boot ECDT EC used to handle transactions\n");
 
 
 
1909}
1910
1911#ifdef CONFIG_PM_SLEEP
1912static int acpi_ec_suspend(struct device *dev)
1913{
1914	struct acpi_ec *ec =
1915		acpi_driver_data(to_acpi_device(dev));
1916
1917	if (!pm_suspend_no_platform() && ec_freeze_events)
1918		acpi_ec_disable_event(ec);
1919	return 0;
1920}
1921
1922static int acpi_ec_suspend_noirq(struct device *dev)
1923{
1924	struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1925
1926	/*
1927	 * The SCI handler doesn't run at this point, so the GPE can be
1928	 * masked at the low level without side effects.
1929	 */
1930	if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1931	    ec->reference_count >= 1)
1932		acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
1933
1934	acpi_ec_enter_noirq(ec);
1935
1936	return 0;
1937}
1938
1939static int acpi_ec_resume_noirq(struct device *dev)
1940{
1941	struct acpi_ec *ec = acpi_driver_data(to_acpi_device(dev));
1942
1943	acpi_ec_leave_noirq(ec);
1944
1945	if (ec_no_wakeup && test_bit(EC_FLAGS_STARTED, &ec->flags) &&
1946	    ec->reference_count >= 1)
1947		acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
1948
1949	return 0;
1950}
1951
1952static int acpi_ec_resume(struct device *dev)
1953{
1954	struct acpi_ec *ec =
1955		acpi_driver_data(to_acpi_device(dev));
1956
1957	acpi_ec_enable_event(ec);
1958	return 0;
1959}
1960
1961void acpi_ec_mark_gpe_for_wake(void)
1962{
1963	if (first_ec && !ec_no_wakeup)
1964		acpi_mark_gpe_for_wake(NULL, first_ec->gpe);
1965}
1966EXPORT_SYMBOL_GPL(acpi_ec_mark_gpe_for_wake);
1967
1968void acpi_ec_set_gpe_wake_mask(u8 action)
1969{
1970	if (pm_suspend_no_platform() && first_ec && !ec_no_wakeup)
1971		acpi_set_gpe_wake_mask(NULL, first_ec->gpe, action);
1972}
1973
1974bool acpi_ec_dispatch_gpe(void)
1975{
1976	u32 ret;
1977
1978	if (!first_ec)
1979		return false;
1980
1981	ret = acpi_dispatch_gpe(NULL, first_ec->gpe);
1982	if (ret == ACPI_INTERRUPT_HANDLED) {
1983		pm_pr_dbg("EC GPE dispatched\n");
 
 
1984		return true;
1985	}
 
 
 
 
 
 
 
 
 
 
 
1986	return false;
1987}
1988#endif /* CONFIG_PM_SLEEP */
1989
1990static const struct dev_pm_ops acpi_ec_pm = {
1991	SET_NOIRQ_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend_noirq, acpi_ec_resume_noirq)
1992	SET_SYSTEM_SLEEP_PM_OPS(acpi_ec_suspend, acpi_ec_resume)
1993};
1994
1995static int param_set_event_clearing(const char *val,
1996				    const struct kernel_param *kp)
1997{
1998	int result = 0;
1999
2000	if (!strncmp(val, "status", sizeof("status") - 1)) {
2001		ec_event_clearing = ACPI_EC_EVT_TIMING_STATUS;
2002		pr_info("Assuming SCI_EVT clearing on EC_SC accesses\n");
2003	} else if (!strncmp(val, "query", sizeof("query") - 1)) {
2004		ec_event_clearing = ACPI_EC_EVT_TIMING_QUERY;
2005		pr_info("Assuming SCI_EVT clearing on QR_EC writes\n");
2006	} else if (!strncmp(val, "event", sizeof("event") - 1)) {
2007		ec_event_clearing = ACPI_EC_EVT_TIMING_EVENT;
2008		pr_info("Assuming SCI_EVT clearing on event reads\n");
2009	} else
2010		result = -EINVAL;
2011	return result;
2012}
2013
2014static int param_get_event_clearing(char *buffer,
2015				    const struct kernel_param *kp)
2016{
2017	switch (ec_event_clearing) {
2018	case ACPI_EC_EVT_TIMING_STATUS:
2019		return sprintf(buffer, "status");
2020	case ACPI_EC_EVT_TIMING_QUERY:
2021		return sprintf(buffer, "query");
2022	case ACPI_EC_EVT_TIMING_EVENT:
2023		return sprintf(buffer, "event");
2024	default:
2025		return sprintf(buffer, "invalid");
2026	}
2027	return 0;
2028}
2029
2030module_param_call(ec_event_clearing, param_set_event_clearing, param_get_event_clearing,
2031		  NULL, 0644);
2032MODULE_PARM_DESC(ec_event_clearing, "Assumed SCI_EVT clearing timing");
2033
2034static struct acpi_driver acpi_ec_driver = {
2035	.name = "ec",
2036	.class = ACPI_EC_CLASS,
2037	.ids = ec_device_ids,
2038	.ops = {
2039		.add = acpi_ec_add,
2040		.remove = acpi_ec_remove,
2041		},
2042	.drv.pm = &acpi_ec_pm,
2043};
2044
2045static inline int acpi_ec_query_init(void)
2046{
2047	if (!ec_query_wq) {
2048		ec_query_wq = alloc_workqueue("kec_query", 0,
2049					      ec_max_queries);
2050		if (!ec_query_wq)
2051			return -ENODEV;
2052	}
2053	return 0;
2054}
2055
2056static inline void acpi_ec_query_exit(void)
2057{
2058	if (ec_query_wq) {
2059		destroy_workqueue(ec_query_wq);
2060		ec_query_wq = NULL;
2061	}
2062}
2063
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
2064static const struct dmi_system_id acpi_ec_no_wakeup[] = {
2065	{
2066		.ident = "Thinkpad X1 Carbon 6th",
2067		.matches = {
2068			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2069			DMI_MATCH(DMI_PRODUCT_FAMILY, "Thinkpad X1 Carbon 6th"),
2070		},
2071	},
2072	{
2073		.ident = "ThinkPad X1 Carbon 6th",
2074		.matches = {
2075			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2076			DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Carbon 6th"),
2077		},
2078	},
2079	{
2080		.ident = "ThinkPad X1 Yoga 3rd",
2081		.matches = {
2082			DMI_MATCH(DMI_SYS_VENDOR, "LENOVO"),
2083			DMI_MATCH(DMI_PRODUCT_FAMILY, "ThinkPad X1 Yoga 3rd"),
2084		},
2085	},
2086	{ },
2087};
2088
2089int __init acpi_ec_init(void)
2090{
2091	int result;
2092	int ecdt_fail, dsdt_fail;
2093
2094	/* register workqueue for _Qxx evaluations */
2095	result = acpi_ec_query_init();
2096	if (result)
2097		return result;
2098
2099	/*
2100	 * Disable EC wakeup on following systems to prevent periodic
2101	 * wakeup from EC GPE.
2102	 */
2103	if (dmi_check_system(acpi_ec_no_wakeup)) {
2104		ec_no_wakeup = true;
2105		pr_debug("Disabling EC wakeup on suspend-to-idle\n");
2106	}
2107
2108	/* Drivers must be started after acpi_ec_query_init() */
2109	dsdt_fail = acpi_bus_register_driver(&acpi_ec_driver);
2110	/*
2111	 * Register ECDT to ACPI bus only when PNP0C09 probe fails. This is
2112	 * useful for platforms (confirmed on ASUS X550ZE) with valid ECDT
2113	 * settings but invalid DSDT settings.
2114	 * https://bugzilla.kernel.org/show_bug.cgi?id=196847
2115	 */
2116	ecdt_fail = acpi_ec_ecdt_start();
2117	return ecdt_fail && dsdt_fail ? -ENODEV : 0;
2118}
2119
2120/* EC driver currently not unloadable */
2121#if 0
2122static void __exit acpi_ec_exit(void)
2123{
2124
2125	acpi_bus_unregister_driver(&acpi_ec_driver);
2126	acpi_ec_query_exit();
2127}
2128#endif	/* 0 */