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         if (battery->state.amperage < 0) {
1037                 seq_printf(seq, "charging state:          discharging\n");
1038                 foo = battery->state.remaining_capacity * cscale * 60 /
1039                     (battery->state.average_time_to_empty == 0 ? 1 :
1040                      battery->state.average_time_to_empty);
1041                 seq_printf(seq, "present rate:            %i%s\n",
1042                            foo, battery->info.capacity_mode ? "0 mW" : " mA");
1043         } else if (battery->state.amperage > 0) {
1044                 seq_printf(seq, "charging state:          charging\n");
1045                 foo = (battery->info.full_charge_capacity -
1046                        battery->state.remaining_capacity) * cscale * 60 /
1047                     (battery->state.average_time_to_full == 0 ? 1 :
1048                      battery->state.average_time_to_full);
1049                 seq_printf(seq, "present rate:            %i%s\n",
1050                            foo, battery->info.capacity_mode ? "0 mW" : " mA");
1051         } else {
1052                 seq_printf(seq, "charging state:          charged\n");
1053                 seq_printf(seq, "present rate:            0 %s\n",
1054                            battery->info.capacity_mode ? "mW" : "mA");
1055         }
1056
1057         seq_printf(seq, "remaining capacity:      %i%s",
1058                    battery->state.remaining_capacity * cscale,
1059                    battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
1060
1061         seq_printf(seq, "present voltage:         %i mV\n",
1062                    battery->state.voltage * battery->info.vscale);
1063
1064       end:
1065
1066         up(&sbs_sem);
1067
1068         return result;
1069 }
1070
1071 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
1072 {
1073         return single_open(file, acpi_battery_read_state, PDE(inode)->data);
1074 }
1075
1076 static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
1077 {
1078         struct acpi_battery *battery = seq->private;
1079         int result = 0;
1080         int cscale;
1081
1082         if (battery->sbs->zombie) {
1083                 return -ENODEV;
1084         }
1085
1086         down(&sbs_sem);
1087
1088         if (update_mode == REQUEST_UPDATE_MODE) {
1089                 result = acpi_sbs_update_run(battery->sbs, DATA_TYPE_ALARM);
1090                 if (result) {
1091                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1092                                           "acpi_sbs_update_run() failed\n"));
1093                 }
1094         }
1095
1096         if (!acpi_battery_is_present(battery)) {
1097                 seq_printf(seq, "present:                 no\n");
1098                 goto end;
1099         }
1100
1101         if (battery->info.capacity_mode) {
1102                 cscale = battery->info.vscale * battery->info.ipscale;
1103         } else {
1104                 cscale = battery->info.ipscale;
1105         }
1106
1107         seq_printf(seq, "alarm:                   ");
1108         if (battery->alarm.remaining_capacity) {
1109                 seq_printf(seq, "%i%s",
1110                            battery->alarm.remaining_capacity * cscale,
1111                            battery->info.capacity_mode ? "0 mWh\n" : " mAh\n");
1112         } else {
1113                 seq_printf(seq, "disabled\n");
1114         }
1115
1116       end:
1117
1118         up(&sbs_sem);
1119
1120         return result;
1121 }
1122
1123 static ssize_t
1124 acpi_battery_write_alarm(struct file *file, const char __user * buffer,
1125                          size_t count, loff_t * ppos)
1126 {
1127         struct seq_file *seq = file->private_data;
1128         struct acpi_battery *battery = seq->private;
1129         char alarm_string[12] = { '\0' };
1130         int result, old_alarm, new_alarm;
1131
1132         if (battery->sbs->zombie) {
1133                 return -ENODEV;
1134         }
1135
1136         down(&sbs_sem);
1137
1138         if (!acpi_battery_is_present(battery)) {
1139                 result = -ENODEV;
1140                 goto end;
1141         }
1142
1143         if (count > sizeof(alarm_string) - 1) {
1144                 result = -EINVAL;
1145                 goto end;
1146         }
1147
1148         if (copy_from_user(alarm_string, buffer, count)) {
1149                 result = -EFAULT;
1150                 goto end;
1151         }
1152
1153         alarm_string[count] = 0;
1154
1155         old_alarm = battery->alarm.remaining_capacity;
1156         new_alarm = simple_strtoul(alarm_string, NULL, 0);
1157
1158         result = acpi_battery_set_alarm(battery, new_alarm);
1159         if (result) {
1160                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1161                                   "acpi_battery_set_alarm() failed\n"));
1162                 acpi_battery_set_alarm(battery, old_alarm);
1163                 goto end;
1164         }
1165         result = acpi_battery_get_alarm(battery);
1166         if (result) {
1167                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1168                                   "acpi_battery_get_alarm() failed\n"));
1169                 acpi_battery_set_alarm(battery, old_alarm);
1170                 goto end;
1171         }
1172
1173       end:
1174         up(&sbs_sem);
1175
1176         if (result) {
1177                 return result;
1178         } else {
1179                 return count;
1180         }
1181 }
1182
1183 static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
1184 {
1185         return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
1186 }
1187
1188 static struct file_operations acpi_battery_info_fops = {
1189         .open = acpi_battery_info_open_fs,
1190         .read = seq_read,
1191         .llseek = seq_lseek,
1192         .release = single_release,
1193         .owner = THIS_MODULE,
1194 };
1195
1196 static struct file_operations acpi_battery_state_fops = {
1197         .open = acpi_battery_state_open_fs,
1198         .read = seq_read,
1199         .llseek = seq_lseek,
1200         .release = single_release,
1201         .owner = THIS_MODULE,
1202 };
1203
1204 static struct file_operations acpi_battery_alarm_fops = {
1205         .open = acpi_battery_alarm_open_fs,
1206         .read = seq_read,
1207         .write = acpi_battery_write_alarm,
1208         .llseek = seq_lseek,
1209         .release = single_release,
1210         .owner = THIS_MODULE,
1211 };
1212
1213 /* Legacy AC Adapter Interface */
1214
1215 static struct proc_dir_entry *acpi_ac_dir = NULL;
1216
1217 static int acpi_ac_read_state(struct seq_file *seq, void *offset)
1218 {
1219         struct acpi_sbs *sbs = seq->private;
1220         int result;
1221
1222         if (sbs->zombie) {
1223                 return -ENODEV;
1224         }
1225
1226         down(&sbs_sem);
1227
1228         if (update_mode == REQUEST_UPDATE_MODE) {
1229                 result = acpi_sbs_update_run(sbs, DATA_TYPE_AC_STATE);
1230                 if (result) {
1231                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1232                                           "acpi_sbs_update_run() failed\n"));
1233                 }
1234         }
1235
1236         seq_printf(seq, "state:                   %s\n",
1237                    sbs->ac_present ? "on-line" : "off-line");
1238
1239         up(&sbs_sem);
1240
1241         return 0;
1242 }
1243
1244 static int acpi_ac_state_open_fs(struct inode *inode, struct file *file)
1245 {
1246         return single_open(file, acpi_ac_read_state, PDE(inode)->data);
1247 }
1248
1249 static struct file_operations acpi_ac_state_fops = {
1250         .open = acpi_ac_state_open_fs,
1251         .read = seq_read,
1252         .llseek = seq_lseek,
1253         .release = single_release,
1254         .owner = THIS_MODULE,
1255 };
1256
1257 /* --------------------------------------------------------------------------
1258                                  Driver Interface
1259    -------------------------------------------------------------------------- */
1260
1261 /* Smart Battery */
1262
1263 static int acpi_battery_add(struct acpi_sbs *sbs, int id)
1264 {
1265         int is_present;
1266         int result;
1267         char dir_name[32];
1268         struct acpi_battery *battery;
1269
1270         battery = &sbs->battery[id];
1271
1272         battery->alive = 0;
1273
1274         battery->init_state = 0;
1275         battery->id = id;
1276         battery->sbs = sbs;
1277
1278         result = acpi_battery_select(battery);
1279         if (result) {
1280                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1281                                   "acpi_battery_select() failed\n"));
1282                 goto end;
1283         }
1284
1285         result = acpi_battery_get_present(battery);
1286         if (result) {
1287                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1288                                   "acpi_battery_get_present() failed\n"));
1289                 goto end;
1290         }
1291
1292         is_present = acpi_battery_is_present(battery);
1293
1294         if (is_present) {
1295                 result = acpi_battery_init(battery);
1296                 if (result) {
1297                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1298                                           "acpi_battery_init() failed\n"));
1299                         goto end;
1300                 }
1301                 battery->init_state = 1;
1302         }
1303
1304         sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
1305
1306         result = acpi_sbs_generic_add_fs(&battery->battery_entry,
1307                                          acpi_battery_dir,
1308                                          dir_name,
1309                                          &acpi_battery_info_fops,
1310                                          &acpi_battery_state_fops,
1311                                          &acpi_battery_alarm_fops, battery);
1312         if (result) {
1313                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1314                                   "acpi_sbs_generic_add_fs() failed\n"));
1315                 goto end;
1316         }
1317         battery->alive = 1;
1318
1319       end:
1320         return result;
1321 }
1322
1323 static void acpi_battery_remove(struct acpi_sbs *sbs, int id)
1324 {
1325
1326         if (sbs->battery[id].battery_entry) {
1327                 acpi_sbs_generic_remove_fs(&(sbs->battery[id].battery_entry),
1328                                            acpi_battery_dir);
1329         }
1330 }
1331
1332 static int acpi_ac_add(struct acpi_sbs *sbs)
1333 {
1334         int result;
1335
1336         result = acpi_ac_get_present(sbs);
1337         if (result) {
1338                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1339                                   "acpi_ac_get_present() failed\n"));
1340                 goto end;
1341         }
1342
1343         result = acpi_sbs_generic_add_fs(&sbs->ac_entry,
1344                                          acpi_ac_dir,
1345                                          ACPI_AC_DIR_NAME,
1346                                          NULL, &acpi_ac_state_fops, NULL, sbs);
1347         if (result) {
1348                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1349                                   "acpi_sbs_generic_add_fs() failed\n"));
1350                 goto end;
1351         }
1352
1353       end:
1354
1355         return result;
1356 }
1357
1358 static void acpi_ac_remove(struct acpi_sbs *sbs)
1359 {
1360
1361         if (sbs->ac_entry) {
1362                 acpi_sbs_generic_remove_fs(&sbs->ac_entry, acpi_ac_dir);
1363         }
1364 }
1365
1366 static void acpi_sbs_update_queue_run(unsigned long data)
1367 {
1368         acpi_os_execute(OSL_GPE_HANDLER, acpi_sbs_update_queue, (void *)data);
1369 }
1370
1371 static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type)
1372 {
1373         struct acpi_battery *battery;
1374         int result = 0;
1375         int old_ac_present;
1376         int old_battery_present;
1377         int new_ac_present;
1378         int new_battery_present;
1379         int id;
1380         char dir_name[32];
1381         int do_battery_init, do_ac_init;
1382         s16 old_remaining_capacity;
1383
1384         if (sbs->zombie) {
1385                 goto end;
1386         }
1387
1388         old_ac_present = acpi_ac_is_present(sbs);
1389
1390         result = acpi_ac_get_present(sbs);
1391         if (result) {
1392                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1393                                   "acpi_ac_get_present() failed\n"));
1394         }
1395
1396         new_ac_present = acpi_ac_is_present(sbs);
1397
1398         do_ac_init = (old_ac_present != new_ac_present);
1399
1400         if (data_type == DATA_TYPE_AC_STATE) {
1401                 goto end;
1402         }
1403
1404         for (id = 0; id < MAX_SBS_BAT; id++) {
1405                 battery = &sbs->battery[id];
1406                 if (battery->alive == 0) {
1407                         continue;
1408                 }
1409
1410                 old_remaining_capacity = battery->state.remaining_capacity;
1411
1412                 old_battery_present = acpi_battery_is_present(battery);
1413
1414                 result = acpi_battery_select(battery);
1415                 if (result) {
1416                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1417                                           "acpi_battery_select() failed\n"));
1418                 }
1419                 if (sbs->zombie) {
1420                         goto end;
1421                 }
1422
1423                 result = acpi_battery_get_present(battery);
1424                 if (result) {
1425                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1426                                           "acpi_battery_get_present() failed\n"));
1427                 }
1428                 if (sbs->zombie) {
1429                         goto end;
1430                 }
1431
1432                 new_battery_present = acpi_battery_is_present(battery);
1433
1434                 do_battery_init = ((old_battery_present != new_battery_present)
1435                                    && new_battery_present);
1436
1437                 if (sbs->zombie) {
1438                         goto end;
1439                 }
1440                 if (do_ac_init || do_battery_init ||
1441                     update_info_mode || sbs->update_info_mode) {
1442                         if (sbs->update_info_mode) {
1443                                 sbs->update_info_mode = 0;
1444                         } else {
1445                                 sbs->update_info_mode = 1;
1446                         }
1447                         result = acpi_battery_init(battery);
1448                         if (result) {
1449                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1450                                                   "acpi_battery_init() "
1451                                                   "failed\n"));
1452                         }
1453                 }
1454                 if (data_type == DATA_TYPE_INFO) {
1455                         continue;
1456                 }
1457
1458                 if (sbs->zombie) {
1459                         goto end;
1460                 }
1461                 if (new_battery_present) {
1462                         result = acpi_battery_get_alarm(battery);
1463                         if (result) {
1464                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1465                                                   "acpi_battery_get_alarm() "
1466                                                   "failed\n"));
1467                         }
1468                         if (data_type == DATA_TYPE_ALARM) {
1469                                 continue;
1470                         }
1471
1472                         result = acpi_battery_get_state(battery);
1473                         if (result) {
1474                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1475                                                   "acpi_battery_get_state() "
1476                                                   "failed\n"));
1477                         }
1478                 }
1479                 if (sbs->zombie) {
1480                         goto end;
1481                 }
1482                 if (data_type != DATA_TYPE_COMMON) {
1483                         continue;
1484                 }
1485
1486                 if (old_battery_present != new_battery_present) {
1487                         sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
1488                         result = acpi_sbs_generate_event(sbs->device,
1489                                                          ACPI_SBS_BATTERY_NOTIFY_STATUS,
1490                                                          new_battery_present,
1491                                                          dir_name,
1492                                                          ACPI_BATTERY_CLASS);
1493                         if (result) {
1494                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1495                                                   "acpi_sbs_generate_event() "
1496                                                   "failed\n"));
1497                         }
1498                 }
1499                 if (old_remaining_capacity != battery->state.remaining_capacity) {
1500                         sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id);
1501                         result = acpi_sbs_generate_event(sbs->device,
1502                                                          ACPI_SBS_BATTERY_NOTIFY_STATUS,
1503                                                          new_battery_present,
1504                                                          dir_name,
1505                                                          ACPI_BATTERY_CLASS);
1506                         if (result) {
1507                                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1508                                                   "acpi_sbs_generate_event() failed\n"));
1509                         }
1510                 }
1511
1512         }
1513         if (sbs->zombie) {
1514                 goto end;
1515         }
1516         if (data_type != DATA_TYPE_COMMON) {
1517                 goto end;
1518         }
1519
1520         if (old_ac_present != new_ac_present) {
1521                 result = acpi_sbs_generate_event(sbs->device,
1522                                                  ACPI_SBS_AC_NOTIFY_STATUS,
1523                                                  new_ac_present,
1524                                                  ACPI_AC_DIR_NAME,
1525                                                  ACPI_AC_CLASS);
1526                 if (result) {
1527                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1528                                           "acpi_sbs_generate_event() failed\n"));
1529                 }
1530         }
1531
1532       end:
1533         return result;
1534 }
1535
1536 static void acpi_sbs_update_queue(void *data)
1537 {
1538         struct acpi_sbs *sbs = data;
1539         unsigned long delay = -1;
1540         int result;
1541
1542         if (sbs->zombie) {
1543                 goto end;
1544         }
1545
1546         result = acpi_sbs_update_run(sbs, DATA_TYPE_COMMON);
1547         if (result) {
1548                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1549                                   "acpi_sbs_update_run() failed\n"));
1550         }
1551
1552         if (sbs->zombie) {
1553                 goto end;
1554         }
1555
1556         if (update_mode == REQUEST_UPDATE_MODE) {
1557                 goto end;
1558         }
1559
1560         delay = jiffies + HZ * update_time;
1561         sbs->update_timer.data = (unsigned long)data;
1562         sbs->update_timer.function = acpi_sbs_update_queue_run;
1563         sbs->update_timer.expires = delay;
1564         add_timer(&sbs->update_timer);
1565       end:
1566         ;
1567 }
1568
1569 static int acpi_sbs_add(struct acpi_device *device)
1570 {
1571         struct acpi_sbs *sbs = NULL;
1572         struct acpi_ec_hc *ec_hc = NULL;
1573         int result, remove_result = 0;
1574         unsigned long sbs_obj;
1575         int id, cnt;
1576         acpi_status status = AE_OK;
1577
1578         sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL);
1579         if (!sbs) {
1580                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "kmalloc() failed\n"));
1581                 return -ENOMEM;
1582         }
1583
1584         cnt = 0;
1585         while (cnt < 10) {
1586                 cnt++;
1587                 ec_hc = acpi_get_ec_hc(device);
1588                 if (ec_hc) {
1589                         break;
1590                 }
1591                 msleep(1000);
1592         }
1593
1594         if (!ec_hc) {
1595                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1596                                   "acpi_get_ec_hc() failed: "
1597                                   "NO driver found for EC HC SMBus\n"));
1598                 result = -ENODEV;
1599                 goto end;
1600         }
1601
1602         sbs->device = device;
1603         sbs->smbus = ec_hc->smbus;
1604
1605         strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME);
1606         strcpy(acpi_device_class(device), ACPI_SBS_CLASS);
1607         acpi_driver_data(device) = sbs;
1608
1609         sbs->update_time = 0;
1610         sbs->update_time2 = 0;
1611
1612         result = acpi_ac_add(sbs);
1613         if (result) {
1614                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_ac_add() failed\n"));
1615                 goto end;
1616         }
1617         result = acpi_evaluate_integer(device->handle, "_SBS", NULL, &sbs_obj);
1618         if (ACPI_FAILURE(result)) {
1619                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1620                                   "acpi_evaluate_integer() failed\n"));
1621                 result = -EIO;
1622                 goto end;
1623         }
1624
1625         if (sbs_obj > 0) {
1626                 result = acpi_sbsm_get_info(sbs);
1627                 if (result) {
1628                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1629                                           "acpi_sbsm_get_info() failed\n"));
1630                         goto end;
1631                 }
1632                 sbs->sbsm_present = 1;
1633         }
1634         if (sbs->sbsm_present == 0) {
1635                 result = acpi_battery_add(sbs, 0);
1636                 if (result) {
1637                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1638                                           "acpi_battery_add() failed\n"));
1639                         goto end;
1640                 }
1641         } else {
1642                 for (id = 0; id < MAX_SBS_BAT; id++) {
1643                         if ((sbs->sbsm_batteries_supported & (1 << id))) {
1644                                 result = acpi_battery_add(sbs, id);
1645                                 if (result) {
1646                                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1647                                                           "acpi_battery_add() "
1648                                                           "failed\n"));
1649                                         goto end;
1650                                 }
1651                         }
1652                 }
1653         }
1654
1655         sbs->handle = device->handle;
1656
1657         init_timer(&sbs->update_timer);
1658         if (update_mode == QUEUE_UPDATE_MODE) {
1659                 status = acpi_os_execute(OSL_GPE_HANDLER,
1660                                          acpi_sbs_update_queue, sbs);
1661                 if (status != AE_OK) {
1662                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1663                                           "acpi_os_execute() failed\n"));
1664                 }
1665         }
1666         sbs->update_time = update_time;
1667         sbs->update_time2 = update_time2;
1668
1669         printk(KERN_INFO PREFIX "%s [%s]\n",
1670                acpi_device_name(device), acpi_device_bid(device));
1671
1672       end:
1673         if (result) {
1674                 remove_result = acpi_sbs_remove(device, 0);
1675                 if (remove_result) {
1676                         ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1677                                           "acpi_sbs_remove() failed\n"));
1678                 }
1679         }
1680
1681         return result;
1682 }
1683
1684 int acpi_sbs_remove(struct acpi_device *device, int type)
1685 {
1686         struct acpi_sbs *sbs;
1687         int id;
1688
1689         if (!device) {
1690                 return -EINVAL;
1691         }
1692
1693         sbs = (struct acpi_sbs *)acpi_driver_data(device);
1694
1695         if (!sbs) {
1696                 return -EINVAL;
1697         }
1698
1699         sbs->zombie = 1;
1700         sbs->update_time = 0;
1701         sbs->update_time2 = 0;
1702         del_timer_sync(&sbs->update_timer);
1703         acpi_os_wait_events_complete(NULL);
1704         del_timer_sync(&sbs->update_timer);
1705
1706         for (id = 0; id < MAX_SBS_BAT; id++) {
1707                 acpi_battery_remove(sbs, id);
1708         }
1709
1710         acpi_ac_remove(sbs);
1711
1712         kfree(sbs);
1713
1714         return 0;
1715 }
1716
1717 static int __init acpi_sbs_init(void)
1718 {
1719         int result = 0;
1720
1721         if (acpi_disabled)
1722                 return -ENODEV;
1723
1724         init_MUTEX(&sbs_sem);
1725
1726         if (capacity_mode != DEF_CAPACITY_UNIT
1727             && capacity_mode != MAH_CAPACITY_UNIT
1728             && capacity_mode != MWH_CAPACITY_UNIT) {
1729                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR, "acpi_sbs_init: "
1730                                   "invalid capacity_mode = %d\n",
1731                                   capacity_mode));
1732                 return -EINVAL;
1733         }
1734
1735         acpi_ac_dir = acpi_lock_ac_dir();
1736         if (!acpi_ac_dir) {
1737                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1738                                   "acpi_lock_ac_dir() failed\n"));
1739                 return -ENODEV;
1740         }
1741
1742         acpi_battery_dir = acpi_lock_battery_dir();
1743         if (!acpi_battery_dir) {
1744                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1745                                   "acpi_lock_battery_dir() failed\n"));
1746                 return -ENODEV;
1747         }
1748
1749         result = acpi_bus_register_driver(&acpi_sbs_driver);
1750         if (result < 0) {
1751                 ACPI_DEBUG_PRINT((ACPI_DB_ERROR,
1752                                   "acpi_bus_register_driver() failed\n"));
1753                 return -ENODEV;
1754         }
1755
1756         return 0;
1757 }
1758
1759 static void __exit acpi_sbs_exit(void)
1760 {
1761
1762         acpi_bus_unregister_driver(&acpi_sbs_driver);
1763
1764         acpi_unlock_ac_dir(acpi_ac_dir);
1765         acpi_ac_dir = NULL;
1766         acpi_unlock_battery_dir(acpi_battery_dir);
1767         acpi_battery_dir = NULL;
1768
1769         return;
1770 }
1771
1772 module_init(acpi_sbs_init);
1773 module_exit(acpi_sbs_exit);