Version:  2.0.40 2.2.26 2.4.37 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2

Linux/drivers/power/bq24735-charger.c

  1 /*
  2  * Battery charger driver for TI BQ24735
  3  *
  4  * Copyright (c) 2013, NVIDIA CORPORATION.  All rights reserved.
  5  *
  6  * This program is free software; you can redistribute it and/or modify
  7  * it under the terms of the GNU General Public License as published by
  8  * the Free Software Foundation;
  9  *
 10  * This program is distributed in the hope that it will be useful, but WITHOUT
 11  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 12  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
 13  * more details.
 14  *
 15  * You should have received a copy of the GNU General Public License along
 16  * with this program; if not, write to the Free Software Foundation, Inc.,
 17  * 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 18  */
 19 
 20 #include <linux/err.h>
 21 #include <linux/gpio.h>
 22 #include <linux/i2c.h>
 23 #include <linux/init.h>
 24 #include <linux/interrupt.h>
 25 #include <linux/kernel.h>
 26 #include <linux/module.h>
 27 #include <linux/of.h>
 28 #include <linux/of_gpio.h>
 29 #include <linux/power_supply.h>
 30 #include <linux/slab.h>
 31 
 32 #include <linux/power/bq24735-charger.h>
 33 
 34 #define BQ24735_CHG_OPT                 0x12
 35 #define BQ24735_CHG_OPT_CHARGE_DISABLE  (1 << 0)
 36 #define BQ24735_CHG_OPT_AC_PRESENT      (1 << 4)
 37 #define BQ24735_CHARGE_CURRENT          0x14
 38 #define BQ24735_CHARGE_CURRENT_MASK     0x1fc0
 39 #define BQ24735_CHARGE_VOLTAGE          0x15
 40 #define BQ24735_CHARGE_VOLTAGE_MASK     0x7ff0
 41 #define BQ24735_INPUT_CURRENT           0x3f
 42 #define BQ24735_INPUT_CURRENT_MASK      0x1f80
 43 #define BQ24735_MANUFACTURER_ID         0xfe
 44 #define BQ24735_DEVICE_ID               0xff
 45 
 46 struct bq24735 {
 47         struct power_supply             *charger;
 48         struct power_supply_desc        charger_desc;
 49         struct i2c_client               *client;
 50         struct bq24735_platform         *pdata;
 51 };
 52 
 53 static inline struct bq24735 *to_bq24735(struct power_supply *psy)
 54 {
 55         return power_supply_get_drvdata(psy);
 56 }
 57 
 58 static enum power_supply_property bq24735_charger_properties[] = {
 59         POWER_SUPPLY_PROP_ONLINE,
 60 };
 61 
 62 static inline int bq24735_write_word(struct i2c_client *client, u8 reg,
 63                                      u16 value)
 64 {
 65         return i2c_smbus_write_word_data(client, reg, le16_to_cpu(value));
 66 }
 67 
 68 static inline int bq24735_read_word(struct i2c_client *client, u8 reg)
 69 {
 70         s32 ret = i2c_smbus_read_word_data(client, reg);
 71 
 72         return ret < 0 ? ret : le16_to_cpu(ret);
 73 }
 74 
 75 static int bq24735_update_word(struct i2c_client *client, u8 reg,
 76                                u16 mask, u16 value)
 77 {
 78         unsigned int tmp;
 79         int ret;
 80 
 81         ret = bq24735_read_word(client, reg);
 82         if (ret < 0)
 83                 return ret;
 84 
 85         tmp = ret & ~mask;
 86         tmp |= value & mask;
 87 
 88         return bq24735_write_word(client, reg, tmp);
 89 }
 90 
 91 static inline int bq24735_enable_charging(struct bq24735 *charger)
 92 {
 93         return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
 94                                    BQ24735_CHG_OPT_CHARGE_DISABLE,
 95                                    ~BQ24735_CHG_OPT_CHARGE_DISABLE);
 96 }
 97 
 98 static inline int bq24735_disable_charging(struct bq24735 *charger)
 99 {
100         return bq24735_update_word(charger->client, BQ24735_CHG_OPT,
101                                    BQ24735_CHG_OPT_CHARGE_DISABLE,
102                                    BQ24735_CHG_OPT_CHARGE_DISABLE);
103 }
104 
105 static int bq24735_config_charger(struct bq24735 *charger)
106 {
107         struct bq24735_platform *pdata = charger->pdata;
108         int ret;
109         u16 value;
110 
111         if (pdata->charge_current) {
112                 value = pdata->charge_current & BQ24735_CHARGE_CURRENT_MASK;
113 
114                 ret = bq24735_write_word(charger->client,
115                                          BQ24735_CHARGE_CURRENT, value);
116                 if (ret < 0) {
117                         dev_err(&charger->client->dev,
118                                 "Failed to write charger current : %d\n",
119                                 ret);
120                         return ret;
121                 }
122         }
123 
124         if (pdata->charge_voltage) {
125                 value = pdata->charge_voltage & BQ24735_CHARGE_VOLTAGE_MASK;
126 
127                 ret = bq24735_write_word(charger->client,
128                                          BQ24735_CHARGE_VOLTAGE, value);
129                 if (ret < 0) {
130                         dev_err(&charger->client->dev,
131                                 "Failed to write charger voltage : %d\n",
132                                 ret);
133                         return ret;
134                 }
135         }
136 
137         if (pdata->input_current) {
138                 value = pdata->input_current & BQ24735_INPUT_CURRENT_MASK;
139 
140                 ret = bq24735_write_word(charger->client,
141                                          BQ24735_INPUT_CURRENT, value);
142                 if (ret < 0) {
143                         dev_err(&charger->client->dev,
144                                 "Failed to write input current : %d\n",
145                                 ret);
146                         return ret;
147                 }
148         }
149 
150         return 0;
151 }
152 
153 static bool bq24735_charger_is_present(struct bq24735 *charger)
154 {
155         struct bq24735_platform *pdata = charger->pdata;
156         int ret;
157 
158         if (pdata->status_gpio_valid) {
159                 ret = gpio_get_value_cansleep(pdata->status_gpio);
160                 return ret ^= pdata->status_gpio_active_low == 0;
161         } else {
162                 int ac = 0;
163 
164                 ac = bq24735_read_word(charger->client, BQ24735_CHG_OPT);
165                 if (ac < 0) {
166                         dev_err(&charger->client->dev,
167                                 "Failed to read charger options : %d\n",
168                                 ac);
169                         return false;
170                 }
171                 return (ac & BQ24735_CHG_OPT_AC_PRESENT) ? true : false;
172         }
173 
174         return false;
175 }
176 
177 static irqreturn_t bq24735_charger_isr(int irq, void *devid)
178 {
179         struct power_supply *psy = devid;
180         struct bq24735 *charger = to_bq24735(psy);
181 
182         if (bq24735_charger_is_present(charger))
183                 bq24735_enable_charging(charger);
184         else
185                 bq24735_disable_charging(charger);
186 
187         power_supply_changed(psy);
188 
189         return IRQ_HANDLED;
190 }
191 
192 static int bq24735_charger_get_property(struct power_supply *psy,
193                                         enum power_supply_property psp,
194                                         union power_supply_propval *val)
195 {
196         struct bq24735 *charger = to_bq24735(psy);
197 
198         switch (psp) {
199         case POWER_SUPPLY_PROP_ONLINE:
200                 val->intval = bq24735_charger_is_present(charger) ? 1 : 0;
201                 break;
202         default:
203                 return -EINVAL;
204         }
205 
206         return 0;
207 }
208 
209 static struct bq24735_platform *bq24735_parse_dt_data(struct i2c_client *client)
210 {
211         struct bq24735_platform *pdata;
212         struct device_node *np = client->dev.of_node;
213         u32 val;
214         int ret;
215         enum of_gpio_flags flags;
216 
217         pdata = devm_kzalloc(&client->dev, sizeof(*pdata), GFP_KERNEL);
218         if (!pdata) {
219                 dev_err(&client->dev,
220                         "Memory alloc for bq24735 pdata failed\n");
221                 return NULL;
222         }
223 
224         pdata->status_gpio = of_get_named_gpio_flags(np, "ti,ac-detect-gpios",
225                                                      0, &flags);
226 
227         if (flags & OF_GPIO_ACTIVE_LOW)
228                 pdata->status_gpio_active_low = 1;
229 
230         ret = of_property_read_u32(np, "ti,charge-current", &val);
231         if (!ret)
232                 pdata->charge_current = val;
233 
234         ret = of_property_read_u32(np, "ti,charge-voltage", &val);
235         if (!ret)
236                 pdata->charge_voltage = val;
237 
238         ret = of_property_read_u32(np, "ti,input-current", &val);
239         if (!ret)
240                 pdata->input_current = val;
241 
242         return pdata;
243 }
244 
245 static int bq24735_charger_probe(struct i2c_client *client,
246                                  const struct i2c_device_id *id)
247 {
248         int ret;
249         struct bq24735 *charger;
250         struct power_supply_desc *supply_desc;
251         struct power_supply_config psy_cfg = {};
252         char *name;
253 
254         charger = devm_kzalloc(&client->dev, sizeof(*charger), GFP_KERNEL);
255         if (!charger)
256                 return -ENOMEM;
257 
258         charger->pdata = client->dev.platform_data;
259 
260         if (IS_ENABLED(CONFIG_OF) && !charger->pdata && client->dev.of_node)
261                 charger->pdata = bq24735_parse_dt_data(client);
262 
263         if (!charger->pdata) {
264                 dev_err(&client->dev, "no platform data provided\n");
265                 return -EINVAL;
266         }
267 
268         name = (char *)charger->pdata->name;
269         if (!name) {
270                 name = kasprintf(GFP_KERNEL, "bq24735@%s",
271                                  dev_name(&client->dev));
272                 if (!name) {
273                         dev_err(&client->dev, "Failed to alloc device name\n");
274                         return -ENOMEM;
275                 }
276         }
277 
278         charger->client = client;
279 
280         supply_desc = &charger->charger_desc;
281 
282         supply_desc->name = name;
283         supply_desc->type = POWER_SUPPLY_TYPE_MAINS;
284         supply_desc->properties = bq24735_charger_properties;
285         supply_desc->num_properties = ARRAY_SIZE(bq24735_charger_properties);
286         supply_desc->get_property = bq24735_charger_get_property;
287 
288         psy_cfg.supplied_to = charger->pdata->supplied_to;
289         psy_cfg.num_supplicants = charger->pdata->num_supplicants;
290         psy_cfg.of_node = client->dev.of_node;
291         psy_cfg.drv_data = charger;
292 
293         i2c_set_clientdata(client, charger);
294 
295         ret = bq24735_read_word(client, BQ24735_MANUFACTURER_ID);
296         if (ret < 0) {
297                 dev_err(&client->dev, "Failed to read manufacturer id : %d\n",
298                         ret);
299                 goto err_free_name;
300         } else if (ret != 0x0040) {
301                 dev_err(&client->dev,
302                         "manufacturer id mismatch. 0x0040 != 0x%04x\n", ret);
303                 ret = -ENODEV;
304                 goto err_free_name;
305         }
306 
307         ret = bq24735_read_word(client, BQ24735_DEVICE_ID);
308         if (ret < 0) {
309                 dev_err(&client->dev, "Failed to read device id : %d\n", ret);
310                 goto err_free_name;
311         } else if (ret != 0x000B) {
312                 dev_err(&client->dev,
313                         "device id mismatch. 0x000b != 0x%04x\n", ret);
314                 ret = -ENODEV;
315                 goto err_free_name;
316         }
317 
318         if (gpio_is_valid(charger->pdata->status_gpio)) {
319                 ret = devm_gpio_request(&client->dev,
320                                         charger->pdata->status_gpio,
321                                         name);
322                 if (ret) {
323                         dev_err(&client->dev,
324                                 "Failed GPIO request for GPIO %d: %d\n",
325                                 charger->pdata->status_gpio, ret);
326                 }
327 
328                 charger->pdata->status_gpio_valid = !ret;
329         }
330 
331         ret = bq24735_config_charger(charger);
332         if (ret < 0) {
333                 dev_err(&client->dev, "failed in configuring charger");
334                 goto err_free_name;
335         }
336 
337         /* check for AC adapter presence */
338         if (bq24735_charger_is_present(charger)) {
339                 ret = bq24735_enable_charging(charger);
340                 if (ret < 0) {
341                         dev_err(&client->dev, "Failed to enable charging\n");
342                         goto err_free_name;
343                 }
344         }
345 
346         charger->charger = power_supply_register(&client->dev, supply_desc,
347                                                  &psy_cfg);
348         if (IS_ERR(charger->charger)) {
349                 ret = PTR_ERR(charger->charger);
350                 dev_err(&client->dev, "Failed to register power supply: %d\n",
351                         ret);
352                 goto err_free_name;
353         }
354 
355         if (client->irq) {
356                 ret = devm_request_threaded_irq(&client->dev, client->irq,
357                                                 NULL, bq24735_charger_isr,
358                                                 IRQF_TRIGGER_RISING |
359                                                 IRQF_TRIGGER_FALLING |
360                                                 IRQF_ONESHOT,
361                                                 supply_desc->name,
362                                                 charger->charger);
363                 if (ret) {
364                         dev_err(&client->dev,
365                                 "Unable to register IRQ %d err %d\n",
366                                 client->irq, ret);
367                         goto err_unregister_supply;
368                 }
369         }
370 
371         return 0;
372 err_unregister_supply:
373         power_supply_unregister(charger->charger);
374 err_free_name:
375         if (name != charger->pdata->name)
376                 kfree(name);
377 
378         return ret;
379 }
380 
381 static int bq24735_charger_remove(struct i2c_client *client)
382 {
383         struct bq24735 *charger = i2c_get_clientdata(client);
384 
385         if (charger->client->irq)
386                 devm_free_irq(&charger->client->dev, charger->client->irq,
387                               &charger->charger);
388 
389         power_supply_unregister(charger->charger);
390 
391         if (charger->charger_desc.name != charger->pdata->name)
392                 kfree(charger->charger_desc.name);
393 
394         return 0;
395 }
396 
397 static const struct i2c_device_id bq24735_charger_id[] = {
398         { "bq24735-charger", 0 },
399         {}
400 };
401 MODULE_DEVICE_TABLE(i2c, bq24735_charger_id);
402 
403 static const struct of_device_id bq24735_match_ids[] = {
404         { .compatible = "ti,bq24735", },
405         { /* end */ }
406 };
407 MODULE_DEVICE_TABLE(of, bq24735_match_ids);
408 
409 static struct i2c_driver bq24735_charger_driver = {
410         .driver = {
411                 .name = "bq24735-charger",
412                 .owner = THIS_MODULE,
413                 .of_match_table = bq24735_match_ids,
414         },
415         .probe = bq24735_charger_probe,
416         .remove = bq24735_charger_remove,
417         .id_table = bq24735_charger_id,
418 };
419 
420 module_i2c_driver(bq24735_charger_driver);
421 
422 MODULE_DESCRIPTION("bq24735 battery charging driver");
423 MODULE_AUTHOR("Darbha Sriharsha <dsriharsha@nvidia.com>");
424 MODULE_LICENSE("GPL v2");
425 

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