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