Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * I2C client/driver for the Linear Technology LTC2941, LTC2942, LTC2943
0004  * and LTC2944 Battery Gas Gauge IC
0005  *
0006  * Copyright (C) 2014 Topic Embedded Systems
0007  *
0008  * Author: Auryn Verwegen
0009  * Author: Mike Looijmans
0010  */
0011 #include <linux/devm-helpers.h>
0012 #include <linux/kernel.h>
0013 #include <linux/module.h>
0014 #include <linux/of_device.h>
0015 #include <linux/types.h>
0016 #include <linux/errno.h>
0017 #include <linux/swab.h>
0018 #include <linux/i2c.h>
0019 #include <linux/delay.h>
0020 #include <linux/power_supply.h>
0021 #include <linux/slab.h>
0022 
0023 #define I16_MSB(x)          ((x >> 8) & 0xFF)
0024 #define I16_LSB(x)          (x & 0xFF)
0025 
0026 #define LTC294X_WORK_DELAY      10  /* Update delay in seconds */
0027 
0028 #define LTC294X_MAX_VALUE       0xFFFF
0029 #define LTC294X_MID_SUPPLY      0x7FFF
0030 
0031 #define LTC2941_MAX_PRESCALER_EXP   7
0032 #define LTC2943_MAX_PRESCALER_EXP   6
0033 
0034 enum ltc294x_reg {
0035     LTC294X_REG_STATUS      = 0x00,
0036     LTC294X_REG_CONTROL     = 0x01,
0037     LTC294X_REG_ACC_CHARGE_MSB  = 0x02,
0038     LTC294X_REG_ACC_CHARGE_LSB  = 0x03,
0039     LTC294X_REG_CHARGE_THR_HIGH_MSB = 0x04,
0040     LTC294X_REG_CHARGE_THR_HIGH_LSB = 0x05,
0041     LTC294X_REG_CHARGE_THR_LOW_MSB  = 0x06,
0042     LTC294X_REG_CHARGE_THR_LOW_LSB  = 0x07,
0043     LTC294X_REG_VOLTAGE_MSB     = 0x08,
0044     LTC294X_REG_VOLTAGE_LSB     = 0x09,
0045     LTC2942_REG_TEMPERATURE_MSB = 0x0C,
0046     LTC2942_REG_TEMPERATURE_LSB = 0x0D,
0047     LTC2943_REG_CURRENT_MSB     = 0x0E,
0048     LTC2943_REG_CURRENT_LSB     = 0x0F,
0049     LTC2943_REG_TEMPERATURE_MSB = 0x14,
0050     LTC2943_REG_TEMPERATURE_LSB = 0x15,
0051 };
0052 
0053 enum ltc294x_id {
0054     LTC2941_ID,
0055     LTC2942_ID,
0056     LTC2943_ID,
0057     LTC2944_ID,
0058 };
0059 
0060 #define LTC2941_REG_STATUS_CHIP_ID  BIT(7)
0061 
0062 #define LTC2942_REG_CONTROL_MODE_SCAN   (BIT(7) | BIT(6))
0063 #define LTC2943_REG_CONTROL_MODE_SCAN   BIT(7)
0064 #define LTC294X_REG_CONTROL_PRESCALER_MASK  (BIT(5) | BIT(4) | BIT(3))
0065 #define LTC294X_REG_CONTROL_SHUTDOWN_MASK   (BIT(0))
0066 #define LTC294X_REG_CONTROL_PRESCALER_SET(x) \
0067     ((x << 3) & LTC294X_REG_CONTROL_PRESCALER_MASK)
0068 #define LTC294X_REG_CONTROL_ALCC_CONFIG_DISABLED    0
0069 #define LTC294X_REG_CONTROL_ADC_DISABLE(x)  ((x) & ~(BIT(7) | BIT(6)))
0070 
0071 struct ltc294x_info {
0072     struct i2c_client *client;  /* I2C Client pointer */
0073     struct power_supply *supply;    /* Supply pointer */
0074     struct power_supply_desc supply_desc;   /* Supply description */
0075     struct delayed_work work;   /* Work scheduler */
0076     enum ltc294x_id id;     /* Chip type */
0077     int charge; /* Last charge register content */
0078     int r_sense;    /* mOhm */
0079     int Qlsb;   /* nAh */
0080 };
0081 
0082 static inline int convert_bin_to_uAh(
0083     const struct ltc294x_info *info, int Q)
0084 {
0085     return ((Q * (info->Qlsb / 10))) / 100;
0086 }
0087 
0088 static inline int convert_uAh_to_bin(
0089     const struct ltc294x_info *info, int uAh)
0090 {
0091     int Q;
0092 
0093     Q = (uAh * 100) / (info->Qlsb/10);
0094     return (Q < LTC294X_MAX_VALUE) ? Q : LTC294X_MAX_VALUE;
0095 }
0096 
0097 static int ltc294x_read_regs(struct i2c_client *client,
0098     enum ltc294x_reg reg, u8 *buf, int num_regs)
0099 {
0100     int ret;
0101     struct i2c_msg msgs[2] = { };
0102     u8 reg_start = reg;
0103 
0104     msgs[0].addr    = client->addr;
0105     msgs[0].len = 1;
0106     msgs[0].buf = &reg_start;
0107 
0108     msgs[1].addr    = client->addr;
0109     msgs[1].len = num_regs;
0110     msgs[1].buf = buf;
0111     msgs[1].flags   = I2C_M_RD;
0112 
0113     ret = i2c_transfer(client->adapter, &msgs[0], 2);
0114     if (ret < 0) {
0115         dev_err(&client->dev, "ltc2941 read_reg(0x%x[%d]) failed: %pe\n",
0116             reg, num_regs, ERR_PTR(ret));
0117         return ret;
0118     }
0119 
0120     dev_dbg(&client->dev, "%s (%#x, %d) -> %#x\n",
0121         __func__, reg, num_regs, *buf);
0122 
0123     return 0;
0124 }
0125 
0126 static int ltc294x_write_regs(struct i2c_client *client,
0127     enum ltc294x_reg reg, const u8 *buf, int num_regs)
0128 {
0129     int ret;
0130     u8 reg_start = reg;
0131 
0132     ret = i2c_smbus_write_i2c_block_data(client, reg_start, num_regs, buf);
0133     if (ret < 0) {
0134         dev_err(&client->dev, "ltc2941 write_reg(0x%x[%d]) failed: %pe\n",
0135             reg, num_regs, ERR_PTR(ret));
0136         return ret;
0137     }
0138 
0139     dev_dbg(&client->dev, "%s (%#x, %d) -> %#x\n",
0140         __func__, reg, num_regs, *buf);
0141 
0142     return 0;
0143 }
0144 
0145 static int ltc294x_reset(const struct ltc294x_info *info, int prescaler_exp)
0146 {
0147     int ret;
0148     u8 value;
0149     u8 control;
0150 
0151     /* Read status and control registers */
0152     ret = ltc294x_read_regs(info->client, LTC294X_REG_CONTROL, &value, 1);
0153     if (ret < 0)
0154         return ret;
0155 
0156     control = LTC294X_REG_CONTROL_PRESCALER_SET(prescaler_exp) |
0157                 LTC294X_REG_CONTROL_ALCC_CONFIG_DISABLED;
0158     /* Put device into "monitor" mode */
0159     switch (info->id) {
0160     case LTC2942_ID:    /* 2942 measures every 2 sec */
0161         control |= LTC2942_REG_CONTROL_MODE_SCAN;
0162         break;
0163     case LTC2943_ID:
0164     case LTC2944_ID:    /* 2943 and 2944 measure every 10 sec */
0165         control |= LTC2943_REG_CONTROL_MODE_SCAN;
0166         break;
0167     default:
0168         break;
0169     }
0170 
0171     if (value != control) {
0172         ret = ltc294x_write_regs(info->client,
0173             LTC294X_REG_CONTROL, &control, 1);
0174         if (ret < 0)
0175             return ret;
0176     }
0177 
0178     return 0;
0179 }
0180 
0181 static int ltc294x_read_charge_register(const struct ltc294x_info *info,
0182                     enum ltc294x_reg reg)
0183  {
0184     int ret;
0185     u8 datar[2];
0186 
0187     ret = ltc294x_read_regs(info->client, reg, &datar[0], 2);
0188     if (ret < 0)
0189         return ret;
0190     return (datar[0] << 8) + datar[1];
0191 }
0192 
0193 static int ltc294x_get_charge(const struct ltc294x_info *info,
0194                 enum ltc294x_reg reg, int *val)
0195 {
0196     int value = ltc294x_read_charge_register(info, reg);
0197 
0198     if (value < 0)
0199         return value;
0200     /* When r_sense < 0, this counts up when the battery discharges */
0201     if (info->Qlsb < 0)
0202         value -= 0xFFFF;
0203     *val = convert_bin_to_uAh(info, value);
0204     return 0;
0205 }
0206 
0207 static int ltc294x_set_charge_now(const struct ltc294x_info *info, int val)
0208 {
0209     int ret;
0210     u8 dataw[2];
0211     u8 ctrl_reg;
0212     s32 value;
0213 
0214     value = convert_uAh_to_bin(info, val);
0215     /* Direction depends on how sense+/- were connected */
0216     if (info->Qlsb < 0)
0217         value += 0xFFFF;
0218     if ((value < 0) || (value > 0xFFFF)) /* input validation */
0219         return -EINVAL;
0220 
0221     /* Read control register */
0222     ret = ltc294x_read_regs(info->client,
0223         LTC294X_REG_CONTROL, &ctrl_reg, 1);
0224     if (ret < 0)
0225         return ret;
0226     /* Disable analog section */
0227     ctrl_reg |= LTC294X_REG_CONTROL_SHUTDOWN_MASK;
0228     ret = ltc294x_write_regs(info->client,
0229         LTC294X_REG_CONTROL, &ctrl_reg, 1);
0230     if (ret < 0)
0231         return ret;
0232     /* Set new charge value */
0233     dataw[0] = I16_MSB(value);
0234     dataw[1] = I16_LSB(value);
0235     ret = ltc294x_write_regs(info->client,
0236         LTC294X_REG_ACC_CHARGE_MSB, &dataw[0], 2);
0237     if (ret < 0)
0238         goto error_exit;
0239     /* Enable analog section */
0240 error_exit:
0241     ctrl_reg &= ~LTC294X_REG_CONTROL_SHUTDOWN_MASK;
0242     ret = ltc294x_write_regs(info->client,
0243         LTC294X_REG_CONTROL, &ctrl_reg, 1);
0244 
0245     return ret < 0 ? ret : 0;
0246 }
0247 
0248 static int ltc294x_set_charge_thr(const struct ltc294x_info *info,
0249                     enum ltc294x_reg reg, int val)
0250 {
0251     u8 dataw[2];
0252     s32 value;
0253 
0254     value = convert_uAh_to_bin(info, val);
0255     /* Direction depends on how sense+/- were connected */
0256     if (info->Qlsb < 0)
0257         value += 0xFFFF;
0258     if ((value < 0) || (value > 0xFFFF)) /* input validation */
0259         return -EINVAL;
0260 
0261     /* Set new charge value */
0262     dataw[0] = I16_MSB(value);
0263     dataw[1] = I16_LSB(value);
0264     return ltc294x_write_regs(info->client, reg, &dataw[0], 2);
0265 }
0266 
0267 static int ltc294x_get_charge_counter(
0268     const struct ltc294x_info *info, int *val)
0269 {
0270     int value = ltc294x_read_charge_register(info, LTC294X_REG_ACC_CHARGE_MSB);
0271 
0272     if (value < 0)
0273         return value;
0274     value -= LTC294X_MID_SUPPLY;
0275     *val = convert_bin_to_uAh(info, value);
0276     return 0;
0277 }
0278 
0279 static int ltc294x_get_voltage(const struct ltc294x_info *info, int *val)
0280 {
0281     int ret;
0282     u8 datar[2];
0283     u32 value;
0284 
0285     ret = ltc294x_read_regs(info->client,
0286         LTC294X_REG_VOLTAGE_MSB, &datar[0], 2);
0287     value = (datar[0] << 8) | datar[1];
0288     switch (info->id) {
0289     case LTC2943_ID:
0290         value *= 23600 * 2;
0291         value /= 0xFFFF;
0292         value *= 1000 / 2;
0293         break;
0294     case LTC2944_ID:
0295         value *= 70800 / 5*4;
0296         value /= 0xFFFF;
0297         value *= 1000 * 5/4;
0298         break;
0299     default:
0300         value *= 6000 * 10;
0301         value /= 0xFFFF;
0302         value *= 1000 / 10;
0303         break;
0304     }
0305     *val = value;
0306     return ret;
0307 }
0308 
0309 static int ltc294x_get_current(const struct ltc294x_info *info, int *val)
0310 {
0311     int ret;
0312     u8 datar[2];
0313     s32 value;
0314 
0315     ret = ltc294x_read_regs(info->client,
0316         LTC2943_REG_CURRENT_MSB, &datar[0], 2);
0317     value = (datar[0] << 8) | datar[1];
0318     value -= 0x7FFF;
0319     if (info->id == LTC2944_ID)
0320         value *= 64000;
0321     else
0322         value *= 60000;
0323     /* Value is in range -32k..+32k, r_sense is usually 10..50 mOhm,
0324      * the formula below keeps everything in s32 range while preserving
0325      * enough digits */
0326     *val = 1000 * (value / (info->r_sense * 0x7FFF)); /* in uA */
0327     return ret;
0328 }
0329 
0330 static int ltc294x_get_temperature(const struct ltc294x_info *info, int *val)
0331 {
0332     enum ltc294x_reg reg;
0333     int ret;
0334     u8 datar[2];
0335     u32 value;
0336 
0337     if (info->id == LTC2942_ID) {
0338         reg = LTC2942_REG_TEMPERATURE_MSB;
0339         value = 6000;   /* Full-scale is 600 Kelvin */
0340     } else {
0341         reg = LTC2943_REG_TEMPERATURE_MSB;
0342         value = 5100;   /* Full-scale is 510 Kelvin */
0343     }
0344     ret = ltc294x_read_regs(info->client, reg, &datar[0], 2);
0345     value *= (datar[0] << 8) | datar[1];
0346     /* Convert to tenths of degree Celsius */
0347     *val = value / 0xFFFF - 2722;
0348     return ret;
0349 }
0350 
0351 static int ltc294x_get_property(struct power_supply *psy,
0352                 enum power_supply_property prop,
0353                 union power_supply_propval *val)
0354 {
0355     struct ltc294x_info *info = power_supply_get_drvdata(psy);
0356 
0357     switch (prop) {
0358     case POWER_SUPPLY_PROP_CHARGE_FULL:
0359         return ltc294x_get_charge(info, LTC294X_REG_CHARGE_THR_HIGH_MSB,
0360                         &val->intval);
0361     case POWER_SUPPLY_PROP_CHARGE_EMPTY:
0362         return ltc294x_get_charge(info, LTC294X_REG_CHARGE_THR_LOW_MSB,
0363                         &val->intval);
0364     case POWER_SUPPLY_PROP_CHARGE_NOW:
0365         return ltc294x_get_charge(info, LTC294X_REG_ACC_CHARGE_MSB,
0366                         &val->intval);
0367     case POWER_SUPPLY_PROP_CHARGE_COUNTER:
0368         return ltc294x_get_charge_counter(info, &val->intval);
0369     case POWER_SUPPLY_PROP_VOLTAGE_NOW:
0370         return ltc294x_get_voltage(info, &val->intval);
0371     case POWER_SUPPLY_PROP_CURRENT_NOW:
0372         return ltc294x_get_current(info, &val->intval);
0373     case POWER_SUPPLY_PROP_TEMP:
0374         return ltc294x_get_temperature(info, &val->intval);
0375     default:
0376         return -EINVAL;
0377     }
0378 }
0379 
0380 static int ltc294x_set_property(struct power_supply *psy,
0381     enum power_supply_property psp,
0382     const union power_supply_propval *val)
0383 {
0384     struct ltc294x_info *info = power_supply_get_drvdata(psy);
0385 
0386     switch (psp) {
0387     case POWER_SUPPLY_PROP_CHARGE_FULL:
0388         return ltc294x_set_charge_thr(info,
0389             LTC294X_REG_CHARGE_THR_HIGH_MSB, val->intval);
0390     case POWER_SUPPLY_PROP_CHARGE_EMPTY:
0391         return ltc294x_set_charge_thr(info,
0392             LTC294X_REG_CHARGE_THR_LOW_MSB, val->intval);
0393     case POWER_SUPPLY_PROP_CHARGE_NOW:
0394         return ltc294x_set_charge_now(info, val->intval);
0395     default:
0396         return -EPERM;
0397     }
0398 }
0399 
0400 static int ltc294x_property_is_writeable(
0401     struct power_supply *psy, enum power_supply_property psp)
0402 {
0403     switch (psp) {
0404     case POWER_SUPPLY_PROP_CHARGE_FULL:
0405     case POWER_SUPPLY_PROP_CHARGE_EMPTY:
0406     case POWER_SUPPLY_PROP_CHARGE_NOW:
0407         return 1;
0408     default:
0409         return 0;
0410     }
0411 }
0412 
0413 static void ltc294x_update(struct ltc294x_info *info)
0414 {
0415     int charge = ltc294x_read_charge_register(info, LTC294X_REG_ACC_CHARGE_MSB);
0416 
0417     if (charge != info->charge) {
0418         info->charge = charge;
0419         power_supply_changed(info->supply);
0420     }
0421 }
0422 
0423 static void ltc294x_work(struct work_struct *work)
0424 {
0425     struct ltc294x_info *info;
0426 
0427     info = container_of(work, struct ltc294x_info, work.work);
0428     ltc294x_update(info);
0429     schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
0430 }
0431 
0432 static enum power_supply_property ltc294x_properties[] = {
0433     POWER_SUPPLY_PROP_CHARGE_COUNTER,
0434     POWER_SUPPLY_PROP_CHARGE_FULL,
0435     POWER_SUPPLY_PROP_CHARGE_EMPTY,
0436     POWER_SUPPLY_PROP_CHARGE_NOW,
0437     POWER_SUPPLY_PROP_VOLTAGE_NOW,
0438     POWER_SUPPLY_PROP_TEMP,
0439     POWER_SUPPLY_PROP_CURRENT_NOW,
0440 };
0441 
0442 static int ltc294x_i2c_probe(struct i2c_client *client,
0443     const struct i2c_device_id *id)
0444 {
0445     struct power_supply_config psy_cfg = {};
0446     struct ltc294x_info *info;
0447     struct device_node *np;
0448     int ret;
0449     u32 prescaler_exp;
0450     s32 r_sense;
0451     u8 status;
0452 
0453     info = devm_kzalloc(&client->dev, sizeof(*info), GFP_KERNEL);
0454     if (info == NULL)
0455         return -ENOMEM;
0456 
0457     i2c_set_clientdata(client, info);
0458 
0459     np = of_node_get(client->dev.of_node);
0460 
0461     info->id = (enum ltc294x_id) (uintptr_t) of_device_get_match_data(
0462                             &client->dev);
0463     info->supply_desc.name = np->name;
0464 
0465     /* r_sense can be negative, when sense+ is connected to the battery
0466      * instead of the sense-. This results in reversed measurements. */
0467     ret = of_property_read_u32(np, "lltc,resistor-sense", &r_sense);
0468     if (ret < 0)
0469         return dev_err_probe(&client->dev, ret,
0470             "Could not find lltc,resistor-sense in devicetree\n");
0471     info->r_sense = r_sense;
0472 
0473     ret = of_property_read_u32(np, "lltc,prescaler-exponent",
0474         &prescaler_exp);
0475     if (ret < 0) {
0476         dev_warn(&client->dev,
0477             "lltc,prescaler-exponent not in devicetree\n");
0478         prescaler_exp = LTC2941_MAX_PRESCALER_EXP;
0479     }
0480 
0481     if (info->id == LTC2943_ID) {
0482         if (prescaler_exp > LTC2943_MAX_PRESCALER_EXP)
0483             prescaler_exp = LTC2943_MAX_PRESCALER_EXP;
0484         info->Qlsb = ((340 * 50000) / r_sense) >>
0485                  (12 - 2*prescaler_exp);
0486     } else {
0487         if (prescaler_exp > LTC2941_MAX_PRESCALER_EXP)
0488             prescaler_exp = LTC2941_MAX_PRESCALER_EXP;
0489         info->Qlsb = ((85 * 50000) / r_sense) >>
0490                  (7 - prescaler_exp);
0491     }
0492 
0493     /* Read status register to check for LTC2942 */
0494     if (info->id == LTC2941_ID || info->id == LTC2942_ID) {
0495         ret = ltc294x_read_regs(client, LTC294X_REG_STATUS, &status, 1);
0496         if (ret < 0)
0497             return dev_err_probe(&client->dev, ret,
0498                 "Could not read status register\n");
0499         if (status & LTC2941_REG_STATUS_CHIP_ID)
0500             info->id = LTC2941_ID;
0501         else
0502             info->id = LTC2942_ID;
0503     }
0504 
0505     info->client = client;
0506     info->supply_desc.type = POWER_SUPPLY_TYPE_BATTERY;
0507     info->supply_desc.properties = ltc294x_properties;
0508     switch (info->id) {
0509     case LTC2944_ID:
0510     case LTC2943_ID:
0511         info->supply_desc.num_properties =
0512             ARRAY_SIZE(ltc294x_properties);
0513         break;
0514     case LTC2942_ID:
0515         info->supply_desc.num_properties =
0516             ARRAY_SIZE(ltc294x_properties) - 1;
0517         break;
0518     case LTC2941_ID:
0519     default:
0520         info->supply_desc.num_properties =
0521             ARRAY_SIZE(ltc294x_properties) - 3;
0522         break;
0523     }
0524     info->supply_desc.get_property = ltc294x_get_property;
0525     info->supply_desc.set_property = ltc294x_set_property;
0526     info->supply_desc.property_is_writeable = ltc294x_property_is_writeable;
0527     info->supply_desc.external_power_changed    = NULL;
0528 
0529     psy_cfg.drv_data = info;
0530 
0531     ret = devm_delayed_work_autocancel(&client->dev, &info->work,
0532                        ltc294x_work);
0533     if (ret)
0534         return ret;
0535 
0536     ret = ltc294x_reset(info, prescaler_exp);
0537     if (ret < 0)
0538         return dev_err_probe(&client->dev, ret,
0539             "Communication with chip failed\n");
0540 
0541     info->supply = devm_power_supply_register(&client->dev,
0542                           &info->supply_desc, &psy_cfg);
0543     if (IS_ERR(info->supply))
0544         return dev_err_probe(&client->dev, PTR_ERR(info->supply),
0545             "failed to register ltc2941\n");
0546 
0547     schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
0548 
0549     return 0;
0550 }
0551 
0552 static void ltc294x_i2c_shutdown(struct i2c_client *client)
0553 {
0554     struct ltc294x_info *info = i2c_get_clientdata(client);
0555     int ret;
0556     u8 value;
0557     u8 control;
0558 
0559     /* The LTC2941 does not need any special handling */
0560     if (info->id == LTC2941_ID)
0561         return;
0562 
0563     /* Read control register */
0564     ret = ltc294x_read_regs(info->client, LTC294X_REG_CONTROL, &value, 1);
0565     if (ret < 0)
0566         return;
0567 
0568     /* Disable continuous ADC conversion as this drains the battery */
0569     control = LTC294X_REG_CONTROL_ADC_DISABLE(value);
0570     if (control != value)
0571         ltc294x_write_regs(info->client, LTC294X_REG_CONTROL,
0572             &control, 1);
0573 }
0574 
0575 #ifdef CONFIG_PM_SLEEP
0576 
0577 static int ltc294x_suspend(struct device *dev)
0578 {
0579     struct i2c_client *client = to_i2c_client(dev);
0580     struct ltc294x_info *info = i2c_get_clientdata(client);
0581 
0582     cancel_delayed_work(&info->work);
0583     return 0;
0584 }
0585 
0586 static int ltc294x_resume(struct device *dev)
0587 {
0588     struct i2c_client *client = to_i2c_client(dev);
0589     struct ltc294x_info *info = i2c_get_clientdata(client);
0590 
0591     schedule_delayed_work(&info->work, LTC294X_WORK_DELAY * HZ);
0592     return 0;
0593 }
0594 
0595 static SIMPLE_DEV_PM_OPS(ltc294x_pm_ops, ltc294x_suspend, ltc294x_resume);
0596 #define LTC294X_PM_OPS (&ltc294x_pm_ops)
0597 
0598 #else
0599 #define LTC294X_PM_OPS NULL
0600 #endif /* CONFIG_PM_SLEEP */
0601 
0602 
0603 static const struct i2c_device_id ltc294x_i2c_id[] = {
0604     { "ltc2941", LTC2941_ID, },
0605     { "ltc2942", LTC2942_ID, },
0606     { "ltc2943", LTC2943_ID, },
0607     { "ltc2944", LTC2944_ID, },
0608     { },
0609 };
0610 MODULE_DEVICE_TABLE(i2c, ltc294x_i2c_id);
0611 
0612 static const struct of_device_id ltc294x_i2c_of_match[] = {
0613     {
0614         .compatible = "lltc,ltc2941",
0615         .data = (void *)LTC2941_ID,
0616     },
0617     {
0618         .compatible = "lltc,ltc2942",
0619         .data = (void *)LTC2942_ID,
0620     },
0621     {
0622         .compatible = "lltc,ltc2943",
0623         .data = (void *)LTC2943_ID,
0624     },
0625     {
0626         .compatible = "lltc,ltc2944",
0627         .data = (void *)LTC2944_ID,
0628     },
0629     { },
0630 };
0631 MODULE_DEVICE_TABLE(of, ltc294x_i2c_of_match);
0632 
0633 static struct i2c_driver ltc294x_driver = {
0634     .driver = {
0635         .name   = "LTC2941",
0636         .of_match_table = ltc294x_i2c_of_match,
0637         .pm = LTC294X_PM_OPS,
0638     },
0639     .probe      = ltc294x_i2c_probe,
0640     .shutdown   = ltc294x_i2c_shutdown,
0641     .id_table   = ltc294x_i2c_id,
0642 };
0643 module_i2c_driver(ltc294x_driver);
0644 
0645 MODULE_AUTHOR("Auryn Verwegen, Topic Embedded Systems");
0646 MODULE_AUTHOR("Mike Looijmans, Topic Embedded Products");
0647 MODULE_DESCRIPTION("LTC2941/LTC2942/LTC2943/LTC2944 Battery Gas Gauge IC driver");
0648 MODULE_LICENSE("GPL");
[ 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!