drm/i915: SDVO hotplug have different interrupt status bits for i915/i965/g4x
[linux-2.6.git] / drivers / power / max8925_power.c
1 /*
2  * Battery driver for Maxim MAX8925
3  *
4  * Copyright (c) 2009-2010 Marvell International Ltd.
5  *      Haojian Zhuang <haojian.zhuang@marvell.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License version 2 as
9  * published by the Free Software Foundation.
10  */
11
12 #include <linux/module.h>
13 #include <linux/err.h>
14 #include <linux/slab.h>
15 #include <linux/i2c.h>
16 #include <linux/interrupt.h>
17 #include <linux/platform_device.h>
18 #include <linux/power_supply.h>
19 #include <linux/mfd/max8925.h>
20
21 /* registers in GPM */
22 #define MAX8925_OUT5VEN                 0x54
23 #define MAX8925_OUT3VEN                 0x58
24 #define MAX8925_CHG_CNTL1               0x7c
25
26 /* bits definition */
27 #define MAX8925_CHG_STAT_VSYSLOW        (1 << 0)
28 #define MAX8925_CHG_STAT_MODE_MASK      (3 << 2)
29 #define MAX8925_CHG_STAT_EN_MASK        (1 << 4)
30 #define MAX8925_CHG_MBDET               (1 << 1)
31 #define MAX8925_CHG_AC_RANGE_MASK       (3 << 6)
32
33 /* registers in ADC */
34 #define MAX8925_ADC_RES_CNFG1           0x06
35 #define MAX8925_ADC_AVG_CNFG1           0x07
36 #define MAX8925_ADC_ACQ_CNFG1           0x08
37 #define MAX8925_ADC_ACQ_CNFG2           0x09
38 /* 2 bytes registers in below. MSB is 1st, LSB is 2nd. */
39 #define MAX8925_ADC_AUX2                0x62
40 #define MAX8925_ADC_VCHG                0x64
41 #define MAX8925_ADC_VBBATT              0x66
42 #define MAX8925_ADC_VMBATT              0x68
43 #define MAX8925_ADC_ISNS                0x6a
44 #define MAX8925_ADC_THM                 0x6c
45 #define MAX8925_ADC_TDIE                0x6e
46 #define MAX8925_CMD_AUX2                0xc8
47 #define MAX8925_CMD_VCHG                0xd0
48 #define MAX8925_CMD_VBBATT              0xd8
49 #define MAX8925_CMD_VMBATT              0xe0
50 #define MAX8925_CMD_ISNS                0xe8
51 #define MAX8925_CMD_THM                 0xf0
52 #define MAX8925_CMD_TDIE                0xf8
53
54 enum {
55         MEASURE_AUX2,
56         MEASURE_VCHG,
57         MEASURE_VBBATT,
58         MEASURE_VMBATT,
59         MEASURE_ISNS,
60         MEASURE_THM,
61         MEASURE_TDIE,
62         MEASURE_MAX,
63 };
64
65 struct max8925_power_info {
66         struct max8925_chip     *chip;
67         struct i2c_client       *gpm;
68         struct i2c_client       *adc;
69
70         struct power_supply     ac;
71         struct power_supply     usb;
72         struct power_supply     battery;
73         int                     irq_base;
74         unsigned                ac_online:1;
75         unsigned                usb_online:1;
76         unsigned                bat_online:1;
77         unsigned                chg_mode:2;
78         unsigned                batt_detect:1;  /* detecing MB by ID pin */
79         unsigned                topoff_threshold:2;
80         unsigned                fast_charge:3;
81         unsigned                no_temp_support:1;
82         unsigned                no_insert_detect:1;
83
84         int (*set_charger) (int);
85 };
86
87 static int __set_charger(struct max8925_power_info *info, int enable)
88 {
89         struct max8925_chip *chip = info->chip;
90         if (enable) {
91                 /* enable charger in platform */
92                 if (info->set_charger)
93                         info->set_charger(1);
94                 /* enable charger */
95                 max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 0);
96         } else {
97                 /* disable charge */
98                 max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
99                 if (info->set_charger)
100                         info->set_charger(0);
101         }
102         dev_dbg(chip->dev, "%s\n", (enable) ? "Enable charger"
103                 : "Disable charger");
104         return 0;
105 }
106
107 static irqreturn_t max8925_charger_handler(int irq, void *data)
108 {
109         struct max8925_power_info *info = (struct max8925_power_info *)data;
110         struct max8925_chip *chip = info->chip;
111
112         switch (irq - chip->irq_base) {
113         case MAX8925_IRQ_VCHG_DC_R:
114                 info->ac_online = 1;
115                 __set_charger(info, 1);
116                 dev_dbg(chip->dev, "Adapter inserted\n");
117                 break;
118         case MAX8925_IRQ_VCHG_DC_F:
119                 info->ac_online = 0;
120                 __set_charger(info, 0);
121                 dev_dbg(chip->dev, "Adapter removed\n");
122                 break;
123         case MAX8925_IRQ_VCHG_THM_OK_F:
124                 /* Battery is not ready yet */
125                 dev_dbg(chip->dev, "Battery temperature is out of range\n");
126         case MAX8925_IRQ_VCHG_DC_OVP:
127                 dev_dbg(chip->dev, "Error detection\n");
128                 __set_charger(info, 0);
129                 break;
130         case MAX8925_IRQ_VCHG_THM_OK_R:
131                 /* Battery is ready now */
132                 dev_dbg(chip->dev, "Battery temperature is in range\n");
133                 break;
134         case MAX8925_IRQ_VCHG_SYSLOW_R:
135                 /* VSYS is low */
136                 dev_info(chip->dev, "Sys power is too low\n");
137                 break;
138         case MAX8925_IRQ_VCHG_SYSLOW_F:
139                 dev_dbg(chip->dev, "Sys power is above low threshold\n");
140                 break;
141         case MAX8925_IRQ_VCHG_DONE:
142                 __set_charger(info, 0);
143                 dev_dbg(chip->dev, "Charging is done\n");
144                 break;
145         case MAX8925_IRQ_VCHG_TOPOFF:
146                 dev_dbg(chip->dev, "Charging in top-off mode\n");
147                 break;
148         case MAX8925_IRQ_VCHG_TMR_FAULT:
149                 __set_charger(info, 0);
150                 dev_dbg(chip->dev, "Safe timer is expired\n");
151                 break;
152         case MAX8925_IRQ_VCHG_RST:
153                 __set_charger(info, 0);
154                 dev_dbg(chip->dev, "Charger is reset\n");
155                 break;
156         }
157         return IRQ_HANDLED;
158 }
159
160 static int start_measure(struct max8925_power_info *info, int type)
161 {
162         unsigned char buf[2] = {0, 0};
163         int meas_cmd;
164         int meas_reg = 0, ret;
165
166         switch (type) {
167         case MEASURE_VCHG:
168                 meas_cmd = MAX8925_CMD_VCHG;
169                 meas_reg = MAX8925_ADC_VCHG;
170                 break;
171         case MEASURE_VBBATT:
172                 meas_cmd = MAX8925_CMD_VBBATT;
173                 meas_reg = MAX8925_ADC_VBBATT;
174                 break;
175         case MEASURE_VMBATT:
176                 meas_cmd = MAX8925_CMD_VMBATT;
177                 meas_reg = MAX8925_ADC_VMBATT;
178                 break;
179         case MEASURE_ISNS:
180                 meas_cmd = MAX8925_CMD_ISNS;
181                 meas_reg = MAX8925_ADC_ISNS;
182                 break;
183         default:
184                 return -EINVAL;
185         }
186
187         max8925_reg_write(info->adc, meas_cmd, 0);
188         max8925_bulk_read(info->adc, meas_reg, 2, buf);
189         ret = ((buf[0]<<8) | buf[1]) >> 4;
190
191         return ret;
192 }
193
194 static int max8925_ac_get_prop(struct power_supply *psy,
195                                enum power_supply_property psp,
196                                union power_supply_propval *val)
197 {
198         struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent);
199         int ret = 0;
200
201         switch (psp) {
202         case POWER_SUPPLY_PROP_ONLINE:
203                 val->intval = info->ac_online;
204                 break;
205         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
206                 if (info->ac_online) {
207                         ret = start_measure(info, MEASURE_VCHG);
208                         if (ret >= 0) {
209                                 val->intval = ret * 2000;       /* unit is uV */
210                                 goto out;
211                         }
212                 }
213                 ret = -ENODATA;
214                 break;
215         default:
216                 ret = -ENODEV;
217                 break;
218         }
219 out:
220         return ret;
221 }
222
223 static enum power_supply_property max8925_ac_props[] = {
224         POWER_SUPPLY_PROP_ONLINE,
225         POWER_SUPPLY_PROP_VOLTAGE_NOW,
226 };
227
228 static int max8925_usb_get_prop(struct power_supply *psy,
229                                 enum power_supply_property psp,
230                                 union power_supply_propval *val)
231 {
232         struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent);
233         int ret = 0;
234
235         switch (psp) {
236         case POWER_SUPPLY_PROP_ONLINE:
237                 val->intval = info->usb_online;
238                 break;
239         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
240                 if (info->usb_online) {
241                         ret = start_measure(info, MEASURE_VCHG);
242                         if (ret >= 0) {
243                                 val->intval = ret * 2000;       /* unit is uV */
244                                 goto out;
245                         }
246                 }
247                 ret = -ENODATA;
248                 break;
249         default:
250                 ret = -ENODEV;
251                 break;
252         }
253 out:
254         return ret;
255 }
256
257 static enum power_supply_property max8925_usb_props[] = {
258         POWER_SUPPLY_PROP_ONLINE,
259         POWER_SUPPLY_PROP_VOLTAGE_NOW,
260 };
261
262 static int max8925_bat_get_prop(struct power_supply *psy,
263                                 enum power_supply_property psp,
264                                 union power_supply_propval *val)
265 {
266         struct max8925_power_info *info = dev_get_drvdata(psy->dev->parent);
267         int ret = 0;
268
269         switch (psp) {
270         case POWER_SUPPLY_PROP_ONLINE:
271                 val->intval = info->bat_online;
272                 break;
273         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
274                 if (info->bat_online) {
275                         ret = start_measure(info, MEASURE_VMBATT);
276                         if (ret >= 0) {
277                                 val->intval = ret * 2000;       /* unit is uV */
278                                 ret = 0;
279                                 break;
280                         }
281                 }
282                 ret = -ENODATA;
283                 break;
284         case POWER_SUPPLY_PROP_CURRENT_NOW:
285                 if (info->bat_online) {
286                         ret = start_measure(info, MEASURE_ISNS);
287                         if (ret >= 0) {
288                                 /* assume r_sns is 0.02 */
289                                 ret = ((ret * 6250) - 3125) /* uA */;
290                                 val->intval = 0;
291                                 if (ret > 0)
292                                         val->intval = ret; /* unit is mA */
293                                 ret = 0;
294                                 break;
295                         }
296                 }
297                 ret = -ENODATA;
298                 break;
299         case POWER_SUPPLY_PROP_CHARGE_TYPE:
300                 if (!info->bat_online) {
301                         ret = -ENODATA;
302                         break;
303                 }
304                 ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
305                 ret = (ret & MAX8925_CHG_STAT_MODE_MASK) >> 2;
306                 switch (ret) {
307                 case 1:
308                         val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
309                         break;
310                 case 0:
311                 case 2:
312                         val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
313                         break;
314                 case 3:
315                         val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
316                         break;
317                 }
318                 ret = 0;
319                 break;
320         case POWER_SUPPLY_PROP_STATUS:
321                 if (!info->bat_online) {
322                         ret = -ENODATA;
323                         break;
324                 }
325                 ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
326                 if (info->usb_online || info->ac_online) {
327                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
328                         if (ret & MAX8925_CHG_STAT_EN_MASK)
329                                 val->intval = POWER_SUPPLY_STATUS_CHARGING;
330                 } else
331                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
332                 ret = 0;
333                 break;
334         default:
335                 ret = -ENODEV;
336                 break;
337         }
338         return ret;
339 }
340
341 static enum power_supply_property max8925_battery_props[] = {
342         POWER_SUPPLY_PROP_ONLINE,
343         POWER_SUPPLY_PROP_VOLTAGE_NOW,
344         POWER_SUPPLY_PROP_CURRENT_NOW,
345         POWER_SUPPLY_PROP_CHARGE_TYPE,
346         POWER_SUPPLY_PROP_STATUS,
347 };
348
349 #define REQUEST_IRQ(_irq, _name)                                        \
350 do {                                                                    \
351         ret = request_threaded_irq(chip->irq_base + _irq, NULL,         \
352                                     max8925_charger_handler,            \
353                                     IRQF_ONESHOT, _name, info);         \
354         if (ret)                                                        \
355                 dev_err(chip->dev, "Failed to request IRQ #%d: %d\n",   \
356                         _irq, ret);                                     \
357 } while (0)
358
359 static __devinit int max8925_init_charger(struct max8925_chip *chip,
360                                           struct max8925_power_info *info)
361 {
362         int ret;
363
364         REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_OVP, "ac-ovp");
365         if (!info->no_insert_detect) {
366                 REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_F, "ac-remove");
367                 REQUEST_IRQ(MAX8925_IRQ_VCHG_DC_R, "ac-insert");
368         }
369         if (!info->no_temp_support) {
370                 REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_R, "batt-temp-in-range");
371                 REQUEST_IRQ(MAX8925_IRQ_VCHG_THM_OK_F, "batt-temp-out-range");
372         }
373         REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_F, "vsys-high");
374         REQUEST_IRQ(MAX8925_IRQ_VCHG_SYSLOW_R, "vsys-low");
375         REQUEST_IRQ(MAX8925_IRQ_VCHG_RST, "charger-reset");
376         REQUEST_IRQ(MAX8925_IRQ_VCHG_DONE, "charger-done");
377         REQUEST_IRQ(MAX8925_IRQ_VCHG_TOPOFF, "charger-topoff");
378         REQUEST_IRQ(MAX8925_IRQ_VCHG_TMR_FAULT, "charger-timer-expire");
379
380         info->usb_online = 0;
381         info->bat_online = 0;
382
383         /* check for power - can miss interrupt at boot time */
384         if (start_measure(info, MEASURE_VCHG) * 2000 > 500000)
385                 info->ac_online = 1;
386         else
387                 info->ac_online = 0;
388
389         ret = max8925_reg_read(info->gpm, MAX8925_CHG_STATUS);
390         if (ret >= 0) {
391                 /*
392                  * If battery detection is enabled, ID pin of battery is
393                  * connected to MBDET pin of MAX8925. It could be used to
394                  * detect battery presence.
395                  * Otherwise, we have to assume that battery is always on.
396                  */
397                 if (info->batt_detect)
398                         info->bat_online = (ret & MAX8925_CHG_MBDET) ? 0 : 1;
399                 else
400                         info->bat_online = 1;
401                 if (ret & MAX8925_CHG_AC_RANGE_MASK)
402                         info->ac_online = 1;
403                 else
404                         info->ac_online = 0;
405         }
406         /* disable charge */
407         max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 1 << 7, 1 << 7);
408         /* set charging current in charge topoff mode */
409         max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 3 << 5,
410                          info->topoff_threshold << 5);
411         /* set charing current in fast charge mode */
412         max8925_set_bits(info->gpm, MAX8925_CHG_CNTL1, 7, info->fast_charge);
413
414         return 0;
415 }
416
417 static __devexit int max8925_deinit_charger(struct max8925_power_info *info)
418 {
419         struct max8925_chip *chip = info->chip;
420         int irq;
421
422         irq = chip->irq_base + MAX8925_IRQ_VCHG_DC_OVP;
423         for (; irq <= chip->irq_base + MAX8925_IRQ_VCHG_TMR_FAULT; irq++)
424                 free_irq(irq, info);
425
426         return 0;
427 }
428
429 static __devinit int max8925_power_probe(struct platform_device *pdev)
430 {
431         struct max8925_chip *chip = dev_get_drvdata(pdev->dev.parent);
432         struct max8925_power_pdata *pdata = NULL;
433         struct max8925_power_info *info;
434         int ret;
435
436         pdata = pdev->dev.platform_data;
437         if (!pdata) {
438                 dev_err(&pdev->dev, "platform data isn't assigned to "
439                         "power supply\n");
440                 return -EINVAL;
441         }
442
443         info = kzalloc(sizeof(struct max8925_power_info), GFP_KERNEL);
444         if (!info)
445                 return -ENOMEM;
446         info->chip = chip;
447         info->gpm = chip->i2c;
448         info->adc = chip->adc;
449         platform_set_drvdata(pdev, info);
450
451         info->ac.name = "max8925-ac";
452         info->ac.type = POWER_SUPPLY_TYPE_MAINS;
453         info->ac.properties = max8925_ac_props;
454         info->ac.num_properties = ARRAY_SIZE(max8925_ac_props);
455         info->ac.get_property = max8925_ac_get_prop;
456         info->ac.supplied_to = pdata->supplied_to;
457         info->ac.num_supplicants = pdata->num_supplicants;
458         ret = power_supply_register(&pdev->dev, &info->ac);
459         if (ret)
460                 goto out;
461         info->ac.dev->parent = &pdev->dev;
462
463         info->usb.name = "max8925-usb";
464         info->usb.type = POWER_SUPPLY_TYPE_USB;
465         info->usb.properties = max8925_usb_props;
466         info->usb.num_properties = ARRAY_SIZE(max8925_usb_props);
467         info->usb.get_property = max8925_usb_get_prop;
468         info->usb.supplied_to = pdata->supplied_to;
469         info->usb.num_supplicants = pdata->num_supplicants;
470
471         ret = power_supply_register(&pdev->dev, &info->usb);
472         if (ret)
473                 goto out_usb;
474         info->usb.dev->parent = &pdev->dev;
475
476         info->battery.name = "max8925-battery";
477         info->battery.type = POWER_SUPPLY_TYPE_BATTERY;
478         info->battery.properties = max8925_battery_props;
479         info->battery.num_properties = ARRAY_SIZE(max8925_battery_props);
480         info->battery.get_property = max8925_bat_get_prop;
481         ret = power_supply_register(&pdev->dev, &info->battery);
482         if (ret)
483                 goto out_battery;
484         info->battery.dev->parent = &pdev->dev;
485
486         info->batt_detect = pdata->batt_detect;
487         info->topoff_threshold = pdata->topoff_threshold;
488         info->fast_charge = pdata->fast_charge;
489         info->set_charger = pdata->set_charger;
490         info->no_temp_support = pdata->no_temp_support;
491         info->no_insert_detect = pdata->no_insert_detect;
492
493         max8925_init_charger(chip, info);
494         return 0;
495 out_battery:
496         power_supply_unregister(&info->battery);
497 out_usb:
498         power_supply_unregister(&info->ac);
499 out:
500         kfree(info);
501         return ret;
502 }
503
504 static __devexit int max8925_power_remove(struct platform_device *pdev)
505 {
506         struct max8925_power_info *info = platform_get_drvdata(pdev);
507
508         if (info) {
509                 power_supply_unregister(&info->ac);
510                 power_supply_unregister(&info->usb);
511                 power_supply_unregister(&info->battery);
512                 max8925_deinit_charger(info);
513                 kfree(info);
514         }
515         return 0;
516 }
517
518 static struct platform_driver max8925_power_driver = {
519         .probe  = max8925_power_probe,
520         .remove = __devexit_p(max8925_power_remove),
521         .driver = {
522                 .name   = "max8925-power",
523         },
524 };
525
526 module_platform_driver(max8925_power_driver);
527
528 MODULE_LICENSE("GPL");
529 MODULE_DESCRIPTION("Power supply driver for MAX8925");
530 MODULE_ALIAS("platform:max8925-power");