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 33 static 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 75 static 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 86 static 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 99 int 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 } 110 EXPORT_SYMBOL(twl6040_reg_read); 111 112 int 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 } 120 EXPORT_SYMBOL(twl6040_reg_write); 121 122 int twl6040_set_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask) 123 { 124 return regmap_update_bits(twl6040->regmap, reg, mask, mask); 125 } 126 EXPORT_SYMBOL(twl6040_set_bits); 127 128 int twl6040_clear_bits(struct twl6040 *twl6040, unsigned int reg, u8 mask) 129 { 130 return regmap_update_bits(twl6040->regmap, reg, mask, 0); 131 } 132 EXPORT_SYMBOL(twl6040_clear_bits); 133 134 /* twl6040 codec manual power-up sequence */ 135 static 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 176 osc_err: 177 lppllctl &= ~TWL6040_LPLLENA; 178 twl6040_reg_write(twl6040, TWL6040_REG_LPPLLCTL, lppllctl); 179 lppll_err: 180 ldoctl &= ~TWL6040_LSLDOENA; 181 twl6040_reg_write(twl6040, TWL6040_REG_LDOCTL, ldoctl); 182 lsldo_err: 183 ncpctl &= ~TWL6040_NCPENA; 184 twl6040_reg_write(twl6040, TWL6040_REG_NCPCTL, ncpctl); 185 ncp_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 */ 194 static 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 224 static 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 233 static 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 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 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 273 int 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 365 out: 366 mutex_unlock(&twl6040->mutex); 367 return ret; 368 } 369 EXPORT_SYMBOL(twl6040_power); 370 371 int 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 508 pll_out: 509 mutex_unlock(&twl6040->mutex); 510 return ret; 511 } 512 EXPORT_SYMBOL(twl6040_set_pll); 513 514 int twl6040_get_pll(struct twl6040 *twl6040) 515 { 516 if (twl6040->power_count) 517 return twl6040->pll; 518 else 519 return -ENODEV; 520 } 521 EXPORT_SYMBOL(twl6040_get_pll); 522 523 unsigned int twl6040_get_sysclk(struct twl6040 *twl6040) 524 { 525 return twl6040->sysclk_rate; 526 } 527 EXPORT_SYMBOL(twl6040_get_sysclk); 528 529 /* Get the combined status of the vibra control register */ 530 int 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, ®); 537 if (ret != 0) 538 return ret; 539 status = reg; 540 541 ret = regmap_read(twl6040->regmap, TWL6040_REG_VIBCTLR, ®); 542 if (ret != 0) 543 return ret; 544 status |= reg; 545 546 status &= (TWL6040_VIBENA | TWL6040_VIBSEL); 547 548 return status; 549 } 550 EXPORT_SYMBOL(twl6040_get_vibralr_status); 551 552 static struct resource twl6040_vibra_rsrc[] = { 553 { 554 .flags = IORESOURCE_IRQ, 555 }, 556 }; 557 558 static struct resource twl6040_codec_rsrc[] = { 559 { 560 .flags = IORESOURCE_IRQ, 561 }, 562 }; 563 564 static 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 572 static 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 587 static 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 599 static 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 617 static 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 626 static 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 636 static 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 804 readyirq_err: 805 regmap_del_irq_chip(twl6040->irq, twl6040->irq_data); 806 gpio_err: 807 regulator_bulk_disable(TWL6040_NUM_SUPPLIES, twl6040->supplies); 808 return ret; 809 } 810 811 static void 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 825 static const struct i2c_device_id twl6040_i2c_id[] = { 826 { "twl6040", 0, }, 827 { "twl6041", 0, }, 828 { }, 829 }; 830 MODULE_DEVICE_TABLE(i2c, twl6040_i2c_id); 831 832 static struct i2c_driver twl6040_driver = { 833 .driver = { 834 .name = "twl6040", 835 }, 836 .probe = twl6040_probe, 837 .remove = twl6040_remove, 838 .id_table = twl6040_i2c_id, 839 }; 840 841 module_i2c_driver(twl6040_driver); 842 843 MODULE_DESCRIPTION("TWL6040 MFD"); 844 MODULE_AUTHOR("Misael Lopez Cruz <misael.lopez@ti.com>"); 845 MODULE_AUTHOR("Jorge Eduardo Candelaria <jorge.candelaria@ti.com>"); 846 MODULE_LICENSE("GPL"); 847