Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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 #define MAX17042_IC_VERSION     0x0092
 67 #define MAX17047_IC_VERSION     0x00AC  /* same for max17050 */
 68 
 69 struct max17042_chip {
 70         struct i2c_client *client;
 71         struct regmap *regmap;
 72         struct power_supply battery;
 73         enum max170xx_chip_type chip_type;
 74         struct max17042_platform_data *pdata;
 75         struct work_struct work;
 76         int    init_complete;
 77 };
 78 
 79 static enum power_supply_property max17042_battery_props[] = {
 80         POWER_SUPPLY_PROP_PRESENT,
 81         POWER_SUPPLY_PROP_CYCLE_COUNT,
 82         POWER_SUPPLY_PROP_VOLTAGE_MAX,
 83         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 84         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 85         POWER_SUPPLY_PROP_VOLTAGE_AVG,
 86         POWER_SUPPLY_PROP_VOLTAGE_OCV,
 87         POWER_SUPPLY_PROP_CAPACITY,
 88         POWER_SUPPLY_PROP_CHARGE_FULL,
 89         POWER_SUPPLY_PROP_CHARGE_COUNTER,
 90         POWER_SUPPLY_PROP_TEMP,
 91         POWER_SUPPLY_PROP_CURRENT_NOW,
 92         POWER_SUPPLY_PROP_CURRENT_AVG,
 93 };
 94 
 95 static int max17042_get_property(struct power_supply *psy,
 96                             enum power_supply_property psp,
 97                             union power_supply_propval *val)
 98 {
 99         struct max17042_chip *chip = container_of(psy,
100                                 struct max17042_chip, battery);
101         struct regmap *map = chip->regmap;
102         int ret;
103         u32 data;
104 
105         if (!chip->init_complete)
106                 return -EAGAIN;
107 
108         switch (psp) {
109         case POWER_SUPPLY_PROP_PRESENT:
110                 ret = regmap_read(map, MAX17042_STATUS, &data);
111                 if (ret < 0)
112                         return ret;
113 
114                 if (data & MAX17042_STATUS_BattAbsent)
115                         val->intval = 0;
116                 else
117                         val->intval = 1;
118                 break;
119         case POWER_SUPPLY_PROP_CYCLE_COUNT:
120                 ret = regmap_read(map, MAX17042_Cycles, &data);
121                 if (ret < 0)
122                         return ret;
123 
124                 val->intval = data;
125                 break;
126         case POWER_SUPPLY_PROP_VOLTAGE_MAX:
127                 ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
128                 if (ret < 0)
129                         return ret;
130 
131                 val->intval = data >> 8;
132                 val->intval *= 20000; /* Units of LSB = 20mV */
133                 break;
134         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
135                 if (chip->chip_type == MAX17042)
136                         ret = regmap_read(map, MAX17042_V_empty, &data);
137                 else
138                         ret = regmap_read(map, MAX17047_V_empty, &data);
139                 if (ret < 0)
140                         return ret;
141 
142                 val->intval = data >> 7;
143                 val->intval *= 10000; /* Units of LSB = 10mV */
144                 break;
145         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
146                 ret = regmap_read(map, MAX17042_VCELL, &data);
147                 if (ret < 0)
148                         return ret;
149 
150                 val->intval = data * 625 / 8;
151                 break;
152         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
153                 ret = regmap_read(map, MAX17042_AvgVCELL, &data);
154                 if (ret < 0)
155                         return ret;
156 
157                 val->intval = data * 625 / 8;
158                 break;
159         case POWER_SUPPLY_PROP_VOLTAGE_OCV:
160                 ret = regmap_read(map, MAX17042_OCVInternal, &data);
161                 if (ret < 0)
162                         return ret;
163 
164                 val->intval = data * 625 / 8;
165                 break;
166         case POWER_SUPPLY_PROP_CAPACITY:
167                 ret = regmap_read(map, MAX17042_RepSOC, &data);
168                 if (ret < 0)
169                         return ret;
170 
171                 val->intval = data >> 8;
172                 break;
173         case POWER_SUPPLY_PROP_CHARGE_FULL:
174                 ret = regmap_read(map, MAX17042_FullCAP, &data);
175                 if (ret < 0)
176                         return ret;
177 
178                 val->intval = data * 1000 / 2;
179                 break;
180         case POWER_SUPPLY_PROP_CHARGE_COUNTER:
181                 ret = regmap_read(map, MAX17042_QH, &data);
182                 if (ret < 0)
183                         return ret;
184 
185                 val->intval = data * 1000 / 2;
186                 break;
187         case POWER_SUPPLY_PROP_TEMP:
188                 ret = regmap_read(map, MAX17042_TEMP, &data);
189                 if (ret < 0)
190                         return ret;
191 
192                 val->intval = data;
193                 /* The value is signed. */
194                 if (val->intval & 0x8000) {
195                         val->intval = (0x7fff & ~val->intval) + 1;
196                         val->intval *= -1;
197                 }
198                 /* The value is converted into deci-centigrade scale */
199                 /* Units of LSB = 1 / 256 degree Celsius */
200                 val->intval = val->intval * 10 / 256;
201                 break;
202         case POWER_SUPPLY_PROP_CURRENT_NOW:
203                 if (chip->pdata->enable_current_sense) {
204                         ret = regmap_read(map, MAX17042_Current, &data);
205                         if (ret < 0)
206                                 return ret;
207 
208                         val->intval = data;
209                         if (val->intval & 0x8000) {
210                                 /* Negative */
211                                 val->intval = ~val->intval & 0x7fff;
212                                 val->intval++;
213                                 val->intval *= -1;
214                         }
215                         val->intval *= 1562500 / chip->pdata->r_sns;
216                 } else {
217                         return -EINVAL;
218                 }
219                 break;
220         case POWER_SUPPLY_PROP_CURRENT_AVG:
221                 if (chip->pdata->enable_current_sense) {
222                         ret = regmap_read(map, MAX17042_AvgCurrent, &data);
223                         if (ret < 0)
224                                 return ret;
225 
226                         val->intval = data;
227                         if (val->intval & 0x8000) {
228                                 /* Negative */
229                                 val->intval = ~val->intval & 0x7fff;
230                                 val->intval++;
231                                 val->intval *= -1;
232                         }
233                         val->intval *= 1562500 / chip->pdata->r_sns;
234                 } else {
235                         return -EINVAL;
236                 }
237                 break;
238         default:
239                 return -EINVAL;
240         }
241         return 0;
242 }
243 
244 static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value)
245 {
246         int retries = 8;
247         int ret;
248         u32 read_value;
249 
250         do {
251                 ret = regmap_write(map, reg, value);
252                 regmap_read(map, reg, &read_value);
253                 if (read_value != value) {
254                         ret = -EIO;
255                         retries--;
256                 }
257         } while (retries && read_value != value);
258 
259         if (ret < 0)
260                 pr_err("%s: err %d\n", __func__, ret);
261 
262         return ret;
263 }
264 
265 static inline void max17042_override_por(struct regmap *map,
266                                          u8 reg, u16 value)
267 {
268         if (value)
269                 regmap_write(map, reg, value);
270 }
271 
272 static inline void max10742_unlock_model(struct max17042_chip *chip)
273 {
274         struct regmap *map = chip->regmap;
275         regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
276         regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
277 }
278 
279 static inline void max10742_lock_model(struct max17042_chip *chip)
280 {
281         struct regmap *map = chip->regmap;
282 
283         regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1);
284         regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2);
285 }
286 
287 static inline void max17042_write_model_data(struct max17042_chip *chip,
288                                         u8 addr, int size)
289 {
290         struct regmap *map = chip->regmap;
291         int i;
292         for (i = 0; i < size; i++)
293                 regmap_write(map, addr + i,
294                         chip->pdata->config_data->cell_char_tbl[i]);
295 }
296 
297 static inline void max17042_read_model_data(struct max17042_chip *chip,
298                                         u8 addr, u32 *data, int size)
299 {
300         struct regmap *map = chip->regmap;
301         int i;
302 
303         for (i = 0; i < size; i++)
304                 regmap_read(map, addr + i, &data[i]);
305 }
306 
307 static inline int max17042_model_data_compare(struct max17042_chip *chip,
308                                         u16 *data1, u16 *data2, int size)
309 {
310         int i;
311 
312         if (memcmp(data1, data2, size)) {
313                 dev_err(&chip->client->dev, "%s compare failed\n", __func__);
314                 for (i = 0; i < size; i++)
315                         dev_info(&chip->client->dev, "0x%x, 0x%x",
316                                 data1[i], data2[i]);
317                 dev_info(&chip->client->dev, "\n");
318                 return -EINVAL;
319         }
320         return 0;
321 }
322 
323 static int max17042_init_model(struct max17042_chip *chip)
324 {
325         int ret;
326         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
327         u32 *temp_data;
328 
329         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
330         if (!temp_data)
331                 return -ENOMEM;
332 
333         max10742_unlock_model(chip);
334         max17042_write_model_data(chip, MAX17042_MODELChrTbl,
335                                 table_size);
336         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
337                                 table_size);
338 
339         ret = max17042_model_data_compare(
340                 chip,
341                 chip->pdata->config_data->cell_char_tbl,
342                 (u16 *)temp_data,
343                 table_size);
344 
345         max10742_lock_model(chip);
346         kfree(temp_data);
347 
348         return ret;
349 }
350 
351 static int max17042_verify_model_lock(struct max17042_chip *chip)
352 {
353         int i;
354         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
355         u32 *temp_data;
356         int ret = 0;
357 
358         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
359         if (!temp_data)
360                 return -ENOMEM;
361 
362         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
363                                 table_size);
364         for (i = 0; i < table_size; i++)
365                 if (temp_data[i])
366                         ret = -EINVAL;
367 
368         kfree(temp_data);
369         return ret;
370 }
371 
372 static void max17042_write_config_regs(struct max17042_chip *chip)
373 {
374         struct max17042_config_data *config = chip->pdata->config_data;
375         struct regmap *map = chip->regmap;
376 
377         regmap_write(map, MAX17042_CONFIG, config->config);
378         regmap_write(map, MAX17042_LearnCFG, config->learn_cfg);
379         regmap_write(map, MAX17042_FilterCFG,
380                         config->filter_cfg);
381         regmap_write(map, MAX17042_RelaxCFG, config->relax_cfg);
382         if (chip->chip_type == MAX17047)
383                 regmap_write(map, MAX17047_FullSOCThr,
384                                                 config->full_soc_thresh);
385 }
386 
387 static void  max17042_write_custom_regs(struct max17042_chip *chip)
388 {
389         struct max17042_config_data *config = chip->pdata->config_data;
390         struct regmap *map = chip->regmap;
391 
392         max17042_write_verify_reg(map, MAX17042_RCOMP0, config->rcomp0);
393         max17042_write_verify_reg(map, MAX17042_TempCo, config->tcompc0);
394         max17042_write_verify_reg(map, MAX17042_ICHGTerm, config->ichgt_term);
395         if (chip->chip_type == MAX17042) {
396                 regmap_write(map, MAX17042_EmptyTempCo, config->empty_tempco);
397                 max17042_write_verify_reg(map, MAX17042_K_empty0,
398                                         config->kempty0);
399         } else {
400                 max17042_write_verify_reg(map, MAX17047_QRTbl00,
401                                                 config->qrtbl00);
402                 max17042_write_verify_reg(map, MAX17047_QRTbl10,
403                                                 config->qrtbl10);
404                 max17042_write_verify_reg(map, MAX17047_QRTbl20,
405                                                 config->qrtbl20);
406                 max17042_write_verify_reg(map, MAX17047_QRTbl30,
407                                                 config->qrtbl30);
408         }
409 }
410 
411 static void max17042_update_capacity_regs(struct max17042_chip *chip)
412 {
413         struct max17042_config_data *config = chip->pdata->config_data;
414         struct regmap *map = chip->regmap;
415 
416         max17042_write_verify_reg(map, MAX17042_FullCAP,
417                                 config->fullcap);
418         regmap_write(map, MAX17042_DesignCap, config->design_cap);
419         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
420                                 config->fullcapnom);
421 }
422 
423 static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip)
424 {
425         unsigned int vfSoc;
426         struct regmap *map = chip->regmap;
427 
428         regmap_read(map, MAX17042_VFSOC, &vfSoc);
429         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK);
430         max17042_write_verify_reg(map, MAX17042_VFSOC0, vfSoc);
431         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK);
432 }
433 
434 static void max17042_load_new_capacity_params(struct max17042_chip *chip)
435 {
436         u32 full_cap0, rep_cap, dq_acc, vfSoc;
437         u32 rem_cap;
438 
439         struct max17042_config_data *config = chip->pdata->config_data;
440         struct regmap *map = chip->regmap;
441 
442         regmap_read(map, MAX17042_FullCAP0, &full_cap0);
443         regmap_read(map, MAX17042_VFSOC, &vfSoc);
444 
445         /* fg_vfSoc needs to shifted by 8 bits to get the
446          * perc in 1% accuracy, to get the right rem_cap multiply
447          * full_cap0, fg_vfSoc and devide by 100
448          */
449         rem_cap = ((vfSoc >> 8) * full_cap0) / 100;
450         max17042_write_verify_reg(map, MAX17042_RemCap, rem_cap);
451 
452         rep_cap = rem_cap;
453         max17042_write_verify_reg(map, MAX17042_RepCap, rep_cap);
454 
455         /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */
456         dq_acc = config->fullcap / dQ_ACC_DIV;
457         max17042_write_verify_reg(map, MAX17042_dQacc, dq_acc);
458         max17042_write_verify_reg(map, MAX17042_dPacc, dP_ACC_200);
459 
460         max17042_write_verify_reg(map, MAX17042_FullCAP,
461                         config->fullcap);
462         regmap_write(map, MAX17042_DesignCap,
463                         config->design_cap);
464         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
465                         config->fullcapnom);
466         /* Update SOC register with new SOC */
467         regmap_write(map, MAX17042_RepSOC, vfSoc);
468 }
469 
470 /*
471  * Block write all the override values coming from platform data.
472  * This function MUST be called before the POR initialization proceedure
473  * specified by maxim.
474  */
475 static inline void max17042_override_por_values(struct max17042_chip *chip)
476 {
477         struct regmap *map = chip->regmap;
478         struct max17042_config_data *config = chip->pdata->config_data;
479 
480         max17042_override_por(map, MAX17042_TGAIN, config->tgain);
481         max17042_override_por(map, MAx17042_TOFF, config->toff);
482         max17042_override_por(map, MAX17042_CGAIN, config->cgain);
483         max17042_override_por(map, MAX17042_COFF, config->coff);
484 
485         max17042_override_por(map, MAX17042_VALRT_Th, config->valrt_thresh);
486         max17042_override_por(map, MAX17042_TALRT_Th, config->talrt_thresh);
487         max17042_override_por(map, MAX17042_SALRT_Th,
488                                                 config->soc_alrt_thresh);
489         max17042_override_por(map, MAX17042_CONFIG, config->config);
490         max17042_override_por(map, MAX17042_SHDNTIMER, config->shdntimer);
491 
492         max17042_override_por(map, MAX17042_DesignCap, config->design_cap);
493         max17042_override_por(map, MAX17042_ICHGTerm, config->ichgt_term);
494 
495         max17042_override_por(map, MAX17042_AtRate, config->at_rate);
496         max17042_override_por(map, MAX17042_LearnCFG, config->learn_cfg);
497         max17042_override_por(map, MAX17042_FilterCFG, config->filter_cfg);
498         max17042_override_por(map, MAX17042_RelaxCFG, config->relax_cfg);
499         max17042_override_por(map, MAX17042_MiscCFG, config->misc_cfg);
500         max17042_override_por(map, MAX17042_MaskSOC, config->masksoc);
501 
502         max17042_override_por(map, MAX17042_FullCAP, config->fullcap);
503         max17042_override_por(map, MAX17042_FullCAPNom, config->fullcapnom);
504         if (chip->chip_type == MAX17042)
505                 max17042_override_por(map, MAX17042_SOC_empty,
506                                                 config->socempty);
507         max17042_override_por(map, MAX17042_LAvg_empty, config->lavg_empty);
508         max17042_override_por(map, MAX17042_dQacc, config->dqacc);
509         max17042_override_por(map, MAX17042_dPacc, config->dpacc);
510 
511         if (chip->chip_type == MAX17042)
512                 max17042_override_por(map, MAX17042_V_empty, config->vempty);
513         else
514                 max17042_override_por(map, MAX17047_V_empty, config->vempty);
515         max17042_override_por(map, MAX17042_TempNom, config->temp_nom);
516         max17042_override_por(map, MAX17042_TempLim, config->temp_lim);
517         max17042_override_por(map, MAX17042_FCTC, config->fctc);
518         max17042_override_por(map, MAX17042_RCOMP0, config->rcomp0);
519         max17042_override_por(map, MAX17042_TempCo, config->tcompc0);
520         if (chip->chip_type) {
521                 max17042_override_por(map, MAX17042_EmptyTempCo,
522                                                 config->empty_tempco);
523                 max17042_override_por(map, MAX17042_K_empty0,
524                                                 config->kempty0);
525         }
526 }
527 
528 static int max17042_init_chip(struct max17042_chip *chip)
529 {
530         struct regmap *map = chip->regmap;
531         int ret;
532         int val;
533 
534         max17042_override_por_values(chip);
535         /* After Power up, the MAX17042 requires 500mS in order
536          * to perform signal debouncing and initial SOC reporting
537          */
538         msleep(500);
539 
540         /* Initialize configaration */
541         max17042_write_config_regs(chip);
542 
543         /* write cell characterization data */
544         ret = max17042_init_model(chip);
545         if (ret) {
546                 dev_err(&chip->client->dev, "%s init failed\n",
547                         __func__);
548                 return -EIO;
549         }
550 
551         ret = max17042_verify_model_lock(chip);
552         if (ret) {
553                 dev_err(&chip->client->dev, "%s lock verify failed\n",
554                         __func__);
555                 return -EIO;
556         }
557         /* write custom parameters */
558         max17042_write_custom_regs(chip);
559 
560         /* update capacity params */
561         max17042_update_capacity_regs(chip);
562 
563         /* delay must be atleast 350mS to allow VFSOC
564          * to be calculated from the new configuration
565          */
566         msleep(350);
567 
568         /* reset vfsoc0 reg */
569         max17042_reset_vfsoc0_reg(chip);
570 
571         /* load new capacity params */
572         max17042_load_new_capacity_params(chip);
573 
574         /* Init complete, Clear the POR bit */
575         regmap_read(map, MAX17042_STATUS, &val);
576         regmap_write(map, MAX17042_STATUS, val & (~STATUS_POR_BIT));
577         return 0;
578 }
579 
580 static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off)
581 {
582         struct regmap *map = chip->regmap;
583         u32 soc, soc_tr;
584 
585         /* program interrupt thesholds such that we should
586          * get interrupt for every 'off' perc change in the soc
587          */
588         regmap_read(map, MAX17042_RepSOC, &soc);
589         soc >>= 8;
590         soc_tr = (soc + off) << 8;
591         soc_tr |= (soc - off);
592         regmap_write(map, MAX17042_SALRT_Th, soc_tr);
593 }
594 
595 static irqreturn_t max17042_thread_handler(int id, void *dev)
596 {
597         struct max17042_chip *chip = dev;
598         u32 val;
599 
600         regmap_read(chip->regmap, MAX17042_STATUS, &val);
601         if ((val & STATUS_INTR_SOCMIN_BIT) ||
602                 (val & STATUS_INTR_SOCMAX_BIT)) {
603                 dev_info(&chip->client->dev, "SOC threshold INTR\n");
604                 max17042_set_soc_threshold(chip, 1);
605         }
606 
607         power_supply_changed(&chip->battery);
608         return IRQ_HANDLED;
609 }
610 
611 static void max17042_init_worker(struct work_struct *work)
612 {
613         struct max17042_chip *chip = container_of(work,
614                                 struct max17042_chip, work);
615         int ret;
616 
617         /* Initialize registers according to values from the platform data */
618         if (chip->pdata->enable_por_init && chip->pdata->config_data) {
619                 ret = max17042_init_chip(chip);
620                 if (ret)
621                         return;
622         }
623 
624         chip->init_complete = 1;
625 }
626 
627 #ifdef CONFIG_OF
628 static struct max17042_platform_data *
629 max17042_get_pdata(struct device *dev)
630 {
631         struct device_node *np = dev->of_node;
632         u32 prop;
633         struct max17042_platform_data *pdata;
634 
635         if (!np)
636                 return dev->platform_data;
637 
638         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
639         if (!pdata)
640                 return NULL;
641 
642         /*
643          * Require current sense resistor value to be specified for
644          * current-sense functionality to be enabled at all.
645          */
646         if (of_property_read_u32(np, "maxim,rsns-microohm", &prop) == 0) {
647                 pdata->r_sns = prop;
648                 pdata->enable_current_sense = true;
649         }
650 
651         return pdata;
652 }
653 #else
654 static struct max17042_platform_data *
655 max17042_get_pdata(struct device *dev)
656 {
657         return dev->platform_data;
658 }
659 #endif
660 
661 static struct regmap_config max17042_regmap_config = {
662         .reg_bits = 8,
663         .val_bits = 16,
664         .val_format_endian = REGMAP_ENDIAN_NATIVE,
665 };
666 
667 static int max17042_probe(struct i2c_client *client,
668                         const struct i2c_device_id *id)
669 {
670         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
671         struct max17042_chip *chip;
672         int ret;
673         int i;
674         u32 val;
675 
676         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
677                 return -EIO;
678 
679         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
680         if (!chip)
681                 return -ENOMEM;
682 
683         chip->client = client;
684         chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config);
685         if (IS_ERR(chip->regmap)) {
686                 dev_err(&client->dev, "Failed to initialize regmap\n");
687                 return -EINVAL;
688         }
689 
690         chip->pdata = max17042_get_pdata(&client->dev);
691         if (!chip->pdata) {
692                 dev_err(&client->dev, "no platform data provided\n");
693                 return -EINVAL;
694         }
695 
696         i2c_set_clientdata(client, chip);
697 
698         regmap_read(chip->regmap, MAX17042_DevName, &val);
699         if (val == MAX17042_IC_VERSION) {
700                 dev_dbg(&client->dev, "chip type max17042 detected\n");
701                 chip->chip_type = MAX17042;
702         } else if (val == MAX17047_IC_VERSION) {
703                 dev_dbg(&client->dev, "chip type max17047/50 detected\n");
704                 chip->chip_type = MAX17047;
705         } else {
706                 dev_err(&client->dev, "device version mismatch: %x\n", val);
707                 return -EIO;
708         }
709 
710         chip->battery.name              = "max170xx_battery";
711         chip->battery.type              = POWER_SUPPLY_TYPE_BATTERY;
712         chip->battery.get_property      = max17042_get_property;
713         chip->battery.properties        = max17042_battery_props;
714         chip->battery.num_properties    = ARRAY_SIZE(max17042_battery_props);
715 
716         /* When current is not measured,
717          * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
718         if (!chip->pdata->enable_current_sense)
719                 chip->battery.num_properties -= 2;
720 
721         if (chip->pdata->r_sns == 0)
722                 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
723 
724         if (chip->pdata->init_data)
725                 for (i = 0; i < chip->pdata->num_init_data; i++)
726                         regmap_write(chip->regmap,
727                                         chip->pdata->init_data[i].addr,
728                                         chip->pdata->init_data[i].data);
729 
730         if (!chip->pdata->enable_current_sense) {
731                 regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000);
732                 regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003);
733                 regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007);
734         }
735 
736         ret = power_supply_register(&client->dev, &chip->battery);
737         if (ret) {
738                 dev_err(&client->dev, "failed: power supply register\n");
739                 return ret;
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.name, chip);
747                 if (!ret) {
748                         regmap_read(chip->regmap, MAX17042_CONFIG, &val);
749                         val |= CONFIG_ALRT_BIT_ENBL;
750                         regmap_write(chip->regmap, MAX17042_CONFIG, val);
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", 0 },
827         { "max17047", 1 },
828         { "max17050", 2 },
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