PageRenderTime 32ms CodeModel.GetById 1ms app.highlight 26ms RepoModel.GetById 1ms app.codeStats 0ms

/drivers/gpio/gpio-twl4030.c

http://github.com/mirrors/linux
C | 651 lines | 440 code | 126 blank | 85 comment | 54 complexity | 3343ae725f872f6d27eaa78aed7f16e2 MD5 | raw file
  1// SPDX-License-Identifier: GPL-2.0+
  2/*
  3 * Access to GPIOs on TWL4030/TPS659x0 chips
  4 *
  5 * Copyright (C) 2006-2007 Texas Instruments, Inc.
  6 * Copyright (C) 2006 MontaVista Software, Inc.
  7 *
  8 * Code re-arranged and cleaned up by:
  9 *	Syed Mohammed Khasim <x0khasim@ti.com>
 10 *
 11 * Initial Code:
 12 *	Andy Lowe / Nishanth Menon
 13 */
 14
 15#include <linux/module.h>
 16#include <linux/init.h>
 17#include <linux/interrupt.h>
 18#include <linux/kthread.h>
 19#include <linux/irq.h>
 20#include <linux/gpio/driver.h>
 21#include <linux/platform_device.h>
 22#include <linux/of.h>
 23#include <linux/irqdomain.h>
 24
 25#include <linux/mfd/twl.h>
 26
 27/*
 28 * The GPIO "subchip" supports 18 GPIOs which can be configured as
 29 * inputs or outputs, with pullups or pulldowns on each pin.  Each
 30 * GPIO can trigger interrupts on either or both edges.
 31 *
 32 * GPIO interrupts can be fed to either of two IRQ lines; this is
 33 * intended to support multiple hosts.
 34 *
 35 * There are also two LED pins used sometimes as output-only GPIOs.
 36 */
 37
 38/* genirq interfaces are not available to modules */
 39#ifdef MODULE
 40#define is_module()	true
 41#else
 42#define is_module()	false
 43#endif
 44
 45/* GPIO_CTRL Fields */
 46#define MASK_GPIO_CTRL_GPIO0CD1		BIT(0)
 47#define MASK_GPIO_CTRL_GPIO1CD2		BIT(1)
 48#define MASK_GPIO_CTRL_GPIO_ON		BIT(2)
 49
 50/* Mask for GPIO registers when aggregated into a 32-bit integer */
 51#define GPIO_32_MASK			0x0003ffff
 52
 53struct gpio_twl4030_priv {
 54	struct gpio_chip gpio_chip;
 55	struct mutex mutex;
 56	int irq_base;
 57
 58	/* Bitfields for state caching */
 59	unsigned int usage_count;
 60	unsigned int direction;
 61	unsigned int out_state;
 62};
 63
 64/*----------------------------------------------------------------------*/
 65
 66/*
 67 * To configure TWL4030 GPIO module registers
 68 */
 69static inline int gpio_twl4030_write(u8 address, u8 data)
 70{
 71	return twl_i2c_write_u8(TWL4030_MODULE_GPIO, data, address);
 72}
 73
 74/*----------------------------------------------------------------------*/
 75
 76/*
 77 * LED register offsets from TWL_MODULE_LED base
 78 * PWMs A and B are dedicated to LEDs A and B, respectively.
 79 */
 80
 81#define TWL4030_LED_LEDEN_REG	0x00
 82#define TWL4030_PWMAON_REG	0x01
 83#define TWL4030_PWMAOFF_REG	0x02
 84#define TWL4030_PWMBON_REG	0x03
 85#define TWL4030_PWMBOFF_REG	0x04
 86
 87/* LEDEN bits */
 88#define LEDEN_LEDAON		BIT(0)
 89#define LEDEN_LEDBON		BIT(1)
 90#define LEDEN_LEDAEXT		BIT(2)
 91#define LEDEN_LEDBEXT		BIT(3)
 92#define LEDEN_LEDAPWM		BIT(4)
 93#define LEDEN_LEDBPWM		BIT(5)
 94#define LEDEN_PWM_LENGTHA	BIT(6)
 95#define LEDEN_PWM_LENGTHB	BIT(7)
 96
 97#define PWMxON_LENGTH		BIT(7)
 98
 99/*----------------------------------------------------------------------*/
