xref: /openbmc/linux/drivers/acpi/sbs.c (revision e868d61272caa648214046a096e5a6bfc068dc8c)
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);
1841