wm97xx_battery: Use irq to detect charger state
[linux-2.6.git] / drivers / power / wm8350_power.c
1 /*
2  * Battery driver for wm8350 PMIC
3  *
4  * Copyright 2007, 2008 Wolfson Microelectronics PLC.
5  *
6  * Based on OLPC Battery Driver
7  *
8  * Copyright 2006  David Woodhouse <dwmw2@infradead.org>
9  *
10  * This program is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License version 2 as
12  * published by the Free Software Foundation.
13  */
14
15 #include <linux/module.h>
16 #include <linux/err.h>
17 #include <linux/platform_device.h>
18 #include <linux/power_supply.h>
19 #include <linux/mfd/wm8350/supply.h>
20 #include <linux/mfd/wm8350/core.h>
21 #include <linux/mfd/wm8350/comparator.h>
22
23 static int wm8350_read_battery_uvolts(struct wm8350 *wm8350)
24 {
25         return wm8350_read_auxadc(wm8350, WM8350_AUXADC_BATT, 0, 0)
26                 * WM8350_AUX_COEFF;
27 }
28
29 static int wm8350_read_line_uvolts(struct wm8350 *wm8350)
30 {
31         return wm8350_read_auxadc(wm8350, WM8350_AUXADC_LINE, 0, 0)
32                 * WM8350_AUX_COEFF;
33 }
34
35 static int wm8350_read_usb_uvolts(struct wm8350 *wm8350)
36 {
37         return wm8350_read_auxadc(wm8350, WM8350_AUXADC_USB, 0, 0)
38                 * WM8350_AUX_COEFF;
39 }
40
41 #define WM8350_BATT_SUPPLY      1
42 #define WM8350_USB_SUPPLY       2
43 #define WM8350_LINE_SUPPLY      4
44
45 static inline int wm8350_charge_time_min(struct wm8350 *wm8350, int min)
46 {
47         if (!wm8350->power.rev_g_coeff)
48                 return (((min - 30) / 15) & 0xf) << 8;
49         else
50                 return (((min - 30) / 30) & 0xf) << 8;
51 }
52
53 static int wm8350_get_supplies(struct wm8350 *wm8350)
54 {
55         u16 sm, ov, co, chrg;
56         int supplies = 0;
57
58         sm = wm8350_reg_read(wm8350, WM8350_STATE_MACHINE_STATUS);
59         ov = wm8350_reg_read(wm8350, WM8350_MISC_OVERRIDES);
60         co = wm8350_reg_read(wm8350, WM8350_COMPARATOR_OVERRIDES);
61         chrg = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2);
62
63         /* USB_SM */
64         sm = (sm & WM8350_USB_SM_MASK) >> WM8350_USB_SM_SHIFT;
65
66         /* CHG_ISEL */
67         chrg &= WM8350_CHG_ISEL_MASK;
68
69         /* If the USB state machine is active then we're using that with or
70          * without battery, otherwise check for wall supply */
71         if (((sm == WM8350_USB_SM_100_SLV) ||
72              (sm == WM8350_USB_SM_500_SLV) ||
73              (sm == WM8350_USB_SM_STDBY_SLV))
74             && !(ov & WM8350_USB_LIMIT_OVRDE))
75                 supplies = WM8350_USB_SUPPLY;
76         else if (((sm == WM8350_USB_SM_100_SLV) ||
77                   (sm == WM8350_USB_SM_500_SLV) ||
78                   (sm == WM8350_USB_SM_STDBY_SLV))
79                  && (ov & WM8350_USB_LIMIT_OVRDE) && (chrg == 0))
80                 supplies = WM8350_USB_SUPPLY | WM8350_BATT_SUPPLY;
81         else if (co & WM8350_WALL_FB_OVRDE)
82                 supplies = WM8350_LINE_SUPPLY;
83         else
84                 supplies = WM8350_BATT_SUPPLY;
85
86         return supplies;
87 }
88
89 static int wm8350_charger_config(struct wm8350 *wm8350,
90                                  struct wm8350_charger_policy *policy)
91 {
92         u16 reg, eoc_mA, fast_limit_mA;
93
94         if (!policy) {
95                 dev_warn(wm8350->dev,
96                          "No charger policy, charger not configured.\n");
97                 return -EINVAL;
98         }
99
100         /* make sure USB fast charge current is not > 500mA */
101         if (policy->fast_limit_USB_mA > 500) {
102                 dev_err(wm8350->dev, "USB fast charge > 500mA\n");
103                 return -EINVAL;
104         }
105
106         eoc_mA = WM8350_CHG_EOC_mA(policy->eoc_mA);
107
108         wm8350_reg_unlock(wm8350);
109
110         reg = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1)
111                 & WM8350_CHG_ENA_R168;
112         wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
113                          reg | eoc_mA | policy->trickle_start_mV |
114                          WM8350_CHG_TRICKLE_TEMP_CHOKE |
115                          WM8350_CHG_TRICKLE_USB_CHOKE |
116                          WM8350_CHG_FAST_USB_THROTTLE);
117
118         if (wm8350_get_supplies(wm8350) & WM8350_USB_SUPPLY) {
119                 fast_limit_mA =
120                         WM8350_CHG_FAST_LIMIT_mA(policy->fast_limit_USB_mA);
121                 wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2,
122                             policy->charge_mV | policy->trickle_charge_USB_mA |
123                             fast_limit_mA | wm8350_charge_time_min(wm8350,
124                                                 policy->charge_timeout));
125
126         } else {
127                 fast_limit_mA =
128                         WM8350_CHG_FAST_LIMIT_mA(policy->fast_limit_mA);
129                 wm8350_reg_write(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2,
130                             policy->charge_mV | policy->trickle_charge_mA |
131                             fast_limit_mA | wm8350_charge_time_min(wm8350,
132                                                 policy->charge_timeout));
133         }
134
135         wm8350_reg_lock(wm8350);
136         return 0;
137 }
138
139 static int wm8350_batt_status(struct wm8350 *wm8350)
140 {
141         u16 state;
142
143         state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2);
144         state &= WM8350_CHG_STS_MASK;
145
146         switch (state) {
147         case WM8350_CHG_STS_OFF:
148                 return POWER_SUPPLY_STATUS_DISCHARGING;
149
150         case WM8350_CHG_STS_TRICKLE:
151         case WM8350_CHG_STS_FAST:
152                 return POWER_SUPPLY_STATUS_CHARGING;
153
154         default:
155                 return POWER_SUPPLY_STATUS_UNKNOWN;
156         }
157 }
158
159 static ssize_t charger_state_show(struct device *dev,
160                                  struct device_attribute *attr, char *buf)
161 {
162         struct wm8350 *wm8350 = dev_get_drvdata(dev);
163         char *charge;
164         int state;
165
166         state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
167             WM8350_CHG_STS_MASK;
168         switch (state) {
169         case WM8350_CHG_STS_OFF:
170                 charge = "Charger Off";
171                 break;
172         case WM8350_CHG_STS_TRICKLE:
173                 charge = "Trickle Charging";
174                 break;
175         case WM8350_CHG_STS_FAST:
176                 charge = "Fast Charging";
177                 break;
178         default:
179                 return 0;
180         }
181
182         return sprintf(buf, "%s\n", charge);
183 }
184
185 static DEVICE_ATTR(charger_state, 0444, charger_state_show, NULL);
186
187 static void wm8350_charger_handler(struct wm8350 *wm8350, int irq, void *data)
188 {
189         struct wm8350_power *power = &wm8350->power;
190         struct wm8350_charger_policy *policy = power->policy;
191
192         switch (irq) {
193         case WM8350_IRQ_CHG_BAT_FAIL:
194                 dev_err(wm8350->dev, "battery failed\n");
195                 break;
196         case WM8350_IRQ_CHG_TO:
197                 dev_err(wm8350->dev, "charger timeout\n");
198                 power_supply_changed(&power->battery);
199                 break;
200
201         case WM8350_IRQ_CHG_BAT_HOT:
202         case WM8350_IRQ_CHG_BAT_COLD:
203         case WM8350_IRQ_CHG_START:
204         case WM8350_IRQ_CHG_END:
205                 power_supply_changed(&power->battery);
206                 break;
207
208         case WM8350_IRQ_CHG_FAST_RDY:
209                 dev_dbg(wm8350->dev, "fast charger ready\n");
210                 wm8350_charger_config(wm8350, policy);
211                 wm8350_reg_unlock(wm8350);
212                 wm8350_set_bits(wm8350, WM8350_BATTERY_CHARGER_CONTROL_1,
213                                 WM8350_CHG_FAST);
214                 wm8350_reg_lock(wm8350);
215                 break;
216
217         case WM8350_IRQ_CHG_VBATT_LT_3P9:
218                 dev_warn(wm8350->dev, "battery < 3.9V\n");
219                 break;
220         case WM8350_IRQ_CHG_VBATT_LT_3P1:
221                 dev_warn(wm8350->dev, "battery < 3.1V\n");
222                 break;
223         case WM8350_IRQ_CHG_VBATT_LT_2P85:
224                 dev_warn(wm8350->dev, "battery < 2.85V\n");
225                 break;
226
227                 /* Supply change.  We will overnotify but it should do
228                  * no harm. */
229         case WM8350_IRQ_EXT_USB_FB:
230         case WM8350_IRQ_EXT_WALL_FB:
231                 wm8350_charger_config(wm8350, policy);
232         case WM8350_IRQ_EXT_BAT_FB:   /* Fall through */
233                 power_supply_changed(&power->battery);
234                 power_supply_changed(&power->usb);
235                 power_supply_changed(&power->ac);
236                 break;
237
238         default:
239                 dev_err(wm8350->dev, "Unknown interrupt %d\n", irq);
240         }
241 }
242
243 /*********************************************************************
244  *              AC Power
245  *********************************************************************/
246 static int wm8350_ac_get_prop(struct power_supply *psy,
247                               enum power_supply_property psp,
248                               union power_supply_propval *val)
249 {
250         struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
251         int ret = 0;
252
253         switch (psp) {
254         case POWER_SUPPLY_PROP_ONLINE:
255                 val->intval = !!(wm8350_get_supplies(wm8350) &
256                                  WM8350_LINE_SUPPLY);
257                 break;
258         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
259                 val->intval = wm8350_read_line_uvolts(wm8350);
260                 break;
261         default:
262                 ret = -EINVAL;
263                 break;
264         }
265         return ret;
266 }
267
268 static enum power_supply_property wm8350_ac_props[] = {
269         POWER_SUPPLY_PROP_ONLINE,
270         POWER_SUPPLY_PROP_VOLTAGE_NOW,
271 };
272
273 /*********************************************************************
274  *              USB Power
275  *********************************************************************/
276 static int wm8350_usb_get_prop(struct power_supply *psy,
277                                enum power_supply_property psp,
278                                union power_supply_propval *val)
279 {
280         struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
281         int ret = 0;
282
283         switch (psp) {
284         case POWER_SUPPLY_PROP_ONLINE:
285                 val->intval = !!(wm8350_get_supplies(wm8350) &
286                                  WM8350_USB_SUPPLY);
287                 break;
288         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
289                 val->intval = wm8350_read_usb_uvolts(wm8350);
290                 break;
291         default:
292                 ret = -EINVAL;
293                 break;
294         }
295         return ret;
296 }
297
298 static enum power_supply_property wm8350_usb_props[] = {
299         POWER_SUPPLY_PROP_ONLINE,
300         POWER_SUPPLY_PROP_VOLTAGE_NOW,
301 };
302
303 /*********************************************************************
304  *              Battery properties
305  *********************************************************************/
306
307 static int wm8350_bat_check_health(struct wm8350 *wm8350)
308 {
309         u16 reg;
310
311         if (wm8350_read_battery_uvolts(wm8350) < 2850000)
312                 return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
313
314         reg = wm8350_reg_read(wm8350, WM8350_CHARGER_OVERRIDES);
315         if (reg & WM8350_CHG_BATT_HOT_OVRDE)
316                 return POWER_SUPPLY_HEALTH_OVERHEAT;
317
318         if (reg & WM8350_CHG_BATT_COLD_OVRDE)
319                 return POWER_SUPPLY_HEALTH_COLD;
320
321         return POWER_SUPPLY_HEALTH_GOOD;
322 }
323
324 static int wm8350_bat_get_charge_type(struct wm8350 *wm8350)
325 {
326         int state;
327
328         state = wm8350_reg_read(wm8350, WM8350_BATTERY_CHARGER_CONTROL_2) &
329             WM8350_CHG_STS_MASK;
330         switch (state) {
331         case WM8350_CHG_STS_OFF:
332                 return POWER_SUPPLY_CHARGE_TYPE_NONE;
333         case WM8350_CHG_STS_TRICKLE:
334                 return POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
335         case WM8350_CHG_STS_FAST:
336                 return POWER_SUPPLY_CHARGE_TYPE_FAST;
337         default:
338                 return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
339         }
340 }
341
342 static int wm8350_bat_get_property(struct power_supply *psy,
343                                    enum power_supply_property psp,
344                                    union power_supply_propval *val)
345 {
346         struct wm8350 *wm8350 = dev_get_drvdata(psy->dev->parent);
347         int ret = 0;
348
349         switch (psp) {
350         case POWER_SUPPLY_PROP_STATUS:
351                 val->intval = wm8350_batt_status(wm8350);
352                 break;
353         case POWER_SUPPLY_PROP_ONLINE:
354                 val->intval = !!(wm8350_get_supplies(wm8350) &
355                                  WM8350_BATT_SUPPLY);
356                 break;
357         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
358                 val->intval = wm8350_read_battery_uvolts(wm8350);
359                 break;
360         case POWER_SUPPLY_PROP_HEALTH:
361                 val->intval = wm8350_bat_check_health(wm8350);
362                 break;
363         case POWER_SUPPLY_PROP_CHARGE_TYPE:
364                 val->intval = wm8350_bat_get_charge_type(wm8350);
365                 break;
366         default:
367                 ret = -EINVAL;
368                 break;
369         }
370
371         return ret;
372 }
373
374 static enum power_supply_property wm8350_bat_props[] = {
375         POWER_SUPPLY_PROP_STATUS,
376         POWER_SUPPLY_PROP_ONLINE,
377         POWER_SUPPLY_PROP_VOLTAGE_NOW,
378         POWER_SUPPLY_PROP_HEALTH,
379         POWER_SUPPLY_PROP_CHARGE_TYPE,
380 };
381
382 /*********************************************************************
383  *              Initialisation
384  *********************************************************************/
385
386 static void wm8350_init_charger(struct wm8350 *wm8350)
387 {
388         /* register our interest in charger events */
389         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT,
390                             wm8350_charger_handler, NULL);
391         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT);
392         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD,
393                             wm8350_charger_handler, NULL);
394         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD);
395         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL,
396                             wm8350_charger_handler, NULL);
397         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL);
398         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_TO,
399                             wm8350_charger_handler, NULL);
400         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_TO);
401         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_END,
402                             wm8350_charger_handler, NULL);
403         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_END);
404         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_START,
405                             wm8350_charger_handler, NULL);
406         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_START);
407         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY,
408                             wm8350_charger_handler, NULL);
409         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_FAST_RDY);
410         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9,
411                             wm8350_charger_handler, NULL);
412         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9);
413         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1,
414                             wm8350_charger_handler, NULL);
415         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1);
416         wm8350_register_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85,
417                             wm8350_charger_handler, NULL);
418         wm8350_unmask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85);
419
420         /* and supply change events */
421         wm8350_register_irq(wm8350, WM8350_IRQ_EXT_USB_FB,
422                             wm8350_charger_handler, NULL);
423         wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_USB_FB);
424         wm8350_register_irq(wm8350, WM8350_IRQ_EXT_WALL_FB,
425                             wm8350_charger_handler, NULL);
426         wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_WALL_FB);
427         wm8350_register_irq(wm8350, WM8350_IRQ_EXT_BAT_FB,
428                             wm8350_charger_handler, NULL);
429         wm8350_unmask_irq(wm8350, WM8350_IRQ_EXT_BAT_FB);
430 }
431
432 static void free_charger_irq(struct wm8350 *wm8350)
433 {
434         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT);
435         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_HOT);
436         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD);
437         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_COLD);
438         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL);
439         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_BAT_FAIL);
440         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_TO);
441         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_TO);
442         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_END);
443         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_END);
444         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_START);
445         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_START);
446         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9);
447         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P9);
448         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1);
449         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_3P1);
450         wm8350_mask_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85);
451         wm8350_free_irq(wm8350, WM8350_IRQ_CHG_VBATT_LT_2P85);
452         wm8350_mask_irq(wm8350, WM8350_IRQ_EXT_USB_FB);
453         wm8350_free_irq(wm8350, WM8350_IRQ_EXT_USB_FB);
454         wm8350_mask_irq(wm8350, WM8350_IRQ_EXT_WALL_FB);
455         wm8350_free_irq(wm8350, WM8350_IRQ_EXT_WALL_FB);
456         wm8350_mask_irq(wm8350, WM8350_IRQ_EXT_BAT_FB);
457         wm8350_free_irq(wm8350, WM8350_IRQ_EXT_BAT_FB);
458 }
459
460 static __devinit int wm8350_power_probe(struct platform_device *pdev)
461 {
462         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
463         struct wm8350_power *power = &wm8350->power;
464         struct wm8350_charger_policy *policy = power->policy;
465         struct power_supply *usb = &power->usb;
466         struct power_supply *battery = &power->battery;
467         struct power_supply *ac = &power->ac;
468         int ret;
469
470         ac->name = "wm8350-ac";
471         ac->type = POWER_SUPPLY_TYPE_MAINS;
472         ac->properties = wm8350_ac_props;
473         ac->num_properties = ARRAY_SIZE(wm8350_ac_props);
474         ac->get_property = wm8350_ac_get_prop;
475         ret = power_supply_register(&pdev->dev, ac);
476         if (ret)
477                 return ret;
478
479         battery->name = "wm8350-battery";
480         battery->properties = wm8350_bat_props;
481         battery->num_properties = ARRAY_SIZE(wm8350_bat_props);
482         battery->get_property = wm8350_bat_get_property;
483         battery->use_for_apm = 1;
484         ret = power_supply_register(&pdev->dev, battery);
485         if (ret)
486                 goto battery_failed;
487
488         usb->name = "wm8350-usb",
489         usb->type = POWER_SUPPLY_TYPE_USB;
490         usb->properties = wm8350_usb_props;
491         usb->num_properties = ARRAY_SIZE(wm8350_usb_props);
492         usb->get_property = wm8350_usb_get_prop;
493         ret = power_supply_register(&pdev->dev, usb);
494         if (ret)
495                 goto usb_failed;
496
497         ret = device_create_file(&pdev->dev, &dev_attr_charger_state);
498         if (ret < 0)
499                 dev_warn(wm8350->dev, "failed to add charge sysfs: %d\n", ret);
500         ret = 0;
501
502         wm8350_init_charger(wm8350);
503         if (wm8350_charger_config(wm8350, policy) == 0) {
504                 wm8350_reg_unlock(wm8350);
505                 wm8350_set_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CHG_ENA);
506                 wm8350_reg_lock(wm8350);
507         }
508
509         return ret;
510
511 usb_failed:
512         power_supply_unregister(battery);
513 battery_failed:
514         power_supply_unregister(ac);
515
516         return ret;
517 }
518
519 static __devexit int wm8350_power_remove(struct platform_device *pdev)
520 {
521         struct wm8350 *wm8350 = platform_get_drvdata(pdev);
522         struct wm8350_power *power = &wm8350->power;
523
524         free_charger_irq(wm8350);
525         device_remove_file(&pdev->dev, &dev_attr_charger_state);
526         power_supply_unregister(&power->battery);
527         power_supply_unregister(&power->ac);
528         power_supply_unregister(&power->usb);
529         return 0;
530 }
531
532 static struct platform_driver wm8350_power_driver = {
533         .probe = wm8350_power_probe,
534         .remove = __devexit_p(wm8350_power_remove),
535         .driver = {
536                 .name = "wm8350-power",
537         },
538 };
539
540 static int __init wm8350_power_init(void)
541 {
542         return platform_driver_register(&wm8350_power_driver);
543 }
544 module_init(wm8350_power_init);
545
546 static void __exit wm8350_power_exit(void)
547 {
548         platform_driver_unregister(&wm8350_power_driver);
549 }
550 module_exit(wm8350_power_exit);
551
552 MODULE_LICENSE("GPL");
553 MODULE_DESCRIPTION("Power supply driver for WM8350");
554 MODULE_ALIAS("platform:wm8350-power");