linux/drivers/acpi/ec.c
<<
>>
Prefs
   1/*
   2 *  ec.c - ACPI Embedded Controller Driver (v2.1)
   3 *
   4 *  Copyright (C) 2006-2008 Alexey Starikovskiy <astarikovskiy@suse.de>
   5 *  Copyright (C) 2006 Denis Sadykov <denis.m.sadykov@intel.com>
   6 *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
   7 *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   8 *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   9 *
  10 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  11 *
  12 *  This program is free software; you can redistribute it and/or modify
  13 *  it under the terms of the GNU General Public License as published by
  14 *  the Free Software Foundation; either version 2 of the License, or (at
  15 *  your option) any later version.
  16 *
  17 *  This program is distributed in the hope that it will be useful, but
  18 *  WITHOUT ANY WARRANTY; without even the implied warranty of
  19 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  20 *  General Public License for more details.
  21 *
  22 *  You should have received a copy of the GNU General Public License along
  23 *  with this program; if not, write to the Free Software Foundation, Inc.,
  24 *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  25 *
  26 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  27 */
  28
  29/* Uncomment next line to get verbose printout */
  30/* #define DEBUG */
  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 <asm/io.h>
  42#include <acpi/acpi_bus.h>
  43#include <acpi/acpi_drivers.h>
  44#include <linux/dmi.h>
  45
  46#include "internal.h"
  47
  48#define ACPI_EC_CLASS                   "embedded_controller"
  49#define ACPI_EC_DEVICE_NAME             "Embedded Controller"
  50#define ACPI_EC_FILE_INFO               "info"
  51
  52#undef PREFIX
  53#define PREFIX                          "ACPI: EC: "
  54
  55/* EC status register */
  56#define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
  57#define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
  58#define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
  59#define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
  60
  61/* EC commands */
  62enum ec_command {
  63        ACPI_EC_COMMAND_READ = 0x80,
  64        ACPI_EC_COMMAND_WRITE = 0x81,
  65        ACPI_EC_BURST_ENABLE = 0x82,
  66        ACPI_EC_BURST_DISABLE = 0x83,
  67        ACPI_EC_COMMAND_QUERY = 0x84,
  68};
  69
  70#define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
  71#define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
  72#define ACPI_EC_MSI_UDELAY      550     /* Wait 550us for MSI EC */
  73
  74enum {
  75        EC_FLAGS_QUERY_PENDING,         /* Query is pending */
  76        EC_FLAGS_GPE_STORM,             /* GPE storm detected */
  77        EC_FLAGS_HANDLERS_INSTALLED,    /* Handlers for GPE and
  78                                         * OpReg are installed */
  79        EC_FLAGS_BLOCKED,               /* Transactions are blocked */
  80};
  81
  82/* ec.c is compiled in acpi namespace so this shows up as acpi.ec_delay param */
  83static unsigned int ec_delay __read_mostly = ACPI_EC_DELAY;
  84module_param(ec_delay, uint, 0644);
  85MODULE_PARM_DESC(ec_delay, "Timeout(ms) waited until an EC command completes");
  86
  87/*
  88 * If the number of false interrupts per one transaction exceeds
  89 * this threshold, will think there is a GPE storm happened and
  90 * will disable the GPE for normal transaction.
  91 */
  92static unsigned int ec_storm_threshold  __read_mostly = 8;
  93module_param(ec_storm_threshold, uint, 0644);
  94MODULE_PARM_DESC(ec_storm_threshold, "Maxim false GPE numbers not considered as GPE storm");
  95
  96/* If we find an EC via the ECDT, we need to keep a ptr to its context */
  97/* External interfaces use first EC only, so remember */
  98typedef int (*acpi_ec_query_func) (void *data);
  99
 100struct acpi_ec_query_handler {
 101        struct list_head node;
 102        acpi_ec_query_func func;
 103        acpi_handle handle;
 104        void *data;
 105        u8 query_bit;
 106};
 107
 108struct transaction {
 109        const u8 *wdata;
 110        u8 *rdata;
 111        unsigned short irq_count;
 112        u8 command;
 113        u8 wi;
 114        u8 ri;
 115        u8 wlen;
 116        u8 rlen;
 117        bool done;
 118};
 119
 120struct acpi_ec *boot_ec, *first_ec;
 121EXPORT_SYMBOL(first_ec);
 122
 123static int EC_FLAGS_MSI; /* Out-of-spec MSI controller */
 124static int EC_FLAGS_VALIDATE_ECDT; /* ASUStec ECDTs need to be validated */
 125static int EC_FLAGS_SKIP_DSDT_SCAN; /* Not all BIOS survive early DSDT scan */
 126
 127/* --------------------------------------------------------------------------
 128                             Transaction Management
 129   -------------------------------------------------------------------------- */
 130
 131static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
 132{
 133        u8 x = inb(ec->command_addr);
 134        pr_debug(PREFIX "---> status = 0x%2.2x\n", x);
 135        return x;
 136}
 137
 138static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
 139{
 140        u8 x = inb(ec->data_addr);
 141        pr_debug(PREFIX "---> data = 0x%2.2x\n", x);
 142        return x;
 143}
 144
 145static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
 146{
 147        pr_debug(PREFIX "<--- command = 0x%2.2x\n", command);
 148        outb(command, ec->command_addr);
 149}
 150
 151static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
 152{
 153        pr_debug(PREFIX "<--- data = 0x%2.2x\n", data);
 154        outb(data, ec->data_addr);
 155}
 156
 157static int ec_transaction_done(struct acpi_ec *ec)
 158{
 159        unsigned long flags;
 160        int ret = 0;
 161        spin_lock_irqsave(&ec->curr_lock, flags);
 162        if (!ec->curr || ec->curr->done)
 163                ret = 1;
 164        spin_unlock_irqrestore(&ec->curr_lock, flags);
 165        return ret;
 166}
 167
 168static void start_transaction(struct acpi_ec *ec)
 169{
 170        ec->curr->irq_count = ec->curr->wi = ec->curr->ri = 0;
 171        ec->curr->done = false;
 172        acpi_ec_write_cmd(ec, ec->curr->command);
 173}
 174
 175static void advance_transaction(struct acpi_ec *ec, u8 status)
 176{
 177        unsigned long flags;
 178        spin_lock_irqsave(&ec->curr_lock, flags);
 179        if (!ec->curr)
 180                goto unlock;
 181        if (ec->curr->wlen > ec->curr->wi) {
 182                if ((status & ACPI_EC_FLAG_IBF) == 0)
 183                        acpi_ec_write_data(ec,
 184                                ec->curr->wdata[ec->curr->wi++]);
 185                else
 186                        goto err;
 187        } else if (ec->curr->rlen > ec->curr->ri) {
 188                if ((status & ACPI_EC_FLAG_OBF) == 1) {
 189                        ec->curr->rdata[ec->curr->ri++] = acpi_ec_read_data(ec);
 190                        if (ec->curr->rlen == ec->curr->ri)
 191                                ec->curr->done = true;
 192                } else
 193                        goto err;
 194        } else if (ec->curr->wlen == ec->curr->wi &&
 195                   (status & ACPI_EC_FLAG_IBF) == 0)
 196                ec->curr->done = true;
 197        goto unlock;
 198err:
 199        /* false interrupt, state didn't change */
 200        if (in_interrupt())
 201                ++ec->curr->irq_count;
 202unlock:
 203        spin_unlock_irqrestore(&ec->curr_lock, flags);
 204}
 205
 206static int acpi_ec_sync_query(struct acpi_ec *ec);
 207
 208static int ec_check_sci_sync(struct acpi_ec *ec, u8 state)
 209{
 210        if (state & ACPI_EC_FLAG_SCI) {
 211                if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags))
 212                        return acpi_ec_sync_query(ec);
 213        }
 214        return 0;
 215}
 216
 217static int ec_poll(struct acpi_ec *ec)
 218{
 219        unsigned long flags;
 220        int repeat = 2; /* number of command restarts */
 221        while (repeat--) {
 222                unsigned long delay = jiffies +
 223                        msecs_to_jiffies(ec_delay);
 224                do {
 225                        /* don't sleep with disabled interrupts */
 226                        if (EC_FLAGS_MSI || irqs_disabled()) {
 227                                udelay(ACPI_EC_MSI_UDELAY);
 228                                if (ec_transaction_done(ec))
 229                                        return 0;
 230                        } else {
 231                                if (wait_event_timeout(ec->wait,
 232                                                ec_transaction_done(ec),
 233                                                msecs_to_jiffies(1)))
 234                                        return 0;
 235                        }
 236                        advance_transaction(ec, acpi_ec_read_status(ec));
 237                } while (time_before(jiffies, delay));
 238                if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)
 239                        break;
 240                pr_debug(PREFIX "controller reset, restart transaction\n");
 241                spin_lock_irqsave(&ec->curr_lock, flags);
 242                start_transaction(ec);
 243                spin_unlock_irqrestore(&ec->curr_lock, flags);
 244        }
 245        return -ETIME;
 246}
 247
 248static int acpi_ec_transaction_unlocked(struct acpi_ec *ec,
 249                                        struct transaction *t)
 250{
 251        unsigned long tmp;
 252        int ret = 0;
 253        if (EC_FLAGS_MSI)
 254                udelay(ACPI_EC_MSI_UDELAY);
 255        /* start transaction */
 256        spin_lock_irqsave(&ec->curr_lock, tmp);
 257        /* following two actions should be kept atomic */
 258        ec->curr = t;
 259        start_transaction(ec);
 260        if (ec->curr->command == ACPI_EC_COMMAND_QUERY)
 261                clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
 262        spin_unlock_irqrestore(&ec->curr_lock, tmp);
 263        ret = ec_poll(ec);
 264        spin_lock_irqsave(&ec->curr_lock, tmp);
 265        ec->curr = NULL;
 266        spin_unlock_irqrestore(&ec->curr_lock, tmp);
 267        return ret;
 268}
 269
 270static int ec_check_ibf0(struct acpi_ec *ec)
 271{
 272        u8 status = acpi_ec_read_status(ec);
 273        return (status & ACPI_EC_FLAG_IBF) == 0;
 274}
 275
 276static int ec_wait_ibf0(struct acpi_ec *ec)
 277{
 278        unsigned long delay = jiffies + msecs_to_jiffies(ec_delay);
 279        /* interrupt wait manually if GPE mode is not active */
 280        while (time_before(jiffies, delay))
 281                if (wait_event_timeout(ec->wait, ec_check_ibf0(ec),
 282                                        msecs_to_jiffies(1)))
 283                        return 0;
 284        return -ETIME;
 285}
 286
 287static int acpi_ec_transaction(struct acpi_ec *ec, struct transaction *t)
 288{
 289        int status;
 290        u32 glk;
 291        if (!ec || (!t) || (t->wlen && !t->wdata) || (t->rlen && !t->rdata))
 292                return -EINVAL;
 293        if (t->rdata)
 294                memset(t->rdata, 0, t->rlen);
 295        mutex_lock(&ec->lock);
 296        if (test_bit(EC_FLAGS_BLOCKED, &ec->flags)) {
 297                status = -EINVAL;
 298                goto unlock;
 299        }
 300        if (ec->global_lock) {
 301                status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 302                if (ACPI_FAILURE(status)) {
 303                        status = -ENODEV;
 304                        goto unlock;
 305                }
 306        }
 307        if (ec_wait_ibf0(ec)) {
 308                pr_err(PREFIX "input buffer is not empty, "
 309                                "aborting transaction\n");
 310                status = -ETIME;
 311                goto end;
 312        }
 313        pr_debug(PREFIX "transaction start\n");
 314        /* disable GPE during transaction if storm is detected */
 315        if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
 316                /* It has to be disabled, so that it doesn't trigger. */
 317                acpi_disable_gpe(NULL, ec->gpe);
 318        }
 319
 320        status = acpi_ec_transaction_unlocked(ec, t);
 321
 322        /* check if we received SCI during transaction */
 323        ec_check_sci_sync(ec, acpi_ec_read_status(ec));
 324        if (test_bit(EC_FLAGS_GPE_STORM, &ec->flags)) {
 325                msleep(1);
 326                /* It is safe to enable the GPE outside of the transaction. */
 327                acpi_enable_gpe(NULL, ec->gpe);
 328        } else if (t->irq_count > ec_storm_threshold) {
 329                pr_info(PREFIX "GPE storm detected, "
 330                        "transactions will use polling mode\n");
 331                set_bit(EC_FLAGS_GPE_STORM, &ec->flags);
 332        }
 333        pr_debug(PREFIX "transaction end\n");
 334end:
 335        if (ec->global_lock)
 336                acpi_release_global_lock(glk);
 337unlock:
 338        mutex_unlock(&ec->lock);
 339        return status;
 340}
 341
 342static int acpi_ec_burst_enable(struct acpi_ec *ec)
 343{
 344        u8 d;
 345        struct transaction t = {.command = ACPI_EC_BURST_ENABLE,
 346                                .wdata = NULL, .rdata = &d,
 347                                .wlen = 0, .rlen = 1};
 348
 349        return acpi_ec_transaction(ec, &t);
 350}
 351
 352static int acpi_ec_burst_disable(struct acpi_ec *ec)
 353{
 354        struct transaction t = {.command = ACPI_EC_BURST_DISABLE,
 355                                .wdata = NULL, .rdata = NULL,
 356                                .wlen = 0, .rlen = 0};
 357
 358        return (acpi_ec_read_status(ec) & ACPI_EC_FLAG_BURST) ?
 359                                acpi_ec_transaction(ec, &t) : 0;
 360}
 361
 362static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 * data)
 363{
 364        int result;
 365        u8 d;
 366        struct transaction t = {.command = ACPI_EC_COMMAND_READ,
 367                                .wdata = &address, .rdata = &d,
 368                                .wlen = 1, .rlen = 1};
 369
 370        result = acpi_ec_transaction(ec, &t);
 371        *data = d;
 372        return result;
 373}
 374
 375static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
 376{
 377        u8 wdata[2] = { address, data };
 378        struct transaction t = {.command = ACPI_EC_COMMAND_WRITE,
 379                                .wdata = wdata, .rdata = NULL,
 380                                .wlen = 2, .rlen = 0};
 381
 382        return acpi_ec_transaction(ec, &t);
 383}
 384
 385/*
 386 * Externally callable EC access functions. For now, assume 1 EC only
 387 */
 388int ec_burst_enable(void)
 389{
 390        if (!first_ec)
 391                return -ENODEV;
 392        return acpi_ec_burst_enable(first_ec);
 393}
 394
 395EXPORT_SYMBOL(ec_burst_enable);
 396
 397int ec_burst_disable(void)
 398{
 399        if (!first_ec)
 400                return -ENODEV;
 401        return acpi_ec_burst_disable(first_ec);
 402}
 403
 404EXPORT_SYMBOL(ec_burst_disable);
 405
 406int ec_read(u8 addr, u8 * val)
 407{
 408        int err;
 409        u8 temp_data;
 410
 411        if (!first_ec)
 412                return -ENODEV;
 413
 414        err = acpi_ec_read(first_ec, addr, &temp_data);
 415
 416        if (!err) {
 417                *val = temp_data;
 418                return 0;
 419        } else
 420                return err;
 421}
 422
 423EXPORT_SYMBOL(ec_read);
 424
 425int ec_write(u8 addr, u8 val)
 426{
 427        int err;
 428
 429        if (!first_ec)
 430                return -ENODEV;
 431
 432        err = acpi_ec_write(first_ec, addr, val);
 433
 434        return err;
 435}
 436
 437EXPORT_SYMBOL(ec_write);
 438
 439int ec_transaction(u8 command,
 440                   const u8 * wdata, unsigned wdata_len,
 441                   u8 * rdata, unsigned rdata_len)
 442{
 443        struct transaction t = {.command = command,
 444                                .wdata = wdata, .rdata = rdata,
 445                                .wlen = wdata_len, .rlen = rdata_len};
 446        if (!first_ec)
 447                return -ENODEV;
 448
 449        return acpi_ec_transaction(first_ec, &t);
 450}
 451
 452EXPORT_SYMBOL(ec_transaction);
 453
 454/* Get the handle to the EC device */
 455acpi_handle ec_get_handle(void)
 456{
 457        if (!first_ec)
 458                return NULL;
 459        return first_ec->handle;
 460}
 461
 462EXPORT_SYMBOL(ec_get_handle);
 463
 464void acpi_ec_block_transactions(void)
 465{
 466        struct acpi_ec *ec = first_ec;
 467
 468        if (!ec)
 469                return;
 470
 471        mutex_lock(&ec->lock);
 472        /* Prevent transactions from being carried out */
 473        set_bit(EC_FLAGS_BLOCKED, &ec->flags);
 474        mutex_unlock(&ec->lock);
 475}
 476
 477void acpi_ec_unblock_transactions(void)
 478{
 479        struct acpi_ec *ec = first_ec;
 480
 481        if (!ec)
 482                return;
 483
 484        mutex_lock(&ec->lock);
 485        /* Allow transactions to be carried out again */
 486        clear_bit(EC_FLAGS_BLOCKED, &ec->flags);
 487        mutex_unlock(&ec->lock);
 488}
 489
 490void acpi_ec_unblock_transactions_early(void)
 491{
 492        /*
 493         * Allow transactions to happen again (this function is called from
 494         * atomic context during wakeup, so we don't need to acquire the mutex).
 495         */
 496        if (first_ec)
 497                clear_bit(EC_FLAGS_BLOCKED, &first_ec->flags);
 498}
 499
 500static int acpi_ec_query_unlocked(struct acpi_ec *ec, u8 * data)
 501{
 502        int result;
 503        u8 d;
 504        struct transaction t = {.command = ACPI_EC_COMMAND_QUERY,
 505                                .wdata = NULL, .rdata = &d,
 506                                .wlen = 0, .rlen = 1};
 507        if (!ec || !data)
 508                return -EINVAL;
 509        /*
 510         * Query the EC to find out which _Qxx method we need to evaluate.
 511         * Note that successful completion of the query causes the ACPI_EC_SCI
 512         * bit to be cleared (and thus clearing the interrupt source).
 513         */
 514        result = acpi_ec_transaction_unlocked(ec, &t);
 515        if (result)
 516                return result;
 517        if (!d)
 518                return -ENODATA;
 519        *data = d;
 520        return 0;
 521}
 522
 523/* --------------------------------------------------------------------------
 524                                Event Management
 525   -------------------------------------------------------------------------- */
 526int acpi_ec_add_query_handler(struct acpi_ec *ec, u8 query_bit,
 527                              acpi_handle handle, acpi_ec_query_func func,
 528                              void *data)
 529{
 530        struct acpi_ec_query_handler *handler =
 531            kzalloc(sizeof(struct acpi_ec_query_handler), GFP_KERNEL);
 532        if (!handler)
 533                return -ENOMEM;
 534
 535        handler->query_bit = query_bit;
 536        handler->handle = handle;
 537        handler->func = func;
 538        handler->data = data;
 539        mutex_lock(&ec->lock);
 540        list_add(&handler->node, &ec->list);
 541        mutex_unlock(&ec->lock);
 542        return 0;
 543}
 544
 545EXPORT_SYMBOL_GPL(acpi_ec_add_query_handler);
 546
 547void acpi_ec_remove_query_handler(struct acpi_ec *ec, u8 query_bit)
 548{
 549        struct acpi_ec_query_handler *handler, *tmp;
 550        mutex_lock(&ec->lock);
 551        list_for_each_entry_safe(handler, tmp, &ec->list, node) {
 552                if (query_bit == handler->query_bit) {
 553                        list_del(&handler->node);
 554                        kfree(handler);
 555                }
 556        }
 557        mutex_unlock(&ec->lock);
 558}
 559
 560EXPORT_SYMBOL_GPL(acpi_ec_remove_query_handler);
 561
 562static void acpi_ec_run(void *cxt)
 563{
 564        struct acpi_ec_query_handler *handler = cxt;
 565        if (!handler)
 566                return;
 567        pr_debug(PREFIX "start query execution\n");
 568        if (handler->func)
 569                handler->func(handler->data);
 570        else if (handler->handle)
 571                acpi_evaluate_object(handler->handle, NULL, NULL, NULL);
 572        pr_debug(PREFIX "stop query execution\n");
 573        kfree(handler);
 574}
 575
 576static int acpi_ec_sync_query(struct acpi_ec *ec)
 577{
 578        u8 value = 0;
 579        int status;
 580        struct acpi_ec_query_handler *handler, *copy;
 581        if ((status = acpi_ec_query_unlocked(ec, &value)))
 582                return status;
 583        list_for_each_entry(handler, &ec->list, node) {
 584                if (value == handler->query_bit) {
 585                        /* have custom handler for this bit */
 586                        copy = kmalloc(sizeof(*handler), GFP_KERNEL);
 587                        if (!copy)
 588                                return -ENOMEM;
 589                        memcpy(copy, handler, sizeof(*copy));
 590                        pr_debug(PREFIX "push query execution (0x%2x) on queue\n", value);
 591                        return acpi_os_execute((copy->func) ?
 592                                OSL_NOTIFY_HANDLER : OSL_GPE_HANDLER,
 593                                acpi_ec_run, copy);
 594                }
 595        }
 596        return 0;
 597}
 598
 599static void acpi_ec_gpe_query(void *ec_cxt)
 600{
 601        struct acpi_ec *ec = ec_cxt;
 602        if (!ec)
 603                return;
 604        mutex_lock(&ec->lock);
 605        acpi_ec_sync_query(ec);
 606        mutex_unlock(&ec->lock);
 607}
 608
 609static int ec_check_sci(struct acpi_ec *ec, u8 state)
 610{
 611        if (state & ACPI_EC_FLAG_SCI) {
 612                if (!test_and_set_bit(EC_FLAGS_QUERY_PENDING, &ec->flags)) {
 613                        pr_debug(PREFIX "push gpe query to the queue\n");
 614                        return acpi_os_execute(OSL_NOTIFY_HANDLER,
 615                                acpi_ec_gpe_query, ec);
 616                }
 617        }
 618        return 0;
 619}
 620
 621static u32 acpi_ec_gpe_handler(acpi_handle gpe_device,
 622        u32 gpe_number, void *data)
 623{
 624        struct acpi_ec *ec = data;
 625
 626        pr_debug(PREFIX "~~~> interrupt\n");
 627
 628        advance_transaction(ec, acpi_ec_read_status(ec));
 629        if (ec_transaction_done(ec) &&
 630            (acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF) == 0) {
 631                wake_up(&ec->wait);
 632                ec_check_sci(ec, acpi_ec_read_status(ec));
 633        }
 634        return ACPI_INTERRUPT_HANDLED | ACPI_REENABLE_GPE;
 635}
 636
 637/* --------------------------------------------------------------------------
 638                             Address Space Management
 639   -------------------------------------------------------------------------- */
 640
 641static acpi_status
 642acpi_ec_space_handler(u32 function, acpi_physical_address address,
 643                      u32 bits, u64 *value64,
 644                      void *handler_context, void *region_context)
 645{
 646        struct acpi_ec *ec = handler_context;
 647        int result = 0, i, bytes = bits / 8;
 648        u8 *value = (u8 *)value64;
 649
 650        if ((address > 0xFF) || !value || !handler_context)
 651                return AE_BAD_PARAMETER;
 652
 653        if (function != ACPI_READ && function != ACPI_WRITE)
 654                return AE_BAD_PARAMETER;
 655
 656        if (EC_FLAGS_MSI || bits > 8)
 657                acpi_ec_burst_enable(ec);
 658
 659        for (i = 0; i < bytes; ++i, ++address, ++value)
 660                result = (function == ACPI_READ) ?
 661                        acpi_ec_read(ec, address, value) :
 662                        acpi_ec_write(ec, address, *value);
 663
 664        if (EC_FLAGS_MSI || bits > 8)
 665                acpi_ec_burst_disable(ec);
 666
 667        switch (result) {
 668        case -EINVAL:
 669                return AE_BAD_PARAMETER;
 670                break;
 671        case -ENODEV:
 672                return AE_NOT_FOUND;
 673                break;
 674        case -ETIME:
 675                return AE_TIME;
 676                break;
 677        default:
 678                return AE_OK;
 679        }
 680}
 681
 682/* --------------------------------------------------------------------------
 683                               Driver Interface
 684   -------------------------------------------------------------------------- */
 685static acpi_status
 686ec_parse_io_ports(struct acpi_resource *resource, void *context);
 687
 688static struct acpi_ec *make_acpi_ec(void)
 689{
 690        struct acpi_ec *ec = kzalloc(sizeof(struct acpi_ec), GFP_KERNEL);
 691        if (!ec)
 692                return NULL;
 693        ec->flags = 1 << EC_FLAGS_QUERY_PENDING;
 694        mutex_init(&ec->lock);
 695        init_waitqueue_head(&ec->wait);
 696        INIT_LIST_HEAD(&ec->list);
 697        spin_lock_init(&ec->curr_lock);
 698        return ec;
 699}
 700
 701static acpi_status
 702acpi_ec_register_query_methods(acpi_handle handle, u32 level,
 703                               void *context, void **return_value)
 704{
 705        char node_name[5];
 706        struct acpi_buffer buffer = { sizeof(node_name), node_name };
 707        struct acpi_ec *ec = context;
 708        int value = 0;
 709        acpi_status status;
 710
 711        status = acpi_get_name(handle, ACPI_SINGLE_NAME, &buffer);
 712
 713        if (ACPI_SUCCESS(status) && sscanf(node_name, "_Q%x", &value) == 1) {
 714                acpi_ec_add_query_handler(ec, value, handle, NULL, NULL);
 715        }
 716        return AE_OK;
 717}
 718
 719static acpi_status
 720ec_parse_device(acpi_handle handle, u32 Level, void *context, void **retval)
 721{
 722        acpi_status status;
 723        unsigned long long tmp = 0;
 724
 725        struct acpi_ec *ec = context;
 726
 727        /* clear addr values, ec_parse_io_ports depend on it */
 728        ec->command_addr = ec->data_addr = 0;
 729
 730        status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 731                                     ec_parse_io_ports, ec);
 732        if (ACPI_FAILURE(status))
 733                return status;
 734
 735        /* Get GPE bit assignment (EC events). */
 736        /* TODO: Add support for _GPE returning a package */
 737        status = acpi_evaluate_integer(handle, "_GPE", NULL, &tmp);
 738        if (ACPI_FAILURE(status))
 739                return status;
 740        ec->gpe = tmp;
 741        /* Use the global lock for all EC transactions? */
 742        tmp = 0;
 743        acpi_evaluate_integer(handle, "_GLK", NULL, &tmp);
 744        ec->global_lock = tmp;
 745        ec->handle = handle;
 746        return AE_CTRL_TERMINATE;
 747}
 748
 749static int ec_install_handlers(struct acpi_ec *ec)
 750{
 751        acpi_status status;
 752        if (test_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags))
 753                return 0;
 754        status = acpi_install_gpe_handler(NULL, ec->gpe,
 755                                  ACPI_GPE_EDGE_TRIGGERED,
 756                                  &acpi_ec_gpe_handler, ec);
 757        if (ACPI_FAILURE(status))
 758                return -ENODEV;
 759
 760        acpi_enable_gpe(NULL, ec->gpe);
 761        status = acpi_install_address_space_handler(ec->handle,
 762                                                    ACPI_ADR_SPACE_EC,
 763                                                    &acpi_ec_space_handler,
 764                                                    NULL, ec);
 765        if (ACPI_FAILURE(status)) {
 766                if (status == AE_NOT_FOUND) {
 767                        /*
 768                         * Maybe OS fails in evaluating the _REG object.
 769                         * The AE_NOT_FOUND error will be ignored and OS
 770                         * continue to initialize EC.
 771                         */
 772                        printk(KERN_ERR "Fail in evaluating the _REG object"
 773                                " of EC device. Broken bios is suspected.\n");
 774                } else {
 775                        acpi_remove_gpe_handler(NULL, ec->gpe,
 776                                &acpi_ec_gpe_handler);
 777                        acpi_disable_gpe(NULL, ec->gpe);
 778                        return -ENODEV;
 779                }
 780        }
 781
 782        set_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
 783        return 0;
 784}
 785
 786static void ec_remove_handlers(struct acpi_ec *ec)
 787{
 788        acpi_disable_gpe(NULL, ec->gpe);
 789        if (ACPI_FAILURE(acpi_remove_address_space_handler(ec->handle,
 790                                ACPI_ADR_SPACE_EC, &acpi_ec_space_handler)))
 791                pr_err(PREFIX "failed to remove space handler\n");
 792        if (ACPI_FAILURE(acpi_remove_gpe_handler(NULL, ec->gpe,
 793                                &acpi_ec_gpe_handler)))
 794                pr_err(PREFIX "failed to remove gpe handler\n");
 795        clear_bit(EC_FLAGS_HANDLERS_INSTALLED, &ec->flags);
 796}
 797
 798static int acpi_ec_add(struct acpi_device *device)
 799{
 800        struct acpi_ec *ec = NULL;
 801        int ret;
 802
 803        strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
 804        strcpy(acpi_device_class(device), ACPI_EC_CLASS);
 805
 806        /* Check for boot EC */
 807        if (boot_ec &&
 808            (boot_ec->handle == device->handle ||
 809             boot_ec->handle == ACPI_ROOT_OBJECT)) {
 810                ec = boot_ec;
 811                boot_ec = NULL;
 812        } else {
 813                ec = make_acpi_ec();
 814                if (!ec)
 815                        return -ENOMEM;
 816        }
 817        if (ec_parse_device(device->handle, 0, ec, NULL) !=
 818                AE_CTRL_TERMINATE) {
 819                        kfree(ec);
 820                        return -EINVAL;
 821        }
 822
 823        /* Find and register all query methods */
 824        acpi_walk_namespace(ACPI_TYPE_METHOD, ec->handle, 1,
 825                            acpi_ec_register_query_methods, NULL, ec, NULL);
 826
 827        if (!first_ec)
 828                first_ec = ec;
 829        device->driver_data = ec;
 830
 831        ret = !!request_region(ec->data_addr, 1, "EC data");
 832        WARN(!ret, "Could not request EC data io port 0x%lx", ec->data_addr);
 833        ret = !!request_region(ec->command_addr, 1, "EC cmd");
 834        WARN(!ret, "Could not request EC cmd io port 0x%lx", ec->command_addr);
 835
 836        pr_info(PREFIX "GPE = 0x%lx, I/O: command/status = 0x%lx, data = 0x%lx\n",
 837                          ec->gpe, ec->command_addr, ec->data_addr);
 838
 839        ret = ec_install_handlers(ec);
 840
 841        /* EC is fully operational, allow queries */
 842        clear_bit(EC_FLAGS_QUERY_PENDING, &ec->flags);
 843        return ret;
 844}
 845
 846static int acpi_ec_remove(struct acpi_device *device, int type)
 847{
 848        struct acpi_ec *ec;
 849        struct acpi_ec_query_handler *handler, *tmp;
 850
 851        if (!device)
 852                return -EINVAL;
 853
 854        ec = acpi_driver_data(device);
 855        ec_remove_handlers(ec);
 856        mutex_lock(&ec->lock);
 857        list_for_each_entry_safe(handler, tmp, &ec->list, node) {
 858                list_del(&handler->node);
 859                kfree(handler);
 860        }
 861        mutex_unlock(&ec->lock);
 862        release_region(ec->data_addr, 1);
 863        release_region(ec->command_addr, 1);
 864        device->driver_data = NULL;
 865        if (ec == first_ec)
 866                first_ec = NULL;
 867        kfree(ec);
 868        return 0;
 869}
 870
 871static acpi_status
 872ec_parse_io_ports(struct acpi_resource *resource, void *context)
 873{
 874        struct acpi_ec *ec = context;
 875
 876        if (resource->type != ACPI_RESOURCE_TYPE_IO)
 877                return AE_OK;
 878
 879        /*
 880         * The first address region returned is the data port, and
 881         * the second address region returned is the status/command
 882         * port.
 883         */
 884        if (ec->data_addr == 0)
 885                ec->data_addr = resource->data.io.minimum;
 886        else if (ec->command_addr == 0)
 887                ec->command_addr = resource->data.io.minimum;
 888        else
 889                return AE_CTRL_TERMINATE;
 890
 891        return AE_OK;
 892}
 893
 894int __init acpi_boot_ec_enable(void)
 895{
 896        if (!boot_ec || test_bit(EC_FLAGS_HANDLERS_INSTALLED, &boot_ec->flags))
 897                return 0;
 898        if (!ec_install_handlers(boot_ec)) {
 899                first_ec = boot_ec;
 900                return 0;
 901        }
 902        return -EFAULT;
 903}
 904
 905static const struct acpi_device_id ec_device_ids[] = {
 906        {"PNP0C09", 0},
 907        {"", 0},
 908};
 909
 910/* Some BIOS do not survive early DSDT scan, skip it */
 911static int ec_skip_dsdt_scan(const struct dmi_system_id *id)
 912{
 913        EC_FLAGS_SKIP_DSDT_SCAN = 1;
 914        return 0;
 915}
 916
 917/* ASUStek often supplies us with broken ECDT, validate it */
 918static int ec_validate_ecdt(const struct dmi_system_id *id)
 919{
 920        EC_FLAGS_VALIDATE_ECDT = 1;
 921        return 0;
 922}
 923
 924/* MSI EC needs special treatment, enable it */
 925static int ec_flag_msi(const struct dmi_system_id *id)
 926{
 927        printk(KERN_DEBUG PREFIX "Detected MSI hardware, enabling workarounds.\n");
 928        EC_FLAGS_MSI = 1;
 929        EC_FLAGS_VALIDATE_ECDT = 1;
 930        return 0;
 931}
 932
 933/*
 934 * Clevo M720 notebook actually works ok with IRQ mode, if we lifted
 935 * the GPE storm threshold back to 20
 936 */
 937static int ec_enlarge_storm_threshold(const struct dmi_system_id *id)
 938{
 939        pr_debug("Setting the EC GPE storm threshold to 20\n");
 940        ec_storm_threshold  = 20;
 941        return 0;
 942}
 943
 944static struct dmi_system_id __initdata ec_dmi_table[] = {
 945        {
 946        ec_skip_dsdt_scan, "Compal JFL92", {
 947        DMI_MATCH(DMI_BIOS_VENDOR, "COMPAL"),
 948        DMI_MATCH(DMI_BOARD_NAME, "JFL92") }, NULL},
 949        {
 950        ec_flag_msi, "MSI hardware", {
 951        DMI_MATCH(DMI_BIOS_VENDOR, "Micro-Star")}, NULL},
 952        {
 953        ec_flag_msi, "MSI hardware", {
 954        DMI_MATCH(DMI_SYS_VENDOR, "Micro-Star")}, NULL},
 955        {
 956        ec_flag_msi, "MSI hardware", {
 957        DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-Star")}, NULL},
 958        {
 959        ec_flag_msi, "MSI hardware", {
 960        DMI_MATCH(DMI_CHASSIS_VENDOR, "MICRO-STAR")}, NULL},
 961        {
 962        ec_flag_msi, "Quanta hardware", {
 963        DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
 964        DMI_MATCH(DMI_PRODUCT_NAME, "TW8/SW8/DW8"),}, NULL},
 965        {
 966        ec_flag_msi, "Quanta hardware", {
 967        DMI_MATCH(DMI_SYS_VENDOR, "Quanta"),
 968        DMI_MATCH(DMI_PRODUCT_NAME, "TW9/SW9"),}, NULL},
 969        {
 970        ec_validate_ecdt, "ASUS hardware", {
 971        DMI_MATCH(DMI_BIOS_VENDOR, "ASUS") }, NULL},
 972        {
 973        ec_validate_ecdt, "ASUS hardware", {
 974        DMI_MATCH(DMI_BOARD_VENDOR, "ASUSTeK Computer Inc.") }, NULL},
 975        {
 976        ec_enlarge_storm_threshold, "CLEVO hardware", {
 977        DMI_MATCH(DMI_SYS_VENDOR, "CLEVO Co."),
 978        DMI_MATCH(DMI_PRODUCT_NAME, "M720T/M730T"),}, NULL},
 979        {},
 980};
 981
 982int __init acpi_ec_ecdt_probe(void)
 983{
 984        acpi_status status;
 985        struct acpi_ec *saved_ec = NULL;
 986        struct acpi_table_ecdt *ecdt_ptr;
 987
 988        boot_ec = make_acpi_ec();
 989        if (!boot_ec)
 990                return -ENOMEM;
 991        /*
 992         * Generate a boot ec context
 993         */
 994        dmi_check_system(ec_dmi_table);
 995        status = acpi_get_table(ACPI_SIG_ECDT, 1,
 996                                (struct acpi_table_header **)&ecdt_ptr);
 997        if (ACPI_SUCCESS(status)) {
 998                pr_info(PREFIX "EC description table is found, configuring boot EC\n");
 999                boot_ec->command_addr = ecdt_ptr->control.address;
1000                boot_ec->data_addr = ecdt_ptr->data.address;
1001                boot_ec->gpe = ecdt_ptr->gpe;
1002                boot_ec->handle = ACPI_ROOT_OBJECT;
1003                acpi_get_handle(ACPI_ROOT_OBJECT, ecdt_ptr->id, &boot_ec->handle);
1004                /* Don't trust ECDT, which comes from ASUSTek */
1005                if (!EC_FLAGS_VALIDATE_ECDT)
1006                        goto install;
1007                saved_ec = kmemdup(boot_ec, sizeof(struct acpi_ec), GFP_KERNEL);
1008                if (!saved_ec)
1009                        return -ENOMEM;
1010        /* fall through */
1011        }
1012
1013        if (EC_FLAGS_SKIP_DSDT_SCAN)
1014                return -ENODEV;
1015
1016        /* This workaround is needed only on some broken machines,
1017         * which require early EC, but fail to provide ECDT */
1018        printk(KERN_DEBUG PREFIX "Look up EC in DSDT\n");
1019        status = acpi_get_devices(ec_device_ids[0].id, ec_parse_device,
1020                                        boot_ec, NULL);
1021        /* Check that acpi_get_devices actually find something */
1022        if (ACPI_FAILURE(status) || !boot_ec->handle)
1023                goto error;
1024        if (saved_ec) {
1025                /* try to find good ECDT from ASUSTek */
1026                if (saved_ec->command_addr != boot_ec->command_addr ||
1027                    saved_ec->data_addr != boot_ec->data_addr ||
1028                    saved_ec->gpe != boot_ec->gpe ||
1029                    saved_ec->handle != boot_ec->handle)
1030                        pr_info(PREFIX "ASUSTek keeps feeding us with broken "
1031                        "ECDT tables, which are very hard to workaround. "
1032                        "Trying to use DSDT EC info instead. Please send "
1033                        "output of acpidump to linux-acpi@vger.kernel.org\n");
1034                kfree(saved_ec);
1035                saved_ec = NULL;
1036        } else {
1037                /* We really need to limit this workaround, the only ASUS,
1038                * which needs it, has fake EC._INI method, so use it as flag.
1039                * Keep boot_ec struct as it will be needed soon.
1040                */
1041                acpi_handle dummy;
1042                if (!dmi_name_in_vendors("ASUS") ||
1043                    ACPI_FAILURE(acpi_get_handle(boot_ec->handle, "_INI",
1044                                                        &dummy)))
1045                        return -ENODEV;
1046        }
1047install:
1048        if (!ec_install_handlers(boot_ec)) {
1049                first_ec = boot_ec;
1050                return 0;
1051        }
1052error:
1053        kfree(boot_ec);
1054        boot_ec = NULL;
1055        return -ENODEV;
1056}
1057
1058static struct acpi_driver acpi_ec_driver = {
1059        .name = "ec",
1060        .class = ACPI_EC_CLASS,
1061        .ids = ec_device_ids,
1062        .ops = {
1063                .add = acpi_ec_add,
1064                .remove = acpi_ec_remove,
1065                },
1066};
1067
1068int __init acpi_ec_init(void)
1069{
1070        int result = 0;
1071
1072        /* Now register the driver for the EC */
1073        result = acpi_bus_register_driver(&acpi_ec_driver);
1074        if (result < 0)
1075                return -ENODEV;
1076
1077        return result;
1078}
1079
1080/* EC driver currently not unloadable */
1081#if 0
1082static void __exit acpi_ec_exit(void)
1083{
1084
1085        acpi_bus_unregister_driver(&acpi_ec_driver);
1086        return;
1087}
1088#endif  /* 0 */
1089
lxr.linux.no kindly hosted by Redpill Linpro AS, provider of Linux consulting and operations services since 1995.