Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

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_VMAX_TOLERANCE         50 /* 50 mV */
 67 
 68 struct max17042_chip {
 69         struct i2c_client *client;
 70         struct regmap *regmap;
 71         struct power_supply *battery;
 72         enum max170xx_chip_type chip_type;
 73         struct max17042_platform_data *pdata;
 74         struct work_struct work;
 75         int    init_complete;
 76 };
 77 
 78 static enum power_supply_property max17042_battery_props[] = {
 79         POWER_SUPPLY_PROP_PRESENT,
 80         POWER_SUPPLY_PROP_CYCLE_COUNT,
 81         POWER_SUPPLY_PROP_VOLTAGE_MAX,
 82         POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
 83         POWER_SUPPLY_PROP_VOLTAGE_NOW,
 84         POWER_SUPPLY_PROP_VOLTAGE_AVG,
 85         POWER_SUPPLY_PROP_VOLTAGE_OCV,
 86         POWER_SUPPLY_PROP_CAPACITY,
 87         POWER_SUPPLY_PROP_CHARGE_FULL,
 88         POWER_SUPPLY_PROP_CHARGE_COUNTER,
 89         POWER_SUPPLY_PROP_TEMP,
 90         POWER_SUPPLY_PROP_TEMP_ALERT_MIN,
 91         POWER_SUPPLY_PROP_TEMP_ALERT_MAX,
 92         POWER_SUPPLY_PROP_TEMP_MIN,
 93         POWER_SUPPLY_PROP_TEMP_MAX,
 94         POWER_SUPPLY_PROP_HEALTH,
 95         POWER_SUPPLY_PROP_CURRENT_NOW,
 96         POWER_SUPPLY_PROP_CURRENT_AVG,
 97 };
 98 
 99 static int max17042_get_temperature(struct max17042_chip *chip, int *temp)
