Version:  2.0.40 2.2.26 2.4.37 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1

Linux/drivers/power/max17042_battery.c

  1 /*
  2  * Fuel gauge driver for Maxim 17042 / 8966 / 8997
  3  *  Note that Maxim 8966 and 8997 are mfd and this is its subdevice.
  4  *
  5  * Copyright (C) 2011 Samsung Electronics
  6  * MyungJoo Ham <myungjoo.ham@samsung.com>
  7  *
  8  * This program is free software; you can redistribute it and/or modify
  9  * it under the terms of the GNU General Public License as published by
 10  * the Free Software Foundation; either version 2 of the License, or
 11  * (at your option) any later version.
 12  *
 13  * This program is distributed in the hope that it will be useful,
 14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 16  * GNU General Public License for more details.
 17  *
 18  * You should have received a copy of the GNU General Public License
 19  * along with this program; if not, write to the Free Software
 20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 21  *
 22  * This driver is based on max17040_battery.c
 23  */
 24 
 25 #include <linux/init.h>
 26 #include <linux/module.h>
 27 #include <linux/slab.h>
 28 #include <linux/i2c.h>
 29 #include <linux/delay.h>
 30 #include <linux/interrupt.h>
 31 #include <linux/pm.h>
 32 #include <linux/mod_devicetable.h>
 33 #include <linux/power_supply.h>
 34 #include <linux/power/max17042_battery.h>
 35 #include <linux/of.h>
 36 #include <linux/regmap.h>
 37 
 38 /* Status register bits */
 39 #define STATUS_POR_BIT         (1 << 1)
 40 #define STATUS_BST_BIT         (1 << 3)
 41 #define STATUS_VMN_BIT         (1 << 8)
 42 #define STATUS_TMN_BIT         (1 << 9)
 43 #define STATUS_SMN_BIT         (1 << 10)
 44 #define STATUS_BI_BIT          (1 << 11)
 45 #define STATUS_VMX_BIT         (1 << 12)
 46 #define STATUS_TMX_BIT         (1 << 13)
 47 #define STATUS_SMX_BIT         (1 << 14)
 48 #define STATUS_BR_BIT          (1 << 15)
 49 
 50 /* Interrupt mask bits */
 51 #define CONFIG_ALRT_BIT_ENBL    (1 << 2)
 52 #define STATUS_INTR_SOCMIN_BIT  (1 << 10)
 53 #define STATUS_INTR_SOCMAX_BIT  (1 << 14)
 54 
 55 #define VFSOC0_LOCK             0x0000
 56 #define VFSOC0_UNLOCK           0x0080
 57 #define MODEL_UNLOCK1   0X0059
 58 #define MODEL_UNLOCK2   0X00C4
 59 #define MODEL_LOCK1             0X0000
 60 #define MODEL_LOCK2             0X0000
 61 
 62 #define dQ_ACC_DIV      0x4
 63 #define dP_ACC_100      0x1900
 64 #define dP_ACC_200      0x3200
 65 
 66 struct max17042_chip {
 67         struct i2c_client *client;
 68         struct regmap *regmap;
 69         struct power_supply *battery;
 70         enum max170xx_chip_type chip_type;
 71         struct max17042_platform_data *pdata;
 72         struct work_struct work;
 73         int    init_complete;
 74 };
 75 
 76 static enum power_supply_property max17042_battery_props[] = {
 77         POWER_SUPPLY_PROP_PRESENT,
 78         POWER_SUPPLY_PROP_CYCLE_COUNT,
 79         POWER_SUPPLY_PROP_VOLTAGE_MAX,
 80         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 81         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 82         POWER_SUPPLY_PROP_VOLTAGE_AVG,
 83         POWER_SUPPLY_PROP_VOLTAGE_OCV,
 84         POWER_SUPPLY_PROP_CAPACITY,
 85         POWER_SUPPLY_PROP_CHARGE_FULL,
 86         POWER_SUPPLY_PROP_CHARGE_COUNTER,
 87         POWER_SUPPLY_PROP_TEMP,
 88         POWER_SUPPLY_PROP_CURRENT_NOW,
 89         POWER_SUPPLY_PROP_CURRENT_AVG,
 90 };
 91 
 92 static int max17042_get_property(struct power_supply *psy,
 93                             enum power_supply_property psp,
 94                             union power_supply_propval *val)
 95 {
 96         struct max17042_chip *chip = power_supply_get_drvdata(psy);
 97         struct regmap *map = chip->regmap;
 98         int ret;
 99         u32 data;
100 
101         if (!chip->init_complete)
102                 return -EAGAIN;
103 
104         switch (psp) {
105         case POWER_SUPPLY_PROP_PRESENT:
106                 ret = regmap_read(map, MAX17042_STATUS, &data);
107                 if (ret < 0)
108                         return ret;
109 
110                 if (data & MAX17042_STATUS_BattAbsent)
111                         val->intval = 0;
112                 else
113                         val->intval = 1;
114                 break;
115         case POWER_SUPPLY_PROP_CYCLE_COUNT:
116                 ret = regmap_read(map, MAX17042_Cycles, &data);
117                 if (ret < 0)
118                         return ret;
119 
120                 val->intval = data;
121                 break;
122         case POWER_SUPPLY_PROP_VOLTAGE_MAX:
123                 ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
124                 if (ret < 0)
125                         return ret;
126 
127                 val->intval = data >> 8;
128                 val->intval *= 20000; /* Units of LSB = 20mV */
129                 break;
130         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
131                 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
132                         ret = regmap_read(map, MAX17042_V_empty, &data);
133                 else
134                         ret = regmap_read(map, MAX17047_V_empty, &data);
135                 if (ret < 0)
136                         return ret;
137 
138                 val->intval = data >> 7;
139                 val->intval *= 10000; /* Units of LSB = 10mV */
140                 break;
141         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
142                 ret = regmap_read(map, MAX17042_VCELL, &data);
143                 if (ret < 0)
144                         return ret;
145 
146                 val->intval = data * 625 / 8;
147                 break;
148         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
149                 ret = regmap_read(map, MAX17042_AvgVCELL, &data);
150                 if (ret < 0)
151                         return ret;
152 
153                 val->intval = data * 625 / 8;
154                 break;
155         case POWER_SUPPLY_PROP_VOLTAGE_OCV:
156                 ret = regmap_read(map, MAX17042_OCVInternal, &data);
157                 if (ret < 0)
158                         return ret;
159 
160                 val->intval = data * 625 / 8;
161                 break;
162         case POWER_SUPPLY_PROP_CAPACITY:
163                 ret = regmap_read(map, MAX17042_RepSOC, &data);
164                 if (ret < 0)
165                         return ret;
166 
167                 val->intval = data >> 8;
168                 break;
169         case POWER_SUPPLY_PROP_CHARGE_FULL:
170                 ret = regmap_read(map, MAX17042_FullCAP, &data);
171                 if (ret < 0)
172                         return ret;
173 
174                 val->intval = data * 1000 / 2;
175                 break;
176         case POWER_SUPPLY_PROP_CHARGE_COUNTER:
177                 ret = regmap_read(map, MAX17042_QH, &data);
178                 if (ret < 0)
179                         return ret;
180 
181                 val->intval = data * 1000 / 2;
182                 break;
183         case POWER_SUPPLY_PROP_TEMP:
184                 ret = regmap_read(map, MAX17042_TEMP, &data);
185                 if (ret < 0)
186                         return ret;
187 
188                 val->intval = data;
189                 /* The value is signed. */
190                 if (val->intval & 0x8000) {
191                         val->intval = (0x7fff & ~val->intval) + 1;
192                         val->intval *= -1;
193                 }
194                 /* The value is converted into deci-centigrade scale */
195                 /* Units of LSB = 1 / 256 degree Celsius */
196                 val->intval = val->intval * 10 / 256;
197                 break;
198         case POWER_SUPPLY_PROP_CURRENT_NOW:
199                 if (chip->pdata->enable_current_sense) {
200                         ret = regmap_read(map, MAX17042_Current, &data);
201                         if (ret < 0)
202                                 return ret;
203 
204                         val->intval = data;
205                         if (val->intval & 0x8000) {
206                                 /* Negative */
207                                 val->intval = ~val->intval & 0x7fff;
208                                 val->intval++;
209                                 val->intval *= -1;
210                         }
211                         val->intval *= 1562500 / chip->pdata->r_sns;
212                 } else {
213                         return -EINVAL;
214                 }
215                 break;
216         case POWER_SUPPLY_PROP_CURRENT_AVG:
217                 if (chip->pdata->enable_current_sense) {
218                         ret = regmap_read(map, MAX17042_AvgCurrent, &data);
219                         if (ret < 0)
220                                 return ret;
221 
222                         val->intval = data;
223                         if (val->intval & 0x8000) {
224                                 /* Negative */
225                                 val->intval = ~val->intval & 0x7fff;
226                                 val->intval++;
227                                 val->intval *= -1;
228                         }
229                         val->intval *= 1562500 / chip->pdata->r_sns;
230                 } else {
231                         return -EINVAL;
232                 }
233                 break;
234         default:
235                 return -EINVAL;
236         }
237         return 0;
238 }
239 
240 static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value)
241 {
242         int retries = 8;
243         int ret;
244         u32 read_value;
245 
246         do {
247                 ret = regmap_write(map, reg, value);
248                 regmap_read(map, reg, &read_value);
249                 if (read_value != value) {
250                         ret = -EIO;
251                         retries--;
252                 }
253         } while (retries && read_value != value);
254 
255         if (ret < 0)
256                 pr_err("%s: err %d\n", __func__, ret);
257 
258         return ret;
259 }
260 
261 static inline void max17042_override_por(struct regmap *map,
262                                          u8 reg, u16 value)
263 {
264         if (value)
265                 regmap_write(map, reg, value);
266 }
267 
268 static inline void max10742_unlock_model(struct max17042_chip *chip)
269 {
270         struct regmap *map = chip->regmap;
271 
272         regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
273         regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
274 }
275 
276 static inline void max10742_lock_model(struct max17042_chip *chip)
277 {
278         struct regmap *map = chip->regmap;
279 
280         regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1);
281         regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2);
282 }
283 
284 static inline void max17042_write_model_data(struct max17042_chip *chip,
285                                         u8 addr, int size)
286 {
287         struct regmap *map = chip->regmap;
288         int i;
289 
290         for (i = 0; i < size; i++)
291                 regmap_write(map, addr + i,
292                         chip->pdata->config_data->cell_char_tbl[i]);
293 }
294 
295 static inline void max17042_read_model_data(struct max17042_chip *chip,
296                                         u8 addr, u32 *data, int size)
297 {
298         struct regmap *map = chip->regmap;
299         int i;
300 
301         for (i = 0; i < size; i++)
302                 regmap_read(map, addr + i, &data[i]);
303 }
304 
305 static inline int max17042_model_data_compare(struct max17042_chip *chip,
306                                         u16 *data1, u16 *data2, int size)
307 {
308         int i;
309 
310         if (memcmp(data1, data2, size)) {
311                 dev_err(&chip->client->dev, "%s compare failed\n", __func__);
312                 for (i = 0; i < size; i++)
313                         dev_info(&chip->client->dev, "0x%x, 0x%x",
314                                 data1[i], data2[i]);
315                 dev_info(&chip->client->dev, "\n");
316                 return -EINVAL;
317         }
318         return 0;
319 }
320 
321 static int max17042_init_model(struct max17042_chip *chip)
322 {
323         int ret;
324         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
325         u32 *temp_data;
326 
327         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
328         if (!temp_data)
329                 return -ENOMEM;
330 
331         max10742_unlock_model(chip);
332         max17042_write_model_data(chip, MAX17042_MODELChrTbl,
333                                 table_size);
334         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
335                                 table_size);
336 
337         ret = max17042_model_data_compare(
338                 chip,
339                 chip->pdata->config_data->cell_char_tbl,
340                 (u16 *)temp_data,
341                 table_size);
342 
343         max10742_lock_model(chip);
344         kfree(temp_data);
345 
346         return ret;
347 }
348 
349 static int max17042_verify_model_lock(struct max17042_chip *chip)
350 {
351         int i;
352         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
353         u32 *temp_data;
354         int ret = 0;
355 
356         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
357         if (!temp_data)
358                 return -ENOMEM;
359 
360         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
361                                 table_size);
362         for (i = 0; i < table_size; i++)
363                 if (temp_data[i])
364                         ret = -EINVAL;
365 
366         kfree(temp_data);
367         return ret;
368 }
369 
370 static void max17042_write_config_regs(struct max17042_chip *chip)
371 {
372         struct max17042_config_data *config = chip->pdata->config_data;
373         struct regmap *map = chip->regmap;
374 
375         regmap_write(map, MAX17042_CONFIG, config->config);
376         regmap_write(map, MAX17042_LearnCFG, config->learn_cfg);
377         regmap_write(map, MAX17042_FilterCFG,
378                         config->filter_cfg);
379         regmap_write(map, MAX17042_RelaxCFG, config->relax_cfg);
380         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17047 ||
381                         chip->chip_type == MAXIM_DEVICE_TYPE_MAX17050)
382                 regmap_write(map, MAX17047_FullSOCThr,
383                                                 config->full_soc_thresh);
384 }
385 
386 static void  max17042_write_custom_regs(struct max17042_chip *chip)
387 {
388         struct max17042_config_data *config = chip->pdata->config_data;
389         struct regmap *map = chip->regmap;
390 
391         max17042_write_verify_reg(map, MAX17042_RCOMP0, config->rcomp0);
392         max17042_write_verify_reg(map, MAX17042_TempCo, config->tcompc0);
393         max17042_write_verify_reg(map, MAX17042_ICHGTerm, config->ichgt_term);
394         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042) {
395                 regmap_write(map, MAX17042_EmptyTempCo, config->empty_tempco);
396                 max17042_write_verify_reg(map, MAX17042_K_empty0,
397                                         config->kempty0);
398         } else {
399                 max17042_write_verify_reg(map, MAX17047_QRTbl00,
400                                                 config->qrtbl00);
401                 max17042_write_verify_reg(map, MAX17047_QRTbl10,
402                                                 config->qrtbl10);
403                 max17042_write_verify_reg(map, MAX17047_QRTbl20,
404                                                 config->qrtbl20);
405                 max17042_write_verify_reg(map, MAX17047_QRTbl30,
406                                                 config->qrtbl30);
407         }
408 }
409 
410 static void max17042_update_capacity_regs(struct max17042_chip *chip)
411 {
412         struct max17042_config_data *config = chip->pdata->config_data;
413         struct regmap *map = chip->regmap;
414 
415         max17042_write_verify_reg(map, MAX17042_FullCAP,
416                                 config->fullcap);
417         regmap_write(map, MAX17042_DesignCap, config->design_cap);
418         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
419                                 config->fullcapnom);
420 }
421 
422 static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip)
423 {
424         unsigned int vfSoc;
425         struct regmap *map = chip->regmap;
426 
427         regmap_read(map, MAX17042_VFSOC, &vfSoc);
428         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK);
429         max17042_write_verify_reg(map, MAX17042_VFSOC0, vfSoc);
430         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK);
431 }
432 
433 static void max17042_load_new_capacity_params(struct max17042_chip *chip)
434 {
435         u32 full_cap0, rep_cap, dq_acc, vfSoc;
436         u32 rem_cap;
437 
438         struct max17042_config_data *config = chip->pdata->config_data;
439         struct regmap *map = chip->regmap;
440 
441         regmap_read(map, MAX17042_FullCAP0, &full_cap0);
442         regmap_read(map, MAX17042_VFSOC, &vfSoc);
443 
444         /* fg_vfSoc needs to shifted by 8 bits to get the
445          * perc in 1% accuracy, to get the right rem_cap multiply
446          * full_cap0, fg_vfSoc and devide by 100
447          */
448         rem_cap = ((vfSoc >> 8) * full_cap0) / 100;
449         max17042_write_verify_reg(map, MAX17042_RemCap, rem_cap);
450 
451         rep_cap = rem_cap;
452         max17042_write_verify_reg(map, MAX17042_RepCap, rep_cap);
453 
454         /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */
455         dq_acc = config->fullcap / dQ_ACC_DIV;
456         max17042_write_verify_reg(map, MAX17042_dQacc, dq_acc);
457         max17042_write_verify_reg(map, MAX17042_dPacc, dP_ACC_200);
458 
459         max17042_write_verify_reg(map, MAX17042_FullCAP,
460                         config->fullcap);
461         regmap_write(map, MAX17042_DesignCap,
462                         config->design_cap);
463         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
464                         config->fullcapnom);
465         /* Update SOC register with new SOC */
466         regmap_write(map, MAX17042_RepSOC, vfSoc);
467 }
468 
469 /*
470  * Block write all the override values coming from platform data.
471  * This function MUST be called before the POR initialization proceedure
472  * specified by maxim.
473  */
474 static inline void max17042_override_por_values(struct max17042_chip *chip)
475 {
476         struct regmap *map = chip->regmap;
477         struct max17042_config_data *config = chip->pdata->config_data;
478 
479         max17042_override_por(map, MAX17042_TGAIN, config->tgain);
480         max17042_override_por(map, MAx17042_TOFF, config->toff);
481         max17042_override_por(map, MAX17042_CGAIN, config->cgain);
482         max17042_override_por(map, MAX17042_COFF, config->coff);
483 
484         max17042_override_por(map, MAX17042_VALRT_Th, config->valrt_thresh);
485         max17042_override_por(map, MAX17042_TALRT_Th, config->talrt_thresh);
486         max17042_override_por(map, MAX17042_SALRT_Th,
487                                                 config->soc_alrt_thresh);
488         max17042_override_por(map, MAX17042_CONFIG, config->config);
489         max17042_override_por(map, MAX17042_SHDNTIMER, config->shdntimer);
490 
491         max17042_override_por(map, MAX17042_DesignCap, config->design_cap);
492         max17042_override_por(map, MAX17042_ICHGTerm, config->ichgt_term);
493 
494         max17042_override_por(map, MAX17042_AtRate, config->at_rate);
495         max17042_override_por(map, MAX17042_LearnCFG, config->learn_cfg);
496         max17042_override_por(map, MAX17042_FilterCFG, config->filter_cfg);
497         max17042_override_por(map, MAX17042_RelaxCFG, config->relax_cfg);
498         max17042_override_por(map, MAX17042_MiscCFG, config->misc_cfg);
499         max17042_override_por(map, MAX17042_MaskSOC, config->masksoc);
500 
501         max17042_override_por(map, MAX17042_FullCAP, config->fullcap);
502         max17042_override_por(map, MAX17042_FullCAPNom, config->fullcapnom);
503         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
504                 max17042_override_por(map, MAX17042_SOC_empty,
505                                                 config->socempty);
506         max17042_override_por(map, MAX17042_LAvg_empty, config->lavg_empty);
507         max17042_override_por(map, MAX17042_dQacc, config->dqacc);
508         max17042_override_por(map, MAX17042_dPacc, config->dpacc);
509 
510         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
511                 max17042_override_por(map, MAX17042_V_empty, config->vempty);
512         else
513                 max17042_override_por(map, MAX17047_V_empty, config->vempty);
514         max17042_override_por(map, MAX17042_TempNom, config->temp_nom);
515         max17042_override_por(map, MAX17042_TempLim, config->temp_lim);
516         max17042_override_por(map, MAX17042_FCTC, config->fctc);
517         max17042_override_por(map, MAX17042_RCOMP0, config->rcomp0);
518         max17042_override_por(map, MAX17042_TempCo, config->tcompc0);
519         if (chip->chip_type) {
520                 max17042_override_por(map, MAX17042_EmptyTempCo,
521                                                 config->empty_tempco);
522                 max17042_override_por(map, MAX17042_K_empty0,
523                                                 config->kempty0);
524         }
525 }
526 
527 static int max17042_init_chip(struct max17042_chip *chip)
528 {
529         struct regmap *map = chip->regmap;
530         int ret;
531 
532         max17042_override_por_values(chip);
533         /* After Power up, the MAX17042 requires 500mS in order
534          * to perform signal debouncing and initial SOC reporting
535          */
536         msleep(500);
537 
538         /* Initialize configaration */
539         max17042_write_config_regs(chip);
540 
541         /* write cell characterization data */
542         ret = max17042_init_model(chip);
543         if (ret) {
544                 dev_err(&chip->client->dev, "%s init failed\n",
545                         __func__);
546                 return -EIO;
547         }
548 
549         ret = max17042_verify_model_lock(chip);
550         if (ret) {
551                 dev_err(&chip->client->dev, "%s lock verify failed\n",
552                         __func__);
553                 return -EIO;
554         }
555         /* write custom parameters */
556         max17042_write_custom_regs(chip);
557 
558         /* update capacity params */
559         max17042_update_capacity_regs(chip);
560 
561         /* delay must be atleast 350mS to allow VFSOC
562          * to be calculated from the new configuration
563          */
564         msleep(350);
565 
566         /* reset vfsoc0 reg */
567         max17042_reset_vfsoc0_reg(chip);
568 
569         /* load new capacity params */
570         max17042_load_new_capacity_params(chip);
571 
572         /* Init complete, Clear the POR bit */
573         regmap_update_bits(map, MAX17042_STATUS, STATUS_POR_BIT, 0x0);
574         return 0;
575 }
576 
577 static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off)
578 {
579         struct regmap *map = chip->regmap;
580         u32 soc, soc_tr;
581 
582         /* program interrupt thesholds such that we should
583          * get interrupt for every 'off' perc change in the soc
584          */
585         regmap_read(map, MAX17042_RepSOC, &soc);
586         soc >>= 8;
587         soc_tr = (soc + off) << 8;
588         soc_tr |= (soc - off);
589         regmap_write(map, MAX17042_SALRT_Th, soc_tr);
590 }
591 
592 static irqreturn_t max17042_thread_handler(int id, void *dev)
593 {
594         struct max17042_chip *chip = dev;
595         u32 val;
596 
597         regmap_read(chip->regmap, MAX17042_STATUS, &val);
598         if ((val & STATUS_INTR_SOCMIN_BIT) ||
599                 (val & STATUS_INTR_SOCMAX_BIT)) {
600                 dev_info(&chip->client->dev, "SOC threshold INTR\n");
601                 max17042_set_soc_threshold(chip, 1);
602         }
603 
604         power_supply_changed(chip->battery);
605         return IRQ_HANDLED;
606 }
607 
608 static void max17042_init_worker(struct work_struct *work)
609 {
610         struct max17042_chip *chip = container_of(work,
611                                 struct max17042_chip, work);
612         int ret;
613 
614         /* Initialize registers according to values from the platform data */
615         if (chip->pdata->enable_por_init && chip->pdata->config_data) {
616                 ret = max17042_init_chip(chip);
617                 if (ret)
618                         return;
619         }
620 
621         chip->init_complete = 1;
622 }
623 
624 #ifdef CONFIG_OF
625 static struct max17042_platform_data *
626 max17042_get_pdata(struct device *dev)
627 {
628         struct device_node *np = dev->of_node;
629         u32 prop;
630         struct max17042_platform_data *pdata;
631 
632         if (!np)
633                 return dev->platform_data;
634 
635         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
636         if (!pdata)
637                 return NULL;
638 
639         /*
640          * Require current sense resistor value to be specified for
641          * current-sense functionality to be enabled at all.
642          */
643         if (of_property_read_u32(np, "maxim,rsns-microohm", &prop) == 0) {
644                 pdata->r_sns = prop;
645                 pdata->enable_current_sense = true;
646         }
647 
648         return pdata;
649 }
650 #else
651 static struct max17042_platform_data *
652 max17042_get_pdata(struct device *dev)
653 {
654         return dev->platform_data;
655 }
656 #endif
657 
658 static const struct regmap_config max17042_regmap_config = {
659         .reg_bits = 8,
660         .val_bits = 16,
661         .val_format_endian = REGMAP_ENDIAN_NATIVE,
662 };
663 
664 static const struct power_supply_desc max17042_psy_desc = {
665         .name           = "max170xx_battery",
666         .type           = POWER_SUPPLY_TYPE_BATTERY,
667         .get_property   = max17042_get_property,
668         .properties     = max17042_battery_props,
669         .num_properties = ARRAY_SIZE(max17042_battery_props),
670 };
671 
672 static const struct power_supply_desc max17042_no_current_sense_psy_desc = {
673         .name           = "max170xx_battery",
674         .type           = POWER_SUPPLY_TYPE_BATTERY,
675         .get_property   = max17042_get_property,
676         .properties     = max17042_battery_props,
677         .num_properties = ARRAY_SIZE(max17042_battery_props) - 2,
678 };
679 
680 static int max17042_probe(struct i2c_client *client,
681                         const struct i2c_device_id *id)
682 {
683         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
684         const struct power_supply_desc *max17042_desc = &max17042_psy_desc;
685         struct power_supply_config psy_cfg = {};
686         struct max17042_chip *chip;
687         int ret;
688         int i;
689         u32 val;
690 
691         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
692                 return -EIO;
693 
694         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
695         if (!chip)
696                 return -ENOMEM;
697 
698         chip->client = client;
699         chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config);
700         if (IS_ERR(chip->regmap)) {
701                 dev_err(&client->dev, "Failed to initialize regmap\n");
702                 return -EINVAL;
703         }
704 
705         chip->pdata = max17042_get_pdata(&client->dev);
706         if (!chip->pdata) {
707                 dev_err(&client->dev, "no platform data provided\n");
708                 return -EINVAL;
709         }
710 
711         i2c_set_clientdata(client, chip);
712         chip->chip_type = id->driver_data;
713         psy_cfg.drv_data = chip;
714 
715         /* When current is not measured,
716          * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
717         if (!chip->pdata->enable_current_sense)
718                 max17042_desc = &max17042_no_current_sense_psy_desc;
719 
720         if (chip->pdata->r_sns == 0)
721                 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
722 
723         if (chip->pdata->init_data)
724                 for (i = 0; i < chip->pdata->num_init_data; i++)
725                         regmap_write(chip->regmap,
726                                         chip->pdata->init_data[i].addr,
727                                         chip->pdata->init_data[i].data);
728 
729         if (!chip->pdata->enable_current_sense) {
730                 regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000);
731                 regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003);
732                 regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007);
733         }
734 
735         chip->battery = power_supply_register(&client->dev, max17042_desc,
736                                                 &psy_cfg);
737         if (IS_ERR(chip->battery)) {
738                 dev_err(&client->dev, "failed: power supply register\n");
739                 return PTR_ERR(chip->battery);
740         }
741 
742         if (client->irq) {
743                 ret = request_threaded_irq(client->irq, NULL,
744                                         max17042_thread_handler,
745                                         IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
746                                         chip->battery->desc->name, chip);
747                 if (!ret) {
748                         regmap_update_bits(chip->regmap, MAX17042_CONFIG,
749                                         CONFIG_ALRT_BIT_ENBL,
750                                         CONFIG_ALRT_BIT_ENBL);
751                         max17042_set_soc_threshold(chip, 1);
752                 } else {
753                         client->irq = 0;
754                         dev_err(&client->dev, "%s(): cannot get IRQ\n",
755                                 __func__);
756                 }
757         }
758 
759         regmap_read(chip->regmap, MAX17042_STATUS, &val);
760         if (val & STATUS_POR_BIT) {
761                 INIT_WORK(&chip->work, max17042_init_worker);
762                 schedule_work(&chip->work);
763         } else {
764                 chip->init_complete = 1;
765         }
766 
767         return 0;
768 }
769 
770 static int max17042_remove(struct i2c_client *client)
771 {
772         struct max17042_chip *chip = i2c_get_clientdata(client);
773 
774         if (client->irq)
775                 free_irq(client->irq, chip);
776         power_supply_unregister(chip->battery);
777         return 0;
778 }
779 
780 #ifdef CONFIG_PM_SLEEP
781 static int max17042_suspend(struct device *dev)
782 {
783         struct max17042_chip *chip = dev_get_drvdata(dev);
784 
785         /*
786          * disable the irq and enable irq_wake
787          * capability to the interrupt line.
788          */
789         if (chip->client->irq) {
790                 disable_irq(chip->client->irq);
791                 enable_irq_wake(chip->client->irq);
792         }
793 
794         return 0;
795 }
796 
797 static int max17042_resume(struct device *dev)
798 {
799         struct max17042_chip *chip = dev_get_drvdata(dev);
800 
801         if (chip->client->irq) {
802                 disable_irq_wake(chip->client->irq);
803                 enable_irq(chip->client->irq);
804                 /* re-program the SOC thresholds to 1% change */
805                 max17042_set_soc_threshold(chip, 1);
806         }
807 
808         return 0;
809 }
810 #endif
811 
812 static SIMPLE_DEV_PM_OPS(max17042_pm_ops, max17042_suspend,
813                         max17042_resume);
814 
815 #ifdef CONFIG_OF
816 static const struct of_device_id max17042_dt_match[] = {
817         { .compatible = "maxim,max17042" },
818         { .compatible = "maxim,max17047" },
819         { .compatible = "maxim,max17050" },
820         { },
821 };
822 MODULE_DEVICE_TABLE(of, max17042_dt_match);
823 #endif
824 
825 static const struct i2c_device_id max17042_id[] = {
826         { "max17042", MAXIM_DEVICE_TYPE_MAX17042 },
827         { "max17047", MAXIM_DEVICE_TYPE_MAX17047 },
828         { "max17050", MAXIM_DEVICE_TYPE_MAX17050 },
829         { }
830 };
831 MODULE_DEVICE_TABLE(i2c, max17042_id);
832 
833 static struct i2c_driver max17042_i2c_driver = {
834         .driver = {
835                 .name   = "max17042",
836                 .of_match_table = of_match_ptr(max17042_dt_match),
837                 .pm     = &max17042_pm_ops,
838         },
839         .probe          = max17042_probe,
840         .remove         = max17042_remove,
841         .id_table       = max17042_id,
842 };
843 module_i2c_driver(max17042_i2c_driver);
844 
845 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
846 MODULE_DESCRIPTION("MAX17042 Fuel Gauge");
847 MODULE_LICENSE("GPL");
848 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us