Kernel

Kernel Git Source Tree

Root/drivers/power/smb347-charger.c

1	/*
2	* Summit Microelectronics SMB347 Battery Charger Driver
3	*
4	* Copyright (C) 2011, Intel Corporation
5	*
6	* Authors: Bruce E. Robertson <bruce.e.robertson@intel.com>
7	* Mika Westerberg <mika.westerberg@linux.intel.com>
8	*
9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License version 2 as
11	* published by the Free Software Foundation.
12	*/
13
14	#include <linux/err.h>
15	#include <linux/gpio.h>
16	#include <linux/kernel.h>
17	#include <linux/module.h>
18	#include <linux/init.h>
19	#include <linux/interrupt.h>
20	#include <linux/i2c.h>
21	#include <linux/mutex.h>
22	#include <linux/power_supply.h>
23	#include <linux/power/smb347-charger.h>
24	#include <linux/regmap.h>
25
26	/*
27	* Configuration registers. These are mirrored to volatile RAM and can be
28	* written once %CMD_A_ALLOW_WRITE is set in %CMD_A register. They will be
29	* reloaded from non-volatile registers after POR.
30	*/
31	#define CFG_CHARGE_CURRENT 0x00
32	#define CFG_CHARGE_CURRENT_FCC_MASK 0xe0
33	#define CFG_CHARGE_CURRENT_FCC_SHIFT 5
34	#define CFG_CHARGE_CURRENT_PCC_MASK 0x18
35	#define CFG_CHARGE_CURRENT_PCC_SHIFT 3
36	#define CFG_CHARGE_CURRENT_TC_MASK 0x07
37	#define CFG_CURRENT_LIMIT 0x01
38	#define CFG_CURRENT_LIMIT_DC_MASK 0xf0
39	#define CFG_CURRENT_LIMIT_DC_SHIFT 4
40	#define CFG_CURRENT_LIMIT_USB_MASK 0x0f
41	#define CFG_FLOAT_VOLTAGE 0x03
42	#define CFG_FLOAT_VOLTAGE_FLOAT_MASK 0x3f
43	#define CFG_FLOAT_VOLTAGE_THRESHOLD_MASK 0xc0
44	#define CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT 6
45	#define CFG_STAT 0x05
46	#define CFG_STAT_DISABLED BIT(5)
47	#define CFG_STAT_ACTIVE_HIGH BIT(7)
48	#define CFG_PIN 0x06
49	#define CFG_PIN_EN_CTRL_MASK 0x60
50	#define CFG_PIN_EN_CTRL_ACTIVE_HIGH 0x40
51	#define CFG_PIN_EN_CTRL_ACTIVE_LOW 0x60
52	#define CFG_PIN_EN_APSD_IRQ BIT(1)
53	#define CFG_PIN_EN_CHARGER_ERROR BIT(2)
54	#define CFG_THERM 0x07
55	#define CFG_THERM_SOFT_HOT_COMPENSATION_MASK 0x03
56	#define CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT 0
57	#define CFG_THERM_SOFT_COLD_COMPENSATION_MASK 0x0c
58	#define CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT 2
59	#define CFG_THERM_MONITOR_DISABLED BIT(4)
60	#define CFG_SYSOK 0x08
61	#define CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED BIT(2)
62	#define CFG_OTHER 0x09
63	#define CFG_OTHER_RID_MASK 0xc0
64	#define CFG_OTHER_RID_ENABLED_AUTO_OTG 0xc0
65	#define CFG_OTG 0x0a
66	#define CFG_OTG_TEMP_THRESHOLD_MASK 0x30
67	#define CFG_OTG_TEMP_THRESHOLD_SHIFT 4
68	#define CFG_OTG_CC_COMPENSATION_MASK 0xc0
69	#define CFG_OTG_CC_COMPENSATION_SHIFT 6
70	#define CFG_TEMP_LIMIT 0x0b
71	#define CFG_TEMP_LIMIT_SOFT_HOT_MASK 0x03
72	#define CFG_TEMP_LIMIT_SOFT_HOT_SHIFT 0
73	#define CFG_TEMP_LIMIT_SOFT_COLD_MASK 0x0c
74	#define CFG_TEMP_LIMIT_SOFT_COLD_SHIFT 2
75	#define CFG_TEMP_LIMIT_HARD_HOT_MASK 0x30
76	#define CFG_TEMP_LIMIT_HARD_HOT_SHIFT 4
77	#define CFG_TEMP_LIMIT_HARD_COLD_MASK 0xc0
78	#define CFG_TEMP_LIMIT_HARD_COLD_SHIFT 6
79	#define CFG_FAULT_IRQ 0x0c
80	#define CFG_FAULT_IRQ_DCIN_UV BIT(2)
81	#define CFG_STATUS_IRQ 0x0d
82	#define CFG_STATUS_IRQ_TERMINATION_OR_TAPER BIT(4)
83	#define CFG_ADDRESS 0x0e
84
85	/* Command registers */
86	#define CMD_A 0x30
87	#define CMD_A_CHG_ENABLED BIT(1)
88	#define CMD_A_SUSPEND_ENABLED BIT(2)
89	#define CMD_A_ALLOW_WRITE BIT(7)
90	#define CMD_B 0x31
91	#define CMD_C 0x33
92
93	/* Interrupt Status registers */
94	#define IRQSTAT_A 0x35
95	#define IRQSTAT_C 0x37
96	#define IRQSTAT_C_TERMINATION_STAT BIT(0)
97	#define IRQSTAT_C_TERMINATION_IRQ BIT(1)
98	#define IRQSTAT_C_TAPER_IRQ BIT(3)
99	#define IRQSTAT_E 0x39
100	#define IRQSTAT_E_USBIN_UV_STAT BIT(0)
101	#define IRQSTAT_E_USBIN_UV_IRQ BIT(1)
102	#define IRQSTAT_E_DCIN_UV_STAT BIT(4)
103	#define IRQSTAT_E_DCIN_UV_IRQ BIT(5)
104	#define IRQSTAT_F 0x3a
105
106	/* Status registers */
107	#define STAT_A 0x3b
108	#define STAT_A_FLOAT_VOLTAGE_MASK 0x3f
109	#define STAT_B 0x3c
110	#define STAT_C 0x3d
111	#define STAT_C_CHG_ENABLED BIT(0)
112	#define STAT_C_CHG_MASK 0x06
113	#define STAT_C_CHG_SHIFT 1
114	#define STAT_C_CHARGER_ERROR BIT(6)
115	#define STAT_E 0x3f
116
117	#define SMB347_MAX_REGISTER 0x3f
118
119	/**
120	* struct smb347_charger - smb347 charger instance
121	* @lock: protects concurrent access to online variables
122	* @dev: pointer to device
123	* @regmap: pointer to driver regmap
124	* @mains: power_supply instance for AC/DC power
125	* @usb: power_supply instance for USB power
126	* @battery: power_supply instance for battery
127	* @mains_online: is AC/DC input connected
128	* @usb_online: is USB input connected
129	* @charging_enabled: is charging enabled
130	* @pdata: pointer to platform data
131	*/
132	struct smb347_charger {
133	struct mutex lock;
134	struct device *dev;
135	struct regmap *regmap;
136	struct power_supply mains;
137	struct power_supply usb;
138	struct power_supply battery;
139	bool mains_online;
140	bool usb_online;
141	bool charging_enabled;
142	const struct smb347_charger_platform_data *pdata;
143	};
144
145	/* Fast charge current in uA */
146	static const unsigned int fcc_tbl[] = {
147	700000,
148	900000,
149	1200000,
150	1500000,
151	1800000,
152	2000000,
153	2200000,
154	2500000,
155	};
156
157	/* Pre-charge current in uA */
158	static const unsigned int pcc_tbl[] = {
159	100000,
160	150000,
161	200000,
162	250000,
163	};
164
165	/* Termination current in uA */
166	static const unsigned int tc_tbl[] = {
167	37500,
168	50000,
169	100000,
170	150000,
171	200000,
172	250000,
173	500000,
174	600000,
175	};
176
177	/* Input current limit in uA */
178	static const unsigned int icl_tbl[] = {
179	300000,
180	500000,
181	700000,
182	900000,
183	1200000,
184	1500000,
185	1800000,
186	2000000,
187	2200000,
188	2500000,
189	};
190
191	/* Charge current compensation in uA */
192	static const unsigned int ccc_tbl[] = {
193	250000,
194	700000,
195	900000,
196	1200000,
197	};
198
199	/* Convert register value to current using lookup table */
200	static int hw_to_current(const unsigned int *tbl, size_t size, unsigned int val)
201	{
202	if (val >= size)
203	return -EINVAL;
204	return tbl[val];
205	}
206
207	/* Convert current to register value using lookup table */
208	static int current_to_hw(const unsigned int *tbl, size_t size, unsigned int val)
209	{
210	size_t i;
211
212	for (i = 0; i < size; i++)
213	if (val < tbl[i])
214	break;
215	return i > 0 ? i - 1 : -EINVAL;
216	}
217
218	/**
219	* smb347_update_ps_status - refreshes the power source status
220	* @smb: pointer to smb347 charger instance
221	*
222	* Function checks whether any power source is connected to the charger and
223	* updates internal state accordingly. If there is a change to previous state
224	* function returns %1, otherwise %0 and negative errno in case of errror.
225	*/
226	static int smb347_update_ps_status(struct smb347_charger *smb)
227	{
228	bool usb = false;
229	bool dc = false;
230	unsigned int val;
231	int ret;
232
233	ret = regmap_read(smb->regmap, IRQSTAT_E, &val);
234	if (ret < 0)
235	return ret;
236
237	/*
238	* Dc and usb are set depending on whether they are enabled in
239	* platform data _and_ whether corresponding undervoltage is set.
240	*/
241	if (smb->pdata->use_mains)
242	dc = !(val & IRQSTAT_E_DCIN_UV_STAT);
243	if (smb->pdata->use_usb)
244	usb = !(val & IRQSTAT_E_USBIN_UV_STAT);
245
246	mutex_lock(&smb->lock);
247	ret = smb->mains_online != dc \|\| smb->usb_online != usb;
248	smb->mains_online = dc;
249	smb->usb_online = usb;
250	mutex_unlock(&smb->lock);
251
252	return ret;
253	}
254
255	/*
256	* smb347_is_ps_online - returns whether input power source is connected
257	* @smb: pointer to smb347 charger instance
258	*
259	* Returns %true if input power source is connected. Note that this is
260	* dependent on what platform has configured for usable power sources. For
261	* example if USB is disabled, this will return %false even if the USB cable
262	* is connected.
263	*/
264	static bool smb347_is_ps_online(struct smb347_charger *smb)
265	{
266	bool ret;
267
268	mutex_lock(&smb->lock);
269	ret = smb->usb_online \|\| smb->mains_online;
270	mutex_unlock(&smb->lock);
271
272	return ret;
273	}
274
275	/**
276	* smb347_charging_status - returns status of charging
277	* @smb: pointer to smb347 charger instance
278	*
279	* Function returns charging status. %0 means no charging is in progress,
280	* %1 means pre-charging, %2 fast-charging and %3 taper-charging.
281	*/
282	static int smb347_charging_status(struct smb347_charger *smb)
283	{
284	unsigned int val;
285	int ret;
286
287	if (!smb347_is_ps_online(smb))
288	return 0;
289
290	ret = regmap_read(smb->regmap, STAT_C, &val);
291	if (ret < 0)
292	return 0;
293
294	return (val & STAT_C_CHG_MASK) >> STAT_C_CHG_SHIFT;
295	}
296
297	static int smb347_charging_set(struct smb347_charger *smb, bool enable)
298	{
299	int ret = 0;
300
301	if (smb->pdata->enable_control != SMB347_CHG_ENABLE_SW) {
302	dev_dbg(smb->dev, "charging enable/disable in SW disabled\n");
303	return 0;
304	}
305
306	mutex_lock(&smb->lock);
307	if (smb->charging_enabled != enable) {
308	ret = regmap_update_bits(smb->regmap, CMD_A, CMD_A_CHG_ENABLED,
309	enable ? CMD_A_CHG_ENABLED : 0);
310	if (!ret)
311	smb->charging_enabled = enable;
312	}
313	mutex_unlock(&smb->lock);
314	return ret;
315	}
316
317	static inline int smb347_charging_enable(struct smb347_charger *smb)
318	{
319	return smb347_charging_set(smb, true);
320	}
321
322	static inline int smb347_charging_disable(struct smb347_charger *smb)
323	{
324	return smb347_charging_set(smb, false);
325	}
326
327	static int smb347_start_stop_charging(struct smb347_charger *smb)
328	{
329	int ret;
330
331	/*
332	* Depending on whether valid power source is connected or not, we
333	* disable or enable the charging. We do it manually because it
334	* depends on how the platform has configured the valid inputs.
335	*/
336	if (smb347_is_ps_online(smb)) {
337	ret = smb347_charging_enable(smb);
338	if (ret < 0)
339	dev_err(smb->dev, "failed to enable charging\n");
340	} else {
341	ret = smb347_charging_disable(smb);
342	if (ret < 0)
343	dev_err(smb->dev, "failed to disable charging\n");
344	}
345
346	return ret;
347	}
348
349	static int smb347_set_charge_current(struct smb347_charger *smb)
350	{
351	int ret;
352
353	if (smb->pdata->max_charge_current) {
354	ret = current_to_hw(fcc_tbl, ARRAY_SIZE(fcc_tbl),
355	smb->pdata->max_charge_current);
356	if (ret < 0)
357	return ret;
358
359	ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
360	CFG_CHARGE_CURRENT_FCC_MASK,
361	ret << CFG_CHARGE_CURRENT_FCC_SHIFT);
362	if (ret < 0)
363	return ret;
364	}
365
366	if (smb->pdata->pre_charge_current) {
367	ret = current_to_hw(pcc_tbl, ARRAY_SIZE(pcc_tbl),
368	smb->pdata->pre_charge_current);
369	if (ret < 0)
370	return ret;
371
372	ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
373	CFG_CHARGE_CURRENT_PCC_MASK,
374	ret << CFG_CHARGE_CURRENT_PCC_SHIFT);
375	if (ret < 0)
376	return ret;
377	}
378
379	if (smb->pdata->termination_current) {
380	ret = current_to_hw(tc_tbl, ARRAY_SIZE(tc_tbl),
381	smb->pdata->termination_current);
382	if (ret < 0)
383	return ret;
384
385	ret = regmap_update_bits(smb->regmap, CFG_CHARGE_CURRENT,
386	CFG_CHARGE_CURRENT_TC_MASK, ret);
387	if (ret < 0)
388	return ret;
389	}
390
391	return 0;
392	}
393
394	static int smb347_set_current_limits(struct smb347_charger *smb)
395	{
396	int ret;
397
398	if (smb->pdata->mains_current_limit) {
399	ret = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
400	smb->pdata->mains_current_limit);
401	if (ret < 0)
402	return ret;
403
404	ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
405	CFG_CURRENT_LIMIT_DC_MASK,
406	ret << CFG_CURRENT_LIMIT_DC_SHIFT);
407	if (ret < 0)
408	return ret;
409	}
410
411	if (smb->pdata->usb_hc_current_limit) {
412	ret = current_to_hw(icl_tbl, ARRAY_SIZE(icl_tbl),
413	smb->pdata->usb_hc_current_limit);
414	if (ret < 0)
415	return ret;
416
417	ret = regmap_update_bits(smb->regmap, CFG_CURRENT_LIMIT,
418	CFG_CURRENT_LIMIT_USB_MASK, ret);
419	if (ret < 0)
420	return ret;
421	}
422
423	return 0;
424	}
425
426	static int smb347_set_voltage_limits(struct smb347_charger *smb)
427	{
428	int ret;
429
430	if (smb->pdata->pre_to_fast_voltage) {
431	ret = smb->pdata->pre_to_fast_voltage;
432
433	/* uV */
434	ret = clamp_val(ret, 2400000, 3000000) - 2400000;
435	ret /= 200000;
436
437	ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
438	CFG_FLOAT_VOLTAGE_THRESHOLD_MASK,
439	ret << CFG_FLOAT_VOLTAGE_THRESHOLD_SHIFT);
440	if (ret < 0)
441	return ret;
442	}
443
444	if (smb->pdata->max_charge_voltage) {
445	ret = smb->pdata->max_charge_voltage;
446
447	/* uV */
448	ret = clamp_val(ret, 3500000, 4500000) - 3500000;
449	ret /= 20000;
450
451	ret = regmap_update_bits(smb->regmap, CFG_FLOAT_VOLTAGE,
452	CFG_FLOAT_VOLTAGE_FLOAT_MASK, ret);
453	if (ret < 0)
454	return ret;
455	}
456
457	return 0;
458	}
459
460	static int smb347_set_temp_limits(struct smb347_charger *smb)
461	{
462	bool enable_therm_monitor = false;
463	int ret = 0;
464	int val;
465
466	if (smb->pdata->chip_temp_threshold) {
467	val = smb->pdata->chip_temp_threshold;
468
469	/* degree C */
470	val = clamp_val(val, 100, 130) - 100;
471	val /= 10;
472
473	ret = regmap_update_bits(smb->regmap, CFG_OTG,
474	CFG_OTG_TEMP_THRESHOLD_MASK,
475	val << CFG_OTG_TEMP_THRESHOLD_SHIFT);
476	if (ret < 0)
477	return ret;
478	}
479
480	if (smb->pdata->soft_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
481	val = smb->pdata->soft_cold_temp_limit;
482
483	val = clamp_val(val, 0, 15);
484	val /= 5;
485	/* this goes from higher to lower so invert the value */
486	val = ~val & 0x3;
487
488	ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
489	CFG_TEMP_LIMIT_SOFT_COLD_MASK,
490	val << CFG_TEMP_LIMIT_SOFT_COLD_SHIFT);
491	if (ret < 0)
492	return ret;
493
494	enable_therm_monitor = true;
495	}
496
497	if (smb->pdata->soft_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
498	val = smb->pdata->soft_hot_temp_limit;
499
500	val = clamp_val(val, 40, 55) - 40;
501	val /= 5;
502
503	ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
504	CFG_TEMP_LIMIT_SOFT_HOT_MASK,
505	val << CFG_TEMP_LIMIT_SOFT_HOT_SHIFT);
506	if (ret < 0)
507	return ret;
508
509	enable_therm_monitor = true;
510	}
511
512	if (smb->pdata->hard_cold_temp_limit != SMB347_TEMP_USE_DEFAULT) {
513	val = smb->pdata->hard_cold_temp_limit;
514
515	val = clamp_val(val, -5, 10) + 5;
516	val /= 5;
517	/* this goes from higher to lower so invert the value */
518	val = ~val & 0x3;
519
520	ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
521	CFG_TEMP_LIMIT_HARD_COLD_MASK,
522	val << CFG_TEMP_LIMIT_HARD_COLD_SHIFT);
523	if (ret < 0)
524	return ret;
525
526	enable_therm_monitor = true;
527	}
528
529	if (smb->pdata->hard_hot_temp_limit != SMB347_TEMP_USE_DEFAULT) {
530	val = smb->pdata->hard_hot_temp_limit;
531
532	val = clamp_val(val, 50, 65) - 50;
533	val /= 5;
534
535	ret = regmap_update_bits(smb->regmap, CFG_TEMP_LIMIT,
536	CFG_TEMP_LIMIT_HARD_HOT_MASK,
537	val << CFG_TEMP_LIMIT_HARD_HOT_SHIFT);
538	if (ret < 0)
539	return ret;
540
541	enable_therm_monitor = true;
542	}
543
544	/*
545	* If any of the temperature limits are set, we also enable the
546	* thermistor monitoring.
547	*
548	* When soft limits are hit, the device will start to compensate
549	* current and/or voltage depending on the configuration.
550	*
551	* When hard limit is hit, the device will suspend charging
552	* depending on the configuration.
553	*/
554	if (enable_therm_monitor) {
555	ret = regmap_update_bits(smb->regmap, CFG_THERM,
556	CFG_THERM_MONITOR_DISABLED, 0);
557	if (ret < 0)
558	return ret;
559	}
560
561	if (smb->pdata->suspend_on_hard_temp_limit) {
562	ret = regmap_update_bits(smb->regmap, CFG_SYSOK,
563	CFG_SYSOK_SUSPEND_HARD_LIMIT_DISABLED, 0);
564	if (ret < 0)
565	return ret;
566	}
567
568	if (smb->pdata->soft_temp_limit_compensation !=
569	SMB347_SOFT_TEMP_COMPENSATE_DEFAULT) {
570	val = smb->pdata->soft_temp_limit_compensation & 0x3;
571
572	ret = regmap_update_bits(smb->regmap, CFG_THERM,
573	CFG_THERM_SOFT_HOT_COMPENSATION_MASK,
574	val << CFG_THERM_SOFT_HOT_COMPENSATION_SHIFT);
575	if (ret < 0)
576	return ret;
577
578	ret = regmap_update_bits(smb->regmap, CFG_THERM,
579	CFG_THERM_SOFT_COLD_COMPENSATION_MASK,
580	val << CFG_THERM_SOFT_COLD_COMPENSATION_SHIFT);
581	if (ret < 0)
582	return ret;
583	}
584
585	if (smb->pdata->charge_current_compensation) {
586	val = current_to_hw(ccc_tbl, ARRAY_SIZE(ccc_tbl),
587	smb->pdata->charge_current_compensation);
588	if (val < 0)
589	return val;
590
591	ret = regmap_update_bits(smb->regmap, CFG_OTG,
592	CFG_OTG_CC_COMPENSATION_MASK,
593	(val & 0x3) << CFG_OTG_CC_COMPENSATION_SHIFT);
594	if (ret < 0)
595	return ret;
596	}
597
598	return ret;
599	}
600
601	/*
602	* smb347_set_writable - enables/disables writing to non-volatile registers
603	* @smb: pointer to smb347 charger instance
604	*
605	* You can enable/disable writing to the non-volatile configuration
606	* registers by calling this function.
607	*
608	* Returns %0 on success and negative errno in case of failure.
609	*/
610	static int smb347_set_writable(struct smb347_charger *smb, bool writable)
611	{
612	return regmap_update_bits(smb->regmap, CMD_A, CMD_A_ALLOW_WRITE,
613	writable ? CMD_A_ALLOW_WRITE : 0);
614	}
615
616	static int smb347_hw_init(struct smb347_charger *smb)
617	{
618	unsigned int val;
619	int ret;
620
621	ret = smb347_set_writable(smb, true);
622	if (ret < 0)
623	return ret;
624
625	/*
626	* Program the platform specific configuration values to the device
627	* first.
628	*/
629	ret = smb347_set_charge_current(smb);
630	if (ret < 0)
631	goto fail;
632
633	ret = smb347_set_current_limits(smb);
634	if (ret < 0)
635	goto fail;
636
637	ret = smb347_set_voltage_limits(smb);
638	if (ret < 0)
639	goto fail;
640
641	ret = smb347_set_temp_limits(smb);
642	if (ret < 0)
643	goto fail;
644
645	/* If USB charging is disabled we put the USB in suspend mode */
646	if (!smb->pdata->use_usb) {
647	ret = regmap_update_bits(smb->regmap, CMD_A,
648	CMD_A_SUSPEND_ENABLED,
649	CMD_A_SUSPEND_ENABLED);
650	if (ret < 0)
651	goto fail;
652	}
653
654	/*
655	* If configured by platform data, we enable hardware Auto-OTG
656	* support for driving VBUS. Otherwise we disable it.
657	*/
658	ret = regmap_update_bits(smb->regmap, CFG_OTHER, CFG_OTHER_RID_MASK,
659	smb->pdata->use_usb_otg ? CFG_OTHER_RID_ENABLED_AUTO_OTG : 0);
660	if (ret < 0)
661	goto fail;
662
663	/*
664	* Make the charging functionality controllable by a write to the
665	* command register unless pin control is specified in the platform
666	* data.
667	*/
668	switch (smb->pdata->enable_control) {
669	case SMB347_CHG_ENABLE_PIN_ACTIVE_LOW:
670	val = CFG_PIN_EN_CTRL_ACTIVE_LOW;
671	break;
672	case SMB347_CHG_ENABLE_PIN_ACTIVE_HIGH:
673	val = CFG_PIN_EN_CTRL_ACTIVE_HIGH;
674	break;
675	default:
676	val = 0;
677	break;
678	}
679
680	ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CTRL_MASK,
681	val);
682	if (ret < 0)
683	goto fail;
684
685	/* Disable Automatic Power Source Detection (APSD) interrupt. */
686	ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_APSD_IRQ, 0);
687	if (ret < 0)
688	goto fail;
689
690	ret = smb347_update_ps_status(smb);
691	if (ret < 0)
692	goto fail;
693
694	ret = smb347_start_stop_charging(smb);
695
696	fail:
697	smb347_set_writable(smb, false);
698	return ret;
699	}
700
701	static irqreturn_t smb347_interrupt(int irq, void *data)
702	{
703	struct smb347_charger *smb = data;
704	unsigned int stat_c, irqstat_e, irqstat_c;
705	bool handled = false;
706	int ret;
707
708	ret = regmap_read(smb->regmap, STAT_C, &stat_c);
709	if (ret < 0) {
710	dev_warn(smb->dev, "reading STAT_C failed\n");
711	return IRQ_NONE;
712	}
713
714	ret = regmap_read(smb->regmap, IRQSTAT_C, &irqstat_c);
715	if (ret < 0) {
716	dev_warn(smb->dev, "reading IRQSTAT_C failed\n");
717	return IRQ_NONE;
718	}
719
720	ret = regmap_read(smb->regmap, IRQSTAT_E, &irqstat_e);
721	if (ret < 0) {
722	dev_warn(smb->dev, "reading IRQSTAT_E failed\n");
723	return IRQ_NONE;
724	}
725
726	/*
727	* If we get charger error we report the error back to user and
728	* disable charging.
729	*/
730	if (stat_c & STAT_C_CHARGER_ERROR) {
731	dev_err(smb->dev, "error in charger, disabling charging\n");
732
733	smb347_charging_disable(smb);
734	power_supply_changed(&smb->battery);
735	handled = true;
736	}
737
738	/*
739	* If we reached the termination current the battery is charged and
740	* we can update the status now. Charging is automatically
741	* disabled by the hardware.
742	*/
743	if (irqstat_c & (IRQSTAT_C_TERMINATION_IRQ \| IRQSTAT_C_TAPER_IRQ)) {
744	if (irqstat_c & IRQSTAT_C_TERMINATION_STAT)
745	power_supply_changed(&smb->battery);
746	handled = true;
747	}
748
749	/*
750	* If we got an under voltage interrupt it means that AC/USB input
751	* was connected or disconnected.
752	*/
753	if (irqstat_e & (IRQSTAT_E_USBIN_UV_IRQ \| IRQSTAT_E_DCIN_UV_IRQ)) {
754	if (smb347_update_ps_status(smb) > 0) {
755	smb347_start_stop_charging(smb);
756	if (smb->pdata->use_mains)
757	power_supply_changed(&smb->mains);
758	if (smb->pdata->use_usb)
759	power_supply_changed(&smb->usb);
760	}
761	handled = true;
762	}
763
764	return handled ? IRQ_HANDLED : IRQ_NONE;
765	}
766
767	static int smb347_irq_set(struct smb347_charger *smb, bool enable)
768	{
769	int ret;
770
771	ret = smb347_set_writable(smb, true);
772	if (ret < 0)
773	return ret;
774
775	/*
776	* Enable/disable interrupts for:
777	* - under voltage
778	* - termination current reached
779	* - charger error
780	*/
781	ret = regmap_update_bits(smb->regmap, CFG_FAULT_IRQ, 0xff,
782	enable ? CFG_FAULT_IRQ_DCIN_UV : 0);
783	if (ret < 0)
784	goto fail;
785
786	ret = regmap_update_bits(smb->regmap, CFG_STATUS_IRQ, 0xff,
787	enable ? CFG_STATUS_IRQ_TERMINATION_OR_TAPER : 0);
788	if (ret < 0)
789	goto fail;
790
791	ret = regmap_update_bits(smb->regmap, CFG_PIN, CFG_PIN_EN_CHARGER_ERROR,
792	enable ? CFG_PIN_EN_CHARGER_ERROR : 0);
793	fail:
794	smb347_set_writable(smb, false);
795	return ret;
796	}
797
798	static inline int smb347_irq_enable(struct smb347_charger *smb)
799	{
800	return smb347_irq_set(smb, true);
801	}
802
803	static inline int smb347_irq_disable(struct smb347_charger *smb)
804	{
805	return smb347_irq_set(smb, false);
806	}
807
808	static int smb347_irq_init(struct smb347_charger *smb,
809	struct i2c_client *client)
810	{
811	const struct smb347_charger_platform_data *pdata = smb->pdata;
812	int ret, irq = gpio_to_irq(pdata->irq_gpio);
813
814	ret = gpio_request_one(pdata->irq_gpio, GPIOF_IN, client->name);
815	if (ret < 0)
816	goto fail;
817
818	ret = request_threaded_irq(irq, NULL, smb347_interrupt,
819	IRQF_TRIGGER_FALLING, client->name, smb);
820	if (ret < 0)
821	goto fail_gpio;
822
823	ret = smb347_set_writable(smb, true);
824	if (ret < 0)
825	goto fail_irq;
826
827	/*
828	* Configure the STAT output to be suitable for interrupts: disable
829	* all other output (except interrupts) and make it active low.
830	*/
831	ret = regmap_update_bits(smb->regmap, CFG_STAT,
832	CFG_STAT_ACTIVE_HIGH \| CFG_STAT_DISABLED,
833	CFG_STAT_DISABLED);
834	if (ret < 0)
835	goto fail_readonly;
836
837	smb347_set_writable(smb, false);
838	client->irq = irq;
839	return 0;
840
841	fail_readonly:
842	smb347_set_writable(smb, false);
843	fail_irq:
844	free_irq(irq, smb);
845	fail_gpio:
846	gpio_free(pdata->irq_gpio);
847	fail:
848	client->irq = 0;
849	return ret;
850	}
851
852	/*
853	* Returns the constant charge current programmed
854	* into the charger in uA.
855	*/
856	static int get_const_charge_current(struct smb347_charger *smb)
857	{
858	int ret, intval;
859	unsigned int v;
860
861	if (!smb347_is_ps_online(smb))
862	return -ENODATA;
863
864	ret = regmap_read(smb->regmap, STAT_B, &v);
865	if (ret < 0)
866	return ret;
867
868	/*
869	* The current value is composition of FCC and PCC values
870	* and we can detect which table to use from bit 5.
871	*/
872	if (v & 0x20) {
873	intval = hw_to_current(fcc_tbl, ARRAY_SIZE(fcc_tbl), v & 7);
874	} else {
875	v >>= 3;
876	intval = hw_to_current(pcc_tbl, ARRAY_SIZE(pcc_tbl), v & 7);
877	}
878
879	return intval;
880	}
881
882	/*
883	* Returns the constant charge voltage programmed
884	* into the charger in uV.
885	*/
886	static int get_const_charge_voltage(struct smb347_charger *smb)
887	{
888	int ret, intval;
889	unsigned int v;
890
891	if (!smb347_is_ps_online(smb))
892	return -ENODATA;
893
894	ret = regmap_read(smb->regmap, STAT_A, &v);
895	if (ret < 0)
896	return ret;
897
898	v &= STAT_A_FLOAT_VOLTAGE_MASK;
899	if (v > 0x3d)
900	v = 0x3d;
901
902	intval = 3500000 + v * 20000;
903
904	return intval;
905	}
906
907	static int smb347_mains_get_property(struct power_supply *psy,
908	enum power_supply_property prop,
909	union power_supply_propval *val)
910	{
911	struct smb347_charger *smb =
912	container_of(psy, struct smb347_charger, mains);
913	int ret;
914
915	switch (prop) {
916	case POWER_SUPPLY_PROP_ONLINE:
917	val->intval = smb->mains_online;
918	break;
919
920	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
921	ret = get_const_charge_voltage(smb);
922	if (ret < 0)
923	return ret;
924	else
925	val->intval = ret;
926	break;
927
928	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
929	ret = get_const_charge_current(smb);
930	if (ret < 0)
931	return ret;
932	else
933	val->intval = ret;
934	break;
935
936	default:
937	return -EINVAL;
938	}
939
940	return 0;
941	}
942
943	static enum power_supply_property smb347_mains_properties[] = {
944	POWER_SUPPLY_PROP_ONLINE,
945	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
946	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
947	};
948
949	static int smb347_usb_get_property(struct power_supply *psy,
950	enum power_supply_property prop,
951	union power_supply_propval *val)
952	{
953	struct smb347_charger *smb =
954	container_of(psy, struct smb347_charger, usb);
955	int ret;
956
957	switch (prop) {
958	case POWER_SUPPLY_PROP_ONLINE:
959	val->intval = smb->usb_online;
960	break;
961
962	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
963	ret = get_const_charge_voltage(smb);
964	if (ret < 0)
965	return ret;
966	else
967	val->intval = ret;
968	break;
969
970	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
971	ret = get_const_charge_current(smb);
972	if (ret < 0)
973	return ret;
974	else
975	val->intval = ret;
976	break;
977
978	default:
979	return -EINVAL;
980	}
981
982	return 0;
983	}
984
985	static enum power_supply_property smb347_usb_properties[] = {
986	POWER_SUPPLY_PROP_ONLINE,
987	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
988	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
989	};
990
991	static int smb347_battery_get_property(struct power_supply *psy,
992	enum power_supply_property prop,
993	union power_supply_propval *val)
994	{
995	struct smb347_charger *smb =
996	container_of(psy, struct smb347_charger, battery);
997	const struct smb347_charger_platform_data *pdata = smb->pdata;
998	int ret;
999
1000	ret = smb347_update_ps_status(smb);
1001	if (ret < 0)
1002	return ret;
1003
1004	switch (prop) {
1005	case POWER_SUPPLY_PROP_STATUS:
1006	if (!smb347_is_ps_online(smb)) {
1007	val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
1008	break;
1009	}
1010	if (smb347_charging_status(smb))
1011	val->intval = POWER_SUPPLY_STATUS_CHARGING;
1012	else
1013	val->intval = POWER_SUPPLY_STATUS_FULL;
1014	break;
1015
1016	case POWER_SUPPLY_PROP_CHARGE_TYPE:
1017	if (!smb347_is_ps_online(smb))
1018	return -ENODATA;
1019
1020	/*
1021	* We handle trickle and pre-charging the same, and taper
1022	* and none the same.
1023	*/
1024	switch (smb347_charging_status(smb)) {
1025	case 1:
1026	val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
1027	break;
1028	case 2:
1029	val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
1030	break;
1031	default:
1032	val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
1033	break;
1034	}
1035	break;
1036
1037	case POWER_SUPPLY_PROP_TECHNOLOGY:
1038	val->intval = pdata->battery_info.technology;
1039	break;
1040
1041	case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
1042	val->intval = pdata->battery_info.voltage_min_design;
1043	break;
1044
1045	case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
1046	val->intval = pdata->battery_info.voltage_max_design;
1047	break;
1048
1049	case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN:
1050	val->intval = pdata->battery_info.charge_full_design;
1051	break;
1052
1053	case POWER_SUPPLY_PROP_MODEL_NAME:
1054	val->strval = pdata->battery_info.name;
1055	break;
1056
1057	default:
1058	return -EINVAL;
1059	}
1060
1061	return 0;
1062	}
1063
1064	static enum power_supply_property smb347_battery_properties[] = {
1065	POWER_SUPPLY_PROP_STATUS,
1066	POWER_SUPPLY_PROP_CHARGE_TYPE,
1067	POWER_SUPPLY_PROP_TECHNOLOGY,
1068	POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
1069	POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
1070	POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN,
1071	POWER_SUPPLY_PROP_MODEL_NAME,
1072	};
1073
1074	static bool smb347_volatile_reg(struct device *dev, unsigned int reg)
1075	{
1076	switch (reg) {
1077	case IRQSTAT_A:
1078	case IRQSTAT_C:
1079	case IRQSTAT_E:
1080	case IRQSTAT_F:
1081	case STAT_A:
1082	case STAT_B:
1083	case STAT_C:
1084	case STAT_E:
1085	return true;
1086	}
1087
1088	return false;
1089	}
1090
1091	static bool smb347_readable_reg(struct device *dev, unsigned int reg)
1092	{
1093	switch (reg) {
1094	case CFG_CHARGE_CURRENT:
1095	case CFG_CURRENT_LIMIT:
1096	case CFG_FLOAT_VOLTAGE:
1097	case CFG_STAT:
1098	case CFG_PIN:
1099	case CFG_THERM:
1100	case CFG_SYSOK:
1101	case CFG_OTHER:
1102	case CFG_OTG:
1103	case CFG_TEMP_LIMIT:
1104	case CFG_FAULT_IRQ:
1105	case CFG_STATUS_IRQ:
1106	case CFG_ADDRESS:
1107	case CMD_A:
1108	case CMD_B:
1109	case CMD_C:
1110	return true;
1111	}
1112
1113	return smb347_volatile_reg(dev, reg);
1114	}
1115
1116	static const struct regmap_config smb347_regmap = {
1117	.reg_bits = 8,
1118	.val_bits = 8,
1119	.max_register = SMB347_MAX_REGISTER,
1120	.volatile_reg = smb347_volatile_reg,
1121	.readable_reg = smb347_readable_reg,
1122	};
1123
1124	static int smb347_probe(struct i2c_client *client,
1125	const struct i2c_device_id *id)
1126	{
1127	static char *battery[] = { "smb347-battery" };
1128	const struct smb347_charger_platform_data *pdata;
1129	struct device *dev = &client->dev;
1130	struct smb347_charger *smb;
1131	int ret;
1132
1133	pdata = dev->platform_data;
1134	if (!pdata)
1135	return -EINVAL;
1136
1137	if (!pdata->use_mains && !pdata->use_usb)
1138	return -EINVAL;
1139
1140	smb = devm_kzalloc(dev, sizeof(*smb), GFP_KERNEL);
1141	if (!smb)
1142	return -ENOMEM;
1143
1144	i2c_set_clientdata(client, smb);
1145
1146	mutex_init(&smb->lock);
1147	smb->dev = &client->dev;
1148	smb->pdata = pdata;
1149
1150	smb->regmap = devm_regmap_init_i2c(client, &smb347_regmap);
1151	if (IS_ERR(smb->regmap))
1152	return PTR_ERR(smb->regmap);
1153
1154	ret = smb347_hw_init(smb);
1155	if (ret < 0)
1156	return ret;
1157
1158	if (smb->pdata->use_mains) {
1159	smb->mains.name = "smb347-mains";
1160	smb->mains.type = POWER_SUPPLY_TYPE_MAINS;
1161	smb->mains.get_property = smb347_mains_get_property;
1162	smb->mains.properties = smb347_mains_properties;
1163	smb->mains.num_properties = ARRAY_SIZE(smb347_mains_properties);
1164	smb->mains.supplied_to = battery;
1165	smb->mains.num_supplicants = ARRAY_SIZE(battery);
1166	ret = power_supply_register(dev, &smb->mains);
1167	if (ret < 0)
1168	return ret;
1169	}
1170
1171	if (smb->pdata->use_usb) {
1172	smb->usb.name = "smb347-usb";
1173	smb->usb.type = POWER_SUPPLY_TYPE_USB;
1174	smb->usb.get_property = smb347_usb_get_property;
1175	smb->usb.properties = smb347_usb_properties;
1176	smb->usb.num_properties = ARRAY_SIZE(smb347_usb_properties);
1177	smb->usb.supplied_to = battery;
1178	smb->usb.num_supplicants = ARRAY_SIZE(battery);
1179	ret = power_supply_register(dev, &smb->usb);
1180	if (ret < 0) {
1181	if (smb->pdata->use_mains)
1182	power_supply_unregister(&smb->mains);
1183	return ret;
1184	}
1185	}
1186
1187	smb->battery.name = "smb347-battery";
1188	smb->battery.type = POWER_SUPPLY_TYPE_BATTERY;
1189	smb->battery.get_property = smb347_battery_get_property;
1190	smb->battery.properties = smb347_battery_properties;
1191	smb->battery.num_properties = ARRAY_SIZE(smb347_battery_properties);
1192
1193
1194	ret = power_supply_register(dev, &smb->battery);
1195	if (ret < 0) {
1196	if (smb->pdata->use_usb)
1197	power_supply_unregister(&smb->usb);
1198	if (smb->pdata->use_mains)
1199	power_supply_unregister(&smb->mains);
1200	return ret;
1201	}
1202
1203	/*
1204	* Interrupt pin is optional. If it is connected, we setup the
1205	* interrupt support here.
1206	*/
1207	if (pdata->irq_gpio >= 0) {
1208	ret = smb347_irq_init(smb, client);
1209	if (ret < 0) {
1210	dev_warn(dev, "failed to initialize IRQ: %d\n", ret);
1211	dev_warn(dev, "disabling IRQ support\n");
1212	} else {
1213	smb347_irq_enable(smb);
1214	}
1215	}
1216
1217	return 0;
1218	}
1219
1220	static int smb347_remove(struct i2c_client *client)
1221	{
1222	struct smb347_charger *smb = i2c_get_clientdata(client);
1223
1224	if (client->irq) {
1225	smb347_irq_disable(smb);
1226	free_irq(client->irq, smb);
1227	gpio_free(smb->pdata->irq_gpio);
1228	}
1229
1230	power_supply_unregister(&smb->battery);
1231	if (smb->pdata->use_usb)
1232	power_supply_unregister(&smb->usb);
1233	if (smb->pdata->use_mains)
1234	power_supply_unregister(&smb->mains);
1235	return 0;
1236	}
1237
1238	static const struct i2c_device_id smb347_id[] = {
1239	{ "smb347", 0 },
1240	{ }
1241	};
1242	MODULE_DEVICE_TABLE(i2c, smb347_id);
1243
1244	static struct i2c_driver smb347_driver = {
1245	.driver = {
1246	.name = "smb347",
1247	},
1248	.probe = smb347_probe,
1249	.remove = __devexit_p(smb347_remove),
1250	.id_table = smb347_id,
1251	};
1252
1253	module_i2c_driver(smb347_driver);
1254
1255	MODULE_AUTHOR("Bruce E. Robertson <bruce.e.robertson@intel.com>");
1256	MODULE_AUTHOR("Mika Westerberg <mika.westerberg@linux.intel.com>");
1257	MODULE_DESCRIPTION("SMB347 battery charger driver");
1258	MODULE_LICENSE("GPL");
1259	MODULE_ALIAS("i2c:smb347");
1260

Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9

Kernel

Kernel Git Source Tree

Root/drivers/power/smb347-charger.c

interactive