drivers/acpi/ec.c

   1 /*
   2  *  acpi_ec.c - ACPI Embedded Controller Driver ($Revision: 38 $)
   3  *
   4  *  Copyright (C) 2004 Luming Yu <luming.yu@intel.com>
   5  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   6  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   7  *
   8  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   9  *
  10  *  This program is free software; you can redistribute it and/or modify
  11  *  it under the terms of the GNU General Public License as published by
  12  *  the Free Software Foundation; either version 2 of the License, or (at
  13  *  your option) any later version.
  14  *
  15  *  This program is distributed in the hope that it will be useful, but
  16  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18  *  General Public License for more details.
  19  *
  20  *  You should have received a copy of the GNU General Public License along
  21  *  with this program; if not, write to the Free Software Foundation, Inc.,
  22  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  23  *
  24  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  25  */
  26
  27 #include <linux/kernel.h>
  28 #include <linux/module.h>
  29 #include <linux/init.h>
  30 #include <linux/types.h>
  31 #include <linux/delay.h>
  32 #include <linux/proc_fs.h>
  33 #include <linux/seq_file.h>
  34 #include <linux/interrupt.h>
  35 #include <asm/io.h>
  36 #include <acpi/acpi_bus.h>
  37 #include <acpi/acpi_drivers.h>
  38 #include <acpi/actypes.h>
  39
  40 #define _COMPONENT              ACPI_EC_COMPONENT
  41 ACPI_MODULE_NAME("acpi_ec")
  42 #define ACPI_EC_COMPONENT               0x00100000
  43 #define ACPI_EC_CLASS                   "embedded_controller"
  44 #define ACPI_EC_HID                     "PNP0C09"
  45 #define ACPI_EC_DRIVER_NAME             "ACPI Embedded Controller Driver"
  46 #define ACPI_EC_DEVICE_NAME             "Embedded Controller"
  47 #define ACPI_EC_FILE_INFO               "info"
  48 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
  49 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
  50 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
  51 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
  52 #define ACPI_EC_EVENT_OBF       0x01    /* Output buffer full */
  53 #define ACPI_EC_EVENT_IBE       0x02    /* Input buffer empty */
  54 #define ACPI_EC_DELAY           50      /* Wait 50ms max. during EC ops */
  55 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
  56 #define ACPI_EC_UDELAY         100      /* Poll @ 100us increments */
  57 #define ACPI_EC_UDELAY_COUNT   1000     /* Wait 10ms max. during EC ops */
  58 #define ACPI_EC_COMMAND_READ    0x80
  59 #define ACPI_EC_COMMAND_WRITE   0x81
  60 #define ACPI_EC_BURST_ENABLE    0x82
  61 #define ACPI_EC_BURST_DISABLE   0x83
  62 #define ACPI_EC_COMMAND_QUERY   0x84
  63 #define EC_POLL                 0xFF
  64 #define EC_INTR                 0x00
  65 static int acpi_ec_remove(struct acpi_device *device, int type);
  66 static int acpi_ec_start(struct acpi_device *device);
  67 static int acpi_ec_stop(struct acpi_device *device, int type);
  68 static int acpi_ec_intr_add(struct acpi_device *device);
  69 static int acpi_ec_poll_add(struct acpi_device *device);
  70
  71 static struct acpi_driver acpi_ec_driver = {
  72         .name = ACPI_EC_DRIVER_NAME,
  73         .class = ACPI_EC_CLASS,
  74         .ids = ACPI_EC_HID,
  75         .ops = {
  76                 .add = acpi_ec_intr_add,
  77                 .remove = acpi_ec_remove,
  78                 .start = acpi_ec_start,
  79                 .stop = acpi_ec_stop,
  80                 },
  81 };
  82 union acpi_ec {
  83         struct {
  84                 u32 mode;
  85                 acpi_handle handle;
  86                 unsigned long uid;
  87                 unsigned long gpe_bit;
  88                 struct acpi_generic_address status_addr;
  89                 struct acpi_generic_address command_addr;
  90                 struct acpi_generic_address data_addr;
  91                 unsigned long global_lock;
  92         } common;
  93
  94         struct {
  95                 u32 mode;
  96                 acpi_handle handle;
  97                 unsigned long uid;
  98                 unsigned long gpe_bit;
  99                 struct acpi_generic_address status_addr;
 100                 struct acpi_generic_address command_addr;
 101                 struct acpi_generic_address data_addr;
 102                 unsigned long global_lock;
 103                 unsigned int expect_event;
 104                 atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
 105                 atomic_t pending_gpe;
 106                 struct semaphore sem;
 107                 wait_queue_head_t wait;
 108         } intr;
 109
 110         struct {
 111                 u32 mode;
 112                 acpi_handle handle;
 113                 unsigned long uid;
 114                 unsigned long gpe_bit;
 115                 struct acpi_generic_address status_addr;
 116                 struct acpi_generic_address command_addr;
 117                 struct acpi_generic_address data_addr;
 118                 unsigned long global_lock;
 119                 struct semaphore sem;
 120         } poll;
 121 };
 122
 123 static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event);
 124 static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event);
 125 static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data);
 126 static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data);
 127 static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data);
 128 static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data);
 129 static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data);
 130 static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data);
 131 static void acpi_ec_gpe_poll_query(void *ec_cxt);
 132 static void acpi_ec_gpe_intr_query(void *ec_cxt);
 133 static u32 acpi_ec_gpe_poll_handler(void *data);
 134 static u32 acpi_ec_gpe_intr_handler(void *data);
 135 static acpi_status __init
 136 acpi_fake_ecdt_poll_callback(acpi_handle handle,
 137                                 u32 Level, void *context, void **retval);
 138
 139 static acpi_status __init
 140 acpi_fake_ecdt_intr_callback(acpi_handle handle,
 141                               u32 Level, void *context, void **retval);
 142
 143 static int __init acpi_ec_poll_get_real_ecdt(void);
 144 static int __init acpi_ec_intr_get_real_ecdt(void);
 145 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
 146 static union acpi_ec *ec_ecdt;
 147
 148 /* External interfaces use first EC only, so remember */
 149 static struct acpi_device *first_ec;
 150 static int acpi_ec_poll_mode = EC_INTR;
 151
 152 /* --------------------------------------------------------------------------
 153                              Transaction Management
 154    -------------------------------------------------------------------------- */
 155
 156 static u32 acpi_ec_read_status(union acpi_ec *ec)
 157 {
 158         u32 status = 0;
 159
 160         acpi_hw_low_level_read(8, &status, &ec->common.status_addr);
 161         return status;
 162 }
 163
 164 static int acpi_ec_wait(union acpi_ec *ec, u8 event)
 165 {
 166         if (acpi_ec_poll_mode)
 167                 return acpi_ec_poll_wait(ec, event);
 168         else
 169                 return acpi_ec_intr_wait(ec, event);
 170 }
 171
 172 static int acpi_ec_poll_wait(union acpi_ec *ec, u8 event)
 173 {
 174         u32 acpi_ec_status = 0;
 175         u32 i = ACPI_EC_UDELAY_COUNT;
 176
 177         if (!ec)
 178                 return -EINVAL;
 179
 180         /* Poll the EC status register waiting for the event to occur. */
 181         switch (event) {
 182         case ACPI_EC_EVENT_OBF:
 183                 do {
 184                         acpi_hw_low_level_read(8, &acpi_ec_status,
 185                                                &ec->common.status_addr);
 186                         if (acpi_ec_status & ACPI_EC_FLAG_OBF)
 187                                 return 0;
 188                         udelay(ACPI_EC_UDELAY);
 189                 } while (--i > 0);
 190                 break;
 191         case ACPI_EC_EVENT_IBE:
 192                 do {
 193                         acpi_hw_low_level_read(8, &acpi_ec_status,
 194                                                &ec->common.status_addr);
 195                         if (!(acpi_ec_status & ACPI_EC_FLAG_IBF))
 196                                 return 0;
 197                         udelay(ACPI_EC_UDELAY);
 198                 } while (--i > 0);
 199                 break;
 200         default:
 201                 return -EINVAL;
 202         }
 203
 204         return -ETIME;
 205 }
 206 static int acpi_ec_intr_wait(union acpi_ec *ec, unsigned int event)
 207 {
 208         int result = 0;
 209
 210
 211         ec->intr.expect_event = event;
 212         smp_mb();
 213
 214         switch (event) {
 215         case ACPI_EC_EVENT_IBE:
 216                 if (~acpi_ec_read_status(ec) & event) {
 217                         ec->intr.expect_event = 0;
 218                         return 0;
 219                 }
 220                 break;
 221         default:
 222                 break;
 223         }
 224
 225         result = wait_event_timeout(ec->intr.wait,
 226                                     !ec->intr.expect_event,
 227                                     msecs_to_jiffies(ACPI_EC_DELAY));
 228
 229         ec->intr.expect_event = 0;
 230         smp_mb();
 231
 232         /*
 233          * Verify that the event in question has actually happened by
 234          * querying EC status. Do the check even if operation timed-out
 235          * to make sure that we did not miss interrupt.
 236          */
 237         switch (event) {
 238         case ACPI_EC_EVENT_OBF:
 239                 if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_OBF)
 240                         return 0;
 241                 break;
 242
 243         case ACPI_EC_EVENT_IBE:
 244                 if (~acpi_ec_read_status(ec) & ACPI_EC_FLAG_IBF)
 245                         return 0;
 246                 break;
 247         }
 248
 249         return -ETIME;
 250 }
 251
 252 #ifdef ACPI_FUTURE_USAGE
 253 /*
 254  * Note: samsung nv5000 doesn't work with ec burst mode.
 255  * http://bugzilla.kernel.org/show_bug.cgi?id=4980
 256  */
 257 int acpi_ec_enter_burst_mode(union acpi_ec *ec)
 258 {
 259         u32 tmp = 0;
 260         int status = 0;
 261
 262
 263         status = acpi_ec_read_status(ec);
 264         if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
 265                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 266                 if (status)
 267                         goto end;
 268                 acpi_hw_low_level_write(8, ACPI_EC_BURST_ENABLE,
 269                                         &ec->common.command_addr);
 270                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
 271                 acpi_hw_low_level_read(8, &tmp, &ec->common.data_addr);
 272                 if (tmp != 0x90) {      /* Burst ACK byte */
 273                         return -EINVAL;
 274                 }
 275         }
 276
 277         atomic_set(&ec->intr.leaving_burst, 0);
 278         return 0;
 279       end:
 280         ACPI_EXCEPTION ((AE_INFO, status, "EC wait, burst mode");
 281         return -1;
 282 }
 283
 284 int acpi_ec_leave_burst_mode(union acpi_ec *ec)
 285 {
 286         int status = 0;
 287
 288
 289         status = acpi_ec_read_status(ec);
 290         if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
 291                 status = acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
 292                 if(status)
 293                         goto end;
 294                 acpi_hw_low_level_write(8, ACPI_EC_BURST_DISABLE, &ec->common.command_addr);
 295                 acpi_ec_wait(ec, ACPI_EC_FLAG_IBF);
 296         }
 297         atomic_set(&ec->intr.leaving_burst, 1);
 298         return 0;
 299 end:
 300         ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode");
 301         return -1;
 302 }
 303 #endif /* ACPI_FUTURE_USAGE */
 304
 305 static int acpi_ec_read(union acpi_ec *ec, u8 address, u32 * data)
 306 {
 307         if (acpi_ec_poll_mode)
 308                 return acpi_ec_poll_read(ec, address, data);
 309         else
 310                 return acpi_ec_intr_read(ec, address, data);
 311 }
 312 static int acpi_ec_write(union acpi_ec *ec, u8 address, u8 data)
 313 {
 314         if (acpi_ec_poll_mode)
 315                 return acpi_ec_poll_write(ec, address, data);
 316         else
 317                 return acpi_ec_intr_write(ec, address, data);
 318 }
 319 static int acpi_ec_poll_read(union acpi_ec *ec, u8 address, u32 * data)
 320 {
 321         acpi_status status = AE_OK;
 322         int result = 0;
 323         u32 glk = 0;
 324
 325
 326         if (!ec || !data)
 327                 return -EINVAL;
 328
 329         *data = 0;
 330
 331         if (ec->common.global_lock) {
 332                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 333                 if (ACPI_FAILURE(status))
 334                         return -ENODEV;
 335         }
 336
 337         if (down_interruptible(&ec->poll.sem)) {
 338                 result = -ERESTARTSYS;
 339                 goto end_nosem;
 340         }
 341
 342         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
 343                                 &ec->common.command_addr);
 344         result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 345         if (result)
 346                 goto end;
 347
 348         acpi_hw_low_level_write(8, address, &ec->common.data_addr);
 349         result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
 350         if (result)
 351                 goto end;
 352
 353         acpi_hw_low_level_read(8, data, &ec->common.data_addr);
 354
 355         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
 356                           *data, address));
 357
 358       end:
 359         up(&ec->poll.sem);
 360 end_nosem:
 361         if (ec->common.global_lock)
 362                 acpi_release_global_lock(glk);
 363
 364         return result;
 365 }
 366
 367 static int acpi_ec_poll_write(union acpi_ec *ec, u8 address, u8 data)
 368 {
 369         int result = 0;
 370         acpi_status status = AE_OK;
 371         u32 glk = 0;
 372
 373
 374         if (!ec)
 375                 return -EINVAL;
 376
 377         if (ec->common.global_lock) {
 378                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 379                 if (ACPI_FAILURE(status))
 380                         return -ENODEV;
 381         }
 382
 383         if (down_interruptible(&ec->poll.sem)) {
 384                 result = -ERESTARTSYS;
 385                 goto end_nosem;
 386         }
 387
 388         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
 389                                 &ec->common.command_addr);
 390         result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 391         if (result)
 392                 goto end;
 393
 394         acpi_hw_low_level_write(8, address, &ec->common.data_addr);
 395         result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 396         if (result)
 397                 goto end;
 398
 399         acpi_hw_low_level_write(8, data, &ec->common.data_addr);
 400         result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 401         if (result)
 402                 goto end;
 403
 404         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
 405                           data, address));
 406
 407       end:
 408         up(&ec->poll.sem);
 409 end_nosem:
 410         if (ec->common.global_lock)
 411                 acpi_release_global_lock(glk);
 412
 413         return result;
 414 }
 415
 416 static int acpi_ec_intr_read(union acpi_ec *ec, u8 address, u32 * data)
 417 {
 418         int status = 0;
 419         u32 glk;
 420
 421
 422         if (!ec || !data)
 423                 return -EINVAL;
 424
 425         *data = 0;
 426
 427         if (ec->common.global_lock) {
 428                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 429                 if (ACPI_FAILURE(status))
 430                         return -ENODEV;
 431         }
 432
 433         WARN_ON(in_interrupt());
 434         down(&ec->intr.sem);
 435
 436         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 437         if (status) {
 438                 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
 439                 goto end;
 440         }
 441         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_READ,
 442                                 &ec->common.command_addr);
 443         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 444         if (status) {
 445                 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
 446         }
 447
 448         acpi_hw_low_level_write(8, address, &ec->common.data_addr);
 449         status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
 450         if (status) {
 451                 printk(KERN_DEBUG PREFIX "read EC, OB not full\n");
 452                 goto end;
 453         }
 454         acpi_hw_low_level_read(8, data, &ec->common.data_addr);
 455         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Read [%02x] from address [%02x]\n",
 456                           *data, address));
 457
 458       end:
 459         up(&ec->intr.sem);
 460
 461         if (ec->common.global_lock)
 462                 acpi_release_global_lock(glk);
 463
 464         return status;
 465 }
 466
 467 static int acpi_ec_intr_write(union acpi_ec *ec, u8 address, u8 data)
 468 {
 469         int status = 0;
 470         u32 glk;
 471
 472
 473         if (!ec)
 474                 return -EINVAL;
 475
 476         if (ec->common.global_lock) {
 477                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 478                 if (ACPI_FAILURE(status))
 479                         return -ENODEV;
 480         }
 481
 482         WARN_ON(in_interrupt());
 483         down(&ec->intr.sem);
 484
 485         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 486         if (status) {
 487                 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
 488         }
 489         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_WRITE,
 490                                 &ec->common.command_addr);
 491         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 492         if (status) {
 493                 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
 494         }
 495
 496         acpi_hw_low_level_write(8, address, &ec->common.data_addr);
 497         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 498         if (status) {
 499                 printk(KERN_DEBUG PREFIX "write EC, IB not empty\n");
 500         }
 501
 502         acpi_hw_low_level_write(8, data, &ec->common.data_addr);
 503
 504         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Wrote [%02x] to address [%02x]\n",
 505                           data, address));
 506
 507         up(&ec->intr.sem);
 508
 509         if (ec->common.global_lock)
 510                 acpi_release_global_lock(glk);
 511
 512         return status;
 513 }
 514
 515 /*
 516  * Externally callable EC access functions. For now, assume 1 EC only
 517  */
 518 int ec_read(u8 addr, u8 * val)
 519 {
 520         union acpi_ec *ec;
 521         int err;
 522         u32 temp_data;
 523
 524         if (!first_ec)
 525                 return -ENODEV;
 526
 527         ec = acpi_driver_data(first_ec);
 528
 529         err = acpi_ec_read(ec, addr, &temp_data);
 530
 531         if (!err) {
 532                 *val = temp_data;
 533                 return 0;
 534         } else
 535                 return err;
 536 }
 537
 538 EXPORT_SYMBOL(ec_read);
 539
 540 int ec_write(u8 addr, u8 val)
 541 {
 542         union acpi_ec *ec;
 543         int err;
 544
 545         if (!first_ec)
 546                 return -ENODEV;
 547
 548         ec = acpi_driver_data(first_ec);
 549
 550         err = acpi_ec_write(ec, addr, val);
 551
 552         return err;
 553 }
 554
 555 EXPORT_SYMBOL(ec_write);
 556
 557 static int acpi_ec_query(union acpi_ec *ec, u32 * data)
 558 {
 559         if (acpi_ec_poll_mode)
 560                 return acpi_ec_poll_query(ec, data);
 561         else
 562                 return acpi_ec_intr_query(ec, data);
 563 }
 564 static int acpi_ec_poll_query(union acpi_ec *ec, u32 * data)
 565 {
 566         int result = 0;
 567         acpi_status status = AE_OK;
 568         u32 glk = 0;
 569
 570
 571         if (!ec || !data)
 572                 return -EINVAL;
 573
 574         *data = 0;
 575
 576         if (ec->common.global_lock) {
 577                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 578                 if (ACPI_FAILURE(status))
 579                         return -ENODEV;
 580         }
 581
 582         /*
 583          * Query the EC to find out which _Qxx method we need to evaluate.
 584          * Note that successful completion of the query causes the ACPI_EC_SCI
 585          * bit to be cleared (and thus clearing the interrupt source).
 586          */
 587         if (down_interruptible(&ec->poll.sem)) {
 588                 result = -ERESTARTSYS;
 589                 goto end_nosem;
 590         }
 591
 592         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
 593                                 &ec->common.command_addr);
 594         result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
 595         if (result)
 596                 goto end;
 597
 598         acpi_hw_low_level_read(8, data, &ec->common.data_addr);
 599         if (!*data)
 600                 result = -ENODATA;
 601
 602       end:
 603         up(&ec->poll.sem);
 604 end_nosem:
 605         if (ec->common.global_lock)
 606                 acpi_release_global_lock(glk);
 607
 608         return result;
 609 }
 610 static int acpi_ec_intr_query(union acpi_ec *ec, u32 * data)
 611 {
 612         int status = 0;
 613         u32 glk;
 614
 615
 616         if (!ec || !data)
 617                 return -EINVAL;
 618         *data = 0;
 619
 620         if (ec->common.global_lock) {
 621                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 622                 if (ACPI_FAILURE(status))
 623                         return -ENODEV;
 624         }
 625
 626         down(&ec->intr.sem);
 627
 628         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBE);
 629         if (status) {
 630                 printk(KERN_DEBUG PREFIX "query EC, IB not empty\n");
 631                 goto end;
 632         }
 633         /*
 634          * Query the EC to find out which _Qxx method we need to evaluate.
 635          * Note that successful completion of the query causes the ACPI_EC_SCI
 636          * bit to be cleared (and thus clearing the interrupt source).
 637          */
 638         acpi_hw_low_level_write(8, ACPI_EC_COMMAND_QUERY,
 639                                 &ec->common.command_addr);
 640         status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF);
 641         if (status) {
 642                 printk(KERN_DEBUG PREFIX "query EC, OB not full\n");
 643                 goto end;
 644         }
 645
 646         acpi_hw_low_level_read(8, data, &ec->common.data_addr);
 647         if (!*data)
 648                 status = -ENODATA;
 649
 650       end:
 651         up(&ec->intr.sem);
 652
 653         if (ec->common.global_lock)
 654                 acpi_release_global_lock(glk);
 655
 656         return status;
 657 }
 658
 659 /* --------------------------------------------------------------------------
 660                                 Event Management
 661    -------------------------------------------------------------------------- */
 662
 663 union acpi_ec_query_data {
 664         acpi_handle handle;
 665         u8 data;
 666 };
 667
 668 static void acpi_ec_gpe_query(void *ec_cxt)
 669 {
 670         if (acpi_ec_poll_mode)
 671                 acpi_ec_gpe_poll_query(ec_cxt);
 672         else
 673                 acpi_ec_gpe_intr_query(ec_cxt);
 674 }
 675
 676 static void acpi_ec_gpe_poll_query(void *ec_cxt)
 677 {
 678         union acpi_ec *ec = (union acpi_ec *)ec_cxt;
 679         u32 value = 0;
 680         static char object_name[5] = { '_', 'Q', '0', '0', '\0' };
 681         const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
 682                 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
 683         };
 684
 685
 686         if (!ec_cxt)
 687                 goto end;
 688
 689         if (down_interruptible (&ec->poll.sem)) {
 690                 return;
 691         }
 692         acpi_hw_low_level_read(8, &value, &ec->common.command_addr);
 693         up(&ec->poll.sem);
 694
 695         /* TBD: Implement asynch events!
 696          * NOTE: All we care about are EC-SCI's.  Other EC events are
 697          * handled via polling (yuck!).  This is because some systems
 698          * treat EC-SCIs as level (versus EDGE!) triggered, preventing
 699          *  a purely interrupt-driven approach (grumble, grumble).
 700          */
 701         if (!(value & ACPI_EC_FLAG_SCI))
 702                 goto end;
 703
 704         if (acpi_ec_query(ec, &value))
 705                 goto end;
 706
 707         object_name[2] = hex[((value >> 4) & 0x0F)];
 708         object_name[3] = hex[(value & 0x0F)];
 709
 710         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
 711
 712         acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
 713
 714       end:
 715         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
 716 }
 717 static void acpi_ec_gpe_intr_query(void *ec_cxt)
 718 {
 719         union acpi_ec *ec = (union acpi_ec *)ec_cxt;
 720         u32 value;
 721         int result = -ENODATA;
 722         static char object_name[5] = { '_', 'Q', '0', '0', '\0' };
 723         const char hex[] = { '0', '1', '2', '3', '4', '5', '6', '7',
 724                 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
 725         };
 726
 727
 728         if (acpi_ec_read_status(ec) & ACPI_EC_FLAG_SCI)
 729                 result = acpi_ec_query(ec, &value);
 730
 731         if (result)
 732                 goto end;
 733
 734         object_name[2] = hex[((value >> 4) & 0x0F)];
 735         object_name[3] = hex[(value & 0x0F)];
 736
 737         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s\n", object_name));
 738
 739         acpi_evaluate_object(ec->common.handle, object_name, NULL, NULL);
 740       end:
 741         atomic_dec(&ec->intr.pending_gpe);
 742         return;
 743 }
 744
 745 static u32 acpi_ec_gpe_handler(void *data)
 746 {
 747         if (acpi_ec_poll_mode)
 748                 return acpi_ec_gpe_poll_handler(data);
 749         else
 750                 return acpi_ec_gpe_intr_handler(data);
 751 }
 752 static u32 acpi_ec_gpe_poll_handler(void *data)
 753 {
 754         acpi_status status = AE_OK;
 755         union acpi_ec *ec = (union acpi_ec *)data;
 756
 757         if (!ec)
 758                 return ACPI_INTERRUPT_NOT_HANDLED;
 759
 760         acpi_disable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
 761
 762         status = acpi_os_execute(OSL_EC_POLL_HANDLER, acpi_ec_gpe_query, ec);
 763
 764         if (status == AE_OK)
 765                 return ACPI_INTERRUPT_HANDLED;
 766         else
 767                 return ACPI_INTERRUPT_NOT_HANDLED;
 768 }
 769 static u32 acpi_ec_gpe_intr_handler(void *data)
 770 {
 771         acpi_status status = AE_OK;
 772         u32 value;
 773         union acpi_ec *ec = (union acpi_ec *)data;
 774
 775         if (!ec)
 776                 return ACPI_INTERRUPT_NOT_HANDLED;
 777
 778         acpi_clear_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
 779         value = acpi_ec_read_status(ec);
 780
 781         switch (ec->intr.expect_event) {
 782         case ACPI_EC_EVENT_OBF:
 783                 if (!(value & ACPI_EC_FLAG_OBF))
 784                         break;
 785         case ACPI_EC_EVENT_IBE:
 786                 if ((value & ACPI_EC_FLAG_IBF))
 787                         break;
 788                 ec->intr.expect_event = 0;
 789                 wake_up(&ec->intr.wait);
 790                 return ACPI_INTERRUPT_HANDLED;
 791         default:
 792                 break;
 793         }
 794
 795         if (value & ACPI_EC_FLAG_SCI) {
 796                 atomic_add(1, &ec->intr.pending_gpe);
 797                 status = acpi_os_execute(OSL_EC_BURST_HANDLER,
 798                                                      acpi_ec_gpe_query, ec);
 799                 return status == AE_OK ?
 800                     ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
 801         }
 802         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
 803         return status == AE_OK ?
 804             ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
 805 }
 806
 807 /* --------------------------------------------------------------------------
 808                              Address Space Management
 809    -------------------------------------------------------------------------- */
 810
 811 static acpi_status
 812 acpi_ec_space_setup(acpi_handle region_handle,
 813                     u32 function, void *handler_context, void **return_context)
 814 {
 815         /*
 816          * The EC object is in the handler context and is needed
 817          * when calling the acpi_ec_space_handler.
 818          */
 819         *return_context = (function != ACPI_REGION_DEACTIVATE) ?
 820             handler_context : NULL;
 821
 822         return AE_OK;
 823 }
 824
 825 static acpi_status
 826 acpi_ec_space_handler(u32 function,
 827                       acpi_physical_address address,
 828                       u32 bit_width,
 829                       acpi_integer * value,
 830                       void *handler_context, void *region_context)
 831 {
 832         int result = 0;
 833         union acpi_ec *ec = NULL;
 834         u64 temp = *value;
 835         acpi_integer f_v = 0;
 836         int i = 0;
 837
 838
 839         if ((address > 0xFF) || !value || !handler_context)
 840                 return AE_BAD_PARAMETER;
 841
 842         if (bit_width != 8 && acpi_strict) {
 843                 printk(KERN_WARNING PREFIX
 844                        "acpi_ec_space_handler: bit_width should be 8\n");
 845                 return AE_BAD_PARAMETER;
 846         }
 847
 848         ec = (union acpi_ec *)handler_context;
 849
 850       next_byte:
 851         switch (function) {
 852         case ACPI_READ:
 853                 temp = 0;
 854                 result = acpi_ec_read(ec, (u8) address, (u32 *) & temp);
 855                 break;
 856         case ACPI_WRITE:
 857                 result = acpi_ec_write(ec, (u8) address, (u8) temp);
 858                 break;
 859         default:
 860                 result = -EINVAL;
 861                 goto out;
 862                 break;
 863         }
 864
 865         bit_width -= 8;
 866         if (bit_width) {
 867                 if (function == ACPI_READ)
 868                         f_v |= temp << 8 * i;
 869                 if (function == ACPI_WRITE)
 870                         temp >>= 8;
 871                 i++;
 872                 address++;
 873                 goto next_byte;
 874         }
 875
 876         if (function == ACPI_READ) {
 877                 f_v |= temp << 8 * i;
 878                 *value = f_v;
 879         }
 880
 881       out:
 882         switch (result) {
 883         case -EINVAL:
 884                 return AE_BAD_PARAMETER;
 885                 break;
 886         case -ENODEV:
 887                 return AE_NOT_FOUND;
 888                 break;
 889         case -ETIME:
 890                 return AE_TIME;
 891                 break;
 892         default:
 893                 return AE_OK;
 894         }
 895 }
 896
 897 /* --------------------------------------------------------------------------
 898                               FS Interface (/proc)
 899    -------------------------------------------------------------------------- */
 900
 901 static struct proc_dir_entry *acpi_ec_dir;
 902
 903 static int acpi_ec_read_info(struct seq_file *seq, void *offset)
 904 {
 905         union acpi_ec *ec = (union acpi_ec *)seq->private;
 906
 907
 908         if (!ec)
 909                 goto end;
 910
 911         seq_printf(seq, "gpe bit:                 0x%02x\n",
 912                    (u32) ec->common.gpe_bit);
 913         seq_printf(seq, "ports:                   0x%02x, 0x%02x\n",
 914                    (u32) ec->common.status_addr.address,
 915                    (u32) ec->common.data_addr.address);
 916         seq_printf(seq, "use global lock:         %s\n",
 917                    ec->common.global_lock ? "yes" : "no");
 918         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
 919
 920       end:
 921         return 0;
 922 }
 923
 924 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
 925 {
 926         return single_open(file, acpi_ec_read_info, PDE(inode)->data);
 927 }
 928
 929 static struct file_operations acpi_ec_info_ops = {
 930         .open = acpi_ec_info_open_fs,
 931         .read = seq_read,
 932         .llseek = seq_lseek,
 933         .release = single_release,
 934         .owner = THIS_MODULE,
 935 };
 936
 937 static int acpi_ec_add_fs(struct acpi_device *device)
 938 {
 939         struct proc_dir_entry *entry = NULL;
 940
 941
 942         if (!acpi_device_dir(device)) {
 943                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 944                                                      acpi_ec_dir);
 945                 if (!acpi_device_dir(device))
 946                         return -ENODEV;
 947         }
 948
 949         entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
 950                                   acpi_device_dir(device));
 951         if (!entry)
 952                 return -ENODEV;
 953         else {
 954                 entry->proc_fops = &acpi_ec_info_ops;
 955                 entry->data = acpi_driver_data(device);
 956                 entry->owner = THIS_MODULE;
 957         }
 958
 959         return 0;
 960 }
 961
 962 static int acpi_ec_remove_fs(struct acpi_device *device)
 963 {
 964
 965         if (acpi_device_dir(device)) {
 966                 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
 967                 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
 968                 acpi_device_dir(device) = NULL;
 969         }
 970
 971         return 0;
 972 }
 973
 974 /* --------------------------------------------------------------------------
 975                                Driver Interface
 976    -------------------------------------------------------------------------- */
 977
 978 static int acpi_ec_poll_add(struct acpi_device *device)
 979 {
 980         int result = 0;
 981         acpi_status status = AE_OK;
 982         union acpi_ec *ec = NULL;
 983
 984
 985         if (!device)
 986                 return -EINVAL;
 987
 988         ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
 989         if (!ec)
 990                 return -ENOMEM;
 991         memset(ec, 0, sizeof(union acpi_ec));
 992
 993         ec->common.handle = device->handle;
 994         ec->common.uid = -1;
 995         init_MUTEX(&ec->poll.sem);
 996         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
 997         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
 998         acpi_driver_data(device) = ec;
 999
1000         /* Use the global lock for all EC transactions? */
1001         acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
1002                               &ec->common.global_lock);
1003
1004         /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
1005            http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
1006         if (ec_ecdt) {
1007                 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1008                                                   ACPI_ADR_SPACE_EC,
1009                                                   &acpi_ec_space_handler);
1010
1011                 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1012                                         &acpi_ec_gpe_handler);
1013
1014                 kfree(ec_ecdt);
1015         }
1016
1017         /* Get GPE bit assignment (EC events). */
1018         /* TODO: Add support for _GPE returning a package */
1019         status =
1020             acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
1021                                   &ec->common.gpe_bit);
1022         if (ACPI_FAILURE(status)) {
1023                 ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit"));
1024                 result = -ENODEV;
1025                 goto end;
1026         }
1027
1028         result = acpi_ec_add_fs(device);
1029         if (result)
1030                 goto end;
1031
1032         printk(KERN_INFO PREFIX "%s [%s] (gpe %d) polling mode.\n",
1033                acpi_device_name(device), acpi_device_bid(device),
1034                (u32) ec->common.gpe_bit);
1035
1036         if (!first_ec)
1037                 first_ec = device;
1038
1039       end:
1040         if (result)
1041                 kfree(ec);
1042
1043         return result;
1044 }
1045 static int acpi_ec_intr_add(struct acpi_device *device)
1046 {
1047         int result = 0;
1048         acpi_status status = AE_OK;
1049         union acpi_ec *ec = NULL;
1050
1051
1052         if (!device)
1053                 return -EINVAL;
1054
1055         ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1056         if (!ec)
1057                 return -ENOMEM;
1058         memset(ec, 0, sizeof(union acpi_ec));
1059
1060         ec->common.handle = device->handle;
1061         ec->common.uid = -1;
1062         atomic_set(&ec->intr.pending_gpe, 0);
1063         atomic_set(&ec->intr.leaving_burst, 1);
1064         init_MUTEX(&ec->intr.sem);
1065         init_waitqueue_head(&ec->intr.wait);
1066         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1067         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1068         acpi_driver_data(device) = ec;
1069
1070         /* Use the global lock for all EC transactions? */
1071         acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
1072                               &ec->common.global_lock);
1073
1074         /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
1075            http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
1076         if (ec_ecdt) {
1077                 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1078                                                   ACPI_ADR_SPACE_EC,
1079                                                   &acpi_ec_space_handler);
1080
1081                 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1082                                         &acpi_ec_gpe_handler);
1083
1084                 kfree(ec_ecdt);
1085         }
1086
1087         /* Get GPE bit assignment (EC events). */
1088         /* TODO: Add support for _GPE returning a package */
1089         status =
1090             acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
1091                                   &ec->common.gpe_bit);
1092         if (ACPI_FAILURE(status)) {
1093                 printk(KERN_ERR PREFIX "Obtaining GPE bit assignment\n");
1094                 result = -ENODEV;
1095                 goto end;
1096         }
1097
1098         result = acpi_ec_add_fs(device);
1099         if (result)
1100                 goto end;
1101
1102         printk(KERN_INFO PREFIX "%s [%s] (gpe %d) interrupt mode.\n",
1103                acpi_device_name(device), acpi_device_bid(device),
1104                (u32) ec->common.gpe_bit);
1105
1106         if (!first_ec)
1107                 first_ec = device;
1108
1109       end:
1110         if (result)
1111                 kfree(ec);
1112
1113         return result;
1114 }
1115
1116 static int acpi_ec_remove(struct acpi_device *device, int type)
1117 {
1118         union acpi_ec *ec = NULL;
1119
1120
1121         if (!device)
1122                 return -EINVAL;
1123
1124         ec = acpi_driver_data(device);
1125
1126         acpi_ec_remove_fs(device);
1127
1128         kfree(ec);
1129
1130         return 0;
1131 }
1132
1133 static acpi_status
1134 acpi_ec_io_ports(struct acpi_resource *resource, void *context)
1135 {
1136         union acpi_ec *ec = (union acpi_ec *)context;
1137         struct acpi_generic_address *addr;
1138
1139         if (resource->type != ACPI_RESOURCE_TYPE_IO) {
1140                 return AE_OK;
1141         }
1142
1143         /*
1144          * The first address region returned is the data port, and
1145          * the second address region returned is the status/command
1146          * port.
1147          */
1148         if (ec->common.data_addr.register_bit_width == 0) {
1149                 addr = &ec->common.data_addr;
1150         } else if (ec->common.command_addr.register_bit_width == 0) {
1151                 addr = &ec->common.command_addr;
1152         } else {
1153                 return AE_CTRL_TERMINATE;
1154         }
1155
1156         addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1157         addr->register_bit_width = 8;
1158         addr->register_bit_offset = 0;
1159         addr->address = resource->data.io.minimum;
1160
1161         return AE_OK;
1162 }
1163
1164 static int acpi_ec_start(struct acpi_device *device)
1165 {
1166         acpi_status status = AE_OK;
1167         union acpi_ec *ec = NULL;
1168
1169
1170         if (!device)
1171                 return -EINVAL;
1172
1173         ec = acpi_driver_data(device);
1174
1175         if (!ec)
1176                 return -EINVAL;
1177
1178         /*
1179          * Get I/O port addresses. Convert to GAS format.
1180          */
1181         status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS,
1182                                      acpi_ec_io_ports, ec);
1183         if (ACPI_FAILURE(status)
1184             || ec->common.command_addr.register_bit_width == 0) {
1185                 printk(KERN_ERR PREFIX "Error getting I/O port addresses\n");
1186                 return -ENODEV;
1187         }
1188
1189         ec->common.status_addr = ec->common.command_addr;
1190
1191         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n",
1192                           (u32) ec->common.gpe_bit,
1193                           (u32) ec->common.command_addr.address,
1194                           (u32) ec->common.data_addr.address));
1195
1196         /*
1197          * Install GPE handler
1198          */
1199         status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit,
1200                                           ACPI_GPE_EDGE_TRIGGERED,
1201                                           &acpi_ec_gpe_handler, ec);
1202         if (ACPI_FAILURE(status)) {
1203                 return -ENODEV;
1204         }
1205         acpi_set_gpe_type(NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1206         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
1207
1208         status = acpi_install_address_space_handler(ec->common.handle,
1209                                                     ACPI_ADR_SPACE_EC,
1210                                                     &acpi_ec_space_handler,
1211                                                     &acpi_ec_space_setup, ec);
1212         if (ACPI_FAILURE(status)) {
1213                 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
1214                                         &acpi_ec_gpe_handler);
1215                 return -ENODEV;
1216         }
1217
1218         return AE_OK;
1219 }
1220
1221 static int acpi_ec_stop(struct acpi_device *device, int type)
1222 {
1223         acpi_status status = AE_OK;
1224         union acpi_ec *ec = NULL;
1225
1226
1227         if (!device)
1228                 return -EINVAL;
1229
1230         ec = acpi_driver_data(device);
1231
1232         status = acpi_remove_address_space_handler(ec->common.handle,
1233                                                    ACPI_ADR_SPACE_EC,
1234                                                    &acpi_ec_space_handler);
1235         if (ACPI_FAILURE(status))
1236                 return -ENODEV;
1237
1238         status =
1239             acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
1240                                     &acpi_ec_gpe_handler);
1241         if (ACPI_FAILURE(status))
1242                 return -ENODEV;
1243
1244         return 0;
1245 }
1246
1247 static acpi_status __init
1248 acpi_fake_ecdt_callback(acpi_handle handle,
1249                         u32 Level, void *context, void **retval)
1250 {
1251
1252         if (acpi_ec_poll_mode)
1253                 return acpi_fake_ecdt_poll_callback(handle,
1254                                                        Level, context, retval);
1255         else
1256                 return acpi_fake_ecdt_intr_callback(handle,
1257                                                      Level, context, retval);
1258 }
1259
1260 static acpi_status __init
1261 acpi_fake_ecdt_poll_callback(acpi_handle handle,
1262                                 u32 Level, void *context, void **retval)
1263 {
1264         acpi_status status;
1265
1266         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1267                                      acpi_ec_io_ports, ec_ecdt);
1268         if (ACPI_FAILURE(status))
1269                 return status;
1270         ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1271
1272         ec_ecdt->common.uid = -1;
1273         acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1274
1275         status =
1276             acpi_evaluate_integer(handle, "_GPE", NULL,
1277                                   &ec_ecdt->common.gpe_bit);
1278         if (ACPI_FAILURE(status))
1279                 return status;
1280         init_MUTEX(&ec_ecdt->poll.sem);
1281         ec_ecdt->common.global_lock = TRUE;
1282         ec_ecdt->common.handle = handle;
1283
1284         printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1285                (u32) ec_ecdt->common.gpe_bit,
1286                (u32) ec_ecdt->common.command_addr.address,
1287                (u32) ec_ecdt->common.data_addr.address);
1288
1289         return AE_CTRL_TERMINATE;
1290 }
1291
1292 static acpi_status __init
1293 acpi_fake_ecdt_intr_callback(acpi_handle handle,
1294                               u32 Level, void *context, void **retval)
1295 {
1296         acpi_status status;
1297
1298         init_MUTEX(&ec_ecdt->intr.sem);
1299         init_waitqueue_head(&ec_ecdt->intr.wait);
1300         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1301                                      acpi_ec_io_ports, ec_ecdt);
1302         if (ACPI_FAILURE(status))
1303                 return status;
1304         ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1305
1306         ec_ecdt->common.uid = -1;
1307         acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1308
1309         status =
1310             acpi_evaluate_integer(handle, "_GPE", NULL,
1311                                   &ec_ecdt->common.gpe_bit);
1312         if (ACPI_FAILURE(status))
1313                 return status;
1314         ec_ecdt->common.global_lock = TRUE;
1315         ec_ecdt->common.handle = handle;
1316
1317         printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1318                (u32) ec_ecdt->common.gpe_bit,
1319                (u32) ec_ecdt->common.command_addr.address,
1320                (u32) ec_ecdt->common.data_addr.address);
1321
1322         return AE_CTRL_TERMINATE;
1323 }
1324
1325 /*
1326  * Some BIOS (such as some from Gateway laptops) access EC region very early
1327  * such as in BAT0._INI or EC._INI before an EC device is found and
1328  * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
1329  * required, but if EC regison is accessed early, it is required.
1330  * The routine tries to workaround the BIOS bug by pre-scan EC device
1331  * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
1332  * op region (since _REG isn't invoked yet). The assumption is true for
1333  * all systems found.
1334  */
1335 static int __init acpi_ec_fake_ecdt(void)
1336 {
1337         acpi_status status;
1338         int ret = 0;
1339
1340         printk(KERN_INFO PREFIX "Try to make an fake ECDT\n");
1341
1342         ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1343         if (!ec_ecdt) {
1344                 ret = -ENOMEM;
1345                 goto error;
1346         }
1347         memset(ec_ecdt, 0, sizeof(union acpi_ec));
1348
1349         status = acpi_get_devices(ACPI_EC_HID,
1350                                   acpi_fake_ecdt_callback, NULL, NULL);
1351         if (ACPI_FAILURE(status)) {
1352                 kfree(ec_ecdt);
1353                 ec_ecdt = NULL;
1354                 ret = -ENODEV;
1355                 goto error;
1356         }
1357         return 0;
1358       error:
1359         printk(KERN_ERR PREFIX "Can't make an fake ECDT\n");
1360         return ret;
1361 }
1362
1363 static int __init acpi_ec_get_real_ecdt(void)
1364 {
1365         if (acpi_ec_poll_mode)
1366                 return acpi_ec_poll_get_real_ecdt();
1367         else
1368                 return acpi_ec_intr_get_real_ecdt();
1369 }
1370
1371 static int __init acpi_ec_poll_get_real_ecdt(void)
1372 {
1373         acpi_status status;
1374         struct acpi_table_ecdt *ecdt_ptr;
1375
1376         status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1377                                          (struct acpi_table_header **)
1378                                          &ecdt_ptr);
1379         if (ACPI_FAILURE(status))
1380                 return -ENODEV;
1381
1382         printk(KERN_INFO PREFIX "Found ECDT\n");
1383
1384         /*
1385          * Generate a temporary ec context to use until the namespace is scanned
1386          */
1387         ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1388         if (!ec_ecdt)
1389                 return -ENOMEM;
1390         memset(ec_ecdt, 0, sizeof(union acpi_ec));
1391
1392         ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1393         ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1394         ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1395         ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1396         init_MUTEX(&ec_ecdt->poll.sem);
1397         /* use the GL just to be safe */
1398         ec_ecdt->common.global_lock = TRUE;
1399         ec_ecdt->common.uid = ecdt_ptr->uid;
1400
1401         status =
1402             acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1403         if (ACPI_FAILURE(status)) {
1404                 goto error;
1405         }
1406
1407         return 0;
1408       error:
1409         printk(KERN_ERR PREFIX "Could not use ECDT\n");
1410         kfree(ec_ecdt);
1411         ec_ecdt = NULL;
1412
1413         return -ENODEV;
1414 }
1415
1416 static int __init acpi_ec_intr_get_real_ecdt(void)
1417 {
1418         acpi_status status;
1419         struct acpi_table_ecdt *ecdt_ptr;
1420
1421         status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1422                                          (struct acpi_table_header **)
1423                                          &ecdt_ptr);
1424         if (ACPI_FAILURE(status))
1425                 return -ENODEV;
1426
1427         printk(KERN_INFO PREFIX "Found ECDT\n");
1428
1429         /*
1430          * Generate a temporary ec context to use until the namespace is scanned
1431          */
1432         ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1433         if (!ec_ecdt)
1434                 return -ENOMEM;
1435         memset(ec_ecdt, 0, sizeof(union acpi_ec));
1436
1437         init_MUTEX(&ec_ecdt->intr.sem);
1438         init_waitqueue_head(&ec_ecdt->intr.wait);
1439         ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1440         ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1441         ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1442         ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1443         /* use the GL just to be safe */
1444         ec_ecdt->common.global_lock = TRUE;
1445         ec_ecdt->common.uid = ecdt_ptr->uid;
1446
1447         status =
1448             acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1449         if (ACPI_FAILURE(status)) {
1450                 goto error;
1451         }
1452
1453         return 0;
1454       error:
1455         printk(KERN_ERR PREFIX "Could not use ECDT\n");
1456         kfree(ec_ecdt);
1457         ec_ecdt = NULL;
1458
1459         return -ENODEV;
1460 }
1461
1462 static int __initdata acpi_fake_ecdt_enabled;
1463 int __init acpi_ec_ecdt_probe(void)
1464 {
1465         acpi_status status;
1466         int ret;
1467
1468         ret = acpi_ec_get_real_ecdt();
1469         /* Try to make a fake ECDT */
1470         if (ret && acpi_fake_ecdt_enabled) {
1471                 ret = acpi_ec_fake_ecdt();
1472         }
1473
1474         if (ret)
1475                 return 0;
1476
1477         /*
1478          * Install GPE handler
1479          */
1480         status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1481                                           ACPI_GPE_EDGE_TRIGGERED,
1482                                           &acpi_ec_gpe_handler, ec_ecdt);
1483         if (ACPI_FAILURE(status)) {
1484                 goto error;
1485         }
1486         acpi_set_gpe_type(NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1487         acpi_enable_gpe(NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR);
1488
1489         status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
1490                                                     ACPI_ADR_SPACE_EC,
1491                                                     &acpi_ec_space_handler,
1492                                                     &acpi_ec_space_setup,
1493                                                     ec_ecdt);
1494         if (ACPI_FAILURE(status)) {
1495                 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1496                                         &acpi_ec_gpe_handler);
1497                 goto error;
1498         }
1499
1500         return 0;
1501
1502       error:
1503         printk(KERN_ERR PREFIX "Could not use ECDT\n");
1504         kfree(ec_ecdt);
1505         ec_ecdt = NULL;
1506
1507         return -ENODEV;
1508 }
1509
1510 static int __init acpi_ec_init(void)
1511 {
1512         int result = 0;
1513
1514
1515         if (acpi_disabled)
1516                 return 0;
1517
1518         acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1519         if (!acpi_ec_dir)
1520                 return -ENODEV;
1521
1522         /* Now register the driver for the EC */
1523         result = acpi_bus_register_driver(&acpi_ec_driver);
1524         if (result < 0) {
1525                 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1526                 return -ENODEV;
1527         }
1528
1529         return result;
1530 }
1531
1532 subsys_initcall(acpi_ec_init);
1533
1534 /* EC driver currently not unloadable */
1535 #if 0
1536 static void __exit acpi_ec_exit(void)
1537 {
1538
1539         acpi_bus_unregister_driver(&acpi_ec_driver);
1540
1541         remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1542
1543         return;
1544 }
1545 #endif                          /* 0 */
1546
1547 static int __init acpi_fake_ecdt_setup(char *str)
1548 {
1549         acpi_fake_ecdt_enabled = 1;
1550         return 1;
1551 }
1552
1553 __setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
1554 static int __init acpi_ec_set_intr_mode(char *str)
1555 {
1556         int intr;
1557
1558         if (!get_option(&str, &intr))
1559                 return 0;
1560
1561         if (intr) {
1562                 acpi_ec_poll_mode = EC_INTR;
1563                 acpi_ec_driver.ops.add = acpi_ec_intr_add;
1564         } else {
1565                 acpi_ec_poll_mode = EC_POLL;
1566                 acpi_ec_driver.ops.add = acpi_ec_poll_add;
1567         }
1568         printk(KERN_INFO PREFIX "EC %s mode.\n", intr ? "interrupt" : "polling");
1569         return 1;
1570 }
1571
1572 __setup("ec_intr=", acpi_ec_set_intr_mode);