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