SAFE public projects git trees. - safe/jmp/linux-2.6/blob - drivers/acpi/sbs.c

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