1  // SPDX-License-Identifier: GPL-2.0-or-later
2  /*
3   * tps65010 - driver for tps6501x power management chips
4   *
5   * Copyright (C) 2004 Texas Instruments
6   * Copyright (C) 2004-2005 David Brownell
7   */
8  
9  #include <linux/kernel.h>
10  #include <linux/module.h>
11  #include <linux/init.h>
12  #include <linux/slab.h>
13  #include <linux/interrupt.h>
14  #include <linux/i2c.h>
15  #include <linux/delay.h>
16  #include <linux/workqueue.h>
17  #include <linux/debugfs.h>
18  #include <linux/seq_file.h>
19  #include <linux/mutex.h>
20  #include <linux/platform_device.h>
21  
22  #include <linux/mfd/tps65010.h>
23  
24  #include <linux/gpio/driver.h>
25  
26  
27  /*-------------------------------------------------------------------------*/
28  
29  #define	DRIVER_VERSION	"2 May 2005"
30  #define	DRIVER_NAME	(tps65010_driver.driver.name)
31  
32  MODULE_DESCRIPTION("TPS6501x Power Management Driver");
33  MODULE_LICENSE("GPL");
34  
35  static struct i2c_driver tps65010_driver;
36  
37  /*-------------------------------------------------------------------------*/
38  
39  /* This driver handles a family of multipurpose chips, which incorporate
40   * voltage regulators, lithium ion/polymer battery charging, GPIOs, LEDs,
41   * and other features often needed in portable devices like cell phones
42   * or digital cameras.
43   *
44   * The tps65011 and tps65013 have different voltage settings compared
45   * to tps65010 and tps65012.  The tps65013 has a NO_CHG status/irq.
46   * All except tps65010 have "wait" mode, possibly defaulted so that
47   * battery-insert != device-on.
48   *
49   * We could distinguish between some models by checking VDCDC1.UVLO or
50   * other registers, unless they've been changed already after powerup
51   * as part of board setup by a bootloader.
52   */
53  enum tps_model {
54  	TPS65010,
55  	TPS65011,
56  	TPS65012,
57  	TPS65013,
58  };
59  
60  struct tps65010 {
61  	struct i2c_client	*client;
62  	struct mutex		lock;
63  	struct delayed_work	work;
64  	struct dentry		*file;
65  	unsigned		charging:1;
66  	unsigned		por:1;
67  	unsigned		model:8;
68  	u16			vbus;
69  	unsigned long		flags;
70  #define	FLAG_VBUS_CHANGED	0
71  #define	FLAG_IRQ_ENABLE		1
72  
73  	/* copies of last register state */
74  	u8			chgstatus, regstatus, chgconf;
75  	u8			nmask1, nmask2;
76  
77  	u8			outmask;
78  	struct gpio_chip	chip;
79  	struct platform_device	*leds;
80  };
81  
82  #define	POWER_POLL_DELAY	msecs_to_jiffies(5000)
83  
84  /*-------------------------------------------------------------------------*/
85  
86  #if	defined(DEBUG) || defined(CONFIG_DEBUG_FS)
87  
dbg_chgstat(char * buf,size_t len,u8 chgstatus)88  static void dbg_chgstat(char *buf, size_t len, u8 chgstatus)
89  {
90  	snprintf(buf, len, "%02x%s%s%s%s%s%s%s%s\n",
91  		chgstatus,
92  		(chgstatus & TPS_CHG_USB) ? " USB" : "",
93  		(chgstatus & TPS_CHG_AC) ? " AC" : "",
94  		(chgstatus & TPS_CHG_THERM) ? " therm" : "",
95  		(chgstatus & TPS_CHG_TERM) ? " done" :
96  			((chgstatus & (TPS_CHG_USB|TPS_CHG_AC))
97  				? " (charging)" : ""),
98  		(chgstatus & TPS_CHG_TAPER_TMO) ? " taper_tmo" : "",
99  		(chgstatus & TPS_CHG_CHG_TMO) ? " charge_tmo" : "",
100  		(chgstatus & TPS_CHG_PRECHG_TMO) ? " prechg_tmo" : "",
101  		(chgstatus & TPS_CHG_TEMP_ERR) ? " temp_err" : "");
102  }
103  
dbg_regstat(char * buf,size_t len,u8 regstatus)104  static void dbg_regstat(char *buf, size_t len, u8 regstatus)
105  {
106  	snprintf(buf, len, "%02x %s%s%s%s%s%s%s%s\n",
107  		regstatus,
108  		(regstatus & TPS_REG_ONOFF) ? "off" : "(on)",
109  		(regstatus & TPS_REG_COVER) ? " uncover" : "",
110  		(regstatus & TPS_REG_UVLO) ? " UVLO" : "",
111  		(regstatus & TPS_REG_NO_CHG) ? " NO_CHG" : "",
112  		(regstatus & TPS_REG_PG_LD02) ? " ld02_bad" : "",
113  		(regstatus & TPS_REG_PG_LD01) ? " ld01_bad" : "",
114  		(regstatus & TPS_REG_PG_MAIN) ? " main_bad" : "",
115  		(regstatus & TPS_REG_PG_CORE) ? " core_bad" : "");
116  }
117  
dbg_chgconf(int por,char * buf,size_t len,u8 chgconfig)118  static void dbg_chgconf(int por, char *buf, size_t len, u8 chgconfig)
119  {
120  	const char *hibit;
121  
122  	if (por)
123  		hibit = (chgconfig & TPS_CHARGE_POR)
124  				? "POR=69ms" : "POR=1sec";
125  	else
126  		hibit = (chgconfig & TPS65013_AUA) ? "AUA" : "";
127  
128  	snprintf(buf, len, "%02x %s%s%s AC=%d%% USB=%dmA %sCharge\n",
129  		chgconfig, hibit,
130  		(chgconfig & TPS_CHARGE_RESET) ? " reset" : "",
131  		(chgconfig & TPS_CHARGE_FAST) ? " fast" : "",
132  		({int p; switch ((chgconfig >> 3) & 3) {
133  		case 3:		p = 100; break;
134  		case 2:		p = 75; break;
135  		case 1:		p = 50; break;
136  		default:	p = 25; break;
137  		}; p; }),
138  		(chgconfig & TPS_VBUS_CHARGING)
139  			? ((chgconfig & TPS_VBUS_500MA) ? 500 : 100)
140  			: 0,
141  		(chgconfig & TPS_CHARGE_ENABLE) ? "" : "No");
142  }
143  
144  #endif
145  
146  #ifdef	DEBUG
147  
show_chgstatus(const char * label,u8 chgstatus)148  static void show_chgstatus(const char *label, u8 chgstatus)
149  {
150  	char buf [100];
151  
152  	dbg_chgstat(buf, sizeof buf, chgstatus);
153  	pr_debug("%s: %s %s", DRIVER_NAME, label, buf);
154  }
155  
show_regstatus(const char * label,u8 regstatus)156  static void show_regstatus(const char *label, u8 regstatus)
157  {
158  	char buf [100];
159  
160  	dbg_regstat(buf, sizeof buf, regstatus);
161  	pr_debug("%s: %s %s", DRIVER_NAME, label, buf);
162  }
163  
show_chgconfig(int por,const char * label,u8 chgconfig)164  static void show_chgconfig(int por, const char *label, u8 chgconfig)
165  {
166  	char buf [100];
167  
168  	dbg_chgconf(por, buf, sizeof buf, chgconfig);
169  	pr_debug("%s: %s %s", DRIVER_NAME, label, buf);
170  }
171  
172  #else
173  
show_chgstatus(const char * label,u8 chgstatus)174  static inline void show_chgstatus(const char *label, u8 chgstatus) { }
show_regstatus(const char * label,u8 chgstatus)175  static inline void show_regstatus(const char *label, u8 chgstatus) { }
show_chgconfig(int por,const char * label,u8 chgconfig)176  static inline void show_chgconfig(int por, const char *label, u8 chgconfig) { }
177  
178  #endif
179  
180  #ifdef	CONFIG_DEBUG_FS
181  
dbg_show(struct seq_file * s,void * _)182  static int dbg_show(struct seq_file *s, void *_)
183  {
184  	struct tps65010	*tps = s->private;
185  	u8		value, v2;
186  	unsigned	i;
187  	char		buf[100];
188  	const char	*chip;
189  
190  	switch (tps->model) {
191  	case TPS65010:	chip = "tps65010"; break;
192  	case TPS65011:	chip = "tps65011"; break;
193  	case TPS65012:	chip = "tps65012"; break;
194  	case TPS65013:	chip = "tps65013"; break;
195  	default:	chip = NULL; break;
196  	}
197  	seq_printf(s, "driver  %s\nversion %s\nchip    %s\n\n",
198  			DRIVER_NAME, DRIVER_VERSION, chip);
199  
200  	mutex_lock(&tps->lock);
201  
202  	/* FIXME how can we tell whether a battery is present?
203  	 * likely involves a charge gauging chip (like BQ26501).
204  	 */
205  
206  	seq_printf(s, "%scharging\n\n", tps->charging ? "" : "(not) ");
207  
208  
209  	/* registers for monitoring battery charging and status; note
210  	 * that reading chgstat and regstat may ack IRQs...
211  	 */
212  	value = i2c_smbus_read_byte_data(tps->client, TPS_CHGCONFIG);
213  	dbg_chgconf(tps->por, buf, sizeof buf, value);
214  	seq_printf(s, "chgconfig %s", buf);
215  
216  	value = i2c_smbus_read_byte_data(tps->client, TPS_CHGSTATUS);
217  	dbg_chgstat(buf, sizeof buf, value);
218  	seq_printf(s, "chgstat   %s", buf);
219  	value = i2c_smbus_read_byte_data(tps->client, TPS_MASK1);
220  	dbg_chgstat(buf, sizeof buf, value);
221  	seq_printf(s, "mask1     %s", buf);
222  	/* ignore ackint1 */
223  
224  	value = i2c_smbus_read_byte_data(tps->client, TPS_REGSTATUS);
225  	dbg_regstat(buf, sizeof buf, value);
226  	seq_printf(s, "regstat   %s", buf);
227  	value = i2c_smbus_read_byte_data(tps->client, TPS_MASK2);
228  	dbg_regstat(buf, sizeof buf, value);
229  	seq_printf(s, "mask2     %s\n", buf);
230  	/* ignore ackint2 */
231  
232  	queue_delayed_work(system_power_efficient_wq, &tps->work,
233  			   POWER_POLL_DELAY);
234  
235  	/* VMAIN voltage, enable lowpower, etc */
236  	value = i2c_smbus_read_byte_data(tps->client, TPS_VDCDC1);
237  	seq_printf(s, "vdcdc1    %02x\n", value);
238  
239  	/* VCORE voltage, vibrator on/off */
240  	value = i2c_smbus_read_byte_data(tps->client, TPS_VDCDC2);
241  	seq_printf(s, "vdcdc2    %02x\n", value);
242  
243  	/* both LD0s, and their lowpower behavior */
244  	value = i2c_smbus_read_byte_data(tps->client, TPS_VREGS1);
245  	seq_printf(s, "vregs1    %02x\n\n", value);
246  
247  
248  	/* LEDs and GPIOs */
249  	value = i2c_smbus_read_byte_data(tps->client, TPS_LED1_ON);
250  	v2 = i2c_smbus_read_byte_data(tps->client, TPS_LED1_PER);
251  	seq_printf(s, "led1 %s, on=%02x, per=%02x, %d/%d msec\n",
252  		(value & 0x80)
253  			? ((v2 & 0x80) ? "on" : "off")
254  			: ((v2 & 0x80) ? "blink" : "(nPG)"),
255  		value, v2,
256  		(value & 0x7f) * 10, (v2 & 0x7f) * 100);
257  
258  	value = i2c_smbus_read_byte_data(tps->client, TPS_LED2_ON);
259  	v2 = i2c_smbus_read_byte_data(tps->client, TPS_LED2_PER);
260  	seq_printf(s, "led2 %s, on=%02x, per=%02x, %d/%d msec\n",
261  		(value & 0x80)
262  			? ((v2 & 0x80) ? "on" : "off")
263  			: ((v2 & 0x80) ? "blink" : "off"),
264  		value, v2,
265  		(value & 0x7f) * 10, (v2 & 0x7f) * 100);
266  
267  	value = i2c_smbus_read_byte_data(tps->client, TPS_DEFGPIO);
268  	v2 = i2c_smbus_read_byte_data(tps->client, TPS_MASK3);
269  	seq_printf(s, "defgpio %02x mask3 %02x\n", value, v2);
270  
271  	for (i = 0; i < 4; i++) {
272  		if (value & (1 << (4 + i)))
273  			seq_printf(s, "  gpio%d-out %s\n", i + 1,
274  				(value & (1 << i)) ? "low" : "hi ");
275  		else
276  			seq_printf(s, "  gpio%d-in  %s %s %s\n", i + 1,
277  				(value & (1 << i)) ? "hi " : "low",
278  				(v2 & (1 << i)) ? "no-irq" : "irq",
279  				(v2 & (1 << (4 + i))) ? "rising" : "falling");
280  	}
281  
282  	mutex_unlock(&tps->lock);
283  	return 0;
284  }
285  
dbg_tps_open(struct inode * inode,struct file * file)286  static int dbg_tps_open(struct inode *inode, struct file *file)
287  {
288  	return single_open(file, dbg_show, inode->i_private);
289  }
290  
291  static const struct file_operations debug_fops = {
292  	.open		= dbg_tps_open,
293  	.read		= seq_read,
294  	.llseek		= seq_lseek,
295  	.release	= single_release,
296  };
297  
298  #define	DEBUG_FOPS	&debug_fops
299  
300  #else
301  #define	DEBUG_FOPS	NULL
302  #endif
303  
304  /*-------------------------------------------------------------------------*/
305  
306  /* handle IRQS in a task context, so we can use I2C calls */
tps65010_interrupt(struct tps65010 * tps)307  static void tps65010_interrupt(struct tps65010 *tps)
308  {
309  	u8 tmp = 0, mask, poll;
310  
311  	/* IRQs won't trigger for certain events, but we can get
312  	 * others by polling (normally, with external power applied).
313  	 */
314  	poll = 0;
315  
316  	/* regstatus irqs */
317  	if (tps->nmask2) {
318  		tmp = i2c_smbus_read_byte_data(tps->client, TPS_REGSTATUS);
319  		mask = tmp ^ tps->regstatus;
320  		tps->regstatus = tmp;
321  		mask &= tps->nmask2;
322  	} else
323  		mask = 0;
324  	if (mask) {
325  		tps->regstatus =  tmp;
326  		/* may need to shut something down ... */
327  
328  		/* "off" usually means deep sleep */
329  		if (tmp & TPS_REG_ONOFF) {
330  			pr_info("%s: power off button\n", DRIVER_NAME);
331  #if 0
332  			/* REVISIT:  this might need its own workqueue
333  			 * plus tweaks including deadlock avoidance ...
334  			 * also needs to get error handling and probably
335  			 * an #ifdef CONFIG_HIBERNATION
336  			 */
337  			hibernate();
338  #endif
339  			poll = 1;
340  		}
341  	}
342  
343  	/* chgstatus irqs */
344  	if (tps->nmask1) {
345  		tmp = i2c_smbus_read_byte_data(tps->client, TPS_CHGSTATUS);
346  		mask = tmp ^ tps->chgstatus;
347  		tps->chgstatus = tmp;
348  		mask &= tps->nmask1;
349  	} else
350  		mask = 0;
351  	if (mask) {
352  		unsigned	charging = 0;
353  
354  		show_chgstatus("chg/irq", tmp);
355  		if (tmp & (TPS_CHG_USB|TPS_CHG_AC))
356  			show_chgconfig(tps->por, "conf", tps->chgconf);
357  
358  		/* Unless it was turned off or disabled, we charge any
359  		 * battery whenever there's power available for it
360  		 * and the charger hasn't been disabled.
361  		 */
362  		if (!(tps->chgstatus & ~(TPS_CHG_USB|TPS_CHG_AC))
363  				&& (tps->chgstatus & (TPS_CHG_USB|TPS_CHG_AC))
364  				&& (tps->chgconf & TPS_CHARGE_ENABLE)
365  				) {
366  			if (tps->chgstatus & TPS_CHG_USB) {
367  				/* VBUS options are readonly until reconnect */
368  				if (mask & TPS_CHG_USB)
369  					set_bit(FLAG_VBUS_CHANGED, &tps->flags);
370  				charging = 1;
371  			} else if (tps->chgstatus & TPS_CHG_AC)
372  				charging = 1;
373  		}
374  		if (charging != tps->charging) {
375  			tps->charging = charging;
376  			pr_info("%s: battery %scharging\n",
377  				DRIVER_NAME, charging ? "" :
378  				((tps->chgstatus & (TPS_CHG_USB|TPS_CHG_AC))
379  					? "NOT " : "dis"));
380  		}
381  	}
382  
383  	/* always poll to detect (a) power removal, without tps65013
384  	 * NO_CHG IRQ; or (b) restart of charging after stop.
385  	 */
386  	if ((tps->model != TPS65013 || !tps->charging)
387  			&& (tps->chgstatus & (TPS_CHG_USB|TPS_CHG_AC)))
388  		poll = 1;
389  	if (poll)
390  		queue_delayed_work(system_power_efficient_wq, &tps->work,
391  				   POWER_POLL_DELAY);
392  
393  	/* also potentially gpio-in rise or fall */
394  }
395  
396  /* handle IRQs and polling using keventd for now */
tps65010_work(struct work_struct * work)397  static void tps65010_work(struct work_struct *work)
398  {
399  	struct tps65010		*tps;
400  
401  	tps = container_of(to_delayed_work(work), struct tps65010, work);
402  	mutex_lock(&tps->lock);
403  
404  	tps65010_interrupt(tps);
405  
406  	if (test_and_clear_bit(FLAG_VBUS_CHANGED, &tps->flags)) {
407  		u8	chgconfig, tmp;
408  
409  		chgconfig = i2c_smbus_read_byte_data(tps->client,
410  					TPS_CHGCONFIG);
411  		chgconfig &= ~(TPS_VBUS_500MA | TPS_VBUS_CHARGING);
412  		if (tps->vbus == 500)
413  			chgconfig |= TPS_VBUS_500MA | TPS_VBUS_CHARGING;
414  		else if (tps->vbus >= 100)
415  			chgconfig |= TPS_VBUS_CHARGING;
416  
417  		i2c_smbus_write_byte_data(tps->client,
418  					  TPS_CHGCONFIG, chgconfig);
419  
420  		/* vbus update fails unless VBUS is connected! */
421  		tmp = i2c_smbus_read_byte_data(tps->client, TPS_CHGCONFIG);
422  		tps->chgconf = tmp;
423  		show_chgconfig(tps->por, "update vbus", tmp);
424  	}
425  
426  	if (test_and_clear_bit(FLAG_IRQ_ENABLE, &tps->flags))
427  		enable_irq(tps->client->irq);
428  
429  	mutex_unlock(&tps->lock);
430  }
431  
tps65010_irq(int irq,void * _tps)432  static irqreturn_t tps65010_irq(int irq, void *_tps)
433  {
434  	struct tps65010		*tps = _tps;
435  
436  	disable_irq_nosync(irq);
437  	set_bit(FLAG_IRQ_ENABLE, &tps->flags);
438  	queue_delayed_work(system_power_efficient_wq, &tps->work, 0);
439  	return IRQ_HANDLED;
440  }
441  
442  /*-------------------------------------------------------------------------*/
443  
444  /* offsets 0..3 == GPIO1..GPIO4
445   * offsets 4..5 == LED1/nPG, LED2 (we set one of the non-BLINK modes)
446   * offset 6 == vibrator motor driver
447   */
448  static void
tps65010_gpio_set(struct gpio_chip * chip,unsigned offset,int value)449  tps65010_gpio_set(struct gpio_chip *chip, unsigned offset, int value)
450  {
451  	if (offset < 4)
452  		tps65010_set_gpio_out_value(offset + 1, value);
453  	else if (offset < 6)
454  		tps65010_set_led(offset - 3, value ? ON : OFF);
455  	else
456  		tps65010_set_vib(value);
457  }
458  
459  static int
tps65010_output(struct gpio_chip * chip,unsigned offset,int value)460  tps65010_output(struct gpio_chip *chip, unsigned offset, int value)
461  {
462  	/* GPIOs may be input-only */
463  	if (offset < 4) {
464  		struct tps65010		*tps;
465  
466  		tps = gpiochip_get_data(chip);
467  		if (!(tps->outmask & (1 << offset)))
468  			return -EINVAL;
469  		tps65010_set_gpio_out_value(offset + 1, value);
470  	} else if (offset < 6)
471  		tps65010_set_led(offset - 3, value ? ON : OFF);
472  	else
473  		tps65010_set_vib(value);
474  
475  	return 0;
476  }
477  
tps65010_gpio_get(struct gpio_chip * chip,unsigned offset)478  static int tps65010_gpio_get(struct gpio_chip *chip, unsigned offset)
479  {
480  	int			value;
481  	struct tps65010		*tps;
482  
483  	tps = gpiochip_get_data(chip);
484  
485  	if (offset < 4) {
486  		value = i2c_smbus_read_byte_data(tps->client, TPS_DEFGPIO);
487  		if (value < 0)
488  			return value;
489  		if (value & (1 << (offset + 4)))	/* output */
490  			return !(value & (1 << offset));
491  		else					/* input */
492  			return !!(value & (1 << offset));
493  	}
494  
495  	/* REVISIT we *could* report LED1/nPG and LED2 state ... */
496  	return 0;
497  }
498  
499  
500  /*-------------------------------------------------------------------------*/
501  
502  static struct tps65010 *the_tps;
503  
tps65010_remove(struct i2c_client * client)504  static void tps65010_remove(struct i2c_client *client)
505  {
506  	struct tps65010		*tps = i2c_get_clientdata(client);
507  	struct tps65010_board	*board = dev_get_platdata(&client->dev);
508  
509  	if (board && board->teardown)
510  		board->teardown(client, &tps->chip);
511  	if (client->irq > 0)
512  		free_irq(client->irq, tps);
513  	cancel_delayed_work_sync(&tps->work);
514  	debugfs_remove(tps->file);
515  	the_tps = NULL;
516  }
517  
tps65010_probe(struct i2c_client * client)518  static int tps65010_probe(struct i2c_client *client)
519  {
520  	const struct i2c_device_id *id = i2c_client_get_device_id(client);
521  	struct tps65010		*tps;
522  	int			status;
523  	struct tps65010_board	*board = dev_get_platdata(&client->dev);
524  
525  	if (the_tps) {
526  		dev_dbg(&client->dev, "only one tps6501x chip allowed\n");
527  		return -ENODEV;
528  	}
529  
530  	if (!i2c_check_functionality(client->adapter, I2C_FUNC_SMBUS_BYTE_DATA))
531  		return -EINVAL;
532  
533  	tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
534  	if (!tps)
535  		return -ENOMEM;
536  
537  	mutex_init(&tps->lock);
538  	INIT_DELAYED_WORK(&tps->work, tps65010_work);
539  	tps->client = client;
540  	tps->model = id->driver_data;
541  
542  	/* the IRQ is active low, but many gpio lines can't support that
543  	 * so this driver uses falling-edge triggers instead.
544  	 */
545  	if (client->irq > 0) {
546  		status = request_irq(client->irq, tps65010_irq,
547  				     IRQF_TRIGGER_FALLING, DRIVER_NAME, tps);
548  		if (status < 0) {
549  			dev_dbg(&client->dev, "can't get IRQ %d, err %d\n",
550  					client->irq, status);
551  			return status;
552  		}
553  		/* annoying race here, ideally we'd have an option
554  		 * to claim the irq now and enable it later.
555  		 * FIXME genirq IRQF_NOAUTOEN now solves that ...
556  		 */
557  		disable_irq(client->irq);
558  		set_bit(FLAG_IRQ_ENABLE, &tps->flags);
559  	} else
560  		dev_warn(&client->dev, "IRQ not configured!\n");
561  
562  
563  	switch (tps->model) {
564  	case TPS65010:
565  	case TPS65012:
566  		tps->por = 1;
567  		break;
568  	/* else CHGCONFIG.POR is replaced by AUA, enabling a WAIT mode */
569  	}
570  	tps->chgconf = i2c_smbus_read_byte_data(client, TPS_CHGCONFIG);
571  	show_chgconfig(tps->por, "conf/init", tps->chgconf);
572  
573  	show_chgstatus("chg/init",
574  		i2c_smbus_read_byte_data(client, TPS_CHGSTATUS));
575  	show_regstatus("reg/init",
576  		i2c_smbus_read_byte_data(client, TPS_REGSTATUS));
577  
578  	pr_debug("%s: vdcdc1 0x%02x, vdcdc2 %02x, vregs1 %02x\n", DRIVER_NAME,
579  		i2c_smbus_read_byte_data(client, TPS_VDCDC1),
580  		i2c_smbus_read_byte_data(client, TPS_VDCDC2),
581  		i2c_smbus_read_byte_data(client, TPS_VREGS1));
582  	pr_debug("%s: defgpio 0x%02x, mask3 0x%02x\n", DRIVER_NAME,
583  		i2c_smbus_read_byte_data(client, TPS_DEFGPIO),
584  		i2c_smbus_read_byte_data(client, TPS_MASK3));
585  
586  	i2c_set_clientdata(client, tps);
587  	the_tps = tps;
588  
589  #if	defined(CONFIG_USB_GADGET) && !defined(CONFIG_USB_OTG)
590  	/* USB hosts can't draw VBUS.  OTG devices could, later
591  	 * when OTG infrastructure enables it.  USB peripherals
592  	 * could be relying on VBUS while booting, though.
593  	 */
594  	tps->vbus = 100;
595  #endif
596  
597  	/* unmask the "interesting" irqs, then poll once to
598  	 * kickstart monitoring, initialize shadowed status
599  	 * registers, and maybe disable VBUS draw.
600  	 */
601  	tps->nmask1 = ~0;
602  	(void) i2c_smbus_write_byte_data(client, TPS_MASK1, ~tps->nmask1);
603  
604  	tps->nmask2 = TPS_REG_ONOFF;
605  	if (tps->model == TPS65013)
606  		tps->nmask2 |= TPS_REG_NO_CHG;
607  	(void) i2c_smbus_write_byte_data(client, TPS_MASK2, ~tps->nmask2);
608  
609  	(void) i2c_smbus_write_byte_data(client, TPS_MASK3, 0x0f
610  		| i2c_smbus_read_byte_data(client, TPS_MASK3));
611  
612  	tps65010_work(&tps->work.work);
613  
614  	tps->file = debugfs_create_file(DRIVER_NAME, S_IRUGO, NULL,
615  				tps, DEBUG_FOPS);
616  
617  	/* optionally register GPIOs */
618  	if (board) {
619  		tps->outmask = board->outmask;
620  
621  		tps->chip.label = client->name;
622  		tps->chip.parent = &client->dev;
623  		tps->chip.owner = THIS_MODULE;
624  
625  		tps->chip.set = tps65010_gpio_set;
626  		tps->chip.direction_output = tps65010_output;
627  
628  		/* NOTE:  only partial support for inputs; nyet IRQs */
629  		tps->chip.get = tps65010_gpio_get;
630  
631  		tps->chip.base = -1;
632  		tps->chip.ngpio = 7;
633  		tps->chip.can_sleep = 1;
634  
635  		status = gpiochip_add_data(&tps->chip, tps);
636  		if (status < 0)
637  			dev_err(&client->dev, "can't add gpiochip, err %d\n",
638  					status);
639  		else if (board->setup) {
640  			status = board->setup(client, &tps->chip);
641  			if (status < 0) {
642  				dev_dbg(&client->dev,
643  					"board %s %s err %d\n",
644  					"setup", client->name, status);
645  				status = 0;
646  			}
647  		}
648  	}
649  
650  	return 0;
651  }
652  
653  static const struct i2c_device_id tps65010_id[] = {
654  	{ "tps65010", TPS65010 },
655  	{ "tps65011", TPS65011 },
656  	{ "tps65012", TPS65012 },
657  	{ "tps65013", TPS65013 },
658  	{ "tps65014", TPS65011 },	/* tps65011 charging at 6.5V max */
659  	{ }
660  };
661  MODULE_DEVICE_TABLE(i2c, tps65010_id);
662  
663  static struct i2c_driver tps65010_driver = {
664  	.driver = {
665  		.name	= "tps65010",
666  	},
667  	.probe = tps65010_probe,
668  	.remove	= tps65010_remove,
669  	.id_table = tps65010_id,
670  };
671  
672  /*-------------------------------------------------------------------------*/
673  
674  /* Draw from VBUS:
675   *   0 mA -- DON'T DRAW (might supply power instead)
676   * 100 mA -- usb unit load (slowest charge rate)
677   * 500 mA -- usb high power (fast battery charge)
678   */
tps65010_set_vbus_draw(unsigned mA)679  int tps65010_set_vbus_draw(unsigned mA)
680  {
681  	unsigned long	flags;
682  
683  	if (!the_tps)
684  		return -ENODEV;
685  
686  	/* assumes non-SMP */
687  	local_irq_save(flags);
688  	if (mA >= 500)
689  		mA = 500;
690  	else if (mA >= 100)
691  		mA = 100;
692  	else
693  		mA = 0;
694  	the_tps->vbus = mA;
695  	if ((the_tps->chgstatus & TPS_CHG_USB)
696  			&& test_and_set_bit(
697  				FLAG_VBUS_CHANGED, &the_tps->flags)) {
698  		/* gadget drivers call this in_irq() */
699  		queue_delayed_work(system_power_efficient_wq, &the_tps->work,
700  				   0);
701  	}
702  	local_irq_restore(flags);
703  
704  	return 0;
705  }
706  EXPORT_SYMBOL(tps65010_set_vbus_draw);
707  
708  /*-------------------------------------------------------------------------*/
709  /* tps65010_set_gpio_out_value parameter:
710   * gpio:  GPIO1, GPIO2, GPIO3 or GPIO4
711   * value: LOW or HIGH
712   */
tps65010_set_gpio_out_value(unsigned gpio,unsigned value)713  int tps65010_set_gpio_out_value(unsigned gpio, unsigned value)
714  {
715  	int	 status;
716  	unsigned defgpio;
717  
718  	if (!the_tps)
719  		return -ENODEV;
720  	if ((gpio < GPIO1) || (gpio > GPIO4))
721  		return -EINVAL;
722  
723  	mutex_lock(&the_tps->lock);
724  
725  	defgpio = i2c_smbus_read_byte_data(the_tps->client, TPS_DEFGPIO);
726  
727  	/* Configure GPIO for output */
728  	defgpio |= 1 << (gpio + 3);
729  
730  	/* Writing 1 forces a logic 0 on that GPIO and vice versa */
731  	switch (value) {
732  	case LOW:
733  		defgpio |= 1 << (gpio - 1);    /* set GPIO low by writing 1 */
734  		break;
735  	/* case HIGH: */
736  	default:
737  		defgpio &= ~(1 << (gpio - 1)); /* set GPIO high by writing 0 */
738  		break;
739  	}
740  
741  	status = i2c_smbus_write_byte_data(the_tps->client,
742  		TPS_DEFGPIO, defgpio);
743  
744  	pr_debug("%s: gpio%dout = %s, defgpio 0x%02x\n", DRIVER_NAME,
745  		gpio, value ? "high" : "low",
746  		i2c_smbus_read_byte_data(the_tps->client, TPS_DEFGPIO));
747  
748  	mutex_unlock(&the_tps->lock);
749  	return status;
750  }
751  EXPORT_SYMBOL(tps65010_set_gpio_out_value);
752  
753  /*-------------------------------------------------------------------------*/
754  /* tps65010_set_led parameter:
755   * led:  LED1 or LED2
756   * mode: ON, OFF or BLINK
757   */
tps65010_set_led(unsigned led,unsigned mode)758  int tps65010_set_led(unsigned led, unsigned mode)
759  {
760  	int	 status;
761  	unsigned led_on, led_per, offs;
762  
763  	if (!the_tps)
764  		return -ENODEV;
765  
766  	if (led == LED1)
767  		offs = 0;
768  	else {
769  		offs = 2;
770  		led = LED2;
771  	}
772  
773  	mutex_lock(&the_tps->lock);
774  
775  	pr_debug("%s: led%i_on   0x%02x\n", DRIVER_NAME, led,
776  		i2c_smbus_read_byte_data(the_tps->client,
777  				TPS_LED1_ON + offs));
778  
779  	pr_debug("%s: led%i_per  0x%02x\n", DRIVER_NAME, led,
780  		i2c_smbus_read_byte_data(the_tps->client,
781  				TPS_LED1_PER + offs));
782  
783  	switch (mode) {
784  	case OFF:
785  		led_on  = 1 << 7;
786  		led_per = 0 << 7;
787  		break;
788  	case ON:
789  		led_on  = 1 << 7;
790  		led_per = 1 << 7;
791  		break;
792  	case BLINK:
793  		led_on  = 0x30 | (0 << 7);
794  		led_per = 0x08 | (1 << 7);
795  		break;
796  	default:
797  		printk(KERN_ERR "%s: Wrong mode parameter for set_led()\n",
798  		       DRIVER_NAME);
799  		mutex_unlock(&the_tps->lock);
800  		return -EINVAL;
801  	}
802  
803  	status = i2c_smbus_write_byte_data(the_tps->client,
804  			TPS_LED1_ON + offs, led_on);
805  
806  	if (status != 0) {
807  		printk(KERN_ERR "%s: Failed to write led%i_on register\n",
808  		       DRIVER_NAME, led);
809  		mutex_unlock(&the_tps->lock);
810  		return status;
811  	}
812  
813  	pr_debug("%s: led%i_on   0x%02x\n", DRIVER_NAME, led,
814  		i2c_smbus_read_byte_data(the_tps->client, TPS_LED1_ON + offs));
815  
816  	status = i2c_smbus_write_byte_data(the_tps->client,
817  			TPS_LED1_PER + offs, led_per);
818  
819  	if (status != 0) {
820  		printk(KERN_ERR "%s: Failed to write led%i_per register\n",
821  		       DRIVER_NAME, led);
822  		mutex_unlock(&the_tps->lock);
823  		return status;
824  	}
825  
826  	pr_debug("%s: led%i_per  0x%02x\n", DRIVER_NAME, led,
827  		i2c_smbus_read_byte_data(the_tps->client,
828  				TPS_LED1_PER + offs));
829  
830  	mutex_unlock(&the_tps->lock);
831  
832  	return status;
833  }
834  EXPORT_SYMBOL(tps65010_set_led);
835  
836  /*-------------------------------------------------------------------------*/
837  /* tps65010_set_vib parameter:
838   * value: ON or OFF
839   */
tps65010_set_vib(unsigned value)840  int tps65010_set_vib(unsigned value)
841  {
842  	int	 status;
843  	unsigned vdcdc2;
844  
845  	if (!the_tps)
846  		return -ENODEV;
847  
848  	mutex_lock(&the_tps->lock);
849  
850  	vdcdc2 = i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC2);
851  	vdcdc2 &= ~(1 << 1);
852  	if (value)
853  		vdcdc2 |= (1 << 1);
854  	status = i2c_smbus_write_byte_data(the_tps->client,
855  		TPS_VDCDC2, vdcdc2);
856  
857  	pr_debug("%s: vibrator %s\n", DRIVER_NAME, value ? "on" : "off");
858  
859  	mutex_unlock(&the_tps->lock);
860  	return status;
861  }
862  EXPORT_SYMBOL(tps65010_set_vib);
863  
864  /*-------------------------------------------------------------------------*/
865  /* tps65010_set_low_pwr parameter:
866   * mode: ON or OFF
867   */
tps65010_set_low_pwr(unsigned mode)868  int tps65010_set_low_pwr(unsigned mode)
869  {
870  	int	 status;
871  	unsigned vdcdc1;
872  
873  	if (!the_tps)
874  		return -ENODEV;
875  
876  	mutex_lock(&the_tps->lock);
877  
878  	pr_debug("%s: %s low_pwr, vdcdc1 0x%02x\n", DRIVER_NAME,
879  		mode ? "enable" : "disable",
880  		i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1));
881  
882  	vdcdc1 = i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1);
883  
884  	switch (mode) {
885  	case OFF:
886  		vdcdc1 &= ~TPS_ENABLE_LP; /* disable ENABLE_LP bit */
887  		break;
888  	/* case ON: */
889  	default:
890  		vdcdc1 |= TPS_ENABLE_LP;  /* enable ENABLE_LP bit */
891  		break;
892  	}
893  
894  	status = i2c_smbus_write_byte_data(the_tps->client,
895  			TPS_VDCDC1, vdcdc1);
896  
897  	if (status != 0)
898  		printk(KERN_ERR "%s: Failed to write vdcdc1 register\n",
899  			DRIVER_NAME);
900  	else
901  		pr_debug("%s: vdcdc1 0x%02x\n", DRIVER_NAME,
902  			i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1));
903  
904  	mutex_unlock(&the_tps->lock);
905  
906  	return status;
907  }
908  EXPORT_SYMBOL(tps65010_set_low_pwr);
909  
910  /*-------------------------------------------------------------------------*/
911  /* tps65010_config_vregs1 parameter:
912   * value to be written to VREGS1 register
913   * Note: The complete register is written, set all bits you need
914   */
tps65010_config_vregs1(unsigned value)915  int tps65010_config_vregs1(unsigned value)
916  {
917  	int	 status;
918  
919  	if (!the_tps)
920  		return -ENODEV;
921  
922  	mutex_lock(&the_tps->lock);
923  
924  	pr_debug("%s: vregs1 0x%02x\n", DRIVER_NAME,
925  			i2c_smbus_read_byte_data(the_tps->client, TPS_VREGS1));
926  
927  	status = i2c_smbus_write_byte_data(the_tps->client,
928  			TPS_VREGS1, value);
929  
930  	if (status != 0)
931  		printk(KERN_ERR "%s: Failed to write vregs1 register\n",
932  			DRIVER_NAME);
933  	else
934  		pr_debug("%s: vregs1 0x%02x\n", DRIVER_NAME,
935  			i2c_smbus_read_byte_data(the_tps->client, TPS_VREGS1));
936  
937  	mutex_unlock(&the_tps->lock);
938  
939  	return status;
940  }
941  EXPORT_SYMBOL(tps65010_config_vregs1);
942  
tps65010_config_vdcdc2(unsigned value)943  int tps65010_config_vdcdc2(unsigned value)
944  {
945  	struct i2c_client *c;
946  	int	 status;
947  
948  	if (!the_tps)
949  		return -ENODEV;
950  
951  	c = the_tps->client;
952  	mutex_lock(&the_tps->lock);
953  
954  	pr_debug("%s: vdcdc2 0x%02x\n", DRIVER_NAME,
955  		 i2c_smbus_read_byte_data(c, TPS_VDCDC2));
956  
957  	status = i2c_smbus_write_byte_data(c, TPS_VDCDC2, value);
958  
959  	if (status != 0)
960  		printk(KERN_ERR "%s: Failed to write vdcdc2 register\n",
961  			DRIVER_NAME);
962  	else
963  		pr_debug("%s: vregs1 0x%02x\n", DRIVER_NAME,
964  			 i2c_smbus_read_byte_data(c, TPS_VDCDC2));
965  
966  	mutex_unlock(&the_tps->lock);
967  	return status;
968  }
969  EXPORT_SYMBOL(tps65010_config_vdcdc2);
970  
971  /*-------------------------------------------------------------------------*/
972  /* tps65013_set_low_pwr parameter:
973   * mode: ON or OFF
974   */
975  
976  /* FIXME: Assumes AC or USB power is present. Setting AUA bit is not
977  	required if power supply is through a battery */
978  
tps65013_set_low_pwr(unsigned mode)979  int tps65013_set_low_pwr(unsigned mode)
980  {
981  	int	 status;
982  	unsigned vdcdc1, chgconfig;
983  
984  	if (!the_tps || the_tps->por)
985  		return -ENODEV;
986  
987  	mutex_lock(&the_tps->lock);
988  
989  	pr_debug("%s: %s low_pwr, chgconfig 0x%02x vdcdc1 0x%02x\n",
990  		DRIVER_NAME,
991  		mode ? "enable" : "disable",
992  		i2c_smbus_read_byte_data(the_tps->client, TPS_CHGCONFIG),
993  		i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1));
994  
995  	chgconfig = i2c_smbus_read_byte_data(the_tps->client, TPS_CHGCONFIG);
996  	vdcdc1 = i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1);
997  
998  	switch (mode) {
999  	case OFF:
1000  		chgconfig &= ~TPS65013_AUA; /* disable AUA bit */
1001  		vdcdc1 &= ~TPS_ENABLE_LP; /* disable ENABLE_LP bit */
1002  		break;
1003  	/* case ON: */
1004  	default:
1005  		chgconfig |= TPS65013_AUA;  /* enable AUA bit */
1006  		vdcdc1 |= TPS_ENABLE_LP;  /* enable ENABLE_LP bit */
1007  		break;
1008  	}
1009  
1010  	status = i2c_smbus_write_byte_data(the_tps->client,
1011  			TPS_CHGCONFIG, chgconfig);
1012  	if (status != 0) {
1013  		printk(KERN_ERR "%s: Failed to write chconfig register\n",
1014  	 DRIVER_NAME);
1015  		mutex_unlock(&the_tps->lock);
1016  		return status;
1017  	}
1018  
1019  	chgconfig = i2c_smbus_read_byte_data(the_tps->client, TPS_CHGCONFIG);
1020  	the_tps->chgconf = chgconfig;
1021  	show_chgconfig(0, "chgconf", chgconfig);
1022  
1023  	status = i2c_smbus_write_byte_data(the_tps->client,
1024  			TPS_VDCDC1, vdcdc1);
1025  
1026  	if (status != 0)
1027  		printk(KERN_ERR "%s: Failed to write vdcdc1 register\n",
1028  	 DRIVER_NAME);
1029  	else
1030  		pr_debug("%s: vdcdc1 0x%02x\n", DRIVER_NAME,
1031  			i2c_smbus_read_byte_data(the_tps->client, TPS_VDCDC1));
1032  
1033  	mutex_unlock(&the_tps->lock);
1034  
1035  	return status;
1036  }
1037  EXPORT_SYMBOL(tps65013_set_low_pwr);
1038  
1039  /*-------------------------------------------------------------------------*/
1040  
tps_init(void)1041  static int __init tps_init(void)
1042  {
1043  	return i2c_add_driver(&tps65010_driver);
1044  }
1045  /* NOTE:  this MUST be initialized before the other parts of the system
1046   * that rely on it ... but after the i2c bus on which this relies.
1047   * That is, much earlier than on PC-type systems, which don't often use
1048   * I2C as a core system bus.
1049   */
1050  subsys_initcall(tps_init);
1051  
tps_exit(void)1052  static void __exit tps_exit(void)
1053  {
1054  	i2c_del_driver(&tps65010_driver);
1055  }
1056  module_exit(tps_exit);
1057  
1058