?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'splice-2.6.22' of git://git.kernel.dk/data/git/linux-2.6-block
[linux-2.6/mini2440.git] / drivers / acpi / sbs.c
blobc1bae106833cef03d6f7faee83e5d42c9fda36a9
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);
Support for the Chinese Samsung S3C2440 based development boards