projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
power_supply: apm_power: Use power_supply_*() API for accessing function attrs
[linux-2.6-block.git] / drivers / power / bq2415x_charger.c
CommitLineData
0bc98cc6 1/*
6c47a3e0
AV		 2 * bq2415x charger driver
3 *
32260308 4 * Copyright (C) 2011-2013 Pali Rohár <pali.rohar@gmail.com>
6c47a3e0
AV		 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; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
6c47a3e0
AV		 16 * Datasheets:
17 * http://www.ti.com/product/bq24150
18 * http://www.ti.com/product/bq24150a
19 * http://www.ti.com/product/bq24152
20 * http://www.ti.com/product/bq24153
21 * http://www.ti.com/product/bq24153a
22 * http://www.ti.com/product/bq24155
0e1392d9
AMN		 23 * http://www.ti.com/product/bq24157s
24 * http://www.ti.com/product/bq24158
6c47a3e0 25 */
0bc98cc6 26
0bc98cc6
PR		 27#include <linux/kernel.h>
28#include <linux/module.h>
29#include <linux/param.h>
30#include <linux/err.h>
31#include <linux/workqueue.h>
32#include <linux/sysfs.h>
33#include <linux/platform_device.h>
34#include <linux/power_supply.h>
35#include <linux/idr.h>
36#include <linux/i2c.h>
37#include <linux/slab.h>
38
39#include <linux/power/bq2415x_charger.h>
40
41/* timeout for resetting chip timer */
42#define BQ2415X_TIMER_TIMEOUT 10
43
44#define BQ2415X_REG_STATUS 0x00
45#define BQ2415X_REG_CONTROL 0x01
46#define BQ2415X_REG_VOLTAGE 0x02
47#define BQ2415X_REG_VENDER 0x03
48#define BQ2415X_REG_CURRENT 0x04
49
50/* reset state for all registers */
51#define BQ2415X_RESET_STATUS BIT(6)
52#define BQ2415X_RESET_CONTROL (BIT(4)|BIT(5))
53#define BQ2415X_RESET_VOLTAGE (BIT(1)|BIT(3))
54#define BQ2415X_RESET_CURRENT (BIT(0)|BIT(3)|BIT(7))
55
56/* status register */
57#define BQ2415X_BIT_TMR_RST 7
58#define BQ2415X_BIT_OTG 7
59#define BQ2415X_BIT_EN_STAT 6
60#define BQ2415X_MASK_STAT (BIT(4)|BIT(5))
61#define BQ2415X_SHIFT_STAT 4
62#define BQ2415X_BIT_BOOST 3
63#define BQ2415X_MASK_FAULT (BIT(0)|BIT(1)|BIT(2))
64#define BQ2415X_SHIFT_FAULT 0
65
66/* control register */
67#define BQ2415X_MASK_LIMIT (BIT(6)|BIT(7))
68#define BQ2415X_SHIFT_LIMIT 6
69#define BQ2415X_MASK_VLOWV (BIT(4)|BIT(5))
70#define BQ2415X_SHIFT_VLOWV 4
71#define BQ2415X_BIT_TE 3
72#define BQ2415X_BIT_CE 2
73#define BQ2415X_BIT_HZ_MODE 1
74#define BQ2415X_BIT_OPA_MODE 0
75
76/* voltage register */
77#define BQ2415X_MASK_VO (BIT(2)|BIT(3)|BIT(4)|BIT(5)|BIT(6)|BIT(7))
78#define BQ2415X_SHIFT_VO 2
79#define BQ2415X_BIT_OTG_PL 1
80#define BQ2415X_BIT_OTG_EN 0
81
82/* vender register */
83#define BQ2415X_MASK_VENDER (BIT(5)|BIT(6)|BIT(7))
84#define BQ2415X_SHIFT_VENDER 5
85#define BQ2415X_MASK_PN (BIT(3)|BIT(4))
86#define BQ2415X_SHIFT_PN 3
87#define BQ2415X_MASK_REVISION (BIT(0)|BIT(1)|BIT(2))
88#define BQ2415X_SHIFT_REVISION 0
89
90/* current register */
91#define BQ2415X_MASK_RESET BIT(7)
92#define BQ2415X_MASK_VI_CHRG (BIT(4)|BIT(5)|BIT(6))
93#define BQ2415X_SHIFT_VI_CHRG 4
94/* N/A BIT(3) */
95#define BQ2415X_MASK_VI_TERM (BIT(0)|BIT(1)|BIT(2))
96#define BQ2415X_SHIFT_VI_TERM 0
97
98
99enum bq2415x_command {
100 BQ2415X_TIMER_RESET,
101 BQ2415X_OTG_STATUS,
102 BQ2415X_STAT_PIN_STATUS,
103 BQ2415X_STAT_PIN_ENABLE,
104 BQ2415X_STAT_PIN_DISABLE,
105 BQ2415X_CHARGE_STATUS,
106 BQ2415X_BOOST_STATUS,
107 BQ2415X_FAULT_STATUS,
108
109 BQ2415X_CHARGE_TERMINATION_STATUS,
110 BQ2415X_CHARGE_TERMINATION_ENABLE,
111 BQ2415X_CHARGE_TERMINATION_DISABLE,
112 BQ2415X_CHARGER_STATUS,
113 BQ2415X_CHARGER_ENABLE,
114 BQ2415X_CHARGER_DISABLE,
115 BQ2415X_HIGH_IMPEDANCE_STATUS,
116 BQ2415X_HIGH_IMPEDANCE_ENABLE,
117 BQ2415X_HIGH_IMPEDANCE_DISABLE,
118 BQ2415X_BOOST_MODE_STATUS,
119 BQ2415X_BOOST_MODE_ENABLE,
120 BQ2415X_BOOST_MODE_DISABLE,
121
122 BQ2415X_OTG_LEVEL,
123 BQ2415X_OTG_ACTIVATE_HIGH,
124 BQ2415X_OTG_ACTIVATE_LOW,
125 BQ2415X_OTG_PIN_STATUS,
126 BQ2415X_OTG_PIN_ENABLE,
127 BQ2415X_OTG_PIN_DISABLE,
128
129 BQ2415X_VENDER_CODE,
130 BQ2415X_PART_NUMBER,
131 BQ2415X_REVISION,
132};
133
134enum bq2415x_chip {
135 BQUNKNOWN,
136 BQ24150,
137 BQ24150A,
138 BQ24151,
139 BQ24151A,
140 BQ24152,
141 BQ24153,
142 BQ24153A,
143 BQ24155,
144 BQ24156,
145 BQ24156A,
0e1392d9 146 BQ24157S,
0bc98cc6
PR		 147 BQ24158,
148};
149
150static char *bq2415x_chip_name[] = {
151 "unknown",
152 "bq24150",
153 "bq24150a",
154 "bq24151",
155 "bq24151a",
156 "bq24152",
157 "bq24153",
158 "bq24153a",
159 "bq24155",
160 "bq24156",
161 "bq24156a",
0e1392d9 162 "bq24157s",
0bc98cc6
PR		 163 "bq24158",
164};
165
166struct bq2415x_device {
167 struct device *dev;
168 struct bq2415x_platform_data init_data;
169 struct power_supply charger;
170 struct delayed_work work;
faffd234 171 struct power_supply *notify_psy;
32260308 172 struct notifier_block nb;
0bc98cc6 173 enum bq2415x_mode reported_mode;/* mode reported by hook function */
881f985a 174 enum bq2415x_mode mode; /* currently configured mode */
0bc98cc6
PR		 175 enum bq2415x_chip chip;
176 const char *timer_error;
177 char *model;
178 char *name;
179 int autotimer; /* 1 - if driver automatically reset timer, 0 - not */
180 int automode; /* 1 - enabled, 0 - disabled; -1 - not supported */
181 int id;
182};
183
184/* each registered chip must have unique id */
185static DEFINE_IDR(bq2415x_id);
186
187static DEFINE_MUTEX(bq2415x_id_mutex);
188static DEFINE_MUTEX(bq2415x_timer_mutex);
189static DEFINE_MUTEX(bq2415x_i2c_mutex);
190
191/**** i2c read functions ****/
192
193/* read value from register */
194static int bq2415x_i2c_read(struct bq2415x_device *bq, u8 reg)
195{
196 struct i2c_client *client = to_i2c_client(bq->dev);
197 struct i2c_msg msg[2];
198 u8 val;
199 int ret;
200
201 if (!client->adapter)
202 return -ENODEV;
203
204 msg[0].addr = client->addr;
205 msg[0].flags = 0;
206 msg[0].buf = &reg;
207 msg[0].len = sizeof(reg);
208 msg[1].addr = client->addr;
209 msg[1].flags = I2C_M_RD;
210 msg[1].buf = &val;
211 msg[1].len = sizeof(val);
212
213 mutex_lock(&bq2415x_i2c_mutex);
214 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
215 mutex_unlock(&bq2415x_i2c_mutex);
216
217 if (ret < 0)
218 return ret;
219
220 return val;
221}
222
223/* read value from register, apply mask and right shift it */
224static int bq2415x_i2c_read_mask(struct bq2415x_device *bq, u8 reg,
6c47a3e0 225 u8 mask, u8 shift)
0bc98cc6
PR		 226{
227 int ret;
228
229 if (shift > 8)
230 return -EINVAL;
231
232 ret = bq2415x_i2c_read(bq, reg);
233 if (ret < 0)
234 return ret;
6c47a3e0 235 return (ret & mask) >> shift;
0bc98cc6
PR		 236}
237
238/* read value from register and return one specified bit */
239static int bq2415x_i2c_read_bit(struct bq2415x_device *bq, u8 reg, u8 bit)
240{
241 if (bit > 8)
242 return -EINVAL;
6c47a3e0 243 return bq2415x_i2c_read_mask(bq, reg, BIT(bit), bit);
0bc98cc6
PR		 244}
245
246/**** i2c write functions ****/
247
248/* write value to register */
249static int bq2415x_i2c_write(struct bq2415x_device *bq, u8 reg, u8 val)
250{
251 struct i2c_client *client = to_i2c_client(bq->dev);
252 struct i2c_msg msg[1];
253 u8 data[2];
254 int ret;
255
256 data[0] = reg;
257 data[1] = val;
258
259 msg[0].addr = client->addr;
260 msg[0].flags = 0;
261 msg[0].buf = data;
262 msg[0].len = ARRAY_SIZE(data);
263
264 mutex_lock(&bq2415x_i2c_mutex);
265 ret = i2c_transfer(client->adapter, msg, ARRAY_SIZE(msg));
266 mutex_unlock(&bq2415x_i2c_mutex);
267
268 /* i2c_transfer returns number of messages transferred */
269 if (ret < 0)
270 return ret;
271 else if (ret != 1)
272 return -EIO;
273
274 return 0;
275}
276
277/* read value from register, change it with mask left shifted and write back */
278static int bq2415x_i2c_write_mask(struct bq2415x_device *bq, u8 reg, u8 val,
6c47a3e0 279 u8 mask, u8 shift)
0bc98cc6
PR		 280{
281 int ret;
282
283 if (shift > 8)
284 return -EINVAL;
285
286 ret = bq2415x_i2c_read(bq, reg);
287 if (ret < 0)
288 return ret;
289
290 ret &= ~mask;
291 ret |= val << shift;
292
293 return bq2415x_i2c_write(bq, reg, ret);
294}
295
296/* change only one bit in register */
297static int bq2415x_i2c_write_bit(struct bq2415x_device *bq, u8 reg,
6c47a3e0 298 bool val, u8 bit)
0bc98cc6
PR		 299{
300 if (bit > 8)
301 return -EINVAL;
6c47a3e0 302 return bq2415x_i2c_write_mask(bq, reg, val, BIT(bit), bit);
0bc98cc6
PR		 303}
304
305/**** global functions ****/
306
307/* exec command function */
308static int bq2415x_exec_command(struct bq2415x_device *bq,
309 enum bq2415x_command command)
310{
311 int ret;
6c47a3e0 312
0bc98cc6
PR		 313 switch (command) {
314 case BQ2415X_TIMER_RESET:
315 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS,
316 1, BQ2415X_BIT_TMR_RST);
317 case BQ2415X_OTG_STATUS:
318 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
319 BQ2415X_BIT_OTG);
320 case BQ2415X_STAT_PIN_STATUS:
321 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
322 BQ2415X_BIT_EN_STAT);
323 case BQ2415X_STAT_PIN_ENABLE:
324 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS, 1,
325 BQ2415X_BIT_EN_STAT);
326 case BQ2415X_STAT_PIN_DISABLE:
327 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_STATUS, 0,
328 BQ2415X_BIT_EN_STAT);
329 case BQ2415X_CHARGE_STATUS:
330 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_STATUS,
331 BQ2415X_MASK_STAT, BQ2415X_SHIFT_STAT);
332 case BQ2415X_BOOST_STATUS:
333 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_STATUS,
334 BQ2415X_BIT_BOOST);
335 case BQ2415X_FAULT_STATUS:
336 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_STATUS,
337 BQ2415X_MASK_FAULT, BQ2415X_SHIFT_FAULT);
338
339 case BQ2415X_CHARGE_TERMINATION_STATUS:
340 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
341 BQ2415X_BIT_TE);
342 case BQ2415X_CHARGE_TERMINATION_ENABLE:
343 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
344 1, BQ2415X_BIT_TE);
345 case BQ2415X_CHARGE_TERMINATION_DISABLE:
346 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
347 0, BQ2415X_BIT_TE);
348 case BQ2415X_CHARGER_STATUS:
349 ret = bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
350 BQ2415X_BIT_CE);
351 if (ret < 0)
352 return ret;
42d0631b 353 return ret > 0 ? 0 : 1;
0bc98cc6
PR		 354 case BQ2415X_CHARGER_ENABLE:
355 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
356 0, BQ2415X_BIT_CE);
357 case BQ2415X_CHARGER_DISABLE:
358 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
359 1, BQ2415X_BIT_CE);
360 case BQ2415X_HIGH_IMPEDANCE_STATUS:
361 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
362 BQ2415X_BIT_HZ_MODE);
363 case BQ2415X_HIGH_IMPEDANCE_ENABLE:
364 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
365 1, BQ2415X_BIT_HZ_MODE);
366 case BQ2415X_HIGH_IMPEDANCE_DISABLE:
367 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
368 0, BQ2415X_BIT_HZ_MODE);
369 case BQ2415X_BOOST_MODE_STATUS:
370 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_CONTROL,
371 BQ2415X_BIT_OPA_MODE);
372 case BQ2415X_BOOST_MODE_ENABLE:
373 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
374 1, BQ2415X_BIT_OPA_MODE);
375 case BQ2415X_BOOST_MODE_DISABLE:
376 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_CONTROL,
377 0, BQ2415X_BIT_OPA_MODE);
378
379 case BQ2415X_OTG_LEVEL:
380 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_VOLTAGE,
381 BQ2415X_BIT_OTG_PL);
382 case BQ2415X_OTG_ACTIVATE_HIGH:
383 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
384 1, BQ2415X_BIT_OTG_PL);
385 case BQ2415X_OTG_ACTIVATE_LOW:
386 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
387 0, BQ2415X_BIT_OTG_PL);
388 case BQ2415X_OTG_PIN_STATUS:
389 return bq2415x_i2c_read_bit(bq, BQ2415X_REG_VOLTAGE,
390 BQ2415X_BIT_OTG_EN);
391 case BQ2415X_OTG_PIN_ENABLE:
392 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
393 1, BQ2415X_BIT_OTG_EN);
394 case BQ2415X_OTG_PIN_DISABLE:
395 return bq2415x_i2c_write_bit(bq, BQ2415X_REG_VOLTAGE,
396 0, BQ2415X_BIT_OTG_EN);
397
398 case BQ2415X_VENDER_CODE:
399 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
400 BQ2415X_MASK_VENDER, BQ2415X_SHIFT_VENDER);
401 case BQ2415X_PART_NUMBER:
402 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
403 BQ2415X_MASK_PN, BQ2415X_SHIFT_PN);
404 case BQ2415X_REVISION:
405 return bq2415x_i2c_read_mask(bq, BQ2415X_REG_VENDER,
406 BQ2415X_MASK_REVISION, BQ2415X_SHIFT_REVISION);
0bc98cc6 407 }
6c47a3e0 408 return -EINVAL;
0bc98cc6
PR		 409}
410
411/* detect chip type */
412static enum bq2415x_chip bq2415x_detect_chip(struct bq2415x_device *bq)
413{
414 struct i2c_client *client = to_i2c_client(bq->dev);
415 int ret = bq2415x_exec_command(bq, BQ2415X_PART_NUMBER);
416
417 if (ret < 0)
418 return ret;
419
420 switch (client->addr) {
421 case 0x6b:
422 switch (ret) {
423 case 0:
424 if (bq->chip == BQ24151A)
425 return bq->chip;
42d0631b 426 return BQ24151;
0bc98cc6
PR		 427 case 1:
428 if (bq->chip == BQ24150A ||
429 bq->chip == BQ24152 ||
430 bq->chip == BQ24155)
431 return bq->chip;
42d0631b 432 return BQ24150;
0bc98cc6
PR		 433 case 2:
434 if (bq->chip == BQ24153A)
435 return bq->chip;
42d0631b 436 return BQ24153;
0bc98cc6
PR		 437 default:
438 return BQUNKNOWN;
439 }
440 break;
441
442 case 0x6a:
443 switch (ret) {
444 case 0:
445 if (bq->chip == BQ24156A)
446 return bq->chip;
42d0631b 447 return BQ24156;
0bc98cc6 448 case 2:
0e1392d9
AMN		 449 if (bq->chip == BQ24157S)
450 return bq->chip;
0bc98cc6
PR		 451 return BQ24158;
452 default:
453 return BQUNKNOWN;
454 }
455 break;
456 }
457
458 return BQUNKNOWN;
459}
460
461/* detect chip revision */
462static int bq2415x_detect_revision(struct bq2415x_device *bq)
463{
464 int ret = bq2415x_exec_command(bq, BQ2415X_REVISION);
465 int chip = bq2415x_detect_chip(bq);
6c47a3e0 466
0bc98cc6
PR		 467 if (ret < 0 || chip < 0)
468 return -1;
469
470 switch (chip) {
471 case BQ24150:
472 case BQ24150A:
473 case BQ24151:
474 case BQ24151A:
475 case BQ24152:
476 if (ret >= 0 && ret <= 3)
477 return ret;
42d0631b 478 return -1;
0bc98cc6
PR		 479 case BQ24153:
480 case BQ24153A:
481 case BQ24156:
482 case BQ24156A:
0e1392d9 483 case BQ24157S:
0bc98cc6
PR		 484 case BQ24158:
485 if (ret == 3)
486 return 0;
487 else if (ret == 1)
488 return 1;
42d0631b 489 return -1;
0bc98cc6
PR		 490 case BQ24155:
491 if (ret == 3)
492 return 3;
42d0631b 493 return -1;
0bc98cc6
PR		 494 case BQUNKNOWN:
495 return -1;
496 }
497
498 return -1;
499}
500
501/* return chip vender code */
502static int bq2415x_get_vender_code(struct bq2415x_device *bq)
503{
6c47a3e0
AV		 504 int ret;
505
506 ret = bq2415x_exec_command(bq, BQ2415X_VENDER_CODE);
0bc98cc6
PR		 507 if (ret < 0)
508 return 0;
6c47a3e0
AV		 509
510 /* convert to binary */
511 return (ret & 0x1) +
512 ((ret >> 1) & 0x1) * 10 +
513 ((ret >> 2) & 0x1) * 100;
0bc98cc6
PR		 514}
515
516/* reset all chip registers to default state */
517static void bq2415x_reset_chip(struct bq2415x_device *bq)
518{
519 bq2415x_i2c_write(bq, BQ2415X_REG_CURRENT, BQ2415X_RESET_CURRENT);
520 bq2415x_i2c_write(bq, BQ2415X_REG_VOLTAGE, BQ2415X_RESET_VOLTAGE);
521 bq2415x_i2c_write(bq, BQ2415X_REG_CONTROL, BQ2415X_RESET_CONTROL);
522 bq2415x_i2c_write(bq, BQ2415X_REG_STATUS, BQ2415X_RESET_STATUS);
523 bq->timer_error = NULL;
524}
525
526/**** properties functions ****/
527
528/* set current limit in mA */
529static int bq2415x_set_current_limit(struct bq2415x_device *bq, int mA)
530{
531 int val;
6c47a3e0 532
0bc98cc6
PR		 533 if (mA <= 100)
534 val = 0;
535 else if (mA <= 500)
536 val = 1;
537 else if (mA <= 800)
538 val = 2;
539 else
540 val = 3;
6c47a3e0 541
0bc98cc6
PR		 542 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CONTROL, val,
543 BQ2415X_MASK_LIMIT, BQ2415X_SHIFT_LIMIT);
544}
545
546/* get current limit in mA */
547static int bq2415x_get_current_limit(struct bq2415x_device *bq)
548{
6c47a3e0
AV		 549 int ret;
550
551 ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CONTROL,
0bc98cc6
PR		 552 BQ2415X_MASK_LIMIT, BQ2415X_SHIFT_LIMIT);
553 if (ret < 0)
554 return ret;
555 else if (ret == 0)
556 return 100;
557 else if (ret == 1)
558 return 500;
559 else if (ret == 2)
560 return 800;
561 else if (ret == 3)
562 return 1800;
6c47a3e0 563 return -EINVAL;
0bc98cc6
PR		 564}
565
566/* set weak battery voltage in mV */
567static int bq2415x_set_weak_battery_voltage(struct bq2415x_device *bq, int mV)
568{
0bc98cc6 569 int val;
6c47a3e0
AV		 570
571 /* round to 100mV */
0bc98cc6
PR		 572 if (mV <= 3400 + 50)
573 val = 0;
574 else if (mV <= 3500 + 50)
575 val = 1;
576 else if (mV <= 3600 + 50)
577 val = 2;
578 else
579 val = 3;
6c47a3e0 580
0bc98cc6
PR		 581 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CONTROL, val,
582 BQ2415X_MASK_VLOWV, BQ2415X_SHIFT_VLOWV);
583}
584
585/* get weak battery voltage in mV */
586static int bq2415x_get_weak_battery_voltage(struct bq2415x_device *bq)
587{
6c47a3e0
AV		 588 int ret;
589
590 ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CONTROL,
0bc98cc6
PR		 591 BQ2415X_MASK_VLOWV, BQ2415X_SHIFT_VLOWV);
592 if (ret < 0)
593 return ret;
6c47a3e0 594 return 100 * (34 + ret);
0bc98cc6
PR		 595}
596
597/* set battery regulation voltage in mV */
598static int bq2415x_set_battery_regulation_voltage(struct bq2415x_device *bq,
6c47a3e0 599 int mV)
0bc98cc6
PR		 600{
601 int val = (mV/10 - 350) / 2;
602
3ed5cd79
AB		 603 /*
604 * According to datasheet, maximum battery regulation voltage is
605 * 4440mV which is b101111 = 47.
606 */
0bc98cc6
PR		 607 if (val < 0)
608 val = 0;
3ed5cd79 609 else if (val > 47)
0bc98cc6
PR		 610 return -EINVAL;
611
612 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_VOLTAGE, val,
613 BQ2415X_MASK_VO, BQ2415X_SHIFT_VO);
614}
615
616/* get battery regulation voltage in mV */
617static int bq2415x_get_battery_regulation_voltage(struct bq2415x_device *bq)
618{
619 int ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_VOLTAGE,
620 BQ2415X_MASK_VO, BQ2415X_SHIFT_VO);
6c47a3e0 621
0bc98cc6
PR		 622 if (ret < 0)
623 return ret;
6c47a3e0 624 return 10 * (350 + 2*ret);
0bc98cc6
PR		 625}
626
627/* set charge current in mA (platform data must provide resistor sense) */
628static int bq2415x_set_charge_current(struct bq2415x_device *bq, int mA)
629{
630 int val;
6c47a3e0 631
0bc98cc6
PR		 632 if (bq->init_data.resistor_sense <= 0)
633 return -ENOSYS;
634
635 val = (mA * bq->init_data.resistor_sense - 37400) / 6800;
0bc98cc6
PR		 636 if (val < 0)
637 val = 0;
638 else if (val > 7)
639 val = 7;
640
641 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CURRENT, val,
642 BQ2415X_MASK_VI_CHRG | BQ2415X_MASK_RESET,
643 BQ2415X_SHIFT_VI_CHRG);
644}
645
646/* get charge current in mA (platform data must provide resistor sense) */
647static int bq2415x_get_charge_current(struct bq2415x_device *bq)
648{
649 int ret;
6c47a3e0 650
0bc98cc6
PR		 651 if (bq->init_data.resistor_sense <= 0)
652 return -ENOSYS;
653
654 ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CURRENT,
655 BQ2415X_MASK_VI_CHRG, BQ2415X_SHIFT_VI_CHRG);
656 if (ret < 0)
657 return ret;
6c47a3e0 658 return (37400 + 6800*ret) / bq->init_data.resistor_sense;
0bc98cc6
PR		 659}
660
661/* set termination current in mA (platform data must provide resistor sense) */
662static int bq2415x_set_termination_current(struct bq2415x_device *bq, int mA)
663{
664 int val;
6c47a3e0 665
0bc98cc6
PR		 666 if (bq->init_data.resistor_sense <= 0)
667 return -ENOSYS;
668
669 val = (mA * bq->init_data.resistor_sense - 3400) / 3400;
0bc98cc6
PR		 670 if (val < 0)
671 val = 0;
672 else if (val > 7)
673 val = 7;
674
675 return bq2415x_i2c_write_mask(bq, BQ2415X_REG_CURRENT, val,
676 BQ2415X_MASK_VI_TERM | BQ2415X_MASK_RESET,
677 BQ2415X_SHIFT_VI_TERM);
678}
679
680/* get termination current in mA (platform data must provide resistor sense) */
681static int bq2415x_get_termination_current(struct bq2415x_device *bq)
682{
683 int ret;
6c47a3e0 684
0bc98cc6
PR		 685 if (bq->init_data.resistor_sense <= 0)
686 return -ENOSYS;
687
688 ret = bq2415x_i2c_read_mask(bq, BQ2415X_REG_CURRENT,
689 BQ2415X_MASK_VI_TERM, BQ2415X_SHIFT_VI_TERM);
690 if (ret < 0)
691 return ret;
6c47a3e0 692 return (3400 + 3400*ret) / bq->init_data.resistor_sense;
0bc98cc6
PR		 693}
694
695/* set default value of property */
696#define bq2415x_set_default_value(bq, prop) \
697 do { \
698 int ret = 0; \
699 if (bq->init_data.prop != -1) \
700 ret = bq2415x_set_##prop(bq, bq->init_data.prop); \
701 if (ret < 0) \
702 return ret; \
703 } while (0)
704
705/* set default values of all properties */
706static int bq2415x_set_defaults(struct bq2415x_device *bq)
707{
708 bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_DISABLE);
709 bq2415x_exec_command(bq, BQ2415X_CHARGER_DISABLE);
710 bq2415x_exec_command(bq, BQ2415X_CHARGE_TERMINATION_DISABLE);
6c47a3e0 711
0bc98cc6
PR		 712 bq2415x_set_default_value(bq, current_limit);
713 bq2415x_set_default_value(bq, weak_battery_voltage);
714 bq2415x_set_default_value(bq, battery_regulation_voltage);
6c47a3e0 715
0bc98cc6
PR		 716 if (bq->init_data.resistor_sense > 0) {
717 bq2415x_set_default_value(bq, charge_current);
718 bq2415x_set_default_value(bq, termination_current);
719 bq2415x_exec_command(bq, BQ2415X_CHARGE_TERMINATION_ENABLE);
720 }
6c47a3e0 721
0bc98cc6
PR		 722 bq2415x_exec_command(bq, BQ2415X_CHARGER_ENABLE);
723 return 0;
724}
725
726/**** charger mode functions ****/
727
728/* set charger mode */
729static int bq2415x_set_mode(struct bq2415x_device *bq, enum bq2415x_mode mode)
730{
731 int ret = 0;
732 int charger = 0;
733 int boost = 0;
734
0bc98cc6
PR		 735 if (mode == BQ2415X_MODE_BOOST)
736 boost = 1;
ac6324e7
PR		 737 else if (mode != BQ2415X_MODE_OFF)
738 charger = 1;
0bc98cc6
PR		 739
740 if (!charger)
741 ret = bq2415x_exec_command(bq, BQ2415X_CHARGER_DISABLE);
742
743 if (!boost)
744 ret = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_DISABLE);
745
746 if (ret < 0)
747 return ret;
748
749 switch (mode) {
ac6324e7
PR		 750 case BQ2415X_MODE_OFF:
751 dev_dbg(bq->dev, "changing mode to: Offline\n");
752 ret = bq2415x_set_current_limit(bq, 100);
753 break;
0bc98cc6
PR		 754 case BQ2415X_MODE_NONE:
755 dev_dbg(bq->dev, "changing mode to: N/A\n");
756 ret = bq2415x_set_current_limit(bq, 100);
757 break;
758 case BQ2415X_MODE_HOST_CHARGER:
759 dev_dbg(bq->dev, "changing mode to: Host/HUB charger\n");
760 ret = bq2415x_set_current_limit(bq, 500);
761 break;
762 case BQ2415X_MODE_DEDICATED_CHARGER:
763 dev_dbg(bq->dev, "changing mode to: Dedicated charger\n");
764 ret = bq2415x_set_current_limit(bq, 1800);
765 break;
766 case BQ2415X_MODE_BOOST: /* Boost mode */
767 dev_dbg(bq->dev, "changing mode to: Boost\n");
768 ret = bq2415x_set_current_limit(bq, 100);
769 break;
770 }
771
772 if (ret < 0)
773 return ret;
774
775 if (charger)
776 ret = bq2415x_exec_command(bq, BQ2415X_CHARGER_ENABLE);
777 else if (boost)
778 ret = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_ENABLE);
779
780 if (ret < 0)
781 return ret;
782
783 bq2415x_set_default_value(bq, weak_battery_voltage);
784 bq2415x_set_default_value(bq, battery_regulation_voltage);
785
786 bq->mode = mode;
787 sysfs_notify(&bq->charger.dev->kobj, NULL, "mode");
788
789 return 0;
790
791}
792
32260308
PR		 793static int bq2415x_notifier_call(struct notifier_block *nb,
794 unsigned long val, void *v)
0bc98cc6 795{
32260308
PR		 796 struct bq2415x_device *bq =
797 container_of(nb, struct bq2415x_device, nb);
798 struct power_supply *psy = v;
799 enum bq2415x_mode mode;
800 union power_supply_propval prop;
801 int ret;
802 int mA;
0bc98cc6 803
32260308
PR		 804 if (val != PSY_EVENT_PROP_CHANGED)
805 return NOTIFY_OK;
806
faffd234 807 if (psy != bq->notify_psy)
32260308
PR		 808 return NOTIFY_OK;
809
810 dev_dbg(bq->dev, "notifier call was called\n");
811
812 ret = psy->get_property(psy, POWER_SUPPLY_PROP_CURRENT_MAX, &prop);
813 if (ret != 0)
814 return NOTIFY_OK;
815
816 mA = prop.intval;
817
818 if (mA == 0)
819 mode = BQ2415X_MODE_OFF;
820 else if (mA < 500)
821 mode = BQ2415X_MODE_NONE;
822 else if (mA < 1800)
823 mode = BQ2415X_MODE_HOST_CHARGER;
824 else
825 mode = BQ2415X_MODE_DEDICATED_CHARGER;
826
827 if (bq->reported_mode == mode)
828 return NOTIFY_OK;
0bc98cc6 829
0bc98cc6
PR		 830 bq->reported_mode = mode;
831
832 /* if automode is not enabled do not tell about reported_mode */
833 if (bq->automode < 1)
32260308 834 return NOTIFY_OK;
0bc98cc6 835
3c018504 836 schedule_delayed_work(&bq->work, 0);
0bc98cc6 837
32260308 838 return NOTIFY_OK;
0bc98cc6
PR		 839}
840
841/**** timer functions ****/
842
843/* enable/disable auto resetting chip timer */
844static void bq2415x_set_autotimer(struct bq2415x_device *bq, int state)
845{
846 mutex_lock(&bq2415x_timer_mutex);
847
848 if (bq->autotimer == state) {
849 mutex_unlock(&bq2415x_timer_mutex);
850 return;
851 }
852
853 bq->autotimer = state;
854
855 if (state) {
856 schedule_delayed_work(&bq->work, BQ2415X_TIMER_TIMEOUT * HZ);
857 bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
858 bq->timer_error = NULL;
859 } else {
860 cancel_delayed_work_sync(&bq->work);
861 }
862
863 mutex_unlock(&bq2415x_timer_mutex);
864}
865
866/* called by bq2415x_timer_work on timer error */
867static void bq2415x_timer_error(struct bq2415x_device *bq, const char *msg)
868{
869 bq->timer_error = msg;
870 sysfs_notify(&bq->charger.dev->kobj, NULL, "timer");
871 dev_err(bq->dev, "%s\n", msg);
872 if (bq->automode > 0)
873 bq->automode = 0;
ac6324e7 874 bq2415x_set_mode(bq, BQ2415X_MODE_OFF);
0bc98cc6
PR		 875 bq2415x_set_autotimer(bq, 0);
876}
877
878/* delayed work function for auto resetting chip timer */
879static void bq2415x_timer_work(struct work_struct *work)
880{
881 struct bq2415x_device *bq = container_of(work, struct bq2415x_device,
6c47a3e0
AV		 882 work.work);
883 int ret;
884 int error;
885 int boost;
0bc98cc6 886
3c018504
SR		 887 if (bq->automode > 0 && (bq->reported_mode != bq->mode)) {
888 sysfs_notify(&bq->charger.dev->kobj, NULL, "reported_mode");
889 bq2415x_set_mode(bq, bq->reported_mode);
890 }
891
0bc98cc6
PR		 892 if (!bq->autotimer)
893 return;
894
895 ret = bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
896 if (ret < 0) {
897 bq2415x_timer_error(bq, "Resetting timer failed");
898 return;
899 }
900
901 boost = bq2415x_exec_command(bq, BQ2415X_BOOST_MODE_STATUS);
902 if (boost < 0) {
903 bq2415x_timer_error(bq, "Unknown error");
904 return;
905 }
906
907 error = bq2415x_exec_command(bq, BQ2415X_FAULT_STATUS);
908 if (error < 0) {
909 bq2415x_timer_error(bq, "Unknown error");
910 return;
911 }
912
913 if (boost) {
914 switch (error) {
915 /* Non fatal errors, chip is OK */
916 case 0: /* No error */
917 break;
918 case 6: /* Timer expired */
919 dev_err(bq->dev, "Timer expired\n");
920 break;
921 case 3: /* Battery voltage too low */
922 dev_err(bq->dev, "Battery voltage to low\n");
923 break;
924
925 /* Fatal errors, disable and reset chip */
926 case 1: /* Overvoltage protection (chip fried) */
927 bq2415x_timer_error(bq,
928 "Overvoltage protection (chip fried)");
929 return;
930 case 2: /* Overload */
931 bq2415x_timer_error(bq, "Overload");
932 return;
933 case 4: /* Battery overvoltage protection */
934 bq2415x_timer_error(bq,
935 "Battery overvoltage protection");
936 return;
937 case 5: /* Thermal shutdown (too hot) */
938 bq2415x_timer_error(bq,
939 "Thermal shutdown (too hot)");
940 return;
941 case 7: /* N/A */
942 bq2415x_timer_error(bq, "Unknown error");
943 return;
944 }
945 } else {
946 switch (error) {
947 /* Non fatal errors, chip is OK */
948 case 0: /* No error */
949 break;
950 case 2: /* Sleep mode */
951 dev_err(bq->dev, "Sleep mode\n");
952 break;
953 case 3: /* Poor input source */
954 dev_err(bq->dev, "Poor input source\n");
955 break;
956 case 6: /* Timer expired */
957 dev_err(bq->dev, "Timer expired\n");
958 break;
959 case 7: /* No battery */
960 dev_err(bq->dev, "No battery\n");
961 break;
962
963 /* Fatal errors, disable and reset chip */
964 case 1: /* Overvoltage protection (chip fried) */
965 bq2415x_timer_error(bq,
966 "Overvoltage protection (chip fried)");
967 return;
968 case 4: /* Battery overvoltage protection */
969 bq2415x_timer_error(bq,
970 "Battery overvoltage protection");
971 return;
972 case 5: /* Thermal shutdown (too hot) */
973 bq2415x_timer_error(bq,
974 "Thermal shutdown (too hot)");
975 return;
976 }
977 }
978
979 schedule_delayed_work(&bq->work, BQ2415X_TIMER_TIMEOUT * HZ);
980}
981
982/**** power supply interface code ****/
983
984static enum power_supply_property bq2415x_power_supply_props[] = {
985 /* TODO: maybe add more power supply properties */
986 POWER_SUPPLY_PROP_STATUS,
987 POWER_SUPPLY_PROP_MODEL_NAME,
988};
989
990static int bq2415x_power_supply_get_property(struct power_supply *psy,
6c47a3e0
AV		 991 enum power_supply_property psp,
992 union power_supply_propval *val)
0bc98cc6
PR		 993{
994 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 995 charger);
0bc98cc6
PR		 996 int ret;
997
998 switch (psp) {
999 case POWER_SUPPLY_PROP_STATUS:
1000 ret = bq2415x_exec_command(bq, BQ2415X_CHARGE_STATUS);
1001 if (ret < 0)
1002 return ret;
1003 else if (ret == 0) /* Ready */
1004 val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
1005 else if (ret == 1) /* Charge in progress */
1006 val->intval = POWER_SUPPLY_STATUS_CHARGING;
1007 else if (ret == 2) /* Charge done */
1008 val->intval = POWER_SUPPLY_STATUS_FULL;
1009 else
1010 val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
1011 break;
1012 case POWER_SUPPLY_PROP_MODEL_NAME:
1013 val->strval = bq->model;
1014 break;
1015 default:
1016 return -EINVAL;
1017 }
1018 return 0;
1019}
1020
1021static int bq2415x_power_supply_init(struct bq2415x_device *bq)
1022{
1023 int ret;
1024 int chip;
1025 char revstr[8];
1026
1027 bq->charger.name = bq->name;
1028 bq->charger.type = POWER_SUPPLY_TYPE_USB;
1029 bq->charger.properties = bq2415x_power_supply_props;
1030 bq->charger.num_properties = ARRAY_SIZE(bq2415x_power_supply_props);
1031 bq->charger.get_property = bq2415x_power_supply_get_property;
1032
1033 ret = bq2415x_detect_chip(bq);
1034 if (ret < 0)
1035 chip = BQUNKNOWN;
1036 else
1037 chip = ret;
1038
1039 ret = bq2415x_detect_revision(bq);
1040 if (ret < 0)
1041 strcpy(revstr, "unknown");
1042 else
1043 sprintf(revstr, "1.%d", ret);
1044
1045 bq->model = kasprintf(GFP_KERNEL,
1046 "chip %s, revision %s, vender code %.3d",
1047 bq2415x_chip_name[chip], revstr,
1048 bq2415x_get_vender_code(bq));
1049 if (!bq->model) {
1050 dev_err(bq->dev, "failed to allocate model name\n");
1051 return -ENOMEM;
1052 }
1053
2dc9215d 1054 ret = power_supply_register(bq->dev, &bq->charger, NULL);
0bc98cc6
PR		 1055 if (ret) {
1056 kfree(bq->model);
1057 return ret;
1058 }
1059
1060 return 0;
1061}
1062
1063static void bq2415x_power_supply_exit(struct bq2415x_device *bq)
1064{
1065 bq->autotimer = 0;
1066 if (bq->automode > 0)
1067 bq->automode = 0;
1068 cancel_delayed_work_sync(&bq->work);
1069 power_supply_unregister(&bq->charger);
1070 kfree(bq->model);
1071}
1072
1073/**** additional sysfs entries for power supply interface ****/
1074
1075/* show *_status entries */
1076static ssize_t bq2415x_sysfs_show_status(struct device *dev,
6c47a3e0
AV		 1077 struct device_attribute *attr,
1078 char *buf)
0bc98cc6
PR		 1079{
1080 struct power_supply *psy = dev_get_drvdata(dev);
1081 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1082 charger);
1083 enum bq2415x_command command;
1084 int ret;
1085
1086 if (strcmp(attr->attr.name, "otg_status") == 0)
1087 command = BQ2415X_OTG_STATUS;
1088 else if (strcmp(attr->attr.name, "charge_status") == 0)
1089 command = BQ2415X_CHARGE_STATUS;
1090 else if (strcmp(attr->attr.name, "boost_status") == 0)
1091 command = BQ2415X_BOOST_STATUS;
1092 else if (strcmp(attr->attr.name, "fault_status") == 0)
1093 command = BQ2415X_FAULT_STATUS;
1094 else
1095 return -EINVAL;
1096
1097 ret = bq2415x_exec_command(bq, command);
1098 if (ret < 0)
1099 return ret;
6c47a3e0 1100 return sprintf(buf, "%d\n", ret);
0bc98cc6
PR		 1101}
1102
6c47a3e0
AV		 1103/*
1104 * set timer entry:
1105 * auto - enable auto mode
1106 * off - disable auto mode
1107 * (other values) - reset chip timer
1108 */
0bc98cc6 1109static ssize_t bq2415x_sysfs_set_timer(struct device *dev,
6c47a3e0
AV		 1110 struct device_attribute *attr,
1111 const char *buf,
1112 size_t count)
0bc98cc6
PR		 1113{
1114 struct power_supply *psy = dev_get_drvdata(dev);
1115 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1116 charger);
1117 int ret = 0;
1118
1119 if (strncmp(buf, "auto", 4) == 0)
1120 bq2415x_set_autotimer(bq, 1);
1121 else if (strncmp(buf, "off", 3) == 0)
1122 bq2415x_set_autotimer(bq, 0);
1123 else
1124 ret = bq2415x_exec_command(bq, BQ2415X_TIMER_RESET);
1125
1126 if (ret < 0)
1127 return ret;
6c47a3e0 1128 return count;
0bc98cc6
PR		 1129}
1130
1131/* show timer entry (auto or off) */
1132static ssize_t bq2415x_sysfs_show_timer(struct device *dev,
6c47a3e0
AV		 1133 struct device_attribute *attr,
1134 char *buf)
0bc98cc6
PR		 1135{
1136 struct power_supply *psy = dev_get_drvdata(dev);
1137 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1138 charger);
0bc98cc6
PR		 1139
1140 if (bq->timer_error)
1141 return sprintf(buf, "%s\n", bq->timer_error);
1142
1143 if (bq->autotimer)
1144 return sprintf(buf, "auto\n");
6c47a3e0 1145 return sprintf(buf, "off\n");
0bc98cc6
PR		 1146}
1147
6c47a3e0
AV		 1148/*
1149 * set mode entry:
1150 * auto - if automode is supported, enable it and set mode to reported
1151 * none - disable charger and boost mode
1152 * host - charging mode for host/hub chargers (current limit 500mA)
1153 * dedicated - charging mode for dedicated chargers (unlimited current limit)
1154 * boost - disable charger and enable boost mode
1155 */
0bc98cc6 1156static ssize_t bq2415x_sysfs_set_mode(struct device *dev,
6c47a3e0
AV		 1157 struct device_attribute *attr,
1158 const char *buf,
1159 size_t count)
0bc98cc6
PR		 1160{
1161 struct power_supply *psy = dev_get_drvdata(dev);
1162 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1163 charger);
0bc98cc6
PR		 1164 enum bq2415x_mode mode;
1165 int ret = 0;
1166
1167 if (strncmp(buf, "auto", 4) == 0) {
1168 if (bq->automode < 0)
1169 return -ENOSYS;
1170 bq->automode = 1;
1171 mode = bq->reported_mode;
ac6324e7
PR		 1172 } else if (strncmp(buf, "off", 3) == 0) {
1173 if (bq->automode > 0)
1174 bq->automode = 0;
1175 mode = BQ2415X_MODE_OFF;
0bc98cc6
PR		 1176 } else if (strncmp(buf, "none", 4) == 0) {
1177 if (bq->automode > 0)
1178 bq->automode = 0;
1179 mode = BQ2415X_MODE_NONE;
1180 } else if (strncmp(buf, "host", 4) == 0) {
1181 if (bq->automode > 0)
1182 bq->automode = 0;
1183 mode = BQ2415X_MODE_HOST_CHARGER;
1184 } else if (strncmp(buf, "dedicated", 9) == 0) {
1185 if (bq->automode > 0)
1186 bq->automode = 0;
1187 mode = BQ2415X_MODE_DEDICATED_CHARGER;
1188 } else if (strncmp(buf, "boost", 5) == 0) {
1189 if (bq->automode > 0)
1190 bq->automode = 0;
1191 mode = BQ2415X_MODE_BOOST;
1192 } else if (strncmp(buf, "reset", 5) == 0) {
1193 bq2415x_reset_chip(bq);
1194 bq2415x_set_defaults(bq);
1195 if (bq->automode <= 0)
1196 return count;
1197 bq->automode = 1;
1198 mode = bq->reported_mode;
6c47a3e0 1199 } else {
0bc98cc6 1200 return -EINVAL;
6c47a3e0 1201 }
0bc98cc6
PR		 1202
1203 ret = bq2415x_set_mode(bq, mode);
1204 if (ret < 0)
1205 return ret;
6c47a3e0 1206 return count;
0bc98cc6
PR		 1207}
1208
1209/* show mode entry (auto, none, host, dedicated or boost) */
1210static ssize_t bq2415x_sysfs_show_mode(struct device *dev,
6c47a3e0
AV		 1211 struct device_attribute *attr,
1212 char *buf)
0bc98cc6
PR		 1213{
1214 struct power_supply *psy = dev_get_drvdata(dev);
1215 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
1216 charger);
1217 ssize_t ret = 0;
1218
1219 if (bq->automode > 0)
1220 ret += sprintf(buf+ret, "auto (");
1221
1222 switch (bq->mode) {
ac6324e7
PR		 1223 case BQ2415X_MODE_OFF:
1224 ret += sprintf(buf+ret, "off");
1225 break;
0bc98cc6
PR		 1226 case BQ2415X_MODE_NONE:
1227 ret += sprintf(buf+ret, "none");
1228 break;
1229 case BQ2415X_MODE_HOST_CHARGER:
1230 ret += sprintf(buf+ret, "host");
1231 break;
1232 case BQ2415X_MODE_DEDICATED_CHARGER:
1233 ret += sprintf(buf+ret, "dedicated");
1234 break;
1235 case BQ2415X_MODE_BOOST:
1236 ret += sprintf(buf+ret, "boost");
1237 break;
1238 }
1239
1240 if (bq->automode > 0)
1241 ret += sprintf(buf+ret, ")");
1242
1243 ret += sprintf(buf+ret, "\n");
1244 return ret;
1245}
1246
1247/* show reported_mode entry (none, host, dedicated or boost) */
1248static ssize_t bq2415x_sysfs_show_reported_mode(struct device *dev,
6c47a3e0
AV		 1249 struct device_attribute *attr,
1250 char *buf)
0bc98cc6
PR		 1251{
1252 struct power_supply *psy = dev_get_drvdata(dev);
1253 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1254 charger);
0bc98cc6
PR		 1255
1256 if (bq->automode < 0)
1257 return -EINVAL;
1258
1259 switch (bq->reported_mode) {
ac6324e7
PR		 1260 case BQ2415X_MODE_OFF:
1261 return sprintf(buf, "off\n");
0bc98cc6
PR		 1262 case BQ2415X_MODE_NONE:
1263 return sprintf(buf, "none\n");
1264 case BQ2415X_MODE_HOST_CHARGER:
1265 return sprintf(buf, "host\n");
1266 case BQ2415X_MODE_DEDICATED_CHARGER:
1267 return sprintf(buf, "dedicated\n");
1268 case BQ2415X_MODE_BOOST:
1269 return sprintf(buf, "boost\n");
1270 }
1271
1272 return -EINVAL;
1273}
1274
1275/* directly set raw value to chip register, format: 'register value' */
1276static ssize_t bq2415x_sysfs_set_registers(struct device *dev,
6c47a3e0
AV		 1277 struct device_attribute *attr,
1278 const char *buf,
1279 size_t count)
0bc98cc6
PR		 1280{
1281 struct power_supply *psy = dev_get_drvdata(dev);
1282 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1283 charger);
0bc98cc6
PR		 1284 ssize_t ret = 0;
1285 unsigned int reg;
1286 unsigned int val;
1287
1288 if (sscanf(buf, "%x %x", &reg, &val) != 2)
1289 return -EINVAL;
1290
1291 if (reg > 4 || val > 255)
1292 return -EINVAL;
1293
1294 ret = bq2415x_i2c_write(bq, reg, val);
1295 if (ret < 0)
1296 return ret;
6c47a3e0 1297 return count;
0bc98cc6
PR		 1298}
1299
1300/* print value of chip register, format: 'register=value' */
1301static ssize_t bq2415x_sysfs_print_reg(struct bq2415x_device *bq,
6c47a3e0
AV		 1302 u8 reg,
1303 char *buf)
0bc98cc6
PR		 1304{
1305 int ret = bq2415x_i2c_read(bq, reg);
6c47a3e0 1306
0bc98cc6
PR		 1307 if (ret < 0)
1308 return sprintf(buf, "%#.2x=error %d\n", reg, ret);
6c47a3e0 1309 return sprintf(buf, "%#.2x=%#.2x\n", reg, ret);
0bc98cc6
PR		 1310}
1311
1312/* show all raw values of chip register, format per line: 'register=value' */
1313static ssize_t bq2415x_sysfs_show_registers(struct device *dev,
6c47a3e0
AV		 1314 struct device_attribute *attr,
1315 char *buf)
0bc98cc6
PR		 1316{
1317 struct power_supply *psy = dev_get_drvdata(dev);
1318 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1319 charger);
0bc98cc6
PR		 1320 ssize_t ret = 0;
1321
1322 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_STATUS, buf+ret);
1323 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_CONTROL, buf+ret);
1324 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_VOLTAGE, buf+ret);
1325 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_VENDER, buf+ret);
1326 ret += bq2415x_sysfs_print_reg(bq, BQ2415X_REG_CURRENT, buf+ret);
1327 return ret;
1328}
1329
1330/* set current and voltage limit entries (in mA or mV) */
1331static ssize_t bq2415x_sysfs_set_limit(struct device *dev,
6c47a3e0
AV		 1332 struct device_attribute *attr,
1333 const char *buf,
1334 size_t count)
0bc98cc6
PR		 1335{
1336 struct power_supply *psy = dev_get_drvdata(dev);
1337 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1338 charger);
0bc98cc6
PR		 1339 long val;
1340 int ret;
1341
1342 if (kstrtol(buf, 10, &val) < 0)
1343 return -EINVAL;
1344
1345 if (strcmp(attr->attr.name, "current_limit") == 0)
1346 ret = bq2415x_set_current_limit(bq, val);
1347 else if (strcmp(attr->attr.name, "weak_battery_voltage") == 0)
1348 ret = bq2415x_set_weak_battery_voltage(bq, val);
1349 else if (strcmp(attr->attr.name, "battery_regulation_voltage") == 0)
1350 ret = bq2415x_set_battery_regulation_voltage(bq, val);
1351 else if (strcmp(attr->attr.name, "charge_current") == 0)
1352 ret = bq2415x_set_charge_current(bq, val);
1353 else if (strcmp(attr->attr.name, "termination_current") == 0)
1354 ret = bq2415x_set_termination_current(bq, val);
1355 else
1356 return -EINVAL;
1357
1358 if (ret < 0)
1359 return ret;
6c47a3e0 1360 return count;
0bc98cc6
PR		 1361}
1362
1363/* show current and voltage limit entries (in mA or mV) */
1364static ssize_t bq2415x_sysfs_show_limit(struct device *dev,
6c47a3e0
AV		 1365 struct device_attribute *attr,
1366 char *buf)
0bc98cc6
PR		 1367{
1368 struct power_supply *psy = dev_get_drvdata(dev);
1369 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1370 charger);
0bc98cc6
PR		 1371 int ret;
1372
1373 if (strcmp(attr->attr.name, "current_limit") == 0)
1374 ret = bq2415x_get_current_limit(bq);
1375 else if (strcmp(attr->attr.name, "weak_battery_voltage") == 0)
1376 ret = bq2415x_get_weak_battery_voltage(bq);
1377 else if (strcmp(attr->attr.name, "battery_regulation_voltage") == 0)
1378 ret = bq2415x_get_battery_regulation_voltage(bq);
1379 else if (strcmp(attr->attr.name, "charge_current") == 0)
1380 ret = bq2415x_get_charge_current(bq);
1381 else if (strcmp(attr->attr.name, "termination_current") == 0)
1382 ret = bq2415x_get_termination_current(bq);
1383 else
1384 return -EINVAL;
1385
1386 if (ret < 0)
1387 return ret;
6c47a3e0 1388 return sprintf(buf, "%d\n", ret);
0bc98cc6
PR		 1389}
1390
1391/* set *_enable entries */
1392static ssize_t bq2415x_sysfs_set_enable(struct device *dev,
6c47a3e0
AV		 1393 struct device_attribute *attr,
1394 const char *buf,
1395 size_t count)
0bc98cc6
PR		 1396{
1397 struct power_supply *psy = dev_get_drvdata(dev);
1398 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1399 charger);
0bc98cc6
PR		 1400 enum bq2415x_command command;
1401 long val;
1402 int ret;
1403
1404 if (kstrtol(buf, 10, &val) < 0)
1405 return -EINVAL;
1406
1407 if (strcmp(attr->attr.name, "charge_termination_enable") == 0)
1408 command = val ? BQ2415X_CHARGE_TERMINATION_ENABLE :
1409 BQ2415X_CHARGE_TERMINATION_DISABLE;
1410 else if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
1411 command = val ? BQ2415X_HIGH_IMPEDANCE_ENABLE :
1412 BQ2415X_HIGH_IMPEDANCE_DISABLE;
1413 else if (strcmp(attr->attr.name, "otg_pin_enable") == 0)
1414 command = val ? BQ2415X_OTG_PIN_ENABLE :
1415 BQ2415X_OTG_PIN_DISABLE;
1416 else if (strcmp(attr->attr.name, "stat_pin_enable") == 0)
1417 command = val ? BQ2415X_STAT_PIN_ENABLE :
1418 BQ2415X_STAT_PIN_DISABLE;
1419 else
1420 return -EINVAL;
1421
1422 ret = bq2415x_exec_command(bq, command);
1423 if (ret < 0)
1424 return ret;
6c47a3e0 1425 return count;
0bc98cc6
PR		 1426}
1427
1428/* show *_enable entries */
1429static ssize_t bq2415x_sysfs_show_enable(struct device *dev,
6c47a3e0
AV		 1430 struct device_attribute *attr,
1431 char *buf)
0bc98cc6
PR		 1432{
1433 struct power_supply *psy = dev_get_drvdata(dev);
1434 struct bq2415x_device *bq = container_of(psy, struct bq2415x_device,
6c47a3e0 1435 charger);
0bc98cc6
PR		 1436 enum bq2415x_command command;
1437 int ret;
1438
1439 if (strcmp(attr->attr.name, "charge_termination_enable") == 0)
1440 command = BQ2415X_CHARGE_TERMINATION_STATUS;
1441 else if (strcmp(attr->attr.name, "high_impedance_enable") == 0)
1442 command = BQ2415X_HIGH_IMPEDANCE_STATUS;
1443 else if (strcmp(attr->attr.name, "otg_pin_enable") == 0)
1444 command = BQ2415X_OTG_PIN_STATUS;
1445 else if (strcmp(attr->attr.name, "stat_pin_enable") == 0)
1446 command = BQ2415X_STAT_PIN_STATUS;
1447 else
1448 return -EINVAL;
1449
1450 ret = bq2415x_exec_command(bq, command);
1451 if (ret < 0)
1452 return ret;
6c47a3e0 1453 return sprintf(buf, "%d\n", ret);
0bc98cc6
PR		 1454}
1455
1456static DEVICE_ATTR(current_limit, S_IWUSR | S_IRUGO,
1457 bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1458static DEVICE_ATTR(weak_battery_voltage, S_IWUSR | S_IRUGO,
1459 bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1460static DEVICE_ATTR(battery_regulation_voltage, S_IWUSR | S_IRUGO,
1461 bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1462static DEVICE_ATTR(charge_current, S_IWUSR | S_IRUGO,
1463 bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1464static DEVICE_ATTR(termination_current, S_IWUSR | S_IRUGO,
1465 bq2415x_sysfs_show_limit, bq2415x_sysfs_set_limit);
1466
1467static DEVICE_ATTR(charge_termination_enable, S_IWUSR | S_IRUGO,
1468 bq2415x_sysfs_show_enable, bq2415x_sysfs_set_enable);
1469static DEVICE_ATTR(high_impedance_enable, S_IWUSR | S_IRUGO,
1470 bq2415x_sysfs_show_enable, bq2415x_sysfs_set_enable);
1471static DEVICE_ATTR(otg_pin_enable, S_IWUSR | S_IRUGO,
1472 bq2415x_sysfs_show_enable, bq2415x_sysfs_set_enable);
1473static DEVICE_ATTR(stat_pin_enable, S_IWUSR | S_IRUGO,
1474 bq2415x_sysfs_show_enable, bq2415x_sysfs_set_enable);
1475
1476static DEVICE_ATTR(reported_mode, S_IRUGO,
1477 bq2415x_sysfs_show_reported_mode, NULL);
1478static DEVICE_ATTR(mode, S_IWUSR | S_IRUGO,
1479 bq2415x_sysfs_show_mode, bq2415x_sysfs_set_mode);
1480static DEVICE_ATTR(timer, S_IWUSR | S_IRUGO,
1481 bq2415x_sysfs_show_timer, bq2415x_sysfs_set_timer);
1482
1483static DEVICE_ATTR(registers, S_IWUSR | S_IRUGO,
1484 bq2415x_sysfs_show_registers, bq2415x_sysfs_set_registers);
1485
1486static DEVICE_ATTR(otg_status, S_IRUGO, bq2415x_sysfs_show_status, NULL);
1487static DEVICE_ATTR(charge_status, S_IRUGO, bq2415x_sysfs_show_status, NULL);
1488static DEVICE_ATTR(boost_status, S_IRUGO, bq2415x_sysfs_show_status, NULL);
1489static DEVICE_ATTR(fault_status, S_IRUGO, bq2415x_sysfs_show_status, NULL);
1490
1491static struct attribute *bq2415x_sysfs_attributes[] = {
6c47a3e0
AV		 1492 /*
1493 * TODO: some (appropriate) of these attrs should be switched to
1494 * use power supply class props.
1495 */
0bc98cc6
PR		 1496 &dev_attr_current_limit.attr,
1497 &dev_attr_weak_battery_voltage.attr,
1498 &dev_attr_battery_regulation_voltage.attr,
1499 &dev_attr_charge_current.attr,
1500 &dev_attr_termination_current.attr,
1501
1502 &dev_attr_charge_termination_enable.attr,
1503 &dev_attr_high_impedance_enable.attr,
1504 &dev_attr_otg_pin_enable.attr,
1505 &dev_attr_stat_pin_enable.attr,
1506
1507 &dev_attr_reported_mode.attr,
1508 &dev_attr_mode.attr,
1509 &dev_attr_timer.attr,
1510
1511 &dev_attr_registers.attr,
1512
1513 &dev_attr_otg_status.attr,
1514 &dev_attr_charge_status.attr,
1515 &dev_attr_boost_status.attr,
1516 &dev_attr_fault_status.attr,
1517 NULL,
1518};
1519
1520static const struct attribute_group bq2415x_sysfs_attr_group = {
1521 .attrs = bq2415x_sysfs_attributes,
1522};
1523
1524static int bq2415x_sysfs_init(struct bq2415x_device *bq)
1525{
1526 return sysfs_create_group(&bq->charger.dev->kobj,
1527 &bq2415x_sysfs_attr_group);
1528}
1529
1530static void bq2415x_sysfs_exit(struct bq2415x_device *bq)
1531{
1532 sysfs_remove_group(&bq->charger.dev->kobj, &bq2415x_sysfs_attr_group);
1533}
1534
1535/* main bq2415x probe function */
1536static int bq2415x_probe(struct i2c_client *client,
6c47a3e0 1537 const struct i2c_device_id *id)
0bc98cc6
PR		 1538{
1539 int ret;
1540 int num;
1541 char *name;
1542 struct bq2415x_device *bq;
faffd234
SR		 1543 struct device_node *np = client->dev.of_node;
1544 struct bq2415x_platform_data *pdata = client->dev.platform_data;
0bc98cc6 1545
faffd234
SR		 1546 if (!np && !pdata) {
1547 dev_err(&client->dev, "platform data missing\n");
0bc98cc6
PR		 1548 return -ENODEV;
1549 }
1550
1551 /* Get new ID for the new device */
0bc98cc6 1552 mutex_lock(&bq2415x_id_mutex);
05e2cefa 1553 num = idr_alloc(&bq2415x_id, client, 0, 0, GFP_KERNEL);
0bc98cc6 1554 mutex_unlock(&bq2415x_id_mutex);
05e2cefa
TH		 1555 if (num < 0)
1556 return num;
0bc98cc6
PR		 1557
1558 name = kasprintf(GFP_KERNEL, "%s-%d", id->name, num);
1559 if (!name) {
1560 dev_err(&client->dev, "failed to allocate device name\n");
1561 ret = -ENOMEM;
1562 goto error_1;
1563 }
1564
a9672e13 1565 bq = devm_kzalloc(&client->dev, sizeof(*bq), GFP_KERNEL);
0bc98cc6
PR		 1566 if (!bq) {
1567 dev_err(&client->dev, "failed to allocate device data\n");
1568 ret = -ENOMEM;
1569 goto error_2;
1570 }
1571
faffd234
SR		 1572 if (np) {
1573 bq->notify_psy = power_supply_get_by_phandle(np, "ti,usb-charger-detection");
1574
0eaf437a
KK		 1575 if (IS_ERR(bq->notify_psy)) {
1576 dev_info(&client->dev,
1577 "no 'ti,usb-charger-detection' property (err=%ld)\n",
1578 PTR_ERR(bq->notify_psy));
1579 bq->notify_psy = NULL;
1580 } else if (!bq->notify_psy) {
1581 ret = -EPROBE_DEFER;
1582 goto error_2;
1583 }
faffd234
SR		 1584 }
1585 else if (pdata->notify_device)
1586 bq->notify_psy = power_supply_get_by_name(pdata->notify_device);
1587 else
1588 bq->notify_psy = NULL;
1589
0bc98cc6
PR		 1590 i2c_set_clientdata(client, bq);
1591
1592 bq->id = num;
1593 bq->dev = &client->dev;
1594 bq->chip = id->driver_data;
1595 bq->name = name;
ac6324e7
PR		 1596 bq->mode = BQ2415X_MODE_OFF;
1597 bq->reported_mode = BQ2415X_MODE_OFF;
0bc98cc6
PR		 1598 bq->autotimer = 0;
1599 bq->automode = 0;
1600
faffd234
SR		 1601 if (np) {
1602 ret = of_property_read_u32(np, "ti,current-limit",
1603 &bq->init_data.current_limit);
1604 if (ret)
21e863b2 1605 goto error_2;
faffd234
SR		 1606 ret = of_property_read_u32(np, "ti,weak-battery-voltage",
1607 &bq->init_data.weak_battery_voltage);
1608 if (ret)
21e863b2 1609 goto error_2;
faffd234
SR		 1610 ret = of_property_read_u32(np, "ti,battery-regulation-voltage",
1611 &bq->init_data.battery_regulation_voltage);
1612 if (ret)
21e863b2 1613 goto error_2;
faffd234
SR		 1614 ret = of_property_read_u32(np, "ti,charge-current",
1615 &bq->init_data.charge_current);
1616 if (ret)
21e863b2 1617 goto error_2;
faffd234
SR		 1618 ret = of_property_read_u32(np, "ti,termination-current",
1619 &bq->init_data.termination_current);
1620 if (ret)
21e863b2 1621 goto error_2;
faffd234
SR		 1622 ret = of_property_read_u32(np, "ti,resistor-sense",
1623 &bq->init_data.resistor_sense);
1624 if (ret)
21e863b2 1625 goto error_2;
faffd234
SR		 1626 } else {
1627 memcpy(&bq->init_data, pdata, sizeof(bq->init_data));
1628 }
0bc98cc6
PR		 1629
1630 bq2415x_reset_chip(bq);
1631
1632 ret = bq2415x_power_supply_init(bq);
1633 if (ret) {
1634 dev_err(bq->dev, "failed to register power supply: %d\n", ret);
a9672e13 1635 goto error_2;
0bc98cc6
PR		 1636 }
1637
1638 ret = bq2415x_sysfs_init(bq);
1639 if (ret) {
1640 dev_err(bq->dev, "failed to create sysfs entries: %d\n", ret);
a9672e13 1641 goto error_3;
0bc98cc6
PR		 1642 }
1643
1644 ret = bq2415x_set_defaults(bq);
1645 if (ret) {
1646 dev_err(bq->dev, "failed to set default values: %d\n", ret);
a9672e13 1647 goto error_4;
0bc98cc6
PR		 1648 }
1649
faffd234 1650 if (bq->notify_psy) {
32260308
PR		 1651 bq->nb.notifier_call = bq2415x_notifier_call;
1652 ret = power_supply_reg_notifier(&bq->nb);
1653 if (ret) {
1654 dev_err(bq->dev, "failed to reg notifier: %d\n", ret);
1655 goto error_5;
1656 }
faffd234
SR		 1657
1658 /* Query for initial reported_mode and set it */
1659 bq2415x_notifier_call(&bq->nb, PSY_EVENT_PROP_CHANGED, bq->notify_psy);
1660 bq2415x_set_mode(bq, bq->reported_mode);
1661
32260308
PR		 1662 bq->automode = 1;
1663 dev_info(bq->dev, "automode enabled\n");
0bc98cc6
PR		 1664 } else {
1665 bq->automode = -1;
1666 dev_info(bq->dev, "automode not supported\n");
1667 }
1668
1669 INIT_DELAYED_WORK(&bq->work, bq2415x_timer_work);
1670 bq2415x_set_autotimer(bq, 1);
1671
1672 dev_info(bq->dev, "driver registered\n");
1673 return 0;
1674
32260308 1675error_5:
0bc98cc6 1676error_4:
a9672e13 1677 bq2415x_sysfs_exit(bq);
0bc98cc6 1678error_3:
a9672e13 1679 bq2415x_power_supply_exit(bq);
0bc98cc6
PR		 1680error_2:
1681 kfree(name);
1682error_1:
1683 mutex_lock(&bq2415x_id_mutex);
1684 idr_remove(&bq2415x_id, num);
1685 mutex_unlock(&bq2415x_id_mutex);
1686
1687 return ret;
1688}
1689
1690/* main bq2415x remove function */
1691
1692static int bq2415x_remove(struct i2c_client *client)
1693{
1694 struct bq2415x_device *bq = i2c_get_clientdata(client);
1695
faffd234 1696 if (bq->notify_psy)
32260308 1697 power_supply_unreg_notifier(&bq->nb);
0bc98cc6
PR		 1698
1699 bq2415x_sysfs_exit(bq);
1700 bq2415x_power_supply_exit(bq);
1701
1702 bq2415x_reset_chip(bq);
1703
1704 mutex_lock(&bq2415x_id_mutex);
1705 idr_remove(&bq2415x_id, bq->id);
1706 mutex_unlock(&bq2415x_id_mutex);
1707
1708 dev_info(bq->dev, "driver unregistered\n");
1709
1710 kfree(bq->name);
0bc98cc6
PR		 1711
1712 return 0;
1713}
1714
1715static const struct i2c_device_id bq2415x_i2c_id_table[] = {
1716 { "bq2415x", BQUNKNOWN },
1717 { "bq24150", BQ24150 },
1718 { "bq24150a", BQ24150A },
1719 { "bq24151", BQ24151 },
1720 { "bq24151a", BQ24151A },
1721 { "bq24152", BQ24152 },
1722 { "bq24153", BQ24153 },
1723 { "bq24153a", BQ24153A },
1724 { "bq24155", BQ24155 },
1725 { "bq24156", BQ24156 },
1726 { "bq24156a", BQ24156A },
0e1392d9 1727 { "bq24157s", BQ24157S },
0bc98cc6
PR		 1728 { "bq24158", BQ24158 },
1729 {},
1730};
1731MODULE_DEVICE_TABLE(i2c, bq2415x_i2c_id_table);
1732
1733static struct i2c_driver bq2415x_driver = {
1734 .driver = {
1735 .name = "bq2415x-charger",
1736 },
1737 .probe = bq2415x_probe,
1738 .remove = bq2415x_remove,
1739 .id_table = bq2415x_i2c_id_table,
1740};
463df514 1741module_i2c_driver(bq2415x_driver);
0bc98cc6
PR		 1742
1743MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
1744MODULE_DESCRIPTION("bq2415x charger driver");
1745MODULE_LICENSE("GPL");
Linux 6.x block layer and io_uring tree(s)