1 /* 2 * BQ27xxx battery driver 3 * 4 * Copyright (C) 2008 Rodolfo Giometti <giometti@linux.it> 5 * Copyright (C) 2008 Eurotech S.p.A. <info@eurotech.it> 6 * Copyright (C) 2010-2011 Lars-Peter Clausen <lars@metafoo.de> 7 * Copyright (C) 2011 Pali Rohár <pali.rohar@gmail.com> 8 * 9 * Based on a previous work by Copyright (C) 2008 Texas Instruments, Inc. 10 * 11 * This package is free software; you can redistribute it and/or modify 12 * it under the terms of the GNU General Public License version 2 as 13 * published by the Free Software Foundation. 14 * 15 * THIS PACKAGE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED 17 * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE. 18 * 19 * Datasheets: 20 * http://www.ti.com/product/bq27000 21 * http://www.ti.com/product/bq27200 22 * http://www.ti.com/product/bq27010 23 * http://www.ti.com/product/bq27210 24 * http://www.ti.com/product/bq27500 25 * http://www.ti.com/product/bq27510-g3 26 * http://www.ti.com/product/bq27520-g4 27 * http://www.ti.com/product/bq27530-g1 28 * http://www.ti.com/product/bq27531-g1 29 * http://www.ti.com/product/bq27541-g1 30 * http://www.ti.com/product/bq27542-g1 31 * http://www.ti.com/product/bq27546-g1 32 * http://www.ti.com/product/bq27742-g1 33 * http://www.ti.com/product/bq27545-g1 34 * http://www.ti.com/product/bq27421-g1 35 * http://www.ti.com/product/bq27425-g1 36 * http://www.ti.com/product/bq27411-g1 37 * http://www.ti.com/product/bq27621-g1 38 */ 39 40 #include <linux/device.h> 41 #include <linux/module.h> 42 #include <linux/mutex.h> 43 #include <linux/param.h> 44 #include <linux/jiffies.h> 45 #include <linux/workqueue.h> 46 #include <linux/delay.h> 47 #include <linux/platform_device.h> 48 #include <linux/power_supply.h> 49 #include <linux/slab.h> 50 #include <linux/of.h> 51 52 #include <linux/power/bq27xxx_battery.h> 53 54 #define DRIVER_VERSION "1.2.0" 55 56 #define BQ27XXX_MANUFACTURER "Texas Instruments" 57 58 /* BQ27XXX Flags */ 59 #define BQ27XXX_FLAG_DSC BIT(0) 60 #define BQ27XXX_FLAG_SOCF BIT(1) /* State-of-Charge threshold final */ 61 #define BQ27XXX_FLAG_SOC1 BIT(2) /* State-of-Charge threshold 1 */ 62 #define BQ27XXX_FLAG_FC BIT(9) 63 #define BQ27XXX_FLAG_OTD BIT(14) 64 #define BQ27XXX_FLAG_OTC BIT(15) 65 #define BQ27XXX_FLAG_UT BIT(14) 66 #define BQ27XXX_FLAG_OT BIT(15) 67 68 /* BQ27000 has different layout for Flags register */ 69 #define BQ27000_FLAG_EDVF BIT(0) /* Final End-of-Discharge-Voltage flag */ 70 #define BQ27000_FLAG_EDV1 BIT(1) /* First End-of-Discharge-Voltage flag */ 71 #define BQ27000_FLAG_CI BIT(4) /* Capacity Inaccurate flag */ 72 #define BQ27000_FLAG_FC BIT(5) 73 #define BQ27000_FLAG_CHGS BIT(7) /* Charge state flag */ 74 75 #define BQ27XXX_RS (20) /* Resistor sense mOhm */ 76 #define BQ27XXX_POWER_CONSTANT (29200) /* 29.2 µV^2 * 1000 */ 77 #define BQ27XXX_CURRENT_CONSTANT (3570) /* 3.57 µV * 1000 */ 78 79 #define INVALID_REG_ADDR 0xff 80 81 /* 82 * bq27xxx_reg_index - Register names 83 * 84 * These are indexes into a device's register mapping array. 85 */ 86 87 enum bq27xxx_reg_index { 88 BQ27XXX_REG_CTRL = 0, /* Control */ 89 BQ27XXX_REG_TEMP, /* Temperature */ 90 BQ27XXX_REG_INT_TEMP, /* Internal Temperature */ 91 BQ27XXX_REG_VOLT, /* Voltage */ 92 BQ27XXX_REG_AI, /* Average Current */ 93 BQ27XXX_REG_FLAGS, /* Flags */ 94 BQ27XXX_REG_TTE, /* Time-to-Empty */ 95 BQ27XXX_REG_TTF, /* Time-to-Full */ 96 BQ27XXX_REG_TTES, /* Time-to-Empty Standby */ 97 BQ27XXX_REG_TTECP, /* Time-to-Empty at Constant Power */ 98 BQ27XXX_REG_NAC, /* Nominal Available Capacity */ 99 BQ27XXX_REG_FCC, /* Full Charge Capacity */ 100 BQ27XXX_REG_CYCT, /* Cycle Count */ 101 BQ27XXX_REG_AE, /* Available Energy */ 102 BQ27XXX_REG_SOC, /* State-of-Charge */ 103 BQ27XXX_REG_DCAP, /* Design Capacity */ 104 BQ27XXX_REG_AP, /* Average Power */ 105 BQ27XXX_REG_MAX, /* sentinel */ 106 }; 107 108 /* Register mappings */ 109 static u8 bq27xxx_regs[][BQ27XXX_REG_MAX] = { 110 [BQ27000] = { 111 [BQ27XXX_REG_CTRL] = 0x00, 112 [BQ27XXX_REG_TEMP] = 0x06, 113 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR, 114 [BQ27XXX_REG_VOLT] = 0x08, 115 [BQ27XXX_REG_AI] = 0x14, 116 [BQ27XXX_REG_FLAGS] = 0x0a, 117 [BQ27XXX_REG_TTE] = 0x16, 118 [BQ27XXX_REG_TTF] = 0x18, 119 [BQ27XXX_REG_TTES] = 0x1c, 120 [BQ27XXX_REG_TTECP] = 0x26, 121 [BQ27XXX_REG_NAC] = 0x0c, 122 [BQ27XXX_REG_FCC] = 0x12, 123 [BQ27XXX_REG_CYCT] = 0x2a, 124 [BQ27XXX_REG_AE] = 0x22, 125 [BQ27XXX_REG_SOC] = 0x0b, 126 [BQ27XXX_REG_DCAP] = 0x76, 127 [BQ27XXX_REG_AP] = 0x24, 128 }, 129 [BQ27010] = { 130 [BQ27XXX_REG_CTRL] = 0x00, 131 [BQ27XXX_REG_TEMP] = 0x06, 132 [BQ27XXX_REG_INT_TEMP] = INVALID_REG_ADDR, 133 [BQ27XXX_REG_VOLT] = 0x08, 134 [BQ27XXX_REG_AI] = 0x14, 135 [BQ27XXX_REG_FLAGS] = 0x0a, 136 [BQ27XXX_REG_TTE] = 0x16, 137 [BQ27XXX_REG_TTF] = 0x18, 138 [BQ27XXX_REG_TTES] = 0x1c, 139 [BQ27XXX_REG_TTECP] = 0x26, 140 [BQ27XXX_REG_NAC] = 0x0c, 141 [BQ27XXX_REG_FCC] = 0x12, 142 [BQ27XXX_REG_CYCT] = 0x2a, 143 [BQ27XXX_REG_AE] = INVALID_REG_ADDR, 144 [BQ27XXX_REG_SOC] = 0x0b, 145 [BQ27XXX_REG_DCAP] = 0x76, 146 [BQ27XXX_REG_AP] = INVALID_REG_ADDR, 147 }, 148 [BQ27500] = { 149 [BQ27XXX_REG_CTRL] = 0x00, 150 [BQ27XXX_REG_TEMP] = 0x06, 151 [BQ27XXX_REG_INT_TEMP] = 0x28, 152 [BQ27XXX_REG_VOLT] = 0x08, 153 [BQ27XXX_REG_AI] = 0x14, 154 [BQ27XXX_REG_FLAGS] = 0x0a, 155 [BQ27XXX_REG_TTE] = 0x16, 156 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR, 157 [BQ27XXX_REG_TTES] = 0x1a, 158 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR, 159 [BQ27XXX_REG_NAC] = 0x0c, 160 [BQ27XXX_REG_FCC] = 0x12, 161 [BQ27XXX_REG_CYCT] = 0x2a, 162 [BQ27XXX_REG_AE] = INVALID_REG_ADDR, 163 [BQ27XXX_REG_SOC] = 0x2c, 164 [BQ27XXX_REG_DCAP] = 0x3c, 165 [BQ27XXX_REG_AP] = INVALID_REG_ADDR, 166 }, 167 [BQ27530] = { 168 [BQ27XXX_REG_CTRL] = 0x00, 169 [BQ27XXX_REG_TEMP] = 0x06, 170 [BQ27XXX_REG_INT_TEMP] = 0x32, 171 [BQ27XXX_REG_VOLT] = 0x08, 172 [BQ27XXX_REG_AI] = 0x14, 173 [BQ27XXX_REG_FLAGS] = 0x0a, 174 [BQ27XXX_REG_TTE] = 0x16, 175 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR, 176 [BQ27XXX_REG_TTES] = INVALID_REG_ADDR, 177 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR, 178 [BQ27XXX_REG_NAC] = 0x0c, 179 [BQ27XXX_REG_FCC] = 0x12, 180 [BQ27XXX_REG_CYCT] = 0x2a, 181 [BQ27XXX_REG_AE] = INVALID_REG_ADDR, 182 [BQ27XXX_REG_SOC] = 0x2c, 183 [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR, 184 [BQ27XXX_REG_AP] = 0x24, 185 }, 186 [BQ27541] = { 187 [BQ27XXX_REG_CTRL] = 0x00, 188 [BQ27XXX_REG_TEMP] = 0x06, 189 [BQ27XXX_REG_INT_TEMP] = 0x28, 190 [BQ27XXX_REG_VOLT] = 0x08, 191 [BQ27XXX_REG_AI] = 0x14, 192 [BQ27XXX_REG_FLAGS] = 0x0a, 193 [BQ27XXX_REG_TTE] = 0x16, 194 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR, 195 [BQ27XXX_REG_TTES] = INVALID_REG_ADDR, 196 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR, 197 [BQ27XXX_REG_NAC] = 0x0c, 198 [BQ27XXX_REG_FCC] = 0x12, 199 [BQ27XXX_REG_CYCT] = 0x2a, 200 [BQ27XXX_REG_AE] = INVALID_REG_ADDR, 201 [BQ27XXX_REG_SOC] = 0x2c, 202 [BQ27XXX_REG_DCAP] = 0x3c, 203 [BQ27XXX_REG_AP] = 0x24, 204 }, 205 [BQ27545] = { 206 [BQ27XXX_REG_CTRL] = 0x00, 207 [BQ27XXX_REG_TEMP] = 0x06, 208 [BQ27XXX_REG_INT_TEMP] = 0x28, 209 [BQ27XXX_REG_VOLT] = 0x08, 210 [BQ27XXX_REG_AI] = 0x14, 211 [BQ27XXX_REG_FLAGS] = 0x0a, 212 [BQ27XXX_REG_TTE] = 0x16, 213 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR, 214 [BQ27XXX_REG_TTES] = INVALID_REG_ADDR, 215 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR, 216 [BQ27XXX_REG_NAC] = 0x0c, 217 [BQ27XXX_REG_FCC] = 0x12, 218 [BQ27XXX_REG_CYCT] = 0x2a, 219 [BQ27XXX_REG_AE] = INVALID_REG_ADDR, 220 [BQ27XXX_REG_SOC] = 0x2c, 221 [BQ27XXX_REG_DCAP] = INVALID_REG_ADDR, 222 [BQ27XXX_REG_AP] = 0x24, 223 }, 224 [BQ27421] = { 225 [BQ27XXX_REG_CTRL] = 0x00, 226 [BQ27XXX_REG_TEMP] = 0x02, 227 [BQ27XXX_REG_INT_TEMP] = 0x1e, 228 [BQ27XXX_REG_VOLT] = 0x04, 229 [BQ27XXX_REG_AI] = 0x10, 230 [BQ27XXX_REG_FLAGS] = 0x06, 231 [BQ27XXX_REG_TTE] = INVALID_REG_ADDR, 232 [BQ27XXX_REG_TTF] = INVALID_REG_ADDR, 233 [BQ27XXX_REG_TTES] = INVALID_REG_ADDR, 234 [BQ27XXX_REG_TTECP] = INVALID_REG_ADDR, 235 [BQ27XXX_REG_NAC] = 0x08, 236 [BQ27XXX_REG_FCC] = 0x0e, 237 [BQ27XXX_REG_CYCT] = INVALID_REG_ADDR, 238 [BQ27XXX_REG_AE] = INVALID_REG_ADDR, 239 [BQ27XXX_REG_SOC] = 0x1c, 240 [BQ27XXX_REG_DCAP] = 0x3c, 241 [BQ27XXX_REG_AP] = 0x18, 242 }, 243 }; 244 245 static enum power_supply_property bq27000_battery_props[] = { 246 POWER_SUPPLY_PROP_STATUS, 247 POWER_SUPPLY_PROP_PRESENT, 248 POWER_SUPPLY_PROP_VOLTAGE_NOW, 249 POWER_SUPPLY_PROP_CURRENT_NOW, 250 POWER_SUPPLY_PROP_CAPACITY, 251 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 252 POWER_SUPPLY_PROP_TEMP, 253 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 254 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 255 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, 256 POWER_SUPPLY_PROP_TECHNOLOGY, 257 POWER_SUPPLY_PROP_CHARGE_FULL, 258 POWER_SUPPLY_PROP_CHARGE_NOW, 259 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 260 POWER_SUPPLY_PROP_CYCLE_COUNT, 261 POWER_SUPPLY_PROP_ENERGY_NOW, 262 POWER_SUPPLY_PROP_POWER_AVG, 263 POWER_SUPPLY_PROP_HEALTH, 264 POWER_SUPPLY_PROP_MANUFACTURER, 265 }; 266 267 static enum power_supply_property bq27010_battery_props[] = { 268 POWER_SUPPLY_PROP_STATUS, 269 POWER_SUPPLY_PROP_PRESENT, 270 POWER_SUPPLY_PROP_VOLTAGE_NOW, 271 POWER_SUPPLY_PROP_CURRENT_NOW, 272 POWER_SUPPLY_PROP_CAPACITY, 273 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 274 POWER_SUPPLY_PROP_TEMP, 275 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 276 POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG, 277 POWER_SUPPLY_PROP_TIME_TO_FULL_NOW, 278 POWER_SUPPLY_PROP_TECHNOLOGY, 279 POWER_SUPPLY_PROP_CHARGE_FULL, 280 POWER_SUPPLY_PROP_CHARGE_NOW, 281 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 282 POWER_SUPPLY_PROP_CYCLE_COUNT, 283 POWER_SUPPLY_PROP_HEALTH, 284 POWER_SUPPLY_PROP_MANUFACTURER, 285 }; 286 287 static enum power_supply_property bq27500_battery_props[] = { 288 POWER_SUPPLY_PROP_STATUS, 289 POWER_SUPPLY_PROP_PRESENT, 290 POWER_SUPPLY_PROP_VOLTAGE_NOW, 291 POWER_SUPPLY_PROP_CURRENT_NOW, 292 POWER_SUPPLY_PROP_CAPACITY, 293 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 294 POWER_SUPPLY_PROP_TEMP, 295 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 296 POWER_SUPPLY_PROP_TECHNOLOGY, 297 POWER_SUPPLY_PROP_CHARGE_FULL, 298 POWER_SUPPLY_PROP_CHARGE_NOW, 299 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 300 POWER_SUPPLY_PROP_CYCLE_COUNT, 301 POWER_SUPPLY_PROP_HEALTH, 302 POWER_SUPPLY_PROP_MANUFACTURER, 303 }; 304 305 static enum power_supply_property bq27530_battery_props[] = { 306 POWER_SUPPLY_PROP_STATUS, 307 POWER_SUPPLY_PROP_PRESENT, 308 POWER_SUPPLY_PROP_VOLTAGE_NOW, 309 POWER_SUPPLY_PROP_CURRENT_NOW, 310 POWER_SUPPLY_PROP_CAPACITY, 311 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 312 POWER_SUPPLY_PROP_TEMP, 313 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 314 POWER_SUPPLY_PROP_TECHNOLOGY, 315 POWER_SUPPLY_PROP_CHARGE_FULL, 316 POWER_SUPPLY_PROP_CHARGE_NOW, 317 POWER_SUPPLY_PROP_POWER_AVG, 318 POWER_SUPPLY_PROP_HEALTH, 319 POWER_SUPPLY_PROP_CYCLE_COUNT, 320 POWER_SUPPLY_PROP_MANUFACTURER, 321 }; 322 323 static enum power_supply_property bq27541_battery_props[] = { 324 POWER_SUPPLY_PROP_STATUS, 325 POWER_SUPPLY_PROP_PRESENT, 326 POWER_SUPPLY_PROP_VOLTAGE_NOW, 327 POWER_SUPPLY_PROP_CURRENT_NOW, 328 POWER_SUPPLY_PROP_CAPACITY, 329 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 330 POWER_SUPPLY_PROP_TEMP, 331 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 332 POWER_SUPPLY_PROP_TECHNOLOGY, 333 POWER_SUPPLY_PROP_CHARGE_FULL, 334 POWER_SUPPLY_PROP_CHARGE_NOW, 335 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 336 POWER_SUPPLY_PROP_CYCLE_COUNT, 337 POWER_SUPPLY_PROP_POWER_AVG, 338 POWER_SUPPLY_PROP_HEALTH, 339 POWER_SUPPLY_PROP_MANUFACTURER, 340 }; 341 342 static enum power_supply_property bq27545_battery_props[] = { 343 POWER_SUPPLY_PROP_STATUS, 344 POWER_SUPPLY_PROP_PRESENT, 345 POWER_SUPPLY_PROP_VOLTAGE_NOW, 346 POWER_SUPPLY_PROP_CURRENT_NOW, 347 POWER_SUPPLY_PROP_CAPACITY, 348 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 349 POWER_SUPPLY_PROP_TEMP, 350 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW, 351 POWER_SUPPLY_PROP_TECHNOLOGY, 352 POWER_SUPPLY_PROP_CHARGE_FULL, 353 POWER_SUPPLY_PROP_CHARGE_NOW, 354 POWER_SUPPLY_PROP_HEALTH, 355 POWER_SUPPLY_PROP_CYCLE_COUNT, 356 POWER_SUPPLY_PROP_POWER_AVG, 357 POWER_SUPPLY_PROP_MANUFACTURER, 358 }; 359 360 static enum power_supply_property bq27421_battery_props[] = { 361 POWER_SUPPLY_PROP_STATUS, 362 POWER_SUPPLY_PROP_PRESENT, 363 POWER_SUPPLY_PROP_VOLTAGE_NOW, 364 POWER_SUPPLY_PROP_CURRENT_NOW, 365 POWER_SUPPLY_PROP_CAPACITY, 366 POWER_SUPPLY_PROP_CAPACITY_LEVEL, 367 POWER_SUPPLY_PROP_TEMP, 368 POWER_SUPPLY_PROP_TECHNOLOGY, 369 POWER_SUPPLY_PROP_CHARGE_FULL, 370 POWER_SUPPLY_PROP_CHARGE_NOW, 371 POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, 372 POWER_SUPPLY_PROP_MANUFACTURER, 373 }; 374 375 #define BQ27XXX_PROP(_id, _prop) \ 376 [_id] = { \ 377 .props = _prop, \ 378 .size = ARRAY_SIZE(_prop), \ 379 } 380 381 static struct { 382 enum power_supply_property *props; 383 size_t size; 384 } bq27xxx_battery_props[] = { 385 BQ27XXX_PROP(BQ27000, bq27000_battery_props), 386 BQ27XXX_PROP(BQ27010, bq27010_battery_props), 387 BQ27XXX_PROP(BQ27500, bq27500_battery_props), 388 BQ27XXX_PROP(BQ27530, bq27530_battery_props), 389 BQ27XXX_PROP(BQ27541, bq27541_battery_props), 390 BQ27XXX_PROP(BQ27545, bq27545_battery_props), 391 BQ27XXX_PROP(BQ27421, bq27421_battery_props), 392 }; 393 394 static DEFINE_MUTEX(bq27xxx_list_lock); 395 static LIST_HEAD(bq27xxx_battery_devices); 396 397 static int poll_interval_param_set(const char *val, const struct kernel_param *kp) 398 { 399 struct bq27xxx_device_info *di; 400 int ret; 401 402 ret = param_set_uint(val, kp); 403 if (ret < 0) 404 return ret; 405 406 mutex_lock(&bq27xxx_list_lock); 407 list_for_each_entry(di, &bq27xxx_battery_devices, list) { 408 cancel_delayed_work_sync(&di->work); 409 schedule_delayed_work(&di->work, 0); 410 } 411 mutex_unlock(&bq27xxx_list_lock); 412 413 return ret; 414 } 415 416 static const struct kernel_param_ops param_ops_poll_interval = { 417 .get = param_get_uint, 418 .set = poll_interval_param_set, 419 }; 420 421 static unsigned int poll_interval = 360; 422 module_param_cb(poll_interval, ¶m_ops_poll_interval, &poll_interval, 0644); 423 MODULE_PARM_DESC(poll_interval, 424 "battery poll interval in seconds - 0 disables polling"); 425 426 /* 427 * Common code for BQ27xxx devices 428 */ 429 430 static inline int bq27xxx_read(struct bq27xxx_device_info *di, int reg_index, 431 bool single) 432 { 433 /* Reports EINVAL for invalid/missing registers */ 434 if (!di || di->regs[reg_index] == INVALID_REG_ADDR) 435 return -EINVAL; 436 437 return di->bus.read(di, di->regs[reg_index], single); 438 } 439 440 /* 441 * Return the battery State-of-Charge 442 * Or < 0 if something fails. 443 */ 444 static int bq27xxx_battery_read_soc(struct bq27xxx_device_info *di) 445 { 446 int soc; 447 448 if (di->chip == BQ27000 || di->chip == BQ27010) 449 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, true); 450 else 451 soc = bq27xxx_read(di, BQ27XXX_REG_SOC, false); 452 453 if (soc < 0) 454 dev_dbg(di->dev, "error reading State-of-Charge\n"); 455 456 return soc; 457 } 458 459 /* 460 * Return a battery charge value in µAh 461 * Or < 0 if something fails. 462 */ 463 static int bq27xxx_battery_read_charge(struct bq27xxx_device_info *di, u8 reg) 464 { 465 int charge; 466 467 charge = bq27xxx_read(di, reg, false); 468 if (charge < 0) { 469 dev_dbg(di->dev, "error reading charge register %02x: %d\n", 470 reg, charge); 471 return charge; 472 } 473 474 if (di->chip == BQ27000 || di->chip == BQ27010) 475 charge *= BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS; 476 else 477 charge *= 1000; 478 479 return charge; 480 } 481 482 /* 483 * Return the battery Nominal available capacity in µAh 484 * Or < 0 if something fails. 485 */ 486 static inline int bq27xxx_battery_read_nac(struct bq27xxx_device_info *di) 487 { 488 int flags; 489 490 if (di->chip == BQ27000 || di->chip == BQ27010) { 491 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true); 492 if (flags >= 0 && (flags & BQ27000_FLAG_CI)) 493 return -ENODATA; 494 } 495 496 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_NAC); 497 } 498 499 /* 500 * Return the battery Full Charge Capacity in µAh 501 * Or < 0 if something fails. 502 */ 503 static inline int bq27xxx_battery_read_fcc(struct bq27xxx_device_info *di) 504 { 505 return bq27xxx_battery_read_charge(di, BQ27XXX_REG_FCC); 506 } 507 508 /* 509 * Return the Design Capacity in µAh 510 * Or < 0 if something fails. 511 */ 512 static int bq27xxx_battery_read_dcap(struct bq27xxx_device_info *di) 513 { 514 int dcap; 515 516 if (di->chip == BQ27000 || di->chip == BQ27010) 517 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, true); 518 else 519 dcap = bq27xxx_read(di, BQ27XXX_REG_DCAP, false); 520 521 if (dcap < 0) { 522 dev_dbg(di->dev, "error reading initial last measured discharge\n"); 523 return dcap; 524 } 525 526 if (di->chip == BQ27000 || di->chip == BQ27010) 527 dcap = (dcap << 8) * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS; 528 else 529 dcap *= 1000; 530 531 return dcap; 532 } 533 534 /* 535 * Return the battery Available energy in µWh 536 * Or < 0 if something fails. 537 */ 538 static int bq27xxx_battery_read_energy(struct bq27xxx_device_info *di) 539 { 540 int ae; 541 542 ae = bq27xxx_read(di, BQ27XXX_REG_AE, false); 543 if (ae < 0) { 544 dev_dbg(di->dev, "error reading available energy\n"); 545 return ae; 546 } 547 548 if (di->chip == BQ27000 || di->chip == BQ27010) 549 ae *= BQ27XXX_POWER_CONSTANT / BQ27XXX_RS; 550 else 551 ae *= 1000; 552 553 return ae; 554 } 555 556 /* 557 * Return the battery temperature in tenths of degree Kelvin 558 * Or < 0 if something fails. 559 */ 560 static int bq27xxx_battery_read_temperature(struct bq27xxx_device_info *di) 561 { 562 int temp; 563 564 temp = bq27xxx_read(di, BQ27XXX_REG_TEMP, false); 565 if (temp < 0) { 566 dev_err(di->dev, "error reading temperature\n"); 567 return temp; 568 } 569 570 if (di->chip == BQ27000 || di->chip == BQ27010) 571 temp = 5 * temp / 2; 572 573 return temp; 574 } 575 576 /* 577 * Return the battery Cycle count total 578 * Or < 0 if something fails. 579 */ 580 static int bq27xxx_battery_read_cyct(struct bq27xxx_device_info *di) 581 { 582 int cyct; 583 584 cyct = bq27xxx_read(di, BQ27XXX_REG_CYCT, false); 585 if (cyct < 0) 586 dev_err(di->dev, "error reading cycle count total\n"); 587 588 return cyct; 589 } 590 591 /* 592 * Read a time register. 593 * Return < 0 if something fails. 594 */ 595 static int bq27xxx_battery_read_time(struct bq27xxx_device_info *di, u8 reg) 596 { 597 int tval; 598 599 tval = bq27xxx_read(di, reg, false); 600 if (tval < 0) { 601 dev_dbg(di->dev, "error reading time register %02x: %d\n", 602 reg, tval); 603 return tval; 604 } 605 606 if (tval == 65535) 607 return -ENODATA; 608 609 return tval * 60; 610 } 611 612 /* 613 * Read an average power register. 614 * Return < 0 if something fails. 615 */ 616 static int bq27xxx_battery_read_pwr_avg(struct bq27xxx_device_info *di) 617 { 618 int tval; 619 620 tval = bq27xxx_read(di, BQ27XXX_REG_AP, false); 621 if (tval < 0) { 622 dev_err(di->dev, "error reading average power register %02x: %d\n", 623 BQ27XXX_REG_AP, tval); 624 return tval; 625 } 626 627 if (di->chip == BQ27000 || di->chip == BQ27010) 628 return (tval * BQ27XXX_POWER_CONSTANT) / BQ27XXX_RS; 629 else 630 return tval; 631 } 632 633 /* 634 * Returns true if a battery over temperature condition is detected 635 */ 636 static bool bq27xxx_battery_overtemp(struct bq27xxx_device_info *di, u16 flags) 637 { 638 if (di->chip == BQ27500 || di->chip == BQ27541 || di->chip == BQ27545) 639 return flags & (BQ27XXX_FLAG_OTC | BQ27XXX_FLAG_OTD); 640 if (di->chip == BQ27530 || di->chip == BQ27421) 641 return flags & BQ27XXX_FLAG_OT; 642 643 return false; 644 } 645 646 /* 647 * Returns true if a battery under temperature condition is detected 648 */ 649 static bool bq27xxx_battery_undertemp(struct bq27xxx_device_info *di, u16 flags) 650 { 651 if (di->chip == BQ27530 || di->chip == BQ27421) 652 return flags & BQ27XXX_FLAG_UT; 653 654 return false; 655 } 656 657 /* 658 * Returns true if a low state of charge condition is detected 659 */ 660 static bool bq27xxx_battery_dead(struct bq27xxx_device_info *di, u16 flags) 661 { 662 if (di->chip == BQ27000 || di->chip == BQ27010) 663 return flags & (BQ27000_FLAG_EDV1 | BQ27000_FLAG_EDVF); 664 else 665 return flags & (BQ27XXX_FLAG_SOC1 | BQ27XXX_FLAG_SOCF); 666 } 667 668 /* 669 * Read flag register. 670 * Return < 0 if something fails. 671 */ 672 static int bq27xxx_battery_read_health(struct bq27xxx_device_info *di) 673 { 674 int flags; 675 bool has_singe_flag = di->chip == BQ27000 || di->chip == BQ27010; 676 677 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag); 678 if (flags < 0) { 679 dev_err(di->dev, "error reading flag register:%d\n", flags); 680 return flags; 681 } 682 683 /* Unlikely but important to return first */ 684 if (unlikely(bq27xxx_battery_overtemp(di, flags))) 685 return POWER_SUPPLY_HEALTH_OVERHEAT; 686 if (unlikely(bq27xxx_battery_undertemp(di, flags))) 687 return POWER_SUPPLY_HEALTH_COLD; 688 if (unlikely(bq27xxx_battery_dead(di, flags))) 689 return POWER_SUPPLY_HEALTH_DEAD; 690 691 return POWER_SUPPLY_HEALTH_GOOD; 692 } 693 694 void bq27xxx_battery_update(struct bq27xxx_device_info *di) 695 { 696 struct bq27xxx_reg_cache cache = {0, }; 697 bool has_ci_flag = di->chip == BQ27000 || di->chip == BQ27010; 698 bool has_singe_flag = di->chip == BQ27000 || di->chip == BQ27010; 699 700 cache.flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, has_singe_flag); 701 if ((cache.flags & 0xff) == 0xff) 702 cache.flags = -1; /* read error */ 703 if (cache.flags >= 0) { 704 cache.temperature = bq27xxx_battery_read_temperature(di); 705 if (has_ci_flag && (cache.flags & BQ27000_FLAG_CI)) { 706 dev_info_once(di->dev, "battery is not calibrated! ignoring capacity values\n"); 707 cache.capacity = -ENODATA; 708 cache.energy = -ENODATA; 709 cache.time_to_empty = -ENODATA; 710 cache.time_to_empty_avg = -ENODATA; 711 cache.time_to_full = -ENODATA; 712 cache.charge_full = -ENODATA; 713 cache.health = -ENODATA; 714 } else { 715 if (di->regs[BQ27XXX_REG_TTE] != INVALID_REG_ADDR) 716 cache.time_to_empty = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTE); 717 if (di->regs[BQ27XXX_REG_TTECP] != INVALID_REG_ADDR) 718 cache.time_to_empty_avg = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTECP); 719 if (di->regs[BQ27XXX_REG_TTF] != INVALID_REG_ADDR) 720 cache.time_to_full = bq27xxx_battery_read_time(di, BQ27XXX_REG_TTF); 721 cache.charge_full = bq27xxx_battery_read_fcc(di); 722 cache.capacity = bq27xxx_battery_read_soc(di); 723 if (di->regs[BQ27XXX_REG_AE] != INVALID_REG_ADDR) 724 cache.energy = bq27xxx_battery_read_energy(di); 725 cache.health = bq27xxx_battery_read_health(di); 726 } 727 if (di->regs[BQ27XXX_REG_CYCT] != INVALID_REG_ADDR) 728 cache.cycle_count = bq27xxx_battery_read_cyct(di); 729 if (di->regs[BQ27XXX_REG_AP] != INVALID_REG_ADDR) 730 cache.power_avg = bq27xxx_battery_read_pwr_avg(di); 731 732 /* We only have to read charge design full once */ 733 if (di->charge_design_full <= 0) 734 di->charge_design_full = bq27xxx_battery_read_dcap(di); 735 } 736 737 if (di->cache.capacity != cache.capacity) 738 power_supply_changed(di->bat); 739 740 if (memcmp(&di->cache, &cache, sizeof(cache)) != 0) 741 di->cache = cache; 742 743 di->last_update = jiffies; 744 } 745 EXPORT_SYMBOL_GPL(bq27xxx_battery_update); 746 747 static void bq27xxx_battery_poll(struct work_struct *work) 748 { 749 struct bq27xxx_device_info *di = 750 container_of(work, struct bq27xxx_device_info, 751 work.work); 752 753 bq27xxx_battery_update(di); 754 755 if (poll_interval > 0) 756 schedule_delayed_work(&di->work, poll_interval * HZ); 757 } 758 759 /* 760 * Return the battery average current in µA 761 * Note that current can be negative signed as well 762 * Or 0 if something fails. 763 */ 764 static int bq27xxx_battery_current(struct bq27xxx_device_info *di, 765 union power_supply_propval *val) 766 { 767 int curr; 768 int flags; 769 770 curr = bq27xxx_read(di, BQ27XXX_REG_AI, false); 771 if (curr < 0) { 772 dev_err(di->dev, "error reading current\n"); 773 return curr; 774 } 775 776 if (di->chip == BQ27000 || di->chip == BQ27010) { 777 flags = bq27xxx_read(di, BQ27XXX_REG_FLAGS, true); 778 if (flags & BQ27000_FLAG_CHGS) { 779 dev_dbg(di->dev, "negative current!\n"); 780 curr = -curr; 781 } 782 783 val->intval = curr * BQ27XXX_CURRENT_CONSTANT / BQ27XXX_RS; 784 } else { 785 /* Other gauges return signed value */ 786 val->intval = (int)((s16)curr) * 1000; 787 } 788 789 return 0; 790 } 791 792 static int bq27xxx_battery_status(struct bq27xxx_device_info *di, 793 union power_supply_propval *val) 794 { 795 int status; 796 797 if (di->chip == BQ27000 || di->chip == BQ27010) { 798 if (di->cache.flags & BQ27000_FLAG_FC) 799 status = POWER_SUPPLY_STATUS_FULL; 800 else if (di->cache.flags & BQ27000_FLAG_CHGS) 801 status = POWER_SUPPLY_STATUS_CHARGING; 802 else if (power_supply_am_i_supplied(di->bat)) 803 status = POWER_SUPPLY_STATUS_NOT_CHARGING; 804 else 805 status = POWER_SUPPLY_STATUS_DISCHARGING; 806 } else { 807 if (di->cache.flags & BQ27XXX_FLAG_FC) 808 status = POWER_SUPPLY_STATUS_FULL; 809 else if (di->cache.flags & BQ27XXX_FLAG_DSC) 810 status = POWER_SUPPLY_STATUS_DISCHARGING; 811 else 812 status = POWER_SUPPLY_STATUS_CHARGING; 813 } 814 815 val->intval = status; 816 817 return 0; 818 } 819 820 static int bq27xxx_battery_capacity_level(struct bq27xxx_device_info *di, 821 union power_supply_propval *val) 822 { 823 int level; 824 825 if (di->chip == BQ27000 || di->chip == BQ27010) { 826 if (di->cache.flags & BQ27000_FLAG_FC) 827 level = POWER_SUPPLY_CAPACITY_LEVEL_FULL; 828 else if (di->cache.flags & BQ27000_FLAG_EDV1) 829 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW; 830 else if (di->cache.flags & BQ27000_FLAG_EDVF) 831 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; 832 else 833 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; 834 } else { 835 if (di->cache.flags & BQ27XXX_FLAG_FC) 836 level = POWER_SUPPLY_CAPACITY_LEVEL_FULL; 837 else if (di->cache.flags & BQ27XXX_FLAG_SOC1) 838 level = POWER_SUPPLY_CAPACITY_LEVEL_LOW; 839 else if (di->cache.flags & BQ27XXX_FLAG_SOCF) 840 level = POWER_SUPPLY_CAPACITY_LEVEL_CRITICAL; 841 else 842 level = POWER_SUPPLY_CAPACITY_LEVEL_NORMAL; 843 } 844 845 val->intval = level; 846 847 return 0; 848 } 849 850 /* 851 * Return the battery Voltage in millivolts 852 * Or < 0 if something fails. 853 */ 854 static int bq27xxx_battery_voltage(struct bq27xxx_device_info *di, 855 union power_supply_propval *val) 856 { 857 int volt; 858 859 volt = bq27xxx_read(di, BQ27XXX_REG_VOLT, false); 860 if (volt < 0) { 861 dev_err(di->dev, "error reading voltage\n"); 862 return volt; 863 } 864 865 val->intval = volt * 1000; 866 867 return 0; 868 } 869 870 static int bq27xxx_simple_value(int value, 871 union power_supply_propval *val) 872 { 873 if (value < 0) 874 return value; 875 876 val->intval = value; 877 878 return 0; 879 } 880 881 static int bq27xxx_battery_get_property(struct power_supply *psy, 882 enum power_supply_property psp, 883 union power_supply_propval *val) 884 { 885 int ret = 0; 886 struct bq27xxx_device_info *di = power_supply_get_drvdata(psy); 887 888 mutex_lock(&di->lock); 889 if (time_is_before_jiffies(di->last_update + 5 * HZ)) { 890 cancel_delayed_work_sync(&di->work); 891 bq27xxx_battery_poll(&di->work.work); 892 } 893 mutex_unlock(&di->lock); 894 895 if (psp != POWER_SUPPLY_PROP_PRESENT && di->cache.flags < 0) 896 return -ENODEV; 897 898 switch (psp) { 899 case POWER_SUPPLY_PROP_STATUS: 900 ret = bq27xxx_battery_status(di, val); 901 break; 902 case POWER_SUPPLY_PROP_VOLTAGE_NOW: 903 ret = bq27xxx_battery_voltage(di, val); 904 break; 905 case POWER_SUPPLY_PROP_PRESENT: 906 val->intval = di->cache.flags < 0 ? 0 : 1; 907 break; 908 case POWER_SUPPLY_PROP_CURRENT_NOW: 909 ret = bq27xxx_battery_current(di, val); 910 break; 911 case POWER_SUPPLY_PROP_CAPACITY: 912 ret = bq27xxx_simple_value(di->cache.capacity, val); 913 break; 914 case POWER_SUPPLY_PROP_CAPACITY_LEVEL: 915 ret = bq27xxx_battery_capacity_level(di, val); 916 break; 917 case POWER_SUPPLY_PROP_TEMP: 918 ret = bq27xxx_simple_value(di->cache.temperature, val); 919 if (ret == 0) 920 val->intval -= 2731; /* convert decidegree k to c */ 921 break; 922 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW: 923 ret = bq27xxx_simple_value(di->cache.time_to_empty, val); 924 break; 925 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_AVG: 926 ret = bq27xxx_simple_value(di->cache.time_to_empty_avg, val); 927 break; 928 case POWER_SUPPLY_PROP_TIME_TO_FULL_NOW: 929 ret = bq27xxx_simple_value(di->cache.time_to_full, val); 930 break; 931 case POWER_SUPPLY_PROP_TECHNOLOGY: 932 val->intval = POWER_SUPPLY_TECHNOLOGY_LION; 933 break; 934 case POWER_SUPPLY_PROP_CHARGE_NOW: 935 ret = bq27xxx_simple_value(bq27xxx_battery_read_nac(di), val); 936 break; 937 case POWER_SUPPLY_PROP_CHARGE_FULL: 938 ret = bq27xxx_simple_value(di->cache.charge_full, val); 939 break; 940 case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: 941 ret = bq27xxx_simple_value(di->charge_design_full, val); 942 break; 943 case POWER_SUPPLY_PROP_CYCLE_COUNT: 944 ret = bq27xxx_simple_value(di->cache.cycle_count, val); 945 break; 946 case POWER_SUPPLY_PROP_ENERGY_NOW: 947 ret = bq27xxx_simple_value(di->cache.energy, val); 948 break; 949 case POWER_SUPPLY_PROP_POWER_AVG: 950 ret = bq27xxx_simple_value(di->cache.power_avg, val); 951 break; 952 case POWER_SUPPLY_PROP_HEALTH: 953 ret = bq27xxx_simple_value(di->cache.health, val); 954 break; 955 case POWER_SUPPLY_PROP_MANUFACTURER: 956 val->strval = BQ27XXX_MANUFACTURER; 957 break; 958 default: 959 return -EINVAL; 960 } 961 962 return ret; 963 } 964 965 static void bq27xxx_external_power_changed(struct power_supply *psy) 966 { 967 struct bq27xxx_device_info *di = power_supply_get_drvdata(psy); 968 969 cancel_delayed_work_sync(&di->work); 970 schedule_delayed_work(&di->work, 0); 971 } 972 973 int bq27xxx_battery_setup(struct bq27xxx_device_info *di) 974 { 975 struct power_supply_desc *psy_desc; 976 struct power_supply_config psy_cfg = { .drv_data = di, }; 977 978 INIT_DELAYED_WORK(&di->work, bq27xxx_battery_poll); 979 mutex_init(&di->lock); 980 di->regs = bq27xxx_regs[di->chip]; 981 982 psy_desc = devm_kzalloc(di->dev, sizeof(*psy_desc), GFP_KERNEL); 983 if (!psy_desc) 984 return -ENOMEM; 985 986 psy_desc->name = di->name; 987 psy_desc->type = POWER_SUPPLY_TYPE_BATTERY; 988 psy_desc->properties = bq27xxx_battery_props[di->chip].props; 989 psy_desc->num_properties = bq27xxx_battery_props[di->chip].size; 990 psy_desc->get_property = bq27xxx_battery_get_property; 991 psy_desc->external_power_changed = bq27xxx_external_power_changed; 992 993 di->bat = power_supply_register_no_ws(di->dev, psy_desc, &psy_cfg); 994 if (IS_ERR(di->bat)) { 995 dev_err(di->dev, "failed to register battery\n"); 996 return PTR_ERR(di->bat); 997 } 998 999 dev_info(di->dev, "support ver. %s enabled\n", DRIVER_VERSION); 1000 1001 bq27xxx_battery_update(di); 1002 1003 mutex_lock(&bq27xxx_list_lock); 1004 list_add(&di->list, &bq27xxx_battery_devices); 1005 mutex_unlock(&bq27xxx_list_lock); 1006 1007 return 0; 1008 } 1009 EXPORT_SYMBOL_GPL(bq27xxx_battery_setup); 1010 1011 void bq27xxx_battery_teardown(struct bq27xxx_device_info *di) 1012 { 1013 /* 1014 * power_supply_unregister call bq27xxx_battery_get_property which 1015 * call bq27xxx_battery_poll. 1016 * Make sure that bq27xxx_battery_poll will not call 1017 * schedule_delayed_work again after unregister (which cause OOPS). 1018 */ 1019 poll_interval = 0; 1020 1021 cancel_delayed_work_sync(&di->work); 1022 1023 power_supply_unregister(di->bat); 1024 1025 mutex_lock(&bq27xxx_list_lock); 1026 list_del(&di->list); 1027 mutex_unlock(&bq27xxx_list_lock); 1028 1029 mutex_destroy(&di->lock); 1030 } 1031 EXPORT_SYMBOL_GPL(bq27xxx_battery_teardown); 1032 1033 static int bq27xxx_battery_platform_read(struct bq27xxx_device_info *di, u8 reg, 1034 bool single) 1035 { 1036 struct device *dev = di->dev; 1037 struct bq27xxx_platform_data *pdata = dev->platform_data; 1038 unsigned int timeout = 3; 1039 int upper, lower; 1040 int temp; 1041 1042 if (!single) { 1043 /* Make sure the value has not changed in between reading the 1044 * lower and the upper part */ 1045 upper = pdata->read(dev, reg + 1); 1046 do { 1047 temp = upper; 1048 if (upper < 0) 1049 return upper; 1050 1051 lower = pdata->read(dev, reg); 1052 if (lower < 0) 1053 return lower; 1054 1055 upper = pdata->read(dev, reg + 1); 1056 } while (temp != upper && --timeout); 1057 1058 if (timeout == 0) 1059 return -EIO; 1060 1061 return (upper << 8) | lower; 1062 } 1063 1064 return pdata->read(dev, reg); 1065 } 1066 1067 static int bq27xxx_battery_platform_probe(struct platform_device *pdev) 1068 { 1069 struct bq27xxx_device_info *di; 1070 struct bq27xxx_platform_data *pdata = pdev->dev.platform_data; 1071 1072 if (!pdata) { 1073 dev_err(&pdev->dev, "no platform_data supplied\n"); 1074 return -EINVAL; 1075 } 1076 1077 if (!pdata->read) { 1078 dev_err(&pdev->dev, "no hdq read callback supplied\n"); 1079 return -EINVAL; 1080 } 1081 1082 if (!pdata->chip) { 1083 dev_err(&pdev->dev, "no device supplied\n"); 1084 return -EINVAL; 1085 } 1086 1087 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL); 1088 if (!di) 1089 return -ENOMEM; 1090 1091 platform_set_drvdata(pdev, di); 1092 1093 di->dev = &pdev->dev; 1094 di->chip = pdata->chip; 1095 di->name = pdata->name ?: dev_name(&pdev->dev); 1096 di->bus.read = bq27xxx_battery_platform_read; 1097 1098 return bq27xxx_battery_setup(di); 1099 } 1100 1101 static int bq27xxx_battery_platform_remove(struct platform_device *pdev) 1102 { 1103 struct bq27xxx_device_info *di = platform_get_drvdata(pdev); 1104 1105 bq27xxx_battery_teardown(di); 1106 1107 return 0; 1108 } 1109 1110 static const struct platform_device_id bq27xxx_battery_platform_id_table[] = { 1111 { "bq27000-battery", }, 1112 { /* sentinel */ } 1113 }; 1114 MODULE_DEVICE_TABLE(platform, bq27xxx_battery_platform_id_table); 1115 1116 #ifdef CONFIG_OF 1117 static const struct of_device_id bq27xxx_battery_platform_of_match_table[] = { 1118 { .compatible = "ti,bq27000" }, 1119 {}, 1120 }; 1121 MODULE_DEVICE_TABLE(of, bq27xxx_battery_platform_of_match_table); 1122 #endif 1123 1124 static struct platform_driver bq27xxx_battery_platform_driver = { 1125 .probe = bq27xxx_battery_platform_probe, 1126 .remove = bq27xxx_battery_platform_remove, 1127 .driver = { 1128 .name = "bq27000-battery", 1129 .of_match_table = of_match_ptr(bq27xxx_battery_platform_of_match_table), 1130 }, 1131 .id_table = bq27xxx_battery_platform_id_table, 1132 }; 1133 module_platform_driver(bq27xxx_battery_platform_driver); 1134 1135 MODULE_ALIAS("platform:bq27000-battery"); 1136 1137 MODULE_AUTHOR("Rodolfo Giometti <giometti@linux.it>"); 1138 MODULE_DESCRIPTION("BQ27xxx battery monitor driver"); 1139 MODULE_LICENSE("GPL"); 1140