drm/i915: SDVO hotplug have different interrupt status bits for i915/i965/g4x
[linux-2.6.git] / drivers / power / sbs-battery.c
1 /*
2  * Gas Gauge driver for SBS Compliant Batteries
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/sbs-battery.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 sbs_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 SBS_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 chip_data {
78         enum power_supply_property psp;
79         u8 addr;
80         int min_value;
81         int max_value;
82 } sbs_data[] = {
83         [REG_MANUFACTURER_DATA] =
84                 SBS_DATA(POWER_SUPPLY_PROP_PRESENT, 0x00, 0, 65535),
85         [REG_TEMPERATURE] =
86                 SBS_DATA(POWER_SUPPLY_PROP_TEMP, 0x08, 0, 65535),
87         [REG_VOLTAGE] =
88                 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_NOW, 0x09, 0, 20000),
89         [REG_CURRENT] =
90                 SBS_DATA(POWER_SUPPLY_PROP_CURRENT_NOW, 0x0A, -32768, 32767),
91         [REG_CAPACITY] =
92                 SBS_DATA(POWER_SUPPLY_PROP_CAPACITY, 0x0E, 0, 100),
93         [REG_REMAINING_CAPACITY] =
94                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_NOW, 0x0F, 0, 65535),
95         [REG_REMAINING_CAPACITY_CHARGE] =
96                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_NOW, 0x0F, 0, 65535),
97         [REG_FULL_CHARGE_CAPACITY] =
98                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL, 0x10, 0, 65535),
99         [REG_FULL_CHARGE_CAPACITY_CHARGE] =
100                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL, 0x10, 0, 65535),
101         [REG_TIME_TO_EMPTY] =
102                 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 0x12, 0, 65535),
103         [REG_TIME_TO_FULL] =
104                 SBS_DATA(POWER_SUPPLY_PROP_TIME_TO_FULL_AVG, 0x13, 0, 65535),
105         [REG_STATUS] =
106                 SBS_DATA(POWER_SUPPLY_PROP_STATUS, 0x16, 0, 65535),
107         [REG_CYCLE_COUNT] =
108                 SBS_DATA(POWER_SUPPLY_PROP_CYCLE_COUNT, 0x17, 0, 65535),
109         [REG_DESIGN_CAPACITY] =
110                 SBS_DATA(POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN, 0x18, 0, 65535),
111         [REG_DESIGN_CAPACITY_CHARGE] =
112                 SBS_DATA(POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 0x18, 0, 65535),
113         [REG_DESIGN_VOLTAGE] =
114                 SBS_DATA(POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, 0x19, 0, 65535),
115         [REG_SERIAL_NUMBER] =
116                 SBS_DATA(POWER_SUPPLY_PROP_SERIAL_NUMBER, 0x1C, 0, 65535),
117 };
118
119 static enum power_supply_property sbs_properties[] = {
120         POWER_SUPPLY_PROP_STATUS,
121         POWER_SUPPLY_PROP_HEALTH,
122         POWER_SUPPLY_PROP_PRESENT,
123         POWER_SUPPLY_PROP_TECHNOLOGY,
124         POWER_SUPPLY_PROP_CYCLE_COUNT,
125         POWER_SUPPLY_PROP_VOLTAGE_NOW,
126         POWER_SUPPLY_PROP_CURRENT_NOW,
127         POWER_SUPPLY_PROP_CAPACITY,
128         POWER_SUPPLY_PROP_TEMP,
129         POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG,
130         POWER_SUPPLY_PROP_TIME_TO_FULL_AVG,
131         POWER_SUPPLY_PROP_SERIAL_NUMBER,
132         POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
133         POWER_SUPPLY_PROP_ENERGY_NOW,
134         POWER_SUPPLY_PROP_ENERGY_FULL,
135         POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN,
136         POWER_SUPPLY_PROP_CHARGE_NOW,
137         POWER_SUPPLY_PROP_CHARGE_FULL,
138         POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
139 };
140
141 struct sbs_info {
142         struct i2c_client               *client;
143         struct power_supply             power_supply;
144         struct sbs_platform_data        *pdata;
145         bool                            is_present;
146         bool                            gpio_detect;
147         bool                            enable_detection;
148         int                             irq;
149         int                             last_state;
150         int                             poll_time;
151         struct delayed_work             work;
152         int                             ignore_changes;
153 };
154
155 static int sbs_read_word_data(struct i2c_client *client, u8 address)
156 {
157         struct sbs_info *chip = i2c_get_clientdata(client);
158         s32 ret = 0;
159         int retries = 1;
160
161         if (chip->pdata)
162                 retries = max(chip->pdata->i2c_retry_count + 1, 1);
163
164         while (retries > 0) {
165                 ret = i2c_smbus_read_word_data(client, address);
166                 if (ret >= 0)
167                         break;
168                 retries--;
169         }
170
171         if (ret < 0) {
172                 dev_dbg(&client->dev,
173                         "%s: i2c read at address 0x%x failed\n",
174                         __func__, address);
175                 return ret;
176         }
177
178         return le16_to_cpu(ret);
179 }
180
181 static int sbs_write_word_data(struct i2c_client *client, u8 address,
182         u16 value)
183 {
184         struct sbs_info *chip = i2c_get_clientdata(client);
185         s32 ret = 0;
186         int retries = 1;
187
188         if (chip->pdata)
189                 retries = max(chip->pdata->i2c_retry_count + 1, 1);
190
191         while (retries > 0) {
192                 ret = i2c_smbus_write_word_data(client, address,
193                         le16_to_cpu(value));
194                 if (ret >= 0)
195                         break;
196                 retries--;
197         }
198
199         if (ret < 0) {
200                 dev_dbg(&client->dev,
201                         "%s: i2c write to address 0x%x failed\n",
202                         __func__, address);
203                 return ret;
204         }
205
206         return 0;
207 }
208
209 static int sbs_get_battery_presence_and_health(
210         struct i2c_client *client, enum power_supply_property psp,
211         union power_supply_propval *val)
212 {
213         s32 ret;
214         struct sbs_info *chip = i2c_get_clientdata(client);
215
216         if (psp == POWER_SUPPLY_PROP_PRESENT &&
217                 chip->gpio_detect) {
218                 ret = gpio_get_value(chip->pdata->battery_detect);
219                 if (ret == chip->pdata->battery_detect_present)
220                         val->intval = 1;
221                 else
222                         val->intval = 0;
223                 chip->is_present = val->intval;
224                 return ret;
225         }
226
227         /* Write to ManufacturerAccess with
228          * ManufacturerAccess command and then
229          * read the status */
230         ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr,
231                                         MANUFACTURER_ACCESS_STATUS);
232         if (ret < 0) {
233                 if (psp == POWER_SUPPLY_PROP_PRESENT)
234                         val->intval = 0; /* battery removed */
235                 return ret;
236         }
237
238         ret = sbs_read_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr);
239         if (ret < 0)
240                 return ret;
241
242         if (ret < sbs_data[REG_MANUFACTURER_DATA].min_value ||
243             ret > sbs_data[REG_MANUFACTURER_DATA].max_value) {
244                 val->intval = 0;
245                 return 0;
246         }
247
248         /* Mask the upper nibble of 2nd byte and
249          * lower byte of response then
250          * shift the result by 8 to get status*/
251         ret &= 0x0F00;
252         ret >>= 8;
253         if (psp == POWER_SUPPLY_PROP_PRESENT) {
254                 if (ret == 0x0F)
255                         /* battery removed */
256                         val->intval = 0;
257                 else
258                         val->intval = 1;
259         } else if (psp == POWER_SUPPLY_PROP_HEALTH) {
260                 if (ret == 0x09)
261                         val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
262                 else if (ret == 0x0B)
263                         val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
264                 else if (ret == 0x0C)
265                         val->intval = POWER_SUPPLY_HEALTH_DEAD;
266                 else
267                         val->intval = POWER_SUPPLY_HEALTH_GOOD;
268         }
269
270         return 0;
271 }
272
273 static int sbs_get_battery_property(struct i2c_client *client,
274         int reg_offset, enum power_supply_property psp,
275         union power_supply_propval *val)
276 {
277         struct sbs_info *chip = i2c_get_clientdata(client);
278         s32 ret;
279
280         ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
281         if (ret < 0)
282                 return ret;
283
284         /* returned values are 16 bit */
285         if (sbs_data[reg_offset].min_value < 0)
286                 ret = (s16)ret;
287
288         if (ret >= sbs_data[reg_offset].min_value &&
289             ret <= sbs_data[reg_offset].max_value) {
290                 val->intval = ret;
291                 if (psp != POWER_SUPPLY_PROP_STATUS)
292                         return 0;
293
294                 if (ret & BATTERY_FULL_CHARGED)
295                         val->intval = POWER_SUPPLY_STATUS_FULL;
296                 else if (ret & BATTERY_FULL_DISCHARGED)
297                         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
298                 else if (ret & BATTERY_DISCHARGING)
299                         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
300                 else
301                         val->intval = POWER_SUPPLY_STATUS_CHARGING;
302
303                 if (chip->poll_time == 0)
304                         chip->last_state = val->intval;
305                 else if (chip->last_state != val->intval) {
306                         cancel_delayed_work_sync(&chip->work);
307                         power_supply_changed(&chip->power_supply);
308                         chip->poll_time = 0;
309                 }
310         } else {
311                 if (psp == POWER_SUPPLY_PROP_STATUS)
312                         val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
313                 else
314                         val->intval = 0;
315         }
316
317         return 0;
318 }
319
320 static void  sbs_unit_adjustment(struct i2c_client *client,
321         enum power_supply_property psp, union power_supply_propval *val)
322 {
323 #define BASE_UNIT_CONVERSION            1000
324 #define BATTERY_MODE_CAP_MULT_WATT      (10 * BASE_UNIT_CONVERSION)
325 #define TIME_UNIT_CONVERSION            60
326 #define TEMP_KELVIN_TO_CELSIUS          2731
327         switch (psp) {
328         case POWER_SUPPLY_PROP_ENERGY_NOW:
329         case POWER_SUPPLY_PROP_ENERGY_FULL:
330         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
331                 /* sbs provides energy in units of 10mWh.
332                  * Convert to µWh
333                  */
334                 val->intval *= BATTERY_MODE_CAP_MULT_WATT;
335                 break;
336
337         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
338         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
339         case POWER_SUPPLY_PROP_CURRENT_NOW:
340         case POWER_SUPPLY_PROP_CHARGE_NOW:
341         case POWER_SUPPLY_PROP_CHARGE_FULL:
342         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
343                 val->intval *= BASE_UNIT_CONVERSION;
344                 break;
345
346         case POWER_SUPPLY_PROP_TEMP:
347                 /* sbs provides battery temperature in 0.1K
348                  * so convert it to 0.1°C
349                  */
350                 val->intval -= TEMP_KELVIN_TO_CELSIUS;
351                 break;
352
353         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
354         case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
355                 /* sbs provides time to empty and time to full in minutes.
356                  * Convert to seconds
357                  */
358                 val->intval *= TIME_UNIT_CONVERSION;
359                 break;
360
361         default:
362                 dev_dbg(&client->dev,
363                         "%s: no need for unit conversion %d\n", __func__, psp);
364         }
365 }
366
367 static enum sbs_battery_mode sbs_set_battery_mode(struct i2c_client *client,
368         enum sbs_battery_mode mode)
369 {
370         int ret, original_val;
371
372         original_val = sbs_read_word_data(client, BATTERY_MODE_OFFSET);
373         if (original_val < 0)
374                 return original_val;
375
376         if ((original_val & BATTERY_MODE_MASK) == mode)
377                 return mode;
378
379         if (mode == BATTERY_MODE_AMPS)
380                 ret = original_val & ~BATTERY_MODE_MASK;
381         else
382                 ret = original_val | BATTERY_MODE_MASK;
383
384         ret = sbs_write_word_data(client, BATTERY_MODE_OFFSET, ret);
385         if (ret < 0)
386                 return ret;
387
388         return original_val & BATTERY_MODE_MASK;
389 }
390
391 static int sbs_get_battery_capacity(struct i2c_client *client,
392         int reg_offset, enum power_supply_property psp,
393         union power_supply_propval *val)
394 {
395         s32 ret;
396         enum sbs_battery_mode mode = BATTERY_MODE_WATTS;
397
398         if (power_supply_is_amp_property(psp))
399                 mode = BATTERY_MODE_AMPS;
400
401         mode = sbs_set_battery_mode(client, mode);
402         if (mode < 0)
403                 return mode;
404
405         ret = sbs_read_word_data(client, sbs_data[reg_offset].addr);
406         if (ret < 0)
407                 return ret;
408
409         if (psp == POWER_SUPPLY_PROP_CAPACITY) {
410                 /* sbs spec says that this can be >100 %
411                 * even if max value is 100 % */
412                 val->intval = min(ret, 100);
413         } else
414                 val->intval = ret;
415
416         ret = sbs_set_battery_mode(client, mode);
417         if (ret < 0)
418                 return ret;
419
420         return 0;
421 }
422
423 static char sbs_serial[5];
424 static int sbs_get_battery_serial_number(struct i2c_client *client,
425         union power_supply_propval *val)
426 {
427         int ret;
428
429         ret = sbs_read_word_data(client, sbs_data[REG_SERIAL_NUMBER].addr);
430         if (ret < 0)
431                 return ret;
432
433         ret = sprintf(sbs_serial, "%04x", ret);
434         val->strval = sbs_serial;
435
436         return 0;
437 }
438
439 static int sbs_get_property_index(struct i2c_client *client,
440         enum power_supply_property psp)
441 {
442         int count;
443         for (count = 0; count < ARRAY_SIZE(sbs_data); count++)
444                 if (psp == sbs_data[count].psp)
445                         return count;
446
447         dev_warn(&client->dev,
448                 "%s: Invalid Property - %d\n", __func__, psp);
449
450         return -EINVAL;
451 }
452
453 static int sbs_get_property(struct power_supply *psy,
454         enum power_supply_property psp,
455         union power_supply_propval *val)
456 {
457         int ret = 0;
458         struct sbs_info *chip = container_of(psy,
459                                 struct sbs_info, power_supply);
460         struct i2c_client *client = chip->client;
461
462         switch (psp) {
463         case POWER_SUPPLY_PROP_PRESENT:
464         case POWER_SUPPLY_PROP_HEALTH:
465                 ret = sbs_get_battery_presence_and_health(client, psp, val);
466                 if (psp == POWER_SUPPLY_PROP_PRESENT)
467                         return 0;
468                 break;
469
470         case POWER_SUPPLY_PROP_TECHNOLOGY:
471                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
472                 break;
473
474         case POWER_SUPPLY_PROP_ENERGY_NOW:
475         case POWER_SUPPLY_PROP_ENERGY_FULL:
476         case POWER_SUPPLY_PROP_ENERGY_FULL_DESIGN:
477         case POWER_SUPPLY_PROP_CHARGE_NOW:
478         case POWER_SUPPLY_PROP_CHARGE_FULL:
479         case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
480         case POWER_SUPPLY_PROP_CAPACITY:
481                 ret = sbs_get_property_index(client, psp);
482                 if (ret < 0)
483                         break;
484
485                 ret = sbs_get_battery_capacity(client, ret, psp, val);
486                 break;
487
488         case POWER_SUPPLY_PROP_SERIAL_NUMBER:
489                 ret = sbs_get_battery_serial_number(client, val);
490                 break;
491
492         case POWER_SUPPLY_PROP_STATUS:
493         case POWER_SUPPLY_PROP_CYCLE_COUNT:
494         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
495         case POWER_SUPPLY_PROP_CURRENT_NOW:
496         case POWER_SUPPLY_PROP_TEMP:
497         case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG:
498         case POWER_SUPPLY_PROP_TIME_TO_FULL_AVG:
499         case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
500                 ret = sbs_get_property_index(client, psp);
501                 if (ret < 0)
502                         break;
503
504                 ret = sbs_get_battery_property(client, ret, psp, val);
505                 break;
506
507         default:
508                 dev_err(&client->dev,
509                         "%s: INVALID property\n", __func__);
510                 return -EINVAL;
511         }
512
513         if (!chip->enable_detection)
514                 goto done;
515
516         if (!chip->gpio_detect &&
517                 chip->is_present != (ret >= 0)) {
518                 chip->is_present = (ret >= 0);
519                 power_supply_changed(&chip->power_supply);
520         }
521
522 done:
523         if (!ret) {
524                 /* Convert units to match requirements for power supply class */
525                 sbs_unit_adjustment(client, psp, val);
526         }
527
528         dev_dbg(&client->dev,
529                 "%s: property = %d, value = %x\n", __func__, psp, val->intval);
530
531         if (ret && chip->is_present)
532                 return ret;
533
534         /* battery not present, so return NODATA for properties */
535         if (ret)
536                 return -ENODATA;
537
538         return 0;
539 }
540
541 static irqreturn_t sbs_irq(int irq, void *devid)
542 {
543         struct power_supply *battery = devid;
544
545         power_supply_changed(battery);
546
547         return IRQ_HANDLED;
548 }
549
550 static void sbs_external_power_changed(struct power_supply *psy)
551 {
552         struct sbs_info *chip;
553
554         chip = container_of(psy, struct sbs_info, power_supply);
555
556         if (chip->ignore_changes > 0) {
557                 chip->ignore_changes--;
558                 return;
559         }
560
561         /* cancel outstanding work */
562         cancel_delayed_work_sync(&chip->work);
563
564         schedule_delayed_work(&chip->work, HZ);
565         chip->poll_time = chip->pdata->poll_retry_count;
566 }
567
568 static void sbs_delayed_work(struct work_struct *work)
569 {
570         struct sbs_info *chip;
571         s32 ret;
572
573         chip = container_of(work, struct sbs_info, work.work);
574
575         ret = sbs_read_word_data(chip->client, sbs_data[REG_STATUS].addr);
576         /* if the read failed, give up on this work */
577         if (ret < 0) {
578                 chip->poll_time = 0;
579                 return;
580         }
581
582         if (ret & BATTERY_FULL_CHARGED)
583                 ret = POWER_SUPPLY_STATUS_FULL;
584         else if (ret & BATTERY_FULL_DISCHARGED)
585                 ret = POWER_SUPPLY_STATUS_NOT_CHARGING;
586         else if (ret & BATTERY_DISCHARGING)
587                 ret = POWER_SUPPLY_STATUS_DISCHARGING;
588         else
589                 ret = POWER_SUPPLY_STATUS_CHARGING;
590
591         if (chip->last_state != ret) {
592                 chip->poll_time = 0;
593                 power_supply_changed(&chip->power_supply);
594                 return;
595         }
596         if (chip->poll_time > 0) {
597                 schedule_delayed_work(&chip->work, HZ);
598                 chip->poll_time--;
599                 return;
600         }
601 }
602
603 #if defined(CONFIG_OF)
604
605 #include <linux/of_device.h>
606 #include <linux/of_gpio.h>
607
608 static const struct of_device_id sbs_dt_ids[] = {
609         { .compatible = "sbs,sbs-battery" },
610         { .compatible = "ti,bq20z75" },
611         { }
612 };
613 MODULE_DEVICE_TABLE(of, sbs_dt_ids);
614
615 static struct sbs_platform_data *sbs_of_populate_pdata(
616                 struct i2c_client *client)
617 {
618         struct device_node *of_node = client->dev.of_node;
619         struct sbs_platform_data *pdata = client->dev.platform_data;
620         enum of_gpio_flags gpio_flags;
621         int rc;
622         u32 prop;
623
624         /* verify this driver matches this device */
625         if (!of_node)
626                 return NULL;
627
628         /* if platform data is set, honor it */
629         if (pdata)
630                 return pdata;
631
632         /* first make sure at least one property is set, otherwise
633          * it won't change behavior from running without pdata.
634          */
635         if (!of_get_property(of_node, "sbs,i2c-retry-count", NULL) &&
636                 !of_get_property(of_node, "sbs,poll-retry-count", NULL) &&
637                 !of_get_property(of_node, "sbs,battery-detect-gpios", NULL))
638                 goto of_out;
639
640         pdata = devm_kzalloc(&client->dev, sizeof(struct sbs_platform_data),
641                                 GFP_KERNEL);
642         if (!pdata)
643                 goto of_out;
644
645         rc = of_property_read_u32(of_node, "sbs,i2c-retry-count", &prop);
646         if (!rc)
647                 pdata->i2c_retry_count = prop;
648
649         rc = of_property_read_u32(of_node, "sbs,poll-retry-count", &prop);
650         if (!rc)
651                 pdata->poll_retry_count = prop;
652
653         if (!of_get_property(of_node, "sbs,battery-detect-gpios", NULL)) {
654                 pdata->battery_detect = -1;
655                 goto of_out;
656         }
657
658         pdata->battery_detect = of_get_named_gpio_flags(of_node,
659                         "sbs,battery-detect-gpios", 0, &gpio_flags);
660
661         if (gpio_flags & OF_GPIO_ACTIVE_LOW)
662                 pdata->battery_detect_present = 0;
663         else
664                 pdata->battery_detect_present = 1;
665
666 of_out:
667         return pdata;
668 }
669 #else
670 #define sbs_dt_ids NULL
671 static struct sbs_platform_data *sbs_of_populate_pdata(
672         struct i2c_client *client)
673 {
674         return client->dev.platform_data;
675 }
676 #endif
677
678 static int __devinit sbs_probe(struct i2c_client *client,
679         const struct i2c_device_id *id)
680 {
681         struct sbs_info *chip;
682         struct sbs_platform_data *pdata = client->dev.platform_data;
683         int rc;
684         int irq;
685         char *name;
686
687         name = kasprintf(GFP_KERNEL, "sbs-%s", dev_name(&client->dev));
688         if (!name) {
689                 dev_err(&client->dev, "Failed to allocate device name\n");
690                 return -ENOMEM;
691         }
692
693         chip = kzalloc(sizeof(struct sbs_info), GFP_KERNEL);
694         if (!chip) {
695                 rc = -ENOMEM;
696                 goto exit_free_name;
697         }
698
699         chip->client = client;
700         chip->enable_detection = false;
701         chip->gpio_detect = false;
702         chip->power_supply.name = name;
703         chip->power_supply.type = POWER_SUPPLY_TYPE_BATTERY;
704         chip->power_supply.properties = sbs_properties;
705         chip->power_supply.num_properties = ARRAY_SIZE(sbs_properties);
706         chip->power_supply.get_property = sbs_get_property;
707         /* ignore first notification of external change, it is generated
708          * from the power_supply_register call back
709          */
710         chip->ignore_changes = 1;
711         chip->last_state = POWER_SUPPLY_STATUS_UNKNOWN;
712         chip->power_supply.external_power_changed = sbs_external_power_changed;
713
714         pdata = sbs_of_populate_pdata(client);
715
716         if (pdata) {
717                 chip->gpio_detect = gpio_is_valid(pdata->battery_detect);
718                 chip->pdata = pdata;
719         }
720
721         i2c_set_clientdata(client, chip);
722
723         if (!chip->gpio_detect)
724                 goto skip_gpio;
725
726         rc = gpio_request(pdata->battery_detect, dev_name(&client->dev));
727         if (rc) {
728                 dev_warn(&client->dev, "Failed to request gpio: %d\n", rc);
729                 chip->gpio_detect = false;
730                 goto skip_gpio;
731         }
732
733         rc = gpio_direction_input(pdata->battery_detect);
734         if (rc) {
735                 dev_warn(&client->dev, "Failed to get gpio as input: %d\n", rc);
736                 gpio_free(pdata->battery_detect);
737                 chip->gpio_detect = false;
738                 goto skip_gpio;
739         }
740
741         irq = gpio_to_irq(pdata->battery_detect);
742         if (irq <= 0) {
743                 dev_warn(&client->dev, "Failed to get gpio as irq: %d\n", irq);
744                 gpio_free(pdata->battery_detect);
745                 chip->gpio_detect = false;
746                 goto skip_gpio;
747         }
748
749         rc = request_irq(irq, sbs_irq,
750                 IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
751                 dev_name(&client->dev), &chip->power_supply);
752         if (rc) {
753                 dev_warn(&client->dev, "Failed to request irq: %d\n", rc);
754                 gpio_free(pdata->battery_detect);
755                 chip->gpio_detect = false;
756                 goto skip_gpio;
757         }
758
759         chip->irq = irq;
760
761 skip_gpio:
762
763         rc = power_supply_register(&client->dev, &chip->power_supply);
764         if (rc) {
765                 dev_err(&client->dev,
766                         "%s: Failed to register power supply\n", __func__);
767                 goto exit_psupply;
768         }
769
770         dev_info(&client->dev,
771                 "%s: battery gas gauge device registered\n", client->name);
772
773         INIT_DELAYED_WORK(&chip->work, sbs_delayed_work);
774
775         chip->enable_detection = true;
776
777         return 0;
778
779 exit_psupply:
780         if (chip->irq)
781                 free_irq(chip->irq, &chip->power_supply);
782         if (chip->gpio_detect)
783                 gpio_free(pdata->battery_detect);
784
785         kfree(chip);
786
787 exit_free_name:
788         kfree(name);
789
790         return rc;
791 }
792
793 static int __devexit sbs_remove(struct i2c_client *client)
794 {
795         struct sbs_info *chip = i2c_get_clientdata(client);
796
797         if (chip->irq)
798                 free_irq(chip->irq, &chip->power_supply);
799         if (chip->gpio_detect)
800                 gpio_free(chip->pdata->battery_detect);
801
802         power_supply_unregister(&chip->power_supply);
803
804         cancel_delayed_work_sync(&chip->work);
805
806         kfree(chip->power_supply.name);
807         kfree(chip);
808         chip = NULL;
809
810         return 0;
811 }
812
813 #if defined CONFIG_PM
814 static int sbs_suspend(struct i2c_client *client,
815         pm_message_t state)
816 {
817         struct sbs_info *chip = i2c_get_clientdata(client);
818         s32 ret;
819
820         if (chip->poll_time > 0)
821                 cancel_delayed_work_sync(&chip->work);
822
823         /* write to manufacturer access with sleep command */
824         ret = sbs_write_word_data(client, sbs_data[REG_MANUFACTURER_DATA].addr,
825                 MANUFACTURER_ACCESS_SLEEP);
826         if (chip->is_present && ret < 0)
827                 return ret;
828
829         return 0;
830 }
831 #else
832 #define sbs_suspend             NULL
833 #endif
834 /* any smbus transaction will wake up sbs */
835 #define sbs_resume              NULL
836
837 static const struct i2c_device_id sbs_id[] = {
838         { "bq20z75", 0 },
839         { "sbs-battery", 1 },
840         {}
841 };
842 MODULE_DEVICE_TABLE(i2c, sbs_id);
843
844 static struct i2c_driver sbs_battery_driver = {
845         .probe          = sbs_probe,
846         .remove         = __devexit_p(sbs_remove),
847         .suspend        = sbs_suspend,
848         .resume         = sbs_resume,
849         .id_table       = sbs_id,
850         .driver = {
851                 .name   = "sbs-battery",
852                 .of_match_table = sbs_dt_ids,
853         },
854 };
855 module_i2c_driver(sbs_battery_driver);
856
857 MODULE_DESCRIPTION("SBS battery monitor driver");
858 MODULE_LICENSE("GPL");