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