twl6040.c 20.8 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-only
2 3 4 5 6 7 8 9 10 11 12 13 14 15
/*
 * MFD driver for TWL6040 audio device
 *
 * Authors:	Misael Lopez Cruz <misael.lopez@ti.com>
 *		Jorge Eduardo Candelaria <jorge.candelaria@ti.com>
 *		Peter Ujfalusi <peter.ujfalusi@ti.com>
 *
 * Copyright:	(C) 2011 Texas Instruments, Inc.
 */

#include <linux/module.h>
#include <linux/types.h>
#include <linux/slab.h>
#include <linux/kernel.h>
16
#include <linux/err.h>
17
#include <linux/platform_device.h>
18 19 20 21
#include <linux/of.h>
#include <linux/of_irq.h>
#include <linux/of_gpio.h>
#include <linux/of_platform.h>
22 23
#include <linux/gpio.h>
#include <linux/delay.h>
24 25
#include <linux/i2c.h>
#include <linux/regmap.h>
26 27
#include <linux/mfd/core.h>
#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

33
static const struct reg_default twl6040_defaults[] = {
34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74
	{ 0x01, 0x4B }, /* REG_ASICID	(ro) */
	{ 0x02, 0x00 }, /* REG_ASICREV	(ro) */
	{ 0x03, 0x00 }, /* REG_INTID	*/
	{ 0x04, 0x00 }, /* REG_INTMR	*/
	{ 0x05, 0x00 }, /* REG_NCPCTRL	*/
	{ 0x06, 0x00 }, /* REG_LDOCTL	*/
	{ 0x07, 0x60 }, /* REG_HPPLLCTL	*/
	{ 0x08, 0x00 }, /* REG_LPPLLCTL	*/
	{ 0x09, 0x4A }, /* REG_LPPLLDIV	*/
	{ 0x0A, 0x00 }, /* REG_AMICBCTL	*/
	{ 0x0B, 0x00 }, /* REG_DMICBCTL	*/
	{ 0x0C, 0x00 }, /* REG_MICLCTL	*/
	{ 0x0D, 0x00 }, /* REG_MICRCTL	*/
	{ 0x0E, 0x00 }, /* REG_MICGAIN	*/
	{ 0x0F, 0x1B }, /* REG_LINEGAIN	*/
	{ 0x10, 0x00 }, /* REG_HSLCTL	*/
	{ 0x11, 0x00 }, /* REG_HSRCTL	*/
	{ 0x12, 0x00 }, /* REG_HSGAIN	*/
	{ 0x13, 0x00 }, /* REG_EARCTL	*/
	{ 0x14, 0x00 }, /* REG_HFLCTL	*/
	{ 0x15, 0x00 }, /* REG_HFLGAIN	*/
	{ 0x16, 0x00 }, /* REG_HFRCTL	*/
	{ 0x17, 0x00 }, /* REG_HFRGAIN	*/
	{ 0x18, 0x00 }, /* REG_VIBCTLL	*/
	{ 0x19, 0x00 }, /* REG_VIBDATL	*/
	{ 0x1A, 0x00 }, /* REG_VIBCTLR	*/
	{ 0x1B, 0x00 }, /* REG_VIBDATR	*/
	{ 0x1C, 0x00 }, /* REG_HKCTL1	*/
	{ 0x1D, 0x00 }, /* REG_HKCTL2	*/
	{ 0x1E, 0x00 }, /* REG_GPOCTL	*/
	{ 0x1F, 0x00 }, /* REG_ALB	*/
	{ 0x20, 0x00 }, /* REG_DLB	*/
	/* 0x28, REG_TRIM1 */
	/* 0x29, REG_TRIM2 */
	/* 0x2A, REG_TRIM3 */
	/* 0x2B, REG_HSOTRIM */
	/* 0x2C, REG_HFOTRIM */
	{ 0x2D, 0x08 }, /* REG_ACCCTL	*/
	{ 0x2E, 0x00 }, /* REG_STATUS	(ro) */
};

75
static struct reg_sequence twl6040_patch[] = {
76 77 78 79 80 81 82
	/*
	 * Select I2C bus access to dual access registers
	 * Interrupt register is cleared on read
	 * Select fast mode for i2c (400KHz)
	 */
	{ TWL6040_REG_ACCCTL,
		TWL6040_I2CSEL | TWL6040_INTCLRMODE | TWL6040_I2CMODE(1) },
83 84 85
};


