power: max17048: reduce debug message
[linux-2.6.git] / drivers / power / max17048_battery.c
1 /*
2  *  max17048_battery.c
3  *  fuel-gauge systems for lithium-ion (Li+) batteries
4  *
5  * Copyright (c) 2012-2013, NVIDIA CORPORATION.  All rights reserved.
6  *  Chandler Zhang <chazhang@nvidia.com>
7  *  Syed Rafiuddin <srafiuddin@nvidia.com>
8  *
9  * This program is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License version 2 as
11  * published by the Free Software Foundation.
12  */
13
14 #include <asm/unaligned.h>
15 #include <linux/module.h>
16 #include <linux/init.h>
17 #include <linux/platform_device.h>
18 #include <linux/mutex.h>
19 #include <linux/err.h>
20 #include <linux/i2c.h>
21 #include <linux/delay.h>
22 #include <linux/power_supply.h>
23 #include <linux/slab.h>
24 #include <linux/interrupt.h>
25 #include <linux/max17048_battery.h>
26 #include <linux/jiffies.h>
27 #include <linux/thermal.h>
28 #include <generated/mach-types.h>
29
30 #define MAX17048_VCELL          0x02
31 #define MAX17048_SOC            0x04
32 #define MAX17048_VER            0x08
33 #define MAX17048_HIBRT          0x0A
34 #define MAX17048_CONFIG         0x0C
35 #define MAX17048_OCV            0x0E
36 #define MAX17048_VALRT          0x14
37 #define MAX17048_VRESET         0x18
38 #define MAX17048_STATUS         0x1A
39 #define MAX17048_UNLOCK         0x3E
40 #define MAX17048_TABLE          0x40
41 #define MAX17048_RCOMPSEG1      0x80
42 #define MAX17048_RCOMPSEG2      0x90
43 #define MAX17048_CMD            0xFF
44 #define MAX17048_UNLOCK_VALUE   0x4a57
45 #define MAX17048_RESET_VALUE    0x5400
46 #define MAX17048_DELAY      (10*HZ)
47 #define MAX17048_BATTERY_FULL   100
48 #define MAX17048_BATTERY_LOW    15
49 #define MAX17048_VERSION_NO_11  0x11
50 #define MAX17048_VERSION_NO_12  0x12
51
52 /* MAX17048 ALERT interrupts */
53 #define MAX17048_STATUS_RI              0x0100 /* reset */
54 #define MAX17048_STATUS_VH              0x0200 /* voltage high */
55 #define MAX17048_STATUS_VL              0x0400 /* voltage low */
56 #define MAX17048_STATUS_VR              0x0800 /* voltage reset */
57 #define MAX17048_STATUS_HD              0x1000 /* SOC low  */
58 #define MAX17048_STATUS_SC              0x2000 /* 1% SOC change */
59 #define MAX17048_STATUS_ENVR            0x4000 /* enable voltage reset alert */
60
61 #define MAX17048_CONFIG_ALRT            0x0020 /* CONFIG.ALRT bit*/
62
63 /* #define DEBUG_PRINTK_SOC_VCELL */
64
65 struct max17048_chip {
66         struct i2c_client               *client;
67         struct delayed_work             work;
68         struct power_supply             battery;
69         struct max17048_platform_data *pdata;
70
71         /* battery voltage */
72         int vcell;
73         /* battery capacity */
74         int soc;
75         /* State Of Charge */
76         int status;
77         /* battery health */
78         int health;
79         /* battery capacity */
80         int capacity_level;
81         /* battery temperature */
82         long temperature;
83
84         int internal_soc;
85         int lasttime_soc;
86         int lasttime_status;
87         long lasttime_temperature;
88
89         int shutdown_complete;
90         struct mutex mutex;
91 };
92 struct max17048_chip *max17048_data;
93
94 static int max17048_write_word(struct i2c_client *client, int reg, u16 value)
95 {
96         struct max17048_chip *chip = i2c_get_clientdata(client);
97         int ret;
98
99         mutex_lock(&chip->mutex);
100         if (chip && chip->shutdown_complete) {
101                 mutex_unlock(&chip->mutex);
102                 return -ENODEV;
103         }
104
105
106         ret = i2c_smbus_write_word_data(client, reg, swab16(value));
107
108         if (ret < 0)
109                 dev_err(&client->dev, "%s(): Failed in writing register"
110                                         "0x%02x err %d\n", __func__, reg, ret);
111
112         mutex_unlock(&chip->mutex);
113         return ret;
114 }
115
116
117 static int max17048_write_block(const struct i2c_client *client,
118                 uint8_t command, uint8_t length, const uint8_t *values)
119 {
120         struct max17048_chip *chip = i2c_get_clientdata(client);
121         int ret;
122
123         mutex_lock(&chip->mutex);
124         if (chip && chip->shutdown_complete) {
125                 mutex_unlock(&chip->mutex);
126                 return -ENODEV;
127         }
128
129         ret = i2c_smbus_write_i2c_block_data(client, command, length, values);
130         if (ret < 0)
131                 dev_err(&client->dev, "%s(): Failed in writing block data to"
132                                 "0x%02x err %d\n", __func__, command, ret);
133         mutex_unlock(&chip->mutex);
134         return ret;
135 }
136
137
138 static int max17048_read_word(struct i2c_client *client, int reg)
139 {
140         struct max17048_chip *chip = i2c_get_clientdata(client);
141         int ret;
142
143         mutex_lock(&chip->mutex);
144         if (chip && chip->shutdown_complete) {
145                 mutex_unlock(&chip->mutex);
146                 return -ENODEV;
147         }
148
149         ret = i2c_smbus_read_word_data(client, reg);
150         if (ret < 0) {
151                 dev_err(&client->dev, "%s(): Failed in reading register"
152                                         "0x%02x err %d\n", __func__, reg, ret);
153
154                 mutex_unlock(&chip->mutex);
155                 return ret;
156         } else {
157                 ret = (int)swab16((uint16_t)(ret & 0x0000ffff));
158
159                 mutex_unlock(&chip->mutex);
160                 return ret;
161
162         }
163 }
164
165 /* Return value in uV */
166 static int max17048_get_ocv(struct max17048_chip *chip)
167 {
168         int r;
169         int reg;
170         int ocv;
171
172         r = max17048_write_word(chip->client, MAX17048_UNLOCK,
173                         MAX17048_UNLOCK_VALUE);
174         if (r)
175                 return r;
176
177         reg = max17048_read_word(chip->client, MAX17048_OCV);
178         ocv = (reg >> 4) * 1250;
179
180         r = max17048_write_word(chip->client, MAX17048_UNLOCK, 0);
181         WARN_ON(r);
182
183         return ocv;
184 }
185
186 static int max17048_get_property(struct power_supply *psy,
187                             enum power_supply_property psp,
188                             union power_supply_propval *val)
189 {
190         struct max17048_chip *chip = container_of(psy,
191                                 struct max17048_chip, battery);
192
193         switch (psp) {
194         case POWER_SUPPLY_PROP_TECHNOLOGY:
195                 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
196                 break;
197         case POWER_SUPPLY_PROP_STATUS:
198                 val->intval = chip->status;
199                 break;
200         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
201                 /* unit is uV */
202                 val->intval = chip->vcell * 1000;
203                 break;
204         case POWER_SUPPLY_PROP_CAPACITY:
205                 val->intval = chip->soc;
206                 break;
207         case POWER_SUPPLY_PROP_HEALTH:
208                 val->intval = chip->health;
209                 break;
210         case POWER_SUPPLY_PROP_CAPACITY_LEVEL:
211                 val->intval = chip->capacity_level;
212                 break;
213         case POWER_SUPPLY_PROP_VOLTAGE_OCV:
214                 /* unit is uV */
215                 val->intval = max17048_get_ocv(chip);
216                 break;
217         default:
218         return -EINVAL;
219         }
220         return 0;
221 }
222
223 static void max17048_get_vcell(struct i2c_client *client)
224 {
225         struct max17048_chip *chip = i2c_get_clientdata(client);
226         int vcell;
227
228         vcell = max17048_read_word(client, MAX17048_VCELL);
229         if (vcell < 0)
230                 dev_err(&client->dev, "%s: err %d\n", __func__, vcell);
231         else
232                 chip->vcell = (uint16_t)(((vcell >> 4) * 125) / 100);
233
234 #ifdef DEBUG_PRINTK_SOC_VCELL
235         dev_info(&client->dev, "%s(): VCELL %dmV\n", __func__, chip->vcell);
236 #endif
237 }
238
239 static void max17048_get_soc(struct i2c_client *client)
240 {
241         struct max17048_chip *chip = i2c_get_clientdata(client);
242         struct max17048_battery_model *mdata = chip->pdata->model_data;
243         int soc;
244
245         soc = max17048_read_word(client, MAX17048_SOC);
246         if (soc < 0)
247                 dev_err(&client->dev, "%s: err %d\n", __func__, soc);
248         else {
249                 if (mdata->bits == 18)
250                         chip->internal_soc = (uint16_t)soc >> 8;
251                 else
252                         chip->internal_soc = (uint16_t)soc >> 9;
253         }
254
255 #ifdef DEBUG_PRINTK_SOC_VCELL
256         dev_info(&client->dev, "%s(): SOC %d%%\n",
257                         __func__, chip->internal_soc);
258 #endif
259
260         chip->soc = chip->internal_soc;
261
262         if (chip->internal_soc >= MAX17048_BATTERY_FULL) {
263                 if (chip->status == POWER_SUPPLY_STATUS_CHARGING)
264                         chip->status = POWER_SUPPLY_STATUS_FULL;
265                 chip->soc = MAX17048_BATTERY_FULL;
266                 chip->capacity_level = POWER_SUPPLY_CAPACITY_LEVEL_FULL;
267                 chip->health = POWER_SUPPLY_HEALTH_GOOD;
268         } else if (chip->soc < MAX17048_BATTERY_LOW) {
269                 chip->status = chip->lasttime_status;
270                 chip->health = POWER_SUPPLY_HEALTH_DEAD;
271                 chip->capacity_level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
272         } else {
273                 chip->status = chip->lasttime_status;
274                 chip->health = POWER_SUPPLY_HEALTH_GOOD;
275                 chip->capacity_level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL;
276         }
277 }
278
279 static uint16_t max17048_get_version(struct i2c_client *client)
280 {
281         return max17048_read_word(client, MAX17048_VER);
282 }
283
284 static int max17048_thz_match(struct thermal_zone_device *thz, void *data)
285 {
286         return strcmp((char *)data, thz->type) == 0;
287 }
288
289 static int max17048_thz_get_temp(void *data, long *temp)
290 {
291         struct thermal_zone_device *thz;
292
293         thz = thermal_zone_device_find(data, max17048_thz_match);
294
295         if (!thz || thz->ops->get_temp(thz, temp))
296                 *temp = 20000;
297
298         return 0;
299 }
300
301 static void max17048_update_rcomp(struct max17048_chip *chip, long temp)
302 {
303         struct i2c_client *client = chip->client;
304         struct max17048_battery_model *mdata = chip->pdata->model_data;
305         int new_rcomp;
306         int ret, val;
307         s64 curr_temp;
308         s64 hot_temp, cold_temp;
309
310         curr_temp = temp;
311         hot_temp = mdata->t_co_hot;
312         cold_temp = mdata->t_co_cold;
313
314         hot_temp = div64_s64(
315                         (curr_temp - (s64)20000LL) * hot_temp,
316                         (s64)1000000LL);
317         cold_temp = div64_s64(
318                         (curr_temp - (s64)20000LL) * cold_temp,
319                         (s64)1000000LL);
320
321         if (temp > 20000)
322                 new_rcomp = mdata->rcomp + (int)hot_temp;
323         else if (temp < 20000)
324                 new_rcomp = mdata->rcomp + (int)cold_temp;
325         else
326                 new_rcomp = mdata->rcomp;
327
328         if (new_rcomp > 0xFF)
329                 new_rcomp = 0xFF;
330         else if (new_rcomp < 0)
331                 new_rcomp = 0;
332
333         dev_info(&client->dev, "%s: new_rcomp %d\n", __func__, new_rcomp);
334
335         val = max17048_read_word(client, MAX17048_CONFIG);
336         if (val < 0) {
337                 dev_err(&client->dev,
338                                 "%s(): Failed in reading register" \
339                                 "MAX17048_CONFIG err %d\n",
340                                         __func__, val);
341         } else {
342                 /* clear upper byte */
343                 val &= 0xFF;
344                 /* Apply new Rcomp value */
345                 val |= (new_rcomp << 8);
346                 ret = max17048_write_word(client, MAX17048_CONFIG, val);
347                 if (ret < 0)
348                         dev_err(&client->dev,
349                                 "failed set RCOMP\n");
350         }
351 }
352
353 static void max17048_work(struct work_struct *work)
354 {
355         struct max17048_chip *chip;
356         long temp;
357
358         chip = container_of(work, struct max17048_chip, work.work);
359
360         if (machine_is_tegratab()) {
361                 /* Use Tskin as Battery Temp */
362                 max17048_thz_get_temp("therm_est", &temp);
363
364                 if (temp >= 20000)
365                         chip->temperature = temp;
366                 else
367                         chip->temperature = 20000;
368         }
369
370         if (abs(chip->temperature - chip->lasttime_temperature) >= 1500) {
371                 dev_info(&chip->client->dev, "%s(): Temp %ldC\n",
372                                 __func__, chip->temperature / 1000);
373                 chip->lasttime_temperature = chip->temperature;
374                 max17048_update_rcomp(chip, chip->temperature);
375         }
376
377         max17048_get_vcell(chip->client);
378         max17048_get_soc(chip->client);
379
380         if (chip->soc != chip->lasttime_soc ||
381                 chip->status != chip->lasttime_status) {
382                 chip->lasttime_soc = chip->soc;
383                 power_supply_changed(&chip->battery);
384         }
385
386         schedule_delayed_work(&chip->work, MAX17048_DELAY);
387 }
388
389 void max17048_battery_status(int status,
390                                 int chrg_type)
391 {
392         if (!max17048_data)
393                 return;
394
395         if (status == progress) {
396                 max17048_data->status = POWER_SUPPLY_STATUS_CHARGING;
397         } else {
398                 max17048_data->status = POWER_SUPPLY_STATUS_DISCHARGING;
399         }
400         power_supply_changed(&max17048_data->battery);
401
402         max17048_data->lasttime_status = max17048_data->status;
403 }
404 EXPORT_SYMBOL_GPL(max17048_battery_status);
405
406 int max17048_check_vcell(void)
407 {
408         if (!max17048_data)
409                 return -1;
410
411         return max17048_data->vcell;
412 }
413 EXPORT_SYMBOL_GPL(max17048_check_vcell);
414
415 int max17048_check_soc(void)
416 {
417         if (!max17048_data)
418                 return -1;
419
420         return max17048_data->internal_soc;
421 }
422 EXPORT_SYMBOL_GPL(max17048_check_soc);
423
424 static enum power_supply_property max17048_battery_props[] = {
425         POWER_SUPPLY_PROP_TECHNOLOGY,
426         POWER_SUPPLY_PROP_STATUS,
427         POWER_SUPPLY_PROP_VOLTAGE_NOW,
428         POWER_SUPPLY_PROP_CAPACITY,
429         POWER_SUPPLY_PROP_HEALTH,
430         POWER_SUPPLY_PROP_CAPACITY_LEVEL,
431         POWER_SUPPLY_PROP_VOLTAGE_OCV
432 };
433
434 static int max17048_write_rcomp_seg(struct i2c_client *client,
435                                                 uint16_t rcomp_seg)
436 {
437         uint8_t rs1, rs2;
438         int ret;
439         uint8_t rcomp_seg_table[16];
440
441         rs1 = (rcomp_seg >> 8) & 0xff;
442         rs2 = rcomp_seg & 0xff;
443
444         rcomp_seg_table[0] = rcomp_seg_table[2] = rcomp_seg_table[4] =
445                 rcomp_seg_table[6] = rcomp_seg_table[8] = rcomp_seg_table[10] =
446                         rcomp_seg_table[12] = rcomp_seg_table[14] = rs1;
447
448         rcomp_seg_table[1] = rcomp_seg_table[3] = rcomp_seg_table[5] =
449                 rcomp_seg_table[7] = rcomp_seg_table[9] = rcomp_seg_table[11] =
450                         rcomp_seg_table[13] = rcomp_seg_table[15] = rs2;
451
452         ret = max17048_write_block(client, MAX17048_RCOMPSEG1,
453                                 16, (uint8_t *)rcomp_seg_table);
454         if (ret < 0) {
455                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
456                 return ret;
457         }
458
459         ret = max17048_write_block(client, MAX17048_RCOMPSEG2,
460                                 16, (uint8_t *)rcomp_seg_table);
461         if (ret < 0) {
462                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
463                 return ret;
464         }
465
466         return 0;
467 }
468
469 static int max17048_load_model_data(struct max17048_chip *chip)
470 {
471         struct i2c_client *client = chip->client;
472         struct max17048_battery_model *mdata = chip->pdata->model_data;
473         uint16_t soc_tst, ocv;
474         int i, ret = 0;
475
476         /* read OCV */
477         ret = max17048_read_word(client, MAX17048_OCV);
478         if (ret < 0) {
479                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
480                 return ret;
481         }
482         ocv = (uint16_t)ret;
483         if (ocv == 0xffff) {
484                 dev_err(&client->dev, "%s: Failed in unlocking"
485                                         "max17048 err: %d\n", __func__, ocv);
486                 return -1;
487         }
488
489         /* write custom model data */
490         for (i = 0; i < 4; i += 1) {
491                 if (max17048_write_block(client,
492                         (MAX17048_TABLE+i*16), 16,
493                                 &mdata->data_tbl[i*0x10]) < 0) {
494                         dev_err(&client->dev, "%s: error writing model data:\n",
495                                                                 __func__);
496                         return -1;
497                 }
498         }
499
500         /* Write OCV Test value */
501         ret = max17048_write_word(client, MAX17048_OCV, mdata->ocvtest);
502         if (ret < 0)
503                 return ret;
504
505         ret = max17048_write_rcomp_seg(client, mdata->rcomp_seg);
506         if (ret < 0)
507                 return ret;
508
509         /* Disable hibernate */
510         ret = max17048_write_word(client, MAX17048_HIBRT, 0x0000);
511         if (ret < 0)
512                 return ret;
513
514         /* Lock model access */
515         ret = max17048_write_word(client, MAX17048_UNLOCK, 0x0000);
516         if (ret < 0)
517                 return ret;
518
519         /* Delay between 150ms to 600ms */
520         mdelay(200);
521
522         /* Read SOC Register and compare to expected result */
523         ret = max17048_read_word(client, MAX17048_SOC);
524         if (ret < 0) {
525                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
526                 return ret;
527         }
528         soc_tst = (uint16_t)ret;
529         if (!((soc_tst >> 8) >= mdata->soccheck_A &&
530                                 (soc_tst >> 8) <=  mdata->soccheck_B)) {
531                 dev_err(&client->dev, "%s: soc comparison failed %d\n",
532                                         __func__, ret);
533                 return ret;
534         } else {
535                 dev_info(&client->dev, "MAX17048 Custom data"
536                                                 " loading successfull\n");
537         }
538
539         /* unlock model access */
540         ret = max17048_write_word(client, MAX17048_UNLOCK,
541                                         MAX17048_UNLOCK_VALUE);
542         if (ret < 0)
543                 return ret;
544
545         /* Restore OCV */
546         ret = max17048_write_word(client, MAX17048_OCV, ocv);
547         if (ret < 0)
548                 return ret;
549
550         return ret;
551 }
552
553 static int max17048_initialize(struct max17048_chip *chip)
554 {
555         uint8_t ret;
556         uint8_t config = 0;
557         struct i2c_client *client = chip->client;
558         struct max17048_battery_model *mdata = chip->pdata->model_data;
559
560         /* unlock model access */
561         ret = max17048_write_word(client, MAX17048_UNLOCK,
562                         MAX17048_UNLOCK_VALUE);
563         if (ret < 0)
564                 return ret;
565
566         /* load model data */
567         ret = max17048_load_model_data(chip);
568         if (ret < 0) {
569                 dev_err(&client->dev, "%s: err %d\n", __func__, ret);
570                 return ret;
571         }
572
573         if (mdata->bits == 19)
574                 config = 32 - (mdata->alert_threshold * 2);
575         else if (mdata->bits == 18)
576                 config = 32 - mdata->alert_threshold;
577         else
578                 dev_info(&client->dev, "Alert bit not set!");
579         config = mdata->one_percent_alerts | config;
580
581         ret = max17048_write_word(client, MAX17048_CONFIG,
582                         ((mdata->rcomp << 8) | config));
583         if (ret < 0)
584                 return ret;
585
586         /* Voltage Alert configuration */
587         ret = max17048_write_word(client, MAX17048_VALRT, mdata->valert);
588         if (ret < 0)
589                 return ret;
590
591         ret = max17048_write_word(client, MAX17048_VRESET, mdata->vreset);
592         if (ret < 0)
593                 return ret;
594
595         /* Lock model access */
596         ret = max17048_write_word(client, MAX17048_UNLOCK, 0x0000);
597         if (ret < 0)
598                 return ret;
599
600         /* Add delay */
601         mdelay(200);
602         return 0;
603 }
604
605 int max17048_check_battery()
606 {
607         uint16_t version;
608
609         if (!max17048_data)
610                 return -ENODEV;
611
612         version = max17048_get_version(max17048_data->client);
613         if ((version != MAX17048_VERSION_NO_11) &&
614                 (version != MAX17048_VERSION_NO_12)) {
615                 return -ENODEV;
616         }
617
618         return 0;
619 }
620 EXPORT_SYMBOL_GPL(max17048_check_battery);
621
622 static irqreturn_t max17048_irq(int id, void *dev)
623 {
624         struct max17048_chip *chip = dev;
625         struct i2c_client *client = chip->client;
626         u16 val;
627         u16 valrt;
628         int ret;
629         struct max17048_battery_model *mdata = chip->pdata->model_data;
630
631         val = max17048_read_word(client, MAX17048_STATUS);
632         if (val < 0) {
633                 dev_err(&client->dev,
634                                 "%s(): Failed in reading register" \
635                                 "MAX17048_STATUS err %d\n",
636                                         __func__, val);
637                 goto clear_irq;
638         }
639
640         if (val & MAX17048_STATUS_RI)
641                 dev_info(&client->dev, "%s(): STATUS_RI\n", __func__);
642         if (val & MAX17048_STATUS_VH)
643                 dev_info(&client->dev, "%s(): STATUS_VH\n", __func__);
644         if (val & MAX17048_STATUS_VL) {
645                 dev_info(&client->dev, "%s(): STATUS_VL\n", __func__);
646                 /* Forced set SOC to 0 for power off */
647                 chip->soc = 0;
648                 chip->lasttime_soc = chip->soc;
649                 chip->status = chip->lasttime_status;
650                 chip->health = POWER_SUPPLY_HEALTH_DEAD;
651                 chip->capacity_level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL;
652                 power_supply_changed(&chip->battery);
653
654                 /* Clear VL for prevent continuous irq */
655                 valrt = mdata->valert & 0x00FF;
656                 ret = max17048_write_word(client, MAX17048_VALRT,
657                                 valrt);
658                 if (ret < 0)
659                         dev_err(&client->dev, "failed write MAX17048_VALRT\n");
660         }
661         if (val & MAX17048_STATUS_VR)
662                 dev_info(&client->dev, "%s(): STATUS_VR\n", __func__);
663         if (val & MAX17048_STATUS_HD) {
664                 max17048_get_vcell(client);
665                 max17048_get_soc(client);
666                 chip->lasttime_soc = chip->soc;
667                 dev_info(&client->dev,
668                                 "%s(): STATUS_HD, VCELL %dmV, SOC %d%%\n",
669                                 __func__, chip->vcell, chip->internal_soc);
670                 power_supply_changed(&chip->battery);
671         }
672         if (val & MAX17048_STATUS_SC) {
673                 max17048_get_vcell(client);
674                 max17048_get_soc(client);
675                 chip->lasttime_soc = chip->soc;
676                 dev_info(&client->dev,
677                                 "%s(): STATUS_SC, VCELL %dmV, SOC %d%%\n",
678                                 __func__, chip->vcell, chip->internal_soc);
679                 power_supply_changed(&chip->battery);
680
681                 /* Set VL again when soc is above 1% */
682                 if (chip->internal_soc >= 1) {
683                         ret = max17048_write_word(client, MAX17048_VALRT,
684                                         mdata->valert);
685                         if (ret < 0)
686                                 dev_err(&client->dev,
687                                         "failed write MAX17048_VALRT\n");
688                 }
689         }
690         if (val & MAX17048_STATUS_ENVR)
691                 dev_info(&client->dev, "%s(): STATUS_ENVR\n", __func__);
692
693         ret = max17048_write_word(client, MAX17048_STATUS, 0x0000);
694         if (ret < 0)
695                 dev_err(&client->dev, "failed clear STATUS\n");
696
697 clear_irq:
698         val = max17048_read_word(client, MAX17048_CONFIG);
699         if (val < 0) {
700                 dev_err(&client->dev,
701                                 "%s(): Failed in reading register" \
702                                 "MAX17048_CONFIG err %d\n",
703                                         __func__, val);
704                 return IRQ_HANDLED;
705         }
706         val &= ~(MAX17048_CONFIG_ALRT);
707         ret = max17048_write_word(client, MAX17048_CONFIG, val);
708         if (ret < 0)
709                 dev_err(&client->dev, "failed clear CONFIG.ALRT\n");
710
711         return IRQ_HANDLED;
712 }
713
714 #ifdef CONFIG_OF
715 static struct max17048_platform_data *max17048_parse_dt(struct device *dev)
716 {
717         struct max17048_platform_data *pdata;
718         struct max17048_battery_model *model_data;
719         struct device_node *np = dev->of_node;
720         u32 val, val_array[MAX17048_DATA_SIZE];
721         int i, ret;
722
723         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
724         if (!pdata)
725                 return ERR_PTR(-ENOMEM);
726
727         model_data = devm_kzalloc(dev, sizeof(*model_data), GFP_KERNEL);
728         if (!model_data)
729                 return ERR_PTR(-ENOMEM);
730
731         pdata->model_data = model_data;
732
733         ret = of_property_read_u32(np, "bits", &val);
734         if (ret < 0)
735                 return ERR_PTR(ret);
736
737         if ((val == 18) || (val == 19))
738                 model_data->bits = val;
739
740         ret = of_property_read_u32(np, "alert-threshold", &val);
741         if (ret < 0)
742                 return ERR_PTR(ret);
743
744         model_data->alert_threshold = val;
745
746         ret = of_property_read_u32(np, "one-percent-alerts", &val);
747         if (ret < 0)
748                 return ERR_PTR(ret);
749
750         if (val)
751                 model_data->one_percent_alerts = 0x40;
752
753         ret = of_property_read_u32(np, "valert-max", &val);
754         if (ret < 0)
755                 return ERR_PTR(ret);
756         model_data->valert = (val / 20) & 0xFF; /* LSB is 20mV. */
757
758         ret = of_property_read_u32(np, "valert-min", &val);
759         if (ret < 0)
760                 return ERR_PTR(ret);
761         model_data->valert |= ((val / 20) & 0xFF) << 8; /* LSB is 20mV. */
762
763         ret = of_property_read_u32(np, "vreset-threshold", &val);
764         if (ret < 0)
765                 return ERR_PTR(ret);
766         model_data->vreset = ((val / 40) & 0xFE) << 8; /* LSB is 40mV. */
767
768         ret = of_property_read_u32(np, "vreset-disable", &val);
769         if (ret < 0)
770                 return ERR_PTR(ret);
771         model_data->vreset |= (val & 0x01) << 8;
772
773         ret = of_property_read_u32(np, "hib-threshold", &val);
774         if (ret < 0)
775                 return ERR_PTR(ret);
776         model_data->hibernate = (val & 0xFF) << 8;
777
778         ret = of_property_read_u32(np, "hib-active-threshold", &val);
779         if (ret < 0)
780                 return ERR_PTR(ret);
781         model_data->hibernate |= val & 0xFF;
782
783         ret = of_property_read_u32(np, "rcomp", &val);
784         if (ret < 0)
785                 return ERR_PTR(ret);
786         model_data->rcomp = val;
787
788         ret = of_property_read_u32(np, "rcomp-seg", &val);
789         if (ret < 0)
790                 return ERR_PTR(ret);
791         model_data->rcomp_seg = val;
792
793         ret = of_property_read_u32(np, "soccheck-a", &val);
794         if (ret < 0)
795                 return ERR_PTR(ret);
796         model_data->soccheck_A = val;
797
798         ret = of_property_read_u32(np, "soccheck-b", &val);
799         if (ret < 0)
800                 return ERR_PTR(ret);
801         model_data->soccheck_B = val;
802
803         ret = of_property_read_u32(np, "ocvtest", &val);
804         if (ret < 0)
805                 return ERR_PTR(ret);
806         model_data->ocvtest = val;
807
808         ret = of_property_read_u32(np, "minus_t_co_hot", &val);
809         if (ret < 0)
810                 return ERR_PTR(ret);
811         model_data->t_co_hot = -1 * val;
812
813         ret = of_property_read_u32(np, "minus_t_co_cold", &val);
814         if (ret < 0)
815                 return ERR_PTR(ret);
816         model_data->t_co_cold = -1 * val;
817
818         ret = of_property_read_u32_array(np, "data-tbl", val_array,
819                                          MAX17048_DATA_SIZE);
820         if (ret < 0)
821                 return ERR_PTR(ret);
822
823         for (i = 0; i < MAX17048_DATA_SIZE; i++)
824                 model_data->data_tbl[i] = val_array[i];
825
826         return pdata;
827 }
828 #else
829 static struct max17048_platform_data *max17048_parse_dt(struct device *dev)
830 {
831         return NULL;
832 }
833 #endif /* CONFIG_OF */
834
835 static int __devinit max17048_probe(struct i2c_client *client,
836                         const struct i2c_device_id *id)
837 {
838         struct max17048_chip *chip;
839         int ret;
840         uint16_t version;
841         u16 val;
842
843         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
844         if (!chip)
845                 return -ENOMEM;
846
847         chip->client = client;
848
849         if (client->dev.of_node) {
850                 chip->pdata = max17048_parse_dt(&client->dev);
851                 if (IS_ERR(chip->pdata))
852                         return PTR_ERR(chip->pdata);
853         } else {
854                 chip->pdata = client->dev.platform_data;
855                 if (!chip->pdata)
856                         return -ENODATA;
857         }
858
859         max17048_data = chip;
860         mutex_init(&chip->mutex);
861         chip->shutdown_complete = 0;
862         i2c_set_clientdata(client, chip);
863
864         version = max17048_get_version(client);
865         dev_info(&client->dev, "MAX17048 Fuel-Gauge Ver 0x%x\n", version);
866
867         ret = max17048_initialize(chip);
868         if (ret < 0) {
869                 dev_err(&client->dev, "Error: Initializing fuel-gauge\n");
870                 goto error2;
871         }
872
873         chip->battery.name              = "battery";
874         chip->battery.type              = POWER_SUPPLY_TYPE_BATTERY;
875         chip->battery.get_property      = max17048_get_property;
876         chip->battery.properties        = max17048_battery_props;
877         chip->battery.num_properties    = ARRAY_SIZE(max17048_battery_props);
878         chip->status                    = POWER_SUPPLY_STATUS_DISCHARGING;
879         chip->lasttime_status   = POWER_SUPPLY_STATUS_DISCHARGING;
880
881         ret = power_supply_register(&client->dev, &chip->battery);
882         if (ret) {
883                 dev_err(&client->dev, "failed: power supply register\n");
884                 goto error2;
885         }
886
887         INIT_DELAYED_WORK_DEFERRABLE(&chip->work, max17048_work);
888         schedule_delayed_work(&chip->work, 0);
889
890         if (client->irq) {
891                 ret = request_threaded_irq(client->irq, NULL,
892                                                 max17048_irq,
893                                                 IRQF_TRIGGER_FALLING,
894                                                 chip->battery.name, chip);
895                 if (!ret) {
896                         ret = max17048_write_word(client, MAX17048_STATUS,
897                                                         0x0000);
898                         if (ret < 0)
899                                 goto irq_clear_error;
900                         val = max17048_read_word(client, MAX17048_CONFIG);
901                         if (val < 0)
902                                 goto irq_clear_error;
903                         val &= ~(MAX17048_CONFIG_ALRT);
904                         ret = max17048_write_word(client, MAX17048_CONFIG,
905                                                         val);
906                         if (ret < 0)
907                                 goto irq_clear_error;
908                 } else {
909                         dev_err(&client->dev,
910                                         "%s: request IRQ %d fail, err = %d\n",
911                                         __func__, client->irq, ret);
912                         client->irq = 0;
913                         goto irq_reg_error;
914                 }
915         }
916         device_set_wakeup_capable(&client->dev, 1);
917
918         return 0;
919 irq_clear_error:
920         free_irq(client->irq, chip);
921 irq_reg_error:
922         cancel_delayed_work_sync(&chip->work);
923         power_supply_unregister(&chip->battery);
924 error2:
925         mutex_destroy(&chip->mutex);
926
927         return ret;
928 }
929
930 static int __devexit max17048_remove(struct i2c_client *client)
931 {
932         struct max17048_chip *chip = i2c_get_clientdata(client);
933
934         if (client->irq)
935                 free_irq(client->irq, chip);
936         power_supply_unregister(&chip->battery);
937         cancel_delayed_work_sync(&chip->work);
938         mutex_destroy(&chip->mutex);
939
940         return 0;
941 }
942
943 static void max17048_shutdown(struct i2c_client *client)
944 {
945         struct max17048_chip *chip = i2c_get_clientdata(client);
946
947         if (client->irq)
948                 disable_irq(client->irq);
949         cancel_delayed_work_sync(&chip->work);
950         mutex_lock(&chip->mutex);
951         chip->shutdown_complete = 1;
952         mutex_unlock(&chip->mutex);
953
954 }
955
956 #ifdef CONFIG_PM
957
958 static int max17048_suspend(struct i2c_client *client,
959                 pm_message_t state)
960 {
961         struct max17048_chip *chip = i2c_get_clientdata(client);
962         int ret;
963
964         if (device_may_wakeup(&client->dev)) {
965                 enable_irq_wake(chip->client->irq);
966         }
967         cancel_delayed_work_sync(&chip->work);
968         ret = max17048_write_word(client, MAX17048_HIBRT, 0xffff);
969         if (ret < 0) {
970                 dev_err(&client->dev, "failed in entering hibernate mode\n");
971                 return ret;
972         }
973
974         return 0;
975 }
976
977 static int max17048_resume(struct i2c_client *client)
978 {
979         struct max17048_chip *chip = i2c_get_clientdata(client);
980         int ret;
981         struct max17048_battery_model *mdata = chip->pdata->model_data;
982
983         ret = max17048_write_word(client, MAX17048_HIBRT, mdata->hibernate);
984         if (ret < 0) {
985                 dev_err(&client->dev, "failed in exiting hibernate mode\n");
986                 return ret;
987         }
988
989         schedule_delayed_work(&chip->work, MAX17048_DELAY);
990         if (device_may_wakeup(&client->dev)) {
991                 disable_irq_wake(client->irq);
992         }
993
994         return 0;
995 }
996
997 #else
998
999 #define max17048_suspend NULL
1000 #define max17048_resume NULL
1001
1002 #endif /* CONFIG_PM */
1003
1004 #ifdef CONFIG_OF
1005 static const struct of_device_id max17048_dt_match[] = {
1006         { .compatible = "maxim,max17048" },
1007         { },
1008 };
1009 MODULE_DEVICE_TABLE(of, max17048_dt_match);
1010 #endif
1011
1012 static const struct i2c_device_id max17048_id[] = {
1013         { "max17048", 0 },
1014         { }
1015 };
1016 MODULE_DEVICE_TABLE(i2c, max17048_id);
1017
1018 static struct i2c_driver max17048_i2c_driver = {
1019         .driver = {
1020                 .name   = "max17048",
1021                 .of_match_table = of_match_ptr(max17048_dt_match),
1022         },
1023         .probe          = max17048_probe,
1024         .remove         = __devexit_p(max17048_remove),
1025         .suspend        = max17048_suspend,
1026         .resume         = max17048_resume,
1027         .id_table       = max17048_id,
1028         .shutdown       = max17048_shutdown,
1029 };
1030
1031 static int __init max17048_init(void)
1032 {
1033         return i2c_add_driver(&max17048_i2c_driver);
1034 }
1035 subsys_initcall(max17048_init);
1036
1037 static void __exit max17048_exit(void)
1038 {
1039         i2c_del_driver(&max17048_i2c_driver);
1040 }
1041 module_exit(max17048_exit);
1042
1043 MODULE_AUTHOR("Chandler Zhang <chazhang@nvidia.com>");
1044 MODULE_DESCRIPTION("MAX17048 Fuel Gauge");
1045 MODULE_LICENSE("GPL");