drivers/acpi/ec.c

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