Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 // BQ2515X Battery Charger Driver
0003 // Copyright (C) 2020 Texas Instruments Incorporated - https://www.ti.com/
0004 
0005 #include <linux/err.h>
0006 #include <linux/i2c.h>
0007 #include <linux/init.h>
0008 #include <linux/kernel.h>
0009 #include <linux/module.h>
0010 #include <linux/gpio/consumer.h>
0011 #include <linux/power_supply.h>
0012 #include <linux/regmap.h>
0013 #include <linux/types.h>
0014 
0015 #define BQ2515X_MANUFACTURER "Texas Instruments"
0016 
0017 #define BQ2515X_STAT0       0x00
0018 #define BQ2515X_STAT1       0x01
0019 #define BQ2515X_STAT2       0x02
0020 #define BQ2515X_FLAG0       0x03
0021 #define BQ2515X_FLAG1       0x04
0022 #define BQ2515X_FLAG2       0x05
0023 #define BQ2515X_FLAG3       0x06
0024 #define BQ2515X_MASK0       0x07
0025 #define BQ2515X_MASK1       0x08
0026 #define BQ2515X_MASK2       0x09
0027 #define BQ2515X_MASK3       0x0a
0028 #define BQ2515X_VBAT_CTRL   0x12
0029 #define BQ2515X_ICHG_CTRL   0x13
0030 #define BQ2515X_PCHRGCTRL   0x14
0031 #define BQ2515X_TERMCTRL    0x15
0032 #define BQ2515X_BUVLO       0x16
0033 #define BQ2515X_CHARGERCTRL0    0x17
0034 #define BQ2515X_CHARGERCTRL1    0x18
0035 #define BQ2515X_ILIMCTRL    0x19
0036 #define BQ2515X_LDOCTRL     0x1d
0037 #define BQ2515X_MRCTRL      0x30
0038 #define BQ2515X_ICCTRL0     0x35
0039 #define BQ2515X_ICCTRL1     0x36
0040 #define BQ2515X_ICCTRL2     0x37
0041 #define BQ2515X_ADCCTRL0    0x40
0042 #define BQ2515X_ADCCTRL1    0x41
0043 #define BQ2515X_ADC_VBAT_M  0x42
0044 #define BQ2515X_ADC_VBAT_L  0x43
0045 #define BQ2515X_ADC_TS_M    0x44
0046 #define BQ2515X_ADC_TS_L    0x45
0047 #define BQ2515X_ADC_ICHG_M  0x46
0048 #define BQ2515X_ADC_ICHG_L  0x47
0049 #define BQ2515X_ADC_ADCIN_M 0x48
0050 #define BQ2515X_ADC_ADCIN_L 0x49
0051 #define BQ2515X_ADC_VIN_M   0x4a
0052 #define BQ2515X_ADC_VIN_L   0x4b
0053 #define BQ2515X_ADC_PMID_M  0x4c
0054 #define BQ2515X_ADC_PMID_L  0x4d
0055 #define BQ2515X_ADC_IIN_M   0x4e
0056 #define BQ2515X_ADC_IIN_L   0x4f
0057 #define BQ2515X_ADC_COMP1_M 0x52
0058 #define BQ2515X_ADC_COMP1_L 0X53
0059 #define BQ2515X_ADC_COMP2_M 0X54
0060 #define BQ2515X_ADC_COMP2_L 0x55
0061 #define BQ2515X_ADC_COMP3_M 0x56
0062 #define BQ2515X_ADC_COMP3_L 0x57
0063 #define BQ2515X_ADC_READ_EN 0x58
0064 #define BQ2515X_TS_FASTCHGCTRL  0x61
0065 #define BQ2515X_TS_COLD     0x62
0066 #define BQ2515X_TS_COOL     0x63
0067 #define BQ2515X_TS_WARM     0x64
0068 #define BQ2515X_TS_HOT      0x65
0069 #define BQ2515X_DEVICE_ID   0x6f
0070 
0071 #define BQ2515X_DEFAULT_ICHG_UA     10000
0072 #define BQ25150_DEFAULT_ILIM_UA     100000
0073 #define BQ25155_DEFAULT_ILIM_UA     500000
0074 #define BQ2515X_DEFAULT_VBAT_REG_UV 4200000
0075 #define BQ2515X_DEFAULT_IPRECHARGE_UA   2500
0076 
0077 #define BQ2515X_DIVISOR             65536
0078 #define BQ2515X_VBAT_BASE_VOLT          3600000
0079 #define BQ2515X_VBAT_REG_MAX            4600000
0080 #define BQ2515X_VBAT_REG_MIN            3600000
0081 #define BQ2515X_VBAT_STEP_UV            10000
0082 #define BQ2515X_UV_FACTOR           1000000
0083 #define BQ2515X_VBAT_MULTIPLIER         6
0084 #define BQ2515X_ICHG_DIVISOR            52429
0085 #define BQ2515X_ICHG_CURR_STEP_THRESH_UA    318750
0086 #define BQ2515X_ICHG_MIN_UA         0
0087 #define BQ2515X_ICHG_MAX_UA         500000
0088 #define BQ2515X_ICHG_RNG_1B0_UA         1250
0089 #define BQ2515X_ICHG_RNG_1B1_UA         2500
0090 #define BQ2515X_VLOWV_SEL_1B0_UV        3000000
0091 #define BQ2515X_VLOWV_SEL_1B1_UV        2800000
0092 #define BQ2515X_PRECHRG_ICHRG_RNGE_1875_UA  18750
0093 #define BQ2515X_PRECHRG_ICHRG_RNGE_3750_UA  37500
0094 #define BQ2515X_TWAKE2_MIN_US           1700000
0095 #define BQ2515X_TWAKE2_MAX_US           2300000
0096 
0097 #define BQ2515X_ILIM_150MA  0x2
0098 #define BQ2515X_ILIM_MASK   0x7
0099 #define BQ2515X_ILIM_MIN    50000
0100 #define BQ2515X_ILIM_MAX    600000
0101 #define BQ2515X_HEALTH_MASK 0xf
0102 #define BQ2515X_ICHGRNG_MASK    0x80
0103 #define BQ2515X_STAT0_MASK  0x0f
0104 #define BQ2515X_STAT1_MASK  0x1f
0105 #define BQ2515X_PRECHARGE_MASK  0x1f
0106 
0107 #define BQ2515X_TS_HOT_STAT     BIT(0)
0108 #define BQ2515X_TS_WARM_STAT        BIT(1)
0109 #define BQ2515X_TS_COOL_STAT        BIT(2)
0110 #define BQ2515X_TS_COLD_STAT        BIT(3)
0111 #define BQ2515X_SAFETY_TIMER_EXP    BIT(5)
0112 
0113 #define BQ2515X_EN_VBAT_READ        BIT(3)
0114 #define BQ2515X_EN_ICHG_READ        BIT(5)
0115 
0116 #define BQ2515X_VIN_GOOD        BIT(0)
0117 #define BQ2515X_CHRG_DONE       BIT(5)
0118 #define BQ2515X_CV_CHRG_MODE        BIT(6)
0119 
0120 #define BQ2515X_VIN_OVP_FAULT_STAT  BIT(7)
0121 
0122 #define BQ2515X_WATCHDOG_DISABLE    BIT(4)
0123 
0124 #define BQ2515X_ICHARGE_RANGE       BIT(7)
0125 
0126 #define BQ2515X_VLOWV_SEL       BIT(5)
0127 
0128 #define BQ2515X_CHARGER_DISABLE     BIT(0)
0129 
0130 #define BQ2515X_HWRESET_14S_WD      BIT(1)
0131 
0132 static const int bq2515x_ilim_lvl_values[] = {
0133     50000, 100000, 150000, 200000, 300000, 400000, 500000, 600000
0134 };
0135 
0136 /**
0137  * struct bq2515x_init_data -
0138  * @ilim: input current limit
0139  * @ichg: fast charge current
0140  * @vbatreg: battery regulation voltage
0141  * @iprechg: precharge current
0142  */
0143 struct bq2515x_init_data {
0144     int ilim;
0145     int ichg;
0146     int vbatreg;
0147     int iprechg;
0148 };
0149 
0150 enum bq2515x_id {
0151     BQ25150,
0152     BQ25155,
0153 };
0154 
0155 /**
0156  * struct bq2515x_device -
0157  * @mains: mains properties
0158  * @battery: battery properties
0159  * @regmap: register map structure
0160  * @dev: device structure
0161  *
0162  * @reset_gpio: manual reset (MR) pin
0163  * @powerdown_gpio: low power mode pin
0164  * @ac_detect_gpio: power good (PG) pin
0165  * @ce_gpio: charge enable (CE) pin
0166  *
0167  * @model_name: string value describing device model
0168  * @device_id: value of device_id
0169  * @mains_online: boolean value indicating power supply online
0170  *
0171  * @init_data: charger initialization data structure
0172  */
0173 struct bq2515x_device {
0174     struct power_supply *mains;
0175     struct power_supply *battery;
0176     struct regmap *regmap;
0177     struct device *dev;
0178 
0179     struct gpio_desc *reset_gpio;
0180     struct gpio_desc *powerdown_gpio;
0181     struct gpio_desc *ac_detect_gpio;
0182     struct gpio_desc *ce_gpio;
0183 
0184     char model_name[I2C_NAME_SIZE];
0185     int device_id;
0186     bool mains_online;
0187 
0188     struct bq2515x_init_data init_data;
0189 };
0190 
0191 static const struct reg_default bq25150_reg_defaults[] = {
0192     {BQ2515X_FLAG0, 0x0},
0193     {BQ2515X_FLAG1, 0x0},
0194     {BQ2515X_FLAG2, 0x0},
0195     {BQ2515X_FLAG3, 0x0},
0196     {BQ2515X_MASK0, 0x0},
0197     {BQ2515X_MASK1, 0x0},
0198     {BQ2515X_MASK2, 0x71},
0199     {BQ2515X_MASK3, 0x0},
0200     {BQ2515X_VBAT_CTRL, 0x3C},
0201     {BQ2515X_ICHG_CTRL, 0x8},
0202     {BQ2515X_PCHRGCTRL, 0x2},
0203     {BQ2515X_TERMCTRL, 0x14},
0204     {BQ2515X_BUVLO, 0x0},
0205     {BQ2515X_CHARGERCTRL0, 0x82},
0206     {BQ2515X_CHARGERCTRL1, 0x42},
0207     {BQ2515X_ILIMCTRL, 0x1},
0208     {BQ2515X_LDOCTRL, 0xB0},
0209     {BQ2515X_MRCTRL, 0x2A},
0210     {BQ2515X_ICCTRL0, 0x10},
0211     {BQ2515X_ICCTRL1, 0x0},
0212     {BQ2515X_ICCTRL2, 0x0},
0213     {BQ2515X_ADCCTRL0, 0x2},
0214     {BQ2515X_ADCCTRL1, 0x40},
0215     {BQ2515X_ADC_COMP1_M, 0x23},
0216     {BQ2515X_ADC_COMP1_L, 0x20},
0217     {BQ2515X_ADC_COMP2_M, 0x38},
0218     {BQ2515X_ADC_COMP2_L, 0x90},
0219     {BQ2515X_ADC_COMP3_M, 0x0},
0220     {BQ2515X_ADC_COMP3_L, 0x0},
0221     {BQ2515X_ADC_READ_EN, 0x0},
0222     {BQ2515X_TS_FASTCHGCTRL, 0x34},
0223     {BQ2515X_TS_COLD, 0x7C},
0224     {BQ2515X_TS_COOL, 0x6D},
0225     {BQ2515X_TS_WARM, 0x38},
0226     {BQ2515X_TS_HOT, 0x27},
0227     {BQ2515X_DEVICE_ID, 0x20},
0228 };
0229 
0230 static const struct reg_default bq25155_reg_defaults[] = {
0231     {BQ2515X_FLAG0, 0x0},
0232     {BQ2515X_FLAG1, 0x0},
0233     {BQ2515X_FLAG2, 0x0},
0234     {BQ2515X_FLAG3, 0x0},
0235     {BQ2515X_MASK0, 0x0},
0236     {BQ2515X_MASK1, 0x0},
0237     {BQ2515X_MASK2, 0x71},
0238     {BQ2515X_MASK3, 0x0},
0239     {BQ2515X_VBAT_CTRL, 0x3C},
0240     {BQ2515X_ICHG_CTRL, 0x8},
0241     {BQ2515X_PCHRGCTRL, 0x2},
0242     {BQ2515X_TERMCTRL, 0x14},
0243     {BQ2515X_BUVLO, 0x0},
0244     {BQ2515X_CHARGERCTRL0, 0x82},
0245     {BQ2515X_CHARGERCTRL1, 0xC2},
0246     {BQ2515X_ILIMCTRL, 0x6},
0247     {BQ2515X_LDOCTRL, 0xB0},
0248     {BQ2515X_MRCTRL, 0x2A},
0249     {BQ2515X_ICCTRL0, 0x10},
0250     {BQ2515X_ICCTRL1, 0x0},
0251     {BQ2515X_ICCTRL2, 0x40},
0252     {BQ2515X_ADCCTRL0, 0x2},
0253     {BQ2515X_ADCCTRL1, 0x40},
0254     {BQ2515X_ADC_COMP1_M, 0x23},
0255     {BQ2515X_ADC_COMP1_L, 0x20},
0256     {BQ2515X_ADC_COMP2_M, 0x38},
0257     {BQ2515X_ADC_COMP2_L, 0x90},
0258     {BQ2515X_ADC_COMP3_M, 0x0},
0259     {BQ2515X_ADC_COMP3_L, 0x0},
0260     {BQ2515X_ADC_READ_EN, 0x0},
0261     {BQ2515X_TS_FASTCHGCTRL, 0x34},
0262     {BQ2515X_TS_COLD, 0x7C},
0263     {BQ2515X_TS_COOL, 0x6D},
0264     {BQ2515X_TS_WARM, 0x38},
0265     {BQ2515X_TS_HOT, 0x27},
0266     {BQ2515X_DEVICE_ID, 0x35},
0267 };
0268 
0269 static int bq2515x_wake_up(struct bq2515x_device *bq2515x)
0270 {
0271     int ret;
0272     int val;
0273 
0274     /* Read the STAT register if we can read it then the device is out
0275      * of ship mode.  If the register cannot be read then attempt to wake
0276      * it up and enable the ADC.
0277      */
0278     ret = regmap_read(bq2515x->regmap, BQ2515X_STAT0, &val);
0279     if (ret)
0280         return ret;
0281 
0282     /* Need to toggle LP and bring device out of ship mode. The device
0283      * will exit the ship mode when the MR pin is held low for at least
0284      * t_WAKE2 as shown in section 8.3.7.1 of the datasheet.
0285      */
0286     gpiod_set_value_cansleep(bq2515x->powerdown_gpio, 0);
0287 
0288     gpiod_set_value_cansleep(bq2515x->reset_gpio, 0);
0289     usleep_range(BQ2515X_TWAKE2_MIN_US, BQ2515X_TWAKE2_MAX_US);
0290     gpiod_set_value_cansleep(bq2515x->reset_gpio, 1);
0291 
0292     return regmap_write(bq2515x->regmap, BQ2515X_ADC_READ_EN,
0293                 (BQ2515X_EN_VBAT_READ | BQ2515X_EN_ICHG_READ));
0294 }
0295 
0296 static int bq2515x_update_ps_status(struct bq2515x_device *bq2515x)
0297 {
0298     bool dc = false;
0299     unsigned int val;
0300     int ret;
0301 
0302     if (bq2515x->ac_detect_gpio)
0303         val = gpiod_get_value_cansleep(bq2515x->ac_detect_gpio);
0304     else {
0305         ret = regmap_read(bq2515x->regmap, BQ2515X_STAT0, &val);
0306         if (ret)
0307             return ret;
0308     }
0309 
0310     dc = val & BQ2515X_VIN_GOOD;
0311 
0312     ret = bq2515x->mains_online != dc;
0313 
0314     bq2515x->mains_online = dc;
0315 
0316     return ret;
0317 }
0318 
0319 static int bq2515x_disable_watchdog_timers(struct bq2515x_device *bq2515x)
0320 {
0321     int ret;
0322 
0323     ret = regmap_update_bits(bq2515x->regmap, BQ2515X_CHARGERCTRL0,
0324             BQ2515X_WATCHDOG_DISABLE, BQ2515X_WATCHDOG_DISABLE);
0325     if (ret)
0326         return ret;
0327 
0328     return regmap_update_bits(bq2515x->regmap, BQ2515X_ICCTRL2,
0329                         BQ2515X_HWRESET_14S_WD, 0);
0330 }
0331 
0332 static int bq2515x_get_battery_voltage_now(struct bq2515x_device *bq2515x)
0333 {
0334     int ret;
0335     int vbat_msb;
0336     int vbat_lsb;
0337     uint32_t vbat_measurement;
0338 
0339     if (!bq2515x->mains_online)
0340         bq2515x_wake_up(bq2515x);
0341 
0342     ret = regmap_read(bq2515x->regmap, BQ2515X_ADC_VBAT_M, &vbat_msb);
0343     if (ret)
0344         return ret;
0345 
0346     ret = regmap_read(bq2515x->regmap, BQ2515X_ADC_VBAT_L, &vbat_lsb);
0347     if (ret)
0348         return ret;
0349 
0350     vbat_measurement = (vbat_msb << 8) | vbat_lsb;
0351 
0352     return vbat_measurement * (BQ2515X_UV_FACTOR / BQ2515X_DIVISOR) *
0353                         BQ2515X_VBAT_MULTIPLIER;
0354 }
0355 
0356 static int bq2515x_get_battery_current_now(struct bq2515x_device *bq2515x)
0357 {
0358     int ret;
0359     int ichg_msb;
0360     int ichg_lsb;
0361     uint32_t ichg_measurement;
0362     u16 ichg_multiplier = BQ2515X_ICHG_RNG_1B0_UA;
0363     unsigned int ichg_reg_code, reg_code;
0364     unsigned int icharge_range = 0, pchrgctrl;
0365     unsigned int buvlo, vlowv_sel, vlowv = BQ2515X_VLOWV_SEL_1B0_UV;
0366 
0367     if (!bq2515x->mains_online)
0368         return -ENODATA;
0369 
0370     ret = regmap_read(bq2515x->regmap, BQ2515X_ADC_ICHG_M, &ichg_msb);
0371     if (ret)
0372         return ret;
0373 
0374     ret = regmap_read(bq2515x->regmap, BQ2515X_ADC_ICHG_L, &ichg_lsb);
0375     if (ret)
0376         return ret;
0377 
0378     ichg_measurement = (ichg_msb << 8) | ichg_lsb;
0379 
0380     ret = regmap_read(bq2515x->regmap, BQ2515X_BUVLO, &buvlo);
0381     if (ret)
0382         return ret;
0383 
0384     vlowv_sel = buvlo & BQ2515X_VLOWV_SEL;
0385 
0386     if (vlowv_sel)
0387         vlowv = BQ2515X_VLOWV_SEL_1B1_UV;
0388 
0389     if (bq2515x_get_battery_voltage_now(bq2515x) < vlowv) {
0390         ret = regmap_read(bq2515x->regmap, BQ2515X_PCHRGCTRL,
0391                                 &pchrgctrl);
0392         if (ret)
0393             return ret;
0394 
0395         reg_code = pchrgctrl & BQ2515X_PRECHARGE_MASK;
0396     } else {
0397         ret = regmap_read(bq2515x->regmap, BQ2515X_ICHG_CTRL,
0398                             &ichg_reg_code);
0399         if (ret)
0400             return ret;
0401 
0402         reg_code = ichg_reg_code;
0403     }
0404 
0405     ret = regmap_read(bq2515x->regmap, BQ2515X_PCHRGCTRL, &pchrgctrl);
0406     if (ret)
0407         return ret;
0408 
0409     icharge_range = pchrgctrl & BQ2515X_ICHARGE_RANGE;
0410 
0411     if (icharge_range)
0412         ichg_multiplier = BQ2515X_ICHG_RNG_1B1_UA;
0413 
0414     return reg_code * (ichg_multiplier * ichg_measurement /
0415                             BQ2515X_ICHG_DIVISOR);
0416 }
0417 
0418 static bool bq2515x_get_charge_disable(struct bq2515x_device *bq2515x)
0419 {
0420     int ret;
0421     int ce_pin;
0422     int icctrl2;
0423     int charger_disable;
0424 
0425     ce_pin = gpiod_get_value_cansleep(bq2515x->ce_gpio);
0426 
0427     ret = regmap_read(bq2515x->regmap, BQ2515X_ICCTRL2, &icctrl2);
0428     if (ret)
0429         return ret;
0430 
0431     charger_disable = icctrl2 & BQ2515X_CHARGER_DISABLE;
0432 
0433     if (charger_disable || ce_pin)
0434         return true;
0435 
0436     return false;
0437 }
0438 
0439 static int bq2515x_set_charge_disable(struct bq2515x_device *bq2515x, int val)
0440 {
0441     gpiod_set_value_cansleep(bq2515x->ce_gpio, val);
0442 
0443     return regmap_update_bits(bq2515x->regmap, BQ2515X_ICCTRL2,
0444                     BQ2515X_CHARGER_DISABLE, val);
0445 }
0446 
0447 static int bq2515x_get_const_charge_current(struct bq2515x_device *bq2515x)
0448 {
0449     int ret;
0450     u16 ichg_multiplier = BQ2515X_ICHG_RNG_1B0_UA;
0451     unsigned int ichg_reg_code;
0452     unsigned int pchrgctrl;
0453     unsigned int icharge_range;
0454 
0455     ret = regmap_read(bq2515x->regmap, BQ2515X_ICHG_CTRL, &ichg_reg_code);
0456     if (ret)
0457         return ret;
0458 
0459     ret = regmap_read(bq2515x->regmap, BQ2515X_PCHRGCTRL, &pchrgctrl);
0460     if (ret)
0461         return ret;
0462 
0463     icharge_range = pchrgctrl & BQ2515X_ICHARGE_RANGE;
0464 
0465     if (icharge_range)
0466         ichg_multiplier = BQ2515X_ICHG_RNG_1B1_UA;
0467 
0468     return ichg_reg_code * ichg_multiplier;
0469 }
0470 
0471 static int bq2515x_set_const_charge_current(struct bq2515x_device *bq2515x,
0472                                 int val)
0473 {
0474     int ret;
0475     unsigned int ichg_reg_code;
0476     u16 ichg_multiplier = BQ2515X_ICHG_RNG_1B0_UA;
0477     unsigned int icharge_range = 0;
0478 
0479     if (val > BQ2515X_ICHG_MAX_UA || val < BQ2515X_ICHG_MIN_UA)
0480         return -EINVAL;
0481 
0482     if (val > BQ2515X_ICHG_CURR_STEP_THRESH_UA) {
0483         ichg_multiplier = BQ2515X_ICHG_RNG_1B1_UA;
0484         icharge_range = BQ2515X_ICHARGE_RANGE;
0485     }
0486 
0487     bq2515x_set_charge_disable(bq2515x, 1);
0488 
0489     ret = regmap_update_bits(bq2515x->regmap, BQ2515X_PCHRGCTRL,
0490                     BQ2515X_ICHARGE_RANGE, icharge_range);
0491     if (ret)
0492         return ret;
0493 
0494     ichg_reg_code = val / ichg_multiplier;
0495 
0496     ret = regmap_write(bq2515x->regmap, BQ2515X_ICHG_CTRL, ichg_reg_code);
0497     if (ret)
0498         return ret;
0499 
0500     return bq2515x_set_charge_disable(bq2515x, 0);
0501 }
0502 
0503 static int bq2515x_get_precharge_current(struct bq2515x_device *bq2515x)
0504 {
0505     int ret;
0506     unsigned int pchrgctrl;
0507     unsigned int icharge_range;
0508     u16 precharge_multiplier = BQ2515X_ICHG_RNG_1B0_UA;
0509     unsigned int precharge_reg_code;
0510 
0511     ret = regmap_read(bq2515x->regmap, BQ2515X_PCHRGCTRL, &pchrgctrl);
0512     if (ret)
0513         return ret;
0514 
0515     icharge_range = pchrgctrl & BQ2515X_ICHARGE_RANGE;
0516 
0517     if (icharge_range)
0518         precharge_multiplier = BQ2515X_ICHG_RNG_1B1_UA;
0519 
0520     precharge_reg_code = pchrgctrl & BQ2515X_PRECHARGE_MASK;
0521 
0522     return precharge_reg_code * precharge_multiplier;
0523 }
0524 
0525 static int bq2515x_set_precharge_current(struct bq2515x_device *bq2515x,
0526                     int val)
0527 {
0528     int ret;
0529     unsigned int pchrgctrl;
0530     unsigned int icharge_range;
0531     unsigned int precharge_reg_code;
0532     unsigned int precharge_multiplier = BQ2515X_ICHG_RNG_1B0_UA;
0533     unsigned int precharge_max_ua = BQ2515X_PRECHRG_ICHRG_RNGE_1875_UA;
0534 
0535     ret = regmap_read(bq2515x->regmap, BQ2515X_PCHRGCTRL, &pchrgctrl);
0536     if (ret)
0537         return ret;
0538 
0539     icharge_range = pchrgctrl & BQ2515X_ICHARGE_RANGE;
0540 
0541     if (icharge_range) {
0542         precharge_max_ua = BQ2515X_PRECHRG_ICHRG_RNGE_3750_UA;
0543         precharge_multiplier = BQ2515X_ICHG_RNG_1B1_UA;
0544     } else {
0545         precharge_max_ua = BQ2515X_PRECHRG_ICHRG_RNGE_1875_UA;
0546         precharge_multiplier = BQ2515X_ICHG_RNG_1B0_UA;
0547     }
0548     if (val > precharge_max_ua || val < BQ2515X_ICHG_MIN_UA)
0549         return -EINVAL;
0550 
0551     precharge_reg_code = val / precharge_multiplier;
0552 
0553     ret = bq2515x_set_charge_disable(bq2515x, 1);
0554     if (ret)
0555         return ret;
0556 
0557     ret = regmap_update_bits(bq2515x->regmap, BQ2515X_PCHRGCTRL,
0558                 BQ2515X_PRECHARGE_MASK, precharge_reg_code);
0559     if (ret)
0560         return ret;
0561 
0562     return bq2515x_set_charge_disable(bq2515x, 0);
0563 }
0564 
0565 static int bq2515x_charging_status(struct bq2515x_device *bq2515x,
0566                    union power_supply_propval *val)
0567 {
0568     bool status0_no_fault;
0569     bool status1_no_fault;
0570     bool ce_status;
0571     bool charge_done;
0572     unsigned int status;
0573     int ret;
0574 
0575     if (!bq2515x->mains_online) {
0576         val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
0577         return 0;
0578     }
0579 
0580     ret = regmap_read(bq2515x->regmap, BQ2515X_STAT0, &status);
0581     if (ret)
0582         return ret;
0583 
0584     /*
0585      * The code block below is used to determine if any faults from the
0586      * STAT0 register are disbaling charging or if the charge has completed
0587      * according to the CHARGE_DONE_STAT bit.
0588      */
0589     if (((status & BQ2515X_STAT0_MASK) == true) &
0590             ((status & BQ2515X_CHRG_DONE) == false)) {
0591         status0_no_fault = true;
0592         charge_done = false;
0593     } else if (status & BQ2515X_CHRG_DONE) {
0594         charge_done = true;
0595         status0_no_fault = false;
0596     } else {
0597         status0_no_fault = false;
0598         charge_done = false;
0599     }
0600 
0601     ret = regmap_read(bq2515x->regmap, BQ2515X_STAT1, &status);
0602     if (ret)
0603         return ret;
0604     /*
0605      * The code block below is used to determine if any faults from the
0606      * STAT1 register are disbaling charging
0607      */
0608     if ((status & BQ2515X_STAT1_MASK) == false)
0609         status1_no_fault = true;
0610     else
0611         status1_no_fault = false;
0612 
0613     ce_status = (!bq2515x_get_charge_disable(bq2515x));
0614 
0615     /*
0616      * If there are no faults and charging is enabled, then status is
0617      * charging. Otherwise, if charging is complete, then status is full.
0618      * Otherwise, if a fault exists or charging is disabled, then status is
0619      * not charging
0620      */
0621     if (status0_no_fault & status1_no_fault & ce_status)
0622         val->intval = POWER_SUPPLY_STATUS_CHARGING;
0623     else if (charge_done)
0624         val->intval = POWER_SUPPLY_STATUS_FULL;
0625     else if (!(status0_no_fault & status1_no_fault & ce_status))
0626         val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
0627 
0628     return 0;
0629 }
0630 
0631 static int bq2515x_get_batt_reg(struct bq2515x_device *bq2515x)
0632 {
0633     int vbat_reg_code;
0634     int ret;
0635 
0636     ret = regmap_read(bq2515x->regmap, BQ2515X_VBAT_CTRL, &vbat_reg_code);
0637     if (ret)
0638         return ret;
0639 
0640     return BQ2515X_VBAT_BASE_VOLT + vbat_reg_code * BQ2515X_VBAT_STEP_UV;
0641 }
0642 
0643 static int bq2515x_set_batt_reg(struct bq2515x_device *bq2515x, int val)
0644 {
0645     int vbat_reg_code;
0646 
0647     if (val > BQ2515X_VBAT_REG_MAX || val < BQ2515X_VBAT_REG_MIN)
0648         return -EINVAL;
0649 
0650     vbat_reg_code = (val - BQ2515X_VBAT_BASE_VOLT) / BQ2515X_VBAT_STEP_UV;
0651 
0652     return regmap_write(bq2515x->regmap, BQ2515X_VBAT_CTRL, vbat_reg_code);
0653 }
0654 
0655 static int bq2515x_get_ilim_lvl(struct bq2515x_device *bq2515x)
0656 {
0657     int ret;
0658     int ilimctrl;
0659 
0660     ret = regmap_read(bq2515x->regmap, BQ2515X_ILIMCTRL, &ilimctrl);
0661     if (ret)
0662         return ret;
0663 
0664     return bq2515x_ilim_lvl_values[ilimctrl & BQ2515X_ILIM_MASK];
0665 }
0666 
0667 static int bq2515x_set_ilim_lvl(struct bq2515x_device *bq2515x, int val)
0668 {
0669     int i = 0;
0670     unsigned int array_size = ARRAY_SIZE(bq2515x_ilim_lvl_values);
0671 
0672     for (i = array_size - 1; i > 0; i--) {
0673         if (val >= bq2515x_ilim_lvl_values[i])
0674             break;
0675     }
0676     return regmap_write(bq2515x->regmap, BQ2515X_ILIMCTRL, i);
0677 }
0678 
0679 static int bq2515x_power_supply_property_is_writeable(struct power_supply *psy,
0680                     enum power_supply_property prop)
0681 {
0682     switch (prop) {
0683     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
0684     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
0685     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
0686     case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
0687         return true;
0688     default:
0689         return false;
0690     }
0691 }
0692 
0693 static int bq2515x_charger_get_health(struct bq2515x_device *bq2515x,
0694                       union power_supply_propval *val)
0695 {
0696     int health = POWER_SUPPLY_HEALTH_GOOD;
0697     int ret;
0698     unsigned int stat1;
0699     unsigned int flag3;
0700 
0701     if (!bq2515x->mains_online)
0702         bq2515x_wake_up(bq2515x);
0703 
0704     ret = regmap_read(bq2515x->regmap, BQ2515X_FLAG3, &flag3);
0705     if (ret)
0706         return ret;
0707 
0708     ret = regmap_read(bq2515x->regmap, BQ2515X_STAT1, &stat1);
0709     if (ret)
0710         return ret;
0711 
0712     if (stat1 & BQ2515X_HEALTH_MASK) {
0713         switch (stat1 & BQ2515X_HEALTH_MASK) {
0714         case BQ2515X_TS_HOT_STAT:
0715             health = POWER_SUPPLY_HEALTH_HOT;
0716             break;
0717         case BQ2515X_TS_WARM_STAT:
0718             health = POWER_SUPPLY_HEALTH_WARM;
0719             break;
0720         case BQ2515X_TS_COOL_STAT:
0721             health = POWER_SUPPLY_HEALTH_COOL;
0722             break;
0723         case BQ2515X_TS_COLD_STAT:
0724             health = POWER_SUPPLY_HEALTH_COLD;
0725             break;
0726         default:
0727             health = POWER_SUPPLY_HEALTH_UNKNOWN;
0728             break;
0729         }
0730     }
0731 
0732     if (stat1 & BQ2515X_VIN_OVP_FAULT_STAT)
0733         health = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
0734 
0735     if (flag3 & BQ2515X_SAFETY_TIMER_EXP)
0736         health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
0737 
0738     val->intval = health;
0739     return 0;
0740 }
0741 
0742 static int bq2515x_mains_set_property(struct power_supply *psy,
0743         enum power_supply_property prop,
0744         const union power_supply_propval *val)
0745 {
0746     struct bq2515x_device *bq2515x = power_supply_get_drvdata(psy);
0747     int ret;
0748 
0749     switch (prop) {
0750     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
0751         ret = bq2515x_set_batt_reg(bq2515x, val->intval);
0752         break;
0753 
0754     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
0755         ret = bq2515x_set_const_charge_current(bq2515x, val->intval);
0756         break;
0757 
0758     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
0759         ret = bq2515x_set_ilim_lvl(bq2515x, val->intval);
0760         break;
0761 
0762     case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
0763         ret = bq2515x_set_precharge_current(bq2515x, val->intval);
0764         break;
0765 
0766     default:
0767         return -EINVAL;
0768     }
0769 
0770     return ret;
0771 }
0772 
0773 static int bq2515x_mains_get_property(struct power_supply *psy,
0774                      enum power_supply_property prop,
0775                      union power_supply_propval *val)
0776 {
0777     struct bq2515x_device *bq2515x = power_supply_get_drvdata(psy);
0778     int ret = 0;
0779 
0780     switch (prop) {
0781 
0782     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
0783         ret = bq2515x_get_const_charge_current(bq2515x);
0784         if (ret < 0)
0785             return ret;
0786 
0787         val->intval = ret;
0788         break;
0789 
0790     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
0791         ret = bq2515x_get_batt_reg(bq2515x);
0792         if (ret < 0)
0793             return ret;
0794         val->intval = ret;
0795         break;
0796 
0797     case POWER_SUPPLY_PROP_PRECHARGE_CURRENT:
0798         ret = bq2515x_get_precharge_current(bq2515x);
0799         if (ret < 0)
0800             return ret;
0801         val->intval = ret;
0802         break;
0803 
0804     case POWER_SUPPLY_PROP_ONLINE:
0805         val->intval = bq2515x->mains_online;
0806         break;
0807 
0808     case POWER_SUPPLY_PROP_HEALTH:
0809         ret = bq2515x_charger_get_health(bq2515x, val);
0810         if (ret)
0811             val->intval = POWER_SUPPLY_HEALTH_UNKNOWN;
0812         break;
0813 
0814     case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
0815         ret = bq2515x_get_ilim_lvl(bq2515x);
0816         if (ret < 0)
0817             return ret;
0818         val->intval = ret;
0819         break;
0820 
0821     case POWER_SUPPLY_PROP_MODEL_NAME:
0822         val->strval = bq2515x->model_name;
0823         break;
0824 
0825     case POWER_SUPPLY_PROP_MANUFACTURER:
0826         val->strval = BQ2515X_MANUFACTURER;
0827         break;
0828 
0829     case POWER_SUPPLY_PROP_STATUS:
0830         ret = bq2515x_charging_status(bq2515x, val);
0831         if (ret)
0832             return ret;
0833         break;
0834 
0835     default:
0836         return -EINVAL;
0837     }
0838 
0839     return ret;
0840 }
0841 
0842 static int bq2515x_battery_get_property(struct power_supply *psy,
0843                        enum power_supply_property prop,
0844                        union power_supply_propval *val)
0845 {
0846     struct bq2515x_device *bq2515x = power_supply_get_drvdata(psy);
0847     int ret;
0848 
0849     ret = bq2515x_update_ps_status(bq2515x);
0850     if (ret)
0851         return ret;
0852 
0853     switch (prop) {
0854 
0855     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
0856         ret = bq2515x->init_data.vbatreg;
0857         if (ret < 0)
0858             return ret;
0859         val->intval = ret;
0860         break;
0861 
0862     case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
0863         ret = bq2515x->init_data.ichg;
0864         if (ret < 0)
0865             return ret;
0866         val->intval = ret;
0867         break;
0868 
0869     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0870         ret = bq2515x_get_battery_voltage_now(bq2515x);
0871         if (ret < 0)
0872             return ret;
0873         val->intval = ret;
0874         break;
0875 
0876     case POWER_SUPPLY_PROP_CURRENT_NOW:
0877         ret = bq2515x_get_battery_current_now(bq2515x);
0878         if (ret < 0)
0879             return ret;
0880         val->intval = ret;
0881         break;
0882 
0883     default:
0884         return -EINVAL;
0885     }
0886     return 0;
0887 }
0888 
0889 static const enum power_supply_property bq2515x_battery_properties[] = {
0890     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0891     POWER_SUPPLY_PROP_CURRENT_NOW,
0892     POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
0893     POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
0894 };
0895 
0896 static const enum power_supply_property bq2515x_mains_properties[] = {
0897     POWER_SUPPLY_PROP_ONLINE,
0898     POWER_SUPPLY_PROP_STATUS,
0899     POWER_SUPPLY_PROP_HEALTH,
0900     POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
0901     POWER_SUPPLY_PROP_MODEL_NAME,
0902     POWER_SUPPLY_PROP_MANUFACTURER,
0903     POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
0904     POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
0905     POWER_SUPPLY_PROP_PRECHARGE_CURRENT,
0906 };
0907 
0908 static const struct power_supply_desc bq2515x_mains_desc = {
0909     .name           = "bq2515x-mains",
0910     .type           = POWER_SUPPLY_TYPE_MAINS,
0911     .get_property       = bq2515x_mains_get_property,
0912     .set_property       = bq2515x_mains_set_property,
0913     .properties     = bq2515x_mains_properties,
0914     .num_properties     = ARRAY_SIZE(bq2515x_mains_properties),
0915     .property_is_writeable  = bq2515x_power_supply_property_is_writeable,
0916 };
0917 
0918 static const struct power_supply_desc bq2515x_battery_desc = {
0919     .name           = "bq2515x-battery",
0920     .type           = POWER_SUPPLY_TYPE_BATTERY,
0921     .get_property       = bq2515x_battery_get_property,
0922     .properties     = bq2515x_battery_properties,
0923     .num_properties     = ARRAY_SIZE(bq2515x_battery_properties),
0924     .property_is_writeable  = bq2515x_power_supply_property_is_writeable,
0925 };
0926 
0927 static int bq2515x_power_supply_register(struct bq2515x_device *bq2515x,
0928         struct device *dev, struct power_supply_config psy_cfg)
0929 {
0930     bq2515x->mains = devm_power_supply_register(bq2515x->dev,
0931                             &bq2515x_mains_desc,
0932                             &psy_cfg);
0933     if (IS_ERR(bq2515x->mains))
0934         return -EINVAL;
0935 
0936     bq2515x->battery = devm_power_supply_register(bq2515x->dev,
0937                               &bq2515x_battery_desc,
0938                               &psy_cfg);
0939     if (IS_ERR(bq2515x->battery))
0940         return -EINVAL;
0941 
0942     return 0;
0943 }
0944 
0945 static int bq2515x_hw_init(struct bq2515x_device *bq2515x)
0946 {
0947     int ret;
0948     struct power_supply_battery_info *bat_info;
0949 
0950     ret = bq2515x_disable_watchdog_timers(bq2515x);
0951     if (ret)
0952         return ret;
0953 
0954     if (bq2515x->init_data.ilim) {
0955         ret = bq2515x_set_ilim_lvl(bq2515x, bq2515x->init_data.ilim);
0956         if (ret)
0957             return ret;
0958     }
0959 
0960     ret = power_supply_get_battery_info(bq2515x->mains, &bat_info);
0961     if (ret) {
0962         dev_warn(bq2515x->dev, "battery info missing, default values will be applied\n");
0963 
0964         bq2515x->init_data.ichg = BQ2515X_DEFAULT_ICHG_UA;
0965 
0966         bq2515x->init_data.vbatreg = BQ2515X_DEFAULT_VBAT_REG_UV;
0967 
0968         bq2515x->init_data.iprechg = BQ2515X_DEFAULT_IPRECHARGE_UA;
0969 
0970     } else {
0971         bq2515x->init_data.ichg =
0972                 bat_info->constant_charge_current_max_ua;
0973 
0974         bq2515x->init_data.vbatreg =
0975                 bat_info->constant_charge_voltage_max_uv;
0976 
0977         bq2515x->init_data.iprechg =
0978                 bat_info->precharge_current_ua;
0979     }
0980 
0981     ret = bq2515x_set_const_charge_current(bq2515x,
0982                         bq2515x->init_data.ichg);
0983     if (ret)
0984         return ret;
0985 
0986     ret = bq2515x_set_batt_reg(bq2515x, bq2515x->init_data.vbatreg);
0987     if (ret)
0988         return ret;
0989 
0990     return bq2515x_set_precharge_current(bq2515x,
0991                         bq2515x->init_data.iprechg);
0992 }
0993 
0994 static int bq2515x_read_properties(struct bq2515x_device *bq2515x)
0995 {
0996     int ret;
0997 
0998     ret = device_property_read_u32(bq2515x->dev,
0999                       "input-current-limit-microamp",
1000                       &bq2515x->init_data.ilim);
1001     if (ret) {
1002         switch (bq2515x->device_id) {
1003         case BQ25150:
1004             bq2515x->init_data.ilim = BQ25150_DEFAULT_ILIM_UA;
1005             break;
1006         case BQ25155:
1007             bq2515x->init_data.ilim = BQ25155_DEFAULT_ILIM_UA;
1008             break;
1009         }
1010     }
1011 
1012     bq2515x->ac_detect_gpio = devm_gpiod_get_optional(bq2515x->dev,
1013                            "ac-detect", GPIOD_IN);
1014     if (IS_ERR(bq2515x->ac_detect_gpio)) {
1015         ret = PTR_ERR(bq2515x->ac_detect_gpio);
1016         dev_err(bq2515x->dev, "Failed to get ac detect");
1017         return ret;
1018     }
1019 
1020     bq2515x->reset_gpio = devm_gpiod_get_optional(bq2515x->dev,
1021                            "reset", GPIOD_OUT_LOW);
1022     if (IS_ERR(bq2515x->reset_gpio)) {
1023         ret = PTR_ERR(bq2515x->reset_gpio);
1024         dev_err(bq2515x->dev, "Failed to get reset");
1025         return ret;
1026     }
1027 
1028     bq2515x->powerdown_gpio = devm_gpiod_get_optional(bq2515x->dev,
1029                         "powerdown", GPIOD_OUT_LOW);
1030     if (IS_ERR(bq2515x->powerdown_gpio)) {
1031         ret = PTR_ERR(bq2515x->powerdown_gpio);
1032         dev_err(bq2515x->dev, "Failed to get powerdown");
1033         return ret;
1034     }
1035 
1036     bq2515x->ce_gpio = devm_gpiod_get_optional(bq2515x->dev,
1037                            "charge-enable",
1038                            GPIOD_OUT_LOW);
1039     if (IS_ERR(bq2515x->ce_gpio)) {
1040         ret = PTR_ERR(bq2515x->ce_gpio);
1041         dev_err(bq2515x->dev, "Failed to get ce");
1042         return ret;
1043     }
1044 
1045     return 0;
1046 }
1047 
1048 static bool bq2515x_volatile_register(struct device *dev, unsigned int reg)
1049 {
1050     switch (reg) {
1051     case BQ2515X_STAT0 ... BQ2515X_FLAG3:
1052     case BQ2515X_ADC_VBAT_M ... BQ2515X_ADC_IIN_L:
1053         return true;
1054     default:
1055         return false;
1056     }
1057 }
1058 
1059 static const struct regmap_config bq25150_regmap_config = {
1060     .reg_bits = 8,
1061     .val_bits = 8,
1062 
1063     .max_register       = BQ2515X_DEVICE_ID,
1064     .reg_defaults       = bq25150_reg_defaults,
1065     .num_reg_defaults   = ARRAY_SIZE(bq25150_reg_defaults),
1066     .cache_type     = REGCACHE_RBTREE,
1067     .volatile_reg       = bq2515x_volatile_register,
1068 };
1069 
1070 static const struct regmap_config bq25155_regmap_config = {
1071     .reg_bits = 8,
1072     .val_bits = 8,
1073 
1074     .max_register       = BQ2515X_DEVICE_ID,
1075     .reg_defaults       = bq25155_reg_defaults,
1076     .num_reg_defaults   = ARRAY_SIZE(bq25155_reg_defaults),
1077     .cache_type     = REGCACHE_RBTREE,
1078     .volatile_reg       = bq2515x_volatile_register,
1079 };
1080 
1081 static int bq2515x_probe(struct i2c_client *client,
1082              const struct i2c_device_id *id)
1083 {
1084     struct device *dev = &client->dev;
1085     struct bq2515x_device *bq2515x;
1086     struct power_supply_config charger_cfg = {};
1087     int ret;
1088 
1089     bq2515x = devm_kzalloc(dev, sizeof(*bq2515x), GFP_KERNEL);
1090     if (!bq2515x)
1091         return -ENOMEM;
1092 
1093     bq2515x->dev = dev;
1094 
1095     strncpy(bq2515x->model_name, id->name, I2C_NAME_SIZE);
1096 
1097     bq2515x->device_id = id->driver_data;
1098 
1099     switch (bq2515x->device_id) {
1100     case BQ25150:
1101         bq2515x->regmap = devm_regmap_init_i2c(client,
1102                         &bq25150_regmap_config);
1103         break;
1104     case BQ25155:
1105         bq2515x->regmap = devm_regmap_init_i2c(client,
1106                         &bq25155_regmap_config);
1107         break;
1108     }
1109 
1110     if (IS_ERR(bq2515x->regmap)) {
1111         dev_err(dev, "failed to allocate register map\n");
1112         return PTR_ERR(bq2515x->regmap);
1113     }
1114 
1115     i2c_set_clientdata(client, bq2515x);
1116 
1117     charger_cfg.drv_data = bq2515x;
1118     charger_cfg.of_node = dev->of_node;
1119 
1120     ret = bq2515x_read_properties(bq2515x);
1121     if (ret) {
1122         dev_err(dev, "Failed to read device tree properties %d\n",
1123                                     ret);
1124         return ret;
1125     }
1126 
1127     ret = bq2515x_power_supply_register(bq2515x, dev, charger_cfg);
1128     if (ret) {
1129         dev_err(dev, "failed to register power supply\n");
1130         return ret;
1131     }
1132 
1133     ret = bq2515x_hw_init(bq2515x);
1134     if (ret) {
1135         dev_err(dev, "Cannot initialize the chip\n");
1136         return ret;
1137     }
1138 
1139     return 0;
1140 }
1141 
1142 static const struct i2c_device_id bq2515x_i2c_ids[] = {
1143     { "bq25150", BQ25150, },
1144     { "bq25155", BQ25155, },
1145     {},
1146 };
1147 MODULE_DEVICE_TABLE(i2c, bq2515x_i2c_ids);
1148 
1149 static const struct of_device_id bq2515x_of_match[] = {
1150     { .compatible = "ti,bq25150", },
1151     { .compatible = "ti,bq25155", },
1152     { },
1153 };
1154 MODULE_DEVICE_TABLE(of, bq2515x_of_match);
1155 
1156 static struct i2c_driver bq2515x_driver = {
1157     .driver = {
1158         .name = "bq2515x-charger",
1159         .of_match_table = bq2515x_of_match,
1160     },
1161     .probe = bq2515x_probe,
1162     .id_table = bq2515x_i2c_ids,
1163 };
1164 module_i2c_driver(bq2515x_driver);
1165 
1166 MODULE_AUTHOR("Dan Murphy <dmurphy@ti.com>");
1167 MODULE_AUTHOR("Ricardo Rivera-Matos <r-rivera-matos@ti.com>");
1168 MODULE_DESCRIPTION("BQ2515X charger driver");
1169 MODULE_LICENSE("GPL v2");
[ 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!