drivers/acpi/ec.c

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