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