Merge git://git.infradead.org/battery-2.6
[pandora-kernel.git] / drivers / power / bq20z75.c
1 /*
2  * Gas Gauge driver for TI's BQ20Z75
3  *
4  * Copyright (c) 2010, NVIDIA Corporation.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version.
10  *
11  * This program is distributed in the hope that it will be useful, but WITHOUT
12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
14  * more details.
15  *
16  * You should have received a copy of the GNU General Public License along
17  * with this program; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
19  */
20
21 #include <linux/init.h>
22 #include <linux/module.h>
23 #include <linux/kernel.h>
24 #include <linux/err.h>
25 #include <linux/power_supply.h>
26 #include <linux/i2c.h>
27 #include <linux/slab.h>
28 #include <linux/interrupt.h>
29 #include <linux/gpio.h>
30
31 #include <linux/power/bq20z75.h>
32
33 enum {
34         REG_MANUFACTURER_DATA,
35         REG_TEMPERATURE,
36         REG_VOLTAGE,
37         REG_CURRENT,
38         REG_CAPACITY,
39         REG_TIME_TO_EMPTY,
40         REG_TIME_TO_FULL,
41         REG_STATUS,
42         REG_CYCLE_COUNT,
43         REG_SERIAL_NUMBER,
44         REG_REMAINING_CAPACITY,
45         REG_REMAINING_CAPACITY_CHARGE,
46         REG_FULL_CHARGE_CAPACITY,
47         REG_FULL_CHARGE_CAPACITY_CHARGE,
48         REG_DESIGN_CAPACITY,
49         REG_DESIGN_CAPACITY_CHARGE,
50         REG_DESIGN_VOLTAGE,
51 };
52
53 /* Battery Mode defines */
54 #define BATTERY_MODE_OFFSET             0x03
55 #define BATTERY_MODE_MASK               0x8000
56 enum bq20z75_battery_mode {
57         BATTERY_MODE_AMPS,
58         BATTERY_MODE_WATTS
59 };
60
61 /* manufacturer access defines */
62 #define MANUFACTURER_ACCESS_STATUS      0x0006
63 #define MANUFACTURER_ACCESS_SLEEP       0x0011
64
65 /* battery status value bits */
66 #define BATTERY_DISCHARGING             0x40
67 #define BATTERY_FULL_CHARGED            0x20
68 #define BATTERY_FULL_DISCHARGED         0x10
69
70 #define BQ20Z75_DATA(_psp, _addr, _min_value, _max_value) { \
71         .psp = _psp, \
72         .addr = _addr, \
73         .min_value = _min_value, \
74         .max_value = _max_value, \
75 }
76
77 static const struct bq20z75_device_data {
78         enum power_supply_property psp;
79         u8 addr;
80         int min_value;
81         int max_value;
82 } bq20z75_data[] = {
83         [REG_MANUFACTURER_DATA] =
84                 BQ20Z75_DATA(POWER_SUPPLY_PROP_PRESENT, 0x00, 0, 65535),
85         [REG_TEMPERATURE] =
86                 BQ20Z75_DATA(POWER_SUPPLY_PROP_TEMP, 0x08, 0, 65535),
87         [REG_VOLTAGE] =
88                 BQ20Z75_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW, 0x09, 0, 20000),
89         [REG_CURRENT] =
90                 BQ20Z75_DATA(POWER_SUPPLY_PROP_CURRENT_NOW, 0x0A, -32768,
91                         32767),
92         [REG_CAPACITY] =
93                 BQ20Z75_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0E, 0, 100),
94         [REG_REMAINING_CAPACITY] =
95                 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535),
96         [REG_REMAINING_CAPACITY_CHARGE] =
97                 BQ20Z75_DATA(POWER_SUPPLY_PROP_CHARGE_NOW, 0x0F, 0, 65535),
98         [REG_FULL_CHARGE_CAPACITY] =
99                 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535),
100         [REG_FULL_CHARGE_CAPACITY_CHARGE] =
101                 BQ20Z75_DATA(POWER_SUPPLY_PROP_CHARGE_FULL, 0x10, 0, 65535),
102         [REG_TIME_TO_EMPTY] =
103                 BQ20Z75_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0,
104                         65535),
105         [REG_TIME_TO_FULL] =
106                 BQ20Z75_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 0x13, 0,
107                         65535),
108         [REG_STATUS] =
109                 BQ20Z75_DATA(POWER_SUPPLY_PROP_STATUS, 0x16, 0, 65535),
110         [REG_CYCLE_COUNT] =
111                 BQ20Z75_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT, 0x17, 0, 65535),
112         [REG_DESIGN_CAPACITY] =
113                 BQ20Z75_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0,
114                         65535),
115         [REG_DESIGN_CAPACITY_CHARGE] =
116                 BQ20Z75_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 0x18, 0,
117                         65535),
118         [REG_DESIGN_VOLTAGE] =
119                 BQ20Z75_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0,
120                         65535),
121         [REG_SERIAL_NUMBER] =
122                 BQ20Z75_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER, 0x1C, 0, 65535),
123 };
124
125 static enum power_supply_property bq20z75_properties[] = {
126         POWER_SUPPLY_PROP_STATUS,
127         POWER_SUPPLY_PROP_HEALTH,
128         POWER_SUPPLY_PROP_PRESENT,
129         POWER_SUPPLY_PROP_TECHNOLOGY,
130         POWER_SUPPLY_PROP_CYCLE_COUNT,
131         POWER_SUPPLY_PROP_VOLTAGE_NOW,
132         POWER_SUPPLY_PROP_CURRENT_NOW,
133         POWER_SUPPLY_PROP_CAPACITY,
134         POWER_SUPPLY_PROP_TEMP,
135         POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
136         POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
137         POWER_SUPPLY_PROP_SERIAL_NUMBER,
138         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
139         POWER_SUPPLY_PROP_ENERGY_NOW,
140         POWER_SUPPLY_PROP_ENERGY_FULL,
141         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
142         POWER_SUPPLY_PROP_CHARGE_NOW,
143         POWER_SUPPLY_PROP_CHARGE_FULL,
144         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
145 };
146
147 struct bq20z75_info {
148         struct i2c_client               *client;
149         struct power_supply             power_supply;
150         struct bq20z75_platform_data    *pdata;
151         bool                            is_present;
152         bool                            gpio_detect;
153         bool                            enable_detection;
154         int                             irq;
155 };
156
157 static int bq20z75_read_word_data(struct i2c_client *client, u8 address)
158 {
159         struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
160         s32 ret = 0;
161         int retries = 1;
162
163         if (bq20z75_device->pdata)
164                 retries = max(bq20z75_device->pdata->i2c_retry_count + 1, 1);
165
166         while (retries > 0) {
167                 ret = i2c_smbus_read_word_data(client, address);
168                 if (ret >= 0)
169                         break;
170                 retries--;
171         }
172
173         if (ret < 0) {
174                 dev_dbg(&client->dev,
175                         "%s: i2c read at address 0x%x failed\n",
176                         __func__, address);
177                 return ret;
178         }
179
180         return le16_to_cpu(ret);
181 }
182
183 static int bq20z75_write_word_data(struct i2c_client *client, u8 address,
184         u16 value)
185 {
186         struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
187         s32 ret = 0;
188         int retries = 1;
189
190         if (bq20z75_device->pdata)
191                 retries = max(bq20z75_device->pdata->i2c_retry_count + 1, 1);
192
193         while (retries > 0) {
194                 ret = i2c_smbus_write_word_data(client, address,
195                         le16_to_cpu(value));
196                 if (ret >= 0)
197                         break;
198                 retries--;
199         }
200
201         if (ret < 0) {
202                 dev_dbg(&client->dev,
203                         "%s: i2c write to address 0x%x failed\n",
204                         __func__, address);
205                 return ret;
206         }
207
208         return 0;
209 }
210
211 static int bq20z75_get_battery_presence_and_health(
212         struct i2c_client *client, enum power_supply_property psp,
213         union power_supply_propval *val)
214 {
215         s32 ret;
216         struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
217
218         if (psp == POWER_SUPPLY_PROP_PRESENT &&
219                 bq20z75_device->gpio_detect) {
220                 ret = gpio_get_value(
221                         bq20z75_device->pdata->battery_detect);
222                 if (ret == bq20z75_device->pdata->battery_detect_present)
223                         val->intval = 1;
224                 else
225                         val->intval = 0;
226                 bq20z75_device->is_present = val->intval;
227                 return ret;
228         }
229
230         /* Write to ManufacturerAccess with
231          * ManufacturerAccess command and then
232          * read the status */
233         ret = bq20z75_write_word_data(client,
234                 bq20z75_data[REG_MANUFACTURER_DATA].addr,
235                 MANUFACTURER_ACCESS_STATUS);
236         if (ret < 0) {
237                 if (psp == POWER_SUPPLY_PROP_PRESENT)
238                         val->intval = 0; /* battery removed */
239                 return ret;
240         }
241
242         ret = bq20z75_read_word_data(client,
243                 bq20z75_data[REG_MANUFACTURER_DATA].addr);
244         if (ret < 0)
245                 return ret;
246
247         if (ret < bq20z75_data[REG_MANUFACTURER_DATA].min_value ||
248             ret > bq20z75_data[REG_MANUFACTURER_DATA].max_value) {
249                 val->intval = 0;
250                 return 0;
251         }
252
253         /* Mask the upper nibble of 2nd byte and
254          * lower byte of response then
255          * shift the result by 8 to get status*/
256         ret &= 0x0F00;
257         ret >>= 8;
258         if (psp == POWER_SUPPLY_PROP_PRESENT) {
259                 if (ret == 0x0F)
260                         /* battery removed */
261                         val->intval = 0;
262                 else
263                         val->intval = 1;
264         } else if (psp == POWER_SUPPLY_PROP_HEALTH) {
265                 if (ret == 0x09)
266                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
267                 else if (ret == 0x0B)
268                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
269                 else if (ret == 0x0C)
270                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
271                 else
272                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
273         }
274
275         return 0;
276 }
277
278 static int bq20z75_get_battery_property(struct i2c_client *client,
279         int reg_offset, enum power_supply_property psp,
280         union power_supply_propval *val)
281 {
282         s32 ret;
283
284         ret = bq20z75_read_word_data(client,
285                 bq20z75_data[reg_offset].addr);
286         if (ret < 0)
287                 return ret;
288
289         /* returned values are 16 bit */
290         if (bq20z75_data[reg_offset].min_value < 0)
291                 ret = (s16)ret;
292
293         if (ret >= bq20z75_data[reg_offset].min_value &&
294             ret <= bq20z75_data[reg_offset].max_value) {
295                 val->intval = ret;
296                 if (psp == POWER_SUPPLY_PROP_STATUS) {
297                         if (ret & BATTERY_FULL_CHARGED)
298                                 val->intval = POWER_SUPPLY_STATUS_FULL;
299                         else if (ret & BATTERY_FULL_DISCHARGED)
300                                 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
301                         else if (ret & BATTERY_DISCHARGING)
302                                 val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
303                         else
304                                 val->intval = POWER_SUPPLY_STATUS_CHARGING;
305                 }
306         } else {
307                 if (psp == POWER_SUPPLY_PROP_STATUS)
308                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
309                 else
310                         val->intval = 0;
311         }
312
313         return 0;
314 }
315
316 static void  bq20z75_unit_adjustment(struct i2c_client *client,
317         enum power_supply_property psp, union power_supply_propval *val)
318 {
319 #define BASE_UNIT_CONVERSION            1000
320 #define BATTERY_MODE_CAP_MULT_WATT      (10 * BASE_UNIT_CONVERSION)
321 #define TIME_UNIT_CONVERSION            60
322 #define TEMP_KELVIN_TO_CELSIUS          2731
323         switch (psp) {
324         case POWER_SUPPLY_PROP_ENERGY_NOW:
325         case POWER_SUPPLY_PROP_ENERGY_FULL:
326         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
327                 /* bq20z75 provides energy in units of 10mWh.
328                  * Convert to µWh
329                  */
330                 val->intval *= BATTERY_MODE_CAP_MULT_WATT;
331                 break;
332
333         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
334         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
335         case POWER_SUPPLY_PROP_CURRENT_NOW:
336         case POWER_SUPPLY_PROP_CHARGE_NOW:
337         case POWER_SUPPLY_PROP_CHARGE_FULL:
338         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
339                 val->intval *= BASE_UNIT_CONVERSION;
340                 break;
341
342         case POWER_SUPPLY_PROP_TEMP:
343                 /* bq20z75 provides battery temperature in 0.1K
344                  * so convert it to 0.1°C
345                  */
346                 val->intval -= TEMP_KELVIN_TO_CELSIUS;
347                 break;
348
349         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
350         case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
351                 /* bq20z75 provides time to empty and time to full in minutes.
352                  * Convert to seconds
353                  */
354                 val->intval *= TIME_UNIT_CONVERSION;
355                 break;
356
357         default:
358                 dev_dbg(&client->dev,
359                         "%s: no need for unit conversion %d\n", __func__, psp);
360         }
361 }
362
363 static enum bq20z75_battery_mode
364 bq20z75_set_battery_mode(struct i2c_client *client,
365         enum bq20z75_battery_mode mode)
366 {
367         int ret, original_val;
368
369         original_val = bq20z75_read_word_data(client, BATTERY_MODE_OFFSET);
370         if (original_val < 0)
371                 return original_val;
372
373         if ((original_val & BATTERY_MODE_MASK) == mode)
374                 return mode;
375
376         if (mode == BATTERY_MODE_AMPS)
377                 ret = original_val & ~BATTERY_MODE_MASK;
378         else
379                 ret = original_val | BATTERY_MODE_MASK;
380
381         ret = bq20z75_write_word_data(client, BATTERY_MODE_OFFSET, ret);
382         if (ret < 0)
383                 return ret;
384
385         return original_val & BATTERY_MODE_MASK;
386 }
387
388 static int bq20z75_get_battery_capacity(struct i2c_client *client,
389         int reg_offset, enum power_supply_property psp,
390         union power_supply_propval *val)
391 {
392         s32 ret;
393         enum bq20z75_battery_mode mode = BATTERY_MODE_WATTS;
394
395         if (power_supply_is_amp_property(psp))
396                 mode = BATTERY_MODE_AMPS;
397
398         mode = bq20z75_set_battery_mode(client, mode);
399         if (mode < 0)
400                 return mode;
401
402         ret = bq20z75_read_word_data(client, bq20z75_data[reg_offset].addr);
403         if (ret < 0)
404                 return ret;
405
406         if (psp == POWER_SUPPLY_PROP_CAPACITY) {
407                 /* bq20z75 spec says that this can be >100 %
408                 * even if max value is 100 % */
409                 val->intval = min(ret, 100);
410         } else
411                 val->intval = ret;
412
413         ret = bq20z75_set_battery_mode(client, mode);
414         if (ret < 0)
415                 return ret;
416
417         return 0;
418 }
419
420 static char bq20z75_serial[5];
421 static int bq20z75_get_battery_serial_number(struct i2c_client *client,
422         union power_supply_propval *val)
423 {
424         int ret;
425
426         ret = bq20z75_read_word_data(client,
427                 bq20z75_data[REG_SERIAL_NUMBER].addr);
428         if (ret < 0)
429                 return ret;
430
431         ret = sprintf(bq20z75_serial, "%04x", ret);
432         val->strval = bq20z75_serial;
433
434         return 0;
435 }
436
437 static int bq20z75_get_property_index(struct i2c_client *client,
438         enum power_supply_property psp)
439 {
440         int count;
441         for (count = 0; count < ARRAY_SIZE(bq20z75_data); count++)
442                 if (psp == bq20z75_data[count].psp)
443                         return count;
444
445         dev_warn(&client->dev,
446                 "%s: Invalid Property - %d\n", __func__, psp);
447
448         return -EINVAL;
449 }
450
451 static int bq20z75_get_property(struct power_supply *psy,
452         enum power_supply_property psp,
453         union power_supply_propval *val)
454 {
455         int ret = 0;
456         struct bq20z75_info *bq20z75_device = container_of(psy,
457                                 struct bq20z75_info, power_supply);
458         struct i2c_client *client = bq20z75_device->client;
459
460         switch (psp) {
461         case POWER_SUPPLY_PROP_PRESENT:
462         case POWER_SUPPLY_PROP_HEALTH:
463                 ret = bq20z75_get_battery_presence_and_health(client, psp, val);
464                 if (psp == POWER_SUPPLY_PROP_PRESENT)
465                         return 0;
466                 break;
467
468         case POWER_SUPPLY_PROP_TECHNOLOGY:
469                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
470                 break;
471
472         case POWER_SUPPLY_PROP_ENERGY_NOW:
473         case POWER_SUPPLY_PROP_ENERGY_FULL:
474         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
475         case POWER_SUPPLY_PROP_CHARGE_NOW:
476         case POWER_SUPPLY_PROP_CHARGE_FULL:
477         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
478         case POWER_SUPPLY_PROP_CAPACITY:
479                 ret = bq20z75_get_property_index(client, psp);
480                 if (ret < 0)
481                         break;
482
483                 ret = bq20z75_get_battery_capacity(client, ret, psp, val);
484                 break;
485
486         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
487                 ret = bq20z75_get_battery_serial_number(client, val);
488                 break;
489
490         case POWER_SUPPLY_PROP_STATUS:
491         case POWER_SUPPLY_PROP_CYCLE_COUNT:
492         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
493         case POWER_SUPPLY_PROP_CURRENT_NOW:
494         case POWER_SUPPLY_PROP_TEMP:
495         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
496         case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
497         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
498                 ret = bq20z75_get_property_index(client, psp);
499                 if (ret < 0)
500                         break;
501
502                 ret = bq20z75_get_battery_property(client, ret, psp, val);
503                 break;
504
505         default:
506                 dev_err(&client->dev,
507                         "%s: INVALID property\n", __func__);
508                 return -EINVAL;
509         }
510
511         if (!bq20z75_device->enable_detection)
512                 goto done;
513
514         if (!bq20z75_device->gpio_detect &&
515                 bq20z75_device->is_present != (ret >= 0)) {
516                 bq20z75_device->is_present = (ret >= 0);
517                 power_supply_changed(&bq20z75_device->power_supply);
518         }
519
520 done:
521         if (!ret) {
522                 /* Convert units to match requirements for power supply class */
523                 bq20z75_unit_adjustment(client, psp, val);
524         }
525
526         dev_dbg(&client->dev,
527                 "%s: property = %d, value = %x\n", __func__, psp, val->intval);
528
529         if (ret && bq20z75_device->is_present)
530                 return ret;
531
532         /* battery not present, so return NODATA for properties */
533         if (ret)
534                 return -ENODATA;
535
536         return 0;
537 }
538
539 static irqreturn_t bq20z75_irq(int irq, void *devid)
540 {
541         struct power_supply *battery = devid;
542
543         power_supply_changed(battery);
544
545         return IRQ_HANDLED;
546 }
547
548 static int __devinit bq20z75_probe(struct i2c_client *client,
549         const struct i2c_device_id *id)
550 {
551         struct bq20z75_info *bq20z75_device;
552         struct bq20z75_platform_data *pdata = client->dev.platform_data;
553         int rc;
554         int irq;
555
556         bq20z75_device = kzalloc(sizeof(struct bq20z75_info), GFP_KERNEL);
557         if (!bq20z75_device)
558                 return -ENOMEM;
559
560         bq20z75_device->client = client;
561         bq20z75_device->enable_detection = false;
562         bq20z75_device->gpio_detect = false;
563         bq20z75_device->power_supply.name = "battery";
564         bq20z75_device->power_supply.type = POWER_SUPPLY_TYPE_BATTERY;
565         bq20z75_device->power_supply.properties = bq20z75_properties;
566         bq20z75_device->power_supply.num_properties =
567                 ARRAY_SIZE(bq20z75_properties);
568         bq20z75_device->power_supply.get_property = bq20z75_get_property;
569
570         if (pdata) {
571                 bq20z75_device->gpio_detect =
572                         gpio_is_valid(pdata->battery_detect);
573                 bq20z75_device->pdata = pdata;
574         }
575
576         i2c_set_clientdata(client, bq20z75_device);
577
578         if (!bq20z75_device->gpio_detect)
579                 goto skip_gpio;
580
581         rc = gpio_request(pdata->battery_detect, dev_name(&client->dev));
582         if (rc) {
583                 dev_warn(&client->dev, "Failed to request gpio: %d\n", rc);
584                 bq20z75_device->gpio_detect = false;
585                 goto skip_gpio;
586         }
587
588         rc = gpio_direction_input(pdata->battery_detect);
589         if (rc) {
590                 dev_warn(&client->dev, "Failed to get gpio as input: %d\n", rc);
591                 gpio_free(pdata->battery_detect);
592                 bq20z75_device->gpio_detect = false;
593                 goto skip_gpio;
594         }
595
596         irq = gpio_to_irq(pdata->battery_detect);
597         if (irq <= 0) {
598                 dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq);
599                 gpio_free(pdata->battery_detect);
600                 bq20z75_device->gpio_detect = false;
601                 goto skip_gpio;
602         }
603
604         rc = request_irq(irq, bq20z75_irq,
605                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
606                 dev_name(&client->dev), &bq20z75_device->power_supply);
607         if (rc) {
608                 dev_warn(&client->dev, "Failed to request irq: %d\n", rc);
609                 gpio_free(pdata->battery_detect);
610                 bq20z75_device->gpio_detect = false;
611                 goto skip_gpio;
612         }
613
614         bq20z75_device->irq = irq;
615
616 skip_gpio:
617
618         rc = power_supply_register(&client->dev, &bq20z75_device->power_supply);
619         if (rc) {
620                 dev_err(&client->dev,
621                         "%s: Failed to register power supply\n", __func__);
622                 goto exit_psupply;
623         }
624
625         dev_info(&client->dev,
626                 "%s: battery gas gauge device registered\n", client->name);
627
628         return 0;
629
630 exit_psupply:
631         if (bq20z75_device->irq)
632                 free_irq(bq20z75_device->irq, &bq20z75_device->power_supply);
633         if (bq20z75_device->gpio_detect)
634                 gpio_free(pdata->battery_detect);
635
636         kfree(bq20z75_device);
637
638         return rc;
639 }
640
641 static int __devexit bq20z75_remove(struct i2c_client *client)
642 {
643         struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
644
645         if (bq20z75_device->irq)
646                 free_irq(bq20z75_device->irq, &bq20z75_device->power_supply);
647         if (bq20z75_device->gpio_detect)
648                 gpio_free(bq20z75_device->pdata->battery_detect);
649
650         power_supply_unregister(&bq20z75_device->power_supply);
651         kfree(bq20z75_device);
652         bq20z75_device = NULL;
653
654         return 0;
655 }
656
657 #if defined CONFIG_PM
658 static int bq20z75_suspend(struct i2c_client *client,
659         pm_message_t state)
660 {
661         struct bq20z75_info *bq20z75_device = i2c_get_clientdata(client);
662         s32 ret;
663
664         /* write to manufacturer access with sleep command */
665         ret = bq20z75_write_word_data(client,
666                 bq20z75_data[REG_MANUFACTURER_DATA].addr,
667                 MANUFACTURER_ACCESS_SLEEP);
668         if (bq20z75_device->is_present && ret < 0)
669                 return ret;
670
671         return 0;
672 }
673 #else
674 #define bq20z75_suspend         NULL
675 #endif
676 /* any smbus transaction will wake up bq20z75 */
677 #define bq20z75_resume          NULL
678
679 static const struct i2c_device_id bq20z75_id[] = {
680         { "bq20z75", 0 },
681         {}
682 };
683 MODULE_DEVICE_TABLE(i2c, bq20z75_id);
684
685 static struct i2c_driver bq20z75_battery_driver = {
686         .probe          = bq20z75_probe,
687         .remove         = __devexit_p(bq20z75_remove),
688         .suspend        = bq20z75_suspend,
689         .resume         = bq20z75_resume,
690         .id_table       = bq20z75_id,
691         .driver = {
692                 .name   = "bq20z75-battery",
693         },
694 };
695
696 static int __init bq20z75_battery_init(void)
697 {
698         return i2c_add_driver(&bq20z75_battery_driver);
699 }
700 module_init(bq20z75_battery_init);
701
702 static void __exit bq20z75_battery_exit(void)
703 {
704         i2c_del_driver(&bq20z75_battery_driver);
705 }
706 module_exit(bq20z75_battery_exit);
707
708 MODULE_DESCRIPTION("BQ20z75 battery monitor driver");
709 MODULE_LICENSE("GPL");