86
static bool twl6040_has_vibra(struct device_node *parent)
87
{
88 89 90 91 92
	struct device_node *node;

	node = of_get_child_by_name(parent, "vibra");
	if (node) {
		of_node_put(node);
93
		return true;
94 95
	}

96 97 98
	return false;
}

99 100 101
int twl6040_reg_read(struct twl6040 *twl6040, unsigned int reg)
{
	int ret;
102
	unsigned int val;
103

104 105 106
	ret = regmap_read(twl6040->regmap, reg, &val);
	if (ret < 0)
		return ret;
107 108 109 110 111 112 113 114 115

	return val;
}
EXPORT_SYMBOL(twl6040_reg_read);

int twl6040_reg_write(struct twl6040 *twl6040, unsigned int reg, u8 val)
{
	int ret;

116
	ret = regmap_write(twl6040->regmap, reg, val);
117 118 119 120 121 122 123

	return ret;
}
EXPORT_SYMBOL(twl6040_reg_write);

int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
{
124
	return regmap_update_bits(twl6040->regmap, reg, mask, mask);
125 126 127 128 129
}
EXPORT_SYMBOL(twl6040_set_bits);

int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask)
{
130
	return regmap_update_bits(twl6040->regmap, reg, mask, 0);
131 132 133 134
}
EXPORT_SYMBOL(twl6040_clear_bits);

/* twl6040 codec manual power-up sequence */
135
static int twl6040_power_up_manual(struct twl6040 *twl6040)
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
{
	u8 ldoctl, ncpctl, lppllctl;
	int ret;

	/* enable high-side LDO, reference system and internal oscillator */
	ldoctl = TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA;
	ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
	if (ret)
		return ret;
	usleep_range(10000, 10500);

	/* enable negative charge pump */
	ncpctl = TWL6040_NCPENA;
	ret = twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
	if (ret)
		goto ncp_err;
	usleep_range(1000, 1500);

	/* enable low-side LDO */
	ldoctl |= TWL6040_LSLDOENA;
	ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
	if (ret)
		goto lsldo_err;
	usleep_range(1000, 1500);

	/* enable low-power PLL */
	lppllctl = TWL6040_LPLLENA;
	ret = twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
	if (ret)
		goto lppll_err;
	usleep_range(5000, 5500);

	/* disable internal oscillator */
	ldoctl &= ~TWL6040_OSCENA;
	ret = twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
	if (ret)
		goto osc_err;

	return 0;

osc_err:
	lppllctl &= ~TWL6040_LPLLENA;
	twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);
lppll_err:
	ldoctl &= ~TWL6040_LSLDOENA;
	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
lsldo_err:
	ncpctl &= ~TWL6040_NCPENA;
	twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);
ncp_err:
	ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);

189
	dev_err(twl6040->dev, "manual power-up failed\n");
190 191 192 193
	return ret;
}

/* twl6040 manual power-down sequence */
194
static void twl6040_power_down_manual(struct twl6040 *twl6040)
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223
{
	u8 ncpctl, ldoctl, lppllctl;

	ncpctl = twl6040_reg_read(twl6040, TWL6040_REG_NCPCTL);
	ldoctl = twl6040_reg_read(twl6040, TWL6040_REG_LDOCTL);
	lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);

	/* enable internal oscillator */
	ldoctl |= TWL6040_OSCENA;
	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
	usleep_range(1000, 1500);

	/* disable low-power PLL */
	lppllctl &= ~TWL6040_LPLLENA;
	twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl);

	/* disable low-side LDO */
	ldoctl &= ~TWL6040_LSLDOENA;
	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);

	/* disable negative charge pump */
	ncpctl &= ~TWL6040_NCPENA;
	twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl);

	/* disable high-side LDO, reference system and internal oscillator */
	ldoctl &= ~(TWL6040_HSLDOENA | TWL6040_REFENA | TWL6040_OSCENA);
	twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl);
}

