git.oblomov.eu Git - linux-2.6/blob - 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
  49 /* EC status register */
  50 #define ACPI_EC_FLAG_OBF        0x01    /* Output buffer full */
  51 #define ACPI_EC_FLAG_IBF        0x02    /* Input buffer full */
  52 #define ACPI_EC_FLAG_BURST      0x10    /* burst mode */
  53 #define ACPI_EC_FLAG_SCI        0x20    /* EC-SCI occurred */
  54
  55 /* EC commands */
  56 #define ACPI_EC_COMMAND_READ    0x80
  57 #define ACPI_EC_COMMAND_WRITE   0x81
  58 #define ACPI_EC_BURST_ENABLE    0x82
  59 #define ACPI_EC_BURST_DISABLE   0x83
  60 #define ACPI_EC_COMMAND_QUERY   0x84
  61
  62 /* EC events */
  63 enum {
  64         ACPI_EC_EVENT_OBF_1 = 1,        /* Output buffer full */
  65         ACPI_EC_EVENT_IBF_0,            /* Input buffer empty */
  66 };
  67
  68 #define ACPI_EC_DELAY           500     /* Wait 500ms max. during EC ops */
  69 #define ACPI_EC_UDELAY_GLK      1000    /* Wait 1ms max. to get global lock */
  70 #define ACPI_EC_UDELAY         100      /* Poll @ 100us increments */
  71 #define ACPI_EC_UDELAY_COUNT   1000     /* Wait 100ms max. during EC ops */
  72
  73 enum {
  74         EC_INTR = 1,    /* Output buffer full */
  75         EC_POLL,        /* Input buffer empty */
  76 };
  77
  78 static int acpi_ec_remove(struct acpi_device *device, int type);
  79 static int acpi_ec_start(struct acpi_device *device);
  80 static int acpi_ec_stop(struct acpi_device *device, int type);
  81 static int acpi_ec_add(struct acpi_device *device);
  82
  83 static struct acpi_driver acpi_ec_driver = {
  84         .name = ACPI_EC_DRIVER_NAME,
  85         .class = ACPI_EC_CLASS,
  86         .ids = ACPI_EC_HID,
  87         .ops = {
  88                 .add = acpi_ec_add,
  89                 .remove = acpi_ec_remove,
  90                 .start = acpi_ec_start,
  91                 .stop = acpi_ec_stop,
  92                 },
  93 };
  94
  95 /* If we find an EC via the ECDT, we need to keep a ptr to its context */
  96 struct acpi_ec {
  97         acpi_handle handle;
  98         unsigned long uid;
  99         unsigned long gpe_bit;
 100         unsigned long command_addr;
 101         unsigned long data_addr;
 102         unsigned long global_lock;
 103         struct semaphore sem;
 104         unsigned int expect_event;
 105         atomic_t leaving_burst; /* 0 : No, 1 : Yes, 2: abort */
 106         wait_queue_head_t wait;
 107 } *ec_ecdt;
 108
 109 /* External interfaces use first EC only, so remember */
 110 static struct acpi_device *first_ec;
 111 static int acpi_ec_mode = EC_INTR;
 112
 113 /* --------------------------------------------------------------------------
 114                              Transaction Management
 115    -------------------------------------------------------------------------- */
 116
 117 static inline u8 acpi_ec_read_status(struct acpi_ec *ec)
 118 {
 119         return inb(ec->command_addr);
 120 }
 121
 122 static inline u8 acpi_ec_read_data(struct acpi_ec *ec)
 123 {
 124         return inb(ec->data_addr);
 125 }
 126
 127 static inline void acpi_ec_write_cmd(struct acpi_ec *ec, u8 command)
 128 {
 129         outb(command, ec->command_addr);
 130 }
 131
 132 static inline void acpi_ec_write_data(struct acpi_ec *ec, u8 data)
 133 {
 134         outb(data, ec->data_addr);
 135 }
 136
 137 static int acpi_ec_check_status(u8 status, u8 event)
 138 {
 139         switch (event) {
 140         case ACPI_EC_EVENT_OBF_1:
 141                 if (status & ACPI_EC_FLAG_OBF)
 142                         return 1;
 143                 break;
 144         case ACPI_EC_EVENT_IBF_0:
 145                 if (!(status & ACPI_EC_FLAG_IBF))
 146                         return 1;
 147                 break;
 148         default:
 149                 break;
 150         }
 151
 152         return 0;
 153 }
 154
 155 static int acpi_ec_wait(struct acpi_ec *ec, u8 event)
 156 {
 157         int i = (acpi_ec_mode == EC_POLL) ? ACPI_EC_UDELAY_COUNT : 0;
 158         long time_left;
 159
 160         ec->expect_event = event;
 161         if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
 162                 ec->expect_event = 0;
 163                 return 0;
 164         }
 165
 166         do {
 167                 if (acpi_ec_mode == EC_POLL) {
 168                         udelay(ACPI_EC_UDELAY);
 169                 } else {
 170                         time_left = wait_event_timeout(ec->wait,
 171                                     !ec->expect_event,
 172                                     msecs_to_jiffies(ACPI_EC_DELAY));
 173                         if (time_left > 0) {
 174                                 ec->expect_event = 0;
 175                                 return 0;
 176                         }
 177                 }
 178                 if (acpi_ec_check_status(acpi_ec_read_status(ec), event)) {
 179                         ec->expect_event = 0;
 180                         return 0;
 181                 }
 182         } while (--i > 0);
 183
 184         ec->expect_event = 0;
 185
 186         return -ETIME;
 187 }
 188
 189 #ifdef ACPI_FUTURE_USAGE
 190 /*
 191  * Note: samsung nv5000 doesn't work with ec burst mode.
 192  * http://bugzilla.kernel.org/show_bug.cgi?id=4980
 193  */
 194 int acpi_ec_enter_burst_mode(struct acpi_ec *ec)
 195 {
 196         u8 tmp = 0;
 197         u8 status = 0;
 198
 199
 200         status = acpi_ec_read_status(ec);
 201         if (status != -EINVAL && !(status & ACPI_EC_FLAG_BURST)) {
 202                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
 203                 if (status)
 204                         goto end;
 205                 acpi_ec_write_cmd(ec, ACPI_EC_BURST_ENABLE);
 206                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
 207                 tmp = acpi_ec_read_data(ec);
 208                 if (tmp != 0x90) {      /* Burst ACK byte */
 209                         return -EINVAL;
 210                 }
 211         }
 212
 213         atomic_set(&ec->leaving_burst, 0);
 214         return 0;
 215   end:
 216         ACPI_EXCEPTION((AE_INFO, status, "EC wait, burst mode"));
 217         return -1;
 218 }
 219
 220 int acpi_ec_leave_burst_mode(struct acpi_ec *ec)
 221 {
 222         u8 status = 0;
 223
 224
 225         status = acpi_ec_read_status(ec);
 226         if (status != -EINVAL && (status & ACPI_EC_FLAG_BURST)){
 227                 status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
 228                 if(status)
 229                         goto end;
 230                 acpi_ec_write_cmd(ec, ACPI_EC_BURST_DISABLE);
 231                 acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
 232         }
 233         atomic_set(&ec->leaving_burst, 1);
 234         return 0;
 235   end:
 236         ACPI_EXCEPTION((AE_INFO, status, "EC leave burst mode"));
 237         return -1;
 238 }
 239 #endif /* ACPI_FUTURE_USAGE */
 240
 241 static int acpi_ec_transaction_unlocked(struct acpi_ec *ec, u8 command,
 242                                         const u8 *wdata, unsigned wdata_len,
 243                                         u8 *rdata, unsigned rdata_len)
 244 {
 245         int result;
 246
 247         acpi_ec_write_cmd(ec, command);
 248
 249         for (; wdata_len > 0; wdata_len --) {
 250                 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
 251                 if (result)
 252                         return result;
 253                 acpi_ec_write_data(ec, *(wdata++));
 254         }
 255
 256         if (!rdata_len) {
 257                 result = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
 258                 if (result)
 259                         return result;
 260         }
 261
 262         for (; rdata_len > 0; rdata_len --) {
 263                 result = acpi_ec_wait(ec, ACPI_EC_EVENT_OBF_1);
 264                 if (result)
 265                         return result;
 266
 267                 *(rdata++) = acpi_ec_read_data(ec);
 268         }
 269
 270         return 0;
 271 }
 272
 273 static int acpi_ec_transaction(struct acpi_ec *ec, u8 command,
 274                                 const u8 *wdata, unsigned wdata_len,
 275                                 u8 *rdata, unsigned rdata_len)
 276 {
 277         int status;
 278         u32 glk;
 279
 280         if (!ec || (wdata_len && !wdata) || (rdata_len && !rdata))
 281                 return -EINVAL;
 282
 283         if (rdata)
 284                 memset(rdata, 0, rdata_len);
 285
 286         if (ec->global_lock) {
 287                 status = acpi_acquire_global_lock(ACPI_EC_UDELAY_GLK, &glk);
 288                 if (ACPI_FAILURE(status))
 289                         return -ENODEV;
 290         }
 291         down(&ec->sem);
 292
 293         /* Make sure GPE is enabled before doing transaction */
 294         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
 295
 296         status = acpi_ec_wait(ec, ACPI_EC_EVENT_IBF_0);
 297         if (status) {
 298                 printk(KERN_DEBUG PREFIX "read EC, IB not empty\n");
 299                 goto end;
 300         }
 301
 302         status = acpi_ec_transaction_unlocked(ec, command,
 303                                               wdata, wdata_len,
 304                                               rdata, rdata_len);
 305
 306 end:
 307         up(&ec->sem);
 308
 309         if (ec->global_lock)
 310                 acpi_release_global_lock(glk);
 311
 312         return status;
 313 }
 314
 315 static int acpi_ec_read(struct acpi_ec *ec, u8 address, u8 *data)
 316 {
 317         int result;
 318         u8 d;
 319
 320         result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_READ,
 321                                      &address, 1, &d, 1);
 322         *data = d;
 323         return result;
 324 }
 325
 326 static int acpi_ec_write(struct acpi_ec *ec, u8 address, u8 data)
 327 {
 328         u8 wdata[2] = { address, data };
 329         return acpi_ec_transaction(ec, ACPI_EC_COMMAND_WRITE,
 330                                    wdata, 2, NULL, 0);
 331 }
 332
 333 /*
 334  * Externally callable EC access functions. For now, assume 1 EC only
 335  */
 336 int ec_read(u8 addr, u8 *val)
 337 {
 338         struct acpi_ec *ec;
 339         int err;
 340         u8 temp_data;
 341
 342         if (!first_ec)
 343                 return -ENODEV;
 344
 345         ec = acpi_driver_data(first_ec);
 346
 347         err = acpi_ec_read(ec, addr, &temp_data);
 348
 349         if (!err) {
 350                 *val = temp_data;
 351                 return 0;
 352         } else
 353                 return err;
 354 }
 355
 356 EXPORT_SYMBOL(ec_read);
 357
 358 int ec_write(u8 addr, u8 val)
 359 {
 360         struct acpi_ec *ec;
 361         int err;
 362
 363         if (!first_ec)
 364                 return -ENODEV;
 365
 366         ec = acpi_driver_data(first_ec);
 367
 368         err = acpi_ec_write(ec, addr, val);
 369
 370         return err;
 371 }
 372
 373 EXPORT_SYMBOL(ec_write);
 374
 375 extern int ec_transaction(u8 command,
 376                           const u8 *wdata, unsigned wdata_len,
 377                           u8 *rdata, unsigned rdata_len)
 378 {
 379         struct acpi_ec *ec;
 380
 381         if (!first_ec)
 382                 return -ENODEV;
 383
 384         ec = acpi_driver_data(first_ec);
 385
 386         return acpi_ec_transaction(ec, command, wdata,
 387                                    wdata_len, rdata, rdata_len);
 388 }
 389
 390 EXPORT_SYMBOL(ec_transaction);
 391
 392 static int acpi_ec_query(struct acpi_ec *ec, u8 *data)
 393 {
 394         int result;
 395         u8 d;
 396
 397         if (!ec || !data)
 398                 return -EINVAL;
 399
 400         /*
 401          * Query the EC to find out which _Qxx method we need to evaluate.
 402          * Note that successful completion of the query causes the ACPI_EC_SCI
 403          * bit to be cleared (and thus clearing the interrupt source).
 404          */
 405
 406         result = acpi_ec_transaction(ec, ACPI_EC_COMMAND_QUERY, NULL, 0, &d, 1);
 407         if (result)
 408                 return result;
 409
 410         if (!d)
 411                 return -ENODATA;
 412
 413         *data = d;
 414         return 0;
 415 }
 416
 417 /* --------------------------------------------------------------------------
 418                                 Event Management
 419    -------------------------------------------------------------------------- */
 420
 421 struct acpi_ec_query_data {
 422         acpi_handle handle;
 423         u8 data;
 424 };
 425
 426 static void acpi_ec_gpe_query(void *ec_cxt)
 427 {
 428         struct acpi_ec *ec = (struct acpi_ec *)ec_cxt;
 429         u8 value = 0;
 430         static char object_name[8];
 431
 432         if (!ec)
 433                 goto end;
 434
 435         value = acpi_ec_read_status(ec);
 436
 437         if (!(value & ACPI_EC_FLAG_SCI))
 438                 goto end;
 439
 440         if (acpi_ec_query(ec, &value))
 441                 goto end;
 442
 443         snprintf(object_name, 8, "_Q%2.2X", value);
 444
 445         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Evaluating %s", object_name));
 446
 447         acpi_evaluate_object(ec->handle, object_name, NULL, NULL);
 448
 449       end:
 450         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
 451 }
 452
 453 static u32 acpi_ec_gpe_handler(void *data)
 454 {
 455         acpi_status status = AE_OK;
 456         u8 value;
 457         struct acpi_ec *ec = (struct acpi_ec *)data;
 458
 459         acpi_clear_gpe(NULL, ec->gpe_bit, ACPI_ISR);
 460         value = acpi_ec_read_status(ec);
 461
 462         if (acpi_ec_mode == EC_INTR) {
 463                 if (acpi_ec_check_status(value, ec->expect_event)) {
 464                         ec->expect_event = 0;
 465                         wake_up(&ec->wait);
 466                 }
 467         }
 468
 469         if (value & ACPI_EC_FLAG_SCI) {
 470                 status = acpi_os_execute(OSL_EC_BURST_HANDLER, acpi_ec_gpe_query, ec);
 471                 return status == AE_OK ?
 472                     ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
 473         }
 474         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_ISR);
 475         return status == AE_OK ?
 476             ACPI_INTERRUPT_HANDLED : ACPI_INTERRUPT_NOT_HANDLED;
 477 }
 478
 479 /* --------------------------------------------------------------------------
 480                              Address Space Management
 481    -------------------------------------------------------------------------- */
 482
 483 static acpi_status
 484 acpi_ec_space_setup(acpi_handle region_handle,
 485                     u32 function, void *handler_context, void **return_context)
 486 {
 487         /*
 488          * The EC object is in the handler context and is needed
 489          * when calling the acpi_ec_space_handler.
 490          */
 491         *return_context = (function != ACPI_REGION_DEACTIVATE) ?
 492             handler_context : NULL;
 493
 494         return AE_OK;
 495 }
 496
 497 static acpi_status
 498 acpi_ec_space_handler(u32 function,
 499                       acpi_physical_address address,
 500                       u32 bit_width,
 501                       acpi_integer * value,
 502                       void *handler_context, void *region_context)
 503 {
 504         int result = 0;
 505         struct acpi_ec *ec = NULL;
 506         u64 temp = *value;
 507         acpi_integer f_v = 0;
 508         int i = 0;
 509
 510
 511         if ((address > 0xFF) || !value || !handler_context)
 512                 return AE_BAD_PARAMETER;
 513
 514         if (bit_width != 8 && acpi_strict) {
 515                 return AE_BAD_PARAMETER;
 516         }
 517
 518         ec = (struct acpi_ec *)handler_context;
 519
 520       next_byte:
 521         switch (function) {
 522         case ACPI_READ:
 523                 temp = 0;
 524                 result = acpi_ec_read(ec, (u8) address, (u8 *) &temp);
 525                 break;
 526         case ACPI_WRITE:
 527                 result = acpi_ec_write(ec, (u8) address, (u8) temp);
 528                 break;
 529         default:
 530                 result = -EINVAL;
 531                 goto out;
 532                 break;
 533         }
 534
 535         bit_width -= 8;
 536         if (bit_width) {
 537                 if (function == ACPI_READ)
 538                         f_v |= temp << 8 * i;
 539                 if (function == ACPI_WRITE)
 540                         temp >>= 8;
 541                 i++;
 542                 address++;
 543                 goto next_byte;
 544         }
 545
 546         if (function == ACPI_READ) {
 547                 f_v |= temp << 8 * i;
 548                 *value = f_v;
 549         }
 550
 551       out:
 552         switch (result) {
 553         case -EINVAL:
 554                 return AE_BAD_PARAMETER;
 555                 break;
 556         case -ENODEV:
 557                 return AE_NOT_FOUND;
 558                 break;
 559         case -ETIME:
 560                 return AE_TIME;
 561                 break;
 562         default:
 563                 return AE_OK;
 564         }
 565 }
 566
 567 /* --------------------------------------------------------------------------
 568                               FS Interface (/proc)
 569    -------------------------------------------------------------------------- */
 570
 571 static struct proc_dir_entry *acpi_ec_dir;
 572
 573 static int acpi_ec_read_info(struct seq_file *seq, void *offset)
 574 {
 575         struct acpi_ec *ec = (struct acpi_ec *)seq->private;
 576
 577
 578         if (!ec)
 579                 goto end;
 580
 581         seq_printf(seq, "gpe bit:                 0x%02x\n",
 582                    (u32) ec->gpe_bit);
 583         seq_printf(seq, "ports:                   0x%02x, 0x%02x\n",
 584                    (u32) ec->command_addr,
 585                    (u32) ec->data_addr);
 586         seq_printf(seq, "use global lock:         %s\n",
 587                    ec->global_lock ? "yes" : "no");
 588         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
 589
 590       end:
 591         return 0;
 592 }
 593
 594 static int acpi_ec_info_open_fs(struct inode *inode, struct file *file)
 595 {
 596         return single_open(file, acpi_ec_read_info, PDE(inode)->data);
 597 }
 598
 599 static struct file_operations acpi_ec_info_ops = {
 600         .open = acpi_ec_info_open_fs,
 601         .read = seq_read,
 602         .llseek = seq_lseek,
 603         .release = single_release,
 604         .owner = THIS_MODULE,
 605 };
 606
 607 static int acpi_ec_add_fs(struct acpi_device *device)
 608 {
 609         struct proc_dir_entry *entry = NULL;
 610
 611
 612         if (!acpi_device_dir(device)) {
 613                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 614                                                      acpi_ec_dir);
 615                 if (!acpi_device_dir(device))
 616                         return -ENODEV;
 617         }
 618
 619         entry = create_proc_entry(ACPI_EC_FILE_INFO, S_IRUGO,
 620                                   acpi_device_dir(device));
 621         if (!entry)
 622                 return -ENODEV;
 623         else {
 624                 entry->proc_fops = &acpi_ec_info_ops;
 625                 entry->data = acpi_driver_data(device);
 626                 entry->owner = THIS_MODULE;
 627         }
 628
 629         return 0;
 630 }
 631
 632 static int acpi_ec_remove_fs(struct acpi_device *device)
 633 {
 634
 635         if (acpi_device_dir(device)) {
 636                 remove_proc_entry(ACPI_EC_FILE_INFO, acpi_device_dir(device));
 637                 remove_proc_entry(acpi_device_bid(device), acpi_ec_dir);
 638                 acpi_device_dir(device) = NULL;
 639         }
 640
 641         return 0;
 642 }
 643
 644 /* --------------------------------------------------------------------------
 645                                Driver Interface
 646    -------------------------------------------------------------------------- */
 647
 648 static int acpi_ec_add(struct acpi_device *device)
 649 {
 650         int result = 0;
 651         acpi_status status = AE_OK;
 652         struct acpi_ec *ec = NULL;
 653
 654
 655         if (!device)
 656                 return -EINVAL;
 657
 658         ec = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
 659         if (!ec)
 660                 return -ENOMEM;
 661         memset(ec, 0, sizeof(struct acpi_ec));
 662
 663         ec->handle = device->handle;
 664         ec->uid = -1;
 665         init_MUTEX(&ec->sem);
 666         if (acpi_ec_mode == EC_INTR) {
 667                 atomic_set(&ec->leaving_burst, 1);
 668                 init_waitqueue_head(&ec->wait);
 669         }
 670         strcpy(acpi_device_name(device), ACPI_EC_DEVICE_NAME);
 671         strcpy(acpi_device_class(device), ACPI_EC_CLASS);
 672         acpi_driver_data(device) = ec;
 673
 674         /* Use the global lock for all EC transactions? */
 675         acpi_evaluate_integer(ec->handle, "_GLK", NULL,
 676                               &ec->global_lock);
 677
 678         /* XXX we don't test uids, because on some boxes ecdt uid = 0, see:
 679            http://bugzilla.kernel.org/show_bug.cgi?id=6111 */
 680         if (ec_ecdt) {
 681                 acpi_remove_address_space_handler(ACPI_ROOT_OBJECT,
 682                                                   ACPI_ADR_SPACE_EC,
 683                                                   &acpi_ec_space_handler);
 684
 685                 acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
 686                                         &acpi_ec_gpe_handler);
 687
 688                 kfree(ec_ecdt);
 689         }
 690
 691         /* Get GPE bit assignment (EC events). */
 692         /* TODO: Add support for _GPE returning a package */
 693         status =
 694             acpi_evaluate_integer(ec->handle, "_GPE", NULL,
 695                                   &ec->gpe_bit);
 696         if (ACPI_FAILURE(status)) {
 697                 ACPI_EXCEPTION((AE_INFO, status, "Obtaining GPE bit assignment"));
 698                 result = -ENODEV;
 699                 goto end;
 700         }
 701
 702         result = acpi_ec_add_fs(device);
 703         if (result)
 704                 goto end;
 705
 706         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "%s [%s] (gpe %d) interrupt mode.",
 707                acpi_device_name(device), acpi_device_bid(device),
 708                (u32) ec->gpe_bit));
 709
 710         if (!first_ec)
 711                 first_ec = device;
 712
 713   end:
 714         if (result)
 715                 kfree(ec);
 716
 717         return result;
 718 }
 719
 720 static int acpi_ec_remove(struct acpi_device *device, int type)
 721 {
 722         struct acpi_ec *ec = NULL;
 723
 724
 725         if (!device)
 726                 return -EINVAL;
 727
 728         ec = acpi_driver_data(device);
 729
 730         acpi_ec_remove_fs(device);
 731
 732         kfree(ec);
 733
 734         return 0;
 735 }
 736
 737 static acpi_status
 738 acpi_ec_io_ports(struct acpi_resource *resource, void *context)
 739 {
 740         struct acpi_ec *ec = (struct acpi_ec *)context;
 741
 742         if (resource->type != ACPI_RESOURCE_TYPE_IO) {
 743                 return AE_OK;
 744         }
 745
 746         /*
 747          * The first address region returned is the data port, and
 748          * the second address region returned is the status/command
 749          * port.
 750          */
 751         if (ec->data_addr == 0) {
 752                 ec->data_addr = resource->data.io.minimum;
 753         } else if (ec->command_addr == 0) {
 754                 ec->command_addr = resource->data.io.minimum;
 755         } else {
 756                 return AE_CTRL_TERMINATE;
 757         }
 758
 759         return AE_OK;
 760 }
 761
 762 static int acpi_ec_start(struct acpi_device *device)
 763 {
 764         acpi_status status = AE_OK;
 765         struct acpi_ec *ec = NULL;
 766
 767
 768         if (!device)
 769                 return -EINVAL;
 770
 771         ec = acpi_driver_data(device);
 772
 773         if (!ec)
 774                 return -EINVAL;
 775
 776         /*
 777          * Get I/O port addresses. Convert to GAS format.
 778          */
 779         status = acpi_walk_resources(ec->handle, METHOD_NAME__CRS,
 780                                      acpi_ec_io_ports, ec);
 781         if (ACPI_FAILURE(status) || ec->command_addr == 0) {
 782                 ACPI_EXCEPTION((AE_INFO, status,
 783                                 "Error getting I/O port addresses"));
 784                 return -ENODEV;
 785         }
 786
 787         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "gpe=0x%02lx, ports=0x%2lx,0x%2lx",
 788                           ec->gpe_bit, ec->command_addr, ec->data_addr));
 789
 790         /*
 791          * Install GPE handler
 792          */
 793         status = acpi_install_gpe_handler(NULL, ec->gpe_bit,
 794                                           ACPI_GPE_EDGE_TRIGGERED,
 795                                           &acpi_ec_gpe_handler, ec);
 796         if (ACPI_FAILURE(status)) {
 797                 return -ENODEV;
 798         }
 799         acpi_set_gpe_type(NULL, ec->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
 800         acpi_enable_gpe(NULL, ec->gpe_bit, ACPI_NOT_ISR);
 801
 802         status = acpi_install_address_space_handler(ec->handle,
 803                                                     ACPI_ADR_SPACE_EC,
 804                                                     &acpi_ec_space_handler,
 805                                                     &acpi_ec_space_setup, ec);
 806         if (ACPI_FAILURE(status)) {
 807                 acpi_remove_gpe_handler(NULL, ec->gpe_bit,
 808                                         &acpi_ec_gpe_handler);
 809                 return -ENODEV;
 810         }
 811
 812         return AE_OK;
 813 }
 814
 815 static int acpi_ec_stop(struct acpi_device *device, int type)
 816 {
 817         acpi_status status = AE_OK;
 818         struct acpi_ec *ec = NULL;
 819
 820
 821         if (!device)
 822                 return -EINVAL;
 823
 824         ec = acpi_driver_data(device);
 825
 826         status = acpi_remove_address_space_handler(ec->handle,
 827                                                    ACPI_ADR_SPACE_EC,
 828                                                    &acpi_ec_space_handler);
 829         if (ACPI_FAILURE(status))
 830                 return -ENODEV;
 831
 832         status =
 833             acpi_remove_gpe_handler(NULL, ec->gpe_bit,
 834                                     &acpi_ec_gpe_handler);
 835         if (ACPI_FAILURE(status))
 836                 return -ENODEV;
 837
 838         return 0;
 839 }
 840
 841 static acpi_status __init
 842 acpi_fake_ecdt_callback(acpi_handle handle,
 843                         u32 Level, void *context, void **retval)
 844 {
 845         acpi_status status;
 846
 847         init_MUTEX(&ec_ecdt->sem);
 848         if (acpi_ec_mode == EC_INTR) {
 849                 init_waitqueue_head(&ec_ecdt->wait);
 850         }
 851         status = acpi_walk_resources(handle, METHOD_NAME__CRS,
 852                                      acpi_ec_io_ports, ec_ecdt);
 853         if (ACPI_FAILURE(status))
 854                 return status;
 855
 856         ec_ecdt->uid = -1;
 857         acpi_evaluate_integer(handle, "_UID", NULL, &ec_ecdt->uid);
 858
 859         status =
 860             acpi_evaluate_integer(handle, "_GPE", NULL,
 861                                   &ec_ecdt->gpe_bit);
 862         if (ACPI_FAILURE(status))
 863                 return status;
 864         ec_ecdt->global_lock = TRUE;
 865         ec_ecdt->handle = handle;
 866
 867         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "GPE=0x%02lx, ports=0x%2lx, 0x%2lx",
 868                ec_ecdt->gpe_bit, ec_ecdt->command_addr, ec_ecdt->data_addr));
 869
 870         return AE_CTRL_TERMINATE;
 871 }
 872
 873 /*
 874  * Some BIOS (such as some from Gateway laptops) access EC region very early
 875  * such as in BAT0._INI or EC._INI before an EC device is found and
 876  * do not provide an ECDT. According to ACPI spec, ECDT isn't mandatorily
 877  * required, but if EC regison is accessed early, it is required.
 878  * The routine tries to workaround the BIOS bug by pre-scan EC device
 879  * It assumes that _CRS, _HID, _GPE, _UID methods of EC don't touch any
 880  * op region (since _REG isn't invoked yet). The assumption is true for
 881  * all systems found.
 882  */
 883 static int __init acpi_ec_fake_ecdt(void)
 884 {
 885         acpi_status status;
 886         int ret = 0;
 887
 888         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Try to make an fake ECDT"));
 889
 890         ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
 891         if (!ec_ecdt) {
 892                 ret = -ENOMEM;
 893                 goto error;
 894         }
 895         memset(ec_ecdt, 0, sizeof(struct acpi_ec));
 896
 897         status = acpi_get_devices(ACPI_EC_HID,
 898                                   acpi_fake_ecdt_callback, NULL, NULL);
 899         if (ACPI_FAILURE(status)) {
 900                 kfree(ec_ecdt);
 901                 ec_ecdt = NULL;
 902                 ret = -ENODEV;
 903                 ACPI_EXCEPTION((AE_INFO, status, "Can't make an fake ECDT"));
 904                 goto error;
 905         }
 906         return 0;
 907   error:
 908         return ret;
 909 }
 910
 911 static int __init acpi_ec_get_real_ecdt(void)
 912 {
 913         acpi_status status;
 914         struct acpi_table_ecdt *ecdt_ptr;
 915
 916         status = acpi_get_firmware_table("ECDT", 1, ACPI_LOGICAL_ADDRESSING,
 917                                          (struct acpi_table_header **)
 918                                          &ecdt_ptr);
 919         if (ACPI_FAILURE(status))
 920                 return -ENODEV;
 921
 922         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found ECDT"));
 923
 924         /*
 925          * Generate a temporary ec context to use until the namespace is scanned
 926          */
 927         ec_ecdt = kmalloc(sizeof(struct acpi_ec), GFP_KERNEL);
 928         if (!ec_ecdt)
 929                 return -ENOMEM;
 930         memset(ec_ecdt, 0, sizeof(struct acpi_ec));
 931
 932         init_MUTEX(&ec_ecdt->sem);
 933         if (acpi_ec_mode == EC_INTR) {
 934                 init_waitqueue_head(&ec_ecdt->wait);
 935         }
 936         ec_ecdt->command_addr = ecdt_ptr->ec_control.address;
 937         ec_ecdt->data_addr = ecdt_ptr->ec_data.address;
 938         ec_ecdt->gpe_bit = ecdt_ptr->gpe_bit;
 939         /* use the GL just to be safe */
 940         ec_ecdt->global_lock = TRUE;
 941         ec_ecdt->uid = ecdt_ptr->uid;
 942
 943         status =
 944             acpi_get_handle(NULL, ecdt_ptr->ec_id, &ec_ecdt->handle);
 945         if (ACPI_FAILURE(status)) {
 946                 goto error;
 947         }
 948
 949         return 0;
 950   error:
 951         ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
 952         kfree(ec_ecdt);
 953         ec_ecdt = NULL;
 954
 955         return -ENODEV;
 956 }
 957
 958 static int __initdata acpi_fake_ecdt_enabled;
 959 int __init acpi_ec_ecdt_probe(void)
 960 {
 961         acpi_status status;
 962         int ret;
 963
 964         ret = acpi_ec_get_real_ecdt();
 965         /* Try to make a fake ECDT */
 966         if (ret && acpi_fake_ecdt_enabled) {
 967                 ret = acpi_ec_fake_ecdt();
 968         }
 969
 970         if (ret)
 971                 return 0;
 972
 973         /*
 974          * Install GPE handler
 975          */
 976         status = acpi_install_gpe_handler(NULL, ec_ecdt->gpe_bit,
 977                                           ACPI_GPE_EDGE_TRIGGERED,
 978                                           &acpi_ec_gpe_handler, ec_ecdt);
 979         if (ACPI_FAILURE(status)) {
 980                 goto error;
 981         }
 982         acpi_set_gpe_type(NULL, ec_ecdt->gpe_bit, ACPI_GPE_TYPE_RUNTIME);
 983         acpi_enable_gpe(NULL, ec_ecdt->gpe_bit, ACPI_NOT_ISR);
 984
 985         status = acpi_install_address_space_handler(ACPI_ROOT_OBJECT,
 986                                                     ACPI_ADR_SPACE_EC,
 987                                                     &acpi_ec_space_handler,
 988                                                     &acpi_ec_space_setup,
 989                                                     ec_ecdt);
 990         if (ACPI_FAILURE(status)) {
 991                 acpi_remove_gpe_handler(NULL, ec_ecdt->gpe_bit,
 992                                         &acpi_ec_gpe_handler);
 993                 goto error;
 994         }
 995
 996         return 0;
 997
 998       error:
 999         ACPI_EXCEPTION((AE_INFO, status, "Could not use ECDT"));
1000         kfree(ec_ecdt);
1001         ec_ecdt = NULL;
1002
1003         return -ENODEV;
1004 }
1005
1006 static int __init acpi_ec_init(void)
1007 {
1008         int result = 0;
1009
1010
1011         if (acpi_disabled)
1012                 return 0;
1013
1014         acpi_ec_dir = proc_mkdir(ACPI_EC_CLASS, acpi_root_dir);
1015         if (!acpi_ec_dir)
1016                 return -ENODEV;
1017
1018         /* Now register the driver for the EC */
1019         result = acpi_bus_register_driver(&acpi_ec_driver);
1020         if (result < 0) {
1021                 remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1022                 return -ENODEV;
1023         }
1024
1025         return result;
1026 }
1027
1028 subsys_initcall(acpi_ec_init);
1029
1030 /* EC driver currently not unloadable */
1031 #if 0
1032 static void __exit acpi_ec_exit(void)
1033 {
1034
1035         acpi_bus_unregister_driver(&acpi_ec_driver);
1036
1037         remove_proc_entry(ACPI_EC_CLASS, acpi_root_dir);
1038
1039         return;
1040 }
1041 #endif                          /* 0 */
1042
1043 static int __init acpi_fake_ecdt_setup(char *str)
1044 {
1045         acpi_fake_ecdt_enabled = 1;
1046         return 1;
1047 }
1048
1049 __setup("acpi_fake_ecdt", acpi_fake_ecdt_setup);
1050 static int __init acpi_ec_set_intr_mode(char *str)
1051 {
1052         int intr;
1053
1054         if (!get_option(&str, &intr))
1055                 return 0;
1056
1057         if (intr) {
1058                 acpi_ec_mode = EC_INTR;
1059         } else {
1060                 acpi_ec_mode = EC_POLL;
1061         }
1062         acpi_ec_driver.ops.add = acpi_ec_add;
1063         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "EC %s mode.\n", intr ? "interrupt" : "polling"));
1064
1065         return 1;
1066 }
1067
1068 __setup("ec_intr=", acpi_ec_set_intr_mode);