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