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) & ACPI_EC_FLAG_IBF) {
 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                 ec->intr.expect_event = 0;
 786                 wake_up(&ec->intr.wait);
 787                 break;
 788         case ACPI_EC_EVENT_IBE:
 789                 if ((value & ACPI_EC_FLAG_IBF))
 790                         break;
 791                 ec->intr.expect_event = 0;
 792                 wake_up(&ec->intr.wait);
 793                 break;
 794         default:
 795                 break;
 796         }
 797
 798         if (value & ACPI_EC_FLAG_SCI) {
 799                 atomic_add(1, &ec->intr.pending_gpe);
 800                 status = acpi_os_execute(OSL_EC_BURST_HANDLER,
 801                                                      acpi_ec_gpe_query, ec);
 802                 return status == AE_OK ?
 803                     ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
 804         }
 805         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_ISR);
 806         return status == AE_OK ?
 807             ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
 808 }
 809
 810 /* --------------------------------------------------------------------------
 811                              Address Space Management
 812    -------------------------------------------------------------------------- */
 813
 814 static acpi_status
 815 acpi_ec_space_setup(acpi_handle region_handle,
 816                     u32 function, void *handler_context, void **return_context)
 817 {
 818         /*
 819          * The EC object is in the handler context and is needed
 820          * when calling the acpi_ec_space_handler.
 821          */
 822         *return_context = (function != ACPI_REGION_DEACTIVATE) ?
 823             handler_context : NULL;
 824
 825         return AE_OK;
 826 }
 827
 828 static acpi_status
 829 acpi_ec_space_handler(u32 function,
 830                       acpi_physical_address address,
 831                       u32 bit_width,
 832                       acpi_integer * value,
 833                       void *handler_context, void *region_context)
 834 {
 835         int result = 0;
 836         union acpi_ec *ec = NULL;
 837         u64 temp = *value;
 838         acpi_integer f_v = 0;
 839         int i = 0;
 840
 841
 842         if ((address > 0xFF) || !value || !handler_context)
 843                 return AE_BAD_PARAMETER;
 844
 845         if (bit_width != 8 && acpi_strict) {
 846                 printk(KERN_WARNING PREFIX
 847                        "acpi_ec_space_handler: bit_width should be 8\n");
 848                 return AE_BAD_PARAMETER;
 849         }
 850
 851         ec = (union acpi_ec *)handler_context;
 852
 853       next_byte:
 854         switch (function) {
 855         case ACPI_READ:
 856                 temp = 0;
 857                 result = acpi_ec_read(ec, (u8) address, (u32 *) & temp);
 858                 break;
 859         case ACPI_WRITE:
 860                 result = acpi_ec_write(ec, (u8) address, (u8) temp);
 861                 break;
 862         default:
 863                 result = -EINVAL;
 864                 goto out;
 865                 break;
 866         }
 867
 868         bit_width -= 8;
 869         if (bit_width) {
 870                 if (function == ACPI_READ)
 871                         f_v |= temp << 8 * i;
 872                 if (function == ACPI_WRITE)
 873                         temp >>= 8;
 874                 i++;
 875                 address++;
 876                 goto next_byte;
 877         }
 878
 879         if (function == ACPI_READ) {
 880                 f_v |= temp << 8 * i;
 881                 *value = f_v;
 882         }
 883
 884       out:
 885         switch (result) {
 886         case -EINVAL:
 887                 return AE_BAD_PARAMETER;
 888                 break;
 889         case -ENODEV:
 890                 return AE_NOT_FOUND;
 891                 break;
 892         case -ETIME:
 893                 return AE_TIME;
 894                 break;
 895         default:
 896                 return AE_OK;
 897         }
 898 }
 899
 900 /* --------------------------------------------------------------------------
 901                               FS Interface (/proc)
 902    -------------------------------------------------------------------------- */
 903
 904 static struct proc_dir_entry *acpi_ec_dir;
 905
 906 static int acpi_ec_read_info(struct seq_file *seq, void *offset)
 907 {
 908         union acpi_ec *ec = (union acpi_ec *)seq->private;
 909
 910
 911         if (!ec)
 912                 goto end;
 913
 914         seq_printf(seq, "gpe bit:                 0x%02x\n",
 915                    (u32) ec->common.gpe_bit);
 916         seq_printf(seq, "ports:                   0x%02x, 0x%02x\n",
 917                    (u32) ec->common.status_addr.address,
 918                    (u32) ec->common.data_addr.address);
 919         seq_printf(seq, "use global lock:         %s\n",
 920                    ec->common.global_lock ? "yes" : "no");
 921         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
 922
 923       end:
 924         return 0;
 925 }
 926
 927 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
 928 {
 929         return single_open(file, acpi_ec_read_info, PDE(inode)->data);
 930 }
 931
 932 static struct file_operations acpi_ec_info_ops = {
 933         .open = acpi_ec_info_open_fs,
 934         .read = seq_read,
 935         .llseek = seq_lseek,
 936         .release = single_release,
 937         .owner = THIS_MODULE,
 938 };
 939
 940 static int acpi_ec_add_fs(struct acpi_device *device)
 941 {
 942         struct proc_dir_entry *entry = NULL;
 943
 944
 945         if (!acpi_device_dir(device)) {
 946                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 947                                                      acpi_ec_dir);
 948                 if (!acpi_device_dir(device))
 949                         return -ENODEV;
 950         }
 951
 952         entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
 953                                   acpi_device_dir(device));
 954         if (!entry)
 955                 return -ENODEV;
 956         else {
 957                 entry->proc_fops = &acpi_ec_info_ops;
 958                 entry->data = acpi_driver_data(device);
 959                 entry->owner = THIS_MODULE;
 960         }
 961
 962         return 0;
 963 }
 964
 965 static int acpi_ec_remove_fs(struct acpi_device *device)
 966 {
 967
 968         if (acpi_device_dir(device)) {
 969                 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
 970                 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
 971                 acpi_device_dir(device) = NULL;
 972         }
 973
 974         return 0;
 975 }
 976
 977 /* --------------------------------------------------------------------------
 978                                Driver Interface
 979    -------------------------------------------------------------------------- */
 980
 981 static int acpi_ec_poll_add(struct acpi_device *device)
 982 {
 983         int result = 0;
 984         acpi_status status = AE_OK;
 985         union acpi_ec *ec = NULL;
 986
 987
 988         if (!device)
 989                 return -EINVAL;
 990
 991         ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
 992         if (!ec)
 993                 return -ENOMEM;
 994         memset(ec, 0, sizeof(union acpi_ec));
 995
 996         ec->common.handle = device->handle;
 997         ec->common.uid = -1;
 998         init_MUTEX(&ec->poll.sem);
 999         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1000         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1001         acpi_driver_data(device) = ec;
1002
1003         /* Use the global lock for all EC transactions? */
1004         acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
1005                               &ec->common.global_lock);
1006
1007         /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
1008            http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
1009         if (ec_ecdt) {
1010                 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1011                                                   ACPI_ADR_SPACE_EC,
1012                                                   &acpi_ec_space_handler);
1013
1014                 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1015                                         &acpi_ec_gpe_handler);
1016
1017                 kfree(ec_ecdt);
1018         }
1019
1020         /* Get GPE bit assignment (EC events). */
1021         /* TODO: Add support for _GPE returning a package */
1022         status =
1023             acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
1024                                   &ec->common.gpe_bit);
1025         if (ACPI_FAILURE(status)) {
1026                 ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit"));
1027                 result = -ENODEV;
1028                 goto end;
1029         }
1030
1031         result = acpi_ec_add_fs(device);
1032         if (result)
1033                 goto end;
1034
1035         printk(KERN_INFO PREFIX "%s [%s] (gpe %d) polling mode.\n",
1036                acpi_device_name(device), acpi_device_bid(device),
1037                (u32) ec->common.gpe_bit);
1038
1039         if (!first_ec)
1040                 first_ec = device;
1041
1042       end:
1043         if (result)
1044                 kfree(ec);
1045
1046         return result;
1047 }
1048 static int acpi_ec_intr_add(struct acpi_device *device)
1049 {
1050         int result = 0;
1051         acpi_status status = AE_OK;
1052         union acpi_ec *ec = NULL;
1053
1054
1055         if (!device)
1056                 return -EINVAL;
1057
1058         ec = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1059         if (!ec)
1060                 return -ENOMEM;
1061         memset(ec, 0, sizeof(union acpi_ec));
1062
1063         ec->common.handle = device->handle;
1064         ec->common.uid = -1;
1065         atomic_set(&ec->intr.pending_gpe, 0);
1066         atomic_set(&ec->intr.leaving_burst, 1);
1067         init_MUTEX(&ec->intr.sem);
1068         init_waitqueue_head(&ec->intr.wait);
1069         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
1070         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
1071         acpi_driver_data(device) = ec;
1072
1073         /* Use the global lock for all EC transactions? */
1074         acpi_evaluate_integer(ec->common.handle, "_GLK", NULL,
1075                               &ec->common.global_lock);
1076
1077         /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
1078            http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
1079         if (ec_ecdt) {
1080                 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
1081                                                   ACPI_ADR_SPACE_EC,
1082                                                   &acpi_ec_space_handler);
1083
1084                 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1085                                         &acpi_ec_gpe_handler);
1086
1087                 kfree(ec_ecdt);
1088         }
1089
1090         /* Get GPE bit assignment (EC events). */
1091         /* TODO: Add support for _GPE returning a package */
1092         status =
1093             acpi_evaluate_integer(ec->common.handle, "_GPE", NULL,
1094                                   &ec->common.gpe_bit);
1095         if (ACPI_FAILURE(status)) {
1096                 printk(KERN_ERR PREFIX "Obtaining GPE bit assignment\n");
1097                 result = -ENODEV;
1098                 goto end;
1099         }
1100
1101         result = acpi_ec_add_fs(device);
1102         if (result)
1103                 goto end;
1104
1105         printk(KERN_INFO PREFIX "%s [%s] (gpe %d) interrupt mode.\n",
1106                acpi_device_name(device), acpi_device_bid(device),
1107                (u32) ec->common.gpe_bit);
1108
1109         if (!first_ec)
1110                 first_ec = device;
1111
1112       end:
1113         if (result)
1114                 kfree(ec);
1115
1116         return result;
1117 }
1118
1119 static int acpi_ec_remove(struct acpi_device *device, int type)
1120 {
1121         union acpi_ec *ec = NULL;
1122
1123
1124         if (!device)
1125                 return -EINVAL;
1126
1127         ec = acpi_driver_data(device);
1128
1129         acpi_ec_remove_fs(device);
1130
1131         kfree(ec);
1132
1133         return 0;
1134 }
1135
1136 static acpi_status
1137 acpi_ec_io_ports(struct acpi_resource *resource, void *context)
1138 {
1139         union acpi_ec *ec = (union acpi_ec *)context;
1140         struct acpi_generic_address *addr;
1141
1142         if (resource->type != ACPI_RESOURCE_TYPE_IO) {
1143                 return AE_OK;
1144         }
1145
1146         /*
1147          * The first address region returned is the data port, and
1148          * the second address region returned is the status/command
1149          * port.
1150          */
1151         if (ec->common.data_addr.register_bit_width == 0) {
1152                 addr = &ec->common.data_addr;
1153         } else if (ec->common.command_addr.register_bit_width == 0) {
1154                 addr = &ec->common.command_addr;
1155         } else {
1156                 return AE_CTRL_TERMINATE;
1157         }
1158
1159         addr->address_space_id = ACPI_ADR_SPACE_SYSTEM_IO;
1160         addr->register_bit_width = 8;
1161         addr->register_bit_offset = 0;
1162         addr->address = resource->data.io.minimum;
1163
1164         return AE_OK;
1165 }
1166
1167 static int acpi_ec_start(struct acpi_device *device)
1168 {
1169         acpi_status status = AE_OK;
1170         union acpi_ec *ec = NULL;
1171
1172
1173         if (!device)
1174                 return -EINVAL;
1175
1176         ec = acpi_driver_data(device);
1177
1178         if (!ec)
1179                 return -EINVAL;
1180
1181         /*
1182          * Get I/O port addresses. Convert to GAS format.
1183          */
1184         status = acpi_walk_resources(ec->common.handle, METHOD_NAME__CRS,
1185                                      acpi_ec_io_ports, ec);
1186         if (ACPI_FAILURE(status)
1187             || ec->common.command_addr.register_bit_width == 0) {
1188                 printk(KERN_ERR PREFIX "Error getting I/O port addresses\n");
1189                 return -ENODEV;
1190         }
1191
1192         ec->common.status_addr = ec->common.command_addr;
1193
1194         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02x, ports=0x%2x,0x%2x\n",
1195                           (u32) ec->common.gpe_bit,
1196                           (u32) ec->common.command_addr.address,
1197                           (u32) ec->common.data_addr.address));
1198
1199         /*
1200          * Install GPE handler
1201          */
1202         status = acpi_install_gpe_handler(NULL, ec->common.gpe_bit,
1203                                           ACPI_GPE_EDGE_TRIGGERED,
1204                                           &acpi_ec_gpe_handler, ec);
1205         if (ACPI_FAILURE(status)) {
1206                 return -ENODEV;
1207         }
1208         acpi_set_gpe_type(NULL, ec->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1209         acpi_enable_gpe(NULL, ec->common.gpe_bit, ACPI_NOT_ISR);
1210
1211         status = acpi_install_address_space_handler(ec->common.handle,
1212                                                     ACPI_ADR_SPACE_EC,
1213                                                     &acpi_ec_space_handler,
1214                                                     &acpi_ec_space_setup, ec);
1215         if (ACPI_FAILURE(status)) {
1216                 acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
1217                                         &acpi_ec_gpe_handler);
1218                 return -ENODEV;
1219         }
1220
1221         return AE_OK;
1222 }
1223
1224 static int acpi_ec_stop(struct acpi_device *device, int type)
1225 {
1226         acpi_status status = AE_OK;
1227         union acpi_ec *ec = NULL;
1228
1229
1230         if (!device)
1231                 return -EINVAL;
1232
1233         ec = acpi_driver_data(device);
1234
1235         status = acpi_remove_address_space_handler(ec->common.handle,
1236                                                    ACPI_ADR_SPACE_EC,
1237                                                    &acpi_ec_space_handler);
1238         if (ACPI_FAILURE(status))
1239                 return -ENODEV;
1240
1241         status =
1242             acpi_remove_gpe_handler(NULL, ec->common.gpe_bit,
1243                                     &acpi_ec_gpe_handler);
1244         if (ACPI_FAILURE(status))
1245                 return -ENODEV;
1246
1247         return 0;
1248 }
1249
1250 static acpi_status __init
1251 acpi_fake_ecdt_callback(acpi_handle handle,
1252                         u32 Level, void *context, void **retval)
1253 {
1254
1255         if (acpi_ec_poll_mode)
1256                 return acpi_fake_ecdt_poll_callback(handle,
1257                                                        Level, context, retval);
1258         else
1259                 return acpi_fake_ecdt_intr_callback(handle,
1260                                                      Level, context, retval);
1261 }
1262
1263 static acpi_status __init
1264 acpi_fake_ecdt_poll_callback(acpi_handle handle,
1265                                 u32 Level, void *context, void **retval)
1266 {
1267         acpi_status status;
1268
1269         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1270                                      acpi_ec_io_ports, ec_ecdt);
1271         if (ACPI_FAILURE(status))
1272                 return status;
1273         ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1274
1275         ec_ecdt->common.uid = -1;
1276         acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1277
1278         status =
1279             acpi_evaluate_integer(handle, "_GPE", NULL,
1280                                   &ec_ecdt->common.gpe_bit);
1281         if (ACPI_FAILURE(status))
1282                 return status;
1283         init_MUTEX(&ec_ecdt->poll.sem);
1284         ec_ecdt->common.global_lock = TRUE;
1285         ec_ecdt->common.handle = handle;
1286
1287         printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1288                (u32) ec_ecdt->common.gpe_bit,
1289                (u32) ec_ecdt->common.command_addr.address,
1290                (u32) ec_ecdt->common.data_addr.address);
1291
1292         return AE_CTRL_TERMINATE;
1293 }
1294
1295 static acpi_status __init
1296 acpi_fake_ecdt_intr_callback(acpi_handle handle,
1297                               u32 Level, void *context, void **retval)
1298 {
1299         acpi_status status;
1300
1301         init_MUTEX(&ec_ecdt->intr.sem);
1302         init_waitqueue_head(&ec_ecdt->intr.wait);
1303         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
1304                                      acpi_ec_io_ports, ec_ecdt);
1305         if (ACPI_FAILURE(status))
1306                 return status;
1307         ec_ecdt->common.status_addr = ec_ecdt->common.command_addr;
1308
1309         ec_ecdt->common.uid = -1;
1310         acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->common.uid);
1311
1312         status =
1313             acpi_evaluate_integer(handle, "_GPE", NULL,
1314                                   &ec_ecdt->common.gpe_bit);
1315         if (ACPI_FAILURE(status))
1316                 return status;
1317         ec_ecdt->common.global_lock = TRUE;
1318         ec_ecdt->common.handle = handle;
1319
1320         printk(KERN_INFO PREFIX "GPE=0x%02x, ports=0x%2x, 0x%2x\n",
1321                (u32) ec_ecdt->common.gpe_bit,
1322                (u32) ec_ecdt->common.command_addr.address,
1323                (u32) ec_ecdt->common.data_addr.address);
1324
1325         return AE_CTRL_TERMINATE;
1326 }
1327
1328 /*
1329  * Some BIOS (such as some from Gateway laptops) access EC region very early
1330  * such as in BAT0._INI or EC._INI before an EC device is found and
1331  * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
1332  * required, but if EC regison is accessed early, it is required.
1333  * The routine tries to workaround the BIOS bug by pre-scan EC device
1334  * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
1335  * op region (since _REG isn't invoked yet). The assumption is true for
1336  * all systems found.
1337  */
1338 static int __init acpi_ec_fake_ecdt(void)
1339 {
1340         acpi_status status;
1341         int ret = 0;
1342
1343         printk(KERN_INFO PREFIX "Try to make an fake ECDT\n");
1344
1345         ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1346         if (!ec_ecdt) {
1347                 ret = -ENOMEM;
1348                 goto error;
1349         }
1350         memset(ec_ecdt, 0, sizeof(union acpi_ec));
1351
1352         status = acpi_get_devices(ACPI_EC_HID,
1353                                   acpi_fake_ecdt_callback, NULL, NULL);
1354         if (ACPI_FAILURE(status)) {
1355                 kfree(ec_ecdt);
1356                 ec_ecdt = NULL;
1357                 ret = -ENODEV;
1358                 goto error;
1359         }
1360         return 0;
1361       error:
1362         printk(KERN_ERR PREFIX "Can't make an fake ECDT\n");
1363         return ret;
1364 }
1365
1366 static int __init acpi_ec_get_real_ecdt(void)
1367 {
1368         if (acpi_ec_poll_mode)
1369                 return acpi_ec_poll_get_real_ecdt();
1370         else
1371                 return acpi_ec_intr_get_real_ecdt();
1372 }
1373
1374 static int __init acpi_ec_poll_get_real_ecdt(void)
1375 {
1376         acpi_status status;
1377         struct acpi_table_ecdt *ecdt_ptr;
1378
1379         status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1380                                          (struct acpi_table_header **)
1381                                          &ecdt_ptr);
1382         if (ACPI_FAILURE(status))
1383                 return -ENODEV;
1384
1385         printk(KERN_INFO PREFIX "Found ECDT\n");
1386
1387         /*
1388          * Generate a temporary ec context to use until the namespace is scanned
1389          */
1390         ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1391         if (!ec_ecdt)
1392                 return -ENOMEM;
1393         memset(ec_ecdt, 0, sizeof(union acpi_ec));
1394
1395         ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1396         ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1397         ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1398         ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1399         init_MUTEX(&ec_ecdt->poll.sem);
1400         /* use the GL just to be safe */
1401         ec_ecdt->common.global_lock = TRUE;
1402         ec_ecdt->common.uid = ecdt_ptr->uid;
1403
1404         status =
1405             acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1406         if (ACPI_FAILURE(status)) {
1407                 goto error;
1408         }
1409
1410         return 0;
1411       error:
1412         printk(KERN_ERR PREFIX "Could not use ECDT\n");
1413         kfree(ec_ecdt);
1414         ec_ecdt = NULL;
1415
1416         return -ENODEV;
1417 }
1418
1419 static int __init acpi_ec_intr_get_real_ecdt(void)
1420 {
1421         acpi_status status;
1422         struct acpi_table_ecdt *ecdt_ptr;
1423
1424         status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
1425                                          (struct acpi_table_header **)
1426                                          &ecdt_ptr);
1427         if (ACPI_FAILURE(status))
1428                 return -ENODEV;
1429
1430         printk(KERN_INFO PREFIX "Found ECDT\n");
1431
1432         /*
1433          * Generate a temporary ec context to use until the namespace is scanned
1434          */
1435         ec_ecdt = kmalloc(sizeof(union acpi_ec), GFP_KERNEL);
1436         if (!ec_ecdt)
1437                 return -ENOMEM;
1438         memset(ec_ecdt, 0, sizeof(union acpi_ec));
1439
1440         init_MUTEX(&ec_ecdt->intr.sem);
1441         init_waitqueue_head(&ec_ecdt->intr.wait);
1442         ec_ecdt->common.command_addr = ecdt_ptr->ec_control;
1443         ec_ecdt->common.status_addr = ecdt_ptr->ec_control;
1444         ec_ecdt->common.data_addr = ecdt_ptr->ec_data;
1445         ec_ecdt->common.gpe_bit = ecdt_ptr->gpe_bit;
1446         /* use the GL just to be safe */
1447         ec_ecdt->common.global_lock = TRUE;
1448         ec_ecdt->common.uid = ecdt_ptr->uid;
1449
1450         status =
1451             acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->common.handle);
1452         if (ACPI_FAILURE(status)) {
1453                 goto error;
1454         }
1455
1456         return 0;
1457       error:
1458         printk(KERN_ERR PREFIX "Could not use ECDT\n");
1459         kfree(ec_ecdt);
1460         ec_ecdt = NULL;
1461
1462         return -ENODEV;
1463 }
1464
1465 static int __initdata acpi_fake_ecdt_enabled;
1466 int __init acpi_ec_ecdt_probe(void)
1467 {
1468         acpi_status status;
1469         int ret;
1470
1471         ret = acpi_ec_get_real_ecdt();
1472         /* Try to make a fake ECDT */
1473         if (ret && acpi_fake_ecdt_enabled) {
1474                 ret = acpi_ec_fake_ecdt();
1475         }
1476
1477         if (ret)
1478                 return 0;
1479
1480         /*
1481          * Install GPE handler
1482          */
1483         status = acpi_install_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1484                                           ACPI_GPE_EDGE_TRIGGERED,
1485                                           &acpi_ec_gpe_handler, ec_ecdt);
1486         if (ACPI_FAILURE(status)) {
1487                 goto error;
1488         }
1489         acpi_set_gpe_type(NULL, ec_ecdt->common.gpe_bit, ACPI_GPE_TYPE_RUNTIME);
1490         acpi_enable_gpe(NULL, ec_ecdt->common.gpe_bit, ACPI_NOT_ISR);
1491
1492         status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
1493                                                     ACPI_ADR_SPACE_EC,
1494                                                     &acpi_ec_space_handler,
1495                                                     &acpi_ec_space_setup,
1496                                                     ec_ecdt);
1497         if (ACPI_FAILURE(status)) {
1498                 acpi_remove_gpe_handler(NULL, ec_ecdt->common.gpe_bit,
1499                                         &acpi_ec_gpe_handler);
1500                 goto error;
1501         }
1502
1503         return 0;
1504
1505       error:
1506         printk(KERN_ERR PREFIX "Could not use ECDT\n");
1507         kfree(ec_ecdt);
1508         ec_ecdt = NULL;
1509
1510         return -ENODEV;
1511 }
1512
1513 static int __init acpi_ec_init(void)
1514 {
1515         int result = 0;
1516
1517
1518         if (acpi_disabled)
1519                 return 0;
1520
1521         acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1522         if (!acpi_ec_dir)
1523                 return -ENODEV;
1524
1525         /* Now register the driver for the EC */
1526         result = acpi_bus_register_driver(&acpi_ec_driver);
1527         if (result < 0) {
1528                 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1529                 return -ENODEV;
1530         }
1531
1532         return result;
1533 }
1534
1535 subsys_initcall(acpi_ec_init);
1536
1537 /* EC driver currently not unloadable */
1538 #if 0
1539 static void __exit acpi_ec_exit(void)
1540 {
1541
1542         acpi_bus_unregister_driver(&acpi_ec_driver);
1543
1544         remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1545
1546         return;
1547 }
1548 #endif                          /* 0 */
1549
1550 static int __init acpi_fake_ecdt_setup(char *str)
1551 {
1552         acpi_fake_ecdt_enabled = 1;
1553         return 1;
1554 }
1555
1556 __setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
1557 static int __init acpi_ec_set_intr_mode(char *str)
1558 {
1559         int intr;
1560
1561         if (!get_option(&str, &intr))
1562                 return 0;
1563
1564         if (intr) {
1565                 acpi_ec_poll_mode = EC_INTR;
1566                 acpi_ec_driver.ops.add = acpi_ec_intr_add;
1567         } else {
1568                 acpi_ec_poll_mode = EC_POLL;
1569                 acpi_ec_driver.ops.add = acpi_ec_poll_add;
1570         }
1571         printk(KERN_INFO PREFIX "EC %s mode.\n", intr ? "interrupt" : "polling");
1572         return 1;
1573 }
1574
1575 __setup("ec_intr=", acpi_ec_set_intr_mode);