224
static irqreturn_t twl6040_readyint_handler(int irq, void *data)
225 226 227
{
	struct twl6040 *twl6040 = data;

228
	complete(&twl6040->ready);
229

230 231
	return IRQ_HANDLED;
}
232

233 234 235 236 237 238 239 240 241 242 243 244
static irqreturn_t twl6040_thint_handler(int irq, void *data)
{
	struct twl6040 *twl6040 = data;
	u8 status;

	status = twl6040_reg_read(twl6040, TWL6040_REG_STATUS);
	if (status & TWL6040_TSHUTDET) {
		dev_warn(twl6040->dev, "Thermal shutdown, powering-off");
		twl6040_power(twl6040, 0);
	} else {
		dev_warn(twl6040->dev, "Leaving thermal shutdown, powering-on");
		twl6040_power(twl6040, 1);
245 246 247 248 249
	}

	return IRQ_HANDLED;
}

250
static int twl6040_power_up_automatic(struct twl6040 *twl6040)
251 252
{
	int time_left;
253 254

	gpio_set_value(twl6040->audpwron, 1);
255 256 257 258

	time_left = wait_for_completion_timeout(&twl6040->ready,
						msecs_to_jiffies(144));
	if (!time_left) {
259 260 261
		u8 intid;

		dev_warn(twl6040->dev, "timeout waiting for READYINT\n");
262 263
		intid = twl6040_reg_read(twl6040, TWL6040_REG_INTID);
		if (!(intid & TWL6040_READYINT)) {
264 265
			dev_err(twl6040->dev, "automatic power-up failed\n");
			gpio_set_value(twl6040->audpwron, 0);
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
			return -ETIMEDOUT;
		}
	}

	return 0;
}

int twl6040_power(struct twl6040 *twl6040, int on)
{
	int ret = 0;

	mutex_lock(&twl6040->mutex);

	if (on) {
		/* already powered-up */
		if (twl6040->power_count++)
			goto out;

284 285 286 287 288
		ret = clk_prepare_enable(twl6040->clk32k);
		if (ret) {
			twl6040->power_count = 0;
			goto out;
		}
289

290 291 292
		/* Allow writes to the chip */
		regcache_cache_only(twl6040->regmap, false);

293 294 295
		if (gpio_is_valid(twl6040->audpwron)) {
			/* use automatic power-up sequence */
			ret = twl6040_power_up_automatic(twl6040);
296
			if (ret) {
297
				clk_disable_unprepare(twl6040->clk32k);
298 299 300 301 302
				twl6040->power_count = 0;
				goto out;
			}
		} else {
			/* use manual power-up sequence */
303
			ret = twl6040_power_up_manual(twl6040);
304
			if (ret) {
305
				clk_disable_unprepare(twl6040->clk32k);
306 307 308 309
				twl6040->power_count = 0;
				goto out;
			}
		}
310

311 312 313 314 315 316
		/*
		 * Register access can produce errors after power-up unless we
		 * wait at least 8ms based on measurements on duovero.
		 */
		usleep_range(10000, 12000);

317
		/* Sync with the HW */
318 319 320 321 322 323
		ret = regcache_sync(twl6040->regmap);
		if (ret) {
			dev_err(twl6040->dev, "Failed to sync with the HW: %i\n",
				ret);
			goto out;
		}
324

325 326
		/* Default PLL configuration after power up */
		twl6040->pll = TWL6040_SYSCLK_SEL_LPPLL;
327
		twl6040->sysclk_rate = 19200000;
328 329 330
	} else {
		/* already powered-down */
		if (!twl6040->power_count) {
331
			dev_err(twl6040->dev,
332 333 334 335 336 337 338 339
				"device is already powered-off\n");
			ret = -EPERM;
			goto out;
		}

		if (--twl6040->power_count)
			goto out;

340
		if (gpio_is_valid(twl6040->audpwron)) {
341
			/* use AUDPWRON line */
342
			gpio_set_value(twl6040->audpwron, 0);
343 344 345 346 347

			/* power-down sequence latency */
			usleep_range(500, 700);
		} else {
			/* use manual power-down sequence */
348
			twl6040_power_down_manual(twl6040);
349
		}
350 351 352 353 354

		/* Set regmap to cache only and mark it as dirty */
		regcache_cache_only(twl6040->regmap, true);
		regcache_mark_dirty(twl6040->regmap);

355 356 357 358 359 360
		twl6040->sysclk_rate = 0;

		if (twl6040->pll == TWL6040_SYSCLK_SEL_HPPLL) {
			clk_disable_unprepare(twl6040->mclk);
			twl6040->mclk_rate = 0;
		}
361 362

		clk_disable_unprepare(twl6040->clk32k);
363 364 365 366 367 368 369 370
	}

out:
	mutex_unlock(&twl6040->mutex);
	return ret;
}
EXPORT_SYMBOL(twl6040_power);

