2 * bq2415x charger driver
4 * Copyright (C) 2011-2013 Pali Rohár <pali.rohar@gmail.com>
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.
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.
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
23 * http://www.ti.com/product/bq24157s
24 * http://www.ti.com/product/bq24158
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 #include <linux/acpi.h>
40 #include <linux/power/bq2415x_charger.h>
42 /* timeout for resetting chip timer */
43 #define BQ2415X_TIMER_TIMEOUT 10
45 #define BQ2415X_REG_STATUS 0x00
46 #define BQ2415X_REG_CONTROL 0x01
47 #define BQ2415X_REG_VOLTAGE 0x02
48 #define BQ2415X_REG_VENDER 0x03
49 #define BQ2415X_REG_CURRENT 0x04
51 /* reset state for all registers */
52 #define BQ2415X_RESET_STATUS BIT(6)
53 #define BQ2415X_RESET_CONTROL (BIT(4)|BIT(5))
54 #define BQ2415X_RESET_VOLTAGE (BIT(1)|BIT(3))
55 #define BQ2415X_RESET_CURRENT (BIT(0)|BIT(3)|BIT(7))
58 #define BQ2415X_BIT_TMR_RST 7
59 #define BQ2415X_BIT_OTG 7
60 #define BQ2415X_BIT_EN_STAT 6
61 #define BQ2415X_MASK_STAT (BIT(4)|BIT(5))
62 #define BQ2415X_SHIFT_STAT 4
63 #define BQ2415X_BIT_BOOST 3
64 #define BQ2415X_MASK_FAULT (BIT(0)|BIT(1)|BIT(2))
65 #define BQ2415X_SHIFT_FAULT 0
67 /* control register */
68 #define BQ2415X_MASK_LIMIT (BIT(6)|BIT(7))
69 #define BQ2415X_SHIFT_LIMIT 6
70 #define BQ2415X_MASK_VLOWV (BIT(4)|BIT(5))
71 #define BQ2415X_SHIFT_VLOWV 4
72 #define BQ2415X_BIT_TE 3
73 #define BQ2415X_BIT_CE 2
74 #define BQ2415X_BIT_HZ_MODE 1
75 #define BQ2415X_BIT_OPA_MODE 0
77 /* voltage register */
78 #define BQ2415X_MASK_VO (BIT(2)|BIT(3)|BIT(4)|BIT(5)|BIT(6)|BIT(7))
79 #define BQ2415X_SHIFT_VO 2
80 #define BQ2415X_BIT_OTG_PL 1
81 #define BQ2415X_BIT_OTG_EN 0
84 #define BQ2415X_MASK_VENDER (BIT(5)|BIT(6)|BIT(7))
85 #define BQ2415X_SHIFT_VENDER 5
86 #define BQ2415X_MASK_PN (BIT(3)|BIT(4))
87 #define BQ2415X_SHIFT_PN 3
88 #define BQ2415X_MASK_REVISION (BIT(0)|BIT(1)|BIT(2))
89 #define BQ2415X_SHIFT_REVISION 0
91 /* current register */
92 #define BQ2415X_MASK_RESET BIT(7)
93 #define BQ2415X_MASK_VI_CHRG (BIT(4)|BIT(5)|BIT(6))
94 #define BQ2415X_SHIFT_VI_CHRG 4
96 #define BQ2415X_MASK_VI_TERM (BIT(0)|BIT(1)|BIT(2))
97 #define BQ2415X_SHIFT_VI_TERM 0
100 enum bq2415x_command
{
103 BQ2415X_STAT_PIN_STATUS
,
104 BQ2415X_STAT_PIN_ENABLE
,
105 BQ2415X_STAT_PIN_DISABLE
,
106 BQ2415X_CHARGE_STATUS
,
107 BQ2415X_BOOST_STATUS
,
108 BQ2415X_FAULT_STATUS
,
110 BQ2415X_CHARGE_TERMINATION_STATUS
,
111 BQ2415X_CHARGE_TERMINATION_ENABLE
,
112 BQ2415X_CHARGE_TERMINATION_DISABLE
,
113 BQ2415X_CHARGER_STATUS
,
114 BQ2415X_CHARGER_ENABLE
,
115 BQ2415X_CHARGER_DISABLE
,
116 BQ2415X_HIGH_IMPEDANCE_STATUS
,
117 BQ2415X_HIGH_IMPEDANCE_ENABLE
,
118 BQ2415X_HIGH_IMPEDANCE_DISABLE
,
119 BQ2415X_BOOST_MODE_STATUS
,
120 BQ2415X_BOOST_MODE_ENABLE
,
121 BQ2415X_BOOST_MODE_DISABLE
,
124 BQ2415X_OTG_ACTIVATE_HIGH
,
125 BQ2415X_OTG_ACTIVATE_LOW
,
126 BQ2415X_OTG_PIN_STATUS
,
127 BQ2415X_OTG_PIN_ENABLE
,
128 BQ2415X_OTG_PIN_DISABLE
,
151 static char *bq2415x_chip_name
[] = {
167 struct bq2415x_device
{
169 struct bq2415x_platform_data init_data
;
170 struct power_supply
*charger
;
171 struct power_supply_desc charger_desc
;
172 struct delayed_work work
;
173 struct device_node
*notify_node
;
174 struct notifier_block nb
;
175 enum bq2415x_mode reported_mode
;/* mode reported by hook function */
176 enum bq2415x_mode mode
; /* currently configured mode */
177 enum bq2415x_chip chip
;
178 const char *timer_error
;
181 int autotimer
; /* 1 - if driver automatically reset timer, 0 - not */
182 int automode
; /* 1 - enabled, 0 - disabled; -1 - not supported */
186 /* each registered chip must have unique id */
187 static DEFINE_IDR(bq2415x_id
);
189 static DEFINE_MUTEX(bq2415x_id_mutex
);
190 static DEFINE_MUTEX(bq2415x_timer_mutex
);
191 static DEFINE_MUTEX(bq2415x_i2c_mutex
);
193 /**** i2c read functions ****/
195 /* read value from register */
196 static int bq2415x_i2c_read(struct bq2415x_device
*bq
, u8 reg
)
198 struct i2c_client
*client
= to_i2c_client(bq
->dev
);
199 struct i2c_msg msg
[2];
203 if (!client
->adapter
)
206 msg
[0].addr
= client
->addr
;
209 msg
[0].len
= sizeof(reg
);
210 msg
[1].addr
= client
->addr
;
211 msg
[1].flags
= I2C_M_RD
;
213 msg
[1].len
= sizeof(val
);
215 mutex_lock(&bq2415x_i2c_mutex
);
216 ret
= i2c_transfer(client
->adapter
, msg
, ARRAY_SIZE(msg
));
217 mutex_unlock(&bq2415x_i2c_mutex
);
225 /* read value from register, apply mask and right shift it */
226 static int bq2415x_i2c_read_mask(struct bq2415x_device
*bq
, u8 reg
,
234 ret
= bq2415x_i2c_read(bq
, reg
);
237 return (ret
& mask
) >> shift
;
240 /* read value from register and return one specified bit */
241 static int bq2415x_i2c_read_bit(struct bq2415x_device
*bq
, u8 reg
, u8 bit
)
245 return bq2415x_i2c_read_mask(bq
, reg
, BIT(bit
), bit
);
248 /**** i2c write functions ****/
250 /* write value to register */
251 static int bq2415x_i2c_write(struct bq2415x_device
*bq
, u8 reg
, u8 val
)
253 struct i2c_client
*client
= to_i2c_client(bq
->dev
);
254 struct i2c_msg msg
[1];
261 msg
[0].addr
= client
->addr
;
264 msg
[0].len
= ARRAY_SIZE(data
);
266 mutex_lock(&bq2415x_i2c_mutex
);
267 ret
= i2c_transfer(client
->adapter
, msg
, ARRAY_SIZE(msg
));
268 mutex_unlock(&bq2415x_i2c_mutex
);
270 /* i2c_transfer returns number of messages transferred */
279 /* read value from register, change it with mask left shifted and write back */
280 static int bq2415x_i2c_write_mask(struct bq2415x_device
*bq
, u8 reg
, u8 val
,
288 ret
= bq2415x_i2c_read(bq
, reg
);
295 return bq2415x_i2c_write(bq
, reg
, ret
);
298 /* change only one bit in register */
299 static int bq2415x_i2c_write_bit(struct bq2415x_device
*bq
, u8 reg
,
304 return bq2415x_i2c_write_mask(bq
, reg
, val
, BIT(bit
), bit
);
307 /**** global functions ****/
309 /* exec command function */
310 static int bq2415x_exec_command(struct bq2415x_device
*bq
,
311 enum bq2415x_command command
)
316 case BQ2415X_TIMER_RESET
:
317 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_STATUS
,
318 1, BQ2415X_BIT_TMR_RST
);
319 case BQ2415X_OTG_STATUS
:
320 return bq2415x_i2c_read_bit(bq
, BQ2415X_REG_STATUS
,
322 case BQ2415X_STAT_PIN_STATUS
:
323 return bq2415x_i2c_read_bit(bq
, BQ2415X_REG_STATUS
,
324 BQ2415X_BIT_EN_STAT
);
325 case BQ2415X_STAT_PIN_ENABLE
:
326 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_STATUS
, 1,
327 BQ2415X_BIT_EN_STAT
);
328 case BQ2415X_STAT_PIN_DISABLE
:
329 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_STATUS
, 0,
330 BQ2415X_BIT_EN_STAT
);
331 case BQ2415X_CHARGE_STATUS
:
332 return bq2415x_i2c_read_mask(bq
, BQ2415X_REG_STATUS
,
333 BQ2415X_MASK_STAT
, BQ2415X_SHIFT_STAT
);
334 case BQ2415X_BOOST_STATUS
:
335 return bq2415x_i2c_read_bit(bq
, BQ2415X_REG_STATUS
,
337 case BQ2415X_FAULT_STATUS
:
338 return bq2415x_i2c_read_mask(bq
, BQ2415X_REG_STATUS
,
339 BQ2415X_MASK_FAULT
, BQ2415X_SHIFT_FAULT
);
341 case BQ2415X_CHARGE_TERMINATION_STATUS
:
342 return bq2415x_i2c_read_bit(bq
, BQ2415X_REG_CONTROL
,
344 case BQ2415X_CHARGE_TERMINATION_ENABLE
:
345 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_CONTROL
,
347 case BQ2415X_CHARGE_TERMINATION_DISABLE
:
348 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_CONTROL
,
350 case BQ2415X_CHARGER_STATUS
:
351 ret
= bq2415x_i2c_read_bit(bq
, BQ2415X_REG_CONTROL
,
355 return ret
> 0 ? 0 : 1;
356 case BQ2415X_CHARGER_ENABLE
:
357 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_CONTROL
,
359 case BQ2415X_CHARGER_DISABLE
:
360 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_CONTROL
,
362 case BQ2415X_HIGH_IMPEDANCE_STATUS
:
363 return bq2415x_i2c_read_bit(bq
, BQ2415X_REG_CONTROL
,
364 BQ2415X_BIT_HZ_MODE
);
365 case BQ2415X_HIGH_IMPEDANCE_ENABLE
:
366 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_CONTROL
,
367 1, BQ2415X_BIT_HZ_MODE
);
368 case BQ2415X_HIGH_IMPEDANCE_DISABLE
:
369 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_CONTROL
,
370 0, BQ2415X_BIT_HZ_MODE
);
371 case BQ2415X_BOOST_MODE_STATUS
:
372 return bq2415x_i2c_read_bit(bq
, BQ2415X_REG_CONTROL
,
373 BQ2415X_BIT_OPA_MODE
);
374 case BQ2415X_BOOST_MODE_ENABLE
:
375 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_CONTROL
,
376 1, BQ2415X_BIT_OPA_MODE
);
377 case BQ2415X_BOOST_MODE_DISABLE
:
378 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_CONTROL
,
379 0, BQ2415X_BIT_OPA_MODE
);
381 case BQ2415X_OTG_LEVEL
:
382 return bq2415x_i2c_read_bit(bq
, BQ2415X_REG_VOLTAGE
,
384 case BQ2415X_OTG_ACTIVATE_HIGH
:
385 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_VOLTAGE
,
386 1, BQ2415X_BIT_OTG_PL
);
387 case BQ2415X_OTG_ACTIVATE_LOW
:
388 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_VOLTAGE
,
389 0, BQ2415X_BIT_OTG_PL
);
390 case BQ2415X_OTG_PIN_STATUS
:
391 return bq2415x_i2c_read_bit(bq
, BQ2415X_REG_VOLTAGE
,
393 case BQ2415X_OTG_PIN_ENABLE
:
394 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_VOLTAGE
,
395 1, BQ2415X_BIT_OTG_EN
);
396 case BQ2415X_OTG_PIN_DISABLE
:
397 return bq2415x_i2c_write_bit(bq
, BQ2415X_REG_VOLTAGE
,
398 0, BQ2415X_BIT_OTG_EN
);
400 case BQ2415X_VENDER_CODE
:
401 return bq2415x_i2c_read_mask(bq
, BQ2415X_REG_VENDER
,
402 BQ2415X_MASK_VENDER
, BQ2415X_SHIFT_VENDER
);
403 case BQ2415X_PART_NUMBER
:
404 return bq2415x_i2c_read_mask(bq
, BQ2415X_REG_VENDER
,
405 BQ2415X_MASK_PN
, BQ2415X_SHIFT_PN
);
406 case BQ2415X_REVISION
:
407 return bq2415x_i2c_read_mask(bq
, BQ2415X_REG_VENDER
,
408 BQ2415X_MASK_REVISION
, BQ2415X_SHIFT_REVISION
);
413 /* detect chip type */
414 static enum bq2415x_chip
bq2415x_detect_chip(struct bq2415x_device
*bq
)
416 struct i2c_client
*client
= to_i2c_client(bq
->dev
);
417 int ret
= bq2415x_exec_command(bq
, BQ2415X_PART_NUMBER
);
422 switch (client
->addr
) {
426 if (bq
->chip
== BQ24151A
)
430 if (bq
->chip
== BQ24150A
||
431 bq
->chip
== BQ24152
||
436 if (bq
->chip
== BQ24153A
)
447 if (bq
->chip
== BQ24156A
)
451 if (bq
->chip
== BQ24157S
)
463 /* detect chip revision */
464 static int bq2415x_detect_revision(struct bq2415x_device
*bq
)
466 int ret
= bq2415x_exec_command(bq
, BQ2415X_REVISION
);
467 int chip
= bq2415x_detect_chip(bq
);
469 if (ret
< 0 || chip
< 0)
478 if (ret
>= 0 && ret
<= 3)
503 /* return chip vender code */
504 static int bq2415x_get_vender_code(struct bq2415x_device
*bq
)
508 ret
= bq2415x_exec_command(bq
, BQ2415X_VENDER_CODE
);
512 /* convert to binary */
514 ((ret
>> 1) & 0x1) * 10 +
515 ((ret
>> 2) & 0x1) * 100;
518 /* reset all chip registers to default state */
519 static void bq2415x_reset_chip(struct bq2415x_device
*bq
)
521 bq2415x_i2c_write(bq
, BQ2415X_REG_CURRENT
, BQ2415X_RESET_CURRENT
);
522 bq2415x_i2c_write(bq
, BQ2415X_REG_VOLTAGE
, BQ2415X_RESET_VOLTAGE
);
523 bq2415x_i2c_write(bq
, BQ2415X_REG_CONTROL
, BQ2415X_RESET_CONTROL
);
524 bq2415x_i2c_write(bq
, BQ2415X_REG_STATUS
, BQ2415X_RESET_STATUS
);
525 bq
->timer_error
= NULL
;
528 /**** properties functions ****/
530 /* set current limit in mA */
531 static int bq2415x_set_current_limit(struct bq2415x_device
*bq
, int mA
)
544 return bq2415x_i2c_write_mask(bq
, BQ2415X_REG_CONTROL
, val
,
545 BQ2415X_MASK_LIMIT
, BQ2415X_SHIFT_LIMIT
);
548 /* get current limit in mA */
549 static int bq2415x_get_current_limit(struct bq2415x_device
*bq
)
553 ret
= bq2415x_i2c_read_mask(bq
, BQ2415X_REG_CONTROL
,
554 BQ2415X_MASK_LIMIT
, BQ2415X_SHIFT_LIMIT
);
568 /* set weak battery voltage in mV */
569 static int bq2415x_set_weak_battery_voltage(struct bq2415x_device
*bq
, int mV
)
576 else if (mV
<= 3500 + 50)
578 else if (mV
<= 3600 + 50)
583 return bq2415x_i2c_write_mask(bq
, BQ2415X_REG_CONTROL
, val
,
584 BQ2415X_MASK_VLOWV
, BQ2415X_SHIFT_VLOWV
);
587 /* get weak battery voltage in mV */
588 static int bq2415x_get_weak_battery_voltage(struct bq2415x_device
*bq
)
592 ret
= bq2415x_i2c_read_mask(bq
, BQ2415X_REG_CONTROL
,
593 BQ2415X_MASK_VLOWV
, BQ2415X_SHIFT_VLOWV
);
596 return 100 * (34 + ret
);
599 /* set battery regulation voltage in mV */
600 static int bq2415x_set_battery_regulation_voltage(struct bq2415x_device
*bq
,
603 int val
= (mV
/10 - 350) / 2;
606 * According to datasheet, maximum battery regulation voltage is
607 * 4440mV which is b101111 = 47.
614 return bq2415x_i2c_write_mask(bq
, BQ2415X_REG_VOLTAGE
, val
,
615 BQ2415X_MASK_VO
, BQ2415X_SHIFT_VO
);
618 /* get battery regulation voltage in mV */
619 static int bq2415x_get_battery_regulation_voltage(struct bq2415x_device
*bq
)
621 int ret
= bq2415x_i2c_read_mask(bq
, BQ2415X_REG_VOLTAGE
,
622 BQ2415X_MASK_VO
, BQ2415X_SHIFT_VO
);
626 return 10 * (350 + 2*ret
);
629 /* set charge current in mA (platform data must provide resistor sense) */
630 static int bq2415x_set_charge_current(struct bq2415x_device
*bq
, int mA
)
634 if (bq
->init_data
.resistor_sense
<= 0)
637 val
= (mA
* bq
->init_data
.resistor_sense
- 37400) / 6800;
643 return bq2415x_i2c_write_mask(bq
, BQ2415X_REG_CURRENT
, val
,
644 BQ2415X_MASK_VI_CHRG
| BQ2415X_MASK_RESET
,
645 BQ2415X_SHIFT_VI_CHRG
);
648 /* get charge current in mA (platform data must provide resistor sense) */
649 static int bq2415x_get_charge_current(struct bq2415x_device
*bq
)
653 if (bq
->init_data
.resistor_sense
<= 0)
656 ret
= bq2415x_i2c_read_mask(bq
, BQ2415X_REG_CURRENT
,
657 BQ2415X_MASK_VI_CHRG
, BQ2415X_SHIFT_VI_CHRG
);
660 return (37400 + 6800*ret
) / bq
->init_data
.resistor_sense
;
663 /* set termination current in mA (platform data must provide resistor sense) */
664 static int bq2415x_set_termination_current(struct bq2415x_device
*bq
, int mA
)
668 if (bq
->init_data
.resistor_sense
<= 0)
671 val
= (mA
* bq
->init_data
.resistor_sense
- 3400) / 3400;
677 return bq2415x_i2c_write_mask(bq
, BQ2415X_REG_CURRENT
, val
,
678 BQ2415X_MASK_VI_TERM
| BQ2415X_MASK_RESET
,
679 BQ2415X_SHIFT_VI_TERM
);
682 /* get termination current in mA (platform data must provide resistor sense) */
683 static int bq2415x_get_termination_current(struct bq2415x_device
*bq
)
687 if (bq
->init_data
.resistor_sense
<= 0)
690 ret
= bq2415x_i2c_read_mask(bq
, BQ2415X_REG_CURRENT
,
691 BQ2415X_MASK_VI_TERM
, BQ2415X_SHIFT_VI_TERM
);
694 return (3400 + 3400*ret
) / bq
->init_data
.resistor_sense
;
697 /* set default value of property */
698 #define bq2415x_set_default_value(bq, prop) \
701 if (bq->init_data.prop != -1) \
702 ret = bq2415x_set_##prop(bq, bq->init_data.prop); \
707 /* set default values of all properties */
708 static int bq2415x_set_defaults(struct bq2415x_device
*bq
)
710 bq2415x_exec_command(bq
, BQ2415X_BOOST_MODE_DISABLE
);
711 bq2415x_exec_command(bq
, BQ2415X_CHARGER_DISABLE
);
712 bq2415x_exec_command(bq
, BQ2415X_CHARGE_TERMINATION_DISABLE
);
714 bq2415x_set_default_value(bq
, current_limit
);
715 bq2415x_set_default_value(bq
, weak_battery_voltage
);
716 bq2415x_set_default_value(bq
, battery_regulation_voltage
);
718 if (bq
->init_data
.resistor_sense
> 0) {
719 bq2415x_set_default_value(bq
, charge_current
);
720 bq2415x_set_default_value(bq
, termination_current
);
721 bq2415x_exec_command(bq
, BQ2415X_CHARGE_TERMINATION_ENABLE
);
724 bq2415x_exec_command(bq
, BQ2415X_CHARGER_ENABLE
);
728 /**** charger mode functions ****/
730 /* set charger mode */
731 static int bq2415x_set_mode(struct bq2415x_device
*bq
, enum bq2415x_mode mode
)
737 if (mode
== BQ2415X_MODE_BOOST
)
739 else if (mode
!= BQ2415X_MODE_OFF
)
743 ret
= bq2415x_exec_command(bq
, BQ2415X_CHARGER_DISABLE
);
746 ret
= bq2415x_exec_command(bq
, BQ2415X_BOOST_MODE_DISABLE
);
752 case BQ2415X_MODE_OFF
:
753 dev_dbg(bq
->dev
, "changing mode to: Offline\n");
754 ret
= bq2415x_set_current_limit(bq
, 100);
756 case BQ2415X_MODE_NONE
:
757 dev_dbg(bq
->dev
, "changing mode to: N/A\n");
758 ret
= bq2415x_set_current_limit(bq
, 100);
760 case BQ2415X_MODE_HOST_CHARGER
:
761 dev_dbg(bq
->dev
, "changing mode to: Host/HUB charger\n");
762 ret
= bq2415x_set_current_limit(bq
, 500);
764 case BQ2415X_MODE_DEDICATED_CHARGER
:
765 dev_dbg(bq
->dev
, "changing mode to: Dedicated charger\n");
766 ret
= bq2415x_set_current_limit(bq
, 1800);
768 case BQ2415X_MODE_BOOST
: /* Boost mode */
769 dev_dbg(bq
->dev
, "changing mode to: Boost\n");
770 ret
= bq2415x_set_current_limit(bq
, 100);
778 ret
= bq2415x_exec_command(bq
, BQ2415X_CHARGER_ENABLE
);
780 ret
= bq2415x_exec_command(bq
, BQ2415X_BOOST_MODE_ENABLE
);
785 bq2415x_set_default_value(bq
, weak_battery_voltage
);
786 bq2415x_set_default_value(bq
, battery_regulation_voltage
);
789 sysfs_notify(&bq
->charger
->dev
.kobj
, NULL
, "mode");
795 static bool bq2415x_update_reported_mode(struct bq2415x_device
*bq
, int mA
)
797 enum bq2415x_mode mode
;
800 mode
= BQ2415X_MODE_OFF
;
802 mode
= BQ2415X_MODE_NONE
;
804 mode
= BQ2415X_MODE_HOST_CHARGER
;
806 mode
= BQ2415X_MODE_DEDICATED_CHARGER
;
808 if (bq
->reported_mode
== mode
)
811 bq
->reported_mode
= mode
;
815 static int bq2415x_notifier_call(struct notifier_block
*nb
,
816 unsigned long val
, void *v
)
818 struct bq2415x_device
*bq
=
819 container_of(nb
, struct bq2415x_device
, nb
);
820 struct power_supply
*psy
= v
;
821 union power_supply_propval prop
;
824 if (val
!= PSY_EVENT_PROP_CHANGED
)
827 /* Ignore event if it was not send by notify_node/notify_device */
828 if (bq
->notify_node
) {
829 if (!psy
->dev
.parent
||
830 psy
->dev
.parent
->of_node
!= bq
->notify_node
)
832 } else if (bq
->init_data
.notify_device
) {
833 if (strcmp(psy
->desc
->name
, bq
->init_data
.notify_device
) != 0)
837 dev_dbg(bq
->dev
, "notifier call was called\n");
839 ret
= power_supply_get_property(psy
, POWER_SUPPLY_PROP_CURRENT_MAX
,
844 if (!bq2415x_update_reported_mode(bq
, prop
.intval
))
847 /* if automode is not enabled do not tell about reported_mode */
848 if (bq
->automode
< 1)
851 schedule_delayed_work(&bq
->work
, 0);
856 /**** timer functions ****/
858 /* enable/disable auto resetting chip timer */
859 static void bq2415x_set_autotimer(struct bq2415x_device
*bq
, int state
)
861 mutex_lock(&bq2415x_timer_mutex
);
863 if (bq
->autotimer
== state
) {
864 mutex_unlock(&bq2415x_timer_mutex
);
868 bq
->autotimer
= state
;
871 schedule_delayed_work(&bq
->work
, BQ2415X_TIMER_TIMEOUT
* HZ
);
872 bq2415x_exec_command(bq
, BQ2415X_TIMER_RESET
);
873 bq
->timer_error
= NULL
;
875 cancel_delayed_work_sync(&bq
->work
);
878 mutex_unlock(&bq2415x_timer_mutex
);
881 /* called by bq2415x_timer_work on timer error */
882 static void bq2415x_timer_error(struct bq2415x_device
*bq
, const char *msg
)
884 bq
->timer_error
= msg
;
885 sysfs_notify(&bq
->charger
->dev
.kobj
, NULL
, "timer");
886 dev_err(bq
->dev
, "%s\n", msg
);
887 if (bq
->automode
> 0)
889 bq2415x_set_mode(bq
, BQ2415X_MODE_OFF
);
890 bq2415x_set_autotimer(bq
, 0);
893 /* delayed work function for auto resetting chip timer */
894 static void bq2415x_timer_work(struct work_struct
*work
)
896 struct bq2415x_device
*bq
= container_of(work
, struct bq2415x_device
,
902 if (bq
->automode
> 0 && (bq
->reported_mode
!= bq
->mode
)) {
903 sysfs_notify(&bq
->charger
->dev
.kobj
, NULL
, "reported_mode");
904 bq2415x_set_mode(bq
, bq
->reported_mode
);
910 ret
= bq2415x_exec_command(bq
, BQ2415X_TIMER_RESET
);
912 bq2415x_timer_error(bq
, "Resetting timer failed");
916 boost
= bq2415x_exec_command(bq
, BQ2415X_BOOST_MODE_STATUS
);
918 bq2415x_timer_error(bq
, "Unknown error");
922 error
= bq2415x_exec_command(bq
, BQ2415X_FAULT_STATUS
);
924 bq2415x_timer_error(bq
, "Unknown error");
930 /* Non fatal errors, chip is OK */
931 case 0: /* No error */
933 case 6: /* Timer expired */
934 dev_err(bq
->dev
, "Timer expired\n");
936 case 3: /* Battery voltage too low */
937 dev_err(bq
->dev
, "Battery voltage to low\n");
940 /* Fatal errors, disable and reset chip */
941 case 1: /* Overvoltage protection (chip fried) */
942 bq2415x_timer_error(bq
,
943 "Overvoltage protection (chip fried)");
945 case 2: /* Overload */
946 bq2415x_timer_error(bq
, "Overload");
948 case 4: /* Battery overvoltage protection */
949 bq2415x_timer_error(bq
,
950 "Battery overvoltage protection");
952 case 5: /* Thermal shutdown (too hot) */
953 bq2415x_timer_error(bq
,
954 "Thermal shutdown (too hot)");
957 bq2415x_timer_error(bq
, "Unknown error");
962 /* Non fatal errors, chip is OK */
963 case 0: /* No error */
965 case 2: /* Sleep mode */
966 dev_err(bq
->dev
, "Sleep mode\n");
968 case 3: /* Poor input source */
969 dev_err(bq
->dev
, "Poor input source\n");
971 case 6: /* Timer expired */
972 dev_err(bq
->dev
, "Timer expired\n");
974 case 7: /* No battery */
975 dev_err(bq
->dev
, "No battery\n");
978 /* Fatal errors, disable and reset chip */
979 case 1: /* Overvoltage protection (chip fried) */
980 bq2415x_timer_error(bq
,
981 "Overvoltage protection (chip fried)");
983 case 4: /* Battery overvoltage protection */
984 bq2415x_timer_error(bq
,
985 "Battery overvoltage protection");
987 case 5: /* Thermal shutdown (too hot) */
988 bq2415x_timer_error(bq
,
989 "Thermal shutdown (too hot)");
994 schedule_delayed_work(&bq
->work
, BQ2415X_TIMER_TIMEOUT
* HZ
);
997 /**** power supply interface code ****/
999 static enum power_supply_property bq2415x_power_supply_props
[] = {
1000 /* TODO: maybe add more power supply properties */
1001 POWER_SUPPLY_PROP_STATUS
,
1002 POWER_SUPPLY_PROP_MODEL_NAME
,
1005 static int bq2415x_power_supply_get_property(struct power_supply
*psy
,
1006 enum power_supply_property psp
,
1007 union power_supply_propval
*val
)
1009 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1013 case POWER_SUPPLY_PROP_STATUS
:
1014 ret
= bq2415x_exec_command(bq
, BQ2415X_CHARGE_STATUS
);
1017 else if (ret
== 0) /* Ready */
1018 val
->intval
= POWER_SUPPLY_STATUS_NOT_CHARGING
;
1019 else if (ret
== 1) /* Charge in progress */
1020 val
->intval
= POWER_SUPPLY_STATUS_CHARGING
;
1021 else if (ret
== 2) /* Charge done */
1022 val
->intval
= POWER_SUPPLY_STATUS_FULL
;
1024 val
->intval
= POWER_SUPPLY_STATUS_UNKNOWN
;
1026 case POWER_SUPPLY_PROP_MODEL_NAME
:
1027 val
->strval
= bq
->model
;
1035 static int bq2415x_power_supply_init(struct bq2415x_device
*bq
)
1040 struct power_supply_config psy_cfg
= { .drv_data
= bq
, };
1042 bq
->charger_desc
.name
= bq
->name
;
1043 bq
->charger_desc
.type
= POWER_SUPPLY_TYPE_USB
;
1044 bq
->charger_desc
.properties
= bq2415x_power_supply_props
;
1045 bq
->charger_desc
.num_properties
=
1046 ARRAY_SIZE(bq2415x_power_supply_props
);
1047 bq
->charger_desc
.get_property
= bq2415x_power_supply_get_property
;
1049 ret
= bq2415x_detect_chip(bq
);
1055 ret
= bq2415x_detect_revision(bq
);
1057 strcpy(revstr
, "unknown");
1059 sprintf(revstr
, "1.%d", ret
);
1061 bq
->model
= kasprintf(GFP_KERNEL
,
1062 "chip %s, revision %s, vender code %.3d",
1063 bq2415x_chip_name
[chip
], revstr
,
1064 bq2415x_get_vender_code(bq
));
1066 dev_err(bq
->dev
, "failed to allocate model name\n");
1070 bq
->charger
= power_supply_register(bq
->dev
, &bq
->charger_desc
,
1072 if (IS_ERR(bq
->charger
)) {
1074 return PTR_ERR(bq
->charger
);
1080 static void bq2415x_power_supply_exit(struct bq2415x_device
*bq
)
1083 if (bq
->automode
> 0)
1085 cancel_delayed_work_sync(&bq
->work
);
1086 power_supply_unregister(bq
->charger
);
1090 /**** additional sysfs entries for power supply interface ****/
1092 /* show *_status entries */
1093 static ssize_t
bq2415x_sysfs_show_status(struct device
*dev
,
1094 struct device_attribute
*attr
,
1097 struct power_supply
*psy
= dev_get_drvdata(dev
);
1098 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1099 enum bq2415x_command command
;
1102 if (strcmp(attr
->attr
.name
, "otg_status") == 0)
1103 command
= BQ2415X_OTG_STATUS
;
1104 else if (strcmp(attr
->attr
.name
, "charge_status") == 0)
1105 command
= BQ2415X_CHARGE_STATUS
;
1106 else if (strcmp(attr
->attr
.name
, "boost_status") == 0)
1107 command
= BQ2415X_BOOST_STATUS
;
1108 else if (strcmp(attr
->attr
.name
, "fault_status") == 0)
1109 command
= BQ2415X_FAULT_STATUS
;
1113 ret
= bq2415x_exec_command(bq
, command
);
1116 return sprintf(buf
, "%d\n", ret
);
1121 * auto - enable auto mode
1122 * off - disable auto mode
1123 * (other values) - reset chip timer
1125 static ssize_t
bq2415x_sysfs_set_timer(struct device
*dev
,
1126 struct device_attribute
*attr
,
1130 struct power_supply
*psy
= dev_get_drvdata(dev
);
1131 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1134 if (strncmp(buf
, "auto", 4) == 0)
1135 bq2415x_set_autotimer(bq
, 1);
1136 else if (strncmp(buf
, "off", 3) == 0)
1137 bq2415x_set_autotimer(bq
, 0);
1139 ret
= bq2415x_exec_command(bq
, BQ2415X_TIMER_RESET
);
1146 /* show timer entry (auto or off) */
1147 static ssize_t
bq2415x_sysfs_show_timer(struct device
*dev
,
1148 struct device_attribute
*attr
,
1151 struct power_supply
*psy
= dev_get_drvdata(dev
);
1152 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1154 if (bq
->timer_error
)
1155 return sprintf(buf
, "%s\n", bq
->timer_error
);
1158 return sprintf(buf
, "auto\n");
1159 return sprintf(buf
, "off\n");
1164 * auto - if automode is supported, enable it and set mode to reported
1165 * none - disable charger and boost mode
1166 * host - charging mode for host/hub chargers (current limit 500mA)
1167 * dedicated - charging mode for dedicated chargers (unlimited current limit)
1168 * boost - disable charger and enable boost mode
1170 static ssize_t
bq2415x_sysfs_set_mode(struct device
*dev
,
1171 struct device_attribute
*attr
,
1175 struct power_supply
*psy
= dev_get_drvdata(dev
);
1176 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1177 enum bq2415x_mode mode
;
1180 if (strncmp(buf
, "auto", 4) == 0) {
1181 if (bq
->automode
< 0)
1184 mode
= bq
->reported_mode
;
1185 } else if (strncmp(buf
, "off", 3) == 0) {
1186 if (bq
->automode
> 0)
1188 mode
= BQ2415X_MODE_OFF
;
1189 } else if (strncmp(buf
, "none", 4) == 0) {
1190 if (bq
->automode
> 0)
1192 mode
= BQ2415X_MODE_NONE
;
1193 } else if (strncmp(buf
, "host", 4) == 0) {
1194 if (bq
->automode
> 0)
1196 mode
= BQ2415X_MODE_HOST_CHARGER
;
1197 } else if (strncmp(buf
, "dedicated", 9) == 0) {
1198 if (bq
->automode
> 0)
1200 mode
= BQ2415X_MODE_DEDICATED_CHARGER
;
1201 } else if (strncmp(buf
, "boost", 5) == 0) {
1202 if (bq
->automode
> 0)
1204 mode
= BQ2415X_MODE_BOOST
;
1205 } else if (strncmp(buf
, "reset", 5) == 0) {
1206 bq2415x_reset_chip(bq
);
1207 bq2415x_set_defaults(bq
);
1208 if (bq
->automode
<= 0)
1211 mode
= bq
->reported_mode
;
1216 ret
= bq2415x_set_mode(bq
, mode
);
1222 /* show mode entry (auto, none, host, dedicated or boost) */
1223 static ssize_t
bq2415x_sysfs_show_mode(struct device
*dev
,
1224 struct device_attribute
*attr
,
1227 struct power_supply
*psy
= dev_get_drvdata(dev
);
1228 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1231 if (bq
->automode
> 0)
1232 ret
+= sprintf(buf
+ret
, "auto (");
1235 case BQ2415X_MODE_OFF
:
1236 ret
+= sprintf(buf
+ret
, "off");
1238 case BQ2415X_MODE_NONE
:
1239 ret
+= sprintf(buf
+ret
, "none");
1241 case BQ2415X_MODE_HOST_CHARGER
:
1242 ret
+= sprintf(buf
+ret
, "host");
1244 case BQ2415X_MODE_DEDICATED_CHARGER
:
1245 ret
+= sprintf(buf
+ret
, "dedicated");
1247 case BQ2415X_MODE_BOOST
:
1248 ret
+= sprintf(buf
+ret
, "boost");
1252 if (bq
->automode
> 0)
1253 ret
+= sprintf(buf
+ret
, ")");
1255 ret
+= sprintf(buf
+ret
, "\n");
1259 /* show reported_mode entry (none, host, dedicated or boost) */
1260 static ssize_t
bq2415x_sysfs_show_reported_mode(struct device
*dev
,
1261 struct device_attribute
*attr
,
1264 struct power_supply
*psy
= dev_get_drvdata(dev
);
1265 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1267 if (bq
->automode
< 0)
1270 switch (bq
->reported_mode
) {
1271 case BQ2415X_MODE_OFF
:
1272 return sprintf(buf
, "off\n");
1273 case BQ2415X_MODE_NONE
:
1274 return sprintf(buf
, "none\n");
1275 case BQ2415X_MODE_HOST_CHARGER
:
1276 return sprintf(buf
, "host\n");
1277 case BQ2415X_MODE_DEDICATED_CHARGER
:
1278 return sprintf(buf
, "dedicated\n");
1279 case BQ2415X_MODE_BOOST
:
1280 return sprintf(buf
, "boost\n");
1286 /* directly set raw value to chip register, format: 'register value' */
1287 static ssize_t
bq2415x_sysfs_set_registers(struct device
*dev
,
1288 struct device_attribute
*attr
,
1292 struct power_supply
*psy
= dev_get_drvdata(dev
);
1293 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1298 if (sscanf(buf
, "%x %x", ®
, &val
) != 2)
1301 if (reg
> 4 || val
> 255)
1304 ret
= bq2415x_i2c_write(bq
, reg
, val
);
1310 /* print value of chip register, format: 'register=value' */
1311 static ssize_t
bq2415x_sysfs_print_reg(struct bq2415x_device
*bq
,
1315 int ret
= bq2415x_i2c_read(bq
, reg
);
1318 return sprintf(buf
, "%#.2x=error %d\n", reg
, ret
);
1319 return sprintf(buf
, "%#.2x=%#.2x\n", reg
, ret
);
1322 /* show all raw values of chip register, format per line: 'register=value' */
1323 static ssize_t
bq2415x_sysfs_show_registers(struct device
*dev
,
1324 struct device_attribute
*attr
,
1327 struct power_supply
*psy
= dev_get_drvdata(dev
);
1328 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1331 ret
+= bq2415x_sysfs_print_reg(bq
, BQ2415X_REG_STATUS
, buf
+ret
);
1332 ret
+= bq2415x_sysfs_print_reg(bq
, BQ2415X_REG_CONTROL
, buf
+ret
);
1333 ret
+= bq2415x_sysfs_print_reg(bq
, BQ2415X_REG_VOLTAGE
, buf
+ret
);
1334 ret
+= bq2415x_sysfs_print_reg(bq
, BQ2415X_REG_VENDER
, buf
+ret
);
1335 ret
+= bq2415x_sysfs_print_reg(bq
, BQ2415X_REG_CURRENT
, buf
+ret
);
1339 /* set current and voltage limit entries (in mA or mV) */
1340 static ssize_t
bq2415x_sysfs_set_limit(struct device
*dev
,
1341 struct device_attribute
*attr
,
1345 struct power_supply
*psy
= dev_get_drvdata(dev
);
1346 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1350 if (kstrtol(buf
, 10, &val
) < 0)
1353 if (strcmp(attr
->attr
.name
, "current_limit") == 0)
1354 ret
= bq2415x_set_current_limit(bq
, val
);
1355 else if (strcmp(attr
->attr
.name
, "weak_battery_voltage") == 0)
1356 ret
= bq2415x_set_weak_battery_voltage(bq
, val
);
1357 else if (strcmp(attr
->attr
.name
, "battery_regulation_voltage") == 0)
1358 ret
= bq2415x_set_battery_regulation_voltage(bq
, val
);
1359 else if (strcmp(attr
->attr
.name
, "charge_current") == 0)
1360 ret
= bq2415x_set_charge_current(bq
, val
);
1361 else if (strcmp(attr
->attr
.name
, "termination_current") == 0)
1362 ret
= bq2415x_set_termination_current(bq
, val
);
1371 /* show current and voltage limit entries (in mA or mV) */
1372 static ssize_t
bq2415x_sysfs_show_limit(struct device
*dev
,
1373 struct device_attribute
*attr
,
1376 struct power_supply
*psy
= dev_get_drvdata(dev
);
1377 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1380 if (strcmp(attr
->attr
.name
, "current_limit") == 0)
1381 ret
= bq2415x_get_current_limit(bq
);
1382 else if (strcmp(attr
->attr
.name
, "weak_battery_voltage") == 0)
1383 ret
= bq2415x_get_weak_battery_voltage(bq
);
1384 else if (strcmp(attr
->attr
.name
, "battery_regulation_voltage") == 0)
1385 ret
= bq2415x_get_battery_regulation_voltage(bq
);
1386 else if (strcmp(attr
->attr
.name
, "charge_current") == 0)
1387 ret
= bq2415x_get_charge_current(bq
);
1388 else if (strcmp(attr
->attr
.name
, "termination_current") == 0)
1389 ret
= bq2415x_get_termination_current(bq
);
1395 return sprintf(buf
, "%d\n", ret
);
1398 /* set *_enable entries */
1399 static ssize_t
bq2415x_sysfs_set_enable(struct device
*dev
,
1400 struct device_attribute
*attr
,
1404 struct power_supply
*psy
= dev_get_drvdata(dev
);
1405 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1406 enum bq2415x_command command
;
1410 if (kstrtol(buf
, 10, &val
) < 0)
1413 if (strcmp(attr
->attr
.name
, "charge_termination_enable") == 0)
1414 command
= val
? BQ2415X_CHARGE_TERMINATION_ENABLE
:
1415 BQ2415X_CHARGE_TERMINATION_DISABLE
;
1416 else if (strcmp(attr
->attr
.name
, "high_impedance_enable") == 0)
1417 command
= val
? BQ2415X_HIGH_IMPEDANCE_ENABLE
:
1418 BQ2415X_HIGH_IMPEDANCE_DISABLE
;
1419 else if (strcmp(attr
->attr
.name
, "otg_pin_enable") == 0)
1420 command
= val
? BQ2415X_OTG_PIN_ENABLE
:
1421 BQ2415X_OTG_PIN_DISABLE
;
1422 else if (strcmp(attr
->attr
.name
, "stat_pin_enable") == 0)
1423 command
= val
? BQ2415X_STAT_PIN_ENABLE
:
1424 BQ2415X_STAT_PIN_DISABLE
;
1428 ret
= bq2415x_exec_command(bq
, command
);
1434 /* show *_enable entries */
1435 static ssize_t
bq2415x_sysfs_show_enable(struct device
*dev
,
1436 struct device_attribute
*attr
,
1439 struct power_supply
*psy
= dev_get_drvdata(dev
);
1440 struct bq2415x_device
*bq
= power_supply_get_drvdata(psy
);
1441 enum bq2415x_command command
;
1444 if (strcmp(attr
->attr
.name
, "charge_termination_enable") == 0)
1445 command
= BQ2415X_CHARGE_TERMINATION_STATUS
;
1446 else if (strcmp(attr
->attr
.name
, "high_impedance_enable") == 0)
1447 command
= BQ2415X_HIGH_IMPEDANCE_STATUS
;
1448 else if (strcmp(attr
->attr
.name
, "otg_pin_enable") == 0)
1449 command
= BQ2415X_OTG_PIN_STATUS
;
1450 else if (strcmp(attr
->attr
.name
, "stat_pin_enable") == 0)
1451 command
= BQ2415X_STAT_PIN_STATUS
;
1455 ret
= bq2415x_exec_command(bq
, command
);
1458 return sprintf(buf
, "%d\n", ret
);
1461 static DEVICE_ATTR(current_limit
, S_IWUSR
| S_IRUGO
,
1462 bq2415x_sysfs_show_limit
, bq2415x_sysfs_set_limit
);
1463 static DEVICE_ATTR(weak_battery_voltage
, S_IWUSR
| S_IRUGO
,
1464 bq2415x_sysfs_show_limit
, bq2415x_sysfs_set_limit
);
1465 static DEVICE_ATTR(battery_regulation_voltage
, S_IWUSR
| S_IRUGO
,
1466 bq2415x_sysfs_show_limit
, bq2415x_sysfs_set_limit
);
1467 static DEVICE_ATTR(charge_current
, S_IWUSR
| S_IRUGO
,
1468 bq2415x_sysfs_show_limit
, bq2415x_sysfs_set_limit
);
1469 static DEVICE_ATTR(termination_current
, S_IWUSR
| S_IRUGO
,
1470 bq2415x_sysfs_show_limit
, bq2415x_sysfs_set_limit
);
1472 static DEVICE_ATTR(charge_termination_enable
, S_IWUSR
| S_IRUGO
,
1473 bq2415x_sysfs_show_enable
, bq2415x_sysfs_set_enable
);
1474 static DEVICE_ATTR(high_impedance_enable
, S_IWUSR
| S_IRUGO
,
1475 bq2415x_sysfs_show_enable
, bq2415x_sysfs_set_enable
);
1476 static DEVICE_ATTR(otg_pin_enable
, S_IWUSR
| S_IRUGO
,
1477 bq2415x_sysfs_show_enable
, bq2415x_sysfs_set_enable
);
1478 static DEVICE_ATTR(stat_pin_enable
, S_IWUSR
| S_IRUGO
,
1479 bq2415x_sysfs_show_enable
, bq2415x_sysfs_set_enable
);
1481 static DEVICE_ATTR(reported_mode
, S_IRUGO
,
1482 bq2415x_sysfs_show_reported_mode
, NULL
);
1483 static DEVICE_ATTR(mode
, S_IWUSR
| S_IRUGO
,
1484 bq2415x_sysfs_show_mode
, bq2415x_sysfs_set_mode
);
1485 static DEVICE_ATTR(timer
, S_IWUSR
| S_IRUGO
,
1486 bq2415x_sysfs_show_timer
, bq2415x_sysfs_set_timer
);
1488 static DEVICE_ATTR(registers
, S_IWUSR
| S_IRUGO
,
1489 bq2415x_sysfs_show_registers
, bq2415x_sysfs_set_registers
);
1491 static DEVICE_ATTR(otg_status
, S_IRUGO
, bq2415x_sysfs_show_status
, NULL
);
1492 static DEVICE_ATTR(charge_status
, S_IRUGO
, bq2415x_sysfs_show_status
, NULL
);
1493 static DEVICE_ATTR(boost_status
, S_IRUGO
, bq2415x_sysfs_show_status
, NULL
);
1494 static DEVICE_ATTR(fault_status
, S_IRUGO
, bq2415x_sysfs_show_status
, NULL
);
1496 static struct attribute
*bq2415x_sysfs_attributes
[] = {
1498 * TODO: some (appropriate) of these attrs should be switched to
1499 * use power supply class props.
1501 &dev_attr_current_limit
.attr
,
1502 &dev_attr_weak_battery_voltage
.attr
,
1503 &dev_attr_battery_regulation_voltage
.attr
,
1504 &dev_attr_charge_current
.attr
,
1505 &dev_attr_termination_current
.attr
,
1507 &dev_attr_charge_termination_enable
.attr
,
1508 &dev_attr_high_impedance_enable
.attr
,
1509 &dev_attr_otg_pin_enable
.attr
,
1510 &dev_attr_stat_pin_enable
.attr
,
1512 &dev_attr_reported_mode
.attr
,
1513 &dev_attr_mode
.attr
,
1514 &dev_attr_timer
.attr
,
1516 &dev_attr_registers
.attr
,
1518 &dev_attr_otg_status
.attr
,
1519 &dev_attr_charge_status
.attr
,
1520 &dev_attr_boost_status
.attr
,
1521 &dev_attr_fault_status
.attr
,
1525 static const struct attribute_group bq2415x_sysfs_attr_group
= {
1526 .attrs
= bq2415x_sysfs_attributes
,
1529 static int bq2415x_sysfs_init(struct bq2415x_device
*bq
)
1531 return sysfs_create_group(&bq
->charger
->dev
.kobj
,
1532 &bq2415x_sysfs_attr_group
);
1535 static void bq2415x_sysfs_exit(struct bq2415x_device
*bq
)
1537 sysfs_remove_group(&bq
->charger
->dev
.kobj
, &bq2415x_sysfs_attr_group
);
1540 /* main bq2415x probe function */
1541 static int bq2415x_probe(struct i2c_client
*client
,
1542 const struct i2c_device_id
*id
)
1547 struct bq2415x_device
*bq
;
1548 struct device_node
*np
= client
->dev
.of_node
;
1549 struct bq2415x_platform_data
*pdata
= client
->dev
.platform_data
;
1550 const struct acpi_device_id
*acpi_id
= NULL
;
1551 struct power_supply
*notify_psy
= NULL
;
1552 union power_supply_propval prop
;
1554 if (!np
&& !pdata
&& !ACPI_HANDLE(&client
->dev
)) {
1555 dev_err(&client
->dev
, "Neither devicetree, nor platform data, nor ACPI support\n");
1559 /* Get new ID for the new device */
1560 mutex_lock(&bq2415x_id_mutex
);
1561 num
= idr_alloc(&bq2415x_id
, client
, 0, 0, GFP_KERNEL
);
1562 mutex_unlock(&bq2415x_id_mutex
);
1567 name
= kasprintf(GFP_KERNEL
, "%s-%d", id
->name
, num
);
1568 } else if (ACPI_HANDLE(&client
->dev
)) {
1570 acpi_match_device(client
->dev
.driver
->acpi_match_table
,
1572 name
= kasprintf(GFP_KERNEL
, "%s-%d", acpi_id
->id
, num
);
1575 dev_err(&client
->dev
, "failed to allocate device name\n");
1580 bq
= devm_kzalloc(&client
->dev
, sizeof(*bq
), GFP_KERNEL
);
1586 i2c_set_clientdata(client
, bq
);
1589 bq
->dev
= &client
->dev
;
1591 bq
->chip
= id
->driver_data
;
1592 else if (ACPI_HANDLE(bq
->dev
))
1593 bq
->chip
= acpi_id
->driver_data
;
1595 bq
->mode
= BQ2415X_MODE_OFF
;
1596 bq
->reported_mode
= BQ2415X_MODE_OFF
;
1600 if (np
|| ACPI_HANDLE(bq
->dev
)) {
1601 ret
= device_property_read_u32(bq
->dev
,
1603 &bq
->init_data
.current_limit
);
1606 ret
= device_property_read_u32(bq
->dev
,
1607 "ti,weak-battery-voltage",
1608 &bq
->init_data
.weak_battery_voltage
);
1611 ret
= device_property_read_u32(bq
->dev
,
1612 "ti,battery-regulation-voltage",
1613 &bq
->init_data
.battery_regulation_voltage
);
1616 ret
= device_property_read_u32(bq
->dev
,
1617 "ti,charge-current",
1618 &bq
->init_data
.charge_current
);
1621 ret
= device_property_read_u32(bq
->dev
,
1622 "ti,termination-current",
1623 &bq
->init_data
.termination_current
);
1626 ret
= device_property_read_u32(bq
->dev
,
1627 "ti,resistor-sense",
1628 &bq
->init_data
.resistor_sense
);
1632 bq
->notify_node
= of_parse_phandle(np
,
1633 "ti,usb-charger-detection", 0);
1635 memcpy(&bq
->init_data
, pdata
, sizeof(bq
->init_data
));
1638 bq2415x_reset_chip(bq
);
1640 ret
= bq2415x_power_supply_init(bq
);
1642 dev_err(bq
->dev
, "failed to register power supply: %d\n", ret
);
1646 ret
= bq2415x_sysfs_init(bq
);
1648 dev_err(bq
->dev
, "failed to create sysfs entries: %d\n", ret
);
1652 ret
= bq2415x_set_defaults(bq
);
1654 dev_err(bq
->dev
, "failed to set default values: %d\n", ret
);
1658 if (bq
->notify_node
|| bq
->init_data
.notify_device
) {
1659 bq
->nb
.notifier_call
= bq2415x_notifier_call
;
1660 ret
= power_supply_reg_notifier(&bq
->nb
);
1662 dev_err(bq
->dev
, "failed to reg notifier: %d\n", ret
);
1667 dev_info(bq
->dev
, "automode supported, waiting for events\n");
1670 dev_info(bq
->dev
, "automode not supported\n");
1673 /* Query for initial reported_mode and set it */
1674 if (bq
->nb
.notifier_call
) {
1676 notify_psy
= power_supply_get_by_phandle(np
,
1677 "ti,usb-charger-detection");
1678 if (IS_ERR(notify_psy
))
1680 } else if (bq
->init_data
.notify_device
) {
1681 notify_psy
= power_supply_get_by_name(
1682 bq
->init_data
.notify_device
);
1686 ret
= power_supply_get_property(notify_psy
,
1687 POWER_SUPPLY_PROP_CURRENT_MAX
, &prop
);
1688 power_supply_put(notify_psy
);
1691 bq2415x_update_reported_mode(bq
, prop
.intval
);
1692 bq2415x_set_mode(bq
, bq
->reported_mode
);
1696 INIT_DELAYED_WORK(&bq
->work
, bq2415x_timer_work
);
1697 bq2415x_set_autotimer(bq
, 1);
1699 dev_info(bq
->dev
, "driver registered\n");
1703 bq2415x_sysfs_exit(bq
);
1705 bq2415x_power_supply_exit(bq
);
1707 if (bq
&& bq
->notify_node
)
1708 of_node_put(bq
->notify_node
);
1711 mutex_lock(&bq2415x_id_mutex
);
1712 idr_remove(&bq2415x_id
, num
);
1713 mutex_unlock(&bq2415x_id_mutex
);
1718 /* main bq2415x remove function */
1720 static int bq2415x_remove(struct i2c_client
*client
)
1722 struct bq2415x_device
*bq
= i2c_get_clientdata(client
);
1724 if (bq
->nb
.notifier_call
)
1725 power_supply_unreg_notifier(&bq
->nb
);
1727 if (bq
->notify_node
)
1728 of_node_put(bq
->notify_node
);
1730 bq2415x_sysfs_exit(bq
);
1731 bq2415x_power_supply_exit(bq
);
1733 bq2415x_reset_chip(bq
);
1735 mutex_lock(&bq2415x_id_mutex
);
1736 idr_remove(&bq2415x_id
, bq
->id
);
1737 mutex_unlock(&bq2415x_id_mutex
);
1739 dev_info(bq
->dev
, "driver unregistered\n");
1746 static const struct i2c_device_id bq2415x_i2c_id_table
[] = {
1747 { "bq2415x", BQUNKNOWN
},
1748 { "bq24150", BQ24150
},
1749 { "bq24150a", BQ24150A
},
1750 { "bq24151", BQ24151
},
1751 { "bq24151a", BQ24151A
},
1752 { "bq24152", BQ24152
},
1753 { "bq24153", BQ24153
},
1754 { "bq24153a", BQ24153A
},
1755 { "bq24155", BQ24155
},
1756 { "bq24156", BQ24156
},
1757 { "bq24156a", BQ24156A
},
1758 { "bq24157s", BQ24157S
},
1759 { "bq24158", BQ24158
},
1762 MODULE_DEVICE_TABLE(i2c
, bq2415x_i2c_id_table
);
1764 static const struct acpi_device_id bq2415x_i2c_acpi_match
[] = {
1765 { "BQ2415X", BQUNKNOWN
},
1766 { "BQ241500", BQ24150
},
1767 { "BQA24150", BQ24150A
},
1768 { "BQ241510", BQ24151
},
1769 { "BQA24151", BQ24151A
},
1770 { "BQ241520", BQ24152
},
1771 { "BQ241530", BQ24153
},
1772 { "BQA24153", BQ24153A
},
1773 { "BQ241550", BQ24155
},
1774 { "BQ241560", BQ24156
},
1775 { "BQA24156", BQ24156A
},
1776 { "BQS24157", BQ24157S
},
1777 { "BQ241580", BQ24158
},
1780 MODULE_DEVICE_TABLE(acpi
, bq2415x_i2c_acpi_match
);
1782 static struct i2c_driver bq2415x_driver
= {
1784 .name
= "bq2415x-charger",
1785 .acpi_match_table
= ACPI_PTR(bq2415x_i2c_acpi_match
),
1787 .probe
= bq2415x_probe
,
1788 .remove
= bq2415x_remove
,
1789 .id_table
= bq2415x_i2c_id_table
,
1791 module_i2c_driver(bq2415x_driver
);
1793 MODULE_AUTHOR("Pali Rohár <pali.rohar@gmail.com>");
1794 MODULE_DESCRIPTION("bq2415x charger driver");
1795 MODULE_LICENSE("GPL");