100
101/*
102 * To read a TWL4030 GPIO module register
103 */
104static inline int gpio_twl4030_read(u8 address)
105{
106	u8 data;
107	int ret = 0;
108
109	ret = twl_i2c_read_u8(TWL4030_MODULE_GPIO, &data, address);
110	return (ret < 0) ? ret : data;
111}
112
113/*----------------------------------------------------------------------*/
114
115static u8 cached_leden;
116
117/* The LED lines are open drain outputs ... a FET pulls to GND, so an
118 * external pullup is needed.  We could also expose the integrated PWM
119 * as a LED brightness control; we initialize it as "always on".
120 */
121static void twl4030_led_set_value(int led, int value)
122{
123	u8 mask = LEDEN_LEDAON | LEDEN_LEDAPWM;
124
125	if (led)
126		mask <<= 1;
127
128	if (value)
129		cached_leden &= ~mask;
130	else
131		cached_leden |= mask;
132
133	WARN_ON_ONCE(twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden,
134				      TWL4030_LED_LEDEN_REG));
135}
136
137static int twl4030_set_gpio_direction(int gpio, int is_input)
138{
139	u8 d_bnk = gpio >> 3;
140	u8 d_msk = BIT(gpio & 0x7);
141	u8 reg = 0;
142	u8 base = REG_GPIODATADIR1 + d_bnk;
143	int ret = 0;
144
145	ret = gpio_twl4030_read(base);
146	if (ret >= 0) {
147		if (is_input)
148			reg = ret & ~d_msk;
149		else
150			reg = ret | d_msk;
151
152		ret = gpio_twl4030_write(base, reg);
153	}
154	return ret;
155}
156
157static int twl4030_get_gpio_direction(int gpio)
158{
159	u8 d_bnk = gpio >> 3;
160	u8 d_msk = BIT(gpio & 0x7);
161	u8 base = REG_GPIODATADIR1 + d_bnk;
162	int ret = 0;
163
164	ret = gpio_twl4030_read(base);
165	if (ret < 0)
166		return ret;
167
168	if (ret & d_msk)
169		return GPIO_LINE_DIRECTION_OUT;
170
171	return GPIO_LINE_DIRECTION_IN;
172}
173
174static int twl4030_set_gpio_dataout(int gpio, int enable)
175{
176	u8 d_bnk = gpio >> 3;
177	u8 d_msk = BIT(gpio & 0x7);
178	u8 base = 0;
179
180	if (enable)
181		base = REG_SETGPIODATAOUT1 + d_bnk;
182	else
183		base = REG_CLEARGPIODATAOUT1 + d_bnk;
184
185	return gpio_twl4030_write(base, d_msk);
186}
187
188static int twl4030_get_gpio_datain(int gpio)
189{
190	u8 d_bnk = gpio >> 3;
191	u8 d_off = gpio & 0x7;
192	u8 base = 0;
193	int ret = 0;
194
195	base = REG_GPIODATAIN1 + d_bnk;
196	ret = gpio_twl4030_read(base);
197	if (ret > 0)
198		ret = (ret >> d_off) & 0x1;
199
200	return ret;
201}
202
203/*----------------------------------------------------------------------*/
204
205static int twl_request(struct gpio_chip *chip, unsigned offset)
206{
207	struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
208	int status = 0;
209
210	mutex_lock(&priv->mutex);
211
212	/* Support the two LED outputs as output-only GPIOs. */
213	if (offset >= TWL4030_GPIO_MAX) {
214		u8	ledclr_mask = LEDEN_LEDAON | LEDEN_LEDAEXT
215				| LEDEN_LEDAPWM | LEDEN_PWM_LENGTHA;
216		u8	reg = TWL4030_PWMAON_REG;
217
218		offset -= TWL4030_GPIO_MAX;
219		if (offset) {
220			ledclr_mask <<= 1;
221			reg = TWL4030_PWMBON_REG;
222		}
223
224		/* initialize PWM to always-drive */
225		/* Configure PWM OFF register first */
226		status = twl_i2c_write_u8(TWL4030_MODULE_LED, 0x7f, reg + 1);
227		if (status < 0)
228			goto done;
229
230		/* Followed by PWM ON register */
231		status = twl_i2c_write_u8(TWL4030_MODULE_LED, 0x7f, reg);
232		if (status < 0)
233			goto done;
234
235		/* init LED to not-driven (high) */
236		status = twl_i2c_read_u8(TWL4030_MODULE_LED, &cached_leden,
237					 TWL4030_LED_LEDEN_REG);
238		if (status < 0)
239			goto done;
240		cached_leden &= ~ledclr_mask;
241		status = twl_i2c_write_u8(TWL4030_MODULE_LED, cached_leden,
242					  TWL4030_LED_LEDEN_REG);
243		if (status < 0)
244			goto done;
245
246		status = 0;
247		goto done;
248	}
249
250	/* on first use, turn GPIO module "on" */
251	if (!priv->usage_count) {
252		struct twl4030_gpio_platform_data *pdata;
253		u8 value = MASK_GPIO_CTRL_GPIO_ON;
254
255		/* optionally have the first two GPIOs switch vMMC1
256		 * and vMMC2 power supplies based on card presence.
257		 */
258		pdata = dev_get_platdata(chip->parent);
259		if (pdata)
260			value |= pdata->mmc_cd & 0x03;
261
262		status = gpio_twl4030_write(REG_GPIO_CTRL, value);
263	}
264
265done:
266	if (!status)
267		priv->usage_count |= BIT(offset);
268
269	mutex_unlock(&priv->mutex);
270	return status;
271}
272
273static void twl_free(struct gpio_chip *chip, unsigned offset)
274{
275	struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
276
277	mutex_lock(&priv->mutex);
278	if (offset >= TWL4030_GPIO_MAX) {
279		twl4030_led_set_value(offset - TWL4030_GPIO_MAX, 1);
280		goto out;
281	}
282
283	priv->usage_count &= ~BIT(offset);
284
285	/* on last use, switch off GPIO module */
286	if (!priv->usage_count)
287		gpio_twl4030_write(REG_GPIO_CTRL, 0x0);
288
289out:
290	mutex_unlock(&priv->mutex);
291}
292
293static int twl_direction_in(struct gpio_chip *chip, unsigned offset)
294{
295	struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
296	int ret;
297
298	mutex_lock(&priv->mutex);
299	if (offset < TWL4030_GPIO_MAX)
300		ret = twl4030_set_gpio_direction(offset, 1);
301	else
302		ret = -EINVAL;	/* LED outputs can't be set as input */
303
304	if (!ret)
305		priv->direction &= ~BIT(offset);
306
307	mutex_unlock(&priv->mutex);
308
309	return ret;
310}
311
312static int twl_get(struct gpio_chip *chip, unsigned offset)
313{
314	struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
315	int ret;
316	int status = 0;
317
318	mutex_lock(&priv->mutex);
319	if (!(priv->usage_count & BIT(offset))) {
320		ret = -EPERM;
321		goto out;
322	}
323
324	if (priv->direction & BIT(offset))
325		status = priv->out_state & BIT(offset);
326	else
327		status = twl4030_get_gpio_datain(offset);
328
329	ret = (status < 0) ? status : !!status;
330out:
331	mutex_unlock(&priv->mutex);
332	return ret;
333}
334
335static void twl_set(struct gpio_chip *chip, unsigned offset, int value)
336{
337	struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
338
339	mutex_lock(&priv->mutex);
340	if (offset < TWL4030_GPIO_MAX)
341		twl4030_set_gpio_dataout(offset, value);
342	else
343		twl4030_led_set_value(offset - TWL4030_GPIO_MAX, value);
344
345	if (value)
346		priv->out_state |= BIT(offset);
347	else
348		priv->out_state &= ~BIT(offset);
349
350	mutex_unlock(&priv->mutex);
351}
352
353static int twl_direction_out(struct gpio_chip *chip, unsigned offset, int value)
354{
355	struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
356	int ret = 0;
357
358	mutex_lock(&priv->mutex);
359	if (offset < TWL4030_GPIO_MAX) {
360		ret = twl4030_set_gpio_direction(offset, 0);
361		if (ret) {
362			mutex_unlock(&priv->mutex);
363			return ret;
364		}
365	}
366
367	/*
368	 *  LED gpios i.e. offset >= TWL4030_GPIO_MAX are always output
369	 */
370
371	priv->direction |= BIT(offset);
372	mutex_unlock(&priv->mutex);
373
374	twl_set(chip, offset, value);
375
376	return ret;
377}
378
379static int twl_get_direction(struct gpio_chip *chip, unsigned offset)
380{
381	struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
382	/*
383	 * Default GPIO_LINE_DIRECTION_OUT
384	 * LED GPIOs >= TWL4030_GPIO_MAX are always output
385	 */
386	int ret = GPIO_LINE_DIRECTION_OUT;
387
388	mutex_lock(&priv->mutex);
389	if (offset < TWL4030_GPIO_MAX) {
390		ret = twl4030_get_gpio_direction(offset);
391		if (ret) {
392			mutex_unlock(&priv->mutex);
393			return ret;
394		}
395	}
396	mutex_unlock(&priv->mutex);
397
398	return ret;
399}
400
401static int twl_to_irq(struct gpio_chip *chip, unsigned offset)
402{
403	struct gpio_twl4030_priv *priv = gpiochip_get_data(chip);
404
405	return (priv->irq_base && (offset < TWL4030_GPIO_MAX))
406		? (priv->irq_base + offset)
407		: -EINVAL;
408}
409
410static const struct gpio_chip template_chip = {
411	.label			= "twl4030",
412	.owner			= THIS_MODULE,
413	.request		= twl_request,
414	.free			= twl_free,
415	.direction_input	= twl_direction_in,
416	.direction_output	= twl_direction_out,
417	.get_direction		= twl_get_direction,
418	.get			= twl_get,
419	.set			= twl_set,
420	.to_irq			= twl_to_irq,
421	.can_sleep		= true,
422};
423
424/*----------------------------------------------------------------------*/
425
426static int gpio_twl4030_pulls(u32 ups, u32 downs)
427{
428	u8		message[5];
429	unsigned	i, gpio_bit;
430
431	/* For most pins, a pulldown was enabled by default.
432	 * We should have data that's specific to this board.
433	 */
434	for (gpio_bit = 1, i = 0; i < 5; i++) {
435		u8		bit_mask;
436		unsigned	j;
437
438		for (bit_mask = 0, j = 0; j < 8; j += 2, gpio_bit <<= 1) {
439			if (ups & gpio_bit)
440				bit_mask |= 1 << (j + 1);
441			else if (downs & gpio_bit)
442				bit_mask |= 1 << (j + 0);
443		}
444		message[i] = bit_mask;
445	}
446
447	return twl_i2c_write(TWL4030_MODULE_GPIO, message,
448				REG_GPIOPUPDCTR1, 5);
449}
450
451static int gpio_twl4030_debounce(u32 debounce, u8 mmc_cd)
452{
453	u8		message[3];
454
455	/* 30 msec of debouncing is always used for MMC card detect,
456	 * and is optional for everything else.
457	 */
458	message[0] = (debounce & 0xff) | (mmc_cd & 0x03);
459	debounce >>= 8;
460	message[1] = (debounce & 0xff);
461	debounce >>= 8;
462	message[2] = (debounce & 0x03);
463
464	return twl_i2c_write(TWL4030_MODULE_GPIO, message,
465				REG_GPIO_DEBEN1, 3);
466}
467
468static int gpio_twl4030_remove(struct platform_device *pdev);
469
470static struct twl4030_gpio_platform_data *of_gpio_twl4030(struct device *dev,
471				struct twl4030_gpio_platform_data *pdata)
472{
473	struct twl4030_gpio_platform_data *omap_twl_info;
474
475	omap_twl_info = devm_kzalloc(dev, sizeof(*omap_twl_info), GFP_KERNEL);
476	if (!omap_twl_info)
477		return NULL;
478
479	if (pdata)
480		*omap_twl_info = *pdata;
481
482	omap_twl_info->use_leds = of_property_read_bool(dev->of_node,
483			"ti,use-leds");
484
485	of_property_read_u32(dev->of_node, "ti,debounce",
486			     &omap_twl_info->debounce);
487	of_property_read_u32(dev->of_node, "ti,mmc-cd",
488			     (u32 *)&omap_twl_info->mmc_cd);
489	of_property_read_u32(dev->of_node, "ti,pullups",
490			     &omap_twl_info->pullups);
491	of_property_read_u32(dev->of_node, "ti,pulldowns",
492			     &omap_twl_info->pulldowns);
493
494	return omap_twl_info;
495}
496
497static int gpio_twl4030_probe(struct platform_device *pdev)
498{
499	struct twl4030_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev);
500	struct device_node *node = pdev->dev.of_node;
501	struct gpio_twl4030_priv *priv;
502	int ret, irq_base;
503
504	priv = devm_kzalloc(&pdev->dev, sizeof(struct gpio_twl4030_priv),
505			    GFP_KERNEL);
506	if (!priv)
507		return -ENOMEM;
508
509	/* maybe setup IRQs */
510	if (is_module()) {
511		dev_err(&pdev->dev, "can't dispatch IRQs from modules\n");
512		goto no_irqs;
513	}
514
515	irq_base = devm_irq_alloc_descs(&pdev->dev, -1,
516					0, TWL4030_GPIO_MAX, 0);
517	if (irq_base < 0) {
518		dev_err(&pdev->dev, "Failed to alloc irq_descs\n");
519		return irq_base;
520	}
521
522	irq_domain_add_legacy(node, TWL4030_GPIO_MAX, irq_base, 0,
523			      &irq_domain_simple_ops, NULL);
524
525	ret = twl4030_sih_setup(&pdev->dev, TWL4030_MODULE_GPIO, irq_base);
526	if (ret < 0)
527		return ret;
528
529	priv->irq_base = irq_base;
530
531no_irqs:
532	priv->gpio_chip = template_chip;
533	priv->gpio_chip.base = -1;
534	priv->gpio_chip.ngpio = TWL4030_GPIO_MAX;
535	priv->gpio_chip.parent = &pdev->dev;
536
537	mutex_init(&priv->mutex);
538
539	if (node)
540		pdata = of_gpio_twl4030(&pdev->dev, pdata);
541
542	if (pdata == NULL) {
543		dev_err(&pdev->dev, "Platform data is missing\n");
544		return -ENXIO;
545	}
546
547	/*
548	 * NOTE:  boards may waste power if they don't set pullups
549	 * and pulldowns correctly ... default for non-ULPI pins is
550	 * pulldown, and some other pins may have external pullups
551	 * or pulldowns.  Careful!
552	 */
553	ret = gpio_twl4030_pulls(pdata->pullups, pdata->pulldowns);
554	if (ret)
555		dev_dbg(&pdev->dev, "pullups %.05x %.05x --> %d\n",
556			pdata->pullups, pdata->pulldowns, ret);
557
558	ret = gpio_twl4030_debounce(pdata->debounce, pdata->mmc_cd);
559	if (ret)
560		dev_dbg(&pdev->dev, "debounce %.03x %.01x --> %d\n",
561			pdata->debounce, pdata->mmc_cd, ret);
562
563	/*
564	 * NOTE: we assume VIBRA_CTL.VIBRA_EN, in MODULE_AUDIO_VOICE,
565	 * is (still) clear if use_leds is set.
566	 */
567	if (pdata->use_leds)
568		priv->gpio_chip.ngpio += 2;
569
570	ret = gpiochip_add_data(&priv->gpio_chip, priv);
571	if (ret < 0) {
572		dev_err(&pdev->dev, "could not register gpiochip, %d\n", ret);
573		priv->gpio_chip.ngpio = 0;
574		gpio_twl4030_remove(pdev);
575		goto out;
576	}
577
578	platform_set_drvdata(pdev, priv);
579
580	if (pdata->setup) {
581		int status;
582
583		status = pdata->setup(&pdev->dev, priv->gpio_chip.base,
584				      TWL4030_GPIO_MAX);
585		if (status)
586			dev_dbg(&pdev->dev, "setup --> %d\n", status);
587	}
588
589out:
590	return ret;
591}
592
593/* Cannot use as gpio_twl4030_probe() calls us */
594static int gpio_twl4030_remove(struct platform_device *pdev)
595{
596	struct twl4030_gpio_platform_data *pdata = dev_get_platdata(&pdev->dev);
597	struct gpio_twl4030_priv *priv = platform_get_drvdata(pdev);
598	int status;
599
600	if (pdata && pdata->teardown) {
601		status = pdata->teardown(&pdev->dev, priv->gpio_chip.base,
602					 TWL4030_GPIO_MAX);
603		if (status) {
604			dev_dbg(&pdev->dev, "teardown --> %d\n", status);
605			return status;
606		}
607	}
608
609	gpiochip_remove(&priv->gpio_chip);
610
611	if (is_module())
612		return 0;
613
614	/* REVISIT no support yet for deregistering all the IRQs */
615	WARN_ON(1);
616	return -EIO;
617}
618
619static const struct of_device_id twl_gpio_match[] = {
620	{ .compatible = "ti,twl4030-gpio", },
621	{ },
622};
623MODULE_DEVICE_TABLE(of, twl_gpio_match);
624
625/* Note:  this hardware lives inside an I2C-based multi-function device. */
626MODULE_ALIAS("platform:twl4030_gpio");
627
628static struct platform_driver gpio_twl4030_driver = {
629	.driver = {
630		.name	= "twl4030_gpio",
631		.of_match_table = twl_gpio_match,
632	},
633	.probe		= gpio_twl4030_probe,
634	.remove		= gpio_twl4030_remove,
635};
636
637static int __init gpio_twl4030_init(void)
638{
639	return platform_driver_register(&gpio_twl4030_driver);
640}
641subsys_initcall(gpio_twl4030_init);
642
643static void __exit gpio_twl4030_exit(void)
644{
645	platform_driver_unregister(&gpio_twl4030_driver);
646}
647module_exit(gpio_twl4030_exit);
648
649MODULE_AUTHOR("Texas Instruments, Inc.");
650MODULE_DESCRIPTION("GPIO interface for TWL4030");
651MODULE_LICENSE("GPL");