1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * MFD driver for TWL6040 audio device
  4 *
  5 * Authors:	Misael Lopez Cruz <misael.lopez@ti.com>
  6 *		Jorge Eduardo Candelaria <jorge.candelaria@ti.com>
  7 *		Peter Ujfalusi <peter.ujfalusi@ti.com>
  8 *
  9 * Copyright:	(C) 2011 Texas Instruments, Inc.
 10 */
 11
 12#include <linux/module.h>
 13#include <linux/types.h>
 14#include <linux/slab.h>
 15#include <linux/kernel.h>
 16#include <linux/err.h>
 17#include <linux/platform_device.h>
 18#include <linux/of.h>
 19#include <linux/of_irq.h>
 20#include <linux/of_gpio.h>
 21#include <linux/of_platform.h>
 22#include <linux/gpio.h>
 23#include <linux/delay.h>
 24#include <linux/i2c.h>
 25#include <linux/regmap.h>
 26#include <linux/mfd/core.h>
 27#include <linux/mfd/twl6040.h>
 28#include <linux/regulator/consumer.h>
 29
 30#define VIBRACTRL_MEMBER(reg) ((reg == TWL6040_REG_VIBCTLL) ? 0 : 1)
 31#define TWL6040_NUM_SUPPLIES	(2)
 32
 33static const struct reg_default twl6040_defaults[] = {
 34	{ 0x01, 0x4B }, /* REG_ASICID	(ro) */
 35	{ 0x02, 0x00 }, /* REG_ASICREV	(ro) */
 36	{ 0x03, 0x00 }, /* REG_INTID	*/
 37	{ 0x04, 0x00 }, /* REG_INTMR	*/
 38	{ 0x05, 0x00 }, /* REG_NCPCTRL	*/
 39	{ 0x06, 0x00 }, /* REG_LDOCTL	*/
 40	{ 0x07, 0x60 }, /* REG_HPPLLCTL	*/
 41	{ 0x08, 0x00 }, /* REG_LPPLLCTL	*/
 42	{ 0x09, 0x4A }, /* REG_LPPLLDIV	*/
 43	{ 0x0A, 0x00 }, /* REG_AMICBCTL	*/
 44	{ 0x0B, 0x00 }, /* REG_DMICBCTL	*/
 45	{ 0x0C, 0x00 }, /* REG_MICLCTL	*/
 46	{ 0x0D, 0x00 }, /* REG_MICRCTL	*/
 47	{ 0x0E, 0x00 }, /* REG_MICGAIN	*/
 48	{ 0x0F, 0x1B }, /* REG_LINEGAIN	*/
 49	{ 0x10, 0x00 }, /* REG_HSLCTL	*/
 50	{ 0x11, 0x00 }, /* REG_HSRCTL	*/
 51	{ 0x12, 0x00 }, /* REG_HSGAIN	*/
 52	{ 0x13, 0x00 }, /* REG_EARCTL	*/
 53	{ 0x14, 0x00 }, /* REG_HFLCTL	*/
 54	{ 0x15, 0x00 }, /* REG_HFLGAIN	*/
 55	{ 0x16, 0x00 }, /* REG_HFRCTL	*/
 56	{ 0x17, 0x00 }, /* REG_HFRGAIN	*/
 57	{ 0x18, 0x00 }, /* REG_VIBCTLL	*/
 58	{ 0x19, 0x00 }, /* REG_VIBDATL	*/
 59	{ 0x1A, 0x00 }, /* REG_VIBCTLR	*/
 60	{ 0x1B, 0x00 }, /* REG_VIBDATR	*/
 61	{ 0x1C, 0x00 }, /* REG_HKCTL1	*/
 62	{ 0x1D, 0x00 }, /* REG_HKCTL2	*/
 63	{ 0x1E, 0x00 }, /* REG_GPOCTL	*/
 64	{ 0x1F, 0x00 }, /* REG_ALB	*/
 65	{ 0x20, 0x00 }, /* REG_DLB	*/
 66	/* 0x28, REG_TRIM1 */
 67	/* 0x29, REG_TRIM2 */
 68	/* 0x2A, REG_TRIM3 */
 69	/* 0x2B, REG_HSOTRIM */
 70	/* 0x2C, REG_HFOTRIM */
 71	{ 0x2D, 0x08 }, /* REG_ACCCTL	*/
 72	{ 0x2E, 0x00 }, /* REG_STATUS	(ro) */
 73};
 74
 75static struct reg_sequence twl6040_patch[] = {
 76	/*
 77	 * Select I2C bus access to dual access registers
 78	 * Interrupt register is cleared on read
 79	 * Select fast mode for i2c (400KHz)
 80	 */
 81	{ TWL6040_REG_ACCCTL,
 82		TWL6040_I2CSEL | TWL6040_INTCLRMODE | TWL6040_I2CMODE(1) },
 83};
 84
 85
 86static bool twl6040_has_vibra(struct device_node *parent)
 87{
 88	struct device_node *node;
 89
 90	node = of_get_child_by_name(parent, "vibra");
 91	if (node) {
 92		of_node_put(node);
 93		return true;
 94	}
 95
 96	return false;
 97}
 98
 99int twl6040_reg_read(struct twl6040 *twl6040, unsigned int reg)
