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