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