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_DEVICE_NAME        "Battery"
  45 #define ACPI_BATTERY_NOTIFY_STATUS      0x80
  46 #define ACPI_BATTERY_NOTIFY_INFO        0x81
  47 #define ACPI_BATTERY_UNITS_WATTS        "mW"
  48 #define ACPI_BATTERY_UNITS_AMPS         "mA"
  49
  50 #define _COMPONENT              ACPI_BATTERY_COMPONENT
  51
  52 #define ACPI_BATTERY_UPDATE_TIME        0
  53
  54 #define ACPI_BATTERY_NONE_UPDATE        0
  55 #define ACPI_BATTERY_EASY_UPDATE        1
  56 #define ACPI_BATTERY_INIT_UPDATE        2
  57
  58 ACPI_MODULE_NAME("battery");
  59
  60 MODULE_AUTHOR("Paul Diefenbaugh");
  61 MODULE_DESCRIPTION("ACPI Battery Driver");
  62 MODULE_LICENSE("GPL");
  63
  64 static unsigned int update_time = ACPI_BATTERY_UPDATE_TIME;
  65
  66 /* 0 - every time, > 0 - by update_time */
  67 module_param(update_time, uint, 0644);
  68
  69 extern struct proc_dir_entry *acpi_lock_battery_dir(void);
  70 extern void *acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir);
  71
  72 static int acpi_battery_add(struct acpi_device *device);
  73 static int acpi_battery_remove(struct acpi_device *device, int type);
  74 static int acpi_battery_resume(struct acpi_device *device);
  75
  76 static const struct acpi_device_id battery_device_ids[] = {
  77         {"PNP0C0A", 0},
  78         {"", 0},
  79 };
  80 MODULE_DEVICE_TABLE(acpi, battery_device_ids);
  81
  82 static struct acpi_driver acpi_battery_driver = {
  83         .name = "battery",
  84         .class = ACPI_BATTERY_CLASS,
  85         .ids = battery_device_ids,
  86         .ops = {
  87                 .add = acpi_battery_add,
  88                 .resume = acpi_battery_resume,
  89                 .remove = acpi_battery_remove,
  90                 },
  91 };
  92
  93 struct acpi_battery_state {
  94         acpi_integer state;
  95         acpi_integer present_rate;
  96         acpi_integer remaining_capacity;
  97         acpi_integer present_voltage;
  98 };
  99
 100 struct acpi_battery_info {
 101         acpi_integer power_unit;
 102         acpi_integer design_capacity;
 103         acpi_integer last_full_capacity;
 104         acpi_integer battery_technology;
 105         acpi_integer design_voltage;
 106         acpi_integer design_capacity_warning;
 107         acpi_integer design_capacity_low;
 108         acpi_integer battery_capacity_granularity_1;
 109         acpi_integer battery_capacity_granularity_2;
 110         acpi_string model_number;
 111         acpi_string serial_number;
 112         acpi_string battery_type;
 113         acpi_string oem_info;
 114 };
 115
 116 enum acpi_battery_files {
 117         ACPI_BATTERY_INFO = 0,
 118         ACPI_BATTERY_STATE,
 119         ACPI_BATTERY_ALARM,
 120         ACPI_BATTERY_NUMFILES,
 121 };
 122
 123 struct acpi_battery_flags {
 124         u8 battery_present_prev;
 125         u8 alarm_present;
 126         u8 init_update;
 127         u8 update[ACPI_BATTERY_NUMFILES];
 128         u8 power_unit;
 129 };
 130
 131 struct acpi_battery {
 132         struct acpi_device *device;
 133         struct acpi_battery_flags flags;
 134         struct acpi_buffer bif_data;
 135         struct acpi_buffer bst_data;
 136         struct mutex lock;
 137         unsigned long alarm;
 138         unsigned long update_time[ACPI_BATTERY_NUMFILES];
 139
 140 };
 141
 142 inline int acpi_battery_present(struct acpi_battery *battery)
 143 {
 144         return battery->device->status.battery_present;
 145 }
 146 inline char *acpi_battery_power_units(struct acpi_battery *battery)
 147 {
 148         if (battery->flags.power_unit)
 149                 return ACPI_BATTERY_UNITS_AMPS;
 150         else
 151                 return ACPI_BATTERY_UNITS_WATTS;
 152 }
 153
 154 inline acpi_handle acpi_battery_handle(struct acpi_battery *battery)
 155 {
 156         return battery->device->handle;
 157 }
 158
 159 /* --------------------------------------------------------------------------
 160                                Battery Management
 161    -------------------------------------------------------------------------- */
 162
 163 static void acpi_battery_check_result(struct acpi_battery *battery, int result)
 164 {
 165         if (!battery)
 166                 return;
 167
 168         if (result) {
 169                 battery->flags.init_update = 1;
 170         }
 171 }
 172
 173 static int acpi_battery_extract_package(struct acpi_battery *battery,
 174                                         union acpi_object *package,
 175                                         struct acpi_buffer *format,
 176                                         struct acpi_buffer *data,
 177                                         char *package_name)
 178 {
 179         acpi_status status = AE_OK;
 180         struct acpi_buffer data_null = { 0, NULL };
 181
 182         status = acpi_extract_package(package, format, &data_null);
 183         if (status != AE_BUFFER_OVERFLOW) {
 184                 ACPI_EXCEPTION((AE_INFO, status, "Extracting size %s",
 185                                 package_name));
 186                 return -ENODEV;
 187         }
 188
 189         if (data_null.length != data->length) {
 190                 kfree(data->pointer);
 191                 data->pointer = kzalloc(data_null.length, GFP_KERNEL);
 192                 if (!data->pointer) {
 193                         ACPI_EXCEPTION((AE_INFO, AE_NO_MEMORY, "kzalloc()"));
 194                         return -ENOMEM;
 195                 }
 196                 data->length = data_null.length;
 197         }
 198
 199         status = acpi_extract_package(package, format, data);
 200         if (ACPI_FAILURE(status)) {
 201                 ACPI_EXCEPTION((AE_INFO, status, "Extracting %s",
 202                                 package_name));
 203                 return -ENODEV;
 204         }
 205
 206         return 0;
 207 }
 208
 209 static int acpi_battery_get_status(struct acpi_battery *battery)
 210 {
 211         int result = 0;
 212
 213         result = acpi_bus_get_status(battery->device);
 214         if (result) {
 215                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "Evaluating _STA"));
 216                 return -ENODEV;
 217         }
 218         return result;
 219 }
 220
 221 static int acpi_battery_get_info(struct acpi_battery *battery)
 222 {
 223         int result = 0;
 224         acpi_status status = 0;
 225         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 226         struct acpi_buffer format = { sizeof(ACPI_BATTERY_FORMAT_BIF),
 227                 ACPI_BATTERY_FORMAT_BIF
 228         };
 229         union acpi_object *package = NULL;
 230         struct acpi_buffer *data = NULL;
 231         struct acpi_battery_info *bif = NULL;
 232
 233         battery->update_time[ACPI_BATTERY_INFO] = get_seconds();
 234
 235         if (!acpi_battery_present(battery))
 236                 return 0;
 237
 238         /* Evaluate _BIF */
 239         mutex_lock(&battery->lock);
 240         status = acpi_evaluate_object(acpi_battery_handle(battery), "_BIF",
 241                                       NULL, &buffer);
 242         mutex_unlock(&battery->lock);
 243         if (ACPI_FAILURE(status)) {
 244                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BIF"));
 245                 return -ENODEV;
 246         }
 247
 248         package = buffer.pointer;
 249
 250         data = &battery->bif_data;
 251
 252         /* Extract Package Data */
 253
 254         result =
 255             acpi_battery_extract_package(battery, package, &format, data,
 256                                          "_BIF");
 257         if (result)
 258                 goto end;
 259
 260       end:
 261
 262         kfree(buffer.pointer);
 263
 264         if (!result) {
 265                 bif = data->pointer;
 266                 battery->flags.power_unit = bif->power_unit;
 267         }
 268
 269         return result;
 270 }
 271
 272 static int acpi_battery_get_state(struct acpi_battery *battery)
 273 {
 274         int result = 0;
 275         acpi_status status = 0;
 276         struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
 277         struct acpi_buffer format = { sizeof(ACPI_BATTERY_FORMAT_BST),
 278                 ACPI_BATTERY_FORMAT_BST
 279         };
 280         union acpi_object *package = NULL;
 281         struct acpi_buffer *data = NULL;
 282
 283         battery->update_time[ACPI_BATTERY_STATE] = get_seconds();
 284
 285         if (!acpi_battery_present(battery))
 286                 return 0;
 287
 288         /* Evaluate _BST */
 289         mutex_lock(&battery->lock);
 290         status = acpi_evaluate_object(acpi_battery_handle(battery), "_BST",
 291                                       NULL, &buffer);
 292         mutex_unlock(&battery->lock);
 293         if (ACPI_FAILURE(status)) {
 294                 ACPI_EXCEPTION((AE_INFO, status, "Evaluating _BST"));
 295                 return -ENODEV;
 296         }
 297
 298         package = buffer.pointer;
 299
 300         data = &battery->bst_data;
 301
 302         /* Extract Package Data */
 303
 304         result =
 305             acpi_battery_extract_package(battery, package, &format, data,
 306                                          "_BST");
 307         if (result)
 308                 goto end;
 309
 310       end:
 311         kfree(buffer.pointer);
 312
 313         return result;
 314 }
 315
 316 static int acpi_battery_get_alarm(struct acpi_battery *battery)
 317 {
 318         battery->update_time[ACPI_BATTERY_ALARM] = get_seconds();
 319
 320         return 0;
 321 }
 322
 323 static int acpi_battery_set_alarm(struct acpi_battery *battery,
 324                                   unsigned long alarm)
 325 {
 326         acpi_status status = 0;
 327         union acpi_object arg0 = { ACPI_TYPE_INTEGER };
 328         struct acpi_object_list arg_list = { 1, &arg0 };
 329
 330         battery->update_time[ACPI_BATTERY_ALARM] = get_seconds();
 331
 332         if (!acpi_battery_present(battery))
 333                 return -ENODEV;
 334
 335         if (!battery->flags.alarm_present)
 336                 return -ENODEV;
 337
 338         arg0.integer.value = alarm;
 339
 340         mutex_lock(&battery->lock);
 341         status = acpi_evaluate_object(acpi_battery_handle(battery), "_BTP",
 342                                  &arg_list, NULL);
 343         mutex_unlock(&battery->lock);
 344         if (ACPI_FAILURE(status))
 345                 return -ENODEV;
 346
 347         ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Alarm set to %d\n", (u32) alarm));
 348
 349         battery->alarm = alarm;
 350
 351         return 0;
 352 }
 353
 354 static int acpi_battery_init_alarm(struct acpi_battery *battery)
 355 {
 356         int result = 0;
 357         acpi_status status = AE_OK;
 358         acpi_handle handle = NULL;
 359         struct acpi_battery_info *bif = battery->bif_data.pointer;
 360         unsigned long alarm = battery->alarm;
 361
 362         /* See if alarms are supported, and if so, set default */
 363
 364         status = acpi_get_handle(acpi_battery_handle(battery), "_BTP", &handle);
 365         if (ACPI_SUCCESS(status)) {
 366                 battery->flags.alarm_present = 1;
 367                 if (!alarm && bif) {
 368                         alarm = bif->design_capacity_warning;
 369                 }
 370                 result = acpi_battery_set_alarm(battery, alarm);
 371                 if (result)
 372                         goto end;
 373         } else {
 374                 battery->flags.alarm_present = 0;
 375         }
 376
 377       end:
 378
 379         return result;
 380 }
 381
 382 static int acpi_battery_init_update(struct acpi_battery *battery)
 383 {
 384         int result = 0;
 385
 386         result = acpi_battery_get_status(battery);
 387         if (result)
 388                 return result;
 389
 390         battery->flags.battery_present_prev = acpi_battery_present(battery);
 391
 392         if (acpi_battery_present(battery)) {
 393                 result = acpi_battery_get_info(battery);
 394                 if (result)
 395                         return result;
 396                 result = acpi_battery_get_state(battery);
 397                 if (result)
 398                         return result;
 399
 400                 acpi_battery_init_alarm(battery);
 401         }
 402
 403         return result;
 404 }
 405
 406 static int acpi_battery_update(struct acpi_battery *battery,
 407                                int update, int *update_result_ptr)
 408 {
 409         int result = 0;
 410         int update_result = ACPI_BATTERY_NONE_UPDATE;
 411
 412         if (!acpi_battery_present(battery)) {
 413                 update = 1;
 414         }
 415
 416         if (battery->flags.init_update) {
 417                 result = acpi_battery_init_update(battery);
 418                 if (result)
 419                         goto end;
 420                 update_result = ACPI_BATTERY_INIT_UPDATE;
 421         } else if (update) {
 422                 result = acpi_battery_get_status(battery);
 423                 if (result)
 424                         goto end;
 425                 if ((!battery->flags.battery_present_prev & acpi_battery_present(battery))
 426                     || (battery->flags.battery_present_prev & !acpi_battery_present(battery))) {
 427                         result = acpi_battery_init_update(battery);
 428                         if (result)
 429                                 goto end;
 430                         update_result = ACPI_BATTERY_INIT_UPDATE;
 431                 } else {
 432                         update_result = ACPI_BATTERY_EASY_UPDATE;
 433                 }
 434         }
 435
 436       end:
 437
 438         battery->flags.init_update = (result != 0);
 439
 440         *update_result_ptr = update_result;
 441
 442         return result;
 443 }
 444
 445 static void acpi_battery_notify_update(struct acpi_battery *battery)
 446 {
 447         acpi_battery_get_status(battery);
 448
 449         if (battery->flags.init_update) {
 450                 return;
 451         }
 452
 453         if ((!battery->flags.battery_present_prev &
 454              acpi_battery_present(battery)) ||
 455             (battery->flags.battery_present_prev &
 456              !acpi_battery_present(battery))) {
 457                 battery->flags.init_update = 1;
 458         } else {
 459                 battery->flags.update[ACPI_BATTERY_INFO] = 1;
 460                 battery->flags.update[ACPI_BATTERY_STATE] = 1;
 461                 battery->flags.update[ACPI_BATTERY_ALARM] = 1;
 462         }
 463 }
 464
 465 /* --------------------------------------------------------------------------
 466                               FS Interface (/proc)
 467    -------------------------------------------------------------------------- */
 468
 469 static struct proc_dir_entry *acpi_battery_dir;
 470
 471 static int acpi_battery_print_info(struct seq_file *seq, int result)
 472 {
 473         struct acpi_battery *battery = seq->private;
 474         struct acpi_battery_info *bif = NULL;
 475         char *units = "?";
 476
 477         if (result)
 478                 goto end;
 479
 480         if (acpi_battery_present(battery))
 481                 seq_printf(seq, "present:                 yes\n");
 482         else {
 483                 seq_printf(seq, "present:                 no\n");
 484                 goto end;
 485         }
 486
 487         bif = battery->bif_data.pointer;
 488         if (!bif) {
 489                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "BIF buffer is NULL"));
 490                 result = -ENODEV;
 491                 goto end;
 492         }
 493
 494         /* Battery Units */
 495
 496         units = acpi_battery_power_units(battery);
 497
 498         if (bif->design_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 499                 seq_printf(seq, "design capacity:         unknown\n");
 500         else
 501                 seq_printf(seq, "design capacity:         %d %sh\n",
 502                            (u32) bif->design_capacity, units);
 503
 504         if (bif->last_full_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 505                 seq_printf(seq, "last full capacity:      unknown\n");
 506         else
 507                 seq_printf(seq, "last full capacity:      %d %sh\n",
 508                            (u32) bif->last_full_capacity, units);
 509
 510         switch ((u32) bif->battery_technology) {
 511         case 0:
 512                 seq_printf(seq, "battery technology:      non-rechargeable\n");
 513                 break;
 514         case 1:
 515                 seq_printf(seq, "battery technology:      rechargeable\n");
 516                 break;
 517         default:
 518                 seq_printf(seq, "battery technology:      unknown\n");
 519                 break;
 520         }
 521
 522         if (bif->design_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 523                 seq_printf(seq, "design voltage:          unknown\n");
 524         else
 525                 seq_printf(seq, "design voltage:          %d mV\n",
 526                            (u32) bif->design_voltage);
 527         seq_printf(seq, "design capacity warning: %d %sh\n",
 528                    (u32) bif->design_capacity_warning, units);
 529         seq_printf(seq, "design capacity low:     %d %sh\n",
 530                    (u32) bif->design_capacity_low, units);
 531         seq_printf(seq, "capacity granularity 1:  %d %sh\n",
 532                    (u32) bif->battery_capacity_granularity_1, units);
 533         seq_printf(seq, "capacity granularity 2:  %d %sh\n",
 534                    (u32) bif->battery_capacity_granularity_2, units);
 535         seq_printf(seq, "model number:            %s\n", bif->model_number);
 536         seq_printf(seq, "serial number:           %s\n", bif->serial_number);
 537         seq_printf(seq, "battery type:            %s\n", bif->battery_type);
 538         seq_printf(seq, "OEM info:                %s\n", bif->oem_info);
 539
 540       end:
 541
 542         if (result)
 543                 seq_printf(seq, "ERROR: Unable to read battery info\n");
 544
 545         return result;
 546 }
 547
 548 static int acpi_battery_print_state(struct seq_file *seq, int result)
 549 {
 550         struct acpi_battery *battery = seq->private;
 551         struct acpi_battery_state *bst = NULL;
 552         char *units = "?";
 553
 554         if (result)
 555                 goto end;
 556
 557         if (acpi_battery_present(battery))
 558                 seq_printf(seq, "present:                 yes\n");
 559         else {
 560                 seq_printf(seq, "present:                 no\n");
 561                 goto end;
 562         }
 563
 564         bst = battery->bst_data.pointer;
 565         if (!bst) {
 566                 ACPI_EXCEPTION((AE_INFO, AE_ERROR, "BST buffer is NULL"));
 567                 result = -ENODEV;
 568                 goto end;
 569         }
 570
 571         /* Battery Units */
 572
 573         units = acpi_battery_power_units(battery);
 574
 575         if (!(bst->state & 0x04))
 576                 seq_printf(seq, "capacity state:          ok\n");
 577         else
 578                 seq_printf(seq, "capacity state:          critical\n");
 579
 580         if ((bst->state & 0x01) && (bst->state & 0x02)) {
 581                 seq_printf(seq,
 582                            "charging state:          charging/discharging\n");
 583         } else if (bst->state & 0x01)
 584                 seq_printf(seq, "charging state:          discharging\n");
 585         else if (bst->state & 0x02)
 586                 seq_printf(seq, "charging state:          charging\n");
 587         else {
 588                 seq_printf(seq, "charging state:          charged\n");
 589         }
 590
 591         if (bst->present_rate == ACPI_BATTERY_VALUE_UNKNOWN)
 592                 seq_printf(seq, "present rate:            unknown\n");
 593         else
 594                 seq_printf(seq, "present rate:            %d %s\n",
 595                            (u32) bst->present_rate, units);
 596
 597         if (bst->remaining_capacity == ACPI_BATTERY_VALUE_UNKNOWN)
 598                 seq_printf(seq, "remaining capacity:      unknown\n");
 599         else
 600                 seq_printf(seq, "remaining capacity:      %d %sh\n",
 601                            (u32) bst->remaining_capacity, units);
 602
 603         if (bst->present_voltage == ACPI_BATTERY_VALUE_UNKNOWN)
 604                 seq_printf(seq, "present voltage:         unknown\n");
 605         else
 606                 seq_printf(seq, "present voltage:         %d mV\n",
 607                            (u32) bst->present_voltage);
 608
 609       end:
 610
 611         if (result) {
 612                 seq_printf(seq, "ERROR: Unable to read battery state\n");
 613         }
 614
 615         return result;
 616 }
 617
 618 static int acpi_battery_print_alarm(struct seq_file *seq, int result)
 619 {
 620         struct acpi_battery *battery = seq->private;
 621         char *units = "?";
 622
 623         if (result)
 624                 goto end;
 625
 626         if (!acpi_battery_present(battery)) {
 627                 seq_printf(seq, "present:                 no\n");
 628                 goto end;
 629         }
 630
 631         /* Battery Units */
 632
 633         units = acpi_battery_power_units(battery);
 634
 635         seq_printf(seq, "alarm:                   ");
 636         if (!battery->alarm)
 637                 seq_printf(seq, "unsupported\n");
 638         else
 639                 seq_printf(seq, "%lu %sh\n", battery->alarm, units);
 640
 641       end:
 642
 643         if (result)
 644                 seq_printf(seq, "ERROR: Unable to read battery alarm\n");
 645
 646         return result;
 647 }
 648
 649 static ssize_t
 650 acpi_battery_write_alarm(struct file *file,
 651                          const char __user * buffer,
 652                          size_t count, loff_t * ppos)
 653 {
 654         int result = 0;
 655         char alarm_string[12] = { '\0' };
 656         struct seq_file *m = file->private_data;
 657         struct acpi_battery *battery = m->private;
 658         int update_result = ACPI_BATTERY_NONE_UPDATE;
 659
 660         if (!battery || (count > sizeof(alarm_string) - 1))
 661                 return -EINVAL;
 662
 663         result = acpi_battery_update(battery, 1, &update_result);
 664         if (result) {
 665                 result = -ENODEV;
 666                 goto end;
 667         }
 668
 669         if (!acpi_battery_present(battery)) {
 670                 result = -ENODEV;
 671                 goto end;
 672         }
 673
 674         if (copy_from_user(alarm_string, buffer, count)) {
 675                 result = -EFAULT;
 676                 goto end;
 677         }
 678
 679         alarm_string[count] = '\0';
 680
 681         result = acpi_battery_set_alarm(battery,
 682                                         simple_strtoul(alarm_string, NULL, 0));
 683         if (result)
 684                 goto end;
 685
 686       end:
 687
 688         acpi_battery_check_result(battery, result);
 689
 690         if (!result)
 691                 return count;
 692
 693         return result;
 694 }
 695
 696 typedef int(*print_func)(struct seq_file *seq, int result);
 697 typedef int(*get_func)(struct acpi_battery *battery);
 698
 699 static struct acpi_read_mux {
 700         print_func print;
 701         get_func get;
 702 } acpi_read_funcs[ACPI_BATTERY_NUMFILES] = {
 703         {.get = acpi_battery_get_info, .print = acpi_battery_print_info},
 704         {.get = acpi_battery_get_state, .print = acpi_battery_print_state},
 705         {.get = acpi_battery_get_alarm, .print = acpi_battery_print_alarm},
 706 };
 707
 708 static int acpi_battery_read(int fid, struct seq_file *seq)
 709 {
 710         struct acpi_battery *battery = seq->private;
 711         int result = 0;
 712         int update_result = ACPI_BATTERY_NONE_UPDATE;
 713         int update = 0;
 714
 715         update = (get_seconds() - battery->update_time[fid] >= update_time);
 716         update = (update | battery->flags.update[fid]);
 717
 718         result = acpi_battery_update(battery, update, &update_result);
 719         if (result)
 720                 goto end;
 721
 722         if (update_result == ACPI_BATTERY_EASY_UPDATE) {
 723                 result = acpi_read_funcs[fid].get(battery);
 724                 if (result)
 725                         goto end;
 726         }
 727
 728       end:
 729         result = acpi_read_funcs[fid].print(seq, result);
 730         acpi_battery_check_result(battery, result);
 731         battery->flags.update[fid] = result;
 732         return result;
 733 }
 734
 735 static int acpi_battery_read_info(struct seq_file *seq, void *offset)
 736 {
 737         return acpi_battery_read(ACPI_BATTERY_INFO, seq);
 738 }
 739
 740 static int acpi_battery_read_state(struct seq_file *seq, void *offset)
 741 {
 742         return acpi_battery_read(ACPI_BATTERY_STATE, seq);
 743 }
 744
 745 static int acpi_battery_read_alarm(struct seq_file *seq, void *offset)
 746 {
 747         return acpi_battery_read(ACPI_BATTERY_ALARM, seq);
 748 }
 749
 750 static int acpi_battery_info_open_fs(struct inode *inode, struct file *file)
 751 {
 752         return single_open(file, acpi_battery_read_info, PDE(inode)->data);
 753 }
 754
 755 static int acpi_battery_state_open_fs(struct inode *inode, struct file *file)
 756 {
 757         return single_open(file, acpi_battery_read_state, PDE(inode)->data);
 758 }
 759
 760 static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file)
 761 {
 762         return single_open(file, acpi_battery_read_alarm, PDE(inode)->data);
 763 }
 764
 765 static struct battery_file {
 766         struct file_operations ops;
 767         mode_t mode;
 768         char *name;
 769 } acpi_battery_file[] = {
 770         {
 771         .name = "info",
 772         .mode = S_IRUGO,
 773         .ops = {
 774         .open = acpi_battery_info_open_fs,
 775         .read = seq_read,
 776         .llseek = seq_lseek,
 777         .release = single_release,
 778         .owner = THIS_MODULE,
 779         },
 780         },
 781         {
 782         .name = "state",
 783         .mode = S_IRUGO,
 784         .ops = {
 785         .open = acpi_battery_state_open_fs,
 786         .read = seq_read,
 787         .llseek = seq_lseek,
 788         .release = single_release,
 789         .owner = THIS_MODULE,
 790         },
 791         },
 792         {
 793         .name = "alarm",
 794         .mode = S_IFREG | S_IRUGO | S_IWUSR,
 795         .ops = {
 796         .open = acpi_battery_alarm_open_fs,
 797         .read = seq_read,
 798         .write = acpi_battery_write_alarm,
 799         .llseek = seq_lseek,
 800         .release = single_release,
 801         .owner = THIS_MODULE,
 802         },
 803         },
 804 };
 805
 806 static int acpi_battery_add_fs(struct acpi_device *device)
 807 {
 808         struct proc_dir_entry *entry = NULL;
 809         int i;
 810
 811         if (!acpi_device_dir(device)) {
 812                 acpi_device_dir(device) = proc_mkdir(acpi_device_bid(device),
 813                                                      acpi_battery_dir);
 814                 if (!acpi_device_dir(device))
 815                         return -ENODEV;
 816                 acpi_device_dir(device)->owner = THIS_MODULE;
 817         }
 818
 819         for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
 820                 entry = create_proc_entry(acpi_battery_file[i].name,
 821                                   acpi_battery_file[i].mode, acpi_device_dir(device));
 822                 if (!entry)
 823                         return -ENODEV;
 824                 else {
 825                         entry->proc_fops = &acpi_battery_file[i].ops;
 826                         entry->data = acpi_driver_data(device);
 827                         entry->owner = THIS_MODULE;
 828                 }
 829         }
 830
 831         return 0;
 832 }
 833
 834 static int acpi_battery_remove_fs(struct acpi_device *device)
 835 {
 836         int i;
 837         if (acpi_device_dir(device)) {
 838                 for (i = 0; i < ACPI_BATTERY_NUMFILES; ++i) {
 839                         remove_proc_entry(acpi_battery_file[i].name,
 840                                   acpi_device_dir(device));
 841                 }
 842                 remove_proc_entry(acpi_device_bid(device), acpi_battery_dir);
 843                 acpi_device_dir(device) = NULL;
 844         }
 845
 846         return 0;
 847 }
 848
 849 /* --------------------------------------------------------------------------
 850                                  Driver Interface
 851    -------------------------------------------------------------------------- */
 852
 853 static void acpi_battery_notify(acpi_handle handle, u32 event, void *data)
 854 {
 855         struct acpi_battery *battery = data;
 856         struct acpi_device *device = NULL;
 857
 858         if (!battery)
 859                 return;
 860
 861         device = battery->device;
 862
 863         switch (event) {
 864         case ACPI_BATTERY_NOTIFY_STATUS:
 865         case ACPI_BATTERY_NOTIFY_INFO:
 866         case ACPI_NOTIFY_BUS_CHECK:
 867         case ACPI_NOTIFY_DEVICE_CHECK:
 868                 device = battery->device;
 869                 acpi_battery_notify_update(battery);
 870                 acpi_bus_generate_event(device, event,
 871                                         acpi_battery_present(battery));
 872                 acpi_bus_generate_netlink_event(device->pnp.device_class,
 873                                                   device->dev.bus_id, event,
 874                                                   acpi_battery_present(battery));
 875                 break;
 876         default:
 877                 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
 878                                   "Unsupported event [0x%x]\n", event));
 879                 break;
 880         }
 881
 882         return;
 883 }
 884
 885 static int acpi_battery_add(struct acpi_device *device)
 886 {
 887         int result = 0;
 888         acpi_status status = 0;
 889         struct acpi_battery *battery = NULL;
 890
 891         if (!device)
 892                 return -EINVAL;
 893
 894         battery = kzalloc(sizeof(struct acpi_battery), GFP_KERNEL);
 895         if (!battery)
 896                 return -ENOMEM;
 897
 898         mutex_init(&battery->lock);
 899         battery->device = device;
 900         strcpy(acpi_device_name(device), ACPI_BATTERY_DEVICE_NAME);
 901         strcpy(acpi_device_class(device), ACPI_BATTERY_CLASS);
 902         acpi_driver_data(device) = battery;
 903
 904         result = acpi_battery_get_status(battery);
 905         if (result)
 906                 goto end;
 907
 908         battery->flags.init_update = 1;
 909
 910         result = acpi_battery_add_fs(device);
 911         if (result)
 912                 goto end;
 913
 914         status = acpi_install_notify_handler(device->handle,
 915                                              ACPI_ALL_NOTIFY,
 916                                              acpi_battery_notify, battery);
 917         if (ACPI_FAILURE(status)) {
 918                 ACPI_EXCEPTION((AE_INFO, status, "Installing notify handler"));
 919                 result = -ENODEV;
 920                 goto end;
 921         }
 922
 923         printk(KERN_INFO PREFIX "%s Slot [%s] (battery %s)\n",
 924                ACPI_BATTERY_DEVICE_NAME, acpi_device_bid(device),
 925                device->status.battery_present ? "present" : "absent");
 926
 927       end:
 928
 929         if (result) {
 930                 acpi_battery_remove_fs(device);
 931                 kfree(battery);
 932         }
 933
 934
 935         return result;
 936 }
 937
 938 static int acpi_battery_remove(struct acpi_device *device, int type)
 939 {
 940         acpi_status status = 0;
 941         struct acpi_battery *battery = NULL;
 942
 943         if (!device || !acpi_driver_data(device))
 944                 return -EINVAL;
 945
 946         battery = acpi_driver_data(device);
 947
 948         status = acpi_remove_notify_handler(device->handle,
 949                                             ACPI_ALL_NOTIFY,
 950                                             acpi_battery_notify);
 951
 952         acpi_battery_remove_fs(device);
 953
 954         kfree(battery->bif_data.pointer);
 955
 956         kfree(battery->bst_data.pointer);
 957
 958         mutex_destroy(&battery->lock);
 959
 960         kfree(battery);
 961
 962         return 0;
 963 }
 964
 965 /* this is needed to learn about changes made in suspended state */
 966 static int acpi_battery_resume(struct acpi_device *device)
 967 {
 968         struct acpi_battery *battery;
 969
 970         if (!device)
 971                 return -EINVAL;
 972
 973         battery = device->driver_data;
 974
 975         battery->flags.init_update = 1;
 976
 977         return 0;
 978 }
 979
 980 static int __init acpi_battery_init(void)
 981 {
 982         int result;
 983
 984         if (acpi_disabled)
 985                 return -ENODEV;
 986
 987         acpi_battery_dir = acpi_lock_battery_dir();
 988         if (!acpi_battery_dir)
 989                 return -ENODEV;
 990
 991         result = acpi_bus_register_driver(&acpi_battery_driver);
 992         if (result < 0) {
 993                 acpi_unlock_battery_dir(acpi_battery_dir);
 994                 return -ENODEV;
 995         }
 996
 997         return 0;
 998 }
 999
1000 static void __exit acpi_battery_exit(void)
1001 {
1002         acpi_bus_unregister_driver(&acpi_battery_driver);
1003
1004         acpi_unlock_battery_dir(acpi_battery_dir);
1005
1006         return;
1007 }
1008
1009 module_init(acpi_battery_init);
1010 module_exit(acpi_battery_exit);