Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 //
0003 // Copyright (C) 2018 BayLibre SAS
0004 // Author: Bartosz Golaszewski <bgolaszewski@baylibre.com>
0005 //
0006 // Battery charger driver for MAXIM 77650/77651 charger/power-supply.
0007 
0008 #include <linux/i2c.h>
0009 #include <linux/interrupt.h>
0010 #include <linux/mfd/max77650.h>
0011 #include <linux/module.h>
0012 #include <linux/platform_device.h>
0013 #include <linux/power_supply.h>
0014 #include <linux/regmap.h>
0015 
0016 #define MAX77650_CHARGER_ENABLED        BIT(0)
0017 #define MAX77650_CHARGER_DISABLED       0x00
0018 #define MAX77650_CHARGER_CHG_EN_MASK        BIT(0)
0019 
0020 #define MAX77650_CHG_DETAILS_MASK       GENMASK(7, 4)
0021 #define MAX77650_CHG_DETAILS_BITS(_reg) \
0022         (((_reg) & MAX77650_CHG_DETAILS_MASK) >> 4)
0023 
0024 /* Charger is OFF. */
0025 #define MAX77650_CHG_OFF            0x00
0026 /* Charger is in prequalification mode. */
0027 #define MAX77650_CHG_PREQ           0x01
0028 /* Charger is in fast-charge constant current mode. */
0029 #define MAX77650_CHG_ON_CURR            0x02
0030 /* Charger is in JEITA modified fast-charge constant-current mode. */
0031 #define MAX77650_CHG_ON_CURR_JEITA      0x03
0032 /* Charger is in fast-charge constant-voltage mode. */
0033 #define MAX77650_CHG_ON_VOLT            0x04
0034 /* Charger is in JEITA modified fast-charge constant-voltage mode. */
0035 #define MAX77650_CHG_ON_VOLT_JEITA      0x05
0036 /* Charger is in top-off mode. */
0037 #define MAX77650_CHG_ON_TOPOFF          0x06
0038 /* Charger is in JEITA modified top-off mode. */
0039 #define MAX77650_CHG_ON_TOPOFF_JEITA        0x07
0040 /* Charger is done. */
0041 #define MAX77650_CHG_DONE           0x08
0042 /* Charger is JEITA modified done. */
0043 #define MAX77650_CHG_DONE_JEITA         0x09
0044 /* Charger is suspended due to a prequalification timer fault. */
0045 #define MAX77650_CHG_SUSP_PREQ_TIM_FAULT    0x0a
0046 /* Charger is suspended due to a fast-charge timer fault. */
0047 #define MAX77650_CHG_SUSP_FAST_CHG_TIM_FAULT    0x0b
0048 /* Charger is suspended due to a battery temperature fault. */
0049 #define MAX77650_CHG_SUSP_BATT_TEMP_FAULT   0x0c
0050 
0051 #define MAX77650_CHGIN_DETAILS_MASK     GENMASK(3, 2)
0052 #define MAX77650_CHGIN_DETAILS_BITS(_reg) \
0053         (((_reg) & MAX77650_CHGIN_DETAILS_MASK) >> 2)
0054 
0055 #define MAX77650_CHGIN_UNDERVOLTAGE_LOCKOUT 0x00
0056 #define MAX77650_CHGIN_OVERVOLTAGE_LOCKOUT  0x01
0057 #define MAX77650_CHGIN_OKAY         0x11
0058 
0059 #define MAX77650_CHARGER_CHG_MASK   BIT(1)
0060 #define MAX77650_CHARGER_CHG_CHARGING(_reg) \
0061         (((_reg) & MAX77650_CHARGER_CHG_MASK) > 1)
0062 
0063 #define MAX77650_CHARGER_VCHGIN_MIN_MASK    0xc0
0064 #define MAX77650_CHARGER_VCHGIN_MIN_SHIFT(_val) ((_val) << 5)
0065 
0066 #define MAX77650_CHARGER_ICHGIN_LIM_MASK    0x1c
0067 #define MAX77650_CHARGER_ICHGIN_LIM_SHIFT(_val) ((_val) << 2)
0068 
0069 struct max77650_charger_data {
0070     struct regmap *map;
0071     struct device *dev;
0072 };
0073 
0074 static enum power_supply_property max77650_charger_properties[] = {
0075     POWER_SUPPLY_PROP_STATUS,
0076     POWER_SUPPLY_PROP_ONLINE,
0077     POWER_SUPPLY_PROP_CHARGE_TYPE
0078 };
0079 
0080 static const unsigned int max77650_charger_vchgin_min_table[] = {
0081     4000000, 4100000, 4200000, 4300000, 4400000, 4500000, 4600000, 4700000
0082 };
0083 
0084 static const unsigned int max77650_charger_ichgin_lim_table[] = {
0085     95000, 190000, 285000, 380000, 475000
0086 };
0087 
0088 static int max77650_charger_set_vchgin_min(struct max77650_charger_data *chg,
0089                        unsigned int val)
0090 {
0091     int i, rv;
0092 
0093     for (i = 0; i < ARRAY_SIZE(max77650_charger_vchgin_min_table); i++) {
0094         if (val == max77650_charger_vchgin_min_table[i]) {
0095             rv = regmap_update_bits(chg->map,
0096                     MAX77650_REG_CNFG_CHG_B,
0097                     MAX77650_CHARGER_VCHGIN_MIN_MASK,
0098                     MAX77650_CHARGER_VCHGIN_MIN_SHIFT(i));
0099             if (rv)
0100                 return rv;
0101 
0102             return 0;
0103         }
0104     }
0105 
0106     return -EINVAL;
0107 }
0108 
0109 static int max77650_charger_set_ichgin_lim(struct max77650_charger_data *chg,
0110                        unsigned int val)
0111 {
0112     int i, rv;
0113 
0114     for (i = 0; i < ARRAY_SIZE(max77650_charger_ichgin_lim_table); i++) {
0115         if (val == max77650_charger_ichgin_lim_table[i]) {
0116             rv = regmap_update_bits(chg->map,
0117                     MAX77650_REG_CNFG_CHG_B,
0118                     MAX77650_CHARGER_ICHGIN_LIM_MASK,
0119                     MAX77650_CHARGER_ICHGIN_LIM_SHIFT(i));
0120             if (rv)
0121                 return rv;
0122 
0123             return 0;
0124         }
0125     }
0126 
0127     return -EINVAL;
0128 }
0129 
0130 static int max77650_charger_enable(struct max77650_charger_data *chg)
0131 {
0132     int rv;
0133 
0134     rv = regmap_update_bits(chg->map,
0135                 MAX77650_REG_CNFG_CHG_B,
0136                 MAX77650_CHARGER_CHG_EN_MASK,
0137                 MAX77650_CHARGER_ENABLED);
0138     if (rv)
0139         dev_err(chg->dev, "unable to enable the charger: %d\n", rv);
0140 
0141     return rv;
0142 }
0143 
0144 static int max77650_charger_disable(struct max77650_charger_data *chg)
0145 {
0146     int rv;
0147 
0148     rv = regmap_update_bits(chg->map,
0149                 MAX77650_REG_CNFG_CHG_B,
0150                 MAX77650_CHARGER_CHG_EN_MASK,
0151                 MAX77650_CHARGER_DISABLED);
0152     if (rv)
0153         dev_err(chg->dev, "unable to disable the charger: %d\n", rv);
0154 
0155     return rv;
0156 }
0157 
0158 static irqreturn_t max77650_charger_check_status(int irq, void *data)
0159 {
0160     struct max77650_charger_data *chg = data;
0161     int rv, reg;
0162 
0163     rv = regmap_read(chg->map, MAX77650_REG_STAT_CHG_B, &reg);
0164     if (rv) {
0165         dev_err(chg->dev,
0166             "unable to read the charger status: %d\n", rv);
0167         return IRQ_HANDLED;
0168     }
0169 
0170     switch (MAX77650_CHGIN_DETAILS_BITS(reg)) {
0171     case MAX77650_CHGIN_UNDERVOLTAGE_LOCKOUT:
0172         dev_err(chg->dev, "undervoltage lockout detected, disabling charger\n");
0173         max77650_charger_disable(chg);
0174         break;
0175     case MAX77650_CHGIN_OVERVOLTAGE_LOCKOUT:
0176         dev_err(chg->dev, "overvoltage lockout detected, disabling charger\n");
0177         max77650_charger_disable(chg);
0178         break;
0179     case MAX77650_CHGIN_OKAY:
0180         max77650_charger_enable(chg);
0181         break;
0182     default:
0183         /* May be 0x10 - debouncing */
0184         break;
0185     }
0186 
0187     return IRQ_HANDLED;
0188 }
0189 
0190 static int max77650_charger_get_property(struct power_supply *psy,
0191                      enum power_supply_property psp,
0192                      union power_supply_propval *val)
0193 {
0194     struct max77650_charger_data *chg = power_supply_get_drvdata(psy);
0195     int rv, reg;
0196 
0197     switch (psp) {
0198     case POWER_SUPPLY_PROP_STATUS:
0199         rv = regmap_read(chg->map, MAX77650_REG_STAT_CHG_B, &reg);
0200         if (rv)
0201             return rv;
0202 
0203         if (MAX77650_CHARGER_CHG_CHARGING(reg)) {
0204             val->intval = POWER_SUPPLY_STATUS_CHARGING;
0205             break;
0206         }
0207 
0208         switch (MAX77650_CHG_DETAILS_BITS(reg)) {
0209         case MAX77650_CHG_OFF:
0210         case MAX77650_CHG_SUSP_PREQ_TIM_FAULT:
0211         case MAX77650_CHG_SUSP_FAST_CHG_TIM_FAULT:
0212         case MAX77650_CHG_SUSP_BATT_TEMP_FAULT:
0213             val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
0214             break;
0215         case MAX77650_CHG_PREQ:
0216         case MAX77650_CHG_ON_CURR:
0217         case MAX77650_CHG_ON_CURR_JEITA:
0218         case MAX77650_CHG_ON_VOLT:
0219         case MAX77650_CHG_ON_VOLT_JEITA:
0220         case MAX77650_CHG_ON_TOPOFF:
0221         case MAX77650_CHG_ON_TOPOFF_JEITA:
0222             val->intval = POWER_SUPPLY_STATUS_CHARGING;
0223             break;
0224         case MAX77650_CHG_DONE:
0225             val->intval = POWER_SUPPLY_STATUS_FULL;
0226             break;
0227         default:
0228             val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
0229         }
0230         break;
0231     case POWER_SUPPLY_PROP_ONLINE:
0232         rv = regmap_read(chg->map, MAX77650_REG_STAT_CHG_B, &reg);
0233         if (rv)
0234             return rv;
0235 
0236         val->intval = MAX77650_CHARGER_CHG_CHARGING(reg);
0237         break;
0238     case POWER_SUPPLY_PROP_CHARGE_TYPE:
0239         rv = regmap_read(chg->map, MAX77650_REG_STAT_CHG_B, &reg);
0240         if (rv)
0241             return rv;
0242 
0243         if (!MAX77650_CHARGER_CHG_CHARGING(reg)) {
0244             val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
0245             break;
0246         }
0247 
0248         switch (MAX77650_CHG_DETAILS_BITS(reg)) {
0249         case MAX77650_CHG_PREQ:
0250         case MAX77650_CHG_ON_CURR:
0251         case MAX77650_CHG_ON_CURR_JEITA:
0252         case MAX77650_CHG_ON_VOLT:
0253         case MAX77650_CHG_ON_VOLT_JEITA:
0254             val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
0255             break;
0256         case MAX77650_CHG_ON_TOPOFF:
0257         case MAX77650_CHG_ON_TOPOFF_JEITA:
0258             val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
0259             break;
0260         default:
0261             val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN;
0262         }
0263         break;
0264     default:
0265         return -EINVAL;
0266     }
0267 
0268     return 0;
0269 }
0270 
0271 static const struct power_supply_desc max77650_battery_desc = {
0272     .name       = "max77650",
0273     .type       = POWER_SUPPLY_TYPE_USB,
0274     .get_property   = max77650_charger_get_property,
0275     .properties = max77650_charger_properties,
0276     .num_properties = ARRAY_SIZE(max77650_charger_properties),
0277 };
0278 
0279 static int max77650_charger_probe(struct platform_device *pdev)
0280 {
0281     struct power_supply_config pscfg = {};
0282     struct max77650_charger_data *chg;
0283     struct power_supply *battery;
0284     struct device *dev, *parent;
0285     int rv, chg_irq, chgin_irq;
0286     unsigned int prop;
0287 
0288     dev = &pdev->dev;
0289     parent = dev->parent;
0290 
0291     chg = devm_kzalloc(dev, sizeof(*chg), GFP_KERNEL);
0292     if (!chg)
0293         return -ENOMEM;
0294 
0295     platform_set_drvdata(pdev, chg);
0296 
0297     chg->map = dev_get_regmap(parent, NULL);
0298     if (!chg->map)
0299         return -ENODEV;
0300 
0301     chg->dev = dev;
0302 
0303     pscfg.of_node = dev->of_node;
0304     pscfg.drv_data = chg;
0305 
0306     chg_irq = platform_get_irq_byname(pdev, "CHG");
0307     if (chg_irq < 0)
0308         return chg_irq;
0309 
0310     chgin_irq = platform_get_irq_byname(pdev, "CHGIN");
0311     if (chgin_irq < 0)
0312         return chgin_irq;
0313 
0314     rv = devm_request_any_context_irq(dev, chg_irq,
0315                       max77650_charger_check_status,
0316                       IRQF_ONESHOT, "chg", chg);
0317     if (rv < 0)
0318         return rv;
0319 
0320     rv = devm_request_any_context_irq(dev, chgin_irq,
0321                       max77650_charger_check_status,
0322                       IRQF_ONESHOT, "chgin", chg);
0323     if (rv < 0)
0324         return rv;
0325 
0326     battery = devm_power_supply_register(dev,
0327                          &max77650_battery_desc, &pscfg);
0328     if (IS_ERR(battery))
0329         return PTR_ERR(battery);
0330 
0331     rv = of_property_read_u32(dev->of_node,
0332                   "input-voltage-min-microvolt", &prop);
0333     if (rv == 0) {
0334         rv = max77650_charger_set_vchgin_min(chg, prop);
0335         if (rv)
0336             return rv;
0337     }
0338 
0339     rv = of_property_read_u32(dev->of_node,
0340                   "input-current-limit-microamp", &prop);
0341     if (rv == 0) {
0342         rv = max77650_charger_set_ichgin_lim(chg, prop);
0343         if (rv)
0344             return rv;
0345     }
0346 
0347     return max77650_charger_enable(chg);
0348 }
0349 
0350 static int max77650_charger_remove(struct platform_device *pdev)
0351 {
0352     struct max77650_charger_data *chg = platform_get_drvdata(pdev);
0353 
0354     return max77650_charger_disable(chg);
0355 }
0356 
0357 static const struct of_device_id max77650_charger_of_match[] = {
0358     { .compatible = "maxim,max77650-charger" },
0359     { }
0360 };
0361 MODULE_DEVICE_TABLE(of, max77650_charger_of_match);
0362 
0363 static struct platform_driver max77650_charger_driver = {
0364     .driver = {
0365         .name = "max77650-charger",
0366         .of_match_table = max77650_charger_of_match,
0367     },
0368     .probe = max77650_charger_probe,
0369     .remove = max77650_charger_remove,
0370 };
0371 module_platform_driver(max77650_charger_driver);
0372 
0373 MODULE_DESCRIPTION("MAXIM 77650/77651 charger driver");
0374 MODULE_AUTHOR("Bartosz Golaszewski <bgolaszewski@baylibre.com>");
0375 MODULE_LICENSE("GPL v2");
0376 MODULE_ALIAS("platform:max77650-charger");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!