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  *  You should have received a copy of the GNU General Public License along
  26  *  with this program; if not, write to the Free Software Foundation, Inc.,
  27  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  28  *
  29  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  30  */
  31
  32 /* Uncomment next line to get verbose printout */
  33 /* #define DEBUG */
  34 #define pr_fmt(fmt) "ACPI : EC: " fmt
  35
  36 #include <linux/kernel.h>
  37 #include <linux/module.h>
  38 #include <linux/init.h>
  39 #include <linux/types.h>
  40 #include <linux/delay.h>
  41 #include <linux/interrupt.h>
  42 #include <linux/list.h>
  43 #include <linux/spinlock.h>
  44 #include <linux/slab.h>
  45 #include <linux/acpi.h>
  46 #include <linux/dmi.h>
  47 #include <asm/io.h>
  48
  49 #include "internal.h"
  50
  51 #define ACPI_EC_CLASS                   "embedded_controller"
  52 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
  53 #define ACPI_EC_FILE_INFO               "info"
  54
  55 /* EC status register */
  56 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
  57 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
  58 #define ACPI_EC_FLAG_CMD        0x08    /* Input buffer contains a command */
  59 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
  60 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
  61
  62 /* EC commands */
  63 enum ec_command {
  64         ACPI_EC_COMMAND_READ = 0x80,
  65         ACPI_EC_COMMAND_WRITE = 0x81,
  66         ACPI_EC_BURST_ENABLE = 0x82,
  67         ACPI_EC_BURST_DISABLE = 0x83,
  68         ACPI_EC_COMMAND_QUERY = 0x84,
  69 };
  70
  71 #define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
  72 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
  73 #define ACPI_EC_MSI_UDELAY      550     /* Wait 550us for MSI EC */
  74 #define ACPI_EC_UDELAY_POLL     1000    /* Wait 1ms for EC transaction polling */
  75 #define ACPI_EC_CLEAR_MAX       100     /* Maximum number of events to query
  76                                          * when trying to clear the EC */
  77
  78 enum {
  79         EC_FLAGS_QUERY_PENDING,         /* Query is pending */
  80         EC_FLAGS_HANDLERS_INSTALLED,    /* Handlers for GPE and
  81                                          * OpReg are installed */
  82         EC_FLAGS_STARTED,               /* Driver is started */
  83         EC_FLAGS_STOPPED,               /* Driver is stopped */
  84         EC_FLAGS_COMMAND_STORM,         /* GPE storms occurred to the
  85                                          * current command processing */
  86 };
  87
  88 #define ACPI_EC_COMMAND_POLL            0x01 /* Available for command byte */
  89 #define ACPI_EC_COMMAND_COMPLETE        0x02 /* Completed last byte */
  90
  91 /* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
  92 static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
  93 module_param(ec_delay, uint, 0644);
  94 MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
  95
  96 /*
  97  * If the number of false interrupts per one transaction exceeds
  98  * this threshold, will think there is a GPE storm happened and
  99  * will disable the GPE for normal transaction.
 100  */
 101 static unsigned int ec_storm_threshold  __read_mostly = 8;
 102 module_param(ec_storm_threshold, uint, 0644);
 103 MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
 104
 105 struct acpi_ec_query_handler {
 106         struct list_head node;
 107         acpi_ec_query_func func;
 108         acpi_handle handle;
 109         void *data;
 110         u8 query_bit;
 111         struct kref kref;
 112 };
 113
 114 struct transaction {
 115         const u8 *wdata;
 116         u8 *rdata;
 117         unsigned short irq_count;
 118         u8 command;
 119         u8 wi;
 120         u8 ri;
 121         u8 wlen;
 122         u8 rlen;
 123         u8 flags;
 124         unsigned long timestamp;
 125 };
 126
 127 static int acpi_ec_query(struct acpi_ec *ec, u8 *data);
 128 static void advance_transaction(struct acpi_ec *ec);
 129
 130 struct acpi_ec *boot_ec, *first_ec;
 131 EXPORT_SYMBOL(first_ec);
 132
 133 static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */
 134 static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */
 135 static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */
 136 static int EC_FLAGS_CLEAR_ON_RESUME; /* Needs acpi_ec_clear() on boot/resume */
 137 static int EC_FLAGS_QUERY_HANDSHAKE; /* Needs QR_EC issued when SCI_EVT set */
 138
 139 /* --------------------------------------------------------------------------
 140  *                           Logging/Debugging
 141  * -------------------------------------------------------------------------- */
 142
 143 /*
 144  * Splitters used by the developers to track the boundary of the EC
 145  * handling processes.
 146  */
 147 #ifdef DEBUG
 148 #define EC_DBG_SEP      " "
 149 #define EC_DBG_DRV      "+++++"
 150 #define EC_DBG_STM      "====="
 151 #define EC_DBG_REQ      "*****"
 152 #define EC_DBG_EVT      "#####"
 153 #else
 154 #define EC_DBG_SEP      ""
 155 #define EC_DBG_DRV
 156 #define EC_DBG_STM
 157 #define EC_DBG_REQ
 158 #define EC_DBG_EVT
 159 #endif
 160
 161 #define ec_log_raw(fmt, ...) \
 162         pr_info(fmt "\n", ##__VA_ARGS__)
 163 #define ec_dbg_raw(fmt, ...) \
 164         pr_debug(fmt "\n", ##__VA_ARGS__)
 165 #define ec_log(filter, fmt, ...) \
 166         ec_log_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
 167 #define ec_dbg(filter, fmt, ...) \
 168         ec_dbg_raw(filter EC_DBG_SEP fmt EC_DBG_SEP filter, ##__VA_ARGS__)
 169
 170 #define ec_log_drv(fmt, ...) \
 171         ec_log(EC_DBG_DRV, fmt, ##__VA_ARGS__)
 172 #define ec_dbg_drv(fmt, ...) \
 173         ec_dbg(EC_DBG_DRV, fmt, ##__VA_ARGS__)
 174 #define ec_dbg_stm(fmt, ...) \
 175         ec_dbg(EC_DBG_STM, fmt, ##__VA_ARGS__)
 176 #define ec_dbg_req(fmt, ...) \
 177         ec_dbg(EC_DBG_REQ, fmt, ##__VA_ARGS__)
 178 #define ec_dbg_evt(fmt, ...) \
 179         ec_dbg(EC_DBG_EVT, fmt, ##__VA_ARGS__)
 180 #define ec_dbg_ref(ec, fmt, ...) \
 181         ec_dbg_raw("%lu: " fmt, ec->reference_count, ## __VA_ARGS__)
 182
 183 /* --------------------------------------------------------------------------
 184  *                           Device Flags
 185  * -------------------------------------------------------------------------- */
 186
 187 static bool acpi_ec_started(struct acpi_ec *ec)
 188 {
 189         return test_bit(EC_FLAGS_STARTED, &ec->flags) &&
 190                !test_bit(EC_FLAGS_STOPPED, &ec->flags);
 191 }
 192
 193 static bool acpi_ec_flushed(struct acpi_ec *ec)
 194 {
 195         return ec->reference_count == 1;
 196 }
 197
 198 /* --------------------------------------------------------------------------
 199  *                           EC Registers
 200  * -------------------------------------------------------------------------- */
 201
 202 static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
 203 {
 204         u8 x = inb(ec->command_addr);
 205
 206         ec_dbg_raw("EC_SC(R) = 0x%2.2x "
 207                    "SCI_EVT=%d BURST=%d CMD=%d IBF=%d OBF=%d",
 208                    x,
 209                    !!(x & ACPI_EC_FLAG_SCI),
 210                    !!(x & ACPI_EC_FLAG_BURST),
 211                    !!(x & ACPI_EC_FLAG_CMD),
 212                    !!(x & ACPI_EC_FLAG_IBF),
 213                    !!(x & ACPI_EC_FLAG_OBF));
 214         return x;
 215 }
 216
 217 static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
 218 {
 219         u8 x = inb(ec->data_addr);
 220
 221         ec->curr->timestamp = jiffies;
 222         ec_dbg_raw("EC_DATA(R) = 0x%2.2x", x);
 223         return x;
 224 }
 225
 226 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
 227 {
 228         ec_dbg_raw("EC_SC(W) = 0x%2.2x", command);
 229         outb(command, ec->command_addr);
 230         ec->curr->timestamp = jiffies;
 231 }
 232
 233 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
 234 {
 235         ec_dbg_raw("EC_DATA(W) = 0x%2.2x", data);
 236         outb(data, ec->data_addr);
 237         ec->curr->timestamp = jiffies;
 238 }
 239
 240 #ifdef DEBUG
 241 static const char *acpi_ec_cmd_string(u8 cmd)
 242 {
 243         switch (cmd) {
 244         case 0x80:
 245                 return "RD_EC";
 246         case 0x81:
 247                 return "WR_EC";
 248         case 0x82:
 249                 return "BE_EC";
 250         case 0x83:
 251                 return "BD_EC";
 252         case 0x84:
 253                 return "QR_EC";
 254         }
 255         return "UNKNOWN";
 256 }
 257 #else
 258 #define acpi_ec_cmd_string(cmd)         "UNDEF"
 259 #endif
 260
 261 /* --------------------------------------------------------------------------
 262  *                           GPE Registers
 263  * -------------------------------------------------------------------------- */
 264
 265 static inline bool acpi_ec_is_gpe_raised(struct acpi_ec *ec)
 266 {
 267         acpi_event_status gpe_status = 0;
 268
 269         (void)acpi_get_gpe_status(NULL, ec->gpe, &gpe_status);
 270         return (gpe_status & ACPI_EVENT_FLAG_STATUS_SET) ? true : false;
 271 }
 272
 273 static inline void acpi_ec_enable_gpe(struct acpi_ec *ec, bool open)
 274 {
 275         if (open)
 276                 acpi_enable_gpe(NULL, ec->gpe);
 277         else {
 278                 BUG_ON(ec->reference_count < 1);
 279                 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_ENABLE);
 280         }
 281         if (acpi_ec_is_gpe_raised(ec)) {
 282                 /*
 283                  * On some platforms, EN=1 writes cannot trigger GPE. So
 284                  * software need to manually trigger a pseudo GPE event on
 285                  * EN=1 writes.
 286                  */
 287                 ec_dbg_raw("Polling quirk");
 288                 advance_transaction(ec);
 289         }
 290 }
 291
 292 static inline void acpi_ec_disable_gpe(struct acpi_ec *ec, bool close)
 293 {
 294         if (close)
 295                 acpi_disable_gpe(NULL, ec->gpe);
 296         else {
 297                 BUG_ON(ec->reference_count < 1);
 298                 acpi_set_gpe(NULL, ec->gpe, ACPI_GPE_DISABLE);
 299         }
 300 }
 301
 302 static inline void acpi_ec_clear_gpe(struct acpi_ec *ec)
 303 {
 304         /*
 305          * GPE STS is a W1C register, which means:
 306          * 1. Software can clear it without worrying about clearing other
 307          *    GPEs' STS bits when the hardware sets them in parallel.
 308          * 2. As long as software can ensure only clearing it when it is
 309          *    set, hardware won't set it in parallel.
 310          * So software can clear GPE in any contexts.
 311          * Warning: do not move the check into advance_transaction() as the
 312          * EC commands will be sent without GPE raised.
 313          */
 314         if (!acpi_ec_is_gpe_raised(ec))
 315                 return;
 316         acpi_clear_gpe(NULL, ec->gpe);
 317 }
 318
 319 /* --------------------------------------------------------------------------
 320  *                           Transaction Management
 321  * -------------------------------------------------------------------------- */
 322
 323 static void acpi_ec_submit_request(struct acpi_ec *ec)
 324 {
 325         ec->reference_count++;
 326         if (ec->reference_count == 1)
 327                 acpi_ec_enable_gpe(ec, true);
 328 }
 329
 330 static void acpi_ec_complete_request(struct acpi_ec *ec)
 331 {
 332         bool flushed = false;
 333
 334         ec->reference_count--;
 335         if (ec->reference_count == 0)
 336                 acpi_ec_disable_gpe(ec, true);
 337         flushed = acpi_ec_flushed(ec);
 338         if (flushed)
 339                 wake_up(&ec->wait);
 340 }
 341
 342 static void acpi_ec_set_storm(struct acpi_ec *ec, u8 flag)
 343 {
 344         if (!test_bit(flag, &ec->flags)) {
 345                 acpi_ec_disable_gpe(ec, false);
 346                 ec_dbg_drv("Polling enabled");
 347                 set_bit(flag, &ec->flags);
 348         }
 349 }
 350
 351 static void acpi_ec_clear_storm(struct acpi_ec *ec, u8 flag)
 352 {
 353         if (test_bit(flag, &ec->flags)) {
 354                 clear_bit(flag, &ec->flags);
 355                 acpi_ec_enable_gpe(ec, false);
 356                 ec_dbg_drv("Polling disabled");
 357         }
 358 }
 359
 360 /*
 361  * acpi_ec_submit_flushable_request() - Increase the reference count unless
 362  *                                      the flush operation is not in
 363  *                                      progress
 364  * @ec: the EC device
 365  *
 366  * This function must be used before taking a new action that should hold
 367  * the reference count.  If this function returns false, then the action
 368  * must be discarded or it will prevent the flush operation from being
 369  * completed.
 370  */
 371 static bool acpi_ec_submit_flushable_request(struct acpi_ec *ec)
 372 {
 373         if (!acpi_ec_started(ec))
 374                 return false;
 375         acpi_ec_submit_request(ec);
 376         return true;
 377 }
 378
 379 static void acpi_ec_submit_query(struct acpi_ec *ec)
 380 {
 381         if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
 382                 ec_dbg_req("Event started");
 383                 schedule_work(&ec->work);
 384         }
 385 }
 386
 387 static void acpi_ec_complete_query(struct acpi_ec *ec)
 388 {
 389         if (ec->curr->command == ACPI_EC_COMMAND_QUERY) {
 390                 clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
 391                 ec_dbg_req("Event stopped");
 392         }
 393 }
 394
 395 static int ec_transaction_completed(struct acpi_ec *ec)
 396 {
 397         unsigned long flags;
 398         int ret = 0;
 399
 400         spin_lock_irqsave(&ec->lock, flags);
 401         if (ec->curr && (ec->curr->flags & ACPI_EC_COMMAND_COMPLETE))
 402                 ret = 1;
 403         spin_unlock_irqrestore(&ec->lock, flags);
 404         return ret;
 405 }
 406
 407 static void advance_transaction(struct acpi_ec *ec)
 408 {
 409         struct transaction *t;
 410         u8 status;
 411         bool wakeup = false;
 412
 413         ec_dbg_stm("%s (%d)", in_interrupt() ? "IRQ" : "TASK",
 414                    smp_processor_id());
 415         /*
 416          * By always clearing STS before handling all indications, we can
 417          * ensure a hardware STS 0->1 change after this clearing can always
 418          * trigger a GPE interrupt.
 419          */
 420         acpi_ec_clear_gpe(ec);
 421         status = acpi_ec_read_status(ec);
 422         t = ec->curr;
 423         if (!t)
 424                 goto err;
 425         if (t->flags & ACPI_EC_COMMAND_POLL) {
 426                 if (t->wlen > t->wi) {
 427                         if ((status & ACPI_EC_FLAG_IBF) == 0)
 428                                 acpi_ec_write_data(ec, t->wdata[t->wi++]);
 429                         else
 430                                 goto err;
 431                 } else if (t->rlen > t->ri) {
 432                         if ((status & ACPI_EC_FLAG_OBF) == 1) {
 433                                 t->rdata[t->ri++] = acpi_ec_read_data(ec);
 434                                 if (t->rlen == t->ri) {
 435                                         t->flags |= ACPI_EC_COMMAND_COMPLETE;
 436                                         if (t->command == ACPI_EC_COMMAND_QUERY)
 437                                                 ec_dbg_req("Command(%s) hardware completion",
 438                                                            acpi_ec_cmd_string(t->command));
 439                                         wakeup = true;
 440                                 }
 441                         } else
 442                                 goto err;
 443                 } else if (t->wlen == t->wi &&
 444                            (status & ACPI_EC_FLAG_IBF) == 0) {
 445                         t->flags |= ACPI_EC_COMMAND_COMPLETE;
 446                         wakeup = true;
 447                 }
 448                 goto out;
 449         } else {
 450                 if (EC_FLAGS_QUERY_HANDSHAKE &&
 451                     !(status & ACPI_EC_FLAG_SCI) &&
 452                     (t->command == ACPI_EC_COMMAND_QUERY)) {
 453                         t->flags |= ACPI_EC_COMMAND_POLL;
 454                         acpi_ec_complete_query(ec);
 455                         t->rdata[t->ri++] = 0x00;
 456                         t->flags |= ACPI_EC_COMMAND_COMPLETE;
 457                         ec_dbg_req("Command(%s) software completion",
 458                                    acpi_ec_cmd_string(t->command));
 459                         wakeup = true;
 460                 } else if ((status & ACPI_EC_FLAG_IBF) == 0) {
 461                         acpi_ec_write_cmd(ec, t->command);
 462                         t->flags |= ACPI_EC_COMMAND_POLL;
 463                         acpi_ec_complete_query(ec);
 464                 } else
 465                         goto err;
 466                 goto out;
 467         }
 468 err:
 469         /*
 470          * If SCI bit is set, then don't think it's a false IRQ
 471          * otherwise will take a not handled IRQ as a false one.
 472          */
 473         if (!(status & ACPI_EC_FLAG_SCI)) {
 474                 if (in_interrupt() && t) {
 475                         if (t->irq_count < ec_storm_threshold)
 476                                 ++t->irq_count;
 477                         /* Allow triggering on 0 threshold */
 478                         if (t->irq_count == ec_storm_threshold)
 479                                 acpi_ec_set_storm(ec, EC_FLAGS_COMMAND_STORM);
 480                 }
 481         }
 482 out:
 483         if (status & ACPI_EC_FLAG_SCI)
 484                 acpi_ec_submit_query(ec);
 485         if (wakeup && in_interrupt())
 486                 wake_up(&ec->wait);
 487 }
 488
 489 static void start_transaction(struct acpi_ec *ec)
 490 {
 491         ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
 492         ec->curr->flags = 0;
 493         ec->curr->timestamp = jiffies;
 494         advance_transaction(ec);
 495 }
 496
 497 static int ec_poll(struct acpi_ec *ec)
 498 {
 499         unsigned long flags;
 500         int repeat = 5; /* number of command restarts */
 501
 502         while (repeat--) {
 503                 unsigned long delay = jiffies +
 504                         msecs_to_jiffies(ec_delay);
 505                 unsigned long usecs = ACPI_EC_UDELAY_POLL;
 506                 do {
 507                         if (EC_FLAGS_MSI) {
 508                                 usecs = ACPI_EC_MSI_UDELAY;
 509                                 udelay(usecs);
 510                                 if (ec_transaction_completed(ec))
 511                                         return 0;
 512                         } else {
 513                                 if (wait_event_timeout(ec->wait,
 514                                                 ec_transaction_completed(ec),
 515                                                 usecs_to_jiffies(usecs)))
 516                                         return 0;
 517                         }
 518                         spin_lock_irqsave(&ec->lock, flags);
 519                         if (time_after(jiffies,
 520                                         ec->curr->timestamp +
 521                                         usecs_to_jiffies(usecs)))
 522                                 advance_transaction(ec);
 523                         spin_unlock_irqrestore(&ec->lock, flags);
 524                 } while (time_before(jiffies, delay));
 525                 pr_debug("controller reset, restart transaction\n");
 526                 spin_lock_irqsave(&ec->lock, flags);
 527                 start_transaction(ec);
 528                 spin_unlock_irqrestore(&ec->lock, flags);
 529         }
 530         return -ETIME;
 531 }
 532
 533 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
 534                                         struct transaction *t)
 535 {
 536         unsigned long tmp;
 537         int ret = 0;
 538
 539         if (EC_FLAGS_MSI)
 540                 udelay(ACPI_EC_MSI_UDELAY);
 541         /* start transaction */
 542         spin_lock_irqsave(&ec->lock, tmp);
 543         /* Enable GPE for command processing (IBF=0/OBF=1) */
 544         if (!acpi_ec_submit_flushable_request(ec)) {
 545                 ret = -EINVAL;
 546                 goto unlock;
 547         }
 548         ec_dbg_ref(ec, "Increase command");
 549         /* following two actions should be kept atomic */
 550         ec->curr = t;
 551         ec_dbg_req("Command(%s) started", acpi_ec_cmd_string(t->command));
 552         start_transaction(ec);
 553         spin_unlock_irqrestore(&ec->lock, tmp);
 554         ret = ec_poll(ec);
 555         spin_lock_irqsave(&ec->lock, tmp);
 556         if (t->irq_count == ec_storm_threshold)
 557                 acpi_ec_clear_storm(ec, EC_FLAGS_COMMAND_STORM);
 558         ec_dbg_req("Command(%s) stopped", acpi_ec_cmd_string(t->command));
 559         ec->curr = NULL;
 560         /* Disable GPE for command processing (IBF=0/OBF=1) */
 561         acpi_ec_complete_request(ec);
 562         ec_dbg_ref(ec, "Decrease command");
 563 unlock:
 564         spin_unlock_irqrestore(&ec->lock, tmp);
 565         return ret;
 566 }
 567
 568 static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
 569 {
 570         int status;
 571         u32 glk;
 572
 573         if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
 574                 return -EINVAL;
 575         if (t->rdata)
 576                 memset(t->rdata, 0, t->rlen);
 577         mutex_lock(&ec->mutex);
 578         if (ec->global_lock) {
 579                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 580                 if (ACPI_FAILURE(status)) {
 581                         status = -ENODEV;
 582                         goto unlock;
 583                 }
 584         }
 585
 586         status = acpi_ec_transaction_unlocked(ec, t);
 587
 588         if (test_bit(EC_FLAGS_COMMAND_STORM, &ec->flags))
 589                 msleep(1);
 590         if (ec->global_lock)
 591                 acpi_release_global_lock(glk);
 592 unlock:
 593         mutex_unlock(&ec->mutex);
 594         return status;
 595 }
 596
 597 static int acpi_ec_burst_enable(struct acpi_ec *ec)
 598 {
 599         u8 d;
 600         struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
 601                                 .wdata = NULL, .rdata = &d,
 602                                 .wlen = 0, .rlen = 1};
 603
 604         return acpi_ec_transaction(ec, &t);
 605 }
 606
 607 static int acpi_ec_burst_disable(struct acpi_ec *ec)
 608 {
 609         struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
 610                                 .wdata = NULL, .rdata = NULL,
 611                                 .wlen = 0, .rlen = 0};
 612
 613         return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
 614                                 acpi_ec_transaction(ec, &t) : 0;
 615 }
 616
 617 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
 618 {
 619         int result;
 620         u8 d;
 621         struct transaction t = {.command = ACPI_EC_COMMAND_READ,
 622                                 .wdata = &address, .rdata = &d,
 623                                 .wlen = 1, .rlen = 1};
 624
 625         result = acpi_ec_transaction(ec, &t);
 626         *data = d;
 627         return result;
 628 }
 629
 630 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
 631 {
 632         u8 wdata[2] = { address, data };
 633         struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
 634                                 .wdata = wdata, .rdata = NULL,
 635                                 .wlen = 2, .rlen = 0};
 636
 637         return acpi_ec_transaction(ec, &t);
 638 }
 639
 640 int ec_read(u8 addr, u8 *val)
 641 {
 642         int err;
 643         u8 temp_data;
 644
 645         if (!first_ec)
 646                 return -ENODEV;
 647
 648         err = acpi_ec_read(first_ec, addr, &temp_data);
 649
 650         if (!err) {
 651                 *val = temp_data;
 652                 return 0;
 653         }
 654         return err;
 655 }
 656 EXPORT_SYMBOL(ec_read);
 657
 658 int ec_write(u8 addr, u8 val)
 659 {
 660         int err;
 661
 662         if (!first_ec)
 663                 return -ENODEV;
 664
 665         err = acpi_ec_write(first_ec, addr, val);
 666
 667         return err;
 668 }
 669 EXPORT_SYMBOL(ec_write);
 670
 671 int ec_transaction(u8 command,
 672                    const u8 *wdata, unsigned wdata_len,
 673                    u8 *rdata, unsigned rdata_len)
 674 {
 675         struct transaction t = {.command = command,
 676                                 .wdata = wdata, .rdata = rdata,
 677                                 .wlen = wdata_len, .rlen = rdata_len};
 678
 679         if (!first_ec)
 680                 return -ENODEV;
 681
 682         return acpi_ec_transaction(first_ec, &t);
 683 }
 684 EXPORT_SYMBOL(ec_transaction);
 685
 686 /* Get the handle to the EC device */
 687 acpi_handle ec_get_handle(void)
 688 {
 689         if (!first_ec)
 690                 return NULL;
 691         return first_ec->handle;
 692 }
 693 EXPORT_SYMBOL(ec_get_handle);
 694
 695 /*
 696  * Process _Q events that might have accumulated in the EC.
 697  * Run with locked ec mutex.
 698  */
 699 static void acpi_ec_clear(struct acpi_ec *ec)
 700 {
 701         int i, status;
 702         u8 value = 0;
 703
 704         for (i = 0; i < ACPI_EC_CLEAR_MAX; i++) {
 705                 status = acpi_ec_query(ec, &value);
 706                 if (status || !value)
 707                         break;
 708         }
 709
 710         if (unlikely(i == ACPI_EC_CLEAR_MAX))
 711                 pr_warn("Warning: Maximum of %d stale EC events cleared\n", i);
 712         else
 713                 pr_info("%d stale EC events cleared\n", i);
 714 }
 715
 716 static void acpi_ec_start(struct acpi_ec *ec, bool resuming)
 717 {
 718         unsigned long flags;
 719
 720         spin_lock_irqsave(&ec->lock, flags);
 721         if (!test_and_set_bit(EC_FLAGS_STARTED, &ec->flags)) {
 722                 ec_dbg_drv("Starting EC");
 723                 /* Enable GPE for event processing (SCI_EVT=1) */
 724                 if (!resuming) {
 725                         acpi_ec_submit_request(ec);
 726                         ec_dbg_ref(ec, "Increase driver");
 727                 }
 728                 ec_log_drv("EC started");
 729         }
 730         spin_unlock_irqrestore(&ec->lock, flags);
 731 }
 732
 733 static bool acpi_ec_stopped(struct acpi_ec *ec)
 734 {
 735         unsigned long flags;
 736         bool flushed;
 737
 738         spin_lock_irqsave(&ec->lock, flags);
 739         flushed = acpi_ec_flushed(ec);
 740         spin_unlock_irqrestore(&ec->lock, flags);
 741         return flushed;
 742 }
 743
 744 static void acpi_ec_stop(struct acpi_ec *ec, bool suspending)
 745 {
 746         unsigned long flags;
 747
 748         spin_lock_irqsave(&ec->lock, flags);
 749         if (acpi_ec_started(ec)) {
 750                 ec_dbg_drv("Stopping EC");
 751                 set_bit(EC_FLAGS_STOPPED, &ec->flags);
 752                 spin_unlock_irqrestore(&ec->lock, flags);
 753                 wait_event(ec->wait, acpi_ec_stopped(ec));
 754                 spin_lock_irqsave(&ec->lock, flags);
 755                 /* Disable GPE for event processing (SCI_EVT=1) */
 756                 if (!suspending) {
 757                         acpi_ec_complete_request(ec);
 758                         ec_dbg_ref(ec, "Decrease driver");
 759                 }
 760                 clear_bit(EC_FLAGS_STARTED, &ec->flags);
 761                 clear_bit(EC_FLAGS_STOPPED, &ec->flags);
 762                 ec_log_drv("EC stopped");
 763         }
 764         spin_unlock_irqrestore(&ec->lock, flags);
 765 }
 766
 767 void acpi_ec_block_transactions(void)
 768 {
 769         struct acpi_ec *ec = first_ec;
 770
 771         if (!ec)
 772                 return;
 773
 774         mutex_lock(&ec->mutex);
 775         /* Prevent transactions from being carried out */
 776         acpi_ec_stop(ec, true);
 777         mutex_unlock(&ec->mutex);
 778 }
 779
 780 void acpi_ec_unblock_transactions(void)
 781 {
 782         struct acpi_ec *ec = first_ec;
 783
 784         if (!ec)
 785                 return;
 786
 787         /* Allow transactions to be carried out again */
 788         acpi_ec_start(ec, true);
 789
 790         if (EC_FLAGS_CLEAR_ON_RESUME)
 791                 acpi_ec_clear(ec);
 792 }
 793
 794 void acpi_ec_unblock_transactions_early(void)
 795 {
 796         /*
 797          * Allow transactions to happen again (this function is called from
 798          * atomic context during wakeup, so we don't need to acquire the mutex).
 799          */
 800         if (first_ec)
 801                 acpi_ec_start(first_ec, true);
 802 }
 803
 804 /* --------------------------------------------------------------------------
 805                                 Event Management
 806    -------------------------------------------------------------------------- */
 807 static struct acpi_ec_query_handler *
 808 acpi_ec_get_query_handler(struct acpi_ec_query_handler *handler)
 809 {
 810         if (handler)
 811                 kref_get(&handler->kref);
 812         return handler;
 813 }
 814
 815 static void acpi_ec_query_handler_release(struct kref *kref)
 816 {
 817         struct acpi_ec_query_handler *handler =
 818                 container_of(kref, struct acpi_ec_query_handler, kref);
 819
 820         kfree(handler);
 821 }
 822
 823 static void acpi_ec_put_query_handler(struct acpi_ec_query_handler *handler)
 824 {
 825         kref_put(&handler->kref, acpi_ec_query_handler_release);
 826 }
 827
 828 int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
 829                               acpi_handle handle, acpi_ec_query_func func,
 830                               void *data)
 831 {
 832         struct acpi_ec_query_handler *handler =
 833             kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
 834
 835         if (!handler)
 836                 return -ENOMEM;
 837
 838         handler->query_bit = query_bit;
 839         handler->handle = handle;
 840         handler->func = func;
 841         handler->data = data;
 842         mutex_lock(&ec->mutex);
 843         kref_init(&handler->kref);
 844         list_add(&handler->node, &ec->list);
 845         mutex_unlock(&ec->mutex);
 846         return 0;
 847 }
 848 EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
 849
 850 void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
 851 {
 852         struct acpi_ec_query_handler *handler, *tmp;
 853         LIST_HEAD(free_list);
 854
 855         mutex_lock(&ec->mutex);
 856         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
 857                 if (query_bit == handler->query_bit) {
 858                         list_del_init(&handler->node);
 859                         list_add(&handler->node, &free_list);
 860                 }
 861         }
 862         mutex_unlock(&ec->mutex);
 863         list_for_each_entry_safe(handler, tmp, &free_list, node)
 864                 acpi_ec_put_query_handler(handler);
 865 }
 866 EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
 867
 868 static void acpi_ec_run(void *cxt)
 869 {
 870         struct acpi_ec_query_handler *handler = cxt;
 871
 872         if (!handler)
 873                 return;
 874         ec_dbg_evt("Query(0x%02x) started", handler->query_bit);
 875         if (handler->func)
 876                 handler->func(handler->data);
 877         else if (handler->handle)
 878                 acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
 879         ec_dbg_evt("Query(0x%02x) stopped", handler->query_bit);
 880         acpi_ec_put_query_handler(handler);
 881 }
 882
 883 static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
 884 {
 885         u8 value = 0;
 886         int result;
 887         acpi_status status;
 888         struct acpi_ec_query_handler *handler;
 889         struct transaction t = {.command = ACPI_EC_COMMAND_QUERY,
 890                                 .wdata = NULL, .rdata = &value,
 891                                 .wlen = 0, .rlen = 1};
 892
 893         /*
 894          * Query the EC to find out which _Qxx method we need to evaluate.
 895          * Note that successful completion of the query causes the ACPI_EC_SCI
 896          * bit to be cleared (and thus clearing the interrupt source).
 897          */
 898         result = acpi_ec_transaction(ec, &t);
 899         if (result)
 900                 return result;
 901         if (data)
 902                 *data = value;
 903         if (!value)
 904                 return -ENODATA;
 905
 906         mutex_lock(&ec->mutex);
 907         list_for_each_entry(handler, &ec->list, node) {
 908                 if (value == handler->query_bit) {
 909                         /* have custom handler for this bit */
 910                         handler = acpi_ec_get_query_handler(handler);
 911                         ec_dbg_evt("Query(0x%02x) scheduled",
 912                                    handler->query_bit);
 913                         status = acpi_os_execute((handler->func) ?
 914                                 OSL_NOTIFY_HANDLER : OSL_GPE_HANDLER,
 915                                 acpi_ec_run, handler);
 916                         if (ACPI_FAILURE(status))
 917                                 result = -EBUSY;
 918                         break;
 919                 }
 920         }
 921         mutex_unlock(&ec->mutex);
 922         return result;
 923 }
 924
 925 static void acpi_ec_gpe_poller(struct work_struct *work)
 926 {
 927         struct acpi_ec *ec = container_of(work, struct acpi_ec, work);
 928
 929         acpi_ec_query(ec, NULL);
 930 }
 931
 932 static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
 933         u32 gpe_number, void *data)
 934 {
 935         unsigned long flags;
 936         struct acpi_ec *ec = data;
 937
 938         spin_lock_irqsave(&ec->lock, flags);
 939         advance_transaction(ec);
 940         spin_unlock_irqrestore(&ec->lock, flags);
 941         return ACPI_INTERRUPT_HANDLED;
 942 }
 943
 944 /* --------------------------------------------------------------------------
 945  *                           Address Space Management
 946  * -------------------------------------------------------------------------- */
 947
 948 static acpi_status
 949 acpi_ec_space_handler(u32 function, acpi_physical_address address,
 950                       u32 bits, u64 *value64,
 951                       void *handler_context, void *region_context)
 952 {
 953         struct acpi_ec *ec = handler_context;
 954         int result = 0, i, bytes = bits / 8;
 955         u8 *value = (u8 *)value64;
 956
 957         if ((address > 0xFF) || !value || !handler_context)
 958                 return AE_BAD_PARAMETER;
 959
 960         if (function != ACPI_READ && function != ACPI_WRITE)
 961                 return AE_BAD_PARAMETER;
 962
 963         if (EC_FLAGS_MSI || bits > 8)
 964                 acpi_ec_burst_enable(ec);
 965
 966         for (i = 0; i < bytes; ++i, ++address, ++value)
 967                 result = (function == ACPI_READ) ?
 968                         acpi_ec_read(ec, address, value) :
 969                         acpi_ec_write(ec, address, *value);
 970
 971         if (EC_FLAGS_MSI || bits > 8)
 972                 acpi_ec_burst_disable(ec);
 973
 974         switch (result) {
 975         case -EINVAL:
 976                 return AE_BAD_PARAMETER;
 977         case -ENODEV:
 978                 return AE_NOT_FOUND;
 979         case -ETIME:
 980                 return AE_TIME;
 981         default:
 982                 return AE_OK;
 983         }
 984 }
 985
 986 /* --------------------------------------------------------------------------
 987  *                             Driver Interface
 988  * -------------------------------------------------------------------------- */
 989
 990 static acpi_status
 991 ec_parse_io_ports(struct acpi_resource *resource, void *context);
 992
 993 static struct acpi_ec *make_acpi_ec(void)
 994 {
 995         struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
 996
 997         if (!ec)
 998                 return NULL;
 999         ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
1000         mutex_init(&ec->mutex);
1001         init_waitqueue_head(&ec->wait);
1002         INIT_LIST_HEAD(&ec->list);
1003         spin_lock_init(&ec->lock);
1004         INIT_WORK(&ec->work, acpi_ec_gpe_poller);
1005         return ec;
1006 }
1007
1008 static acpi_status
1009 acpi_ec_register_query_methods(acpi_handle handle, u32 level,
1010                                void *context, void **return_value)
1011 {
1012         char node_name[5];
1013         struct acpi_buffer buffer = { sizeof(node_name), node_name };
1014         struct acpi_ec *ec = context;
1015         int value = 0;
1016         acpi_status status;
1017
1018         status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
1019
1020         if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1)
1021                 acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
1022         return AE_OK;
1023 }
1024
1025 static acpi_status
1026 ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
1027 {
1028         acpi_status status;
1029         unsigned long long tmp = 0;
1030         struct acpi_ec *ec = context;
1031
1032         /* clear addr values, ec_parse_io_ports depend on it */
1033         ec->command_addr = ec->data_addr = 0;
1034
1035         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1036                                      ec_parse_io_ports, ec);
1037         if (ACPI_FAILURE(status))
1038                 return status;
1039
1040         /* Get GPE bit assignment (EC events). */
1041         /* TODO: Add support for _GPE returning a package */
1042         status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
1043         if (ACPI_FAILURE(status))
1044                 return status;
1045         ec->gpe = tmp;
1046         /* Use the global lock for all EC transactions? */
1047         tmp = 0;
1048         acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
1049         ec->global_lock = tmp;
1050         ec->handle = handle;
1051         return AE_CTRL_TERMINATE;
1052 }
1053
1054 static int ec_install_handlers(struct acpi_ec *ec)
1055 {
1056         acpi_status status;
1057
1058         if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
1059                 return 0;
1060         status = acpi_install_gpe_raw_handler(NULL, ec->gpe,
1061                                   ACPI_GPE_EDGE_TRIGGERED,
1062                                   &acpi_ec_gpe_handler, ec);
1063         if (ACPI_FAILURE(status))
1064                 return -ENODEV;
1065
1066         acpi_ec_start(ec, false);
1067         status = acpi_install_address_space_handler(ec->handle,
1068                                                     ACPI_ADR_SPACE_EC,
1069                                                     &acpi_ec_space_handler,
1070                                                     NULL, ec);
1071         if (ACPI_FAILURE(status)) {
1072                 if (status == AE_NOT_FOUND) {
1073                         /*
1074                          * Maybe OS fails in evaluating the _REG object.
1075                          * The AE_NOT_FOUND error will be ignored and OS
1076                          * continue to initialize EC.
1077                          */
1078                         pr_err("Fail in evaluating the _REG object"
1079                                 " of EC device. Broken bios is suspected.\n");
1080                 } else {
1081                         acpi_ec_stop(ec, false);
1082                         acpi_remove_gpe_handler(NULL, ec->gpe,
1083                                 &acpi_ec_gpe_handler);
1084                         return -ENODEV;
1085                 }
1086         }
1087
1088         set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
1089         return 0;
1090 }
1091
1092 static void ec_remove_handlers(struct acpi_ec *ec)
1093 {
1094         if (!test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
1095                 return;
1096         acpi_ec_stop(ec, false);
1097         if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
1098                                 ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
1099                 pr_err("failed to remove space handler\n");
1100         if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
1101                                 &acpi_ec_gpe_handler)))
1102                 pr_err("failed to remove gpe handler\n");
1103         clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
1104 }
1105
1106 static int acpi_ec_add(struct acpi_device *device)
1107 {
1108         struct acpi_ec *ec = NULL;
1109         int ret;
1110
1111         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1112         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1113
1114         /* Check for boot EC */
1115         if (boot_ec &&
1116             (boot_ec->handle == device->handle ||
1117              boot_ec->handle == ACPI_ROOT_OBJECT)) {
1118                 ec = boot_ec;
1119                 boot_ec = NULL;
1120         } else {
1121                 ec = make_acpi_ec();
1122                 if (!ec)
1123                         return -ENOMEM;
1124         }
1125         if (ec_parse_device(device->handle, 0, ec, NULL) !=
1126                 AE_CTRL_TERMINATE) {
1127                         kfree(ec);
1128                         return -EINVAL;
1129         }
1130
1131         /* Find and register all query methods */
1132         acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
1133                             acpi_ec_register_query_methods, NULL, ec, NULL);
1134
1135         if (!first_ec)
1136                 first_ec = ec;
1137         device->driver_data = ec;
1138
1139         ret = !!request_region(ec->data_addr, 1, "EC data");
1140         WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
1141         ret = !!request_region(ec->command_addr, 1, "EC cmd");
1142         WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
1143
1144         pr_info("GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
1145                           ec->gpe, ec->command_addr, ec->data_addr);
1146
1147         ret = ec_install_handlers(ec);
1148
1149         /* Reprobe devices depending on the EC */
1150         acpi_walk_dep_device_list(ec->handle);
1151
1152         /* EC is fully operational, allow queries */
1153         clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
1154
1155         /* Clear stale _Q events if hardware might require that */
1156         if (EC_FLAGS_CLEAR_ON_RESUME)
1157                 acpi_ec_clear(ec);
1158         return ret;
1159 }
1160
1161 static int acpi_ec_remove(struct acpi_device *device)
1162 {
1163         struct acpi_ec *ec;
1164         struct acpi_ec_query_handler *handler, *tmp;
1165
1166         if (!device)
1167                 return -EINVAL;
1168
1169         ec = acpi_driver_data(device);
1170         ec_remove_handlers(ec);
1171         mutex_lock(&ec->mutex);
1172         list_for_each_entry_safe(handler, tmp, &ec->list, node) {
1173                 list_del(&handler->node);
1174                 kfree(handler);
1175         }
1176         mutex_unlock(&ec->mutex);
1177         release_region(ec->data_addr, 1);
1178         release_region(ec->command_addr, 1);
1179         device->driver_data = NULL;
1180         if (ec == first_ec)
1181                 first_ec = NULL;
1182         kfree(ec);
1183         return 0;
1184 }
1185
1186 static acpi_status
1187 ec_parse_io_ports(struct acpi_resource *resource, void *context)
1188 {
1189         struct acpi_ec *ec = context;
1190
1191         if (resource->type != ACPI_RESOURCE_TYPE_IO)
1192                 return AE_OK;
1193
1194         /*
1195          * The first address region returned is the data port, and
1196          * the second address region returned is the status/command
1197          * port.
1198          */
1199         if (ec->data_addr == 0)
1200                 ec->data_addr = resource->data.io.minimum;
1201         else if (ec->command_addr == 0)
1202                 ec->command_addr = resource->data.io.minimum;
1203         else
1204                 return AE_CTRL_TERMINATE;
1205
1206         return AE_OK;
1207 }
1208
1209 int __init acpi_boot_ec_enable(void)
1210 {
1211         if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
1212                 return 0;
1213         if (!ec_install_handlers(boot_ec)) {
1214                 first_ec = boot_ec;
1215                 return 0;
1216         }
1217         return -EFAULT;
1218 }
1219
1220 static const struct acpi_device_id ec_device_ids[] = {
1221         {"PNP0C09", 0},
1222         {"", 0},
1223 };
1224
1225 /* Some BIOS do not survive early DSDT scan, skip it */
1226 static int ec_skip_dsdt_scan(const struct dmi_system_id *id)
1227 {
1228         EC_FLAGS_SKIP_DSDT_SCAN = 1;
1229         return 0;
1230 }
1231
1232 /* ASUStek often supplies us with broken ECDT, validate it */
1233 static int ec_validate_ecdt(const struct dmi_system_id *id)
1234 {
1235         EC_FLAGS_VALIDATE_ECDT = 1;
1236         return 0;
1237 }
1238
1239 /* MSI EC needs special treatment, enable it */
1240 static int ec_flag_msi(const struct dmi_system_id *id)
1241 {
1242         pr_debug("Detected MSI hardware, enabling workarounds.\n");
1243         EC_FLAGS_MSI = 1;
1244         EC_FLAGS_VALIDATE_ECDT = 1;
1245         return 0;
1246 }
1247
1248 /*
1249  * Acer EC firmware refuses to respond QR_EC when SCI_EVT is not set, for
1250  * which case, we complete the QR_EC without issuing it to the firmware.
1251  * https://bugzilla.kernel.org/show_bug.cgi?id=86211
1252  */
1253 static int ec_flag_query_handshake(const struct dmi_system_id *id)
1254 {
1255         pr_debug("Detected the EC firmware requiring QR_EC issued when SCI_EVT set\n");
1256         EC_FLAGS_QUERY_HANDSHAKE = 1;
1257         return 0;
1258 }
1259
1260 /*
1261  * On some hardware it is necessary to clear events accumulated by the EC during
1262  * sleep. These ECs stop reporting GPEs until they are manually polled, if too
1263  * many events are accumulated. (e.g. Samsung Series 5/9 notebooks)
1264  *
1265  * https://bugzilla.kernel.org/show_bug.cgi?id=44161
1266  *
1267  * Ideally, the EC should also be instructed NOT to accumulate events during
1268  * sleep (which Windows seems to do somehow), but the interface to control this
1269  * behaviour is not known at this time.
1270  *
1271  * Models known to be affected are Samsung 530Uxx/535Uxx/540Uxx/550Pxx/900Xxx,
1272  * however it is very likely that other Samsung models are affected.
1273  *
1274  * On systems which don't accumulate _Q events during sleep, this extra check
1275  * should be harmless.
1276  */
1277 static int ec_clear_on_resume(const struct dmi_system_id *id)
1278 {
1279         pr_debug("Detected system needing EC poll on resume.\n");
1280         EC_FLAGS_CLEAR_ON_RESUME = 1;
1281         return 0;
1282 }
1283
1284 static struct dmi_system_id ec_dmi_table[] __initdata = {
1285         {
1286         ec_skip_dsdt_scan, "Compal JFL92", {
1287         DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
1288         DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL},
1289         {
1290         ec_flag_msi, "MSI hardware", {
1291         DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star")}, NULL},
1292         {
1293         ec_flag_msi, "MSI hardware", {
1294         DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star")}, NULL},
1295         {
1296         ec_flag_msi, "MSI hardware", {
1297         DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star")}, NULL},
1298         {
1299         ec_flag_msi, "MSI hardware", {
1300         DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL},
1301         {
1302         ec_flag_msi, "Quanta hardware", {
1303         DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
1304         DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL},
1305         {
1306         ec_flag_msi, "Quanta hardware", {
1307         DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
1308         DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL},
1309         {
1310         ec_flag_msi, "Clevo W350etq", {
1311         DMI_MATCH(DMI_SYS_VENDOR, "CLEVO CO."),
1312         DMI_MATCH(DMI_PRODUCT_NAME, "W35_37ET"),}, NULL},
1313         {
1314         ec_validate_ecdt, "ASUS hardware", {
1315         DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
1316         {
1317         ec_validate_ecdt, "ASUS hardware", {
1318         DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
1319         {
1320         ec_skip_dsdt_scan, "HP Folio 13", {
1321         DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
1322         DMI_MATCH(DMI_PRODUCT_NAME, "HP Folio 13"),}, NULL},
1323         {
1324         ec_validate_ecdt, "ASUS hardware", {
1325         DMI_MATCH(DMI_SYS_VENDOR, "ASUSTek Computer Inc."),
1326         DMI_MATCH(DMI_PRODUCT_NAME, "L4R"),}, NULL},
1327         {
1328         ec_clear_on_resume, "Samsung hardware", {
1329         DMI_MATCH(DMI_SYS_VENDOR, "SAMSUNG ELECTRONICS CO., LTD.")}, NULL},
1330         {
1331         ec_flag_query_handshake, "Acer hardware", {
1332         DMI_MATCH(DMI_SYS_VENDOR, "Acer"), }, NULL},
1333         {},
1334 };
1335
1336 int __init acpi_ec_ecdt_probe(void)
1337 {
1338         acpi_status status;
1339         struct acpi_ec *saved_ec = NULL;
1340         struct acpi_table_ecdt *ecdt_ptr;
1341
1342         boot_ec = make_acpi_ec();
1343         if (!boot_ec)
1344                 return -ENOMEM;
1345         /*
1346          * Generate a boot ec context
1347          */
1348         dmi_check_system(ec_dmi_table);
1349         status = acpi_get_table(ACPI_SIG_ECDT, 1,
1350                                 (struct acpi_table_header **)&ecdt_ptr);
1351         if (ACPI_SUCCESS(status)) {
1352                 pr_info("EC description table is found, configuring boot EC\n");
1353                 boot_ec->command_addr = ecdt_ptr->control.address;
1354                 boot_ec->data_addr = ecdt_ptr->data.address;
1355                 boot_ec->gpe = ecdt_ptr->gpe;
1356                 boot_ec->handle = ACPI_ROOT_OBJECT;
1357                 acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id,
1358                                 &boot_ec->handle);
1359                 /* Don't trust ECDT, which comes from ASUSTek */
1360                 if (!EC_FLAGS_VALIDATE_ECDT)
1361                         goto install;
1362                 saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL);
1363                 if (!saved_ec)
1364                         return -ENOMEM;
1365         /* fall through */
1366         }
1367
1368         if (EC_FLAGS_SKIP_DSDT_SCAN) {
1369                 kfree(saved_ec);
1370                 return -ENODEV;
1371         }
1372
1373         /* This workaround is needed only on some broken machines,
1374          * which require early EC, but fail to provide ECDT */
1375         pr_debug("Look up EC in DSDT\n");
1376         status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
1377                                         boot_ec, NULL);
1378         /* Check that acpi_get_devices actually find something */
1379         if (ACPI_FAILURE(status) || !boot_ec->handle)
1380                 goto error;
1381         if (saved_ec) {
1382                 /* try to find good ECDT from ASUSTek */
1383                 if (saved_ec->command_addr != boot_ec->command_addr ||
1384                     saved_ec->data_addr != boot_ec->data_addr ||
1385                     saved_ec->gpe != boot_ec->gpe ||
1386                     saved_ec->handle != boot_ec->handle)
1387                         pr_info("ASUSTek keeps feeding us with broken "
1388                         "ECDT tables, which are very hard to workaround. "
1389                         "Trying to use DSDT EC info instead. Please send "
1390                         "output of acpidump to linux-acpi@vger.kernel.org\n");
1391                 kfree(saved_ec);
1392                 saved_ec = NULL;
1393         } else {
1394                 /* We really need to limit this workaround, the only ASUS,
1395                 * which needs it, has fake EC._INI method, so use it as flag.
1396                 * Keep boot_ec struct as it will be needed soon.
1397                 */
1398                 if (!dmi_name_in_vendors("ASUS") ||
1399                     !acpi_has_method(boot_ec->handle, "_INI"))
1400                         return -ENODEV;
1401         }
1402 install:
1403         if (!ec_install_handlers(boot_ec)) {
1404                 first_ec = boot_ec;
1405                 return 0;
1406         }
1407 error:
1408         kfree(boot_ec);
1409         kfree(saved_ec);
1410         boot_ec = NULL;
1411         return -ENODEV;
1412 }
1413
1414 static struct acpi_driver acpi_ec_driver = {
1415         .name = "ec",
1416         .class = ACPI_EC_CLASS,
1417         .ids = ec_device_ids,
1418         .ops = {
1419                 .add = acpi_ec_add,
1420                 .remove = acpi_ec_remove,
1421                 },
1422 };
1423
1424 int __init acpi_ec_init(void)
1425 {
1426         int result = 0;
1427
1428         /* Now register the driver for the EC */
1429         result = acpi_bus_register_driver(&acpi_ec_driver);
1430         if (result < 0)
1431                 return -ENODEV;
1432
1433         return result;
1434 }
1435
1436 /* EC driver currently not unloadable */
1437 #if 0
1438 static void __exit acpi_ec_exit(void)
1439 {
1440
1441         acpi_bus_unregister_driver(&acpi_ec_driver);
1442 }
1443 #endif  /* 0 */