100 {
101         int ret;
102         u32 data;
103         struct regmap *map = chip->regmap;
104 
105         ret = regmap_read(map, MAX17042_TEMP, &data);
106         if (ret < 0)
107                 return ret;
108 
109         *temp = data;
110         /* The value is signed. */
111         if (*temp & 0x8000) {
112                 *temp = (0x7fff & ~*temp) + 1;
113                 *temp *= -1;
114         }
115 
116         /* The value is converted into deci-centigrade scale */
117         /* Units of LSB = 1 / 256 degree Celsius */
118         *temp = *temp * 10 / 256;
119         return 0;
120 }
121 
122 static int max17042_get_battery_health(struct max17042_chip *chip, int *health)
123 {
124         int temp, vavg, vbatt, ret;
125         u32 val;
126 
127         ret = regmap_read(chip->regmap, MAX17042_AvgVCELL, &val);
128         if (ret < 0)
129                 goto health_error;
130 
131         /* bits [0-3] unused */
132         vavg = val * 625 / 8;
133         /* Convert to millivolts */
134         vavg /= 1000;
135 
136         ret = regmap_read(chip->regmap, MAX17042_VCELL, &val);
137         if (ret < 0)
138                 goto health_error;
139 
140         /* bits [0-3] unused */
141         vbatt = val * 625 / 8;
142         /* Convert to millivolts */
143         vbatt /= 1000;
144 
145         if (vavg < chip->pdata->vmin) {
146                 *health = POWER_SUPPLY_HEALTH_DEAD;
147                 goto out;
148         }
149 
150         if (vbatt > chip->pdata->vmax + MAX17042_VMAX_TOLERANCE) {
151                 *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
152                 goto out;
153         }
154 
155         ret = max17042_get_temperature(chip, &temp);
156         if (ret < 0)
157                 goto health_error;
158 
159         if (temp <= chip->pdata->temp_min) {
160                 *health = POWER_SUPPLY_HEALTH_COLD;
161                 goto out;
162         }
163 
164         if (temp >= chip->pdata->temp_max) {
165                 *health = POWER_SUPPLY_HEALTH_OVERHEAT;
166                 goto out;
167         }
168 
169         *health = POWER_SUPPLY_HEALTH_GOOD;
170 
171 out:
172         return 0;
173 
174 health_error:
175         return ret;
176 }
177 
178 static int max17042_get_property(struct power_supply *psy,
179                             enum power_supply_property psp,
180                             union power_supply_propval *val)
181 {
182         struct max17042_chip *chip = power_supply_get_drvdata(psy);
183         struct regmap *map = chip->regmap;
184         int ret;
185         u32 data;
186 
187         if (!chip->init_complete)
188                 return -EAGAIN;
189 
190         switch (psp) {
191         case POWER_SUPPLY_PROP_PRESENT:
192                 ret = regmap_read(map, MAX17042_STATUS, &data);
193                 if (ret < 0)
194                         return ret;
195 
196                 if (data & MAX17042_STATUS_BattAbsent)
197                         val->intval = 0;
198                 else
199                         val->intval = 1;
200                 break;
201         case POWER_SUPPLY_PROP_CYCLE_COUNT:
202                 ret = regmap_read(map, MAX17042_Cycles, &data);
203                 if (ret < 0)
204                         return ret;
205 
206                 val->intval = data;
207                 break;
208         case POWER_SUPPLY_PROP_VOLTAGE_MAX:
209                 ret = regmap_read(map, MAX17042_MinMaxVolt, &data);
210                 if (ret < 0)
211                         return ret;
212 
213                 val->intval = data >> 8;
214                 val->intval *= 20000; /* Units of LSB = 20mV */
215                 break;
216         case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
217                 if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
218                         ret = regmap_read(map, MAX17042_V_empty, &data);
219                 else
220                         ret = regmap_read(map, MAX17047_V_empty, &data);
221                 if (ret < 0)
222                         return ret;
223 
224                 val->intval = data >> 7;
225                 val->intval *= 10000; /* Units of LSB = 10mV */
226                 break;
227         case POWER_SUPPLY_PROP_VOLTAGE_NOW:
228                 ret = regmap_read(map, MAX17042_VCELL, &data);
229                 if (ret < 0)
230                         return ret;
231 
232                 val->intval = data * 625 / 8;
233                 break;
234         case POWER_SUPPLY_PROP_VOLTAGE_AVG:
235                 ret = regmap_read(map, MAX17042_AvgVCELL, &data);
236                 if (ret < 0)
237                         return ret;
238 
239                 val->intval = data * 625 / 8;
240                 break;
241         case POWER_SUPPLY_PROP_VOLTAGE_OCV:
242                 ret = regmap_read(map, MAX17042_OCVInternal, &data);
243                 if (ret < 0)
244                         return ret;
245 
246                 val->intval = data * 625 / 8;
247                 break;
248         case POWER_SUPPLY_PROP_CAPACITY:
249                 ret = regmap_read(map, MAX17042_RepSOC, &data);
250                 if (ret < 0)
251                         return ret;
252 
253                 val->intval = data >> 8;
254                 break;
255         case POWER_SUPPLY_PROP_CHARGE_FULL:
256                 ret = regmap_read(map, MAX17042_FullCAP, &data);
257                 if (ret < 0)
258                         return ret;
259 
260                 val->intval = data * 1000 / 2;
261                 break;
262         case POWER_SUPPLY_PROP_CHARGE_COUNTER:
263                 ret = regmap_read(map, MAX17042_QH, &data);
264                 if (ret < 0)
265                         return ret;
266 
267                 val->intval = data * 1000 / 2;
268                 break;
269         case POWER_SUPPLY_PROP_TEMP:
270                 ret = max17042_get_temperature(chip, &val->intval);
271                 if (ret < 0)
272                         return ret;
273                 break;
274         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
275                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
276                 if (ret < 0)
277                         return ret;
278                 /* LSB is Alert Minimum. In deci-centigrade */
279                 val->intval = (data & 0xff) * 10;
280                 break;
281         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
282                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
283                 if (ret < 0)
284                         return ret;
285                 /* MSB is Alert Maximum. In deci-centigrade */
286                 val->intval = (data >> 8) * 10;
287                 break;
288         case POWER_SUPPLY_PROP_TEMP_MIN:
289                 val->intval = chip->pdata->temp_min;
290                 break;
291         case POWER_SUPPLY_PROP_TEMP_MAX:
292                 val->intval = chip->pdata->temp_max;
293                 break;
294         case POWER_SUPPLY_PROP_HEALTH:
295                 ret = max17042_get_battery_health(chip, &val->intval);
296                 if (ret < 0)
297                         return ret;
298                 break;
299         case POWER_SUPPLY_PROP_CURRENT_NOW:
300                 if (chip->pdata->enable_current_sense) {
301                         ret = regmap_read(map, MAX17042_Current, &data);
302                         if (ret < 0)
303                                 return ret;
304 
305                         val->intval = data;
306                         if (val->intval & 0x8000) {
307                                 /* Negative */
308                                 val->intval = ~val->intval & 0x7fff;
309                                 val->intval++;
310                                 val->intval *= -1;
311                         }
312                         val->intval *= 1562500 / chip->pdata->r_sns;
313                 } else {
314                         return -EINVAL;
315                 }
316                 break;
317         case POWER_SUPPLY_PROP_CURRENT_AVG:
318                 if (chip->pdata->enable_current_sense) {
319                         ret = regmap_read(map, MAX17042_AvgCurrent, &data);
320                         if (ret < 0)
321                                 return ret;
322 
323                         val->intval = data;
324                         if (val->intval & 0x8000) {
325                                 /* Negative */
326                                 val->intval = ~val->intval & 0x7fff;
327                                 val->intval++;
328                                 val->intval *= -1;
329                         }
330                         val->intval *= 1562500 / chip->pdata->r_sns;
331                 } else {
332                         return -EINVAL;
333                 }
334                 break;
335         default:
336                 return -EINVAL;
337         }
338         return 0;
339 }
340 
341 static int max17042_set_property(struct power_supply *psy,
342                             enum power_supply_property psp,
343                             const union power_supply_propval *val)
344 {
345         struct max17042_chip *chip = power_supply_get_drvdata(psy);
346         struct regmap *map = chip->regmap;
347         int ret = 0;
348         u32 data;
349         int8_t temp;
350 
351         switch (psp) {
352         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
353                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
354                 if (ret < 0)
355                         return ret;
356 
357                 /* Input in deci-centigrade, convert to centigrade */
358                 temp = val->intval / 10;
359                 /* force min < max */
360                 if (temp >= (int8_t)(data >> 8))
361                         temp = (int8_t)(data >> 8) - 1;
362                 /* Write both MAX and MIN ALERT */
363                 data = (data & 0xff00) + temp;
364                 ret = regmap_write(map, MAX17042_TALRT_Th, data);
365                 break;
366         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
367                 ret = regmap_read(map, MAX17042_TALRT_Th, &data);
368                 if (ret < 0)
369                         return ret;
370 
371                 /* Input in Deci-Centigrade, convert to centigrade */
372                 temp = val->intval / 10;
373                 /* force max > min */
374                 if (temp <= (int8_t)(data & 0xff))
375                         temp = (int8_t)(data & 0xff) + 1;
376                 /* Write both MAX and MIN ALERT */
377                 data = (data & 0xff) + (temp << 8);
378                 ret = regmap_write(map, MAX17042_TALRT_Th, data);
379                 break;
380         default:
381                 ret = -EINVAL;
382         }
383 
384         return ret;
385 }
386 
387 static int max17042_property_is_writeable(struct power_supply *psy,
388                 enum power_supply_property psp)
389 {
390         int ret;
391 
392         switch (psp) {
393         case POWER_SUPPLY_PROP_TEMP_ALERT_MIN:
394         case POWER_SUPPLY_PROP_TEMP_ALERT_MAX:
395                 ret = 1;
396                 break;
397         default:
398                 ret = 0;
399         }
400 
401         return ret;
402 }
403 
404 static int max17042_write_verify_reg(struct regmap *map, u8 reg, u32 value)
405 {
406         int retries = 8;
407         int ret;
408         u32 read_value;
409 
410         do {
411                 ret = regmap_write(map, reg, value);
412                 regmap_read(map, reg, &read_value);
413                 if (read_value != value) {
414                         ret = -EIO;
415                         retries--;
416                 }
417         } while (retries && read_value != value);
418 
419         if (ret < 0)
420                 pr_err("%s: err %d\n", __func__, ret);
421 
422         return ret;
423 }
424 
425 static inline void max17042_override_por(struct regmap *map,
426                                          u8 reg, u16 value)
427 {
428         if (value)
429                 regmap_write(map, reg, value);
430 }
431 
432 static inline void max10742_unlock_model(struct max17042_chip *chip)
433 {
434         struct regmap *map = chip->regmap;
435 
436         regmap_write(map, MAX17042_MLOCKReg1, MODEL_UNLOCK1);
437         regmap_write(map, MAX17042_MLOCKReg2, MODEL_UNLOCK2);
438 }
439 
440 static inline void max10742_lock_model(struct max17042_chip *chip)
441 {
442         struct regmap *map = chip->regmap;
443 
444         regmap_write(map, MAX17042_MLOCKReg1, MODEL_LOCK1);
445         regmap_write(map, MAX17042_MLOCKReg2, MODEL_LOCK2);
446 }
447 
448 static inline void max17042_write_model_data(struct max17042_chip *chip,
449                                         u8 addr, int size)
450 {
451         struct regmap *map = chip->regmap;
452         int i;
453 
454         for (i = 0; i < size; i++)
455                 regmap_write(map, addr + i,
456                         chip->pdata->config_data->cell_char_tbl[i]);
457 }
458 
459 static inline void max17042_read_model_data(struct max17042_chip *chip,
460                                         u8 addr, u16 *data, int size)
461 {
462         struct regmap *map = chip->regmap;
463         int i;
464         u32 tmp;
465 
466         for (i = 0; i < size; i++) {
467                 regmap_read(map, addr + i, &tmp);
468                 data[i] = (u16)tmp;
469         }
470 }
471 
472 static inline int max17042_model_data_compare(struct max17042_chip *chip,
473                                         u16 *data1, u16 *data2, int size)
474 {
475         int i;
476 
477         if (memcmp(data1, data2, size)) {
478                 dev_err(&chip->client->dev, "%s compare failed\n", __func__);
479                 for (i = 0; i < size; i++)
480                         dev_info(&chip->client->dev, "0x%x, 0x%x",
481                                 data1[i], data2[i]);
482                 dev_info(&chip->client->dev, "\n");
483                 return -EINVAL;
484         }
485         return 0;
486 }
487 
488 static int max17042_init_model(struct max17042_chip *chip)
489 {
490         int ret;
491         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
492         u16 *temp_data;
493 
494         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
495         if (!temp_data)
496                 return -ENOMEM;
497 
498         max10742_unlock_model(chip);
499         max17042_write_model_data(chip, MAX17042_MODELChrTbl,
500                                 table_size);
501         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
502                                 table_size);
503 
504         ret = max17042_model_data_compare(
505                 chip,
506                 chip->pdata->config_data->cell_char_tbl,
507                 temp_data,
508                 table_size);
509 
510         max10742_lock_model(chip);
511         kfree(temp_data);
512 
513         return ret;
514 }
515 
516 static int max17042_verify_model_lock(struct max17042_chip *chip)
517 {
518         int i;
519         int table_size = ARRAY_SIZE(chip->pdata->config_data->cell_char_tbl);
520         u16 *temp_data;
521         int ret = 0;
522 
523         temp_data = kcalloc(table_size, sizeof(*temp_data), GFP_KERNEL);
524         if (!temp_data)
525                 return -ENOMEM;
526 
527         max17042_read_model_data(chip, MAX17042_MODELChrTbl, temp_data,
528                                 table_size);
529         for (i = 0; i < table_size; i++)
530                 if (temp_data[i])
531                         ret = -EINVAL;
532 
533         kfree(temp_data);
534         return ret;
535 }
536 
537 static void max17042_write_config_regs(struct max17042_chip *chip)
538 {
539         struct max17042_config_data *config = chip->pdata->config_data;
540         struct regmap *map = chip->regmap;
541 
542         regmap_write(map, MAX17042_CONFIG, config->config);
543         regmap_write(map, MAX17042_LearnCFG, config->learn_cfg);
544         regmap_write(map, MAX17042_FilterCFG,
545                         config->filter_cfg);
546         regmap_write(map, MAX17042_RelaxCFG, config->relax_cfg);
547         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17047 ||
548                         chip->chip_type == MAXIM_DEVICE_TYPE_MAX17050)
549                 regmap_write(map, MAX17047_FullSOCThr,
550                                                 config->full_soc_thresh);
551 }
552 
553 static void  max17042_write_custom_regs(struct max17042_chip *chip)
554 {
555         struct max17042_config_data *config = chip->pdata->config_data;
556         struct regmap *map = chip->regmap;
557 
558         max17042_write_verify_reg(map, MAX17042_RCOMP0, config->rcomp0);
559         max17042_write_verify_reg(map, MAX17042_TempCo, config->tcompc0);
560         max17042_write_verify_reg(map, MAX17042_ICHGTerm, config->ichgt_term);
561         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042) {
562                 regmap_write(map, MAX17042_EmptyTempCo, config->empty_tempco);
563                 max17042_write_verify_reg(map, MAX17042_K_empty0,
564                                         config->kempty0);
565         } else {
566                 max17042_write_verify_reg(map, MAX17047_QRTbl00,
567                                                 config->qrtbl00);
568                 max17042_write_verify_reg(map, MAX17047_QRTbl10,
569                                                 config->qrtbl10);
570                 max17042_write_verify_reg(map, MAX17047_QRTbl20,
571                                                 config->qrtbl20);
572                 max17042_write_verify_reg(map, MAX17047_QRTbl30,
573                                                 config->qrtbl30);
574         }
575 }
576 
577 static void max17042_update_capacity_regs(struct max17042_chip *chip)
578 {
579         struct max17042_config_data *config = chip->pdata->config_data;
580         struct regmap *map = chip->regmap;
581 
582         max17042_write_verify_reg(map, MAX17042_FullCAP,
583                                 config->fullcap);
584         regmap_write(map, MAX17042_DesignCap, config->design_cap);
585         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
586                                 config->fullcapnom);
587 }
588 
589 static void max17042_reset_vfsoc0_reg(struct max17042_chip *chip)
590 {
591         unsigned int vfSoc;
592         struct regmap *map = chip->regmap;
593 
594         regmap_read(map, MAX17042_VFSOC, &vfSoc);
595         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_UNLOCK);
596         max17042_write_verify_reg(map, MAX17042_VFSOC0, vfSoc);
597         regmap_write(map, MAX17042_VFSOC0Enable, VFSOC0_LOCK);
598 }
599 
600 static void max17042_load_new_capacity_params(struct max17042_chip *chip)
601 {
602         u32 full_cap0, rep_cap, dq_acc, vfSoc;
603         u32 rem_cap;
604 
605         struct max17042_config_data *config = chip->pdata->config_data;
606         struct regmap *map = chip->regmap;
607 
608         regmap_read(map, MAX17042_FullCAP0, &full_cap0);
609         regmap_read(map, MAX17042_VFSOC, &vfSoc);
610 
611         /* fg_vfSoc needs to shifted by 8 bits to get the
612          * perc in 1% accuracy, to get the right rem_cap multiply
613          * full_cap0, fg_vfSoc and devide by 100
614          */
615         rem_cap = ((vfSoc >> 8) * full_cap0) / 100;
616         max17042_write_verify_reg(map, MAX17042_RemCap, rem_cap);
617 
618         rep_cap = rem_cap;
619         max17042_write_verify_reg(map, MAX17042_RepCap, rep_cap);
620 
621         /* Write dQ_acc to 200% of Capacity and dP_acc to 200% */
622         dq_acc = config->fullcap / dQ_ACC_DIV;
623         max17042_write_verify_reg(map, MAX17042_dQacc, dq_acc);
624         max17042_write_verify_reg(map, MAX17042_dPacc, dP_ACC_200);
625 
626         max17042_write_verify_reg(map, MAX17042_FullCAP,
627                         config->fullcap);
628         regmap_write(map, MAX17042_DesignCap,
629                         config->design_cap);
630         max17042_write_verify_reg(map, MAX17042_FullCAPNom,
631                         config->fullcapnom);
632         /* Update SOC register with new SOC */
633         regmap_write(map, MAX17042_RepSOC, vfSoc);
634 }
635 
636 /*
637  * Block write all the override values coming from platform data.
638  * This function MUST be called before the POR initialization proceedure
639  * specified by maxim.
640  */
641 static inline void max17042_override_por_values(struct max17042_chip *chip)
642 {
643         struct regmap *map = chip->regmap;
644         struct max17042_config_data *config = chip->pdata->config_data;
645 
646         max17042_override_por(map, MAX17042_TGAIN, config->tgain);
647         max17042_override_por(map, MAx17042_TOFF, config->toff);
648         max17042_override_por(map, MAX17042_CGAIN, config->cgain);
649         max17042_override_por(map, MAX17042_COFF, config->coff);
650 
651         max17042_override_por(map, MAX17042_VALRT_Th, config->valrt_thresh);
652         max17042_override_por(map, MAX17042_TALRT_Th, config->talrt_thresh);
653         max17042_override_por(map, MAX17042_SALRT_Th,
654                                                 config->soc_alrt_thresh);
655         max17042_override_por(map, MAX17042_CONFIG, config->config);
656         max17042_override_por(map, MAX17042_SHDNTIMER, config->shdntimer);
657 
658         max17042_override_por(map, MAX17042_DesignCap, config->design_cap);
659         max17042_override_por(map, MAX17042_ICHGTerm, config->ichgt_term);
660 
661         max17042_override_por(map, MAX17042_AtRate, config->at_rate);
662         max17042_override_por(map, MAX17042_LearnCFG, config->learn_cfg);
663         max17042_override_por(map, MAX17042_FilterCFG, config->filter_cfg);
664         max17042_override_por(map, MAX17042_RelaxCFG, config->relax_cfg);
665         max17042_override_por(map, MAX17042_MiscCFG, config->misc_cfg);
666         max17042_override_por(map, MAX17042_MaskSOC, config->masksoc);
667 
668         max17042_override_por(map, MAX17042_FullCAP, config->fullcap);
669         max17042_override_por(map, MAX17042_FullCAPNom, config->fullcapnom);
670         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
671                 max17042_override_por(map, MAX17042_SOC_empty,
672                                                 config->socempty);
673         max17042_override_por(map, MAX17042_LAvg_empty, config->lavg_empty);
674         max17042_override_por(map, MAX17042_dQacc, config->dqacc);
675         max17042_override_por(map, MAX17042_dPacc, config->dpacc);
676 
677         if (chip->chip_type == MAXIM_DEVICE_TYPE_MAX17042)
678                 max17042_override_por(map, MAX17042_V_empty, config->vempty);
679         else
680                 max17042_override_por(map, MAX17047_V_empty, config->vempty);
681         max17042_override_por(map, MAX17042_TempNom, config->temp_nom);
682         max17042_override_por(map, MAX17042_TempLim, config->temp_lim);
683         max17042_override_por(map, MAX17042_FCTC, config->fctc);
684         max17042_override_por(map, MAX17042_RCOMP0, config->rcomp0);
685         max17042_override_por(map, MAX17042_TempCo, config->tcompc0);
686         if (chip->chip_type) {
687                 max17042_override_por(map, MAX17042_EmptyTempCo,
688                                                 config->empty_tempco);
689                 max17042_override_por(map, MAX17042_K_empty0,
690                                                 config->kempty0);
691         }
692 }
693 
694 static int max17042_init_chip(struct max17042_chip *chip)
695 {
696         struct regmap *map = chip->regmap;
697         int ret;
698 
699         max17042_override_por_values(chip);
700         /* After Power up, the MAX17042 requires 500mS in order
701          * to perform signal debouncing and initial SOC reporting
702          */
703         msleep(500);
704 
705         /* Initialize configaration */
706         max17042_write_config_regs(chip);
707 
708         /* write cell characterization data */
709         ret = max17042_init_model(chip);
710         if (ret) {
711                 dev_err(&chip->client->dev, "%s init failed\n",
712                         __func__);
713                 return -EIO;
714         }
715 
716         ret = max17042_verify_model_lock(chip);
717         if (ret) {
718                 dev_err(&chip->client->dev, "%s lock verify failed\n",
719                         __func__);
720                 return -EIO;
721         }
722         /* write custom parameters */
723         max17042_write_custom_regs(chip);
724 
725         /* update capacity params */
726         max17042_update_capacity_regs(chip);
727 
728         /* delay must be atleast 350mS to allow VFSOC
729          * to be calculated from the new configuration
730          */
731         msleep(350);
732 
733         /* reset vfsoc0 reg */
734         max17042_reset_vfsoc0_reg(chip);
735 
736         /* load new capacity params */
737         max17042_load_new_capacity_params(chip);
738 
739         /* Init complete, Clear the POR bit */
740         regmap_update_bits(map, MAX17042_STATUS, STATUS_POR_BIT, 0x0);
741         return 0;
742 }
743 
744 static void max17042_set_soc_threshold(struct max17042_chip *chip, u16 off)
745 {
746         struct regmap *map = chip->regmap;
747         u32 soc, soc_tr;
748 
749         /* program interrupt thesholds such that we should
750          * get interrupt for every 'off' perc change in the soc
751          */
752         regmap_read(map, MAX17042_RepSOC, &soc);
753         soc >>= 8;
754         soc_tr = (soc + off) << 8;
755         soc_tr |= (soc - off);
756         regmap_write(map, MAX17042_SALRT_Th, soc_tr);
757 }
758 
759 static irqreturn_t max17042_thread_handler(int id, void *dev)
760 {
761         struct max17042_chip *chip = dev;
762         u32 val;
763 
764         regmap_read(chip->regmap, MAX17042_STATUS, &val);
765         if ((val & STATUS_INTR_SOCMIN_BIT) ||
766                 (val & STATUS_INTR_SOCMAX_BIT)) {
767                 dev_info(&chip->client->dev, "SOC threshold INTR\n");
768                 max17042_set_soc_threshold(chip, 1);
769         }
770 
771         power_supply_changed(chip->battery);
772         return IRQ_HANDLED;
773 }
774 
775 static void max17042_init_worker(struct work_struct *work)
776 {
777         struct max17042_chip *chip = container_of(work,
778                                 struct max17042_chip, work);
779         int ret;
780 
781         /* Initialize registers according to values from the platform data */
782         if (chip->pdata->enable_por_init && chip->pdata->config_data) {
783                 ret = max17042_init_chip(chip);
784                 if (ret)
785                         return;
786         }
787 
788         chip->init_complete = 1;
789 }
790 
791 #ifdef CONFIG_OF
792 static struct max17042_platform_data *
793 max17042_get_pdata(struct device *dev)
794 {
795         struct device_node *np = dev->of_node;
796         u32 prop;
797         struct max17042_platform_data *pdata;
798 
799         if (!np)
800                 return dev->platform_data;
801 
802         pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
803         if (!pdata)
804                 return NULL;
805 
806         /*
807          * Require current sense resistor value to be specified for
808          * current-sense functionality to be enabled at all.
809          */
810         if (of_property_read_u32(np, "maxim,rsns-microohm", &prop) == 0) {
811                 pdata->r_sns = prop;
812                 pdata->enable_current_sense = true;
813         }
814 
815         if (of_property_read_s32(np, "maxim,cold-temp", &pdata->temp_min))
816                 pdata->temp_min = INT_MIN;
817         if (of_property_read_s32(np, "maxim,over-heat-temp", &pdata->temp_max))
818                 pdata->temp_max = INT_MAX;
819         if (of_property_read_s32(np, "maxim,dead-volt", &pdata->vmin))
820                 pdata->vmin = INT_MIN;
821         if (of_property_read_s32(np, "maxim,over-volt", &pdata->vmax))
822                 pdata->vmax = INT_MAX;
823 
824         return pdata;
825 }
826 #else
827 static struct max17042_platform_data *
828 max17042_get_pdata(struct device *dev)
829 {
830         return dev->platform_data;
831 }
832 #endif
833 
834 static const struct regmap_config max17042_regmap_config = {
835         .reg_bits = 8,
836         .val_bits = 16,
837         .val_format_endian = REGMAP_ENDIAN_NATIVE,
838 };
839 
840 static const struct power_supply_desc max17042_psy_desc = {
841         .name           = "max170xx_battery",
842         .type           = POWER_SUPPLY_TYPE_BATTERY,
843         .get_property   = max17042_get_property,
844         .set_property   = max17042_set_property,
845         .property_is_writeable  = max17042_property_is_writeable,
846         .properties     = max17042_battery_props,
847         .num_properties = ARRAY_SIZE(max17042_battery_props),
848 };
849 
850 static const struct power_supply_desc max17042_no_current_sense_psy_desc = {
851         .name           = "max170xx_battery",
852         .type           = POWER_SUPPLY_TYPE_BATTERY,
853         .get_property   = max17042_get_property,
854         .set_property   = max17042_set_property,
855         .property_is_writeable  = max17042_property_is_writeable,
856         .properties     = max17042_battery_props,
857         .num_properties = ARRAY_SIZE(max17042_battery_props) - 2,
858 };
859 
860 static int max17042_probe(struct i2c_client *client,
861                         const struct i2c_device_id *id)
862 {
863         struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);
864         const struct power_supply_desc *max17042_desc = &max17042_psy_desc;
865         struct power_supply_config psy_cfg = {};
866         struct max17042_chip *chip;
867         int ret;
868         int i;
869         u32 val;
870 
871         if (!i2c_check_functionality(adapter, I2C_FUNC_SMBUS_WORD_DATA))
872                 return -EIO;
873 
874         chip = devm_kzalloc(&client->dev, sizeof(*chip), GFP_KERNEL);
875         if (!chip)
876                 return -ENOMEM;
877 
878         chip->client = client;
879         chip->regmap = devm_regmap_init_i2c(client, &max17042_regmap_config);
880         if (IS_ERR(chip->regmap)) {
881                 dev_err(&client->dev, "Failed to initialize regmap\n");
882                 return -EINVAL;
883         }
884 
885         chip->pdata = max17042_get_pdata(&client->dev);
886         if (!chip->pdata) {
887                 dev_err(&client->dev, "no platform data provided\n");
888                 return -EINVAL;
889         }
890 
891         i2c_set_clientdata(client, chip);
892         chip->chip_type = id->driver_data;
893         psy_cfg.drv_data = chip;
894 
895         /* When current is not measured,
896          * CURRENT_NOW and CURRENT_AVG properties should be invisible. */
897         if (!chip->pdata->enable_current_sense)
898                 max17042_desc = &max17042_no_current_sense_psy_desc;
899 
900         if (chip->pdata->r_sns == 0)
901                 chip->pdata->r_sns = MAX17042_DEFAULT_SNS_RESISTOR;
902 
903         if (chip->pdata->init_data)
904                 for (i = 0; i < chip->pdata->num_init_data; i++)
905                         regmap_write(chip->regmap,
906                                         chip->pdata->init_data[i].addr,
907                                         chip->pdata->init_data[i].data);
908 
909         if (!chip->pdata->enable_current_sense) {
910                 regmap_write(chip->regmap, MAX17042_CGAIN, 0x0000);
911                 regmap_write(chip->regmap, MAX17042_MiscCFG, 0x0003);
912                 regmap_write(chip->regmap, MAX17042_LearnCFG, 0x0007);
913         }
914 
915         chip->battery = devm_power_supply_register(&client->dev, max17042_desc,
916                                                    &psy_cfg);
917         if (IS_ERR(chip->battery)) {
918                 dev_err(&client->dev, "failed: power supply register\n");
919                 return PTR_ERR(chip->battery);
920         }
921 
922         if (client->irq) {
923                 ret = devm_request_threaded_irq(&client->dev, client->irq,
924                                                 NULL,
925                                                 max17042_thread_handler,
926                                                 IRQF_TRIGGER_FALLING |
927                                                 IRQF_ONESHOT,
928                                                 chip->battery->desc->name,
929                                                 chip);
930                 if (!ret) {
931                         regmap_update_bits(chip->regmap, MAX17042_CONFIG,
932                                         CONFIG_ALRT_BIT_ENBL,
933                                         CONFIG_ALRT_BIT_ENBL);
934                         max17042_set_soc_threshold(chip, 1);
935                 } else {
936                         client->irq = 0;
937                         dev_err(&client->dev, "%s(): cannot get IRQ\n",
938                                 __func__);
939                 }
940         }
941 
942         regmap_read(chip->regmap, MAX17042_STATUS, &val);
943         if (val & STATUS_POR_BIT) {
944                 INIT_WORK(&chip->work, max17042_init_worker);
945                 schedule_work(&chip->work);
946         } else {
947                 chip->init_complete = 1;
948         }
949 
950         return 0;
951 }
952 
953 #ifdef CONFIG_PM_SLEEP
954 static int max17042_suspend(struct device *dev)
955 {
956         struct max17042_chip *chip = dev_get_drvdata(dev);
957 
958         /*
959          * disable the irq and enable irq_wake
960          * capability to the interrupt line.
961          */
962         if (chip->client->irq) {
963                 disable_irq(chip->client->irq);
964                 enable_irq_wake(chip->client->irq);
965         }
966 
967         return 0;
968 }
969 
970 static int max17042_resume(struct device *dev)
971 {
972         struct max17042_chip *chip = dev_get_drvdata(dev);
973 
974         if (chip->client->irq) {
975                 disable_irq_wake(chip->client->irq);
976                 enable_irq(chip->client->irq);
977                 /* re-program the SOC thresholds to 1% change */
978                 max17042_set_soc_threshold(chip, 1);
979         }
980 
981         return 0;
982 }
983 #endif
984 
985 static SIMPLE_DEV_PM_OPS(max17042_pm_ops, max17042_suspend,
986                         max17042_resume);
987 
988 #ifdef CONFIG_OF
989 static const struct of_device_id max17042_dt_match[] = {
990         { .compatible = "maxim,max17042" },
991         { .compatible = "maxim,max17047" },
992         { .compatible = "maxim,max17050" },
993         { },
994 };
995 MODULE_DEVICE_TABLE(of, max17042_dt_match);
996 #endif
997 
998 static const struct i2c_device_id max17042_id[] = {
999         { "max17042", MAXIM_DEVICE_TYPE_MAX17042 },
1000         { "max17047", MAXIM_DEVICE_TYPE_MAX17047 },
1001         { "max17050", MAXIM_DEVICE_TYPE_MAX17050 },
1002         { }
1003 };
1004 MODULE_DEVICE_TABLE(i2c, max17042_id);
1005 
1006 static struct i2c_driver max17042_i2c_driver = {
1007         .driver = {
1008                 .name   = "max17042",
1009                 .of_match_table = of_match_ptr(max17042_dt_match),
1010                 .pm     = &max17042_pm_ops,
1011         },
1012         .probe          = max17042_probe,
1013         .id_table       = max17042_id,
1014 };
1015 module_i2c_driver(max17042_i2c_driver);
1016 
1017 MODULE_AUTHOR("MyungJoo Ham <myungjoo.ham@samsung.com>");
1018 MODULE_DESCRIPTION("MAX17042 Fuel Gauge");
1019 MODULE_LICENSE("GPL");
1020 

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