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