371
int twl6040_set_pll(struct twl6040 *twl6040, int pll_id,
372 373 374 375 376 377 378 379 380 381
		    unsigned int freq_in, unsigned int freq_out)
{
	u8 hppllctl, lppllctl;
	int ret = 0;

	mutex_lock(&twl6040->mutex);

	hppllctl = twl6040_reg_read(twl6040, TWL6040_REG_HPPLLCTL);
	lppllctl = twl6040_reg_read(twl6040, TWL6040_REG_LPPLLCTL);

382 383
	/* Force full reconfiguration when switching between PLL */
	if (pll_id != twl6040->pll) {
384 385
		twl6040->sysclk_rate = 0;
		twl6040->mclk_rate = 0;
386 387
	}

388 389
	switch (pll_id) {
	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 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408
			switch (freq_out) {
			case 17640000:
				lppllctl |= TWL6040_LPLLFIN;
				break;
			case 19200000:
				lppllctl &= ~TWL6040_LPLLFIN;
				break;
			default:
				dev_err(twl6040->dev,
					"freq_out %d not supported\n",
					freq_out);
				ret = -EINVAL;
				goto pll_out;
			}
			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
					  lppllctl);
409
		}
410 411 412 413

		/* The PLL in use has not been change, we can exit */
		if (twl6040->pll == pll_id)
			break;
414 415 416 417 418 419 420 421 422 423 424 425 426 427 428

		switch (freq_in) {
		case 32768:
			lppllctl |= TWL6040_LPLLENA;
			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
					  lppllctl);
			mdelay(5);
			lppllctl &= ~TWL6040_HPLLSEL;
			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
					  lppllctl);
			hppllctl &= ~TWL6040_HPLLENA;
			twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
					  hppllctl);
			break;
		default:
429
			dev_err(twl6040->dev,
430 431 432 433
				"freq_in %d not supported\n", freq_in);
			ret = -EINVAL;
			goto pll_out;
		}
434 435

		clk_disable_unprepare(twl6040->mclk);
436
		break;
437
	case TWL6040_SYSCLK_SEL_HPPLL:
438 439
		/* high-performance PLL can provide only 19.2 MHz */
		if (freq_out != 19200000) {
440
			dev_err(twl6040->dev,
441 442 443 444 445
				"freq_out %d not supported\n", freq_out);
			ret = -EINVAL;
			goto pll_out;
		}

446
		if (twl6040->mclk_rate != freq_in) {
447 448 449 450 451 452 453 454 455
			hppllctl &= ~TWL6040_MCLK_MSK;

			switch (freq_in) {
			case 12000000:
				/* PLL enabled, active mode */
				hppllctl |= TWL6040_MCLK_12000KHZ |
					    TWL6040_HPLLENA;
				break;
			case 19200000:
456 457 458
				/* PLL enabled, bypass mode */
				hppllctl |= TWL6040_MCLK_19200KHZ |
					    TWL6040_HPLLBP | TWL6040_HPLLENA;
459 460 461 462 463 464 465
				break;
			case 26000000:
				/* PLL enabled, active mode */
				hppllctl |= TWL6040_MCLK_26000KHZ |
					    TWL6040_HPLLENA;
				break;
			case 38400000:
466
				/* PLL enabled, bypass mode */
467
				hppllctl |= TWL6040_MCLK_38400KHZ |
468
					    TWL6040_HPLLBP | TWL6040_HPLLENA;
469 470 471 472 473 474 475
				break;
			default:
				dev_err(twl6040->dev,
					"freq_in %d not supported\n", freq_in);
				ret = -EINVAL;
				goto pll_out;
			}
476

477 478 479
			/* When switching to HPPLL, enable the mclk first */
			if (pll_id != twl6040->pll)
				clk_prepare_enable(twl6040->mclk);
480
			/*
481 482
			 * enable clock slicer to ensure input waveform is
			 * square
483
			 */
484
			hppllctl |= TWL6040_HPLLSQRENA;
485

486 487 488 489 490 491 492 493 494
			twl6040_reg_write(twl6040, TWL6040_REG_HPPLLCTL,
					  hppllctl);
			usleep_range(500, 700);
			lppllctl |= TWL6040_HPLLSEL;
			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
					  lppllctl);
			lppllctl &= ~TWL6040_LPLLENA;
			twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL,
					  lppllctl);
