1 /* 2 * ALSA SoC TWL6040 codec driver 3 * 4 * Author: Misael Lopez Cruz <x0052729@ti.com> 5 * 6 * This program is free software; you can redistribute it and/or 7 * modify it under the terms of the GNU General Public License 8 * version 2 as published by the Free Software Foundation. 9 * 10 * This program is distributed in the hope that it will be useful, but 11 * WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 13 * General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 18 * 02110-1301 USA 19 * 20 */ 21 22 #include <linux/module.h> 23 #include <linux/moduleparam.h> 24 #include <linux/init.h> 25 #include <linux/delay.h> 26 #include <linux/pm.h> 27 #include <linux/i2c.h> 28 #include <linux/gpio.h> 29 #include <linux/platform_device.h> 30 #include <linux/slab.h> 31 #include <linux/i2c/twl.h> 32 33 #include <sound/core.h> 34 #include <sound/pcm.h> 35 #include <sound/pcm_params.h> 36 #include <sound/soc.h> 37 #include <sound/initval.h> 38 #include <sound/tlv.h> 39 40 #include "twl6040.h" 41 42 #define TWL6040_RATES SNDRV_PCM_RATE_8000_96000 43 #define TWL6040_FORMATS (SNDRV_PCM_FMTBIT_S32_LE) 44 45 #define TWL6040_OUTHS_0dB 0x00 46 #define TWL6040_OUTHS_M30dB 0x0F 47 #define TWL6040_OUTHF_0dB 0x03 48 #define TWL6040_OUTHF_M52dB 0x1D 49 50 #define TWL6040_RAMP_NONE 0 51 #define TWL6040_RAMP_UP 1 52 #define TWL6040_RAMP_DOWN 2 53 54 #define TWL6040_HSL_VOL_MASK 0x0F 55 #define TWL6040_HSL_VOL_SHIFT 0 56 #define TWL6040_HSR_VOL_MASK 0xF0 57 #define TWL6040_HSR_VOL_SHIFT 4 58 #define TWL6040_HF_VOL_MASK 0x1F 59 #define TWL6040_HF_VOL_SHIFT 0 60 61 struct twl6040_output { 62 u16 active; 63 u16 left_vol; 64 u16 right_vol; 65 u16 left_step; 66 u16 right_step; 67 unsigned int step_delay; 68 u16 ramp; 69 u16 mute; 70 struct completion ramp_done; 71 }; 72 73 struct twl6040_jack_data { 74 struct snd_soc_jack *jack; 75 int report; 76 }; 77 78 /* codec private data */ 79 struct twl6040_data { 80 int audpwron; 81 int naudint; 82 int codec_powered; 83 int pll; 84 int non_lp; 85 unsigned int sysclk; 86 struct snd_pcm_hw_constraint_list *sysclk_constraints; 87 struct completion ready; 88 struct twl6040_jack_data hs_jack; 89 struct snd_soc_codec *codec; 90 struct workqueue_struct *workqueue; 91 struct delayed_work delayed_work; 92 struct mutex mutex; 93 struct twl6040_output headset; 94 struct twl6040_output handsfree; 95 struct workqueue_struct *hf_workqueue; 96 struct workqueue_struct *hs_workqueue; 97 struct delayed_work hs_delayed_work; 98 struct delayed_work hf_delayed_work; 99 }; 100 101 /* 102 * twl6040 register cache & default register settings 103 */ 104 static const u8 twl6040_reg[TWL6040_CACHEREGNUM] = { 105 0x00, /* not used 0x00 */ 106 0x4B, /* TWL6040_ASICID (ro) 0x01 */ 107 0x00, /* TWL6040_ASICREV (ro) 0x02 */ 108 0x00, /* TWL6040_INTID 0x03 */ 109 0x00, /* TWL6040_INTMR 0x04 */ 110 0x00, /* TWL6040_NCPCTRL 0x05 */ 111 0x00, /* TWL6040_LDOCTL 0x06 */ 112 0x60, /* TWL6040_HPPLLCTL 0x07 */ 113 0x00, /* TWL6040_LPPLLCTL 0x08 */ 114 0x4A, /* TWL6040_LPPLLDIV 0x09 */ 115 0x00, /* TWL6040_AMICBCTL 0x0A */ 116 0x00, /* TWL6040_DMICBCTL 0x0B */ 117 0x18, /* TWL6040_MICLCTL 0x0C - No input selected on Left Mic */ 118 0x18, /* TWL6040_MICRCTL 0x0D - No input selected on Right Mic */ 119 0x00, /* TWL6040_MICGAIN 0x0E */ 120 0x1B, /* TWL6040_LINEGAIN 0x0F */ 121 0x00, /* TWL6040_HSLCTL 0x10 */ 122 0x00, /* TWL6040_HSRCTL 0x11 */ 123 0x00, /* TWL6040_HSGAIN 0x12 */ 124 0x00, /* TWL6040_EARCTL 0x13 */ 125 0x00, /* TWL6040_HFLCTL 0x14 */ 126 0x00, /* TWL6040_HFLGAIN 0x15 */ 127 0x00, /* TWL6040_HFRCTL 0x16 */ 128 0x00, /* TWL6040_HFRGAIN 0x17 */ 129 0x00, /* TWL6040_VIBCTLL 0x18 */ 130 0x00, /* TWL6040_VIBDATL 0x19 */ 131 0x00, /* TWL6040_VIBCTLR 0x1A */ 132 0x00, /* TWL6040_VIBDATR 0x1B */ 133 0x00, /* TWL6040_HKCTL1 0x1C */ 134 0x00, /* TWL6040_HKCTL2 0x1D */ 135 0x00, /* TWL6040_GPOCTL 0x1E */ 136 0x00, /* TWL6040_ALB 0x1F */ 137 0x00, /* TWL6040_DLB 0x20 */ 138 0x00, /* not used 0x21 */ 139 0x00, /* not used 0x22 */ 140 0x00, /* not used 0x23 */ 141 0x00, /* not used 0x24 */ 142 0x00, /* not used 0x25 */ 143 0x00, /* not used 0x26 */ 144 0x00, /* not used 0x27 */ 145 0x00, /* TWL6040_TRIM1 0x28 */ 146 0x00, /* TWL6040_TRIM2 0x29 */ 147 0x00, /* TWL6040_TRIM3 0x2A */ 148 0x00, /* TWL6040_HSOTRIM 0x2B */ 149 0x00, /* TWL6040_HFOTRIM 0x2C */ 150 0x09, /* TWL6040_ACCCTL 0x2D */ 151 0x00, /* TWL6040_STATUS (ro) 0x2E */ 152 }; 153 154 /* 155 * twl6040 vio/gnd registers: 156 * registers under vio/gnd supply can be accessed 157 * before the power-up sequence, after NRESPWRON goes high 158 */ 159 static const int twl6040_vio_reg[TWL6040_VIOREGNUM] = { 160 TWL6040_REG_ASICID, 161 TWL6040_REG_ASICREV, 162 TWL6040_REG_INTID, 163 TWL6040_REG_INTMR, 164 TWL6040_REG_NCPCTL, 165 TWL6040_REG_LDOCTL, 166 TWL6040_REG_AMICBCTL, 167 TWL6040_REG_DMICBCTL, 168 TWL6040_REG_HKCTL1, 169 TWL6040_REG_HKCTL2, 170 TWL6040_REG_GPOCTL, 171 TWL6040_REG_TRIM1, 172 TWL6040_REG_TRIM2, 173 TWL6040_REG_TRIM3, 174 TWL6040_REG_HSOTRIM, 175 TWL6040_REG_HFOTRIM, 176 TWL6040_REG_ACCCTL, 177 TWL6040_REG_STATUS, 178 }; 179 180 /* 181 * twl6040 vdd/vss registers: 182 * registers under vdd/vss supplies can only be accessed 183 * after the power-up sequence 184 */ 185 static const int twl6040_vdd_reg[TWL6040_VDDREGNUM] = { 186 TWL6040_REG_HPPLLCTL, 187 TWL6040_REG_LPPLLCTL, 188 TWL6040_REG_LPPLLDIV, 189 TWL6040_REG_MICLCTL, 190 TWL6040_REG_MICRCTL, 191 TWL6040_REG_MICGAIN, 192 TWL6040_REG_LINEGAIN, 193 TWL6040_REG_HSLCTL, 194 TWL6040_REG_HSRCTL, 195 TWL6040_REG_HSGAIN, 196 TWL6040_REG_EARCTL, 197 TWL6040_REG_HFLCTL, 198 TWL6040_REG_HFLGAIN, 199 TWL6040_REG_HFRCTL, 200 TWL6040_REG_HFRGAIN, 201 TWL6040_REG_VIBCTLL, 202 TWL6040_REG_VIBDATL, 203 TWL6040_REG_VIBCTLR, 204 TWL6040_REG_VIBDATR, 205 TWL6040_REG_ALB, 206 TWL6040_REG_DLB, 207 }; 208 209 /* 210 * read twl6040 register cache 211 */ 212 static inline unsigned int twl6040_read_reg_cache(struct snd_soc_codec *codec, 213 unsigned int reg) 214 { 215 u8 *cache = codec->reg_cache; 216 217 if (reg >= TWL6040_CACHEREGNUM) 218 return -EIO; 219 220 return cache[reg]; 221 } 222 223 /* 224 * write twl6040 register cache 225 */ 226 static inline void twl6040_write_reg_cache(struct snd_soc_codec *codec, 227 u8 reg, u8 value) 228 { 229 u8 *cache = codec->reg_cache; 230 231 if (reg >= TWL6040_CACHEREGNUM) 232 return; 233 cache[reg] = value; 234 } 235 236 /* 237 * read from twl6040 hardware register 238 */ 239 static int twl6040_read_reg_volatile(struct snd_soc_codec *codec, 240 unsigned int reg) 241 { 242 u8 value; 243 244 if (reg >= TWL6040_CACHEREGNUM) 245 return -EIO; 246 247 twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &value, reg); 248 twl6040_write_reg_cache(codec, reg, value); 249 250 return value; 251 } 252 253 /* 254 * write to the twl6040 register space 255 */ 256 static int twl6040_write(struct snd_soc_codec *codec, 257 unsigned int reg, unsigned int value) 258 { 259 if (reg >= TWL6040_CACHEREGNUM) 260 return -EIO; 261 262 twl6040_write_reg_cache(codec, reg, value); 263 return twl_i2c_write_u8(TWL_MODULE_AUDIO_VOICE, value, reg); 264 } 265 266 static void twl6040_init_vio_regs(struct snd_soc_codec *codec) 267 { 268 u8 *cache = codec->reg_cache; 269 int reg, i; 270 271 /* allow registers to be accessed by i2c */ 272 twl6040_write(codec, TWL6040_REG_ACCCTL, cache[TWL6040_REG_ACCCTL]); 273 274 for (i = 0; i < TWL6040_VIOREGNUM; i++) { 275 reg = twl6040_vio_reg[i]; 276 /* skip read-only registers (ASICID, ASICREV, STATUS) */ 277 switch (reg) { 278 case TWL6040_REG_ASICID: 279 case TWL6040_REG_ASICREV: 280 case TWL6040_REG_STATUS: 281 continue; 282 default: 283 break; 284 } 285 twl6040_write(codec, reg, cache[reg]); 286 } 287 } 288 289 static void twl6040_init_vdd_regs(struct snd_soc_codec *codec) 290 { 291 u8 *cache = codec->reg_cache; 292 int reg, i; 293 294 for (i = 0; i < TWL6040_VDDREGNUM; i++) { 295 reg = twl6040_vdd_reg[i]; 296 twl6040_write(codec, reg, cache[reg]); 297 } 298 } 299 300 /* 301 * Ramp HS PGA volume to minimise pops at stream startup and shutdown. 302 */ 303 static inline int twl6040_hs_ramp_step(struct snd_soc_codec *codec, 304 unsigned int left_step, unsigned int right_step) 305 { 306 307 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 308 struct twl6040_output *headset = &priv->headset; 309 int left_complete = 0, right_complete = 0; 310 u8 reg, val; 311 312 /* left channel */ 313 left_step = (left_step > 0xF) ? 0xF : left_step; 314 reg = twl6040_read_reg_cache(codec, TWL6040_REG_HSGAIN); 315 val = (~reg & TWL6040_HSL_VOL_MASK); 316 317 if (headset->ramp == TWL6040_RAMP_UP) { 318 /* ramp step up */ 319 if (val < headset->left_vol) { 320 val += left_step; 321 reg &= ~TWL6040_HSL_VOL_MASK; 322 twl6040_write(codec, TWL6040_REG_HSGAIN, 323 (reg | (~val & TWL6040_HSL_VOL_MASK))); 324 } else { 325 left_complete = 1; 326 } 327 } else if (headset->ramp == TWL6040_RAMP_DOWN) { 328 /* ramp step down */ 329 if (val > 0x0) { 330 val -= left_step; 331 reg &= ~TWL6040_HSL_VOL_MASK; 332 twl6040_write(codec, TWL6040_REG_HSGAIN, reg | 333 (~val & TWL6040_HSL_VOL_MASK)); 334 } else { 335 left_complete = 1; 336 } 337 } 338 339 /* right channel */ 340 right_step = (right_step > 0xF) ? 0xF : right_step; 341 reg = twl6040_read_reg_cache(codec, TWL6040_REG_HSGAIN); 342 val = (~reg & TWL6040_HSR_VOL_MASK) >> TWL6040_HSR_VOL_SHIFT; 343 344 if (headset->ramp == TWL6040_RAMP_UP) { 345 /* ramp step up */ 346 if (val < headset->right_vol) { 347 val += right_step; 348 reg &= ~TWL6040_HSR_VOL_MASK; 349 twl6040_write(codec, TWL6040_REG_HSGAIN, 350 (reg | (~val << TWL6040_HSR_VOL_SHIFT))); 351 } else { 352 right_complete = 1; 353 } 354 } else if (headset->ramp == TWL6040_RAMP_DOWN) { 355 /* ramp step down */ 356 if (val > 0x0) { 357 val -= right_step; 358 reg &= ~TWL6040_HSR_VOL_MASK; 359 twl6040_write(codec, TWL6040_REG_HSGAIN, 360 reg | (~val << TWL6040_HSR_VOL_SHIFT)); 361 } else { 362 right_complete = 1; 363 } 364 } 365 366 return left_complete & right_complete; 367 } 368 369 /* 370 * Ramp HF PGA volume to minimise pops at stream startup and shutdown. 371 */ 372 static inline int twl6040_hf_ramp_step(struct snd_soc_codec *codec, 373 unsigned int left_step, unsigned int right_step) 374 { 375 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 376 struct twl6040_output *handsfree = &priv->handsfree; 377 int left_complete = 0, right_complete = 0; 378 u16 reg, val; 379 380 /* left channel */ 381 left_step = (left_step > 0x1D) ? 0x1D : left_step; 382 reg = twl6040_read_reg_cache(codec, TWL6040_REG_HFLGAIN); 383 reg = 0x1D - reg; 384 val = (reg & TWL6040_HF_VOL_MASK); 385 if (handsfree->ramp == TWL6040_RAMP_UP) { 386 /* ramp step up */ 387 if (val < handsfree->left_vol) { 388 val += left_step; 389 reg &= ~TWL6040_HF_VOL_MASK; 390 twl6040_write(codec, TWL6040_REG_HFLGAIN, 391 reg | (0x1D - val)); 392 } else { 393 left_complete = 1; 394 } 395 } else if (handsfree->ramp == TWL6040_RAMP_DOWN) { 396 /* ramp step down */ 397 if (val > 0) { 398 val -= left_step; 399 reg &= ~TWL6040_HF_VOL_MASK; 400 twl6040_write(codec, TWL6040_REG_HFLGAIN, 401 reg | (0x1D - val)); 402 } else { 403 left_complete = 1; 404 } 405 } 406 407 /* right channel */ 408 right_step = (right_step > 0x1D) ? 0x1D : right_step; 409 reg = twl6040_read_reg_cache(codec, TWL6040_REG_HFRGAIN); 410 reg = 0x1D - reg; 411 val = (reg & TWL6040_HF_VOL_MASK); 412 if (handsfree->ramp == TWL6040_RAMP_UP) { 413 /* ramp step up */ 414 if (val < handsfree->right_vol) { 415 val += right_step; 416 reg &= ~TWL6040_HF_VOL_MASK; 417 twl6040_write(codec, TWL6040_REG_HFRGAIN, 418 reg | (0x1D - val)); 419 } else { 420 right_complete = 1; 421 } 422 } else if (handsfree->ramp == TWL6040_RAMP_DOWN) { 423 /* ramp step down */ 424 if (val > 0) { 425 val -= right_step; 426 reg &= ~TWL6040_HF_VOL_MASK; 427 twl6040_write(codec, TWL6040_REG_HFRGAIN, 428 reg | (0x1D - val)); 429 } 430 } 431 432 return left_complete & right_complete; 433 } 434 435 /* 436 * This work ramps both output PGAs at stream start/stop time to 437 * minimise pop associated with DAPM power switching. 438 */ 439 static void twl6040_pga_hs_work(struct work_struct *work) 440 { 441 struct twl6040_data *priv = 442 container_of(work, struct twl6040_data, hs_delayed_work.work); 443 struct snd_soc_codec *codec = priv->codec; 444 struct twl6040_output *headset = &priv->headset; 445 unsigned int delay = headset->step_delay; 446 int i, headset_complete; 447 448 /* do we need to ramp at all ? */ 449 if (headset->ramp == TWL6040_RAMP_NONE) 450 return; 451 452 /* HS PGA volumes have 4 bits of resolution to ramp */ 453 for (i = 0; i <= 16; i++) { 454 headset_complete = 1; 455 if (headset->ramp != TWL6040_RAMP_NONE) 456 headset_complete = twl6040_hs_ramp_step(codec, 457 headset->left_step, 458 headset->right_step); 459 460 /* ramp finished ? */ 461 if (headset_complete) 462 break; 463 464 /* 465 * TODO: tune: delay is longer over 0dB 466 * as increases are larger. 467 */ 468 if (i >= 8) 469 schedule_timeout_interruptible(msecs_to_jiffies(delay + 470 (delay >> 1))); 471 else 472 schedule_timeout_interruptible(msecs_to_jiffies(delay)); 473 } 474 475 if (headset->ramp == TWL6040_RAMP_DOWN) { 476 headset->active = 0; 477 complete(&headset->ramp_done); 478 } else { 479 headset->active = 1; 480 } 481 headset->ramp = TWL6040_RAMP_NONE; 482 } 483 484 static void twl6040_pga_hf_work(struct work_struct *work) 485 { 486 struct twl6040_data *priv = 487 container_of(work, struct twl6040_data, hf_delayed_work.work); 488 struct snd_soc_codec *codec = priv->codec; 489 struct twl6040_output *handsfree = &priv->handsfree; 490 unsigned int delay = handsfree->step_delay; 491 int i, handsfree_complete; 492 493 /* do we need to ramp at all ? */ 494 if (handsfree->ramp == TWL6040_RAMP_NONE) 495 return; 496 497 /* HF PGA volumes have 5 bits of resolution to ramp */ 498 for (i = 0; i <= 32; i++) { 499 handsfree_complete = 1; 500 if (handsfree->ramp != TWL6040_RAMP_NONE) 501 handsfree_complete = twl6040_hf_ramp_step(codec, 502 handsfree->left_step, 503 handsfree->right_step); 504 505 /* ramp finished ? */ 506 if (handsfree_complete) 507 break; 508 509 /* 510 * TODO: tune: delay is longer over 0dB 511 * as increases are larger. 512 */ 513 if (i >= 16) 514 schedule_timeout_interruptible(msecs_to_jiffies(delay + 515 (delay >> 1))); 516 else 517 schedule_timeout_interruptible(msecs_to_jiffies(delay)); 518 } 519 520 521 if (handsfree->ramp == TWL6040_RAMP_DOWN) { 522 handsfree->active = 0; 523 complete(&handsfree->ramp_done); 524 } else 525 handsfree->active = 1; 526 handsfree->ramp = TWL6040_RAMP_NONE; 527 } 528 529 static int pga_event(struct snd_soc_dapm_widget *w, 530 struct snd_kcontrol *kcontrol, int event) 531 { 532 struct snd_soc_codec *codec = w->codec; 533 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 534 struct twl6040_output *out; 535 struct delayed_work *work; 536 struct workqueue_struct *queue; 537 538 switch (w->shift) { 539 case 2: 540 case 3: 541 out = &priv->headset; 542 work = &priv->hs_delayed_work; 543 queue = priv->hs_workqueue; 544 out->step_delay = 5; /* 5 ms between volume ramp steps */ 545 break; 546 case 4: 547 out = &priv->handsfree; 548 work = &priv->hf_delayed_work; 549 queue = priv->hf_workqueue; 550 out->step_delay = 5; /* 5 ms between volume ramp steps */ 551 if (SND_SOC_DAPM_EVENT_ON(event)) 552 priv->non_lp++; 553 else 554 priv->non_lp--; 555 break; 556 default: 557 return -1; 558 } 559 560 switch (event) { 561 case SND_SOC_DAPM_POST_PMU: 562 if (out->active) 563 break; 564 565 /* don't use volume ramp for power-up */ 566 out->left_step = out->left_vol; 567 out->right_step = out->right_vol; 568 569 if (!delayed_work_pending(work)) { 570 out->ramp = TWL6040_RAMP_UP; 571 queue_delayed_work(queue, work, 572 msecs_to_jiffies(1)); 573 } 574 break; 575 576 case SND_SOC_DAPM_PRE_PMD: 577 if (!out->active) 578 break; 579 580 if (!delayed_work_pending(work)) { 581 /* use volume ramp for power-down */ 582 out->left_step = 1; 583 out->right_step = 1; 584 out->ramp = TWL6040_RAMP_DOWN; 585 INIT_COMPLETION(out->ramp_done); 586 587 queue_delayed_work(queue, work, 588 msecs_to_jiffies(1)); 589 590 wait_for_completion_timeout(&out->ramp_done, 591 msecs_to_jiffies(2000)); 592 } 593 break; 594 } 595 596 return 0; 597 } 598 599 /* twl6040 codec manual power-up sequence */ 600 static void twl6040_power_up(struct snd_soc_codec *codec) 601 { 602 u8 ncpctl, ldoctl, lppllctl, accctl; 603 604 ncpctl = twl6040_read_reg_cache(codec, TWL6040_REG_NCPCTL); 605 ldoctl = twl6040_read_reg_cache(codec, TWL6040_REG_LDOCTL); 606 lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL); 607 accctl = twl6040_read_reg_cache(codec, TWL6040_REG_ACCCTL); 608 609 /* enable reference system */ 610 ldoctl |= TWL6040_REFENA; 611 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 612 msleep(10); 613 /* enable internal oscillator */ 614 ldoctl |= TWL6040_OSCENA; 615 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 616 udelay(10); 617 /* enable high-side ldo */ 618 ldoctl |= TWL6040_HSLDOENA; 619 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 620 udelay(244); 621 /* enable negative charge pump */ 622 ncpctl |= TWL6040_NCPENA | TWL6040_NCPOPEN; 623 twl6040_write(codec, TWL6040_REG_NCPCTL, ncpctl); 624 udelay(488); 625 /* enable low-side ldo */ 626 ldoctl |= TWL6040_LSLDOENA; 627 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 628 udelay(244); 629 /* enable low-power pll */ 630 lppllctl |= TWL6040_LPLLENA; 631 twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl); 632 /* reset state machine */ 633 accctl |= TWL6040_RESETSPLIT; 634 twl6040_write(codec, TWL6040_REG_ACCCTL, accctl); 635 mdelay(5); 636 accctl &= ~TWL6040_RESETSPLIT; 637 twl6040_write(codec, TWL6040_REG_ACCCTL, accctl); 638 /* disable internal oscillator */ 639 ldoctl &= ~TWL6040_OSCENA; 640 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 641 } 642 643 /* twl6040 codec manual power-down sequence */ 644 static void twl6040_power_down(struct snd_soc_codec *codec) 645 { 646 u8 ncpctl, ldoctl, lppllctl, accctl; 647 648 ncpctl = twl6040_read_reg_cache(codec, TWL6040_REG_NCPCTL); 649 ldoctl = twl6040_read_reg_cache(codec, TWL6040_REG_LDOCTL); 650 lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL); 651 accctl = twl6040_read_reg_cache(codec, TWL6040_REG_ACCCTL); 652 653 /* enable internal oscillator */ 654 ldoctl |= TWL6040_OSCENA; 655 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 656 udelay(10); 657 /* disable low-power pll */ 658 lppllctl &= ~TWL6040_LPLLENA; 659 twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl); 660 /* disable low-side ldo */ 661 ldoctl &= ~TWL6040_LSLDOENA; 662 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 663 udelay(244); 664 /* disable negative charge pump */ 665 ncpctl &= ~(TWL6040_NCPENA | TWL6040_NCPOPEN); 666 twl6040_write(codec, TWL6040_REG_NCPCTL, ncpctl); 667 udelay(488); 668 /* disable high-side ldo */ 669 ldoctl &= ~TWL6040_HSLDOENA; 670 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 671 udelay(244); 672 /* disable internal oscillator */ 673 ldoctl &= ~TWL6040_OSCENA; 674 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 675 /* disable reference system */ 676 ldoctl &= ~TWL6040_REFENA; 677 twl6040_write(codec, TWL6040_REG_LDOCTL, ldoctl); 678 msleep(10); 679 } 680 681 /* set headset dac and driver power mode */ 682 static int headset_power_mode(struct snd_soc_codec *codec, int high_perf) 683 { 684 int hslctl, hsrctl; 685 int mask = TWL6040_HSDRVMODEL | TWL6040_HSDACMODEL; 686 687 hslctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSLCTL); 688 hsrctl = twl6040_read_reg_cache(codec, TWL6040_REG_HSRCTL); 689 690 if (high_perf) { 691 hslctl &= ~mask; 692 hsrctl &= ~mask; 693 } else { 694 hslctl |= mask; 695 hsrctl |= mask; 696 } 697 698 twl6040_write(codec, TWL6040_REG_HSLCTL, hslctl); 699 twl6040_write(codec, TWL6040_REG_HSRCTL, hsrctl); 700 701 return 0; 702 } 703 704 static int twl6040_hs_dac_event(struct snd_soc_dapm_widget *w, 705 struct snd_kcontrol *kcontrol, int event) 706 { 707 msleep(1); 708 return 0; 709 } 710 711 static int twl6040_power_mode_event(struct snd_soc_dapm_widget *w, 712 struct snd_kcontrol *kcontrol, int event) 713 { 714 struct snd_soc_codec *codec = w->codec; 715 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 716 717 if (SND_SOC_DAPM_EVENT_ON(event)) 718 priv->non_lp++; 719 else 720 priv->non_lp--; 721 722 msleep(1); 723 724 return 0; 725 } 726 727 static void twl6040_hs_jack_report(struct snd_soc_codec *codec, 728 struct snd_soc_jack *jack, int report) 729 { 730 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 731 int status; 732 733 mutex_lock(&priv->mutex); 734 735 /* Sync status */ 736 status = twl6040_read_reg_volatile(codec, TWL6040_REG_STATUS); 737 if (status & TWL6040_PLUGCOMP) 738 snd_soc_jack_report(jack, report, report); 739 else 740 snd_soc_jack_report(jack, 0, report); 741 742 mutex_unlock(&priv->mutex); 743 } 744 745 void twl6040_hs_jack_detect(struct snd_soc_codec *codec, 746 struct snd_soc_jack *jack, int report) 747 { 748 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 749 struct twl6040_jack_data *hs_jack = &priv->hs_jack; 750 751 hs_jack->jack = jack; 752 hs_jack->report = report; 753 754 twl6040_hs_jack_report(codec, hs_jack->jack, hs_jack->report); 755 } 756 EXPORT_SYMBOL_GPL(twl6040_hs_jack_detect); 757 758 static void twl6040_accessory_work(struct work_struct *work) 759 { 760 struct twl6040_data *priv = container_of(work, 761 struct twl6040_data, delayed_work.work); 762 struct snd_soc_codec *codec = priv->codec; 763 struct twl6040_jack_data *hs_jack = &priv->hs_jack; 764 765 twl6040_hs_jack_report(codec, hs_jack->jack, hs_jack->report); 766 } 767 768 /* audio interrupt handler */ 769 static irqreturn_t twl6040_naudint_handler(int irq, void *data) 770 { 771 struct snd_soc_codec *codec = data; 772 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 773 u8 intid; 774 775 twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &intid, TWL6040_REG_INTID); 776 777 if (intid & TWL6040_THINT) 778 dev_alert(codec->dev, "die temp over-limit detection\n"); 779 780 if ((intid & TWL6040_PLUGINT) || (intid & TWL6040_UNPLUGINT)) 781 queue_delayed_work(priv->workqueue, &priv->delayed_work, 782 msecs_to_jiffies(200)); 783 784 if (intid & TWL6040_HOOKINT) 785 dev_info(codec->dev, "hook detection\n"); 786 787 if (intid & TWL6040_HFINT) 788 dev_alert(codec->dev, "hf drivers over current detection\n"); 789 790 if (intid & TWL6040_VIBINT) 791 dev_alert(codec->dev, "vib drivers over current detection\n"); 792 793 if (intid & TWL6040_READYINT) 794 complete(&priv->ready); 795 796 return IRQ_HANDLED; 797 } 798 799 static int twl6040_put_volsw(struct snd_kcontrol *kcontrol, 800 struct snd_ctl_elem_value *ucontrol) 801 { 802 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 803 struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec); 804 struct twl6040_output *out = NULL; 805 struct soc_mixer_control *mc = 806 (struct soc_mixer_control *)kcontrol->private_value; 807 int ret; 808 unsigned int reg = mc->reg; 809 810 /* For HS and HF we shadow the values and only actually write 811 * them out when active in order to ensure the amplifier comes on 812 * as quietly as possible. */ 813 switch (reg) { 814 case TWL6040_REG_HSGAIN: 815 out = &twl6040_priv->headset; 816 break; 817 default: 818 break; 819 } 820 821 if (out) { 822 out->left_vol = ucontrol->value.integer.value[0]; 823 out->right_vol = ucontrol->value.integer.value[1]; 824 if (!out->active) 825 return 1; 826 } 827 828 ret = snd_soc_put_volsw(kcontrol, ucontrol); 829 if (ret < 0) 830 return ret; 831 832 return 1; 833 } 834 835 static int twl6040_get_volsw(struct snd_kcontrol *kcontrol, 836 struct snd_ctl_elem_value *ucontrol) 837 { 838 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 839 struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec); 840 struct twl6040_output *out = &twl6040_priv->headset; 841 struct soc_mixer_control *mc = 842 (struct soc_mixer_control *)kcontrol->private_value; 843 unsigned int reg = mc->reg; 844 845 switch (reg) { 846 case TWL6040_REG_HSGAIN: 847 out = &twl6040_priv->headset; 848 ucontrol->value.integer.value[0] = out->left_vol; 849 ucontrol->value.integer.value[1] = out->right_vol; 850 return 0; 851 852 default: 853 break; 854 } 855 856 return snd_soc_get_volsw(kcontrol, ucontrol); 857 } 858 859 static int twl6040_put_volsw_2r_vu(struct snd_kcontrol *kcontrol, 860 struct snd_ctl_elem_value *ucontrol) 861 { 862 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 863 struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec); 864 struct twl6040_output *out = NULL; 865 struct soc_mixer_control *mc = 866 (struct soc_mixer_control *)kcontrol->private_value; 867 int ret; 868 unsigned int reg = mc->reg; 869 870 /* For HS and HF we shadow the values and only actually write 871 * them out when active in order to ensure the amplifier comes on 872 * as quietly as possible. */ 873 switch (reg) { 874 case TWL6040_REG_HFLGAIN: 875 case TWL6040_REG_HFRGAIN: 876 out = &twl6040_priv->handsfree; 877 break; 878 default: 879 break; 880 } 881 882 if (out) { 883 out->left_vol = ucontrol->value.integer.value[0]; 884 out->right_vol = ucontrol->value.integer.value[1]; 885 if (!out->active) 886 return 1; 887 } 888 889 ret = snd_soc_put_volsw_2r(kcontrol, ucontrol); 890 if (ret < 0) 891 return ret; 892 893 return 1; 894 } 895 896 static int twl6040_get_volsw_2r(struct snd_kcontrol *kcontrol, 897 struct snd_ctl_elem_value *ucontrol) 898 { 899 struct snd_soc_codec *codec = snd_kcontrol_chip(kcontrol); 900 struct twl6040_data *twl6040_priv = snd_soc_codec_get_drvdata(codec); 901 struct twl6040_output *out = &twl6040_priv->handsfree; 902 struct soc_mixer_control *mc = 903 (struct soc_mixer_control *)kcontrol->private_value; 904 unsigned int reg = mc->reg; 905 906 /* If these are cached registers use the cache */ 907 switch (reg) { 908 case TWL6040_REG_HFLGAIN: 909 case TWL6040_REG_HFRGAIN: 910 out = &twl6040_priv->handsfree; 911 ucontrol->value.integer.value[0] = out->left_vol; 912 ucontrol->value.integer.value[1] = out->right_vol; 913 return 0; 914 915 default: 916 break; 917 } 918 919 return snd_soc_get_volsw_2r(kcontrol, ucontrol); 920 } 921 922 /* double control with volume update */ 923 #define SOC_TWL6040_DOUBLE_TLV(xname, xreg, shift_left, shift_right, xmax,\ 924 xinvert, tlv_array)\ 925 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\ 926 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\ 927 SNDRV_CTL_ELEM_ACCESS_READWRITE,\ 928 .tlv.p = (tlv_array), \ 929 .info = snd_soc_info_volsw, .get = twl6040_get_volsw, \ 930 .put = twl6040_put_volsw, \ 931 .private_value = (unsigned long)&(struct soc_mixer_control) \ 932 {.reg = xreg, .shift = shift_left, .rshift = shift_right,\ 933 .max = xmax, .platform_max = xmax, .invert = xinvert} } 934 935 /* double control with volume update */ 936 #define SOC_TWL6040_DOUBLE_R_TLV(xname, reg_left, reg_right, xshift, xmax,\ 937 xinvert, tlv_array)\ 938 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname),\ 939 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \ 940 SNDRV_CTL_ELEM_ACCESS_READWRITE | \ 941 SNDRV_CTL_ELEM_ACCESS_VOLATILE, \ 942 .tlv.p = (tlv_array), \ 943 .info = snd_soc_info_volsw_2r, \ 944 .get = twl6040_get_volsw_2r, .put = twl6040_put_volsw_2r_vu, \ 945 .private_value = (unsigned long)&(struct soc_mixer_control) \ 946 {.reg = reg_left, .rreg = reg_right, .shift = xshift, \ 947 .rshift = xshift, .max = xmax, .invert = xinvert}, } 948 949 /* 950 * MICATT volume control: 951 * from -6 to 0 dB in 6 dB steps 952 */ 953 static DECLARE_TLV_DB_SCALE(mic_preamp_tlv, -600, 600, 0); 954 955 /* 956 * MICGAIN volume control: 957 * from -6 to 30 dB in 6 dB steps 958 */ 959 static DECLARE_TLV_DB_SCALE(mic_amp_tlv, -600, 600, 0); 960 961 /* 962 * AFMGAIN volume control: 963 * from 18 to 24 dB in 6 dB steps 964 */ 965 static DECLARE_TLV_DB_SCALE(afm_amp_tlv, 1800, 600, 0); 966 967 /* 968 * HSGAIN volume control: 969 * from -30 to 0 dB in 2 dB steps 970 */ 971 static DECLARE_TLV_DB_SCALE(hs_tlv, -3000, 200, 0); 972 973 /* 974 * HFGAIN volume control: 975 * from -52 to 6 dB in 2 dB steps 976 */ 977 static DECLARE_TLV_DB_SCALE(hf_tlv, -5200, 200, 0); 978 979 /* 980 * EPGAIN volume control: 981 * from -24 to 6 dB in 2 dB steps 982 */ 983 static DECLARE_TLV_DB_SCALE(ep_tlv, -2400, 200, 0); 984 985 /* Left analog microphone selection */ 986 static const char *twl6040_amicl_texts[] = 987 {"Headset Mic", "Main Mic", "Aux/FM Left", "Off"}; 988 989 /* Right analog microphone selection */ 990 static const char *twl6040_amicr_texts[] = 991 {"Headset Mic", "Sub Mic", "Aux/FM Right", "Off"}; 992 993 static const struct soc_enum twl6040_enum[] = { 994 SOC_ENUM_SINGLE(TWL6040_REG_MICLCTL, 3, 4, twl6040_amicl_texts), 995 SOC_ENUM_SINGLE(TWL6040_REG_MICRCTL, 3, 4, twl6040_amicr_texts), 996 }; 997 998 static const char *twl6040_hs_texts[] = { 999 "Off", "HS DAC", "Line-In amp" 1000 }; 1001 1002 static const struct soc_enum twl6040_hs_enum[] = { 1003 SOC_ENUM_SINGLE(TWL6040_REG_HSLCTL, 5, ARRAY_SIZE(twl6040_hs_texts), 1004 twl6040_hs_texts), 1005 SOC_ENUM_SINGLE(TWL6040_REG_HSRCTL, 5, ARRAY_SIZE(twl6040_hs_texts), 1006 twl6040_hs_texts), 1007 }; 1008 1009 static const char *twl6040_hf_texts[] = { 1010 "Off", "HF DAC", "Line-In amp" 1011 }; 1012 1013 static const struct soc_enum twl6040_hf_enum[] = { 1014 SOC_ENUM_SINGLE(TWL6040_REG_HFLCTL, 2, ARRAY_SIZE(twl6040_hf_texts), 1015 twl6040_hf_texts), 1016 SOC_ENUM_SINGLE(TWL6040_REG_HFRCTL, 2, ARRAY_SIZE(twl6040_hf_texts), 1017 twl6040_hf_texts), 1018 }; 1019 1020 static const struct snd_kcontrol_new amicl_control = 1021 SOC_DAPM_ENUM("Route", twl6040_enum[0]); 1022 1023 static const struct snd_kcontrol_new amicr_control = 1024 SOC_DAPM_ENUM("Route", twl6040_enum[1]); 1025 1026 /* Headset DAC playback switches */ 1027 static const struct snd_kcontrol_new hsl_mux_controls = 1028 SOC_DAPM_ENUM("Route", twl6040_hs_enum[0]); 1029 1030 static const struct snd_kcontrol_new hsr_mux_controls = 1031 SOC_DAPM_ENUM("Route", twl6040_hs_enum[1]); 1032 1033 /* Handsfree DAC playback switches */ 1034 static const struct snd_kcontrol_new hfl_mux_controls = 1035 SOC_DAPM_ENUM("Route", twl6040_hf_enum[0]); 1036 1037 static const struct snd_kcontrol_new hfr_mux_controls = 1038 SOC_DAPM_ENUM("Route", twl6040_hf_enum[1]); 1039 1040 static const struct snd_kcontrol_new ep_driver_switch_controls = 1041 SOC_DAPM_SINGLE("Switch", TWL6040_REG_EARCTL, 0, 1, 0); 1042 1043 static const struct snd_kcontrol_new twl6040_snd_controls[] = { 1044 /* Capture gains */ 1045 SOC_DOUBLE_TLV("Capture Preamplifier Volume", 1046 TWL6040_REG_MICGAIN, 6, 7, 1, 1, mic_preamp_tlv), 1047 SOC_DOUBLE_TLV("Capture Volume", 1048 TWL6040_REG_MICGAIN, 0, 3, 4, 0, mic_amp_tlv), 1049 1050 /* AFM gains */ 1051 SOC_DOUBLE_TLV("Aux FM Volume", 1052 TWL6040_REG_LINEGAIN, 0, 4, 0xF, 0, afm_amp_tlv), 1053 1054 /* Playback gains */ 1055 SOC_TWL6040_DOUBLE_TLV("Headset Playback Volume", 1056 TWL6040_REG_HSGAIN, 0, 4, 0xF, 1, hs_tlv), 1057 SOC_TWL6040_DOUBLE_R_TLV("Handsfree Playback Volume", 1058 TWL6040_REG_HFLGAIN, TWL6040_REG_HFRGAIN, 0, 0x1D, 1, hf_tlv), 1059 SOC_SINGLE_TLV("Earphone Playback Volume", 1060 TWL6040_REG_EARCTL, 1, 0xF, 1, ep_tlv), 1061 }; 1062 1063 static const struct snd_soc_dapm_widget twl6040_dapm_widgets[] = { 1064 /* Inputs */ 1065 SND_SOC_DAPM_INPUT("MAINMIC"), 1066 SND_SOC_DAPM_INPUT("HSMIC"), 1067 SND_SOC_DAPM_INPUT("SUBMIC"), 1068 SND_SOC_DAPM_INPUT("AFML"), 1069 SND_SOC_DAPM_INPUT("AFMR"), 1070 1071 /* Outputs */ 1072 SND_SOC_DAPM_OUTPUT("HSOL"), 1073 SND_SOC_DAPM_OUTPUT("HSOR"), 1074 SND_SOC_DAPM_OUTPUT("HFL"), 1075 SND_SOC_DAPM_OUTPUT("HFR"), 1076 SND_SOC_DAPM_OUTPUT("EP"), 1077 1078 /* Analog input muxes for the capture amplifiers */ 1079 SND_SOC_DAPM_MUX("Analog Left Capture Route", 1080 SND_SOC_NOPM, 0, 0, &amicl_control), 1081 SND_SOC_DAPM_MUX("Analog Right Capture Route", 1082 SND_SOC_NOPM, 0, 0, &amicr_control), 1083 1084 /* Analog capture PGAs */ 1085 SND_SOC_DAPM_PGA("MicAmpL", 1086 TWL6040_REG_MICLCTL, 0, 0, NULL, 0), 1087 SND_SOC_DAPM_PGA("MicAmpR", 1088 TWL6040_REG_MICRCTL, 0, 0, NULL, 0), 1089 1090 /* Auxiliary FM PGAs */ 1091 SND_SOC_DAPM_PGA("AFMAmpL", 1092 TWL6040_REG_MICLCTL, 1, 0, NULL, 0), 1093 SND_SOC_DAPM_PGA("AFMAmpR", 1094 TWL6040_REG_MICRCTL, 1, 0, NULL, 0), 1095 1096 /* ADCs */ 1097 SND_SOC_DAPM_ADC("ADC Left", "Left Front Capture", 1098 TWL6040_REG_MICLCTL, 2, 0), 1099 SND_SOC_DAPM_ADC("ADC Right", "Right Front Capture", 1100 TWL6040_REG_MICRCTL, 2, 0), 1101 1102 /* Microphone bias */ 1103 SND_SOC_DAPM_MICBIAS("Headset Mic Bias", 1104 TWL6040_REG_AMICBCTL, 0, 0), 1105 SND_SOC_DAPM_MICBIAS("Main Mic Bias", 1106 TWL6040_REG_AMICBCTL, 4, 0), 1107 SND_SOC_DAPM_MICBIAS("Digital Mic1 Bias", 1108 TWL6040_REG_DMICBCTL, 0, 0), 1109 SND_SOC_DAPM_MICBIAS("Digital Mic2 Bias", 1110 TWL6040_REG_DMICBCTL, 4, 0), 1111 1112 /* DACs */ 1113 SND_SOC_DAPM_DAC_E("HSDAC Left", "Headset Playback", 1114 TWL6040_REG_HSLCTL, 0, 0, 1115 twl6040_hs_dac_event, 1116 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), 1117 SND_SOC_DAPM_DAC_E("HSDAC Right", "Headset Playback", 1118 TWL6040_REG_HSRCTL, 0, 0, 1119 twl6040_hs_dac_event, 1120 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), 1121 SND_SOC_DAPM_DAC_E("HFDAC Left", "Handsfree Playback", 1122 TWL6040_REG_HFLCTL, 0, 0, 1123 twl6040_power_mode_event, 1124 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), 1125 SND_SOC_DAPM_DAC_E("HFDAC Right", "Handsfree Playback", 1126 TWL6040_REG_HFRCTL, 0, 0, 1127 twl6040_power_mode_event, 1128 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), 1129 1130 SND_SOC_DAPM_MUX("HF Left Playback", 1131 SND_SOC_NOPM, 0, 0, &hfl_mux_controls), 1132 SND_SOC_DAPM_MUX("HF Right Playback", 1133 SND_SOC_NOPM, 0, 0, &hfr_mux_controls), 1134 /* Analog playback Muxes */ 1135 SND_SOC_DAPM_MUX("HS Left Playback", 1136 SND_SOC_NOPM, 0, 0, &hsl_mux_controls), 1137 SND_SOC_DAPM_MUX("HS Right Playback", 1138 SND_SOC_NOPM, 0, 0, &hsr_mux_controls), 1139 1140 /* Analog playback drivers */ 1141 SND_SOC_DAPM_OUT_DRV_E("Handsfree Left Driver", 1142 TWL6040_REG_HFLCTL, 4, 0, NULL, 0, 1143 pga_event, 1144 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1145 SND_SOC_DAPM_OUT_DRV_E("Handsfree Right Driver", 1146 TWL6040_REG_HFRCTL, 4, 0, NULL, 0, 1147 pga_event, 1148 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1149 SND_SOC_DAPM_OUT_DRV_E("Headset Left Driver", 1150 TWL6040_REG_HSLCTL, 2, 0, NULL, 0, 1151 pga_event, 1152 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1153 SND_SOC_DAPM_OUT_DRV_E("Headset Right Driver", 1154 TWL6040_REG_HSRCTL, 2, 0, NULL, 0, 1155 pga_event, 1156 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 1157 SND_SOC_DAPM_SWITCH_E("Earphone Driver", 1158 SND_SOC_NOPM, 0, 0, &ep_driver_switch_controls, 1159 twl6040_power_mode_event, 1160 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_POST_PMD), 1161 1162 /* Analog playback PGAs */ 1163 SND_SOC_DAPM_PGA("HFDAC Left PGA", 1164 TWL6040_REG_HFLCTL, 1, 0, NULL, 0), 1165 SND_SOC_DAPM_PGA("HFDAC Right PGA", 1166 TWL6040_REG_HFRCTL, 1, 0, NULL, 0), 1167 1168 }; 1169 1170 static const struct snd_soc_dapm_route intercon[] = { 1171 /* Capture path */ 1172 {"Analog Left Capture Route", "Headset Mic", "HSMIC"}, 1173 {"Analog Left Capture Route", "Main Mic", "MAINMIC"}, 1174 {"Analog Left Capture Route", "Aux/FM Left", "AFML"}, 1175 1176 {"Analog Right Capture Route", "Headset Mic", "HSMIC"}, 1177 {"Analog Right Capture Route", "Sub Mic", "SUBMIC"}, 1178 {"Analog Right Capture Route", "Aux/FM Right", "AFMR"}, 1179 1180 {"MicAmpL", NULL, "Analog Left Capture Route"}, 1181 {"MicAmpR", NULL, "Analog Right Capture Route"}, 1182 1183 {"ADC Left", NULL, "MicAmpL"}, 1184 {"ADC Right", NULL, "MicAmpR"}, 1185 1186 /* AFM path */ 1187 {"AFMAmpL", "NULL", "AFML"}, 1188 {"AFMAmpR", "NULL", "AFMR"}, 1189 1190 {"HS Left Playback", "HS DAC", "HSDAC Left"}, 1191 {"HS Left Playback", "Line-In amp", "AFMAmpL"}, 1192 1193 {"HS Right Playback", "HS DAC", "HSDAC Right"}, 1194 {"HS Right Playback", "Line-In amp", "AFMAmpR"}, 1195 1196 {"Headset Left Driver", "NULL", "HS Left Playback"}, 1197 {"Headset Right Driver", "NULL", "HS Right Playback"}, 1198 1199 {"HSOL", NULL, "Headset Left Driver"}, 1200 {"HSOR", NULL, "Headset Right Driver"}, 1201 1202 /* Earphone playback path */ 1203 {"Earphone Driver", "Switch", "HSDAC Left"}, 1204 {"EP", NULL, "Earphone Driver"}, 1205 1206 {"HF Left Playback", "HF DAC", "HFDAC Left"}, 1207 {"HF Left Playback", "Line-In amp", "AFMAmpL"}, 1208 1209 {"HF Right Playback", "HF DAC", "HFDAC Right"}, 1210 {"HF Right Playback", "Line-In amp", "AFMAmpR"}, 1211 1212 {"HFDAC Left PGA", NULL, "HF Left Playback"}, 1213 {"HFDAC Right PGA", NULL, "HF Right Playback"}, 1214 1215 {"Handsfree Left Driver", "Switch", "HFDAC Left PGA"}, 1216 {"Handsfree Right Driver", "Switch", "HFDAC Right PGA"}, 1217 1218 {"HFL", NULL, "Handsfree Left Driver"}, 1219 {"HFR", NULL, "Handsfree Right Driver"}, 1220 }; 1221 1222 static int twl6040_add_widgets(struct snd_soc_codec *codec) 1223 { 1224 struct snd_soc_dapm_context *dapm = &codec->dapm; 1225 1226 snd_soc_dapm_new_controls(dapm, twl6040_dapm_widgets, 1227 ARRAY_SIZE(twl6040_dapm_widgets)); 1228 snd_soc_dapm_add_routes(dapm, intercon, ARRAY_SIZE(intercon)); 1229 snd_soc_dapm_new_widgets(dapm); 1230 1231 return 0; 1232 } 1233 1234 static int twl6040_power_up_completion(struct snd_soc_codec *codec, 1235 int naudint) 1236 { 1237 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 1238 int time_left; 1239 u8 intid; 1240 1241 time_left = wait_for_completion_timeout(&priv->ready, 1242 msecs_to_jiffies(144)); 1243 1244 if (!time_left) { 1245 twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &intid, 1246 TWL6040_REG_INTID); 1247 if (!(intid & TWL6040_READYINT)) { 1248 dev_err(codec->dev, "timeout waiting for READYINT\n"); 1249 return -ETIMEDOUT; 1250 } 1251 } 1252 1253 priv->codec_powered = 1; 1254 1255 return 0; 1256 } 1257 1258 static int twl6040_set_bias_level(struct snd_soc_codec *codec, 1259 enum snd_soc_bias_level level) 1260 { 1261 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 1262 int audpwron = priv->audpwron; 1263 int naudint = priv->naudint; 1264 int ret; 1265 1266 switch (level) { 1267 case SND_SOC_BIAS_ON: 1268 break; 1269 case SND_SOC_BIAS_PREPARE: 1270 break; 1271 case SND_SOC_BIAS_STANDBY: 1272 if (priv->codec_powered) 1273 break; 1274 1275 if (gpio_is_valid(audpwron)) { 1276 /* use AUDPWRON line */ 1277 gpio_set_value(audpwron, 1); 1278 1279 /* wait for power-up completion */ 1280 ret = twl6040_power_up_completion(codec, naudint); 1281 if (ret) 1282 return ret; 1283 1284 /* sync registers updated during power-up sequence */ 1285 twl6040_read_reg_volatile(codec, TWL6040_REG_NCPCTL); 1286 twl6040_read_reg_volatile(codec, TWL6040_REG_LDOCTL); 1287 twl6040_read_reg_volatile(codec, TWL6040_REG_LPPLLCTL); 1288 } else { 1289 /* use manual power-up sequence */ 1290 twl6040_power_up(codec); 1291 priv->codec_powered = 1; 1292 } 1293 1294 /* initialize vdd/vss registers with reg_cache */ 1295 twl6040_init_vdd_regs(codec); 1296 1297 /* Set external boost GPO */ 1298 twl6040_write(codec, TWL6040_REG_GPOCTL, 0x02); 1299 1300 /* Set initial minimal gain values */ 1301 twl6040_write(codec, TWL6040_REG_HSGAIN, 0xFF); 1302 twl6040_write(codec, TWL6040_REG_EARCTL, 0x1E); 1303 twl6040_write(codec, TWL6040_REG_HFLGAIN, 0x1D); 1304 twl6040_write(codec, TWL6040_REG_HFRGAIN, 0x1D); 1305 break; 1306 case SND_SOC_BIAS_OFF: 1307 if (!priv->codec_powered) 1308 break; 1309 1310 if (gpio_is_valid(audpwron)) { 1311 /* use AUDPWRON line */ 1312 gpio_set_value(audpwron, 0); 1313 1314 /* power-down sequence latency */ 1315 udelay(500); 1316 1317 /* sync registers updated during power-down sequence */ 1318 twl6040_read_reg_volatile(codec, TWL6040_REG_NCPCTL); 1319 twl6040_read_reg_volatile(codec, TWL6040_REG_LDOCTL); 1320 twl6040_write_reg_cache(codec, TWL6040_REG_LPPLLCTL, 1321 0x00); 1322 } else { 1323 /* use manual power-down sequence */ 1324 twl6040_power_down(codec); 1325 } 1326 1327 priv->codec_powered = 0; 1328 break; 1329 } 1330 1331 codec->dapm.bias_level = level; 1332 1333 return 0; 1334 } 1335 1336 /* set of rates for each pll: low-power and high-performance */ 1337 1338 static unsigned int lp_rates[] = { 1339 88200, 1340 96000, 1341 }; 1342 1343 static struct snd_pcm_hw_constraint_list lp_constraints = { 1344 .count = ARRAY_SIZE(lp_rates), 1345 .list = lp_rates, 1346 }; 1347 1348 static unsigned int hp_rates[] = { 1349 96000, 1350 }; 1351 1352 static struct snd_pcm_hw_constraint_list hp_constraints = { 1353 .count = ARRAY_SIZE(hp_rates), 1354 .list = hp_rates, 1355 }; 1356 1357 static int twl6040_startup(struct snd_pcm_substream *substream, 1358 struct snd_soc_dai *dai) 1359 { 1360 struct snd_soc_pcm_runtime *rtd = substream->private_data; 1361 struct snd_soc_codec *codec = rtd->codec; 1362 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 1363 1364 snd_pcm_hw_constraint_list(substream->runtime, 0, 1365 SNDRV_PCM_HW_PARAM_RATE, 1366 priv->sysclk_constraints); 1367 1368 return 0; 1369 } 1370 1371 static int twl6040_hw_params(struct snd_pcm_substream *substream, 1372 struct snd_pcm_hw_params *params, 1373 struct snd_soc_dai *dai) 1374 { 1375 struct snd_soc_pcm_runtime *rtd = substream->private_data; 1376 struct snd_soc_codec *codec = rtd->codec; 1377 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 1378 u8 lppllctl; 1379 int rate; 1380 1381 /* nothing to do for high-perf pll, it supports only 48 kHz */ 1382 if (priv->pll == TWL6040_HPPLL_ID) 1383 return 0; 1384 1385 lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL); 1386 1387 rate = params_rate(params); 1388 switch (rate) { 1389 case 11250: 1390 case 22500: 1391 case 44100: 1392 case 88200: 1393 lppllctl |= TWL6040_LPLLFIN; 1394 priv->sysclk = 17640000; 1395 break; 1396 case 8000: 1397 case 16000: 1398 case 32000: 1399 case 48000: 1400 case 96000: 1401 lppllctl &= ~TWL6040_LPLLFIN; 1402 priv->sysclk = 19200000; 1403 break; 1404 default: 1405 dev_err(codec->dev, "unsupported rate %d\n", rate); 1406 return -EINVAL; 1407 } 1408 1409 twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl); 1410 1411 return 0; 1412 } 1413 1414 static int twl6040_prepare(struct snd_pcm_substream *substream, 1415 struct snd_soc_dai *dai) 1416 { 1417 struct snd_soc_pcm_runtime *rtd = substream->private_data; 1418 struct snd_soc_codec *codec = rtd->codec; 1419 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 1420 1421 if (!priv->sysclk) { 1422 dev_err(codec->dev, 1423 "no mclk configured, call set_sysclk() on init\n"); 1424 return -EINVAL; 1425 } 1426 1427 /* 1428 * capture is not supported at 17.64 MHz, 1429 * it's reserved for headset low-power playback scenario 1430 */ 1431 if ((priv->sysclk == 17640000) && 1432 substream->stream == SNDRV_PCM_STREAM_CAPTURE) { 1433 dev_err(codec->dev, 1434 "capture mode is not supported at %dHz\n", 1435 priv->sysclk); 1436 return -EINVAL; 1437 } 1438 1439 if ((priv->sysclk == 17640000) && priv->non_lp) { 1440 dev_err(codec->dev, 1441 "some enabled paths aren't supported at %dHz\n", 1442 priv->sysclk); 1443 return -EPERM; 1444 } 1445 return 0; 1446 } 1447 1448 static int twl6040_set_dai_sysclk(struct snd_soc_dai *codec_dai, 1449 int clk_id, unsigned int freq, int dir) 1450 { 1451 struct snd_soc_codec *codec = codec_dai->codec; 1452 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 1453 u8 hppllctl, lppllctl; 1454 1455 hppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_HPPLLCTL); 1456 lppllctl = twl6040_read_reg_cache(codec, TWL6040_REG_LPPLLCTL); 1457 1458 switch (clk_id) { 1459 case TWL6040_SYSCLK_SEL_LPPLL: 1460 switch (freq) { 1461 case 32768: 1462 /* headset dac and driver must be in low-power mode */ 1463 headset_power_mode(codec, 0); 1464 1465 /* clk32k input requires low-power pll */ 1466 lppllctl |= TWL6040_LPLLENA; 1467 twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl); 1468 mdelay(5); 1469 lppllctl &= ~TWL6040_HPLLSEL; 1470 twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl); 1471 hppllctl &= ~TWL6040_HPLLENA; 1472 twl6040_write(codec, TWL6040_REG_HPPLLCTL, hppllctl); 1473 break; 1474 default: 1475 dev_err(codec->dev, "unknown mclk freq %d\n", freq); 1476 return -EINVAL; 1477 } 1478 1479 /* lppll divider */ 1480 switch (priv->sysclk) { 1481 case 17640000: 1482 lppllctl |= TWL6040_LPLLFIN; 1483 break; 1484 case 19200000: 1485 lppllctl &= ~TWL6040_LPLLFIN; 1486 break; 1487 default: 1488 /* sysclk not yet configured */ 1489 lppllctl &= ~TWL6040_LPLLFIN; 1490 priv->sysclk = 19200000; 1491 break; 1492 } 1493 1494 twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl); 1495 1496 priv->pll = TWL6040_LPPLL_ID; 1497 priv->sysclk_constraints = &lp_constraints; 1498 break; 1499 case TWL6040_SYSCLK_SEL_HPPLL: 1500 hppllctl &= ~TWL6040_MCLK_MSK; 1501 1502 switch (freq) { 1503 case 12000000: 1504 /* mclk input, pll enabled */ 1505 hppllctl |= TWL6040_MCLK_12000KHZ | 1506 TWL6040_HPLLSQRBP | 1507 TWL6040_HPLLENA; 1508 break; 1509 case 19200000: 1510 /* mclk input, pll disabled */ 1511 hppllctl |= TWL6040_MCLK_19200KHZ | 1512 TWL6040_HPLLSQRENA | 1513 TWL6040_HPLLBP; 1514 break; 1515 case 26000000: 1516 /* mclk input, pll enabled */ 1517 hppllctl |= TWL6040_MCLK_26000KHZ | 1518 TWL6040_HPLLSQRBP | 1519 TWL6040_HPLLENA; 1520 break; 1521 case 38400000: 1522 /* clk slicer, pll disabled */ 1523 hppllctl |= TWL6040_MCLK_38400KHZ | 1524 TWL6040_HPLLSQRENA | 1525 TWL6040_HPLLBP; 1526 break; 1527 default: 1528 dev_err(codec->dev, "unknown mclk freq %d\n", freq); 1529 return -EINVAL; 1530 } 1531 1532 /* headset dac and driver must be in high-performance mode */ 1533 headset_power_mode(codec, 1); 1534 1535 twl6040_write(codec, TWL6040_REG_HPPLLCTL, hppllctl); 1536 udelay(500); 1537 lppllctl |= TWL6040_HPLLSEL; 1538 twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl); 1539 lppllctl &= ~TWL6040_LPLLENA; 1540 twl6040_write(codec, TWL6040_REG_LPPLLCTL, lppllctl); 1541 1542 /* high-performance pll can provide only 19.2 MHz */ 1543 priv->pll = TWL6040_HPPLL_ID; 1544 priv->sysclk = 19200000; 1545 priv->sysclk_constraints = &hp_constraints; 1546 break; 1547 default: 1548 dev_err(codec->dev, "unknown clk_id %d\n", clk_id); 1549 return -EINVAL; 1550 } 1551 1552 return 0; 1553 } 1554 1555 static struct snd_soc_dai_ops twl6040_dai_ops = { 1556 .startup = twl6040_startup, 1557 .hw_params = twl6040_hw_params, 1558 .prepare = twl6040_prepare, 1559 .set_sysclk = twl6040_set_dai_sysclk, 1560 }; 1561 1562 static struct snd_soc_dai_driver twl6040_dai = { 1563 .name = "twl6040-hifi", 1564 .playback = { 1565 .stream_name = "Playback", 1566 .channels_min = 1, 1567 .channels_max = 4, 1568 .rates = TWL6040_RATES, 1569 .formats = TWL6040_FORMATS, 1570 }, 1571 .capture = { 1572 .stream_name = "Capture", 1573 .channels_min = 1, 1574 .channels_max = 2, 1575 .rates = TWL6040_RATES, 1576 .formats = TWL6040_FORMATS, 1577 }, 1578 .ops = &twl6040_dai_ops, 1579 }; 1580 1581 #ifdef CONFIG_PM 1582 static int twl6040_suspend(struct snd_soc_codec *codec, pm_message_t state) 1583 { 1584 twl6040_set_bias_level(codec, SND_SOC_BIAS_OFF); 1585 1586 return 0; 1587 } 1588 1589 static int twl6040_resume(struct snd_soc_codec *codec) 1590 { 1591 twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 1592 twl6040_set_bias_level(codec, codec->dapm.suspend_bias_level); 1593 1594 return 0; 1595 } 1596 #else 1597 #define twl6040_suspend NULL 1598 #define twl6040_resume NULL 1599 #endif 1600 1601 static int twl6040_probe(struct snd_soc_codec *codec) 1602 { 1603 struct twl4030_codec_data *twl_codec = codec->dev->platform_data; 1604 struct twl6040_data *priv; 1605 int audpwron, naudint; 1606 int ret = 0; 1607 u8 icrev, intmr = TWL6040_ALLINT_MSK; 1608 1609 priv = kzalloc(sizeof(struct twl6040_data), GFP_KERNEL); 1610 if (priv == NULL) 1611 return -ENOMEM; 1612 snd_soc_codec_set_drvdata(codec, priv); 1613 1614 priv->codec = codec; 1615 1616 twl_i2c_read_u8(TWL_MODULE_AUDIO_VOICE, &icrev, TWL6040_REG_ASICREV); 1617 1618 if (twl_codec && (icrev > 0)) 1619 audpwron = twl_codec->audpwron_gpio; 1620 else 1621 audpwron = -EINVAL; 1622 1623 if (twl_codec) 1624 naudint = twl_codec->naudint_irq; 1625 else 1626 naudint = 0; 1627 1628 priv->audpwron = audpwron; 1629 priv->naudint = naudint; 1630 priv->workqueue = create_singlethread_workqueue("twl6040-codec"); 1631 1632 if (!priv->workqueue) 1633 goto work_err; 1634 1635 INIT_DELAYED_WORK(&priv->delayed_work, twl6040_accessory_work); 1636 1637 mutex_init(&priv->mutex); 1638 1639 init_completion(&priv->ready); 1640 init_completion(&priv->headset.ramp_done); 1641 init_completion(&priv->handsfree.ramp_done); 1642 1643 if (gpio_is_valid(audpwron)) { 1644 ret = gpio_request(audpwron, "audpwron"); 1645 if (ret) 1646 goto gpio1_err; 1647 1648 ret = gpio_direction_output(audpwron, 0); 1649 if (ret) 1650 goto gpio2_err; 1651 1652 priv->codec_powered = 0; 1653 1654 /* enable only codec ready interrupt */ 1655 intmr &= ~(TWL6040_READYMSK | TWL6040_PLUGMSK); 1656 1657 /* reset interrupt status to allow correct power up sequence */ 1658 twl6040_read_reg_volatile(codec, TWL6040_REG_INTID); 1659 } 1660 twl6040_write(codec, TWL6040_REG_INTMR, intmr); 1661 1662 if (naudint) { 1663 /* audio interrupt */ 1664 ret = request_threaded_irq(naudint, NULL, 1665 twl6040_naudint_handler, 1666 IRQF_TRIGGER_LOW | IRQF_ONESHOT, 1667 "twl6040_codec", codec); 1668 if (ret) 1669 goto gpio2_err; 1670 } 1671 1672 /* init vio registers */ 1673 twl6040_init_vio_regs(codec); 1674 1675 priv->hf_workqueue = create_singlethread_workqueue("twl6040-hf"); 1676 if (priv->hf_workqueue == NULL) { 1677 ret = -ENOMEM; 1678 goto irq_err; 1679 } 1680 priv->hs_workqueue = create_singlethread_workqueue("twl6040-hs"); 1681 if (priv->hs_workqueue == NULL) { 1682 ret = -ENOMEM; 1683 goto wq_err; 1684 } 1685 1686 INIT_DELAYED_WORK(&priv->hs_delayed_work, twl6040_pga_hs_work); 1687 INIT_DELAYED_WORK(&priv->hf_delayed_work, twl6040_pga_hf_work); 1688 1689 /* power on device */ 1690 ret = twl6040_set_bias_level(codec, SND_SOC_BIAS_STANDBY); 1691 if (ret) 1692 goto bias_err; 1693 1694 snd_soc_add_controls(codec, twl6040_snd_controls, 1695 ARRAY_SIZE(twl6040_snd_controls)); 1696 twl6040_add_widgets(codec); 1697 1698 return 0; 1699 1700 bias_err: 1701 destroy_workqueue(priv->hs_workqueue); 1702 wq_err: 1703 destroy_workqueue(priv->hf_workqueue); 1704 irq_err: 1705 if (naudint) 1706 free_irq(naudint, codec); 1707 gpio2_err: 1708 if (gpio_is_valid(audpwron)) 1709 gpio_free(audpwron); 1710 gpio1_err: 1711 destroy_workqueue(priv->workqueue); 1712 work_err: 1713 kfree(priv); 1714 return ret; 1715 } 1716 1717 static int twl6040_remove(struct snd_soc_codec *codec) 1718 { 1719 struct twl6040_data *priv = snd_soc_codec_get_drvdata(codec); 1720 int audpwron = priv->audpwron; 1721 int naudint = priv->naudint; 1722 1723 twl6040_set_bias_level(codec, SND_SOC_BIAS_OFF); 1724 1725 if (gpio_is_valid(audpwron)) 1726 gpio_free(audpwron); 1727 1728 if (naudint) 1729 free_irq(naudint, codec); 1730 1731 destroy_workqueue(priv->workqueue); 1732 destroy_workqueue(priv->hf_workqueue); 1733 destroy_workqueue(priv->hs_workqueue); 1734 kfree(priv); 1735 1736 return 0; 1737 } 1738 1739 static struct snd_soc_codec_driver soc_codec_dev_twl6040 = { 1740 .probe = twl6040_probe, 1741 .remove = twl6040_remove, 1742 .suspend = twl6040_suspend, 1743 .resume = twl6040_resume, 1744 .read = twl6040_read_reg_cache, 1745 .write = twl6040_write, 1746 .set_bias_level = twl6040_set_bias_level, 1747 .reg_cache_size = ARRAY_SIZE(twl6040_reg), 1748 .reg_word_size = sizeof(u8), 1749 .reg_cache_default = twl6040_reg, 1750 }; 1751 1752 static int __devinit twl6040_codec_probe(struct platform_device *pdev) 1753 { 1754 return snd_soc_register_codec(&pdev->dev, 1755 &soc_codec_dev_twl6040, &twl6040_dai, 1); 1756 } 1757 1758 static int __devexit twl6040_codec_remove(struct platform_device *pdev) 1759 { 1760 snd_soc_unregister_codec(&pdev->dev); 1761 return 0; 1762 } 1763 1764 static struct platform_driver twl6040_codec_driver = { 1765 .driver = { 1766 .name = "twl6040-codec", 1767 .owner = THIS_MODULE, 1768 }, 1769 .probe = twl6040_codec_probe, 1770 .remove = __devexit_p(twl6040_codec_remove), 1771 }; 1772 1773 static int __init twl6040_codec_init(void) 1774 { 1775 return platform_driver_register(&twl6040_codec_driver); 1776 } 1777 module_init(twl6040_codec_init); 1778 1779 static void __exit twl6040_codec_exit(void) 1780 { 1781 platform_driver_unregister(&twl6040_codec_driver); 1782 } 1783 module_exit(twl6040_codec_exit); 1784 1785 MODULE_DESCRIPTION("ASoC TWL6040 codec driver"); 1786 MODULE_AUTHOR("Misael Lopez Cruz"); 1787 MODULE_LICENSE("GPL"); 1788