100{
101	int ret;
102	unsigned int val;
103
104	ret = regmap_read(twl6040->regmap, reg, &val);
105	if (ret < 0)
106		return ret;
107
108	return val;
109}
110EXPORT_SYMBOL(twl6040_reg_read);
111
112int twl6040_reg_write(struct twl6040 *twl6040, unsigned int reg, u8 val)
113{
114	int ret;
115
116	ret = regmap_write(twl6040->regmap, reg, val);
117
118	return ret;
119}
120EXPORT_SYMBOL(twl6040_reg_write);
121
122int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
123{
124	return regmap_update_bits(twl6040->regmap, reg, mask, mask);
125}
126EXPORT_SYMBOL(twl6040_set_bits);
127
128int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
129{
130	return regmap_update_bits(twl6040->regmap, reg, mask, 0);
131}
132EXPORT_SYMBOL(twl6040_clear_bits);
133
134/* twl6040 codec manual power-up sequence */
135static int twl6040_power_up_manual(struct twl6040 *twl6040)
136{
137	u8 ldoctl, ncpctl, lppllctl;
138	int ret;
139
140	/* enable high-side LDO, reference system and internal oscillator */
141	ldoctl = TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA;
142	ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
143	if (ret)
144		return ret;
145	usleep_range(10000, 10500);
146
147	/* enable negative charge pump */
148	ncpctl = TWL6040_NCPENA;
149	ret = twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
150	if (ret)
151		goto ncp_err;
152	usleep_range(1000, 1500);
153
154	/* enable low-side LDO */
155	ldoctl |= TWL6040_LSLDOENA;
156	ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
157	if (ret)
158		goto lsldo_err;
159	usleep_range(1000, 1500);
160
161	/* enable low-power PLL */
162	lppllctl = TWL6040_LPLLENA;
163	ret = twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
164	if (ret)
165		goto lppll_err;
166	usleep_range(5000, 5500);
167
168	/* disable internal oscillator */
169	ldoctl &= ~TWL6040_OSCENA;
170	ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
171	if (ret)
172		goto osc_err;
173
174	return 0;
175
176osc_err:
177	lppllctl &= ~TWL6040_LPLLENA;
178	twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
179lppll_err:
180	ldoctl &= ~TWL6040_LSLDOENA;
181	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
182lsldo_err:
183	ncpctl &= ~TWL6040_NCPENA;
184	twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
185ncp_err:
186	ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
187	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
188
189	dev_err(twl6040->dev, "manual power-up failed\n");
190	return ret;
191}
192
193/* twl6040 manual power-down sequence */
194static void twl6040_power_down_manual(struct twl6040 *twl6040)
195{
196	u8 ncpctl, ldoctl, lppllctl;
197
198	ncpctl = twl6040_reg_read(twl6040, TWL6040_REG_NCPCTL);
199	ldoctl = twl6040_reg_read(twl6040, TWL6040_REG_LDOCTL);
200	lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);
201
202	/* enable internal oscillator */
203	ldoctl |= TWL6040_OSCENA;
204	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
205	usleep_range(1000, 1500);
206
207	/* disable low-power PLL */
208	lppllctl &= ~TWL6040_LPLLENA;
209	twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
210
211	/* disable low-side LDO */
212	ldoctl &= ~TWL6040_LSLDOENA;
213	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
214
215	/* disable negative charge pump */
216	ncpctl &= ~TWL6040_NCPENA;
217	twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
218
219	/* disable high-side LDO, reference system and internal oscillator */
220	ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
221	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
222}
223
224static irqreturn_t twl6040_readyint_handler(int irq, void *data)
225{
226	struct twl6040 *twl6040 = data;
227
228	complete(&twl6040->ready);
229
230	return IRQ_HANDLED;
231}
232
233static irqreturn_t twl6040_thint_handler(int irq, void *data)
234{
235	struct twl6040 *twl6040 = data;
236	u8 status;
237
238	status = twl6040_reg_read(twl6040, TWL6040_REG_STATUS);
239	if (status & TWL6040_TSHUTDET) {
240		dev_warn(twl6040->dev, "Thermal shutdown, powering-off");
241		twl6040_power(twl6040, 0);
242	} else {
243		dev_warn(twl6040->dev, "Leaving thermal shutdown, powering-on");
244		twl6040_power(twl6040, 1);
245	}
246
247	return IRQ_HANDLED;
248}
249
250static int twl6040_power_up_automatic(struct twl6040 *twl6040)
251{
252	int time_left;
253
254	gpio_set_value(twl6040->audpwron, 1);
255
256	time_left = wait_for_completion_timeout(&twl6040->ready,
257						msecs_to_jiffies(144));
258	if (!time_left) {
259		u8 intid;
260
261		dev_warn(twl6040->dev, "timeout waiting for READYINT\n");
262		intid = twl6040_reg_read(twl6040, TWL6040_REG_INTID);
263		if (!(intid & TWL6040_READYINT)) {
264			dev_err(twl6040->dev, "automatic power-up failed\n");
265			gpio_set_value(twl6040->audpwron, 0);
266			return -ETIMEDOUT;
267		}
268	}
269
270	return 0;
271}
272
273int twl6040_power(struct twl6040 *twl6040, int on)
274{
275	int ret = 0;
276
277	mutex_lock(&twl6040->mutex);
278
279	if (on) {
280		/* already powered-up */
281		if (twl6040->power_count++)
282			goto out;
283
284		ret = clk_prepare_enable(twl6040->clk32k);
285		if (ret) {
286			twl6040->power_count = 0;
287			goto out;
288		}
289
290		/* Allow writes to the chip */
291		regcache_cache_only(twl6040->regmap, false);
292
293		if (gpio_is_valid(twl6040->audpwron)) {
294			/* use automatic power-up sequence */
295			ret = twl6040_power_up_automatic(twl6040);
296			if (ret) {
297				clk_disable_unprepare(twl6040->clk32k);
298				twl6040->power_count = 0;
299				goto out;
300			}
301		} else {
302			/* use manual power-up sequence */
303			ret = twl6040_power_up_manual(twl6040);
304			if (ret) {
305				clk_disable_unprepare(twl6040->clk32k);
306				twl6040->power_count = 0;
307				goto out;
308			}
309		}
310
311		/*
312		 * Register access can produce errors after power-up unless we
313		 * wait at least 8ms based on measurements on duovero.
314		 */
315		usleep_range(10000, 12000);
316
317		/* Sync with the HW */
318		ret = regcache_sync(twl6040->regmap);
319		if (ret) {
320			dev_err(twl6040->dev, "Failed to sync with the HW: %i\n",
321				ret);
322			goto out;
323		}
324
325		/* Default PLL configuration after power up */
326		twl6040->pll = TWL6040_SYSCLK_SEL_LPPLL;
327		twl6040->sysclk_rate = 19200000;
328	} else {
329		/* already powered-down */
330		if (!twl6040->power_count) {
331			dev_err(twl6040->dev,
332				"device is already powered-off\n");
333			ret = -EPERM;
334			goto out;
335		}
336
337		if (--twl6040->power_count)
338			goto out;
339
340		if (gpio_is_valid(twl6040->audpwron)) {
341			/* use AUDPWRON line */
342			gpio_set_value(twl6040->audpwron, 0);
343
344			/* power-down sequence latency */
345			usleep_range(500, 700);
346		} else {
347			/* use manual power-down sequence */
348			twl6040_power_down_manual(twl6040);
349		}
350
351		/* Set regmap to cache only and mark it as dirty */
352		regcache_cache_only(twl6040->regmap, true);
353		regcache_mark_dirty(twl6040->regmap);
354
355		twl6040->sysclk_rate = 0;
356
357		if (twl6040->pll == TWL6040_SYSCLK_SEL_HPPLL) {
358			clk_disable_unprepare(twl6040->mclk);
359			twl6040->mclk_rate = 0;
360		}
361
362		clk_disable_unprepare(twl6040->clk32k);
363	}
364
365out:
366	mutex_unlock(&twl6040->mutex);
367	return ret;
368}
369EXPORT_SYMBOL(twl6040_power);
370
371int twl6040_set_pll(struct twl6040 *twl6040, int pll_id,
372		    unsigned int freq_in, unsigned int freq_out)
373{
374	u8 hppllctl, lppllctl;
375	int ret = 0;
376
377	mutex_lock(&twl6040->mutex);
378
379	hppllctl = twl6040_reg_read(twl6040, TWL6040_REG_HPPLLCTL);
380	lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);
381
382	/* Force full reconfiguration when switching between PLL */
383	if (pll_id != twl6040->pll) {
384		twl6040->sysclk_rate = 0;
385		twl6040->mclk_rate = 0;
386	}
387
388	switch (pll_id) {
389	case TWL6040_SYSCLK_SEL_LPPLL:
390		/* low-power PLL divider */
391		/* Change the sysclk configuration only if it has been canged */
392		if (twl6040->sysclk_rate != freq_out) {
393			switch (freq_out) {
394			case 17640000:
395				lppllctl |= TWL6040_LPLLFIN;
396				break;
397			case 19200000:
398				lppllctl &= ~TWL6040_LPLLFIN;
399				break;
400			default:
401				dev_err(twl6040->dev,
402					"freq_out %d not supported\n",
403					freq_out);
404				ret = -EINVAL;
405				goto pll_out;
406			}
407			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
408					  lppllctl);
409		}
410
411		/* The PLL in use has not been change, we can exit */
412		if (twl6040->pll == pll_id)
413			break;
414
415		switch (freq_in) {
416		case 32768:
417			lppllctl |= TWL6040_LPLLENA;
418			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
419					  lppllctl);
420			mdelay(5);
421			lppllctl &= ~TWL6040_HPLLSEL;
422			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
423					  lppllctl);
424			hppllctl &= ~TWL6040_HPLLENA;
425			twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
426					  hppllctl);
427			break;
428		default:
429			dev_err(twl6040->dev,
430				"freq_in %d not supported\n", freq_in);
431			ret = -EINVAL;
432			goto pll_out;
433		}
434
435		clk_disable_unprepare(twl6040->mclk);
436		break;
437	case TWL6040_SYSCLK_SEL_HPPLL:
438		/* high-performance PLL can provide only 19.2 MHz */
439		if (freq_out != 19200000) {
440			dev_err(twl6040->dev,
441				"freq_out %d not supported\n", freq_out);
442			ret = -EINVAL;
443			goto pll_out;
444		}
445
446		if (twl6040->mclk_rate != freq_in) {
447			hppllctl &= ~TWL6040_MCLK_MSK;
448
449			switch (freq_in) {
450			case 12000000:
451				/* PLL enabled, active mode */
452				hppllctl |= TWL6040_MCLK_12000KHZ |
453					    TWL6040_HPLLENA;
454				break;
455			case 19200000:
456				/* PLL enabled, bypass mode */
457				hppllctl |= TWL6040_MCLK_19200KHZ |
458					    TWL6040_HPLLBP | TWL6040_HPLLENA;
459				break;
460			case 26000000:
461				/* PLL enabled, active mode */
462				hppllctl |= TWL6040_MCLK_26000KHZ |
463					    TWL6040_HPLLENA;
464				break;
465			case 38400000:
466				/* PLL enabled, bypass mode */
467				hppllctl |= TWL6040_MCLK_38400KHZ |
468					    TWL6040_HPLLBP | TWL6040_HPLLENA;
469				break;
470			default:
471				dev_err(twl6040->dev,
472					"freq_in %d not supported\n", freq_in);
473				ret = -EINVAL;
474				goto pll_out;
475			}
476
477			/* When switching to HPPLL, enable the mclk first */
478			if (pll_id != twl6040->pll)
479				clk_prepare_enable(twl6040->mclk);
480			/*
481			 * enable clock slicer to ensure input waveform is
482			 * square
483			 */
484			hppllctl |= TWL6040_HPLLSQRENA;
485
486			twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
487					  hppllctl);
488			usleep_range(500, 700);
489			lppllctl |= TWL6040_HPLLSEL;
490			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
491					  lppllctl);
492			lppllctl &= ~TWL6040_LPLLENA;
493			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
494					  lppllctl);
495
496			twl6040->mclk_rate = freq_in;
497		}
498		break;
499	default:
500		dev_err(twl6040->dev, "unknown pll id %d\n", pll_id);
501		ret = -EINVAL;
502		goto pll_out;
503	}
504
505	twl6040->sysclk_rate = freq_out;
506	twl6040->pll = pll_id;
507
508pll_out:
509	mutex_unlock(&twl6040->mutex);
510	return ret;
511}
512EXPORT_SYMBOL(twl6040_set_pll);
513
514int twl6040_get_pll(struct twl6040 *twl6040)
515{
516	if (twl6040->power_count)
517		return twl6040->pll;
518	else
519		return -ENODEV;
520}
521EXPORT_SYMBOL(twl6040_get_pll);
522
523unsigned int twl6040_get_sysclk(struct twl6040 *twl6040)
524{
525	return twl6040->sysclk_rate;
526}
527EXPORT_SYMBOL(twl6040_get_sysclk);
528
529/* Get the combined status of the vibra control register */
530int twl6040_get_vibralr_status(struct twl6040 *twl6040)
531{
532	unsigned int reg;
533	int ret;
534	u8 status;
535
536	ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLL, &reg);
537	if (ret != 0)
538		return ret;
539	status = reg;
540
541	ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLR, &reg);
542	if (ret != 0)
543		return ret;
544	status |= reg;
545
546	status &= (TWL6040_VIBENA | TWL6040_VIBSEL);
547
548	return status;
549}
550EXPORT_SYMBOL(twl6040_get_vibralr_status);
551
552static struct resource twl6040_vibra_rsrc[] = {
553	{
554		.flags = IORESOURCE_IRQ,
555	},
556};
557
558static struct resource twl6040_codec_rsrc[] = {
559	{
560		.flags = IORESOURCE_IRQ,
561	},
562};
563
564static bool twl6040_readable_reg(struct device *dev, unsigned int reg)
565{
566	/* Register 0 is not readable */
567	if (!reg)
568		return false;
569	return true;
570}
571
572static bool twl6040_volatile_reg(struct device *dev, unsigned int reg)
573{
574	switch (reg) {
575	case TWL6040_REG_ASICID:
576	case TWL6040_REG_ASICREV:
577	case TWL6040_REG_INTID:
578	case TWL6040_REG_LPPLLCTL:
579	case TWL6040_REG_HPPLLCTL:
580	case TWL6040_REG_STATUS:
581		return true;
582	default:
583		return false;
584	}
585}
586
587static bool twl6040_writeable_reg(struct device *dev, unsigned int reg)
588{
589	switch (reg) {
590	case TWL6040_REG_ASICID:
591	case TWL6040_REG_ASICREV:
592	case TWL6040_REG_STATUS:
593		return false;
594	default:
595		return true;
596	}
597}
598
599static const struct regmap_config twl6040_regmap_config = {
600	.reg_bits = 8,
601	.val_bits = 8,
602
603	.reg_defaults = twl6040_defaults,
604	.num_reg_defaults = ARRAY_SIZE(twl6040_defaults),
605
606	.max_register = TWL6040_REG_STATUS, /* 0x2e */
607
608	.readable_reg = twl6040_readable_reg,
609	.volatile_reg = twl6040_volatile_reg,
610	.writeable_reg = twl6040_writeable_reg,
611
612	.cache_type = REGCACHE_RBTREE,
613	.use_single_read = true,
614	.use_single_write = true,
615};
616
617static const struct regmap_irq twl6040_irqs[] = {
618	{ .reg_offset = 0, .mask = TWL6040_THINT, },
619	{ .reg_offset = 0, .mask = TWL6040_PLUGINT | TWL6040_UNPLUGINT, },
620	{ .reg_offset = 0, .mask = TWL6040_HOOKINT, },
621	{ .reg_offset = 0, .mask = TWL6040_HFINT, },
622	{ .reg_offset = 0, .mask = TWL6040_VIBINT, },
623	{ .reg_offset = 0, .mask = TWL6040_READYINT, },
624};
625
626static struct regmap_irq_chip twl6040_irq_chip = {
627	.name = "twl6040",
628	.irqs = twl6040_irqs,
629	.num_irqs = ARRAY_SIZE(twl6040_irqs),
630
631	.num_regs = 1,
632	.status_base = TWL6040_REG_INTID,
633	.mask_base = TWL6040_REG_INTMR,
634};
635
636static int twl6040_probe(struct i2c_client *client,
637			 const struct i2c_device_id *id)
638{
639	struct device_node *node = client->dev.of_node;
640	struct twl6040 *twl6040;
641	struct mfd_cell *cell = NULL;
642	int irq, ret, children = 0;
643
644	if (!node) {
645		dev_err(&client->dev, "of node is missing\n");
646		return -EINVAL;
647	}
648
649	/* In order to operate correctly we need valid interrupt config */
650	if (!client->irq) {
651		dev_err(&client->dev, "Invalid IRQ configuration\n");
652		return -EINVAL;
653	}
654
655	twl6040 = devm_kzalloc(&client->dev, sizeof(struct twl6040),
656			       GFP_KERNEL);
657	if (!twl6040)
658		return -ENOMEM;
659
660	twl6040->regmap = devm_regmap_init_i2c(client, &twl6040_regmap_config);
661	if (IS_ERR(twl6040->regmap))
662		return PTR_ERR(twl6040->regmap);
663
664	i2c_set_clientdata(client, twl6040);
665
666	twl6040->clk32k = devm_clk_get(&client->dev, "clk32k");
667	if (IS_ERR(twl6040->clk32k)) {
668		if (PTR_ERR(twl6040->clk32k) == -EPROBE_DEFER)
669			return -EPROBE_DEFER;
670		dev_dbg(&client->dev, "clk32k is not handled\n");
671		twl6040->clk32k = NULL;
672	}
673
674	twl6040->mclk = devm_clk_get(&client->dev, "mclk");
675	if (IS_ERR(twl6040->mclk)) {
676		if (PTR_ERR(twl6040->mclk) == -EPROBE_DEFER)
677			return -EPROBE_DEFER;
678		dev_dbg(&client->dev, "mclk is not handled\n");
679		twl6040->mclk = NULL;
680	}
681
682	twl6040->supplies[0].supply = "vio";
683	twl6040->supplies[1].supply = "v2v1";
684	ret = devm_regulator_bulk_get(&client->dev, TWL6040_NUM_SUPPLIES,
685				      twl6040->supplies);
686	if (ret != 0) {
687		dev_err(&client->dev, "Failed to get supplies: %d\n", ret);
688		return ret;
689	}
690
691	ret = regulator_bulk_enable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
692	if (ret != 0) {
693		dev_err(&client->dev, "Failed to enable supplies: %d\n", ret);
694		return ret;
695	}
696
697	twl6040->dev = &client->dev;
698	twl6040->irq = client->irq;
699
700	mutex_init(&twl6040->mutex);
701	init_completion(&twl6040->ready);
702
703	regmap_register_patch(twl6040->regmap, twl6040_patch,
704			      ARRAY_SIZE(twl6040_patch));
705
706	twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV);
707	if (twl6040->rev < 0) {
708		dev_err(&client->dev, "Failed to read revision register: %d\n",
709			twl6040->rev);
710		ret = twl6040->rev;
711		goto gpio_err;
712	}
713
714	/* ERRATA: Automatic power-up is not possible in ES1.0 */
715	if (twl6040_get_revid(twl6040) > TWL6040_REV_ES1_0)
716		twl6040->audpwron = of_get_named_gpio(node,
717						      "ti,audpwron-gpio", 0);
718	else
719		twl6040->audpwron = -EINVAL;
720
721	if (gpio_is_valid(twl6040->audpwron)) {
722		ret = devm_gpio_request_one(&client->dev, twl6040->audpwron,
723					    GPIOF_OUT_INIT_LOW, "audpwron");
724		if (ret)
725			goto gpio_err;
726
727		/* Clear any pending interrupt */
728		twl6040_reg_read(twl6040, TWL6040_REG_INTID);
729	}
730
731	ret = regmap_add_irq_chip(twl6040->regmap, twl6040->irq, IRQF_ONESHOT,
732				  0, &twl6040_irq_chip, &twl6040->irq_data);
733	if (ret < 0)
734		goto gpio_err;
735
736	twl6040->irq_ready = regmap_irq_get_virq(twl6040->irq_data,
737						 TWL6040_IRQ_READY);
738	twl6040->irq_th = regmap_irq_get_virq(twl6040->irq_data,
739					      TWL6040_IRQ_TH);
740
741	ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_ready, NULL,
742					twl6040_readyint_handler, IRQF_ONESHOT,
743					"twl6040_irq_ready", twl6040);
744	if (ret) {
745		dev_err(twl6040->dev, "READY IRQ request failed: %d\n", ret);
746		goto readyirq_err;
747	}
748
749	ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_th, NULL,
750					twl6040_thint_handler, IRQF_ONESHOT,
751					"twl6040_irq_th", twl6040);
752	if (ret) {
753		dev_err(twl6040->dev, "Thermal IRQ request failed: %d\n", ret);
754		goto readyirq_err;
755	}
756
757	/*
758	 * The main functionality of twl6040 to provide audio on OMAP4+ systems.
759	 * We can add the ASoC codec child whenever this driver has been loaded.
760	 */
761	irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_PLUG);
762	cell = &twl6040->cells[children];
763	cell->name = "twl6040-codec";
764	twl6040_codec_rsrc[0].start = irq;
765	twl6040_codec_rsrc[0].end = irq;
766	cell->resources = twl6040_codec_rsrc;
767	cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc);
768	children++;
769
770	/* Vibra input driver support */
771	if (twl6040_has_vibra(node)) {
772		irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_VIB);
773
774		cell = &twl6040->cells[children];
775		cell->name = "twl6040-vibra";
776		twl6040_vibra_rsrc[0].start = irq;
777		twl6040_vibra_rsrc[0].end = irq;
778		cell->resources = twl6040_vibra_rsrc;
779		cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc);
780		children++;
781	}
782
783	/* GPO support */
784	cell = &twl6040->cells[children];
785	cell->name = "twl6040-gpo";
786	children++;
787
788	/* PDM clock support  */
789	cell = &twl6040->cells[children];
790	cell->name = "twl6040-pdmclk";
791	children++;
792
793	/* The chip is powered down so mark regmap to cache only and dirty */
794	regcache_cache_only(twl6040->regmap, true);
795	regcache_mark_dirty(twl6040->regmap);
796
797	ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children,
798			      NULL, 0, NULL);
799	if (ret)
800		goto readyirq_err;
801
802	return 0;
803
804readyirq_err:
805	regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
806gpio_err:
807	regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
808	return ret;
809}
810
811static int twl6040_remove(struct i2c_client *client)
812{
813	struct twl6040 *twl6040 = i2c_get_clientdata(client);
814
815	if (twl6040->power_count)
816		twl6040_power(twl6040, 0);
817
818	regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
819
820	mfd_remove_devices(&client->dev);
821
822	regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
823
824	return 0;
825}
826
827static const struct i2c_device_id twl6040_i2c_id[] = {
828	{ "twl6040", 0, },
829	{ "twl6041", 0, },
830	{ },
831};
832MODULE_DEVICE_TABLE(i2c, twl6040_i2c_id);
833
834static struct i2c_driver twl6040_driver = {
835	.driver = {
836		.name = "twl6040",
837	},
838	.probe		= twl6040_probe,
839	.remove		= twl6040_remove,
840	.id_table	= twl6040_i2c_id,
841};
842
843module_i2c_driver(twl6040_driver);
844
845MODULE_DESCRIPTION("TWL6040 MFD");
846MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>");
847MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>");
848MODULE_LICENSE("GPL");