2 * BQ27xxx battery monitor I2C driver
4 * Copyright (C) 2015 Texas Instruments Incorporated - http://www.ti.com/
5 * Andrew F. Davis <afd@ti.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
11 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
12 * kind, whether express or implied; without even the implied warranty
13 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
17 #include <linux/i2c.h>
18 #include <linux/interrupt.h>
19 #include <linux/module.h>
20 #include <asm/unaligned.h>
22 #include <linux/power/bq27xxx_battery.h>
24 static DEFINE_IDR(battery_id);
25 static DEFINE_MUTEX(battery_mutex);
27 static irqreturn_t bq27xxx_battery_irq_handler_thread(int irq, void *data)
29 struct bq27xxx_device_info *di = data;
31 bq27xxx_battery_update(di);
36 static int bq27xxx_battery_i2c_read(struct bq27xxx_device_info *di, u8 reg,
39 struct i2c_client *client = to_i2c_client(di->dev);
40 struct i2c_msg msg[2];
47 msg[0].addr = client->addr;
50 msg[0].len = sizeof(reg);
51 msg[1].addr = client->addr;
52 msg[1].flags = I2C_M_RD;
59 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
64 ret = get_unaligned_le16(data);
71 static int bq27xxx_battery_i2c_write(struct bq27xxx_device_info *di, u8 reg,
72 int value, bool single)
74 struct i2c_client *client = to_i2c_client(di->dev);
87 put_unaligned_le16(value, &data[1]);
92 msg.addr = client->addr;
95 ret = i2c_transfer(client->adapter, &msg, 1);
103 static int bq27xxx_battery_i2c_bulk_read(struct bq27xxx_device_info *di, u8 reg,
106 struct i2c_client *client = to_i2c_client(di->dev);
109 if (!client->adapter)
112 ret = i2c_smbus_read_i2c_block_data(client, reg, len, data);
120 static int bq27xxx_battery_i2c_bulk_write(struct bq27xxx_device_info *di,
121 u8 reg, u8 *data, int len)
123 struct i2c_client *client = to_i2c_client(di->dev);
128 if (!client->adapter)
132 memcpy(&buf[1], data, len);
135 msg.addr = client->addr;
139 ret = i2c_transfer(client->adapter, &msg, 1);
147 static int bq27xxx_battery_i2c_probe(struct i2c_client *client,
148 const struct i2c_device_id *id)
150 struct bq27xxx_device_info *di;
155 /* Get new ID for the new battery device */
156 mutex_lock(&battery_mutex);
157 num = idr_alloc(&battery_id, client, 0, 0, GFP_KERNEL);
158 mutex_unlock(&battery_mutex);
162 name = devm_kasprintf(&client->dev, GFP_KERNEL, "%s-%d", id->name, num);
166 di = devm_kzalloc(&client->dev, sizeof(*di), GFP_KERNEL);
171 di->dev = &client->dev;
172 di->chip = id->driver_data;
175 di->bus.read = bq27xxx_battery_i2c_read;
176 di->bus.write = bq27xxx_battery_i2c_write;
177 di->bus.read_bulk = bq27xxx_battery_i2c_bulk_read;
178 di->bus.write_bulk = bq27xxx_battery_i2c_bulk_write;
180 ret = bq27xxx_battery_setup(di);
184 /* Schedule a polling after about 1 min */
185 schedule_delayed_work(&di->work, 60 * HZ);
187 i2c_set_clientdata(client, di);
190 ret = request_threaded_irq(client->irq,
191 NULL, bq27xxx_battery_irq_handler_thread,
195 dev_err(&client->dev,
196 "Unable to register IRQ %d error %d\n",
198 bq27xxx_battery_teardown(di);
209 mutex_lock(&battery_mutex);
210 idr_remove(&battery_id, num);
211 mutex_unlock(&battery_mutex);
216 static int bq27xxx_battery_i2c_remove(struct i2c_client *client)
218 struct bq27xxx_device_info *di = i2c_get_clientdata(client);
220 free_irq(client->irq, di);
221 bq27xxx_battery_teardown(di);
223 mutex_lock(&battery_mutex);
224 idr_remove(&battery_id, di->id);
225 mutex_unlock(&battery_mutex);
230 static const struct i2c_device_id bq27xxx_i2c_id_table[] = {
231 { "bq27200", BQ27000 },
232 { "bq27210", BQ27010 },
233 { "bq27500", BQ2750X },
234 { "bq27510", BQ2751X },
235 { "bq27520", BQ2752X },
236 { "bq27500-1", BQ27500 },
237 { "bq27510g1", BQ27510G1 },
238 { "bq27510g2", BQ27510G2 },
239 { "bq27510g3", BQ27510G3 },
240 { "bq27520g1", BQ27520G1 },
241 { "bq27520g2", BQ27520G2 },
242 { "bq27520g3", BQ27520G3 },
243 { "bq27520g4", BQ27520G4 },
244 { "bq27530", BQ27530 },
245 { "bq27531", BQ27531 },
246 { "bq27541", BQ27541 },
247 { "bq27542", BQ27542 },
248 { "bq27546", BQ27546 },
249 { "bq27742", BQ27742 },
250 { "bq27545", BQ27545 },
251 { "bq27421", BQ27421 },
252 { "bq27425", BQ27425 },
253 { "bq27441", BQ27441 },
254 { "bq27621", BQ27621 },
257 MODULE_DEVICE_TABLE(i2c, bq27xxx_i2c_id_table);
260 static const struct of_device_id bq27xxx_battery_i2c_of_match_table[] = {
261 { .compatible = "ti,bq27200" },
262 { .compatible = "ti,bq27210" },
263 { .compatible = "ti,bq27500" },
264 { .compatible = "ti,bq27510" },
265 { .compatible = "ti,bq27520" },
266 { .compatible = "ti,bq27500-1" },
267 { .compatible = "ti,bq27510g1" },
268 { .compatible = "ti,bq27510g2" },
269 { .compatible = "ti,bq27510g3" },
270 { .compatible = "ti,bq27520g1" },
271 { .compatible = "ti,bq27520g2" },
272 { .compatible = "ti,bq27520g3" },
273 { .compatible = "ti,bq27520g4" },
274 { .compatible = "ti,bq27530" },
275 { .compatible = "ti,bq27531" },
276 { .compatible = "ti,bq27541" },
277 { .compatible = "ti,bq27542" },
278 { .compatible = "ti,bq27546" },
279 { .compatible = "ti,bq27742" },
280 { .compatible = "ti,bq27545" },
281 { .compatible = "ti,bq27421" },
282 { .compatible = "ti,bq27425" },
283 { .compatible = "ti,bq27441" },
284 { .compatible = "ti,bq27621" },
287 MODULE_DEVICE_TABLE(of, bq27xxx_battery_i2c_of_match_table);
290 static struct i2c_driver bq27xxx_battery_i2c_driver = {
292 .name = "bq27xxx-battery",
293 .of_match_table = of_match_ptr(bq27xxx_battery_i2c_of_match_table),
295 .probe = bq27xxx_battery_i2c_probe,
296 .remove = bq27xxx_battery_i2c_remove,
297 .id_table = bq27xxx_i2c_id_table,
299 module_i2c_driver(bq27xxx_battery_i2c_driver);
301 MODULE_AUTHOR("Andrew F. Davis <afd@ti.com>");
302 MODULE_DESCRIPTION("BQ27xxx battery monitor i2c driver");
303 MODULE_LICENSE("GPL");