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