sbs.c revision b20d2aeb0ad322cbe7fd9120acae6118231b17a3
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 52extern struct proc_dir_entry *acpi_lock_ac_dir(void); 53extern struct proc_dir_entry *acpi_lock_battery_dir(void); 54extern void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir); 55extern 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 81ACPI_MODULE_NAME("acpi_sbs"); 82 83MODULE_AUTHOR("Rich Townsend"); 84MODULE_DESCRIPTION("Smart Battery System ACPI interface driver"); 85MODULE_LICENSE("GPL"); 86 87static 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 95static int capacity_mode = CAPACITY_UNIT; 96static int update_mode = UPDATE_MODE; 97static int update_info_mode = UPDATE_INFO_MODE; 98static int update_time = UPDATE_TIME; 99static int update_time2 = UPDATE_TIME2; 100 101module_param(capacity_mode, int, CAPACITY_UNIT); 102module_param(update_mode, int, UPDATE_MODE); 103module_param(update_info_mode, int, UPDATE_INFO_MODE); 104module_param(update_time, int, UPDATE_TIME); 105module_param(update_time2, int, UPDATE_TIME2); 106 107static int acpi_sbs_add(struct acpi_device *device); 108static int acpi_sbs_remove(struct acpi_device *device, int type); 109static void acpi_battery_smbus_err_handler(struct acpi_ec_smbus *smbus); 110static void acpi_sbs_update_queue(void *data); 111 112static 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 122struct 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 135struct 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 144struct acpi_battery_alarm { 145 s16 remaining_capacity; 146}; 147 148struct 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 160struct 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 176static void acpi_update_delay(struct acpi_sbs *sbs); 177static int acpi_sbs_update_run(struct acpi_sbs *sbs, int data_type); 178 179/* -------------------------------------------------------------------------- 180 SMBus Communication 181 -------------------------------------------------------------------------- */ 182 183static 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 231static int 232acpi_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 265static int 266acpi_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 302static int 303acpi_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 343static 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 364static 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 385static int acpi_battery_is_present(struct acpi_battery *battery) 386{ 387 return (battery->battery_present); 388} 389 390static int acpi_ac_is_present(struct acpi_sbs *sbs) 391{ 392 return (sbs->ac_present); 393} 394 395static 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 432static 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 453static 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 571static 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 581static 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 652static 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 673static 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 727static 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 772static 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 815static 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 843static int 844acpi_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 905static void 906acpi_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 922static struct proc_dir_entry *acpi_battery_dir = NULL; 923 924static 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 993static 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 998static 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 1072static 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 1077static 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 1124static ssize_t 1125acpi_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 1184static 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 1189static 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 1197static 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 1205static 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 1216static struct proc_dir_entry *acpi_ac_dir = NULL; 1217 1218static 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 1245static 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 1250static 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 1264static 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 1324static 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 1333static 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 1359static 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 1367static 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 1372static 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 1537static 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 1570static 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 1686int 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 1713static 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 1755static 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 1768module_init(acpi_sbs_init); 1769module_exit(acpi_sbs_exit); 1770