495 496

			twl6040->mclk_rate = freq_in;
497
		}
498 499
		break;
	default:
500
		dev_err(twl6040->dev, "unknown pll id %d\n", pll_id);
501 502 503 504
		ret = -EINVAL;
		goto pll_out;
	}

505
	twl6040->sysclk_rate = freq_out;
506
	twl6040->pll = pll_id;
507 508 509 510 511 512 513

pll_out:
	mutex_unlock(&twl6040->mutex);
	return ret;
}
EXPORT_SYMBOL(twl6040_set_pll);

514
int twl6040_get_pll(struct twl6040 *twl6040)
515
{
516 517 518 519
	if (twl6040->power_count)
		return twl6040->pll;
	else
		return -ENODEV;
520 521 522 523 524
}
EXPORT_SYMBOL(twl6040_get_pll);

unsigned int twl6040_get_sysclk(struct twl6040 *twl6040)
{
525
	return twl6040->sysclk_rate;
526 527 528
}
EXPORT_SYMBOL(twl6040_get_sysclk);

529 530 531
/* Get the combined status of the vibra control register */
int twl6040_get_vibralr_status(struct twl6040 *twl6040)
{
532 533
	unsigned int reg;
	int ret;
534 535
	u8 status;

536 537 538 539 540 541 542 543 544 545
	ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLL, &reg);
	if (ret != 0)
		return ret;
	status = reg;

	ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLR, &reg);
	if (ret != 0)
		return ret;
	status |= reg;

546 547 548 549 550 551
	status &= (TWL6040_VIBENA | TWL6040_VIBSEL);

	return status;
}
EXPORT_SYMBOL(twl6040_get_vibralr_status);

552 553 554 555 556 557 558 559 560 561 562 563
static struct resource twl6040_vibra_rsrc[] = {
	{
		.flags = IORESOURCE_IRQ,
	},
};

static struct resource twl6040_codec_rsrc[] = {
	{
		.flags = IORESOURCE_IRQ,
	},
};

564
static bool twl6040_readable_reg(struct device *dev, unsigned int reg)
565
{
566 567 568 569 570 571
	/* Register 0 is not readable */
	if (!reg)
		return false;
	return true;
}

572 573 574
static bool twl6040_volatile_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592
	case TWL6040_REG_ASICID:
	case TWL6040_REG_ASICREV:
	case TWL6040_REG_INTID:
	case TWL6040_REG_LPPLLCTL:
	case TWL6040_REG_HPPLLCTL:
	case TWL6040_REG_STATUS:
		return true;
	default:
		return false;
	}
}

static bool twl6040_writeable_reg(struct device *dev, unsigned int reg)
{
	switch (reg) {
	case TWL6040_REG_ASICID:
	case TWL6040_REG_ASICREV:
	case TWL6040_REG_STATUS:
593 594 595 596 597 598
		return false;
	default:
		return true;
	}
}

599
static const struct regmap_config twl6040_regmap_config = {
600 601
	.reg_bits = 8,
	.val_bits = 8,
602 603 604 605

	.reg_defaults = twl6040_defaults,
	.num_reg_defaults = ARRAY_SIZE(twl6040_defaults),

606 607 608
	.max_register = TWL6040_REG_STATUS, /* 0x2e */

	.readable_reg = twl6040_readable_reg,
609
	.volatile_reg = twl6040_volatile_reg,
610
	.writeable_reg = twl6040_writeable_reg,
611 612

	.cache_type = REGCACHE_RBTREE,
613 614
	.use_single_read = true,
	.use_single_write = true,
615 616
};

