diff options
-rw-r--r-- | drivers/acpi/sbs.c | 1292 |
1 files changed, 275 insertions, 1017 deletions
diff --git a/drivers/acpi/sbs.c b/drivers/acpi/sbs.c index f35fe63cef3d..3351dea11ff0 100644 --- a/drivers/acpi/sbs.c +++ b/drivers/acpi/sbs.c | |||
@@ -1,6 +1,8 @@ | |||
1 | /* | 1 | /* |
2 | * acpi_sbs.c - ACPI Smart Battery System Driver ($Revision: 1.16 $) | 2 | * sbs.c - ACPI Smart Battery System Driver ($Revision: 2.0 $) |
3 | * | 3 | * |
4 | * Copyright (c) 2007 Alexey Starikovskiy <astarikovskiy@suse.de> | ||
5 | * Copyright (c) 2005-2007 Vladimir Lebedev <vladimir.p.lebedev@intel.com> | ||
4 | * Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu> | 6 | * Copyright (c) 2005 Rich Townsend <rhdt@bartol.udel.edu> |
5 | * | 7 | * |
6 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ | 8 | * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ |
@@ -46,53 +48,34 @@ | |||
46 | #define ACPI_SBS_FILE_ALARM "alarm" | 48 | #define ACPI_SBS_FILE_ALARM "alarm" |
47 | #define ACPI_BATTERY_DIR_NAME "BAT%i" | 49 | #define ACPI_BATTERY_DIR_NAME "BAT%i" |
48 | #define ACPI_AC_DIR_NAME "AC0" | 50 | #define ACPI_AC_DIR_NAME "AC0" |
49 | #define ACPI_SBC_SMBUS_ADDR 0x9 | ||
50 | #define ACPI_SBSM_SMBUS_ADDR 0xa | ||
51 | #define ACPI_SB_SMBUS_ADDR 0xb | ||
52 | #define ACPI_SBS_AC_NOTIFY_STATUS 0x80 | ||
53 | #define ACPI_SBS_BATTERY_NOTIFY_STATUS 0x80 | ||
54 | #define ACPI_SBS_BATTERY_NOTIFY_INFO 0x81 | ||
55 | 51 | ||
56 | #define _COMPONENT ACPI_SBS_COMPONENT | 52 | enum acpi_sbs_device_addr { |
53 | ACPI_SBS_CHARGER = 0x9, | ||
54 | ACPI_SBS_MANAGER = 0xa, | ||
55 | ACPI_SBS_BATTERY = 0xb, | ||
56 | }; | ||
57 | |||
58 | #define ACPI_SBS_NOTIFY_STATUS 0x80 | ||
59 | #define ACPI_SBS_NOTIFY_INFO 0x81 | ||
57 | 60 | ||
58 | ACPI_MODULE_NAME("sbs"); | 61 | ACPI_MODULE_NAME("sbs"); |
59 | 62 | ||
60 | MODULE_AUTHOR("Rich Townsend"); | 63 | MODULE_AUTHOR("Alexey Starikovskiy <astarikovskiy@suse.de>"); |
61 | MODULE_DESCRIPTION("Smart Battery System ACPI interface driver"); | 64 | MODULE_DESCRIPTION("Smart Battery System ACPI interface driver"); |
62 | MODULE_LICENSE("GPL"); | 65 | MODULE_LICENSE("GPL"); |
63 | 66 | ||
64 | #define DEF_CAPACITY_UNIT 3 | 67 | static unsigned int cache_time = 1000; |
65 | #define MAH_CAPACITY_UNIT 1 | 68 | module_param(cache_time, uint, 0644); |
66 | #define MWH_CAPACITY_UNIT 2 | 69 | MODULE_PARM_DESC(cache_time, "cache time in milliseconds"); |
67 | #define CAPACITY_UNIT DEF_CAPACITY_UNIT | ||
68 | |||
69 | #define REQUEST_UPDATE_MODE 1 | ||
70 | #define QUEUE_UPDATE_MODE 2 | ||
71 | |||
72 | #define DATA_TYPE_COMMON 0 | ||
73 | #define DATA_TYPE_INFO 1 | ||
74 | #define DATA_TYPE_STATE 2 | ||
75 | #define DATA_TYPE_ALARM 3 | ||
76 | #define DATA_TYPE_AC_STATE 4 | ||
77 | 70 | ||
78 | extern struct proc_dir_entry *acpi_lock_ac_dir(void); | 71 | extern struct proc_dir_entry *acpi_lock_ac_dir(void); |
79 | extern struct proc_dir_entry *acpi_lock_battery_dir(void); | 72 | extern struct proc_dir_entry *acpi_lock_battery_dir(void); |
80 | extern void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir); | 73 | extern void acpi_unlock_ac_dir(struct proc_dir_entry *acpi_ac_dir); |
81 | extern void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir); | 74 | extern void acpi_unlock_battery_dir(struct proc_dir_entry *acpi_battery_dir); |
82 | 75 | ||
83 | #define MAX_SBS_BAT 4 | 76 | #define MAX_SBS_BAT 4 |
84 | #define ACPI_SBS_BLOCK_MAX 32 | 77 | #define ACPI_SBS_BLOCK_MAX 32 |
85 | 78 | ||
86 | #define UPDATE_DELAY 10 | ||
87 | |||
88 | /* 0 - every time, > 0 - by update_time */ | ||
89 | static unsigned int update_time = 120; | ||
90 | |||
91 | static unsigned int mode = CAPACITY_UNIT; | ||
92 | |||
93 | module_param(update_time, uint, 0644); | ||
94 | module_param(mode, uint, 0444); | ||
95 | |||
96 | static int acpi_sbs_add(struct acpi_device *device); | 79 | static int acpi_sbs_add(struct acpi_device *device); |
97 | static int acpi_sbs_remove(struct acpi_device *device, int type); | 80 | static int acpi_sbs_remove(struct acpi_device *device, int type); |
98 | static int acpi_sbs_resume(struct acpi_device *device); | 81 | static int acpi_sbs_resume(struct acpi_device *device); |
@@ -117,486 +100,187 @@ static struct acpi_driver acpi_sbs_driver = { | |||
117 | struct acpi_battery { | 100 | struct acpi_battery { |
118 | struct acpi_sbs *sbs; | 101 | struct acpi_sbs *sbs; |
119 | struct proc_dir_entry *proc_entry; | 102 | struct proc_dir_entry *proc_entry; |
120 | int vscale; | 103 | unsigned long update_time; |
121 | int ipscale; | 104 | char name[8]; |
122 | char manufacturer_name[ACPI_SBS_BLOCK_MAX]; | 105 | char manufacturer_name[ACPI_SBS_BLOCK_MAX]; |
123 | char device_name[ACPI_SBS_BLOCK_MAX]; | 106 | char device_name[ACPI_SBS_BLOCK_MAX]; |
124 | char device_chemistry[ACPI_SBS_BLOCK_MAX]; | 107 | char device_chemistry[ACPI_SBS_BLOCK_MAX]; |
108 | u32 alarm_capacity; | ||
125 | u16 full_charge_capacity; | 109 | u16 full_charge_capacity; |
126 | u16 design_capacity; | 110 | u16 design_capacity; |
127 | u16 design_voltage; | 111 | u16 design_voltage; |
128 | u16 serial_number; | 112 | u16 serial_number; |
113 | u16 cycle_count; | ||
114 | u16 temp_now; | ||
129 | u16 voltage_now; | 115 | u16 voltage_now; |
130 | s16 current_now; | 116 | s16 current_now; |
117 | s16 current_avg; | ||
131 | u16 capacity_now; | 118 | u16 capacity_now; |
119 | u16 state_of_charge; | ||
132 | u16 state; | 120 | u16 state; |
133 | u16 alarm_capacity; | ||
134 | u16 mode; | 121 | u16 mode; |
122 | u16 spec; | ||
135 | u8 id; | 123 | u8 id; |
136 | u8 alive:1; | ||
137 | u8 init_state:1; | ||
138 | u8 present:1; | 124 | u8 present:1; |
139 | }; | 125 | }; |
140 | 126 | ||
141 | struct acpi_sbs { | 127 | struct acpi_sbs { |
142 | struct acpi_device *device; | 128 | struct acpi_device *device; |
143 | struct acpi_smb_hc *hc; | 129 | struct acpi_smb_hc *hc; |
144 | struct mutex mutex; | 130 | struct mutex lock; |
145 | struct proc_dir_entry *ac_entry; | 131 | struct proc_dir_entry *charger_entry; |
146 | struct acpi_battery battery[MAX_SBS_BAT]; | 132 | struct acpi_battery battery[MAX_SBS_BAT]; |
147 | int zombie; | 133 | u8 batteries_supported:4; |
148 | struct timer_list update_timer; | ||
149 | int run_cnt; | ||
150 | int update_proc_flg; | ||
151 | u8 batteries_supported; | ||
152 | u8 manager_present:1; | 134 | u8 manager_present:1; |
153 | u8 charger_present:1; | 135 | u8 charger_present:1; |
154 | }; | 136 | }; |
155 | 137 | ||
156 | static int acpi_sbs_update_run(struct acpi_sbs *sbs, int id, int data_type); | 138 | static inline int battery_scale(int log) |
157 | static void acpi_sbs_update_time(void *data); | ||
158 | |||
159 | static int sbs_zombie(struct acpi_sbs *sbs) | ||
160 | { | 139 | { |
161 | return (sbs->zombie); | 140 | int scale = 1; |
141 | while (log--) | ||
142 | scale *= 10; | ||
143 | return scale; | ||
162 | } | 144 | } |
163 | 145 | ||
164 | static int sbs_mutex_lock(struct acpi_sbs *sbs) | 146 | static inline int acpi_battery_vscale(struct acpi_battery *battery) |
165 | { | 147 | { |
166 | if (sbs_zombie(sbs)) { | 148 | return battery_scale((battery->spec & 0x0f00) >> 8); |
167 | return -ENODEV; | ||
168 | } | ||
169 | mutex_lock(&sbs->mutex); | ||
170 | return 0; | ||
171 | } | 149 | } |
172 | 150 | ||
173 | static void sbs_mutex_unlock(struct acpi_sbs *sbs) | 151 | static inline int acpi_battery_ipscale(struct acpi_battery *battery) |
174 | { | 152 | { |
175 | mutex_unlock(&sbs->mutex); | 153 | return battery_scale((battery->spec & 0xf000) >> 12); |
176 | } | 154 | } |
177 | 155 | ||
178 | /* -------------------------------------------------------------------------- | 156 | static inline int acpi_battery_mode(struct acpi_battery *battery) |
179 | Smart Battery System Management | ||
180 | -------------------------------------------------------------------------- */ | ||
181 | |||
182 | static int acpi_check_update_proc(struct acpi_sbs *sbs) | ||
183 | { | 157 | { |
184 | acpi_status status = AE_OK; | 158 | return (battery->mode & 0x8000); |
185 | |||
186 | if (update_time == 0) { | ||
187 | sbs->update_proc_flg = 0; | ||
188 | return 0; | ||
189 | } | ||
190 | if (sbs->update_proc_flg == 0) { | ||
191 | status = acpi_os_execute(OSL_GPE_HANDLER, | ||
192 | acpi_sbs_update_time, sbs); | ||
193 | if (status != AE_OK) { | ||
194 | ACPI_EXCEPTION((AE_INFO, status, | ||
195 | "acpi_os_execute() failed")); | ||
196 | return 1; | ||
197 | } | ||
198 | sbs->update_proc_flg = 1; | ||
199 | } | ||
200 | return 0; | ||
201 | } | 159 | } |
202 | 160 | ||
203 | static int acpi_battery_get_present(struct acpi_battery *battery) | 161 | static inline int acpi_battery_scale(struct acpi_battery *battery) |
204 | { | 162 | { |
205 | s16 state; | 163 | return (acpi_battery_mode(battery) ? 10 : 1) * |
206 | int result = 0; | 164 | acpi_battery_ipscale(battery); |
207 | int is_present = 0; | ||
208 | |||
209 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, | ||
210 | ACPI_SBSM_SMBUS_ADDR, 0x01, (u8 *)&state); | ||
211 | if (result) { | ||
212 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
213 | "acpi_smbus_read() failed")); | ||
214 | } | ||
215 | if (!result) { | ||
216 | is_present = (state & 0x000f) & (1 << battery->id); | ||
217 | } | ||
218 | battery->present = is_present; | ||
219 | |||
220 | return result; | ||
221 | } | 165 | } |
222 | 166 | ||
223 | static int acpi_battery_select(struct acpi_battery *battery) | 167 | /* -------------------------------------------------------------------------- |
224 | { | 168 | Smart Battery System Management |
225 | struct acpi_sbs *sbs = battery->sbs; | 169 | -------------------------------------------------------------------------- */ |
226 | int result = 0; | ||
227 | s16 state; | ||
228 | int foo; | ||
229 | |||
230 | if (sbs->manager_present) { | ||
231 | |||
232 | /* Take special care not to knobble other nibbles of | ||
233 | * state (aka selector_state), since | ||
234 | * it causes charging to halt on SBSELs */ | ||
235 | 170 | ||
236 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, | 171 | struct acpi_battery_reader { |
237 | ACPI_SBSM_SMBUS_ADDR, 0x01, (u8 *)&state); | 172 | u8 command; /* command for battery */ |
238 | if (result) { | 173 | u8 mode; /* word or block? */ |
239 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | 174 | size_t offset; /* offset inside struct acpi_sbs_battery */ |
240 | "acpi_smbus_read() failed")); | 175 | }; |
241 | goto end; | ||
242 | } | ||
243 | 176 | ||
244 | foo = (state & 0x0fff) | (1 << (battery->id + 12)); | 177 | static struct acpi_battery_reader info_readers[] = { |
245 | result = acpi_smbus_write(battery->sbs->hc, SMBUS_WRITE_WORD, | 178 | {0x01, SMBUS_READ_WORD, offsetof(struct acpi_battery, alarm_capacity)}, |
246 | ACPI_SBSM_SMBUS_ADDR, 0x01, (u8 *)&foo, 2); | 179 | {0x03, SMBUS_READ_WORD, offsetof(struct acpi_battery, mode)}, |
247 | if (result) { | 180 | {0x10, SMBUS_READ_WORD, offsetof(struct acpi_battery, full_charge_capacity)}, |
248 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | 181 | {0x17, SMBUS_READ_WORD, offsetof(struct acpi_battery, cycle_count)}, |
249 | "acpi_smbus_write() failed")); | 182 | {0x18, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_capacity)}, |
250 | goto end; | 183 | {0x19, SMBUS_READ_WORD, offsetof(struct acpi_battery, design_voltage)}, |
251 | } | 184 | {0x1a, SMBUS_READ_WORD, offsetof(struct acpi_battery, spec)}, |
252 | } | 185 | {0x1c, SMBUS_READ_WORD, offsetof(struct acpi_battery, serial_number)}, |
186 | {0x20, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, manufacturer_name)}, | ||
187 | {0x21, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_name)}, | ||
188 | {0x22, SMBUS_READ_BLOCK, offsetof(struct acpi_battery, device_chemistry)}, | ||
189 | }; | ||
253 | 190 | ||
254 | end: | 191 | static struct acpi_battery_reader state_readers[] = { |
255 | return result; | 192 | {0x08, SMBUS_READ_WORD, offsetof(struct acpi_battery, temp_now)}, |
256 | } | 193 | {0x09, SMBUS_READ_WORD, offsetof(struct acpi_battery, voltage_now)}, |
194 | {0x0a, SMBUS_READ_WORD, offsetof(struct acpi_battery, current_now)}, | ||
195 | {0x0b, SMBUS_READ_WORD, offsetof(struct acpi_battery, current_avg)}, | ||
196 | {0x0f, SMBUS_READ_WORD, offsetof(struct acpi_battery, capacity_now)}, | ||
197 | {0x0e, SMBUS_READ_WORD, offsetof(struct acpi_battery, state_of_charge)}, | ||
198 | {0x16, SMBUS_READ_WORD, offsetof(struct acpi_battery, state)}, | ||
199 | }; | ||
257 | 200 | ||
258 | static int acpi_sbsm_get_info(struct acpi_sbs *sbs) | 201 | static int acpi_manager_get_info(struct acpi_sbs *sbs) |
259 | { | 202 | { |
260 | int result = 0; | 203 | int result = 0; |
261 | s16 battery_system_info; | 204 | u16 battery_system_info; |
262 | |||
263 | result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBSM_SMBUS_ADDR, 0x04, | ||
264 | (u8 *)&battery_system_info); | ||
265 | if (result) { | ||
266 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
267 | "acpi_smbus_read() failed")); | ||
268 | goto end; | ||
269 | } | ||
270 | sbs->manager_present = 1; | ||
271 | |||
272 | end: | ||
273 | 205 | ||
206 | result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER, | ||
207 | 0x04, (u8 *) & battery_system_info); | ||
208 | if (!result) | ||
209 | sbs->batteries_supported = battery_system_info & 0x000f; | ||
274 | return result; | 210 | return result; |
275 | } | 211 | } |
276 | 212 | ||
277 | static int acpi_battery_get_info(struct acpi_battery *battery) | 213 | static int acpi_battery_get_info(struct acpi_battery *battery) |
278 | { | 214 | { |
279 | int result = 0; | 215 | int i, result = 0; |
280 | s16 battery_mode; | ||
281 | s16 specification_info; | ||
282 | |||
283 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x03, | ||
284 | (u8 *)&battery_mode); | ||
285 | if (result) { | ||
286 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
287 | "acpi_smbus_read() failed")); | ||
288 | goto end; | ||
289 | } | ||
290 | battery->mode = (battery_mode & 0x8000) >> 15; | ||
291 | |||
292 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x10, | ||
293 | (u8 *)&battery->full_charge_capacity); | ||
294 | if (result) { | ||
295 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
296 | "acpi_smbus_read() failed")); | ||
297 | goto end; | ||
298 | } | ||
299 | |||
300 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x18, | ||
301 | (u8 *)&battery->design_capacity); | ||
302 | 216 | ||
303 | if (result) { | 217 | for (i = 0; i < ARRAY_SIZE(info_readers); ++i) { |
304 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | 218 | result = acpi_smbus_read(battery->sbs->hc, info_readers[i].mode, |
305 | "acpi_smbus_read() failed")); | 219 | ACPI_SBS_BATTERY, info_readers[i].command, |
306 | goto end; | 220 | (u8 *) battery + info_readers[i].offset); |
307 | } | 221 | if (result) |
308 | 222 | break; | |
309 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x19, | ||
310 | (u8 *)&battery->design_voltage); | ||
311 | if (result) { | ||
312 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
313 | "acpi_smbus_read() failed")); | ||
314 | goto end; | ||
315 | } | 223 | } |
316 | |||
317 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x1a, | ||
318 | (u8 *)&specification_info); | ||
319 | if (result) { | ||
320 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
321 | "acpi_smbus_read() failed")); | ||
322 | goto end; | ||
323 | } | ||
324 | |||
325 | switch ((specification_info & 0x0f00) >> 8) { | ||
326 | case 1: | ||
327 | battery->vscale = 10; | ||
328 | break; | ||
329 | case 2: | ||
330 | battery->vscale = 100; | ||
331 | break; | ||
332 | case 3: | ||
333 | battery->vscale = 1000; | ||
334 | break; | ||
335 | default: | ||
336 | battery->vscale = 1; | ||
337 | } | ||
338 | |||
339 | switch ((specification_info & 0xf000) >> 12) { | ||
340 | case 1: | ||
341 | battery->ipscale = 10; | ||
342 | break; | ||
343 | case 2: | ||
344 | battery->ipscale = 100; | ||
345 | break; | ||
346 | case 3: | ||
347 | battery->ipscale = 1000; | ||
348 | break; | ||
349 | default: | ||
350 | battery->ipscale = 1; | ||
351 | } | ||
352 | |||
353 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x1c, | ||
354 | (u8 *)&battery->serial_number); | ||
355 | if (result) { | ||
356 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
357 | "acpi_smbus_read() failed")); | ||
358 | goto end; | ||
359 | } | ||
360 | |||
361 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_BLOCK, ACPI_SB_SMBUS_ADDR, 0x20, | ||
362 | (u8 *)battery->manufacturer_name); | ||
363 | if (result) { | ||
364 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
365 | "acpi_sbs_read_str() failed")); | ||
366 | goto end; | ||
367 | } | ||
368 | |||
369 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_BLOCK, ACPI_SB_SMBUS_ADDR, 0x21, | ||
370 | (u8 *)battery->device_name); | ||
371 | if (result) { | ||
372 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
373 | "acpi_sbs_read_str() failed")); | ||
374 | goto end; | ||
375 | } | ||
376 | |||
377 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_BLOCK, ACPI_SB_SMBUS_ADDR, 0x22, | ||
378 | (u8 *)battery->device_chemistry); | ||
379 | if (result) { | ||
380 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
381 | "acpi_sbs_read_str() failed")); | ||
382 | goto end; | ||
383 | } | ||
384 | |||
385 | end: | ||
386 | return result; | 224 | return result; |
387 | } | 225 | } |
388 | 226 | ||
389 | static int acpi_battery_get_state(struct acpi_battery *battery) | 227 | static int acpi_battery_get_state(struct acpi_battery *battery) |
390 | { | 228 | { |
391 | int result = 0; | 229 | int i, result = 0; |
392 | |||
393 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x09, | ||
394 | (u8 *)&battery->voltage_now); | ||
395 | if (result) { | ||
396 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
397 | "acpi_smbus_read() failed")); | ||
398 | goto end; | ||
399 | } | ||
400 | |||
401 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x0a, | ||
402 | (u8 *)&battery->current_now); | ||
403 | if (result) { | ||
404 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
405 | "acpi_smbus_read() failed")); | ||
406 | goto end; | ||
407 | } | ||
408 | |||
409 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x0f, | ||
410 | (u8 *)&battery->capacity_now); | ||
411 | if (result) { | ||
412 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
413 | "acpi_smbus_read() failed")); | ||
414 | goto end; | ||
415 | } | ||
416 | |||
417 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x16, | ||
418 | (u8 *)&battery->state); | ||
419 | if (result) { | ||
420 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
421 | "acpi_smbus_read() failed")); | ||
422 | goto end; | ||
423 | } | ||
424 | |||
425 | end: | ||
426 | return result; | ||
427 | } | ||
428 | |||
429 | static int acpi_battery_get_alarm(struct acpi_battery *battery) | ||
430 | { | ||
431 | int result = 0; | ||
432 | |||
433 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x01, | ||
434 | (u8 *)&battery->alarm_capacity); | ||
435 | if (result) { | ||
436 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
437 | "acpi_smbus_read() failed")); | ||
438 | goto end; | ||
439 | } | ||
440 | |||
441 | end: | ||
442 | |||
443 | return result; | ||
444 | } | ||
445 | |||
446 | static int acpi_battery_set_alarm(struct acpi_battery *battery, | ||
447 | unsigned long alarm) | ||
448 | { | ||
449 | int result = 0; | ||
450 | s16 battery_mode; | ||
451 | int foo; | ||
452 | 230 | ||
453 | result = acpi_battery_select(battery); | 231 | if (time_before(jiffies, battery->update_time + |
454 | if (result) { | 232 | msecs_to_jiffies(cache_time))) |
455 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | 233 | return 0; |
456 | "acpi_battery_select() failed")); | 234 | for (i = 0; i < ARRAY_SIZE(state_readers); ++i) { |
457 | goto end; | 235 | result = acpi_smbus_read(battery->sbs->hc, |
458 | } | 236 | state_readers[i].mode, |
459 | 237 | ACPI_SBS_BATTERY, | |
460 | /* If necessary, enable the alarm */ | 238 | state_readers[i].command, |
461 | 239 | (u8 *)battery + | |
462 | if (alarm > 0) { | 240 | state_readers[i].offset); |
463 | result = | 241 | if (result) |
464 | acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x03, | ||
465 | (u8 *)&battery_mode); | ||
466 | if (result) { | ||
467 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
468 | "acpi_smbus_read() failed")); | ||
469 | goto end; | ||
470 | } | ||
471 | |||
472 | battery_mode &= 0xbfff; | ||
473 | result = | ||
474 | acpi_smbus_write(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x01, | ||
475 | (u8 *)&battery_mode, 2); | ||
476 | if (result) { | ||
477 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
478 | "acpi_smbus_write() failed")); | ||
479 | goto end; | 242 | goto end; |
480 | } | ||
481 | } | 243 | } |
482 | |||
483 | foo = alarm / (battery->mode ? 10 : 1); | ||
484 | result = acpi_smbus_write(battery->sbs->hc, SMBUS_READ_WORD, ACPI_SB_SMBUS_ADDR, 0x01, | ||
485 | (u8 *)&foo, 2); | ||
486 | if (result) { | ||
487 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
488 | "acpi_smbus_write() failed")); | ||
489 | goto end; | ||
490 | } | ||
491 | |||
492 | end: | 244 | end: |
493 | 245 | battery->update_time = jiffies; | |
494 | return result; | 246 | return result; |
495 | } | 247 | } |
496 | 248 | ||
497 | static int acpi_battery_set_mode(struct acpi_battery *battery) | 249 | static int acpi_battery_get_alarm(struct acpi_battery *battery) |
498 | { | 250 | { |
499 | int result = 0; | 251 | return acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, |
500 | s16 battery_mode; | 252 | ACPI_SBS_BATTERY, 0x01, |
501 | 253 | (u8 *) & battery->alarm_capacity); | |
502 | if (mode == DEF_CAPACITY_UNIT) { | ||
503 | goto end; | ||
504 | } | ||
505 | |||
506 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, | ||
507 | ACPI_SB_SMBUS_ADDR, 0x03, (u8 *)&battery_mode); | ||
508 | if (result) { | ||
509 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
510 | "acpi_smbus_read() failed")); | ||
511 | goto end; | ||
512 | } | ||
513 | |||
514 | if (mode == MAH_CAPACITY_UNIT) { | ||
515 | battery_mode &= 0x7fff; | ||
516 | } else { | ||
517 | battery_mode |= 0x8000; | ||
518 | } | ||
519 | result = acpi_smbus_write(battery->sbs->hc, SMBUS_READ_WORD, | ||
520 | ACPI_SB_SMBUS_ADDR, 0x03, (u8 *)&battery_mode, 2); | ||
521 | if (result) { | ||
522 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
523 | "acpi_smbus_write() failed")); | ||
524 | goto end; | ||
525 | } | ||
526 | |||
527 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, | ||
528 | ACPI_SB_SMBUS_ADDR, 0x03, (u8 *)&battery_mode); | ||
529 | if (result) { | ||
530 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
531 | "acpi_smbus_read() failed")); | ||
532 | goto end; | ||
533 | } | ||
534 | |||
535 | end: | ||
536 | return result; | ||
537 | } | 254 | } |
538 | 255 | ||
539 | static int acpi_battery_init(struct acpi_battery *battery) | 256 | static int acpi_battery_set_alarm(struct acpi_battery *battery) |
540 | { | 257 | { |
541 | int result = 0; | 258 | struct acpi_sbs *sbs = battery->sbs; |
542 | 259 | u16 value; | |
543 | result = acpi_battery_select(battery); | 260 | return 0; |
544 | if (result) { | ||
545 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
546 | "acpi_battery_select() failed")); | ||
547 | goto end; | ||
548 | } | ||
549 | |||
550 | result = acpi_battery_set_mode(battery); | ||
551 | if (result) { | ||
552 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
553 | "acpi_battery_set_mode() failed")); | ||
554 | goto end; | ||
555 | } | ||
556 | |||
557 | result = acpi_battery_get_info(battery); | ||
558 | if (result) { | ||
559 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
560 | "acpi_battery_get_info() failed")); | ||
561 | goto end; | ||
562 | } | ||
563 | |||
564 | result = acpi_battery_get_state(battery); | ||
565 | if (result) { | ||
566 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
567 | "acpi_battery_get_state() failed")); | ||
568 | goto end; | ||
569 | } | ||
570 | 261 | ||
571 | result = acpi_battery_get_alarm(battery); | 262 | if (sbs->manager_present) { |
572 | if (result) { | 263 | acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_MANAGER, |
573 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | 264 | 0x01, (u8 *)&value); |
574 | "acpi_battery_get_alarm() failed")); | 265 | value &= 0x0fff; |
575 | goto end; | 266 | value |= 1 << (battery->id + 12); |
267 | acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD, ACPI_SBS_MANAGER, | ||
268 | 0x01, (u8 *)&value, 2); | ||
576 | } | 269 | } |
577 | 270 | value = battery->alarm_capacity / (acpi_battery_mode(battery) ? 10 : 1); | |
578 | end: | 271 | return acpi_smbus_write(sbs->hc, SMBUS_WRITE_WORD, ACPI_SBS_BATTERY, |
579 | return result; | 272 | 0x01, (u8 *)&value, 2); |
580 | } | 273 | } |
581 | 274 | ||
582 | static int acpi_ac_get_present(struct acpi_sbs *sbs) | 275 | static int acpi_ac_get_present(struct acpi_sbs *sbs) |
583 | { | 276 | { |
584 | int result = 0; | 277 | int result; |
585 | s16 charger_status; | 278 | u16 status; |
586 | |||
587 | result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBC_SMBUS_ADDR, 0x13, | ||
588 | (u8 *)&charger_status); | ||
589 | |||
590 | if (result) { | ||
591 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
592 | "acpi_smbus_read() failed")); | ||
593 | goto end; | ||
594 | } | ||
595 | |||
596 | sbs->charger_present = (charger_status & 0x8000) >> 15; | ||
597 | |||
598 | end: | ||
599 | 279 | ||
280 | result = acpi_smbus_read(sbs->hc, SMBUS_READ_WORD, ACPI_SBS_CHARGER, | ||
281 | 0x13, (u8 *) & status); | ||
282 | if (!result) | ||
283 | sbs->charger_present = (status >> 15) & 0x1; | ||
600 | return result; | 284 | return result; |
601 | } | 285 | } |
602 | 286 | ||
@@ -607,7 +291,7 @@ static int acpi_ac_get_present(struct acpi_sbs *sbs) | |||
607 | /* Generic Routines */ | 291 | /* Generic Routines */ |
608 | 292 | ||
609 | static int | 293 | static int |
610 | acpi_sbs_generic_add_fs(struct proc_dir_entry **dir, | 294 | acpi_sbs_add_fs(struct proc_dir_entry **dir, |
611 | struct proc_dir_entry *parent_dir, | 295 | struct proc_dir_entry *parent_dir, |
612 | char *dir_name, | 296 | char *dir_name, |
613 | struct file_operations *info_fops, | 297 | struct file_operations *info_fops, |
@@ -669,7 +353,7 @@ acpi_sbs_generic_add_fs(struct proc_dir_entry **dir, | |||
669 | } | 353 | } |
670 | 354 | ||
671 | static void | 355 | static void |
672 | acpi_sbs_generic_remove_fs(struct proc_dir_entry **dir, | 356 | acpi_sbs_remove_fs(struct proc_dir_entry **dir, |
673 | struct proc_dir_entry *parent_dir) | 357 | struct proc_dir_entry *parent_dir) |
674 | { | 358 | { |
675 | 359 | ||
@@ -687,75 +371,47 @@ acpi_sbs_generic_remove_fs(struct proc_dir_entry **dir, | |||
687 | 371 | ||
688 | static struct proc_dir_entry *acpi_battery_dir = NULL; | 372 | static struct proc_dir_entry *acpi_battery_dir = NULL; |
689 | 373 | ||
374 | static inline char *acpi_battery_units(struct acpi_battery *battery) | ||
375 | { | ||
376 | return acpi_battery_mode(battery) ? " mWh" : " mAh"; | ||
377 | } | ||
378 | |||
379 | |||
690 | static int acpi_battery_read_info(struct seq_file *seq, void *offset) | 380 | static int acpi_battery_read_info(struct seq_file *seq, void *offset) |
691 | { | 381 | { |
692 | struct acpi_battery *battery = seq->private; | 382 | struct acpi_battery *battery = seq->private; |
693 | struct acpi_sbs *sbs = battery->sbs; | 383 | struct acpi_sbs *sbs = battery->sbs; |
694 | int cscale; | ||
695 | int result = 0; | 384 | int result = 0; |
696 | 385 | ||
697 | if (sbs_mutex_lock(sbs)) { | 386 | mutex_lock(&sbs->lock); |
698 | return -ENODEV; | ||
699 | } | ||
700 | 387 | ||
701 | result = acpi_check_update_proc(sbs); | 388 | seq_printf(seq, "present: %s\n", |
702 | if (result) | 389 | (battery->present) ? "yes" : "no"); |
390 | if (!battery->present) | ||
703 | goto end; | 391 | goto end; |
704 | 392 | ||
705 | if (update_time == 0) { | ||
706 | result = acpi_sbs_update_run(sbs, battery->id, DATA_TYPE_INFO); | ||
707 | if (result) { | ||
708 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
709 | "acpi_sbs_update_run() failed")); | ||
710 | } | ||
711 | } | ||
712 | |||
713 | if (battery->present) { | ||
714 | seq_printf(seq, "present: yes\n"); | ||
715 | } else { | ||
716 | seq_printf(seq, "present: no\n"); | ||
717 | goto end; | ||
718 | } | ||
719 | |||
720 | if (battery->mode) { | ||
721 | cscale = battery->vscale * battery->ipscale; | ||
722 | } else { | ||
723 | cscale = battery->ipscale; | ||
724 | } | ||
725 | seq_printf(seq, "design capacity: %i%s\n", | 393 | seq_printf(seq, "design capacity: %i%s\n", |
726 | battery->design_capacity * cscale, | 394 | battery->design_capacity * acpi_battery_scale(battery), |
727 | battery->mode ? "0 mWh" : " mAh"); | 395 | acpi_battery_units(battery)); |
728 | |||
729 | seq_printf(seq, "last full capacity: %i%s\n", | 396 | seq_printf(seq, "last full capacity: %i%s\n", |
730 | battery->full_charge_capacity * cscale, | 397 | battery->full_charge_capacity * acpi_battery_scale(battery), |
731 | battery->mode ? "0 mWh" : " mAh"); | 398 | acpi_battery_units(battery)); |
732 | |||
733 | seq_printf(seq, "battery technology: rechargeable\n"); | 399 | seq_printf(seq, "battery technology: rechargeable\n"); |
734 | |||
735 | seq_printf(seq, "design voltage: %i mV\n", | 400 | seq_printf(seq, "design voltage: %i mV\n", |
736 | battery->design_voltage * battery->vscale); | 401 | battery->design_voltage * acpi_battery_vscale(battery)); |
737 | |||
738 | seq_printf(seq, "design capacity warning: unknown\n"); | 402 | seq_printf(seq, "design capacity warning: unknown\n"); |
739 | seq_printf(seq, "design capacity low: unknown\n"); | 403 | seq_printf(seq, "design capacity low: unknown\n"); |
740 | seq_printf(seq, "capacity granularity 1: unknown\n"); | 404 | seq_printf(seq, "capacity granularity 1: unknown\n"); |
741 | seq_printf(seq, "capacity granularity 2: unknown\n"); | 405 | seq_printf(seq, "capacity granularity 2: unknown\n"); |
742 | 406 | seq_printf(seq, "model number: %s\n", battery->device_name); | |
743 | seq_printf(seq, "model number: %s\n", | ||
744 | battery->device_name); | ||
745 | |||
746 | seq_printf(seq, "serial number: %i\n", | 407 | seq_printf(seq, "serial number: %i\n", |
747 | battery->serial_number); | 408 | battery->serial_number); |
748 | |||
749 | seq_printf(seq, "battery type: %s\n", | 409 | seq_printf(seq, "battery type: %s\n", |
750 | battery->device_chemistry); | 410 | battery->device_chemistry); |
751 | |||
752 | seq_printf(seq, "OEM info: %s\n", | 411 | seq_printf(seq, "OEM info: %s\n", |
753 | battery->manufacturer_name); | 412 | battery->manufacturer_name); |
754 | |||
755 | end: | 413 | end: |
756 | 414 | mutex_unlock(&sbs->lock); | |
757 | sbs_mutex_unlock(sbs); | ||
758 | |||
759 | return result; | 415 | return result; |
760 | } | 416 | } |
761 | 417 | ||
@@ -769,73 +425,29 @@ static int acpi_battery_read_state(struct seq_file *seq, void *offset) | |||
769 | struct acpi_battery *battery = seq->private; | 425 | struct acpi_battery *battery = seq->private; |
770 | struct acpi_sbs *sbs = battery->sbs; | 426 | struct acpi_sbs *sbs = battery->sbs; |
771 | int result = 0; | 427 | int result = 0; |
772 | int cscale; | ||
773 | int foo; | ||
774 | |||
775 | if (sbs_mutex_lock(sbs)) { | ||
776 | return -ENODEV; | ||
777 | } | ||
778 | |||
779 | result = acpi_check_update_proc(sbs); | ||
780 | if (result) | ||
781 | goto end; | ||
782 | |||
783 | if (update_time == 0) { | ||
784 | result = acpi_sbs_update_run(sbs, battery->id, DATA_TYPE_STATE); | ||
785 | if (result) { | ||
786 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
787 | "acpi_sbs_update_run() failed")); | ||
788 | } | ||
789 | } | ||
790 | 428 | ||
791 | if (battery->present) { | 429 | mutex_lock(&sbs->lock); |
792 | seq_printf(seq, "present: yes\n"); | 430 | seq_printf(seq, "present: %s\n", |
793 | } else { | 431 | (battery->present) ? "yes" : "no"); |
794 | seq_printf(seq, "present: no\n"); | 432 | if (!battery->present) |
795 | goto end; | 433 | goto end; |
796 | } | ||
797 | |||
798 | if (battery->mode) { | ||
799 | cscale = battery->vscale * battery->ipscale; | ||
800 | } else { | ||
801 | cscale = battery->ipscale; | ||
802 | } | ||
803 | |||
804 | if (battery->state & 0x0010) { | ||
805 | seq_printf(seq, "capacity state: critical\n"); | ||
806 | } else { | ||
807 | seq_printf(seq, "capacity state: ok\n"); | ||
808 | } | ||
809 | |||
810 | foo = (s16) battery->current_now * battery->ipscale; | ||
811 | if (battery->mode) { | ||
812 | foo = foo * battery->design_voltage / 1000; | ||
813 | } | ||
814 | if (battery->current_now < 0) { | ||
815 | seq_printf(seq, "charging state: discharging\n"); | ||
816 | seq_printf(seq, "present rate: %d %s\n", | ||
817 | -foo, battery->mode ? "mW" : "mA"); | ||
818 | } else if (battery->current_now > 0) { | ||
819 | seq_printf(seq, "charging state: charging\n"); | ||
820 | seq_printf(seq, "present rate: %d %s\n", | ||
821 | foo, battery->mode ? "mW" : "mA"); | ||
822 | } else { | ||
823 | seq_printf(seq, "charging state: charged\n"); | ||
824 | seq_printf(seq, "present rate: 0 %s\n", | ||
825 | battery->mode ? "mW" : "mA"); | ||
826 | } | ||
827 | 434 | ||
435 | acpi_battery_get_state(battery); | ||
436 | seq_printf(seq, "capacity state: %s\n", | ||
437 | (battery->state & 0x0010) ? "critical" : "ok"); | ||
438 | seq_printf(seq, "charging state: %s\n", | ||
439 | (battery->current_now < 0) ? "discharging" : | ||
440 | ((battery->current_now > 0) ? "charging" : "charged")); | ||
441 | seq_printf(seq, "present rate: %d mA\n", | ||
442 | abs(battery->current_now) * acpi_battery_ipscale(battery)); | ||
828 | seq_printf(seq, "remaining capacity: %i%s\n", | 443 | seq_printf(seq, "remaining capacity: %i%s\n", |
829 | battery->capacity_now * cscale, | 444 | battery->capacity_now * acpi_battery_scale(battery), |
830 | battery->mode ? "0 mWh" : " mAh"); | 445 | acpi_battery_units(battery)); |
831 | |||
832 | seq_printf(seq, "present voltage: %i mV\n", | 446 | seq_printf(seq, "present voltage: %i mV\n", |
833 | battery->voltage_now * battery->vscale); | 447 | battery->voltage_now * acpi_battery_vscale(battery)); |
834 | 448 | ||
835 | end: | 449 | end: |
836 | 450 | mutex_unlock(&sbs->lock); | |
837 | sbs_mutex_unlock(sbs); | ||
838 | |||
839 | return result; | 451 | return result; |
840 | } | 452 | } |
841 | 453 | ||
@@ -849,48 +461,25 @@ static int acpi_battery_read_alarm(struct seq_file *seq, void *offset) | |||
849 | struct acpi_battery *battery = seq->private; | 461 | struct acpi_battery *battery = seq->private; |
850 | struct acpi_sbs *sbs = battery->sbs; | 462 | struct acpi_sbs *sbs = battery->sbs; |
851 | int result = 0; | 463 | int result = 0; |
852 | int cscale; | ||
853 | |||
854 | if (sbs_mutex_lock(sbs)) { | ||
855 | return -ENODEV; | ||
856 | } | ||
857 | 464 | ||
858 | result = acpi_check_update_proc(sbs); | 465 | mutex_lock(&sbs->lock); |
859 | if (result) | ||
860 | goto end; | ||
861 | |||
862 | if (update_time == 0) { | ||
863 | result = acpi_sbs_update_run(sbs, battery->id, DATA_TYPE_ALARM); | ||
864 | if (result) { | ||
865 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
866 | "acpi_sbs_update_run() failed")); | ||
867 | } | ||
868 | } | ||
869 | 466 | ||
870 | if (!battery->present) { | 467 | if (!battery->present) { |
871 | seq_printf(seq, "present: no\n"); | 468 | seq_printf(seq, "present: no\n"); |
872 | goto end; | 469 | goto end; |
873 | } | 470 | } |
874 | 471 | ||
875 | if (battery->mode) { | 472 | acpi_battery_get_alarm(battery); |
876 | cscale = battery->vscale * battery->ipscale; | ||
877 | } else { | ||
878 | cscale = battery->ipscale; | ||
879 | } | ||
880 | |||
881 | seq_printf(seq, "alarm: "); | 473 | seq_printf(seq, "alarm: "); |
882 | if (battery->alarm_capacity) { | 474 | if (battery->alarm_capacity) |
883 | seq_printf(seq, "%i%s\n", | 475 | seq_printf(seq, "%i%s\n", |
884 | battery->alarm_capacity * cscale, | 476 | battery->alarm_capacity * |
885 | battery->mode ? "0 mWh" : " mAh"); | 477 | acpi_battery_scale(battery), |
886 | } else { | 478 | acpi_battery_units(battery)); |
479 | else | ||
887 | seq_printf(seq, "disabled\n"); | 480 | seq_printf(seq, "disabled\n"); |
888 | } | ||
889 | |||
890 | end: | 481 | end: |
891 | 482 | mutex_unlock(&sbs->lock); | |
892 | sbs_mutex_unlock(sbs); | ||
893 | |||
894 | return result; | 483 | return result; |
895 | } | 484 | } |
896 | 485 | ||
@@ -902,59 +491,28 @@ acpi_battery_write_alarm(struct file *file, const char __user * buffer, | |||
902 | struct acpi_battery *battery = seq->private; | 491 | struct acpi_battery *battery = seq->private; |
903 | struct acpi_sbs *sbs = battery->sbs; | 492 | struct acpi_sbs *sbs = battery->sbs; |
904 | char alarm_string[12] = { '\0' }; | 493 | char alarm_string[12] = { '\0' }; |
905 | int result, old_alarm, new_alarm; | 494 | int result = 0; |
906 | 495 | mutex_lock(&sbs->lock); | |
907 | if (sbs_mutex_lock(sbs)) { | ||
908 | return -ENODEV; | ||
909 | } | ||
910 | |||
911 | result = acpi_check_update_proc(sbs); | ||
912 | if (result) | ||
913 | goto end; | ||
914 | |||
915 | if (!battery->present) { | 496 | if (!battery->present) { |
916 | result = -ENODEV; | 497 | result = -ENODEV; |
917 | goto end; | 498 | goto end; |
918 | } | 499 | } |
919 | |||
920 | if (count > sizeof(alarm_string) - 1) { | 500 | if (count > sizeof(alarm_string) - 1) { |
921 | result = -EINVAL; | 501 | result = -EINVAL; |
922 | goto end; | 502 | goto end; |
923 | } | 503 | } |
924 | |||
925 | if (copy_from_user(alarm_string, buffer, count)) { | 504 | if (copy_from_user(alarm_string, buffer, count)) { |
926 | result = -EFAULT; | 505 | result = -EFAULT; |
927 | goto end; | 506 | goto end; |
928 | } | 507 | } |
929 | |||
930 | alarm_string[count] = 0; | 508 | alarm_string[count] = 0; |
931 | 509 | battery->alarm_capacity = simple_strtoul(alarm_string, NULL, 0); | |
932 | old_alarm = battery->alarm_capacity; | 510 | acpi_battery_set_alarm(battery); |
933 | new_alarm = simple_strtoul(alarm_string, NULL, 0); | ||
934 | |||
935 | result = acpi_battery_set_alarm(battery, new_alarm); | ||
936 | if (result) { | ||
937 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
938 | "acpi_battery_set_alarm() failed")); | ||
939 | acpi_battery_set_alarm(battery, old_alarm); | ||
940 | goto end; | ||
941 | } | ||
942 | result = acpi_battery_get_alarm(battery); | ||
943 | if (result) { | ||
944 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
945 | "acpi_battery_get_alarm() failed")); | ||
946 | acpi_battery_set_alarm(battery, old_alarm); | ||
947 | goto end; | ||
948 | } | ||
949 | |||
950 | end: | 511 | end: |
951 | sbs_mutex_unlock(sbs); | 512 | mutex_unlock(&sbs->lock); |
952 | 513 | if (result) | |
953 | if (result) { | ||
954 | return result; | 514 | return result; |
955 | } else { | 515 | return count; |
956 | return count; | ||
957 | } | ||
958 | } | 516 | } |
959 | 517 | ||
960 | static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file) | 518 | static int acpi_battery_alarm_open_fs(struct inode *inode, struct file *file) |
@@ -993,26 +551,15 @@ static struct proc_dir_entry *acpi_ac_dir = NULL; | |||
993 | 551 | ||
994 | static int acpi_ac_read_state(struct seq_file *seq, void *offset) | 552 | static int acpi_ac_read_state(struct seq_file *seq, void *offset) |
995 | { | 553 | { |
996 | struct acpi_sbs *sbs = seq->private; | ||
997 | int result; | ||
998 | 554 | ||
999 | if (sbs_mutex_lock(sbs)) { | 555 | struct acpi_sbs *sbs = seq->private; |
1000 | return -ENODEV; | ||
1001 | } | ||
1002 | 556 | ||
1003 | if (update_time == 0) { | 557 | mutex_lock(&sbs->lock); |
1004 | result = acpi_sbs_update_run(sbs, -1, DATA_TYPE_AC_STATE); | ||
1005 | if (result) { | ||
1006 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1007 | "acpi_sbs_update_run() failed")); | ||
1008 | } | ||
1009 | } | ||
1010 | 558 | ||
1011 | seq_printf(seq, "state: %s\n", | 559 | seq_printf(seq, "state: %s\n", |
1012 | sbs->charger_present ? "on-line" : "off-line"); | 560 | sbs->charger_present ? "on-line" : "off-line"); |
1013 | 561 | ||
1014 | sbs_mutex_unlock(sbs); | 562 | mutex_unlock(&sbs->lock); |
1015 | |||
1016 | return 0; | 563 | return 0; |
1017 | } | 564 | } |
1018 | 565 | ||
@@ -1035,67 +582,54 @@ static struct file_operations acpi_ac_state_fops = { | |||
1035 | 582 | ||
1036 | /* Smart Battery */ | 583 | /* Smart Battery */ |
1037 | 584 | ||
1038 | static int acpi_battery_add(struct acpi_sbs *sbs, int id) | 585 | static int acpi_battery_read(struct acpi_battery *battery) |
1039 | { | 586 | { |
1040 | int is_present; | 587 | int result = 0, saved_present = battery->present; |
1041 | int result; | 588 | u16 state; |
1042 | char dir_name[32]; | ||
1043 | struct acpi_battery *battery; | ||
1044 | 589 | ||
1045 | battery = &sbs->battery[id]; | 590 | if (battery->sbs->manager_present) { |
591 | result = acpi_smbus_read(battery->sbs->hc, SMBUS_READ_WORD, | ||
592 | ACPI_SBS_MANAGER, 0x01, (u8 *)&state); | ||
593 | if (!result) | ||
594 | battery->present = state & (1 << battery->id); | ||
595 | state &= 0x0fff; | ||
596 | state |= 1 << (battery->id + 12); | ||
597 | acpi_smbus_write(battery->sbs->hc, SMBUS_WRITE_WORD, | ||
598 | ACPI_SBS_MANAGER, 0x01, (u8 *)&state, 2); | ||
599 | } else if (battery->id == 0) | ||
600 | battery->present = 1; | ||
601 | if (result || !battery->present) | ||
602 | return result; | ||
1046 | 603 | ||
1047 | battery->alive = 0; | 604 | if (saved_present != battery->present) { |
605 | battery->update_time = 0; | ||
606 | result = acpi_battery_get_info(battery); | ||
607 | if (result) | ||
608 | return result; | ||
609 | } | ||
610 | result = acpi_battery_get_state(battery); | ||
611 | return result; | ||
612 | } | ||
1048 | 613 | ||
1049 | battery->init_state = 0; | 614 | static int acpi_battery_add(struct acpi_sbs *sbs, int id) |
615 | { | ||
616 | int result; | ||
617 | struct acpi_battery *battery = &sbs->battery[id]; | ||
1050 | battery->id = id; | 618 | battery->id = id; |
1051 | battery->sbs = sbs; | 619 | battery->sbs = sbs; |
620 | battery->update_time = 0; | ||
621 | result = acpi_battery_read(battery); | ||
622 | if (result) | ||
623 | return result; | ||
1052 | 624 | ||
1053 | result = acpi_battery_select(battery); | 625 | sprintf(battery->name, ACPI_BATTERY_DIR_NAME, id); |
1054 | if (result) { | 626 | acpi_sbs_add_fs(&battery->proc_entry, acpi_battery_dir, |
1055 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | 627 | battery->name, &acpi_battery_info_fops, |
1056 | "acpi_battery_select() failed")); | 628 | &acpi_battery_state_fops, &acpi_battery_alarm_fops, |
1057 | goto end; | 629 | battery); |
1058 | } | ||
1059 | |||
1060 | result = acpi_battery_get_present(battery); | ||
1061 | if (result) { | ||
1062 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1063 | "acpi_battery_get_present() failed")); | ||
1064 | goto end; | ||
1065 | } | ||
1066 | |||
1067 | is_present = battery->present; | ||
1068 | |||
1069 | if (is_present) { | ||
1070 | result = acpi_battery_init(battery); | ||
1071 | if (result) { | ||
1072 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1073 | "acpi_battery_init() failed")); | ||
1074 | goto end; | ||
1075 | } | ||
1076 | battery->init_state = 1; | ||
1077 | } | ||
1078 | |||
1079 | sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id); | ||
1080 | |||
1081 | result = acpi_sbs_generic_add_fs(&battery->proc_entry, | ||
1082 | acpi_battery_dir, | ||
1083 | dir_name, | ||
1084 | &acpi_battery_info_fops, | ||
1085 | &acpi_battery_state_fops, | ||
1086 | &acpi_battery_alarm_fops, battery); | ||
1087 | if (result) { | ||
1088 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1089 | "acpi_sbs_generic_add_fs() failed")); | ||
1090 | goto end; | ||
1091 | } | ||
1092 | battery->alive = 1; | ||
1093 | |||
1094 | printk(KERN_INFO PREFIX "%s [%s]: Battery Slot [%s] (battery %s)\n", | 630 | printk(KERN_INFO PREFIX "%s [%s]: Battery Slot [%s] (battery %s)\n", |
1095 | ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device), dir_name, | 631 | ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device), |
1096 | sbs->battery->present ? "present" : "absent"); | 632 | battery->name, sbs->battery->present ? "present" : "absent"); |
1097 | |||
1098 | end: | ||
1099 | return result; | 633 | return result; |
1100 | } | 634 | } |
1101 | 635 | ||
@@ -1103,354 +637,105 @@ static void acpi_battery_remove(struct acpi_sbs *sbs, int id) | |||
1103 | { | 637 | { |
1104 | 638 | ||
1105 | if (sbs->battery[id].proc_entry) { | 639 | if (sbs->battery[id].proc_entry) { |
1106 | acpi_sbs_generic_remove_fs(&(sbs->battery[id].proc_entry), | 640 | acpi_sbs_remove_fs(&(sbs->battery[id].proc_entry), |
1107 | acpi_battery_dir); | 641 | acpi_battery_dir); |
1108 | } | 642 | } |
1109 | } | 643 | } |
1110 | 644 | ||
1111 | static int acpi_ac_add(struct acpi_sbs *sbs) | 645 | static int acpi_charger_add(struct acpi_sbs *sbs) |
1112 | { | 646 | { |
1113 | int result; | 647 | int result; |
1114 | 648 | ||
1115 | result = acpi_ac_get_present(sbs); | 649 | result = acpi_ac_get_present(sbs); |
1116 | if (result) { | 650 | if (result) |
1117 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1118 | "acpi_ac_get_present() failed")); | ||
1119 | goto end; | 651 | goto end; |
1120 | } | 652 | result = acpi_sbs_add_fs(&sbs->charger_entry, acpi_ac_dir, |
1121 | 653 | ACPI_AC_DIR_NAME, NULL, | |
1122 | result = acpi_sbs_generic_add_fs(&sbs->ac_entry, | 654 | &acpi_ac_state_fops, NULL, sbs); |
1123 | acpi_ac_dir, | 655 | if (result) |
1124 | ACPI_AC_DIR_NAME, | ||
1125 | NULL, &acpi_ac_state_fops, NULL, sbs); | ||
1126 | if (result) { | ||
1127 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1128 | "acpi_sbs_generic_add_fs() failed")); | ||
1129 | goto end; | 656 | goto end; |
1130 | } | ||
1131 | |||
1132 | printk(KERN_INFO PREFIX "%s [%s]: AC Adapter [%s] (%s)\n", | 657 | printk(KERN_INFO PREFIX "%s [%s]: AC Adapter [%s] (%s)\n", |
1133 | ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device), | 658 | ACPI_SBS_DEVICE_NAME, acpi_device_bid(sbs->device), |
1134 | ACPI_AC_DIR_NAME, sbs->charger_present ? "on-line" : "off-line"); | 659 | ACPI_AC_DIR_NAME, sbs->charger_present ? "on-line" : "off-line"); |
1135 | |||
1136 | end: | 660 | end: |
1137 | |||
1138 | return result; | 661 | return result; |
1139 | } | 662 | } |
1140 | 663 | ||
1141 | static void acpi_ac_remove(struct acpi_sbs *sbs) | 664 | static void acpi_charger_remove(struct acpi_sbs *sbs) |
1142 | { | 665 | { |
1143 | 666 | ||
1144 | if (sbs->ac_entry) { | 667 | if (sbs->charger_entry) |
1145 | acpi_sbs_generic_remove_fs(&sbs->ac_entry, acpi_ac_dir); | 668 | acpi_sbs_remove_fs(&sbs->charger_entry, acpi_ac_dir); |
1146 | } | ||
1147 | } | ||
1148 | |||
1149 | static void acpi_sbs_update_time_run(unsigned long data) | ||
1150 | { | ||
1151 | acpi_os_execute(OSL_GPE_HANDLER, acpi_sbs_update_time, (void *)data); | ||
1152 | } | 669 | } |
1153 | 670 | ||
1154 | static int acpi_sbs_update_run(struct acpi_sbs *sbs, int id, int data_type) | 671 | void acpi_sbs_callback(void *context) |
1155 | { | 672 | { |
1156 | struct acpi_battery *battery; | 673 | int id; |
1157 | int result = 0, cnt; | 674 | struct acpi_sbs *sbs = context; |
1158 | int old_ac_present = -1; | 675 | struct acpi_battery *bat; |
1159 | int old_present = -1; | 676 | u8 saved_charger_state = sbs->charger_present; |
1160 | int new_ac_present = -1; | 677 | u8 saved_battery_state; |
1161 | int new_present = -1; | 678 | acpi_ac_get_present(sbs); |
1162 | int id_min = 0, id_max = MAX_SBS_BAT - 1; | 679 | if (sbs->charger_present != saved_charger_state) { |
1163 | char dir_name[32]; | 680 | acpi_bus_generate_proc_event4(ACPI_AC_CLASS, ACPI_AC_DIR_NAME, |
1164 | int do_battery_init = 0, do_ac_init = 0; | 681 | ACPI_SBS_NOTIFY_STATUS, |
1165 | int old_remaining_capacity = 0; | 682 | sbs->charger_present); |
1166 | int update_battery = 1; | ||
1167 | int up_tm = update_time; | ||
1168 | |||
1169 | if (sbs_zombie(sbs)) { | ||
1170 | goto end; | ||
1171 | } | ||
1172 | |||
1173 | if (id >= 0) { | ||
1174 | id_min = id_max = id; | ||
1175 | } | ||
1176 | |||
1177 | if (data_type == DATA_TYPE_COMMON && up_tm > 0) { | ||
1178 | cnt = up_tm / (up_tm > UPDATE_DELAY ? UPDATE_DELAY : up_tm); | ||
1179 | if (sbs->run_cnt % cnt != 0) { | ||
1180 | update_battery = 0; | ||
1181 | } | ||
1182 | } | ||
1183 | |||
1184 | sbs->run_cnt++; | ||
1185 | |||
1186 | if (!update_battery) { | ||
1187 | goto end; | ||
1188 | } | ||
1189 | |||
1190 | old_ac_present = sbs->charger_present; | ||
1191 | |||
1192 | result = acpi_ac_get_present(sbs); | ||
1193 | if (result) { | ||
1194 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1195 | "acpi_ac_get_present() failed")); | ||
1196 | } | ||
1197 | |||
1198 | new_ac_present = sbs->charger_present; | ||
1199 | |||
1200 | do_ac_init = (old_ac_present != new_ac_present); | ||
1201 | if (sbs->run_cnt == 1 && data_type == DATA_TYPE_COMMON) { | ||
1202 | do_ac_init = 1; | ||
1203 | } | ||
1204 | |||
1205 | if (do_ac_init) { | ||
1206 | result = acpi_bus_generate_proc_event4(ACPI_AC_CLASS, | ||
1207 | ACPI_AC_DIR_NAME, | ||
1208 | ACPI_SBS_AC_NOTIFY_STATUS, | ||
1209 | new_ac_present); | ||
1210 | if (result) { | ||
1211 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1212 | "acpi_bus_generate_event4() failed")); | ||
1213 | } | ||
1214 | acpi_bus_generate_netlink_event(ACPI_AC_CLASS, ACPI_AC_DIR_NAME, | ||
1215 | ACPI_SBS_AC_NOTIFY_STATUS, | ||
1216 | new_ac_present); | ||
1217 | } | ||
1218 | |||
1219 | if (data_type == DATA_TYPE_COMMON) { | ||
1220 | if (!do_ac_init && !update_battery) { | ||
1221 | goto end; | ||
1222 | } | ||
1223 | } | ||
1224 | |||
1225 | if (data_type == DATA_TYPE_AC_STATE && !do_ac_init) { | ||
1226 | goto end; | ||
1227 | } | 683 | } |
1228 | 684 | if (sbs->manager_present) { | |
1229 | for (id = id_min; id <= id_max; id++) { | 685 | for (id = 0; id < MAX_SBS_BAT; ++id) { |
1230 | battery = &sbs->battery[id]; | 686 | if (!(sbs->batteries_supported & (1 << id))) |
1231 | if (battery->alive == 0) { | 687 | continue; |
1232 | continue; | 688 | bat = &sbs->battery[id]; |
1233 | } | 689 | saved_battery_state = bat->present; |
1234 | 690 | acpi_battery_read(bat); | |
1235 | old_remaining_capacity = battery->capacity_now; | 691 | if (saved_battery_state == bat->present) |
1236 | 692 | continue; | |
1237 | old_present = battery->present; | 693 | acpi_bus_generate_proc_event4(ACPI_BATTERY_CLASS, |
1238 | 694 | bat->name, | |
1239 | result = acpi_battery_select(battery); | 695 | ACPI_SBS_NOTIFY_STATUS, |
1240 | if (result) { | 696 | bat->present); |
1241 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1242 | "acpi_battery_select() failed")); | ||
1243 | } | ||
1244 | |||
1245 | result = acpi_battery_get_present(battery); | ||
1246 | if (result) { | ||
1247 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1248 | "acpi_battery_get_present() failed")); | ||
1249 | } | ||
1250 | |||
1251 | new_present = battery->present; | ||
1252 | |||
1253 | do_battery_init = ((old_present != new_present) | ||
1254 | && new_present); | ||
1255 | if (!new_present) | ||
1256 | goto event; | ||
1257 | if (do_ac_init || do_battery_init) { | ||
1258 | result = acpi_battery_init(battery); | ||
1259 | if (result) { | ||
1260 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1261 | "acpi_battery_init() " | ||
1262 | "failed")); | ||
1263 | } | ||
1264 | } | ||
1265 | if (sbs_zombie(sbs)) { | ||
1266 | goto end; | ||
1267 | } | ||
1268 | |||
1269 | if ((data_type == DATA_TYPE_COMMON | ||
1270 | || data_type == DATA_TYPE_INFO) | ||
1271 | && new_present) { | ||
1272 | result = acpi_battery_get_info(battery); | ||
1273 | if (result) { | ||
1274 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1275 | "acpi_battery_get_info() failed")); | ||
1276 | } | ||
1277 | } | ||
1278 | if (data_type == DATA_TYPE_INFO) { | ||
1279 | continue; | ||
1280 | } | ||
1281 | if (sbs_zombie(sbs)) { | ||
1282 | goto end; | ||
1283 | } | ||
1284 | |||
1285 | if ((data_type == DATA_TYPE_COMMON | ||
1286 | || data_type == DATA_TYPE_STATE) | ||
1287 | && new_present) { | ||
1288 | result = acpi_battery_get_state(battery); | ||
1289 | if (result) { | ||
1290 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1291 | "acpi_battery_get_state() failed")); | ||
1292 | } | ||
1293 | } | ||
1294 | if (data_type == DATA_TYPE_STATE) { | ||
1295 | goto event; | ||
1296 | } | ||
1297 | if (sbs_zombie(sbs)) { | ||
1298 | goto end; | ||
1299 | } | ||
1300 | |||
1301 | if ((data_type == DATA_TYPE_COMMON | ||
1302 | || data_type == DATA_TYPE_ALARM) | ||
1303 | && new_present) { | ||
1304 | result = acpi_battery_get_alarm(battery); | ||
1305 | if (result) { | ||
1306 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1307 | "acpi_battery_get_alarm() " | ||
1308 | "failed")); | ||
1309 | } | ||
1310 | } | ||
1311 | if (data_type == DATA_TYPE_ALARM) { | ||
1312 | continue; | ||
1313 | } | ||
1314 | if (sbs_zombie(sbs)) { | ||
1315 | goto end; | ||
1316 | } | ||
1317 | |||
1318 | event: | ||
1319 | |||
1320 | if (old_present != new_present || do_ac_init || | ||
1321 | old_remaining_capacity != | ||
1322 | battery->capacity_now) { | ||
1323 | sprintf(dir_name, ACPI_BATTERY_DIR_NAME, id); | ||
1324 | result = acpi_bus_generate_proc_event4(ACPI_BATTERY_CLASS, | ||
1325 | dir_name, | ||
1326 | ACPI_SBS_BATTERY_NOTIFY_STATUS, | ||
1327 | new_present); | ||
1328 | acpi_bus_generate_netlink_event(ACPI_BATTERY_CLASS, dir_name, | ||
1329 | ACPI_SBS_BATTERY_NOTIFY_STATUS, | ||
1330 | new_present); | ||
1331 | if (result) { | ||
1332 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1333 | "acpi_bus_generate_proc_event4() " | ||
1334 | "failed")); | ||
1335 | } | ||
1336 | } | 697 | } |
1337 | } | 698 | } |
1338 | |||
1339 | end: | ||
1340 | |||
1341 | return result; | ||
1342 | } | 699 | } |
1343 | 700 | ||
1344 | static void acpi_sbs_update_time(void *data) | 701 | static int acpi_sbs_remove(struct acpi_device *device, int type); |
1345 | { | ||
1346 | struct acpi_sbs *sbs = data; | ||
1347 | unsigned long delay = -1; | ||
1348 | int result; | ||
1349 | unsigned int up_tm = update_time; | ||
1350 | |||
1351 | if (sbs_mutex_lock(sbs)) | ||
1352 | return; | ||
1353 | |||
1354 | result = acpi_sbs_update_run(sbs, -1, DATA_TYPE_COMMON); | ||
1355 | if (result) { | ||
1356 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1357 | "acpi_sbs_update_run() failed")); | ||
1358 | } | ||
1359 | |||
1360 | if (sbs_zombie(sbs)) { | ||
1361 | goto end; | ||
1362 | } | ||
1363 | |||
1364 | if (!up_tm) { | ||
1365 | if (timer_pending(&sbs->update_timer)) | ||
1366 | del_timer(&sbs->update_timer); | ||
1367 | } else { | ||
1368 | delay = (up_tm > UPDATE_DELAY ? UPDATE_DELAY : up_tm); | ||
1369 | delay = jiffies + HZ * delay; | ||
1370 | if (timer_pending(&sbs->update_timer)) { | ||
1371 | mod_timer(&sbs->update_timer, delay); | ||
1372 | } else { | ||
1373 | sbs->update_timer.data = (unsigned long)data; | ||
1374 | sbs->update_timer.function = acpi_sbs_update_time_run; | ||
1375 | sbs->update_timer.expires = delay; | ||
1376 | add_timer(&sbs->update_timer); | ||
1377 | } | ||
1378 | } | ||
1379 | |||
1380 | end: | ||
1381 | |||
1382 | sbs_mutex_unlock(sbs); | ||
1383 | } | ||
1384 | 702 | ||
1385 | static int acpi_sbs_add(struct acpi_device *device) | 703 | static int acpi_sbs_add(struct acpi_device *device) |
1386 | { | 704 | { |
1387 | struct acpi_sbs *sbs = NULL; | 705 | struct acpi_sbs *sbs; |
1388 | int result = 0, remove_result = 0; | 706 | int result = 0; |
1389 | int id; | 707 | int id; |
1390 | 708 | ||
1391 | sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL); | 709 | sbs = kzalloc(sizeof(struct acpi_sbs), GFP_KERNEL); |
1392 | if (!sbs) { | 710 | if (!sbs) { |
1393 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, "kzalloc() failed")); | ||
1394 | result = -ENOMEM; | 711 | result = -ENOMEM; |
1395 | goto end; | 712 | goto end; |
1396 | } | 713 | } |
1397 | 714 | ||
1398 | mutex_init(&sbs->mutex); | 715 | mutex_init(&sbs->lock); |
1399 | |||
1400 | sbs_mutex_lock(sbs); | ||
1401 | 716 | ||
1402 | sbs->device = device; | ||
1403 | sbs->hc = acpi_driver_data(device->parent); | 717 | sbs->hc = acpi_driver_data(device->parent); |
1404 | 718 | sbs->device = device; | |
1405 | strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME); | 719 | strcpy(acpi_device_name(device), ACPI_SBS_DEVICE_NAME); |
1406 | strcpy(acpi_device_class(device), ACPI_SBS_CLASS); | 720 | strcpy(acpi_device_class(device), ACPI_SBS_CLASS); |
1407 | acpi_driver_data(device) = sbs; | 721 | acpi_driver_data(device) = sbs; |
1408 | 722 | ||
1409 | result = acpi_ac_add(sbs); | 723 | result = acpi_charger_add(sbs); |
1410 | if (result) { | ||
1411 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, "acpi_ac_add() failed")); | ||
1412 | goto end; | ||
1413 | } | ||
1414 | |||
1415 | acpi_sbsm_get_info(sbs); | ||
1416 | |||
1417 | if (!sbs->manager_present) { | ||
1418 | result = acpi_battery_add(sbs, 0); | ||
1419 | if (result) { | ||
1420 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1421 | "acpi_battery_add() failed")); | ||
1422 | goto end; | ||
1423 | } | ||
1424 | } else { | ||
1425 | for (id = 0; id < MAX_SBS_BAT; id++) { | ||
1426 | if ((sbs->batteries_supported & (1 << id))) { | ||
1427 | result = acpi_battery_add(sbs, id); | ||
1428 | if (result) { | ||
1429 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1430 | "acpi_battery_add() failed")); | ||
1431 | goto end; | ||
1432 | } | ||
1433 | } | ||
1434 | } | ||
1435 | } | ||
1436 | |||
1437 | init_timer(&sbs->update_timer); | ||
1438 | result = acpi_check_update_proc(sbs); | ||
1439 | if (result) | 724 | if (result) |
1440 | goto end; | 725 | goto end; |
1441 | 726 | ||
727 | result = acpi_manager_get_info(sbs); | ||
728 | if (!result) { | ||
729 | sbs->manager_present = 1; | ||
730 | for (id = 0; id < MAX_SBS_BAT; ++id) | ||
731 | if ((sbs->batteries_supported & (1 << id))) | ||
732 | acpi_battery_add(sbs, id); | ||
733 | } else | ||
734 | acpi_battery_add(sbs, 0); | ||
735 | acpi_smbus_register_callback(sbs->hc, acpi_sbs_callback, sbs); | ||
1442 | end: | 736 | end: |
1443 | 737 | if (result) | |
1444 | sbs_mutex_unlock(sbs); | 738 | acpi_sbs_remove(device, 0); |
1445 | |||
1446 | if (result) { | ||
1447 | remove_result = acpi_sbs_remove(device, 0); | ||
1448 | if (remove_result) { | ||
1449 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1450 | "acpi_sbs_remove() failed")); | ||
1451 | } | ||
1452 | } | ||
1453 | |||
1454 | return result; | 739 | return result; |
1455 | } | 740 | } |
1456 | 741 | ||
@@ -1459,34 +744,19 @@ static int acpi_sbs_remove(struct acpi_device *device, int type) | |||
1459 | struct acpi_sbs *sbs; | 744 | struct acpi_sbs *sbs; |
1460 | int id; | 745 | int id; |
1461 | 746 | ||
1462 | if (!device) { | 747 | if (!device) |
1463 | return -EINVAL; | 748 | return -EINVAL; |
1464 | } | ||
1465 | |||
1466 | sbs = acpi_driver_data(device); | 749 | sbs = acpi_driver_data(device); |
1467 | if (!sbs) { | 750 | if (!sbs) |
1468 | return -EINVAL; | 751 | return -EINVAL; |
1469 | } | 752 | mutex_lock(&sbs->lock); |
1470 | 753 | acpi_smbus_unregister_callback(sbs->hc); | |
1471 | sbs_mutex_lock(sbs); | 754 | for (id = 0; id < MAX_SBS_BAT; ++id) |
1472 | |||
1473 | sbs->zombie = 1; | ||
1474 | del_timer_sync(&sbs->update_timer); | ||
1475 | acpi_os_wait_events_complete(NULL); | ||
1476 | del_timer_sync(&sbs->update_timer); | ||
1477 | |||
1478 | for (id = 0; id < MAX_SBS_BAT; id++) { | ||
1479 | acpi_battery_remove(sbs, id); | 755 | acpi_battery_remove(sbs, id); |
1480 | } | 756 | acpi_charger_remove(sbs); |
1481 | 757 | mutex_unlock(&sbs->lock); | |
1482 | acpi_ac_remove(sbs); | 758 | mutex_destroy(&sbs->lock); |
1483 | |||
1484 | sbs_mutex_unlock(sbs); | ||
1485 | |||
1486 | mutex_destroy(&sbs->mutex); | ||
1487 | |||
1488 | kfree(sbs); | 759 | kfree(sbs); |
1489 | |||
1490 | return 0; | 760 | return 0; |
1491 | } | 761 | } |
1492 | 762 | ||
@@ -1505,14 +775,10 @@ static void acpi_sbs_rmdirs(void) | |||
1505 | static int acpi_sbs_resume(struct acpi_device *device) | 775 | static int acpi_sbs_resume(struct acpi_device *device) |
1506 | { | 776 | { |
1507 | struct acpi_sbs *sbs; | 777 | struct acpi_sbs *sbs; |
1508 | |||
1509 | if (!device) | 778 | if (!device) |
1510 | return -EINVAL; | 779 | return -EINVAL; |
1511 | |||
1512 | sbs = device->driver_data; | 780 | sbs = device->driver_data; |
1513 | 781 | acpi_sbs_callback(sbs); | |
1514 | sbs->run_cnt = 0; | ||
1515 | |||
1516 | return 0; | 782 | return 0; |
1517 | } | 783 | } |
1518 | 784 | ||
@@ -1523,14 +789,6 @@ static int __init acpi_sbs_init(void) | |||
1523 | if (acpi_disabled) | 789 | if (acpi_disabled) |
1524 | return -ENODEV; | 790 | return -ENODEV; |
1525 | 791 | ||
1526 | if (mode != DEF_CAPACITY_UNIT | ||
1527 | && mode != MAH_CAPACITY_UNIT | ||
1528 | && mode != MWH_CAPACITY_UNIT) { | ||
1529 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | ||
1530 | "invalid mode = %d", mode)); | ||
1531 | return -EINVAL; | ||
1532 | } | ||
1533 | |||
1534 | acpi_ac_dir = acpi_lock_ac_dir(); | 792 | acpi_ac_dir = acpi_lock_ac_dir(); |
1535 | if (!acpi_ac_dir) { | 793 | if (!acpi_ac_dir) { |
1536 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, | 794 | ACPI_EXCEPTION((AE_INFO, AE_ERROR, |