drivers/acpi/battery.c

   1 /*
   2  *  acpi_battery.c - ACPI Battery Driver ($Revision: 37 $)
   3  *
   4  *  Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
   5  *  Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
   6  *
   7  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 2 of the License, or (at
  12  *  your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful, but
  15  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  *  General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License along
  20  *  with this program; if not, write to the Free Software Foundation, Inc.,
  21  *  59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  22  *
  23  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  24  */
  25
  26 #include <linux/kernel.h>
  27 #include <linux/module.h>
  28 #include <linux/init.h>
  29 #include <linux/types.h>
  30 #include <linux/proc_fs.h>
  31 #include <linux/seq_file.h>
  32 #include <asm/uaccess.h>
  33
  34 #include <acpi/acpi_bus.h>
  35 #include <acpi/acpi_drivers.h>
  36
  37 #define ACPI_BATTERY_VALUE_UNKNOWN 0xFFFFFFFF
  38
  39 #define ACPI_BATTERY_FORMAT_BIF "NNNNNNNNNSSSS"
  40 #define ACPI_BATTERY_FORMAT_BST "NNNN"
  41
  42 #define ACPI_BATTERY_COMPONENT          0x00040000
  43 #define ACPI_BATTERY_CLASS              "battery"
  44 #define ACPI_BATTERY_HID                "PNP0C0A"
  45 #define ACPI_BATTERY_DRIVER_NAME        "ACPI Battery Driver"
  46 #define ACPI_BATTERY_DEVICE_NAME        "Battery"
  47 #define ACPI_BATTERY_FILE_INFO          "info"
  48 #define ACPI_BATTERY_FILE_STATUS        "state"
  49 #define ACPI_BATTERY_FILE_ALARM         "alarm"
  50 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
  51 #define ACPI_BATTERY_NOTIFY_INFO        0x81
  52 #define ACPI_BATTERY_UNITS_WATTS        "mW"
  53 #define ACPI_BATTERY_UNITS_AMPS         "mA"
  54
  55 #define _COMPONENT              ACPI_BATTERY_COMPONENT
  56 ACPI_MODULE_NAME("acpi_battery")
  57
  58     MODULE_AUTHOR("Paul Diefenbaugh");
  59 MODULE_DESCRIPTION(ACPI_BATTERY_DRIVER_NAME);
  60 MODULE_LICENSE("GPL");
  61
  62 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
  63 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
  64
  65 static int acpi_battery_add(struct acpi_device *device);
  66 static int acpi_battery_remove(struct acpi_device *device, int type);
  67
  68 static struct acpi_driver acpi_battery_driver = {
  69         .name = ACPI_BATTERY_DRIVER_NAME,
  70         .class = ACPI_BATTERY_CLASS,
  71         .ids = ACPI_BATTERY_HID,
  72         .ops = {
  73                 .add = acpi_battery_add,
  74                 .remove = acpi_battery_remove,
  75                 },
  76 };
  77
  78 struct acpi_battery_status {
  79         acpi_integer state;
  80         acpi_integer present_rate;
  81         acpi_integer remaining_capacity;
  82         acpi_integer present_voltage;
  83 };
  84
  85 struct acpi_battery_info {
  86         acpi_integer power_unit;
  87         acpi_integer design_capacity;
  88         acpi_integer last_full_capacity;
  89         acpi_integer battery_technology;
  90         acpi_integer design_voltage;
  91         acpi_integer design_capacity_warning;
  92         acpi_integer design_capacity_low;
  93         acpi_integer battery_capacity_granularity_1;
  94         acpi_integer battery_capacity_granularity_2;
  95         acpi_string model_number;
  96         acpi_string serial_number;
  97         acpi_string battery_type;
  98         acpi_string oem_info;
  99 };
 100
 101 struct acpi_battery_flags {
 102         u8 present:1;           /* Bay occupied? */
 103         u8 power_unit:1;        /* 0=watts, 1=apms */
 104         u8 alarm:1;             /* _BTP present? */
 105         u8 reserved:5;
 106 };
 107
 108 struct acpi_battery_trips {
 109         unsigned long warning;
 110         unsigned long low;
 111 };
 112
 113 struct acpi_battery {
 114         struct acpi_device * device;
 115         struct acpi_battery_flags flags;
 116         struct acpi_battery_trips trips;
 117         unsigned long alarm;
 118         struct acpi_battery_info *info;
 119 };
 120
 121 /* --------------------------------------------------------------------------
 122                                Battery Management
 123    -------------------------------------------------------------------------- */
 124
 125 static int
 126 acpi_battery_get_info(struct acpi_battery *battery,
 127                       struct acpi_battery_info **bif)
 128 {
 129         int result = 0;
 130         acpi_status status = 0;
 131         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 132         struct acpi_buffer format = { sizeof(ACPI_BATTERY_FORMAT_BIF),
 133                 ACPI_BATTERY_FORMAT_BIF
 134         };
 135         struct acpi_buffer data = { 0, NULL };
 136         union acpi_object *package = NULL;
 137
 138
 139         if (!battery || !bif)
 140                 return -EINVAL;
 141
 142         /* Evalute _BIF */
 143
 144         status = acpi_evaluate_object(battery->device->handle, "_BIF", NULL, &buffer);
 145         if (ACPI_FAILURE(status)) {
 146                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
 147                 return -ENODEV;
 148         }
 149
 150         package = (union acpi_object *)buffer.pointer;
 151
 152         /* Extract Package Data */
 153
 154         status = acpi_extract_package(package, &format, &data);
 155         if (status != AE_BUFFER_OVERFLOW) {
 156                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _BIF"));
 157                 result = -ENODEV;
 158                 goto end;
 159         }
 160
 161         data.pointer = kmalloc(data.length, GFP_KERNEL);
 162         if (!data.pointer) {
 163                 result = -ENOMEM;
 164                 goto end;
 165         }
 166         memset(data.pointer, 0, data.length);
 167
 168         status = acpi_extract_package(package, &format, &data);
 169         if (ACPI_FAILURE(status)) {
 170                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _BIF"));
 171                 kfree(data.pointer);
 172                 result = -ENODEV;
 173                 goto end;
 174         }
 175
 176       end:
 177         kfree(buffer.pointer);
 178
 179         if (!result)
 180                 (*bif) = (struct acpi_battery_info *)data.pointer;
 181
 182         return result;
 183 }
 184
 185 static int
 186 acpi_battery_get_status(struct acpi_battery *battery,
 187                         struct acpi_battery_status **bst)
 188 {
 189         int result = 0;
 190         acpi_status status = 0;
 191         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 192         struct acpi_buffer format = { sizeof(ACPI_BATTERY_FORMAT_BST),
 193                 ACPI_BATTERY_FORMAT_BST
 194         };
 195         struct acpi_buffer data = { 0, NULL };
 196         union acpi_object *package = NULL;
 197
 198
 199         if (!battery || !bst)
 200                 return -EINVAL;
 201
 202         /* Evalute _BST */
 203
 204         status = acpi_evaluate_object(battery->device->handle, "_BST", NULL, &buffer);
 205         if (ACPI_FAILURE(status)) {
 206                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 207                 return -ENODEV;
 208         }
 209
 210         package = (union acpi_object *)buffer.pointer;
 211
 212         /* Extract Package Data */
 213
 214         status = acpi_extract_package(package, &format, &data);
 215         if (status != AE_BUFFER_OVERFLOW) {
 216                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _BST"));
 217                 result = -ENODEV;
 218                 goto end;
 219         }
 220
 221         data.pointer = kmalloc(data.length, GFP_KERNEL);
 222         if (!data.pointer) {
 223                 result = -ENOMEM;
 224                 goto end;
 225         }
 226         memset(data.pointer, 0, data.length);
 227
 228         status = acpi_extract_package(package, &format, &data);
 229         if (ACPI_FAILURE(status)) {
 230                 ACPI_EXCEPTION((AE_INFO, status, "Extracting _BST"));
 231                 kfree(data.pointer);
 232                 result = -ENODEV;
 233                 goto end;
 234         }
 235
 236       end:
 237         kfree(buffer.pointer);
 238
 239         if (!result)
 240                 (*bst) = (struct acpi_battery_status *)data.pointer;
 241
 242         return result;
 243 }
 244
 245 static int
 246 acpi_battery_set_alarm(struct acpi_battery *battery, unsigned long alarm)
 247 {
 248         acpi_status status = 0;
 249         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
 250         struct acpi_object_list arg_list = { 1, &arg0 };
 251
 252
 253         if (!battery)
 254                 return -EINVAL;
 255
 256         if (!battery->flags.alarm)
 257                 return -ENODEV;
 258
 259         arg0.integer.value = alarm;
 260
 261         status = acpi_evaluate_object(battery->device->handle, "_BTP", &arg_list, NULL);
 262         if (ACPI_FAILURE(status))
 263                 return -ENODEV;
 264
 265         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", (u32) alarm));
 266
 267         battery->alarm = alarm;
 268
 269         return 0;
 270 }
 271
 272 static int acpi_battery_check(struct acpi_battery *battery)
 273 {
 274         int result = 0;
 275         acpi_status status = AE_OK;
 276         acpi_handle handle = NULL;
 277         struct acpi_device *device = NULL;
 278         struct acpi_battery_info *bif = NULL;
 279
 280
 281         if (!battery)
 282                 return -EINVAL;
 283
 284         device = battery->device;
 285
 286         result = acpi_bus_get_status(device);
 287         if (result)
 288                 return result;
 289
 290         /* Insertion? */
 291
 292         if (!battery->flags.present && device->status.battery_present) {
 293
 294                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Battery inserted\n"));
 295
 296                 /* Evalute _BIF to get certain static information */
 297
 298                 result = acpi_battery_get_info(battery, &bif);
 299                 if (result)
 300                         return result;
 301
 302                 battery->flags.power_unit = bif->power_unit;
 303                 battery->trips.warning = bif->design_capacity_warning;
 304                 battery->trips.low = bif->design_capacity_low;
 305                 kfree(bif);
 306
 307                 /* See if alarms are supported, and if so, set default */
 308
 309                 status = acpi_get_handle(battery->device->handle, "_BTP", &handle);
 310                 if (ACPI_SUCCESS(status)) {
 311                         battery->flags.alarm = 1;
 312                         acpi_battery_set_alarm(battery, battery->trips.warning);
 313                 }
 314         }
 315
 316         /* Removal? */
 317
 318         else if (battery->flags.present && !device->status.battery_present) {
 319                 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Battery removed\n"));
 320         }
 321
 322         battery->flags.present = device->status.battery_present;
 323
 324         return result;
 325 }
 326
 327 /* --------------------------------------------------------------------------
 328                               FS Interface (/proc)
 329    -------------------------------------------------------------------------- */
 330
 331 static struct proc_dir_entry *acpi_battery_dir;
 332 static int acpi_battery_read_info(struct seq_file *seq, void *offset)
 333 {
 334         int result = 0;
 335         struct acpi_battery *battery = (struct acpi_battery *)seq->private;
 336         struct acpi_battery_info *bif = NULL;
 337         char *units = "?";
 338
 339
 340         if (!battery)
 341                 goto end;
 342
 343         if (battery->flags.present)
 344                 seq_printf(seq, "present:                 yes\n");
 345         else {
 346                 seq_printf(seq, "present:                 no\n");
 347                 goto end;
 348         }
 349
 350         /* Battery Info (_BIF) */
 351
 352         result = acpi_battery_get_info(battery, &bif);
 353         if (result || !bif) {
 354                 seq_printf(seq, "ERROR: Unable to read battery information\n");
 355                 goto end;
 356         }
 357
 358         units =
 359             bif->
 360             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
 361
 362         if (bif->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 363                 seq_printf(seq, "design capacity:         unknown\n");
 364         else
 365                 seq_printf(seq, "design capacity:         %d %sh\n",
 366                            (u32) bif->design_capacity, units);
 367
 368         if (bif->last_full_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 369                 seq_printf(seq, "last full capacity:      unknown\n");
 370         else
 371                 seq_printf(seq, "last full capacity:      %d %sh\n",
 372                            (u32) bif->last_full_capacity, units);
 373
 374         switch ((u32) bif->battery_technology) {
 375         case 0:
 376                 seq_printf(seq, "battery technology:      non-rechargeable\n");
 377                 break;
 378         case 1:
 379                 seq_printf(seq, "battery technology:      rechargeable\n");
 380                 break;
 381         default:
 382                 seq_printf(seq, "battery technology:      unknown\n");
 383                 break;
 384         }
 385
 386         if (bif->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 387                 seq_printf(seq, "design voltage:          unknown\n");
 388         else
 389                 seq_printf(seq, "design voltage:          %d mV\n",
 390                            (u32) bif->design_voltage);
 391
 392         seq_printf(seq, "design capacity warning: %d %sh\n",
 393                    (u32) bif->design_capacity_warning, units);
 394         seq_printf(seq, "design capacity low:     %d %sh\n",
 395                    (u32) bif->design_capacity_low, units);
 396         seq_printf(seq, "capacity granularity 1:  %d %sh\n",
 397                    (u32) bif->battery_capacity_granularity_1, units);
 398         seq_printf(seq, "capacity granularity 2:  %d %sh\n",
 399                    (u32) bif->battery_capacity_granularity_2, units);
 400         seq_printf(seq, "model number:            %s\n", bif->model_number);
 401         seq_printf(seq, "serial number:           %s\n", bif->serial_number);
 402         seq_printf(seq, "battery type:            %s\n", bif->battery_type);
 403         seq_printf(seq, "OEM info:                %s\n", bif->oem_info);
 404
 405       end:
 406         kfree(bif);
 407
 408         return 0;
 409 }
 410
 411 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
 412 {
 413         return single_open(file, acpi_battery_read_info, PDE(inode)->data);
 414 }
 415
 416 static int acpi_battery_read_state(struct seq_file *seq, void *offset)
 417 {
 418         int result = 0;
 419         struct acpi_battery *battery = (struct acpi_battery *)seq->private;
 420         struct acpi_battery_status *bst = NULL;
 421         char *units = "?";
 422
 423
 424         if (!battery)
 425                 goto end;
 426
 427         if (battery->flags.present)
 428                 seq_printf(seq, "present:                 yes\n");
 429         else {
 430                 seq_printf(seq, "present:                 no\n");
 431                 goto end;
 432         }
 433
 434         /* Battery Units */
 435
 436         units =
 437             battery->flags.
 438             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
 439
 440         /* Battery Status (_BST) */
 441
 442         result = acpi_battery_get_status(battery, &bst);
 443         if (result || !bst) {
 444                 seq_printf(seq, "ERROR: Unable to read battery status\n");
 445                 goto end;
 446         }
 447
 448         if (!(bst->state & 0x04))
 449                 seq_printf(seq, "capacity state:          ok\n");
 450         else
 451                 seq_printf(seq, "capacity state:          critical\n");
 452
 453         if ((bst->state & 0x01) && (bst->state & 0x02)) {
 454                 seq_printf(seq,
 455                            "charging state:          charging/discharging\n");
 456         } else if (bst->state & 0x01)
 457                 seq_printf(seq, "charging state:          discharging\n");
 458         else if (bst->state & 0x02)
 459                 seq_printf(seq, "charging state:          charging\n");
 460         else {
 461                 seq_printf(seq, "charging state:          charged\n");
 462         }
 463
 464         if (bst->present_rate == ACPI_BATTERY_VALUE_UNKNOWN)
 465                 seq_printf(seq, "present rate:            unknown\n");
 466         else
 467                 seq_printf(seq, "present rate:            %d %s\n",
 468                            (u32) bst->present_rate, units);
 469
 470         if (bst->remaining_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 471                 seq_printf(seq, "remaining capacity:      unknown\n");
 472         else
 473                 seq_printf(seq, "remaining capacity:      %d %sh\n",
 474                            (u32) bst->remaining_capacity, units);
 475
 476         if (bst->present_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 477                 seq_printf(seq, "present voltage:         unknown\n");
 478         else
 479                 seq_printf(seq, "present voltage:         %d mV\n",
 480                            (u32) bst->present_voltage);
 481
 482       end:
 483         kfree(bst);
 484
 485         return 0;
 486 }
 487
 488 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
 489 {
 490         return single_open(file, acpi_battery_read_state, PDE(inode)->data);
 491 }
 492
 493 static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
 494 {
 495         struct acpi_battery *battery = (struct acpi_battery *)seq->private;
 496         char *units = "?";
 497
 498
 499         if (!battery)
 500                 goto end;
 501
 502         if (!battery->flags.present) {
 503                 seq_printf(seq, "present:                 no\n");
 504                 goto end;
 505         }
 506
 507         /* Battery Units */
 508
 509         units =
 510             battery->flags.
 511             power_unit ? ACPI_BATTERY_UNITS_AMPS : ACPI_BATTERY_UNITS_WATTS;
 512
 513         /* Battery Alarm */
 514
 515         seq_printf(seq, "alarm:                   ");
 516         if (!battery->alarm)
 517                 seq_printf(seq, "unsupported\n");
 518         else
 519                 seq_printf(seq, "%d %sh\n", (u32) battery->alarm, units);
 520
 521       end:
 522         return 0;
 523 }
 524
 525 static ssize_t
 526 acpi_battery_write_alarm(struct file *file,
 527                          const char __user * buffer,
 528                          size_t count, loff_t * ppos)
 529 {
 530         int result = 0;
 531         char alarm_string[12] = { '\0' };
 532         struct seq_file *m = (struct seq_file *)file->private_data;
 533         struct acpi_battery *battery = (struct acpi_battery *)m->private;
 534
 535
 536         if (!battery || (count > sizeof(alarm_string) - 1))
 537                 return -EINVAL;
 538
 539         if (!battery->flags.present)
 540                 return -ENODEV;
 541
 542         if (copy_from_user(alarm_string, buffer, count))
 543                 return -EFAULT;
 544
 545         alarm_string[count] = '\0';
 546
 547         result = acpi_battery_set_alarm(battery,
 548                                         simple_strtoul(alarm_string, NULL, 0));
 549         if (result)
 550                 return result;
 551
 552         return count;
 553 }
 554
 555 static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
 556 {
 557         return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
 558 }
 559
 560 static const struct file_operations acpi_battery_info_ops = {
 561         .open = acpi_battery_info_open_fs,
 562         .read = seq_read,
 563         .llseek = seq_lseek,
 564         .release = single_release,
 565         .owner = THIS_MODULE,
 566 };
 567
 568 static const struct file_operations acpi_battery_state_ops = {
 569         .open = acpi_battery_state_open_fs,
 570         .read = seq_read,
 571         .llseek = seq_lseek,
 572         .release = single_release,
 573         .owner = THIS_MODULE,
 574 };
 575
 576 static const struct file_operations acpi_battery_alarm_ops = {
 577         .open = acpi_battery_alarm_open_fs,
 578         .read = seq_read,
 579         .write = acpi_battery_write_alarm,
 580         .llseek = seq_lseek,
 581         .release = single_release,
 582         .owner = THIS_MODULE,
 583 };
 584
 585 static int acpi_battery_add_fs(struct acpi_device *device)
 586 {
 587         struct proc_dir_entry *entry = NULL;
 588
 589
 590         if (!acpi_device_dir(device)) {
 591                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 592                                                      acpi_battery_dir);
 593                 if (!acpi_device_dir(device))
 594                         return -ENODEV;
 595                 acpi_device_dir(device)->owner = THIS_MODULE;
 596         }
 597
 598         /* 'info' [R] */
 599         entry = create_proc_entry(ACPI_BATTERY_FILE_INFO,
 600                                   S_IRUGO, acpi_device_dir(device));
 601         if (!entry)
 602                 return -ENODEV;
 603         else {
 604                 entry->proc_fops = &acpi_battery_info_ops;
 605                 entry->data = acpi_driver_data(device);
 606                 entry->owner = THIS_MODULE;
 607         }
 608
 609         /* 'status' [R] */
 610         entry = create_proc_entry(ACPI_BATTERY_FILE_STATUS,
 611                                   S_IRUGO, acpi_device_dir(device));
 612         if (!entry)
 613                 return -ENODEV;
 614         else {
 615                 entry->proc_fops = &acpi_battery_state_ops;
 616                 entry->data = acpi_driver_data(device);
 617                 entry->owner = THIS_MODULE;
 618         }
 619
 620         /* 'alarm' [R/W] */
 621         entry = create_proc_entry(ACPI_BATTERY_FILE_ALARM,
 622                                   S_IFREG | S_IRUGO | S_IWUSR,
 623                                   acpi_device_dir(device));
 624         if (!entry)
 625                 return -ENODEV;
 626         else {
 627                 entry->proc_fops = &acpi_battery_alarm_ops;
 628                 entry->data = acpi_driver_data(device);
 629                 entry->owner = THIS_MODULE;
 630         }
 631
 632         return 0;
 633 }
 634
 635 static int acpi_battery_remove_fs(struct acpi_device *device)
 636 {
 637
 638         if (acpi_device_dir(device)) {
 639                 remove_proc_entry(ACPI_BATTERY_FILE_ALARM,
 640                                   acpi_device_dir(device));
 641                 remove_proc_entry(ACPI_BATTERY_FILE_STATUS,
 642                                   acpi_device_dir(device));
 643                 remove_proc_entry(ACPI_BATTERY_FILE_INFO,
 644                                   acpi_device_dir(device));
 645
 646                 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
 647                 acpi_device_dir(device) = NULL;
 648         }
 649
 650         return 0;
 651 }
 652
 653 /* --------------------------------------------------------------------------
 654                                  Driver Interface
 655    -------------------------------------------------------------------------- */
 656
 657 static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
 658 {
 659         struct acpi_battery *battery = (struct acpi_battery *)data;
 660         struct acpi_device *device = NULL;
 661
 662
 663         if (!battery)
 664                 return;
 665
 666         device = battery->device;
 667
 668         switch (event) {
 669         case ACPI_BATTERY_NOTIFY_STATUS:
 670         case ACPI_BATTERY_NOTIFY_INFO:
 671         case ACPI_NOTIFY_BUS_CHECK:
 672         case ACPI_NOTIFY_DEVICE_CHECK:
 673                 acpi_battery_check(battery);
 674                 acpi_bus_generate_event(device, event, battery->flags.present);
 675                 break;
 676         default:
 677                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 678                                   "Unsupported event [0x%x]\n", event));
 679                 break;
 680         }
 681
 682         return;
 683 }
 684
 685 static int acpi_battery_add(struct acpi_device *device)
 686 {
 687         int result = 0;
 688         acpi_status status = 0;
 689         struct acpi_battery *battery = NULL;
 690
 691
 692         if (!device)
 693                 return -EINVAL;
 694
 695         battery = kmalloc(sizeof(struct acpi_battery), GFP_KERNEL);
 696         if (!battery)
 697                 return -ENOMEM;
 698         memset(battery, 0, sizeof(struct acpi_battery));
 699
 700         battery->device = device;
 701         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
 702         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
 703         acpi_driver_data(device) = battery;
 704
 705         result = acpi_battery_check(battery);
 706         if (result)
 707                 goto end;
 708
 709         result = acpi_battery_add_fs(device);
 710         if (result)
 711                 goto end;
 712
 713         status = acpi_install_notify_handler(device->handle,
 714                                              ACPI_ALL_NOTIFY,
 715                                              acpi_battery_notify, battery);
 716         if (ACPI_FAILURE(status)) {
 717                 result = -ENODEV;
 718                 goto end;
 719         }
 720
 721         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
 722                ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
 723                device->status.battery_present ? "present" : "absent");
 724
 725       end:
 726         if (result) {
 727                 acpi_battery_remove_fs(device);
 728                 kfree(battery);
 729         }
 730
 731         return result;
 732 }
 733
 734 static int acpi_battery_remove(struct acpi_device *device, int type)
 735 {
 736         acpi_status status = 0;
 737         struct acpi_battery *battery = NULL;
 738
 739
 740         if (!device || !acpi_driver_data(device))
 741                 return -EINVAL;
 742
 743         battery = (struct acpi_battery *)acpi_driver_data(device);
 744
 745         status = acpi_remove_notify_handler(device->handle,
 746                                             ACPI_ALL_NOTIFY,
 747                                             acpi_battery_notify);
 748
 749         acpi_battery_remove_fs(device);
 750
 751         kfree(battery);
 752
 753         return 0;
 754 }
 755
 756 static int __init acpi_battery_init(void)
 757 {
 758         int result;
 759
 760         acpi_battery_dir = acpi_lock_battery_dir();
 761         if (!acpi_battery_dir)
 762                 return -ENODEV;
 763
 764         result = acpi_bus_register_driver(&acpi_battery_driver);
 765         if (result < 0) {
 766                 acpi_unlock_battery_dir(acpi_battery_dir);
 767                 return -ENODEV;
 768         }
 769
 770         return 0;
 771 }
 772
 773 static void __exit acpi_battery_exit(void)
 774 {
 775
 776         acpi_bus_unregister_driver(&acpi_battery_driver);
 777
 778         acpi_unlock_battery_dir(acpi_battery_dir);
 779
 780         return;
 781 }
 782
 783 module_init(acpi_battery_init);
 784 module_exit(acpi_battery_exit);