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