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