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