git.oblomov.eu Git - linux-2.6/blob - drivers/acpi/sbs.c

   1 /*
   2  *  acpi_sbs.c - ACPI Smart Battery System Driver ($Revision: 1.16 $)
   3  *
   4  *  Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu>
   5  *
   6  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 2 of the License, or (at
  11  *  your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful, but
  14  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  *  General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License along
  19  *  with this program; if not, write to the Free Software Foundation, Inc.,
  20  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  21  *
  22  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  23  */
  24
  25 #include <linux/init.h>
  26 #include <linux/module.h>
  27 #include <linux/moduleparam.h>
  28 #include <linux/kernel.h>
  29 #include <linux/proc_fs.h>
  30 #include <linux/seq_file.h>
  31 #include <asm/uaccess.h>
  32 #include <linux/acpi.h>
  33 #include <linux/i2c.h>
  34 #include <linux/delay.h>
  35
  36 #include "i2c_ec.h"
  37
  38 #define DEF_CAPACITY_UNIT       3
  39 #define MAH_CAPACITY_UNIT       1
  40 #define MWH_CAPACITY_UNIT       2
  41 #define CAPACITY_UNIT           DEF_CAPACITY_UNIT
  42
  43 #define REQUEST_UPDATE_MODE     1
  44 #define QUEUE_UPDATE_MODE       2
  45
  46 #define DATA_TYPE_COMMON        0
  47 #define DATA_TYPE_INFO          1
  48 #define DATA_TYPE_STATE         2
  49 #define DATA_TYPE_ALARM         3
  50 #define DATA_TYPE_AC_STATE      4
  51
  52 extern struct proc_dir_entry *acpi_lock_ac_dir(void);
  53 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
  54 extern void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir);
  55 extern void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
  56
  57 #define ACPI_SBS_COMPONENT              0x00080000
  58 #define ACPI_SBS_CLASS                  "sbs"
  59 #define ACPI_AC_CLASS                   "ac_adapter"
  60 #define ACPI_BATTERY_CLASS              "battery"
  61 #define ACPI_SBS_HID                    "ACPI0002"
  62 #define ACPI_SBS_DEVICE_NAME            "Smart Battery System"
  63 #define ACPI_SBS_FILE_INFO              "info"
  64 #define ACPI_SBS_FILE_STATE             "state"
  65 #define ACPI_SBS_FILE_ALARM             "alarm"
  66 #define ACPI_BATTERY_DIR_NAME           "BAT%i"
  67 #define ACPI_AC_DIR_NAME                "AC0"
  68 #define ACPI_SBC_SMBUS_ADDR             0x9
  69 #define ACPI_SBSM_SMBUS_ADDR            0xa
  70 #define ACPI_SB_SMBUS_ADDR              0xb
  71 #define ACPI_SBS_AC_NOTIFY_STATUS       0x80
  72 #define ACPI_SBS_BATTERY_NOTIFY_STATUS  0x80
  73 #define ACPI_SBS_BATTERY_NOTIFY_INFO    0x81
  74
  75 #define _COMPONENT                      ACPI_SBS_COMPONENT
  76
  77 #define MAX_SBS_BAT                     4
  78 #define MAX_SMBUS_ERR                   1
  79
  80 ACPI_MODULE_NAME("sbs");
  81
  82 MODULE_AUTHOR("Rich Townsend");
  83 MODULE_DESCRIPTION("Smart Battery System ACPI interface driver");
  84 MODULE_LICENSE("GPL");
  85
  86 static struct semaphore sbs_sem;
  87
  88 #define UPDATE_MODE             QUEUE_UPDATE_MODE
  89 /* REQUEST_UPDATE_MODE  QUEUE_UPDATE_MODE */
  90 #define UPDATE_INFO_MODE        0
  91 #define UPDATE_TIME             60
  92 #define UPDATE_TIME2            0
  93
  94 static int capacity_mode = CAPACITY_UNIT;
  95 static int update_mode = UPDATE_MODE;
  96 static int update_info_mode = UPDATE_INFO_MODE;
  97 static int update_time = UPDATE_TIME;
  98 static int update_time2 = UPDATE_TIME2;
  99
 100 module_param(capacity_mode, int, 0);
 101 module_param(update_mode, int, 0);
 102 module_param(update_info_mode, int, 0);
 103 module_param(update_time, int, 0);
 104 module_param(update_time2, int, 0);
 105
 106 static int acpi_sbs_add(struct acpi_device *device);
 107 static int acpi_sbs_remove(struct acpi_device *device, int type);
 108 static void acpi_battery_smbus_err_handler(struct acpi_ec_smbus *smbus);
 109 static void acpi_sbs_update_queue(void *data);
 110
 111 static struct acpi_driver acpi_sbs_driver = {
 112         .name = "sbs",
 113         .class = ACPI_SBS_CLASS,
 114         .ids = ACPI_SBS_HID,
 115         .ops = {
 116                 .add = acpi_sbs_add,
 117                 .remove = acpi_sbs_remove,
 118                 },
 119 };
 120
 121 struct acpi_battery_info {
 122         int capacity_mode;
 123         s16 full_charge_capacity;
 124         s16 design_capacity;
 125         s16 design_voltage;
 126         int vscale;
 127         int ipscale;
 128         s16 serial_number;
 129         char manufacturer_name[I2C_SMBUS_BLOCK_MAX + 3];
 130         char device_name[I2C_SMBUS_BLOCK_MAX + 3];
 131         char device_chemistry[I2C_SMBUS_BLOCK_MAX + 3];
 132 };
 133
 134 struct acpi_battery_state {
 135         s16 voltage;
 136         s16 amperage;
 137         s16 remaining_capacity;
 138         s16 average_time_to_empty;
 139         s16 average_time_to_full;
 140         s16 battery_status;
 141 };
 142
 143 struct acpi_battery_alarm {
 144         s16 remaining_capacity;
 145 };
 146
 147 struct acpi_battery {
 148         int alive;
 149         int battery_present;
 150         int id;
 151         int init_state;
 152         struct acpi_sbs *sbs;
 153         struct acpi_battery_info info;
 154         struct acpi_battery_state state;
 155         struct acpi_battery_alarm alarm;
 156         struct proc_dir_entry *battery_entry;
 157 };
 158
 159 struct acpi_sbs {
 160         acpi_handle handle;
 161         struct acpi_device *device;
 162         struct acpi_ec_smbus *smbus;
 163         int sbsm_present;
 164         int sbsm_batteries_supported;
 165         int ac_present;
 166         struct proc_dir_entry *ac_entry;
 167         struct acpi_battery battery[MAX_SBS_BAT];
 168         int update_info_mode;
 169         int zombie;
 170         int update_time;
 171         int update_time2;
 172         struct timer_list update_timer;
 173 };
 174
 175 static void acpi_update_delay(struct acpi_sbs *sbs);
 176 static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type);
 177
 178 /* --------------------------------------------------------------------------
 179                                SMBus Communication
 180    -------------------------------------------------------------------------- */
 181
 182 static void acpi_battery_smbus_err_handler(struct acpi_ec_smbus *smbus)
 183 {
 184         union i2c_smbus_data data;
 185         int result = 0;
 186         char *err_str;
 187         int err_number;
 188
 189         data.word = 0;
 190
 191         result = smbus->adapter.algo->
 192             smbus_xfer(&smbus->adapter,
 193                        ACPI_SB_SMBUS_ADDR,
 194                        0, I2C_SMBUS_READ, 0x16, I2C_SMBUS_BLOCK_DATA, &data);
 195
 196         err_number = (data.word & 0x000f);
 197
 198         switch (data.word & 0x000f) {
 199         case 0x0000:
 200                 err_str = "unexpected bus error";
 201                 break;
 202         case 0x0001:
 203                 err_str = "busy";
 204                 break;
 205         case 0x0002:
 206                 err_str = "reserved command";
 207                 break;
 208         case 0x0003:
 209                 err_str = "unsupported command";
 210                 break;
 211         case 0x0004:
 212                 err_str = "access denied";
 213                 break;
 214         case 0x0005:
 215                 err_str = "overflow/underflow";
 216                 break;
 217         case 0x0006:
 218                 err_str = "bad size";
 219                 break;
 220         case 0x0007:
 221                 err_str = "unknown error";
 222                 break;
 223         default:
 224                 err_str = "unrecognized error";
 225         }
 226         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 227                           "%s: ret %i, err %i\n", err_str, result, err_number));
 228 }
 229
 230 static int
 231 acpi_sbs_smbus_read_word(struct acpi_ec_smbus *smbus, int addr, int func,
 232                          u16 * word,
 233                          void (*err_handler) (struct acpi_ec_smbus * smbus))
 234 {
 235         union i2c_smbus_data data;
 236         int result = 0;
 237         int i;
 238
 239         if (err_handler == NULL) {
 240                 err_handler = acpi_battery_smbus_err_handler;
 241         }
 242
 243         for (i = 0; i < MAX_SMBUS_ERR; i++) {
 244                 result =
 245                     smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
 246                                                     I2C_SMBUS_READ, func,
 247                                                     I2C_SMBUS_WORD_DATA, &data);
 248                 if (result) {
 249                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 250                                           "try %i: smbus->adapter.algo->smbus_xfer() failed\n",
 251                                           i));
 252                         if (err_handler) {
 253                                 err_handler(smbus);
 254                         }
 255                 } else {
 256                         *word = data.word;
 257                         break;
 258                 }
 259         }
 260
 261         return result;
 262 }
 263
 264 static int
 265 acpi_sbs_smbus_read_str(struct acpi_ec_smbus *smbus, int addr, int func,
 266                         char *str,
 267                         void (*err_handler) (struct acpi_ec_smbus * smbus))
 268 {
 269         union i2c_smbus_data data;
 270         int result = 0;
 271         int i;
 272
 273         if (err_handler == NULL) {
 274                 err_handler = acpi_battery_smbus_err_handler;
 275         }
 276
 277         for (i = 0; i < MAX_SMBUS_ERR; i++) {
 278                 result =
 279                     smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
 280                                                     I2C_SMBUS_READ, func,
 281                                                     I2C_SMBUS_BLOCK_DATA,
 282                                                     &data);
 283                 if (result) {
 284                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 285                                           "try %i: smbus->adapter.algo->smbus_xfer() failed\n",
 286                                           i));
 287                         if (err_handler) {
 288                                 err_handler(smbus);
 289                         }
 290                 } else {
 291                         strncpy(str, (const char *)data.block + 1,
 292                                 data.block[0]);
 293                         str[data.block[0]] = 0;
 294                         break;
 295                 }
 296         }
 297
 298         return result;
 299 }
 300
 301 static int
 302 acpi_sbs_smbus_write_word(struct acpi_ec_smbus *smbus, int addr, int func,
 303                           int word,
 304                           void (*err_handler) (struct acpi_ec_smbus * smbus))
 305 {
 306         union i2c_smbus_data data;
 307         int result = 0;
 308         int i;
 309
 310         if (err_handler == NULL) {
 311                 err_handler = acpi_battery_smbus_err_handler;
 312         }
 313
 314         data.word = word;
 315
 316         for (i = 0; i < MAX_SMBUS_ERR; i++) {
 317                 result =
 318                     smbus->adapter.algo->smbus_xfer(&smbus->adapter, addr, 0,
 319                                                     I2C_SMBUS_WRITE, func,
 320                                                     I2C_SMBUS_WORD_DATA, &data);
 321                 if (result) {
 322                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 323                                           "try %i: smbus->adapter.algo"
 324                                           "->smbus_xfer() failed\n", i));
 325                         if (err_handler) {
 326                                 err_handler(smbus);
 327                         }
 328                 } else {
 329                         break;
 330                 }
 331         }
 332
 333         return result;
 334 }
 335
 336 /* --------------------------------------------------------------------------
 337                             Smart Battery System Management
 338    -------------------------------------------------------------------------- */
 339
 340 /* Smart Battery */
 341
 342 static int acpi_sbs_generate_event(struct acpi_device *device,
 343                                    int event, int state, char *bid, char *class)
 344 {
 345         char bid_saved[5];
 346         char class_saved[20];
 347         int result = 0;
 348
 349         strcpy(bid_saved, acpi_device_bid(device));
 350         strcpy(class_saved, acpi_device_class(device));
 351
 352         strcpy(acpi_device_bid(device), bid);
 353         strcpy(acpi_device_class(device), class);
 354
 355         result = acpi_bus_generate_event(device, event, state);
 356
 357         strcpy(acpi_device_bid(device), bid_saved);
 358         strcpy(acpi_device_class(device), class_saved);
 359
 360         return result;
 361 }
 362
 363 static int acpi_battery_get_present(struct acpi_battery *battery)
 364 {
 365         s16 state;
 366         int result = 0;
 367         int is_present = 0;
 368
 369         result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
 370                                           ACPI_SBSM_SMBUS_ADDR, 0x01,
 371                                           &state, NULL);
 372         if (result) {
 373                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 374                                   "acpi_sbs_smbus_read_word() failed"));
 375         }
 376         if (!result) {
 377                 is_present = (state & 0x000f) & (1 << battery->id);
 378         }
 379         battery->battery_present = is_present;
 380
 381         return result;
 382 }
 383
 384 static int acpi_battery_is_present(struct acpi_battery *battery)
 385 {
 386         return (battery->battery_present);
 387 }
 388
 389 static int acpi_ac_is_present(struct acpi_sbs *sbs)
 390 {
 391         return (sbs->ac_present);
 392 }
 393
 394 static int acpi_battery_select(struct acpi_battery *battery)
 395 {
 396         struct acpi_ec_smbus *smbus = battery->sbs->smbus;
 397         int result = 0;
 398         s16 state;
 399         int foo;
 400
 401         if (battery->sbs->sbsm_present) {
 402
 403                 /* Take special care not to knobble other nibbles of
 404                  * state (aka selector_state), since
 405                  * it causes charging to halt on SBSELs */
 406
 407                 result =
 408                     acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x01,
 409                                              &state, NULL);
 410                 if (result) {
 411                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 412                                           "acpi_sbs_smbus_read_word() failed\n"));
 413                         goto end;
 414                 }
 415
 416                 foo = (state & 0x0fff) | (1 << (battery->id + 12));
 417                 result =
 418                     acpi_sbs_smbus_write_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x01,
 419                                               foo, NULL);
 420                 if (result) {
 421                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 422                                           "acpi_sbs_smbus_write_word() failed\n"));
 423                         goto end;
 424                 }
 425         }
 426
 427       end:
 428         return result;
 429 }
 430
 431 static int acpi_sbsm_get_info(struct acpi_sbs *sbs)
 432 {
 433         struct acpi_ec_smbus *smbus = sbs->smbus;
 434         int result = 0;
 435         s16 battery_system_info;
 436
 437         result = acpi_sbs_smbus_read_word(smbus, ACPI_SBSM_SMBUS_ADDR, 0x04,
 438                                           &battery_system_info, NULL);
 439         if (result) {
 440                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 441                                   "acpi_sbs_smbus_read_word() failed\n"));
 442                 goto end;
 443         }
 444
 445         sbs->sbsm_batteries_supported = battery_system_info & 0x000f;
 446
 447       end:
 448
 449         return result;
 450 }
 451
 452 static int acpi_battery_get_info(struct acpi_battery *battery)
 453 {
 454         struct acpi_ec_smbus *smbus = battery->sbs->smbus;
 455         int result = 0;
 456         s16 battery_mode;
 457         s16 specification_info;
 458
 459         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03,
 460                                           &battery_mode,
 461                                           &acpi_battery_smbus_err_handler);
 462         if (result) {
 463                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 464                                   "acpi_sbs_smbus_read_word() failed\n"));
 465                 goto end;
 466         }
 467         battery->info.capacity_mode = (battery_mode & 0x8000) >> 15;
 468
 469         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x10,
 470                                           &battery->info.full_charge_capacity,
 471                                           &acpi_battery_smbus_err_handler);
 472         if (result) {
 473                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 474                                   "acpi_sbs_smbus_read_word() failed\n"));
 475                 goto end;
 476         }
 477
 478         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x18,
 479                                           &battery->info.design_capacity,
 480                                           &acpi_battery_smbus_err_handler);
 481
 482         if (result) {
 483                 goto end;
 484         }
 485
 486         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x19,
 487                                           &battery->info.design_voltage,
 488                                           &acpi_battery_smbus_err_handler);
 489         if (result) {
 490                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 491                                   "acpi_sbs_smbus_read_word() failed\n"));
 492                 goto end;
 493         }
 494
 495         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x1a,
 496                                           &specification_info,
 497                                           &acpi_battery_smbus_err_handler);
 498         if (result) {
 499                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 500                                   "acpi_sbs_smbus_read_word() failed\n"));
 501                 goto end;
 502         }
 503
 504         switch ((specification_info & 0x0f00) >> 8) {
 505         case 1:
 506                 battery->info.vscale = 10;
 507                 break;
 508         case 2:
 509                 battery->info.vscale = 100;
 510                 break;
 511         case 3:
 512                 battery->info.vscale = 1000;
 513                 break;
 514         default:
 515                 battery->info.vscale = 1;
 516         }
 517
 518         switch ((specification_info & 0xf000) >> 12) {
 519         case 1:
 520                 battery->info.ipscale = 10;
 521                 break;
 522         case 2:
 523                 battery->info.ipscale = 100;
 524                 break;
 525         case 3:
 526                 battery->info.ipscale = 1000;
 527                 break;
 528         default:
 529                 battery->info.ipscale = 1;
 530         }
 531
 532         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x1c,
 533                                           &battery->info.serial_number,
 534                                           &acpi_battery_smbus_err_handler);
 535         if (result) {
 536                 goto end;
 537         }
 538
 539         result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x20,
 540                                          battery->info.manufacturer_name,
 541                                          &acpi_battery_smbus_err_handler);
 542         if (result) {
 543                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 544                                   "acpi_sbs_smbus_read_str() failed\n"));
 545                 goto end;
 546         }
 547
 548         result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x21,
 549                                          battery->info.device_name,
 550                                          &acpi_battery_smbus_err_handler);
 551         if (result) {
 552                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 553                                   "acpi_sbs_smbus_read_str() failed\n"));
 554                 goto end;
 555         }
 556
 557         result = acpi_sbs_smbus_read_str(smbus, ACPI_SB_SMBUS_ADDR, 0x22,
 558                                          battery->info.device_chemistry,
 559                                          &acpi_battery_smbus_err_handler);
 560         if (result) {
 561                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 562                                   "acpi_sbs_smbus_read_str() failed\n"));
 563                 goto end;
 564         }
 565
 566       end:
 567         return result;
 568 }
 569
 570 static void acpi_update_delay(struct acpi_sbs *sbs)
 571 {
 572         if (sbs->zombie) {
 573                 return;
 574         }
 575         if (sbs->update_time2 > 0) {
 576                 msleep(sbs->update_time2 * 1000);
 577         }
 578 }
 579
 580 static int acpi_battery_get_state(struct acpi_battery *battery)
 581 {
 582         struct acpi_ec_smbus *smbus = battery->sbs->smbus;
 583         int result = 0;
 584
 585         acpi_update_delay(battery->sbs);
 586         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x09,
 587                                           &battery->state.voltage,
 588                                           &acpi_battery_smbus_err_handler);
 589         if (result) {
 590                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 591                                   "acpi_sbs_smbus_read_word() failed\n"));
 592                 goto end;
 593         }
 594
 595         acpi_update_delay(battery->sbs);
 596         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x0a,
 597                                           &battery->state.amperage,
 598                                           &acpi_battery_smbus_err_handler);
 599         if (result) {
 600                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 601                                   "acpi_sbs_smbus_read_word() failed\n"));
 602                 goto end;
 603         }
 604
 605         acpi_update_delay(battery->sbs);
 606         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x0f,
 607                                           &battery->state.remaining_capacity,
 608                                           &acpi_battery_smbus_err_handler);
 609         if (result) {
 610                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 611                                   "acpi_sbs_smbus_read_word() failed\n"));
 612                 goto end;
 613         }
 614
 615         acpi_update_delay(battery->sbs);
 616         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x12,
 617                                           &battery->state.average_time_to_empty,
 618                                           &acpi_battery_smbus_err_handler);
 619         if (result) {
 620                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 621                                   "acpi_sbs_smbus_read_word() failed\n"));
 622                 goto end;
 623         }
 624
 625         acpi_update_delay(battery->sbs);
 626         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x13,
 627                                           &battery->state.average_time_to_full,
 628                                           &acpi_battery_smbus_err_handler);
 629         if (result) {
 630                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 631                                   "acpi_sbs_smbus_read_word() failed\n"));
 632                 goto end;
 633         }
 634
 635         acpi_update_delay(battery->sbs);
 636         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x16,
 637                                           &battery->state.battery_status,
 638                                           &acpi_battery_smbus_err_handler);
 639         if (result) {
 640                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 641                                   "acpi_sbs_smbus_read_word() failed\n"));
 642                 goto end;
 643         }
 644
 645         acpi_update_delay(battery->sbs);
 646
 647       end:
 648         return result;
 649 }
 650
 651 static int acpi_battery_get_alarm(struct acpi_battery *battery)
 652 {
 653         struct acpi_ec_smbus *smbus = battery->sbs->smbus;
 654         int result = 0;
 655
 656         result = acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
 657                                           &battery->alarm.remaining_capacity,
 658                                           &acpi_battery_smbus_err_handler);
 659         if (result) {
 660                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 661                                   "acpi_sbs_smbus_read_word() failed\n"));
 662                 goto end;
 663         }
 664
 665         acpi_update_delay(battery->sbs);
 666
 667       end:
 668
 669         return result;
 670 }
 671
 672 static int acpi_battery_set_alarm(struct acpi_battery *battery,
 673                                   unsigned long alarm)
 674 {
 675         struct acpi_ec_smbus *smbus = battery->sbs->smbus;
 676         int result = 0;
 677         s16 battery_mode;
 678         int foo;
 679
 680         result = acpi_battery_select(battery);
 681         if (result) {
 682                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 683                                   "acpi_battery_select() failed\n"));
 684                 goto end;
 685         }
 686
 687         /* If necessary, enable the alarm */
 688
 689         if (alarm > 0) {
 690                 result =
 691                     acpi_sbs_smbus_read_word(smbus, ACPI_SB_SMBUS_ADDR, 0x03,
 692                                              &battery_mode,
 693                                              &acpi_battery_smbus_err_handler);
 694                 if (result) {
 695                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 696                                           "acpi_sbs_smbus_read_word() failed\n"));
 697                         goto end;
 698                 }
 699
 700                 result =
 701                     acpi_sbs_smbus_write_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
 702                                               battery_mode & 0xbfff,
 703                                               &acpi_battery_smbus_err_handler);
 704                 if (result) {
 705                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 706                                           "acpi_sbs_smbus_write_word() failed\n"));
 707                         goto end;
 708                 }
 709         }
 710
 711         foo = alarm / (battery->info.capacity_mode ? 10 : 1);
 712         result = acpi_sbs_smbus_write_word(smbus, ACPI_SB_SMBUS_ADDR, 0x01,
 713                                            foo,
 714                                            &acpi_battery_smbus_err_handler);
 715         if (result) {
 716                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 717                                   "acpi_sbs_smbus_write_word() failed\n"));
 718                 goto end;
 719         }
 720
 721       end:
 722
 723         return result;
 724 }
 725
 726 static int acpi_battery_set_mode(struct acpi_battery *battery)
 727 {
 728         int result = 0;
 729         s16 battery_mode;
 730
 731         if (capacity_mode == DEF_CAPACITY_UNIT) {
 732                 goto end;
 733         }
 734
 735         result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
 736                                           ACPI_SB_SMBUS_ADDR, 0x03,
 737                                           &battery_mode, NULL);
 738         if (result) {
 739                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 740                                   "acpi_sbs_smbus_read_word() failed\n"));
 741                 goto end;
 742         }
 743
 744         if (capacity_mode == MAH_CAPACITY_UNIT) {
 745                 battery_mode &= 0x7fff;
 746         } else {
 747                 battery_mode |= 0x8000;
 748         }
 749         result = acpi_sbs_smbus_write_word(battery->sbs->smbus,
 750                                            ACPI_SB_SMBUS_ADDR, 0x03,
 751                                            battery_mode, NULL);
 752         if (result) {
 753                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 754                                   "acpi_sbs_smbus_write_word() failed\n"));
 755                 goto end;
 756         }
 757
 758         result = acpi_sbs_smbus_read_word(battery->sbs->smbus,
 759                                           ACPI_SB_SMBUS_ADDR, 0x03,
 760                                           &battery_mode, NULL);
 761         if (result) {
 762                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 763                                   "acpi_sbs_smbus_read_word() failed\n"));
 764                 goto end;
 765         }
 766
 767       end:
 768         return result;
 769 }
 770
 771 static int acpi_battery_init(struct acpi_battery *battery)
 772 {
 773         int result = 0;
 774
 775         result = acpi_battery_select(battery);
 776         if (result) {
 777                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 778                                   "acpi_battery_init() failed\n"));
 779                 goto end;
 780         }
 781
 782         result = acpi_battery_set_mode(battery);
 783         if (result) {
 784                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 785                                   "acpi_battery_set_mode() failed\n"));
 786                 goto end;
 787         }
 788
 789         result = acpi_battery_get_info(battery);
 790         if (result) {
 791                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 792                                   "acpi_battery_get_info() failed\n"));
 793                 goto end;
 794         }
 795
 796         result = acpi_battery_get_state(battery);
 797         if (result) {
 798                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 799                                   "acpi_battery_get_state() failed\n"));
 800                 goto end;
 801         }
 802
 803         result = acpi_battery_get_alarm(battery);
 804         if (result) {
 805                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 806                                   "acpi_battery_get_alarm() failed\n"));
 807                 goto end;
 808         }
 809
 810       end:
 811         return result;
 812 }
 813
 814 static int acpi_ac_get_present(struct acpi_sbs *sbs)
 815 {
 816         struct acpi_ec_smbus *smbus = sbs->smbus;
 817         int result = 0;
 818         s16 charger_status;
 819
 820         result = acpi_sbs_smbus_read_word(smbus, ACPI_SBC_SMBUS_ADDR, 0x13,
 821                                           &charger_status, NULL);
 822
 823         if (result) {
 824                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 825                                   "acpi_sbs_smbus_read_word() failed\n"));
 826                 goto end;
 827         }
 828
 829         sbs->ac_present = (charger_status & 0x8000) >> 15;
 830
 831       end:
 832
 833         return result;
 834 }
 835
 836 /* --------------------------------------------------------------------------
 837                               FS Interface (/proc/acpi)
 838    -------------------------------------------------------------------------- */
 839
 840 /* Generic Routines */
 841
 842 static int
 843 acpi_sbs_generic_add_fs(struct proc_dir_entry **dir,
 844                         struct proc_dir_entry *parent_dir,
 845                         char *dir_name,
 846                         struct file_operations *info_fops,
 847                         struct file_operations *state_fops,
 848                         struct file_operations *alarm_fops, void *data)
 849 {
 850         struct proc_dir_entry *entry = NULL;
 851
 852         if (!*dir) {
 853                 *dir = proc_mkdir(dir_name, parent_dir);
 854                 if (!*dir) {
 855                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 856                                           "proc_mkdir() failed\n"));
 857                         return -ENODEV;
 858                 }
 859                 (*dir)->owner = THIS_MODULE;
 860         }
 861
 862         /* 'info' [R] */
 863         if (info_fops) {
 864                 entry = create_proc_entry(ACPI_SBS_FILE_INFO, S_IRUGO, *dir);
 865                 if (!entry) {
 866                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 867                                           "create_proc_entry() failed\n"));
 868                 } else {
 869                         entry->proc_fops = info_fops;
 870                         entry->data = data;
 871                         entry->owner = THIS_MODULE;
 872                 }
 873         }
 874
 875         /* 'state' [R] */
 876         if (state_fops) {
 877                 entry = create_proc_entry(ACPI_SBS_FILE_STATE, S_IRUGO, *dir);
 878                 if (!entry) {
 879                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 880                                           "create_proc_entry() failed\n"));
 881                 } else {
 882                         entry->proc_fops = state_fops;
 883                         entry->data = data;
 884                         entry->owner = THIS_MODULE;
 885                 }
 886         }
 887
 888         /* 'alarm' [R/W] */
 889         if (alarm_fops) {
 890                 entry = create_proc_entry(ACPI_SBS_FILE_ALARM, S_IRUGO, *dir);
 891                 if (!entry) {
 892                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 893                                           "create_proc_entry() failed\n"));
 894                 } else {
 895                         entry->proc_fops = alarm_fops;
 896                         entry->data = data;
 897                         entry->owner = THIS_MODULE;
 898                 }
 899         }
 900
 901         return 0;
 902 }
 903
 904 static void
 905 acpi_sbs_generic_remove_fs(struct proc_dir_entry **dir,
 906                            struct proc_dir_entry *parent_dir)
 907 {
 908
 909         if (*dir) {
 910                 remove_proc_entry(ACPI_SBS_FILE_INFO, *dir);
 911                 remove_proc_entry(ACPI_SBS_FILE_STATE, *dir);
 912                 remove_proc_entry(ACPI_SBS_FILE_ALARM, *dir);
 913                 remove_proc_entry((*dir)->name, parent_dir);
 914                 *dir = NULL;
 915         }
 916
 917 }
 918
 919 /* Smart Battery Interface */
 920
 921 static struct proc_dir_entry *acpi_battery_dir = NULL;
 922
 923 static int acpi_battery_read_info(struct seq_file *seq, void *offset)
 924 {
 925         struct acpi_battery *battery = seq->private;
 926         int cscale;
 927         int result = 0;
 928
 929         if (battery->sbs->zombie) {
 930                 return -ENODEV;
 931         }
 932
 933         down(&sbs_sem);
 934
 935         if (update_mode == REQUEST_UPDATE_MODE) {
 936                 result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_INFO);
 937                 if (result) {
 938                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
 939                                           "acpi_sbs_update_run() failed\n"));
 940                 }
 941         }
 942
 943         if (acpi_battery_is_present(battery)) {
 944                 seq_printf(seq, "present:                 yes\n");
 945         } else {
 946                 seq_printf(seq, "present:                 no\n");
 947                 goto end;
 948         }
 949
 950         if (battery->info.capacity_mode) {
 951                 cscale = battery->info.vscale * battery->info.ipscale;
 952         } else {
 953                 cscale = battery->info.ipscale;
 954         }
 955         seq_printf(seq, "design capacity:         %i%s",
 956                    battery->info.design_capacity * cscale,
 957                    battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
 958
 959         seq_printf(seq, "last full capacity:      %i%s",
 960                    battery->info.full_charge_capacity * cscale,
 961                    battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
 962
 963         seq_printf(seq, "battery technology:      rechargeable\n");
 964
 965         seq_printf(seq, "design voltage:          %i mV\n",
 966                    battery->info.design_voltage * battery->info.vscale);
 967
 968         seq_printf(seq, "design capacity warning: unknown\n");
 969         seq_printf(seq, "design capacity low:     unknown\n");
 970         seq_printf(seq, "capacity granularity 1:  unknown\n");
 971         seq_printf(seq, "capacity granularity 2:  unknown\n");
 972
 973         seq_printf(seq, "model number:            %s\n",
 974                    battery->info.device_name);
 975
 976         seq_printf(seq, "serial number:           %i\n",
 977                    battery->info.serial_number);
 978
 979         seq_printf(seq, "battery type:            %s\n",
 980                    battery->info.device_chemistry);
 981
 982         seq_printf(seq, "OEM info:                %s\n",
 983                    battery->info.manufacturer_name);
 984
 985       end:
 986
 987         up(&sbs_sem);
 988
 989         return result;
 990 }
 991
 992 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
 993 {
 994         return single_open(file, acpi_battery_read_info, PDE(inode)->data);
 995 }
 996
 997 static int acpi_battery_read_state(struct seq_file *seq, void *offset)
 998 {
 999         struct acpi_battery *battery = (struct acpi_battery *)seq->private;
1000         int result = 0;
1001         int cscale;
1002         int foo;
1003
1004         if (battery->sbs->zombie) {
1005                 return -ENODEV;
1006         }
1007
1008         down(&sbs_sem);
1009
1010         if (update_mode == REQUEST_UPDATE_MODE) {
1011                 result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_STATE);
1012                 if (result) {
1013                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1014                                           "acpi_sbs_update_run() failed\n"));
1015                 }
1016         }
1017
1018         if (acpi_battery_is_present(battery)) {
1019                 seq_printf(seq, "present:                 yes\n");
1020         } else {
1021                 seq_printf(seq, "present:                 no\n");
1022                 goto end;
1023         }
1024
1025         if (battery->info.capacity_mode) {
1026                 cscale = battery->info.vscale * battery->info.ipscale;
1027         } else {
1028                 cscale = battery->info.ipscale;
1029         }
1030
1031         if (battery->state.battery_status & 0x0010) {
1032                 seq_printf(seq, "capacity state:          critical\n");
1033         } else {
1034                 seq_printf(seq, "capacity state:          ok\n");
1035         }
1036
1037         foo = (s16) battery->state.amperage * battery->info.ipscale;
1038         if (battery->info.capacity_mode) {
1039                 foo = foo * battery->info.design_voltage / 1000;
1040         }
1041         if (battery->state.amperage < 0) {
1042                 seq_printf(seq, "charging state:          discharging\n");
1043                 seq_printf(seq, "present rate:            %d %s\n",
1044                            -foo, battery->info.capacity_mode ? "mW" : "mA");
1045         } else if (battery->state.amperage > 0) {
1046                 seq_printf(seq, "charging state:          charging\n");
1047                 seq_printf(seq, "present rate:            %d %s\n",
1048                            foo, battery->info.capacity_mode ? "mW" : "mA");
1049         } else {
1050                 seq_printf(seq, "charging state:          charged\n");
1051                 seq_printf(seq, "present rate:            0 %s\n",
1052                            battery->info.capacity_mode ? "mW" : "mA");
1053         }
1054
1055         seq_printf(seq, "remaining capacity:      %i%s",
1056                    battery->state.remaining_capacity * cscale,
1057                    battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
1058
1059         seq_printf(seq, "present voltage:         %i mV\n",
1060                    battery->state.voltage * battery->info.vscale);
1061
1062       end:
1063
1064         up(&sbs_sem);
1065
1066         return result;
1067 }
1068
1069 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
1070 {
1071         return single_open(file, acpi_battery_read_state, PDE(inode)->data);
1072 }
1073
1074 static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
1075 {
1076         struct acpi_battery *battery = seq->private;
1077         int result = 0;
1078         int cscale;
1079
1080         if (battery->sbs->zombie) {
1081                 return -ENODEV;
1082         }
1083
1084         down(&sbs_sem);
1085
1086         if (update_mode == REQUEST_UPDATE_MODE) {
1087                 result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_ALARM);
1088                 if (result) {
1089                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1090                                           "acpi_sbs_update_run() failed\n"));
1091                 }
1092         }
1093
1094         if (!acpi_battery_is_present(battery)) {
1095                 seq_printf(seq, "present:                 no\n");
1096                 goto end;
1097         }
1098
1099         if (battery->info.capacity_mode) {
1100                 cscale = battery->info.vscale * battery->info.ipscale;
1101         } else {
1102                 cscale = battery->info.ipscale;
1103         }
1104
1105         seq_printf(seq, "alarm:                   ");
1106         if (battery->alarm.remaining_capacity) {
1107                 seq_printf(seq, "%i%s",
1108                            battery->alarm.remaining_capacity * cscale,
1109                            battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
1110         } else {
1111                 seq_printf(seq, "disabled\n");
1112         }
1113
1114       end:
1115
1116         up(&sbs_sem);
1117
1118         return result;
1119 }
1120
1121 static ssize_t
1122 acpi_battery_write_alarm(struct file *file, const char __user * buffer,
1123                          size_t count, loff_t * ppos)
1124 {
1125         struct seq_file *seq = file->private_data;
1126         struct acpi_battery *battery = seq->private;
1127         char alarm_string[12] = { '\0' };
1128         int result, old_alarm, new_alarm;
1129
1130         if (battery->sbs->zombie) {
1131                 return -ENODEV;
1132         }
1133
1134         down(&sbs_sem);
1135
1136         if (!acpi_battery_is_present(battery)) {
1137                 result = -ENODEV;
1138                 goto end;
1139         }
1140
1141         if (count > sizeof(alarm_string) - 1) {
1142                 result = -EINVAL;
1143                 goto end;
1144         }
1145
1146         if (copy_from_user(alarm_string, buffer, count)) {
1147                 result = -EFAULT;
1148                 goto end;
1149         }
1150
1151         alarm_string[count] = 0;
1152
1153         old_alarm = battery->alarm.remaining_capacity;
1154         new_alarm = simple_strtoul(alarm_string, NULL, 0);
1155
1156         result = acpi_battery_set_alarm(battery, new_alarm);
1157         if (result) {
1158                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1159                                   "acpi_battery_set_alarm() failed\n"));
1160                 acpi_battery_set_alarm(battery, old_alarm);
1161                 goto end;
1162         }
1163         result = acpi_battery_get_alarm(battery);
1164         if (result) {
1165                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1166                                   "acpi_battery_get_alarm() failed\n"));
1167                 acpi_battery_set_alarm(battery, old_alarm);
1168                 goto end;
1169         }
1170
1171       end:
1172         up(&sbs_sem);
1173
1174         if (result) {
1175                 return result;
1176         } else {
1177                 return count;
1178         }
1179 }
1180
1181 static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
1182 {
1183         return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
1184 }
1185
1186 static struct file_operations acpi_battery_info_fops = {
1187         .open = acpi_battery_info_open_fs,
1188         .read = seq_read,
1189         .llseek = seq_lseek,
1190         .release = single_release,
1191         .owner = THIS_MODULE,
1192 };
1193
1194 static struct file_operations acpi_battery_state_fops = {
1195         .open = acpi_battery_state_open_fs,
1196         .read = seq_read,
1197         .llseek = seq_lseek,
1198         .release = single_release,
1199         .owner = THIS_MODULE,
1200 };
1201
1202 static struct file_operations acpi_battery_alarm_fops = {
1203         .open = acpi_battery_alarm_open_fs,
1204         .read = seq_read,
1205         .write = acpi_battery_write_alarm,
1206         .llseek = seq_lseek,
1207         .release = single_release,
1208         .owner = THIS_MODULE,
1209 };
1210
1211 /* Legacy AC Adapter Interface */
1212
1213 static struct proc_dir_entry *acpi_ac_dir = NULL;
1214
1215 static int acpi_ac_read_state(struct seq_file *seq, void *offset)
1216 {
1217         struct acpi_sbs *sbs = seq->private;
1218         int result;
1219
1220         if (sbs->zombie) {
1221                 return -ENODEV;
1222         }
1223
1224         down(&sbs_sem);
1225
1226         if (update_mode == REQUEST_UPDATE_MODE) {
1227                 result = acpi_sbs_update_run(sbs, DATA_TYPE_AC_STATE);
1228                 if (result) {
1229                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1230                                           "acpi_sbs_update_run() failed\n"));
1231                 }
1232         }
1233
1234         seq_printf(seq, "state:                   %s\n",
1235                    sbs->ac_present ? "on-line" : "off-line");
1236
1237         up(&sbs_sem);
1238
1239         return 0;
1240 }
1241
1242 static int acpi_ac_state_open_fs(struct inode *inode, struct file *file)
1243 {
1244         return single_open(file, acpi_ac_read_state, PDE(inode)->data);
1245 }
1246
1247 static struct file_operations acpi_ac_state_fops = {
1248         .open = acpi_ac_state_open_fs,
1249         .read = seq_read,
1250         .llseek = seq_lseek,
1251         .release = single_release,
1252         .owner = THIS_MODULE,
1253 };
1254
1255 /* --------------------------------------------------------------------------
1256                                  Driver Interface
1257    -------------------------------------------------------------------------- */
1258
1259 /* Smart Battery */
1260
1261 static int acpi_battery_add(struct acpi_sbs *sbs, int id)
1262 {
1263         int is_present;
1264         int result;
1265         char dir_name[32];
1266         struct acpi_battery *battery;
1267
1268         battery = &sbs->battery[id];
1269
1270         battery->alive = 0;
1271
1272         battery->init_state = 0;
1273         battery->id = id;
1274         battery->sbs = sbs;
1275
1276         result = acpi_battery_select(battery);
1277         if (result) {
1278                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1279                                   "acpi_battery_select() failed\n"));
1280                 goto end;
1281         }
1282
1283         result = acpi_battery_get_present(battery);
1284         if (result) {
1285                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1286                                   "acpi_battery_get_present() failed\n"));
1287                 goto end;
1288         }
1289
1290         is_present = acpi_battery_is_present(battery);
1291
1292         if (is_present) {
1293                 result = acpi_battery_init(battery);
1294                 if (result) {
1295                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1296                                           "acpi_battery_init() failed\n"));
1297                         goto end;
1298                 }
1299                 battery->init_state = 1;
1300         }
1301
1302         sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
1303
1304         result = acpi_sbs_generic_add_fs(&battery->battery_entry,
1305                                          acpi_battery_dir,
1306                                          dir_name,
1307                                          &acpi_battery_info_fops,
1308                                          &acpi_battery_state_fops,
1309                                          &acpi_battery_alarm_fops, battery);
1310         if (result) {
1311                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1312                                   "acpi_sbs_generic_add_fs() failed\n"));
1313                 goto end;
1314         }
1315         battery->alive = 1;
1316
1317       end:
1318         return result;
1319 }
1320
1321 static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
1322 {
1323
1324         if (sbs->battery[id].battery_entry) {
1325                 acpi_sbs_generic_remove_fs(&(sbs->battery[id].battery_entry),
1326                                            acpi_battery_dir);
1327         }
1328 }
1329
1330 static int acpi_ac_add(struct acpi_sbs *sbs)
1331 {
1332         int result;
1333
1334         result = acpi_ac_get_present(sbs);
1335         if (result) {
1336                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1337                                   "acpi_ac_get_present() failed\n"));
1338                 goto end;
1339         }
1340
1341         result = acpi_sbs_generic_add_fs(&sbs->ac_entry,
1342                                          acpi_ac_dir,
1343                                          ACPI_AC_DIR_NAME,
1344                                          NULL, &acpi_ac_state_fops, NULL, sbs);
1345         if (result) {
1346                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1347                                   "acpi_sbs_generic_add_fs() failed\n"));
1348                 goto end;
1349         }
1350
1351       end:
1352
1353         return result;
1354 }
1355
1356 static void acpi_ac_remove(struct acpi_sbs *sbs)
1357 {
1358
1359         if (sbs->ac_entry) {
1360                 acpi_sbs_generic_remove_fs(&sbs->ac_entry, acpi_ac_dir);
1361         }
1362 }
1363
1364 static void acpi_sbs_update_queue_run(unsigned long data)
1365 {
1366         acpi_os_execute(OSL_GPE_HANDLER, acpi_sbs_update_queue, (void *)data);
1367 }
1368
1369 static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type)
1370 {
1371         struct acpi_battery *battery;
1372         int result = 0;
1373         int old_ac_present;
1374         int old_battery_present;
1375         int new_ac_present;
1376         int new_battery_present;
1377         int id;
1378         char dir_name[32];
1379         int do_battery_init, do_ac_init;
1380         s16 old_remaining_capacity;
1381
1382         if (sbs->zombie) {
1383                 goto end;
1384         }
1385
1386         old_ac_present = acpi_ac_is_present(sbs);
1387
1388         result = acpi_ac_get_present(sbs);
1389         if (result) {
1390                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1391                                   "acpi_ac_get_present() failed\n"));
1392         }
1393
1394         new_ac_present = acpi_ac_is_present(sbs);
1395
1396         do_ac_init = (old_ac_present != new_ac_present);
1397
1398         if (data_type == DATA_TYPE_AC_STATE) {
1399                 goto end;
1400         }
1401
1402         for (id = 0; id < MAX_SBS_BAT; id++) {
1403                 battery = &sbs->battery[id];
1404                 if (battery->alive == 0) {
1405                         continue;
1406                 }
1407
1408                 old_remaining_capacity = battery->state.remaining_capacity;
1409
1410                 old_battery_present = acpi_battery_is_present(battery);
1411
1412                 result = acpi_battery_select(battery);
1413                 if (result) {
1414                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1415                                           "acpi_battery_select() failed\n"));
1416                 }
1417                 if (sbs->zombie) {
1418                         goto end;
1419                 }
1420
1421                 result = acpi_battery_get_present(battery);
1422                 if (result) {
1423                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1424                                           "acpi_battery_get_present() failed\n"));
1425                 }
1426                 if (sbs->zombie) {
1427                         goto end;
1428                 }
1429
1430                 new_battery_present = acpi_battery_is_present(battery);
1431
1432                 do_battery_init = ((old_battery_present != new_battery_present)
1433                                    && new_battery_present);
1434
1435                 if (sbs->zombie) {
1436                         goto end;
1437                 }
1438                 if (do_ac_init || do_battery_init ||
1439                     update_info_mode || sbs->update_info_mode) {
1440                         if (sbs->update_info_mode) {
1441                                 sbs->update_info_mode = 0;
1442                         } else {
1443                                 sbs->update_info_mode = 1;
1444                         }
1445                         result = acpi_battery_init(battery);
1446                         if (result) {
1447                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1448                                                   "acpi_battery_init() "
1449                                                   "failed\n"));
1450                         }
1451                 }
1452                 if (data_type == DATA_TYPE_INFO) {
1453                         continue;
1454                 }
1455
1456                 if (sbs->zombie) {
1457                         goto end;
1458                 }
1459                 if (new_battery_present) {
1460                         result = acpi_battery_get_alarm(battery);
1461                         if (result) {
1462                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1463                                                   "acpi_battery_get_alarm() "
1464                                                   "failed\n"));
1465                         }
1466                         if (data_type == DATA_TYPE_ALARM) {
1467                                 continue;
1468                         }
1469
1470                         result = acpi_battery_get_state(battery);
1471                         if (result) {
1472                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1473                                                   "acpi_battery_get_state() "
1474                                                   "failed\n"));
1475                         }
1476                 }
1477                 if (sbs->zombie) {
1478                         goto end;
1479                 }
1480                 if (data_type != DATA_TYPE_COMMON) {
1481                         continue;
1482                 }
1483
1484                 if (old_battery_present != new_battery_present) {
1485                         sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
1486                         result = acpi_sbs_generate_event(sbs->device,
1487                                                          ACPI_SBS_BATTERY_NOTIFY_STATUS,
1488                                                          new_battery_present,
1489                                                          dir_name,
1490                                                          ACPI_BATTERY_CLASS);
1491                         if (result) {
1492                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1493                                                   "acpi_sbs_generate_event() "
1494                                                   "failed\n"));
1495                         }
1496                 }
1497                 if (old_remaining_capacity != battery->state.remaining_capacity) {
1498                         sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
1499                         result = acpi_sbs_generate_event(sbs->device,
1500                                                          ACPI_SBS_BATTERY_NOTIFY_STATUS,
1501                                                          new_battery_present,
1502                                                          dir_name,
1503                                                          ACPI_BATTERY_CLASS);
1504                         if (result) {
1505                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1506                                                   "acpi_sbs_generate_event() failed\n"));
1507                         }
1508                 }
1509
1510         }
1511         if (sbs->zombie) {
1512                 goto end;
1513         }
1514         if (data_type != DATA_TYPE_COMMON) {
1515                 goto end;
1516         }
1517
1518         if (old_ac_present != new_ac_present) {
1519                 result = acpi_sbs_generate_event(sbs->device,
1520                                                  ACPI_SBS_AC_NOTIFY_STATUS,
1521                                                  new_ac_present,
1522                                                  ACPI_AC_DIR_NAME,
1523                                                  ACPI_AC_CLASS);
1524                 if (result) {
1525                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1526                                           "acpi_sbs_generate_event() failed\n"));
1527                 }
1528         }
1529
1530       end:
1531         return result;
1532 }
1533
1534 static void acpi_sbs_update_queue(void *data)
1535 {
1536         struct acpi_sbs *sbs = data;
1537         unsigned long delay = -1;
1538         int result;
1539
1540         if (sbs->zombie) {
1541                 goto end;
1542         }
1543
1544         result = acpi_sbs_update_run(sbs, DATA_TYPE_COMMON);
1545         if (result) {
1546                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1547                                   "acpi_sbs_update_run() failed\n"));
1548         }
1549
1550         if (sbs->zombie) {
1551                 goto end;
1552         }
1553
1554         if (update_mode == REQUEST_UPDATE_MODE) {
1555                 goto end;
1556         }
1557
1558         delay = jiffies + HZ * update_time;
1559         sbs->update_timer.data = (unsigned long)data;
1560         sbs->update_timer.function = acpi_sbs_update_queue_run;
1561         sbs->update_timer.expires = delay;
1562         add_timer(&sbs->update_timer);
1563       end:
1564         ;
1565 }
1566
1567 static int acpi_sbs_add(struct acpi_device *device)
1568 {
1569         struct acpi_sbs *sbs = NULL;
1570         struct acpi_ec_hc *ec_hc = NULL;
1571         int result, remove_result = 0;
1572         unsigned long sbs_obj;
1573         int id, cnt;
1574         acpi_status status = AE_OK;
1575
1576         sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
1577         if (!sbs) {
1578                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "kmalloc() failed\n"));
1579                 return -ENOMEM;
1580         }
1581
1582         cnt = 0;
1583         while (cnt < 10) {
1584                 cnt++;
1585                 ec_hc = acpi_get_ec_hc(device);
1586                 if (ec_hc) {
1587                         break;
1588                 }
1589                 msleep(1000);
1590         }
1591
1592         if (!ec_hc) {
1593                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1594                                   "acpi_get_ec_hc() failed: "
1595                                   "NO driver found for EC HC SMBus\n"));
1596                 result = -ENODEV;
1597                 goto end;
1598         }
1599
1600         sbs->device = device;
1601         sbs->smbus = ec_hc->smbus;
1602
1603         strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
1604         strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
1605         acpi_driver_data(device) = sbs;
1606
1607         sbs->update_time = 0;
1608         sbs->update_time2 = 0;
1609
1610         result = acpi_ac_add(sbs);
1611         if (result) {
1612                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_ac_add() failed\n"));
1613                 goto end;
1614         }
1615         result = acpi_evaluate_integer(device->handle, "_SBS", NULL, &sbs_obj);
1616         if (ACPI_FAILURE(result)) {
1617                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1618                                   "acpi_evaluate_integer() failed\n"));
1619                 result = -EIO;
1620                 goto end;
1621         }
1622
1623         if (sbs_obj > 0) {
1624                 result = acpi_sbsm_get_info(sbs);
1625                 if (result) {
1626                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1627                                           "acpi_sbsm_get_info() failed\n"));
1628                         goto end;
1629                 }
1630                 sbs->sbsm_present = 1;
1631         }
1632         if (sbs->sbsm_present == 0) {
1633                 result = acpi_battery_add(sbs, 0);
1634                 if (result) {
1635                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1636                                           "acpi_battery_add() failed\n"));
1637                         goto end;
1638                 }
1639         } else {
1640                 for (id = 0; id < MAX_SBS_BAT; id++) {
1641                         if ((sbs->sbsm_batteries_supported & (1 << id))) {
1642                                 result = acpi_battery_add(sbs, id);
1643                                 if (result) {
1644                                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1645                                                           "acpi_battery_add() "
1646                                                           "failed\n"));
1647                                         goto end;
1648                                 }
1649                         }
1650                 }
1651         }
1652
1653         sbs->handle = device->handle;
1654
1655         init_timer(&sbs->update_timer);
1656         if (update_mode == QUEUE_UPDATE_MODE) {
1657                 status = acpi_os_execute(OSL_GPE_HANDLER,
1658                                          acpi_sbs_update_queue, sbs);
1659                 if (status != AE_OK) {
1660                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1661                                           "acpi_os_execute() failed\n"));
1662                 }
1663         }
1664         sbs->update_time = update_time;
1665         sbs->update_time2 = update_time2;
1666
1667         printk(KERN_INFO PREFIX "%s [%s]\n",
1668                acpi_device_name(device), acpi_device_bid(device));
1669
1670       end:
1671         if (result) {
1672                 remove_result = acpi_sbs_remove(device, 0);
1673                 if (remove_result) {
1674                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1675                                           "acpi_sbs_remove() failed\n"));
1676                 }
1677         }
1678
1679         return result;
1680 }
1681
1682 int acpi_sbs_remove(struct acpi_device *device, int type)
1683 {
1684         struct acpi_sbs *sbs;
1685         int id;
1686
1687         if (!device) {
1688                 return -EINVAL;
1689         }
1690
1691         sbs = (struct acpi_sbs *)acpi_driver_data(device);
1692
1693         if (!sbs) {
1694                 return -EINVAL;
1695         }
1696
1697         sbs->zombie = 1;
1698         sbs->update_time = 0;
1699         sbs->update_time2 = 0;
1700         del_timer_sync(&sbs->update_timer);
1701         acpi_os_wait_events_complete(NULL);
1702         del_timer_sync(&sbs->update_timer);
1703
1704         for (id = 0; id < MAX_SBS_BAT; id++) {
1705                 acpi_battery_remove(sbs, id);
1706         }
1707
1708         acpi_ac_remove(sbs);
1709
1710         kfree(sbs);
1711
1712         return 0;
1713 }
1714
1715 static int __init acpi_sbs_init(void)
1716 {
1717         int result = 0;
1718
1719         if (acpi_disabled)
1720                 return -ENODEV;
1721
1722         init_MUTEX(&sbs_sem);
1723
1724         if (capacity_mode != DEF_CAPACITY_UNIT
1725             && capacity_mode != MAH_CAPACITY_UNIT
1726             && capacity_mode != MWH_CAPACITY_UNIT) {
1727                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_sbs_init: "
1728                                   "invalid capacity_mode = %d\n",
1729                                   capacity_mode));
1730                 return -EINVAL;
1731         }
1732
1733         acpi_ac_dir = acpi_lock_ac_dir();
1734         if (!acpi_ac_dir) {
1735                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1736                                   "acpi_lock_ac_dir() failed\n"));
1737                 return -ENODEV;
1738         }
1739
1740         acpi_battery_dir = acpi_lock_battery_dir();
1741         if (!acpi_battery_dir) {
1742                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1743                                   "acpi_lock_battery_dir() failed\n"));
1744                 return -ENODEV;
1745         }
1746
1747         result = acpi_bus_register_driver(&acpi_sbs_driver);
1748         if (result < 0) {
1749                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1750                                   "acpi_bus_register_driver() failed\n"));
1751                 return -ENODEV;
1752         }
1753
1754         return 0;
1755 }
1756
1757 static void __exit acpi_sbs_exit(void)
1758 {
1759
1760         acpi_bus_unregister_driver(&acpi_sbs_driver);
1761
1762         acpi_unlock_ac_dir(acpi_ac_dir);
1763         acpi_ac_dir = NULL;
1764         acpi_unlock_battery_dir(acpi_battery_dir);
1765         acpi_battery_dir = NULL;
1766
1767         return;
1768 }
1769
1770 module_init(acpi_sbs_init);
1771 module_exit(acpi_sbs_exit);