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