617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635
static const struct regmap_irq twl6040_irqs[] = {
	{ .reg_offset = 0, .mask = TWL6040_THINT, },
	{ .reg_offset = 0, .mask = TWL6040_PLUGINT | TWL6040_UNPLUGINT, },
	{ .reg_offset = 0, .mask = TWL6040_HOOKINT, },
	{ .reg_offset = 0, .mask = TWL6040_HFINT, },
	{ .reg_offset = 0, .mask = TWL6040_VIBINT, },
	{ .reg_offset = 0, .mask = TWL6040_READYINT, },
};

static struct regmap_irq_chip twl6040_irq_chip = {
	.name = "twl6040",
	.irqs = twl6040_irqs,
	.num_irqs = ARRAY_SIZE(twl6040_irqs),

	.num_regs = 1,
	.status_base = TWL6040_REG_INTID,
	.mask_base = TWL6040_REG_INTMR,
};

636 637
static int twl6040_probe(struct i2c_client *client,
			 const struct i2c_device_id *id)
638
{
639
	struct device_node *node = client->dev.of_node;
640 641
	struct twl6040 *twl6040;
	struct mfd_cell *cell = NULL;
642
	int irq, ret, children = 0;
643

644 645
	if (!node) {
		dev_err(&client->dev, "of node is missing\n");
646 647 648
		return -EINVAL;
	}

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 653 654
		return -EINVAL;
	}

655 656
	twl6040 = devm_kzalloc(&client->dev, sizeof(struct twl6040),
			       GFP_KERNEL);
657 658
	if (!twl6040)
		return -ENOMEM;
659

660
	twl6040->regmap = devm_regmap_init_i2c(client, &twl6040_regmap_config);
661 662
	if (IS_ERR(twl6040->regmap))
		return PTR_ERR(twl6040->regmap);
663

664
	i2c_set_clientdata(client, twl6040);
665

666 667
	twl6040->clk32k = devm_clk_get(&client->dev, "clk32k");
	if (IS_ERR(twl6040->clk32k)) {
668 669
		if (PTR_ERR(twl6040->clk32k) == -EPROBE_DEFER)
			return -EPROBE_DEFER;
670
		dev_dbg(&client->dev, "clk32k is not handled\n");
671 672 673
		twl6040->clk32k = NULL;
	}

674 675 676 677 678 679 680 681
	twl6040->mclk = devm_clk_get(&client->dev, "mclk");
	if (IS_ERR(twl6040->mclk)) {
		if (PTR_ERR(twl6040->mclk) == -EPROBE_DEFER)
			return -EPROBE_DEFER;
		dev_dbg(&client->dev, "mclk is not handled\n");
		twl6040->mclk = NULL;
	}

682 683
	twl6040->supplies[0].supply = "vio";
	twl6040->supplies[1].supply = "v2v1";
684
	ret = devm_regulator_bulk_get(&client->dev, TWL6040_NUM_SUPPLIES,
685
				      twl6040->supplies);
686 687
	if (ret != 0) {
		dev_err(&client->dev, "Failed to get supplies: %d\n", ret);
688
		return ret;
689 690 691 692 693
	}

	ret = regulator_bulk_enable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
	if (ret != 0) {
		dev_err(&client->dev, "Failed to enable supplies: %d\n", ret);
694
		return ret;
695 696
	}

697 698
	twl6040->dev = &client->dev;
	twl6040->irq = client->irq;
699 700 701 702

	mutex_init(&twl6040->mutex);
	init_completion(&twl6040->ready);

703 704 705
	regmap_register_patch(twl6040->regmap, twl6040_patch,
			      ARRAY_SIZE(twl6040_patch));

706
	twl6040->rev = twl6040_reg_read(twl6040, TWL6040_REG_ASICREV);
707 708 709
	if (twl6040->rev < 0) {
		dev_err(&client->dev, "Failed to read revision register: %d\n",
			twl6040->rev);
710
		ret = twl6040->rev;
711 712
		goto gpio_err;
	}
713

714
	/* ERRATA: Automatic power-up is not possible in ES1.0 */
