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