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