715 716 717 718
	if (twl6040_get_revid(twl6040) > TWL6040_REV_ES1_0)
		twl6040->audpwron = of_get_named_gpio(node,
						      "ti,audpwron-gpio", 0);
	else
719 720
		twl6040->audpwron = -EINVAL;

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 728

		/* Clear any pending interrupt */
		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 743
					twl6040_readyint_handler, IRQF_ONESHOT,
					"twl6040_irq_ready", twl6040);
744
	if (ret) {
745 746 747 748
		dev_err(twl6040->dev, "READY IRQ request failed: %d\n", ret);
		goto readyirq_err;
	}

749
	ret = devm_request_threaded_irq(twl6040->dev, twl6040->irq_th, NULL,
750 751
					twl6040_thint_handler, IRQF_ONESHOT,
					"twl6040_irq_th", twl6040);
752 753
	if (ret) {
		dev_err(twl6040->dev, "Thermal IRQ request failed: %d\n", ret);
754
		goto readyirq_err;
755 756
	}

757 758 759 760
	/*
	 * The main functionality of twl6040 to provide audio on OMAP4+ systems.
	 * We can add the ASoC codec child whenever this driver has been loaded.
	 */
761
	irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_PLUG);
762 763 764 765 766 767 768
	cell = &twl6040->cells[children];
	cell->name = "twl6040-codec";
	twl6040_codec_rsrc[0].start = irq;
	twl6040_codec_rsrc[0].end = irq;
	cell->resources = twl6040_codec_rsrc;
	cell->num_resources = ARRAY_SIZE(twl6040_codec_rsrc);
	children++;
769

770 771
	/* Vibra input driver support */
	if (twl6040_has_vibra(node)) {
772
		irq = regmap_irq_get_virq(twl6040->irq_data, TWL6040_IRQ_VIB);
773

774 775
		cell = &twl6040->cells[children];
		cell->name = "twl6040-vibra";
776 777 778 779
		twl6040_vibra_rsrc[0].start = irq;
		twl6040_vibra_rsrc[0].end = irq;
		cell->resources = twl6040_vibra_rsrc;
		cell->num_resources = ARRAY_SIZE(twl6040_vibra_rsrc);
780 781 782
		children++;
	}

783 784 785 786
	/* GPO support */
	cell = &twl6040->cells[children];
	cell->name = "twl6040-gpo";
	children++;
787

788 789 790 791 792
	/* PDM clock support  */
	cell = &twl6040->cells[children];
	cell->name = "twl6040-pdmclk";
	children++;

793 794 795 796
	/* The chip is powered down so mark regmap to cache only and dirty */
	regcache_cache_only(twl6040->regmap, true);
	regcache_mark_dirty(twl6040->regmap);

797
	ret = mfd_add_devices(&client->dev, -1, twl6040->cells, children,
798
			      NULL, 0, NULL);
799
	if (ret)
800
		goto readyirq_err;
801 802 803

	return 0;

804
readyirq_err:
805
	regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
806 807
gpio_err:
	regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);
808 809 810
	return ret;
}

811
static int twl6040_remove(struct i2c_client *client)
812
{
813
	struct twl6040 *twl6040 = i2c_get_clientdata(client);
814 815 816 817

	if (twl6040->power_count)
		twl6040_power(twl6040, 0);

818
	regmap_del_irq_chip(twl6040->irq, twl6040->irq_data);
819

820
	mfd_remove_devices(&client->dev);
821

822 823
	regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies);

824 825 826
	return 0;
}

827 828
static const struct i2c_device_id twl6040_i2c_id[] = {
	{ "twl6040", 0, },
829
	{ "twl6041", 0, },
830 831 832 833 834 835 836 837
	{ },
};
MODULE_DEVICE_TABLE(i2c, twl6040_i2c_id);

static struct i2c_driver twl6040_driver = {
	.driver = {
		.name = "twl6040",
	},
838
	.probe		= twl6040_probe,
839
	.remove		= twl6040_remove,
840
	.id_table	= twl6040_i2c_id,
841 842
};

843
module_i2c_driver(twl6040_driver);
844 845 846 847 848

MODULE_DESCRIPTION("TWL6040 MFD");
MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>");
MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>");
MODULE_LICENSE("GPL");