2 * ALSA Mixer implementation for TSC2301
4 * Copyright (C) 2006 Nokia Corporation.
6 * Contact: Jarkko Nikula <jarkko.nikula@nokia.com>
9 * Some notes about TSC2301:
10 * - PLL will stop when DAC and ADC's are powered down.
11 * - Touchscreen will stop working when audio part is powered up and if audio
12 * MCLK is stopped. Problem is avoided if audio is powered down before
14 * - Audio DAC or audio outputs will activate only after 100 msec from the
15 * chip power-up. Reason seems to be VCM since there is no this delay if the
16 * chip and VCM (bit AVPD on PD/MISC) were not powered down. The chip will
17 * consume about 1 mA if all other audio blocks are powered down except the
18 * chip itself and VCM. Full power down consumes only about few uA.
19 * - Power-down transition could happen earliest about 100 msec after the chip
20 * power-up. Otherwise power-down will fail if there is no that 100 msec
21 * on time before it. It's not obvious why is that since chip reports
22 * power-up to be completed and also PLL output on GPIO_0 is active in few
25 * This program is free software; you can redistribute it and/or
26 * modify it under the terms of the GNU General Public License
27 * version 2 as published by the Free Software Foundation.
29 * This program is distributed in the hope that it will be useful, but
30 * WITHOUT ANY WARRANTY; without even the implied warranty of
31 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
32 * General Public License for more details.
34 * You should have received a copy of the GNU General Public License
35 * along with this program; if not, write to the Free Software
36 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
41 #include <linux/module.h>
42 #include <linux/device.h>
43 #include <linux/errno.h>
44 #include <linux/delay.h>
45 #include <linux/slab.h>
46 #include <linux/spi/spi.h>
47 #include <linux/spi/tsc2301.h>
49 #include <sound/driver.h>
50 #include <sound/core.h>
51 #include <sound/control.h>
53 /* shadow register indexes */
55 /* audio control and volume registers */
60 /* keyclick control register (not needed here) */
61 /* audio power control register */
63 /* TSC2301 GPIO control register */
69 /* structure for driver private data */
70 struct tsc2301_mixer {
74 /* shadow registers holding TSC2301 audio registers. Used to hold
75 * their states during the sleep and also to reduce communication with
76 * the chip since get callback functions could get register values
77 * directly from these shadow registers without needing to read them
79 u16 shadow_regs[SHADOW_REG_COUNT];
81 /* audio controller driver usage of the ADC and DAC */
82 unsigned adc_enabled:1, dac_enabled:1;
83 unsigned pll_output:1;
84 unsigned mclk_enabled;
86 /* latest audio power-up timestamp */
87 unsigned long pu_jiffies;
89 /* these are used when upper layer(s) are going to power-down TSC2301
90 * before 100 msec is passed from power-up */
91 struct delayed_work delayed_power_down;
92 unsigned delayed_pd_active:1;
94 int (* platform_init)(struct device *);
95 void (* platform_cleanup)(struct device *);
97 struct tsc2301_mixer_gpio *mixer_gpios;
101 #define TSC2301_DAC_DELAY msecs_to_jiffies(100)
102 #define TSC2301_MIN_PU_PERIOD msecs_to_jiffies(100)
104 #define TSC2301_REG_TO_PVAL(reg) \
105 (TSC2301_REG_TO_PAGE(reg) << 6 | TSC2301_REG_TO_ADDR(reg))
106 #define TSC2301_PVAL_TO_REG(v) \
107 (TSC2301_REG((((v) >> 6) & 3),((v) & 0x1f)))
109 #define TSC2301_VOLUME_MASK 0x7f
110 #define TSC2301_MIN_ADCVOL 6
111 #define TSC2301_MIN_DACVOL 0
112 #define TSC2301_MIN_BPVOL 31
113 #define TSC2301_MUTE_LEFT_SHIFT 15
114 #define TSC2301_VOL_LEFT_SHIFT 8
115 #define TSC2301_MUTE_RIGHT_SHIFT 7
116 #define TSC2301_VOL_RIGHT_SHIFT 0
118 #define TSC2301_INM_MASK 3
119 #define TSC2301_INML_SHIFT 12
120 #define TSC2301_INMR_SHIFT 10
122 #define TSC2301_MICG_MASK 3
123 #define TSC2301_MICG_MIN 1 /* values 0 & 1 both mean 0 dB */
124 #define TSC2301_MICG_SHIFT 8
126 #define TSC2301_REG_AUDCNTL_MCLK(v) (((v) & 3) << 6)
127 #define TSC2301_REG_AUDCNTL_I2SFS(v) (((v) & 0xf) << 2)
128 #define TSC2301_REG_AUDCNTL_I2SFM(v) (((v) & 3) << 0)
130 #define TSC2301_SINGLE(xname, xindex, reg, shadow_index, shift, mask, min) \
132 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
135 .info = snd_tsc2301_info_single, \
136 .get = snd_tsc2301_get_single, \
137 .put = snd_tsc2301_put_single, \
138 .private_value = TSC2301_REG_TO_PVAL(reg) | \
139 (shadow_index << 8) | (shift << 16) | (mask << 24) | \
142 #define TSC2301_SINGLE_MINVAL(v) (((v) >> 28) & 15)
143 #define TSC2301_SINGLE_SHIFT(v) (((v) >> 16) & 15)
144 #define TSC2301_SINGLE_MASK(v) (((v) >> 24) & 15)
146 #define TSC2301_DOUBLE(xname, xindex, reg, shadow_index, ls, rs, mask, min) \
148 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
151 .info = snd_tsc2301_info_double, \
152 .get = snd_tsc2301_get_double, \
153 .put = snd_tsc2301_put_double, \
154 .private_value = TSC2301_REG_TO_PVAL(reg) | \
155 (shadow_index << 8) | (min << 11) | \
156 (ls << 16) | (rs << 20) | (mask << 24) \
158 #define TSC2301_DOUBLE_MINVAL(v) (((v) >> 11) & 0x1f)
159 #define TSC2301_DOUBLE_LEFT_SHIFT(v) (((v) >> 16) & 15)
160 #define TSC2301_DOUBLE_RIGHT_SHIFT(v) (((v) >> 20) & 15)
161 #define TSC2301_DOUBLE_MASK(v) (((v) >> 24) & TSC2301_VOLUME_MASK)
163 #define TSC2301_MUX(xname, xindex, reg, shadow_index, ls, rs, mask) \
165 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
168 .info = snd_tsc2301_info_mux, \
169 .get = snd_tsc2301_get_mux, \
170 .put = snd_tsc2301_put_mux, \
171 .private_value = TSC2301_REG_TO_PVAL(reg) | \
172 (shadow_index << 8) | (ls << 16) | (rs << 20) | (mask << 24) \
174 #define TSC2301_MUX_LEFT_SHIFT(v) (((v) >> 16) & 15)
175 #define TSC2301_MUX_RIGHT_SHIFT(v) (((v) >> 20) & 15)
176 #define TSC2301_MUX_MASK(v) (((v) >> 24) & TSC2301_VOLUME_MASK)
178 #define TSC2301_BOOL(xname, xindex, reg, shadow_index, shift, invert, state) \
180 .iface = SNDRV_CTL_ELEM_IFACE_MIXER, \
183 .info = snd_tsc2301_info_bool, \
184 .get = snd_tsc2301_get_bool, \
185 .put = snd_tsc2301_put_bool, \
186 .private_value = TSC2301_REG_TO_PVAL(reg) | \
187 (shadow_index << 8) | (shift << 16) | \
188 (invert << 24) | (state << 25) \
190 #define TSC2301_BOOL_SHIFT(v) (((v) >> 16) & 7)
191 #define TSC2301_BOOL_INVERT(v) (((v) >> 24) & 1)
192 #define TSC2301_BOOL_STATE(v) (((v) >> 25) & 1)
194 #define TSC2301_SHADOW_INDEX(v) (((v) >> 8) & 7)
197 * Power-down handler for additional GPIO mixer controls. GPIO state of GPIO
198 * controls whose power-down flag is enabled are set to their false/deactivate
201 * Must be called tsc->mixer->mutex locked
203 static void tsc2301_gpio_power_down(struct tsc2301 *tsc)
205 struct tsc2301_mixer *mix = tsc->mixer;
209 temp = mix->shadow_regs[GPIO_INDEX];
210 for (i = 0; i < mix->n_mixer_gpios; i++) {
211 const struct tsc2301_mixer_gpio *mg;
213 mg = mix->mixer_gpios + i;
214 if (mg->deactivate_on_pd) {
217 temp &= ~(1 << gpio);
218 temp |= mg->inverted << gpio;
221 tsc2301_write_reg(tsc, TSC2301_REG_GPIO, temp);
225 * Powers down/up audio blocks which are muted or become unused.
226 * shadow_index >= 0, changes power state of single audio block
227 * shadow_index < 0, changes power state of all blocks
229 * Must be called tsc->mixer->mutex locked
231 #define TSC2301_MUTE_MASK \
232 ((1 << TSC2301_MUTE_LEFT_SHIFT) | (1 << TSC2301_MUTE_RIGHT_SHIFT))
233 static void tsc2301_power_ctrl(struct tsc2301 *tsc, int shadow_index,
236 struct tsc2301_mixer *mix = tsc->mixer;
237 u16 pd_ctrl, pd_ctrl_old, w;
238 unsigned long timeout;
241 if (mix->delayed_pd_active) {
242 mix->delayed_pd_active = 0;
244 cancel_delayed_work(&mix->delayed_power_down);
247 pd_ctrl = pd_ctrl_old = mix->shadow_regs[PD_MISC_INDEX];
248 /* power control helper based on used space mixer selections. See
249 * actual power control decisions below */
250 if (shadow_index < 0 || shadow_index == ADCVOL_INDEX) {
251 /* ADC left and right power down control */
252 if (mix->shadow_regs[ADCVOL_INDEX] &
253 (1 << TSC2301_MUTE_LEFT_SHIFT))
254 /* left ADC muted. Power down the left ADC */
255 pd_ctrl |= TSC2301_REG_PD_MISC_ADPDL;
257 pd_ctrl &= ~TSC2301_REG_PD_MISC_ADPDL;
258 if (mix->shadow_regs[ADCVOL_INDEX] &
259 (1 << TSC2301_MUTE_LEFT_SHIFT))
260 /* right ADC muted. Power down the right ADC */
261 pd_ctrl |= TSC2301_REG_PD_MISC_ADPDR;
263 pd_ctrl &= ~TSC2301_REG_PD_MISC_ADPDR;
265 if (shadow_index < 0 || shadow_index == DACVOL_INDEX) {
266 /* DAC power down control */
267 if ((mix->shadow_regs[DACVOL_INDEX] &
268 TSC2301_MUTE_MASK) == TSC2301_MUTE_MASK)
269 /* both DACs muted. Power down the DAC */
270 pd_ctrl |= TSC2301_REG_PD_MISC_DAPD;
272 pd_ctrl &= ~TSC2301_REG_PD_MISC_DAPD;
274 if (shadow_index < 0 || shadow_index == BPVOL_INDEX) {
275 /* line bypass power down control */
276 if ((mix->shadow_regs[BPVOL_INDEX] &
277 TSC2301_MUTE_MASK) == TSC2301_MUTE_MASK)
278 /* both line bypasses muted. Power down the bypass
280 pd_ctrl |= TSC2301_REG_PD_MISC_ABPD;
282 pd_ctrl &= ~TSC2301_REG_PD_MISC_ABPD;
284 if (shadow_index < 0 || shadow_index == AUDCNTL_INDEX) {
285 /* mic bias power down control */
286 if ((mix->shadow_regs[AUDCNTL_INDEX] &
287 (3 << TSC2301_INML_SHIFT)) &&
288 (mix->shadow_regs[AUDCNTL_INDEX] &
289 (3 << TSC2301_INMR_SHIFT)))
290 /* both ADC channels use other than mic input. Power
291 * down the mic bias output */
292 pd_ctrl |= TSC2301_REG_PD_MISC_MIBPD;
294 pd_ctrl &= ~TSC2301_REG_PD_MISC_MIBPD;
297 /* power control decisions based on codec usage and user space mixer
298 * selections detected above */
299 pd_ctrl &= ~TSC2301_REG_PD_MISC_APD; /* audio not powered down */
300 if (mix->mclk_enabled) {
301 if (!mix->adc_enabled) {
302 /* ADC not used, power down both ADC's and mic bias
303 * output independently of user space mixer
305 pd_ctrl |= TSC2301_REG_PD_MISC_ADPDL;
306 pd_ctrl |= TSC2301_REG_PD_MISC_ADPDR;
307 pd_ctrl |= TSC2301_REG_PD_MISC_MIBPD;
309 if (!mix->dac_enabled) {
310 /* DAC not used, power down DAC independently of user
311 * space mixer selections */
312 pd_ctrl |= TSC2301_REG_PD_MISC_DAPD;
315 if (mix->pll_output) {
316 /* GPIO_0 is configured as PLL output so audio
317 * controller is expecting clock from TSC2301. Either
318 * ADC or DAC must be active in order to keep PLL on */
319 if ((pd_ctrl & TSC2301_REG_PD_MISC_ADPDL) &&
320 (pd_ctrl & TSC2301_REG_PD_MISC_ADPDR) &&
321 (pd_ctrl & TSC2301_REG_PD_MISC_DAPD)) {
322 /* neither ADC or DAC used. Force ADC on in
323 * order to keep PLL active */
324 pd_ctrl &= ~(TSC2301_REG_PD_MISC_ADPDL |
325 TSC2301_REG_PD_MISC_ADPDR);
329 /* audio input clock is not enabled so power down DAC and ADC
330 * in order to shutdown PLL and to keep touchscreen and keypad
331 * parts working. Touchscreen and keypad use audio clock when
332 * PLL is on and internal clock otherwise */
333 pd_ctrl |= TSC2301_REG_PD_MISC_DAPD |
334 TSC2301_REG_PD_MISC_ADPDL |
335 TSC2301_REG_PD_MISC_ADPDR;
338 if ((pd_ctrl & TSC2301_REG_PD_MISC_ADPDL) &&
339 (pd_ctrl & TSC2301_REG_PD_MISC_ADPDR) &&
340 (pd_ctrl & TSC2301_REG_PD_MISC_DAPD) &&
341 (pd_ctrl & TSC2301_REG_PD_MISC_ABPD)) {
342 /* all ADC, DAC and line bypass path unused. Power down the
343 * whole audio part of the TSC2301 */
344 pd_ctrl |= TSC2301_REG_PD_MISC_APD;
347 if (pd_ctrl == pd_ctrl_old)
350 /* power down control changed. Update into TSC2301 */
351 if ((pd_ctrl ^ pd_ctrl_old) & TSC2301_REG_PD_MISC_APD) {
352 /* whole audio power state changed. Update GPIO states */
353 if (pd_ctrl & TSC2301_REG_PD_MISC_APD) {
354 /* power down GPIO controls before powering down
356 tsc2301_gpio_power_down(tsc);
357 /* we must really ensure that codec has been on no less
358 * than 100 msec before doing power-down */
359 timeout = mix->pu_jiffies + TSC2301_MIN_PU_PERIOD -
361 if (timeout <= TSC2301_MIN_PU_PERIOD) {
362 mix->delayed_pd_active = 1;
364 schedule_delayed_work(&mix->delayed_power_down,
369 /* restore GPIOs after codec is powered up */
372 mix->shadow_regs[PD_MISC_INDEX] = pd_ctrl;
373 tsc2301_write_reg(tsc, TSC2301_REG_PD_MISC, pd_ctrl);
375 mix->pu_jiffies = jiffies;
378 tsc2301_write_reg(tsc, TSC2301_REG_GPIO,
379 mix->shadow_regs[GPIO_INDEX]);
383 /* wait until power-up/-down is completed */
384 timeout = jiffies + msecs_to_jiffies(100);
387 if (time_after(jiffies, timeout)) {
388 /* Print a warning only if the I2S clock is not
389 * present / out of sync. This can happen during
390 * init time, when that clock will be turned on
391 * by another driver like in the OMAP EAC with
392 * external clock case.
394 if (w & TSC2301_REG_PD_MISC_OTSYN) {
395 dev_warn(&tsc->spi->dev,
396 "I2S clock not in sync or off.\n");
398 dev_err(&tsc->spi->dev,
399 "power-up/-down timed out "
400 "(0x%04x, 0x%04x -> 0x%04x)\n",
401 w, pd_ctrl_old, pd_ctrl);
405 w = tsc2301_read_reg(tsc, TSC2301_REG_PD_MISC);
406 } while (!(w & TSC2301_REG_PD_MISC_PDSTS));
409 if (((pd_ctrl ^ pd_ctrl_old) & TSC2301_REG_PD_MISC_DAPD) &&
410 !(pd_ctrl & TSC2301_REG_PD_MISC_DAPD)) {
411 /* DAC powered up now. Ensure that DAC and audio outputs are
412 * activated. They are up 100 msec after the chip power-up
414 timeout = mix->pu_jiffies + TSC2301_DAC_DELAY - jiffies;
415 if (timeout <= TSC2301_DAC_DELAY)
416 schedule_timeout_interruptible(timeout);
417 /* FIXME: This is lazy. We restore GPIOs only after activating
418 * the DAC. It would be better to do some kind of delayed GPIO
419 * restore. That ensures that we restore them also if only ADC
420 * path is activated. But this is required only if there is
421 * some input amplifier, bias control, etc. and their power
422 * state is under TSC GPIO control */
423 tsc2301_write_reg(tsc, TSC2301_REG_GPIO,
424 mix->shadow_regs[GPIO_INDEX]);
428 static int snd_tsc2301_info_single(struct snd_kcontrol *kcontrol,
429 struct snd_ctl_elem_info *uinfo)
431 int mask = TSC2301_SINGLE_MASK(kcontrol->private_value);
432 int minval = TSC2301_SINGLE_MINVAL(kcontrol->private_value);
434 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
436 uinfo->value.integer.min = minval;
437 uinfo->value.integer.max = mask;
442 static int snd_tsc2301_get_single(struct snd_kcontrol *kcontrol,
443 struct snd_ctl_elem_value *ucontrol)
445 struct tsc2301 *tsc = kcontrol->private_data;
446 unsigned long priv = kcontrol->private_value;
447 int mask = TSC2301_SINGLE_MASK(priv);
448 int shift = TSC2301_SINGLE_SHIFT(priv);
449 int shadow_index = TSC2301_SHADOW_INDEX(priv);
452 shadow_reg = tsc->mixer->shadow_regs[shadow_index];
454 ucontrol->value.integer.value[0] = (shadow_reg >> shift) & mask;
459 static int snd_tsc2301_put_single(struct snd_kcontrol *kcontrol,
460 struct snd_ctl_elem_value *ucontrol)
462 struct tsc2301 *tsc = kcontrol->private_data;
463 unsigned long priv = kcontrol->private_value;
464 int mask = TSC2301_SINGLE_MASK(priv);
465 int shadow_index = TSC2301_SHADOW_INDEX(priv);
466 u16 shadow_reg, shadow_reg_old;
467 int shift = TSC2301_SINGLE_SHIFT(priv);
468 int reg = TSC2301_PVAL_TO_REG(priv);
471 mutex_lock(&tsc->mixer->mutex);
472 shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
474 /* zero bits to be modified */
475 shadow_reg &= ~(mask << shift);
476 /* modify with new value */
477 shadow_reg |= ((ucontrol->value.integer.value[0] & mask) << shift);
479 changed = (shadow_reg != shadow_reg_old);
480 tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
482 /* update into TSC2301 if necessary */
484 tsc2301_write_reg(tsc, reg, shadow_reg);
485 mutex_unlock(&tsc->mixer->mutex);
490 static int snd_tsc2301_info_double(struct snd_kcontrol *kcontrol,
491 struct snd_ctl_elem_info *uinfo)
493 /* mask == 1 : Switch
494 * mask > 1 : Max volume */
495 int mask = TSC2301_DOUBLE_MASK(kcontrol->private_value);
496 int minval = TSC2301_DOUBLE_MINVAL(kcontrol->private_value);
498 uinfo->type = mask == 1 ? SNDRV_CTL_ELEM_TYPE_BOOLEAN :
499 SNDRV_CTL_ELEM_TYPE_INTEGER;
501 uinfo->value.integer.min = minval;
502 uinfo->value.integer.max = mask;
507 static int snd_tsc2301_get_double(struct snd_kcontrol *kcontrol,
508 struct snd_ctl_elem_value *ucontrol)
510 struct tsc2301 *tsc = kcontrol->private_data;
511 unsigned long priv = kcontrol->private_value;
512 /* mask == 1 : Switch
513 * mask > 1 : Volume */
514 int mask = TSC2301_DOUBLE_MASK(priv);
515 int ls = TSC2301_DOUBLE_LEFT_SHIFT(priv);
516 int rs = TSC2301_DOUBLE_RIGHT_SHIFT(priv);
517 int shadow_index = TSC2301_SHADOW_INDEX(priv);
520 shadow_reg = tsc->mixer->shadow_regs[shadow_index];
522 /* invert mute bits for the switches */
524 shadow_reg = ~shadow_reg;
526 ucontrol->value.integer.value[0] = (shadow_reg >> ls) & mask;
527 ucontrol->value.integer.value[1] = (shadow_reg >> rs) & mask;
532 static int snd_tsc2301_put_double(struct snd_kcontrol *kcontrol,
533 struct snd_ctl_elem_value *ucontrol)
535 struct tsc2301 *tsc = kcontrol->private_data;
536 unsigned long priv = kcontrol->private_value;
537 /* mask == 1 : Switch
538 * mask > 1 : Volume */
539 int mask = TSC2301_DOUBLE_MASK(priv);
540 int shadow_index = TSC2301_SHADOW_INDEX(priv);
541 u16 shadow_reg, shadow_reg_old;
542 int ls = TSC2301_DOUBLE_LEFT_SHIFT(priv);
543 int rs = TSC2301_DOUBLE_RIGHT_SHIFT(priv);
544 int reg = TSC2301_PVAL_TO_REG(priv);
547 mutex_lock(&tsc->mixer->mutex);
548 shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
550 /* zero bits to be modified */
551 shadow_reg &= ~((mask << ls) | (mask << rs));
552 /* modify with new value */
554 /* switch. Invert switch values for the mute bits */
556 ((~ucontrol->value.integer.value[0] & mask) << ls) |
557 ((~ucontrol->value.integer.value[1] & mask) << rs);
561 (ucontrol->value.integer.value[0] << ls) |
562 (ucontrol->value.integer.value[1] << rs);
565 changed = (shadow_reg != shadow_reg_old);
566 tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
568 /* update into TSC2301 if necessary */
570 tsc2301_write_reg(tsc, reg, shadow_reg);
573 /* check is need to power down/up audio blocks in case of
574 * muted state change */
575 tsc2301_power_ctrl(tsc, shadow_index, 0);
576 mutex_unlock(&tsc->mixer->mutex);
581 static int snd_tsc2301_info_mux(struct snd_kcontrol *kcontrol,
582 struct snd_ctl_elem_info *uinfo)
584 static char *texts[4] = {"Mic", "Line", "Line swapped", "Line mono"};
586 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
588 uinfo->value.enumerated.items = 4;
589 if (uinfo->value.enumerated.item > 3)
590 uinfo->value.enumerated.item = 3;
591 strcpy(uinfo->value.enumerated.name,
592 texts[uinfo->value.enumerated.item]);
597 static int snd_tsc2301_get_mux(struct snd_kcontrol *kcontrol,
598 struct snd_ctl_elem_value *ucontrol)
600 struct tsc2301 *tsc = kcontrol->private_data;
601 unsigned long priv = kcontrol->private_value;
602 int mask = TSC2301_MUX_MASK(priv);
603 int ls = TSC2301_MUX_LEFT_SHIFT(priv);
604 int rs = TSC2301_MUX_RIGHT_SHIFT(priv);
605 int shadow_index = TSC2301_SHADOW_INDEX(priv);
608 shadow_reg = tsc->mixer->shadow_regs[shadow_index];
609 ucontrol->value.enumerated.item[0] = (shadow_reg >> ls) & mask;
610 ucontrol->value.enumerated.item[1] = (shadow_reg >> rs) & mask;
615 static int snd_tsc2301_put_mux(struct snd_kcontrol *kcontrol,
616 struct snd_ctl_elem_value *ucontrol)
618 struct tsc2301 *tsc = kcontrol->private_data;
619 unsigned long priv = kcontrol->private_value;
620 int mask = TSC2301_MUX_MASK(priv);
621 int shadow_index = TSC2301_SHADOW_INDEX(priv);
622 u16 shadow_reg, shadow_reg_old;
623 int ls = TSC2301_MUX_LEFT_SHIFT(priv);
624 int rs = TSC2301_MUX_RIGHT_SHIFT(priv);
625 int reg = TSC2301_PVAL_TO_REG(priv);
628 mutex_lock(&tsc->mixer->mutex);
629 shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
631 /* zero bits to be modified */
632 shadow_reg &= ~((mask << ls) | (mask << rs));
633 /* modify with new value */
634 shadow_reg |= (ucontrol->value.enumerated.item[0] << ls);
635 shadow_reg |= (ucontrol->value.enumerated.item[1] << rs);
637 changed = (shadow_reg != shadow_reg_old);
639 /* update into TSC2301 if necessary */
641 tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
642 tsc2301_write_reg(tsc, reg, shadow_reg);
645 /* check is need to power up/down audio blocks in case of ADC input
647 tsc2301_power_ctrl(tsc, shadow_index, 0);
648 mutex_unlock(&tsc->mixer->mutex);
653 static int snd_tsc2301_info_bool(struct snd_kcontrol *kcontrol,
654 struct snd_ctl_elem_info *uinfo)
656 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
658 uinfo->value.integer.min = 0;
659 uinfo->value.integer.max = 1;
664 static int snd_tsc2301_get_bool(struct snd_kcontrol *kcontrol,
665 struct snd_ctl_elem_value *ucontrol)
667 struct tsc2301 *tsc = kcontrol->private_data;
668 unsigned long priv = kcontrol->private_value;
669 int shadow_index = TSC2301_SHADOW_INDEX(priv);
670 int shift = TSC2301_BOOL_SHIFT(priv);
671 int invert = TSC2301_BOOL_INVERT(priv);
674 shadow_reg = tsc->mixer->shadow_regs[shadow_index];
675 ucontrol->value.integer.value[0] =
676 invert ^ ((shadow_reg >> shift) & 1);
681 static int snd_tsc2301_put_bool(struct snd_kcontrol *kcontrol,
682 struct snd_ctl_elem_value *ucontrol)
684 struct tsc2301 *tsc = kcontrol->private_data;
685 unsigned long priv = kcontrol->private_value;
686 int shadow_index = TSC2301_SHADOW_INDEX(priv);
687 int shift = TSC2301_BOOL_SHIFT(priv);
688 int invert = TSC2301_BOOL_INVERT(priv);
689 int reg = TSC2301_PVAL_TO_REG(priv);
690 u16 shadow_reg, shadow_reg_old;
693 mutex_lock(&tsc->mixer->mutex);
694 shadow_reg = shadow_reg_old = tsc->mixer->shadow_regs[shadow_index];
696 /* zero bit to be modified */
697 shadow_reg &= ~(1 << shift);
698 /* modify with new value */
700 (invert ^ (ucontrol->value.integer.value[0] & 1)) << shift;
702 changed = (shadow_reg != shadow_reg_old);
704 /* update into TSC2301 if necessary */
706 tsc->mixer->shadow_regs[shadow_index] = shadow_reg;
707 if ((shadow_index == GPIO_INDEX) &&
708 (tsc->mixer->shadow_regs[PD_MISC_INDEX] &
709 TSC2301_REG_PD_MISC_APD)) {
710 /* changing GPIO control and audio is powered down.
711 * Update GPIO states according to their power-down
713 tsc2301_gpio_power_down(tsc);
715 tsc2301_write_reg(tsc, reg, shadow_reg);
717 mutex_unlock(&tsc->mixer->mutex);
722 /* TSC2301 internal mixer controls */
723 static struct snd_kcontrol_new snd_tsc2301_controls[] = {
724 /* stereo ADC input switches and volumes */
725 TSC2301_DOUBLE("Capture Switch", 0,
726 TSC2301_REG_ADCVOL, ADCVOL_INDEX,
727 TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
729 TSC2301_DOUBLE("Capture Volume", 0,
730 TSC2301_REG_ADCVOL, ADCVOL_INDEX,
731 TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
732 TSC2301_VOLUME_MASK, TSC2301_MIN_ADCVOL),
734 /* stereo DAC output switches and volumes */
735 TSC2301_DOUBLE("PCM Playback Switch", 0,
736 TSC2301_REG_DACVOL, DACVOL_INDEX,
737 TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
739 TSC2301_DOUBLE("PCM Playback Volume", 0,
740 TSC2301_REG_DACVOL, DACVOL_INDEX,
741 TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
742 TSC2301_VOLUME_MASK, TSC2301_MIN_DACVOL),
744 /* stereo line input bypass switches and volumes */
745 TSC2301_DOUBLE("Line Playback Switch", 0,
746 TSC2301_REG_BPVOL, BPVOL_INDEX,
747 TSC2301_MUTE_LEFT_SHIFT, TSC2301_MUTE_RIGHT_SHIFT,
749 TSC2301_DOUBLE("Line Playback Volume", 0,
750 TSC2301_REG_BPVOL, BPVOL_INDEX,
751 TSC2301_VOL_LEFT_SHIFT, TSC2301_VOL_RIGHT_SHIFT,
752 TSC2301_VOLUME_MASK, TSC2301_MIN_BPVOL),
754 /* mono microphone input gain */
755 TSC2301_SINGLE("Mic Boost", 0,
756 TSC2301_REG_AUDCNTL, AUDCNTL_INDEX,
758 TSC2301_MICG_MASK, TSC2301_MICG_MIN),
760 /* ADC input sources. Both channels could be selected separately */
761 TSC2301_MUX("Capture Source", 0,
762 TSC2301_REG_AUDCNTL, AUDCNTL_INDEX,
763 TSC2301_INML_SHIFT, TSC2301_INMR_SHIFT,
767 /* must be called tsc->mixer->mutex locked */
768 static void tsc2301_flush_shadow_regs(struct tsc2301 *tsc)
773 page = TSC2301_REG_TO_PAGE(TSC2301_REG_AUDCNTL);
774 addr = TSC2301_REG_TO_ADDR(TSC2301_REG_AUDCNTL);
776 for (i = 0; i < 4; i++) {
777 temp = tsc->mixer->shadow_regs[i];
778 tsc2301_write_reg(tsc, TSC2301_REG(page, addr + i), temp);
780 temp = tsc->mixer->shadow_regs[GPIO_INDEX];
781 tsc2301_write_reg(tsc, TSC2301_REG_GPIO, temp);
783 /* Update power state of all audio blocks depending are they
784 * muted or unused. */
785 tsc2301_power_ctrl(tsc, -1, 0);
789 int tsc2301_mixer_suspend(struct tsc2301 *tsc)
791 /* power down entire audio section inside TSC2301 in case the
792 * chip is still powered during the system sleep. However this driver
793 * doesn't require that chip is powered because registers are restored
794 * in function tsc2301_mixer_resume */
795 mutex_lock(&tsc->mixer->mutex);
796 tsc2301_gpio_power_down(tsc);
797 tsc->mixer->shadow_regs[PD_MISC_INDEX] |= TSC2301_REG_PD_MISC_APD;
798 tsc2301_write_reg(tsc, TSC2301_REG_PD_MISC,
799 tsc->mixer->shadow_regs[PD_MISC_INDEX]);
800 mutex_unlock(&tsc->mixer->mutex);
804 void tsc2301_mixer_resume(struct tsc2301 *tsc)
806 /* power up the TSC2301 audio section and restore registers */
807 mutex_lock(&tsc->mixer->mutex);
808 tsc->mixer->shadow_regs[PD_MISC_INDEX] &= ~TSC2301_REG_PD_MISC_APD;
809 tsc2301_flush_shadow_regs(tsc);
810 mutex_unlock(&tsc->mixer->mutex);
814 void tsc2301_mixer_enable_mclk(struct device *dev)
816 struct tsc2301 *tsc = dev_get_drvdata(dev);
817 struct tsc2301_mixer *mix = tsc->mixer;
819 mutex_lock(&mix->mutex);
820 if (!mix->mclk_enabled++ && tsc->enable_clock != NULL) {
821 tsc->enable_clock(dev);
823 tsc2301_power_ctrl(tsc, -1, 1);
824 mutex_unlock(&mix->mutex);
827 void tsc2301_mixer_disable_mclk(struct device *dev)
829 struct tsc2301 *tsc = dev_get_drvdata(dev);
830 struct tsc2301_mixer *mix = tsc->mixer;
832 mutex_lock(&mix->mutex);
834 tsc2301_power_ctrl(tsc, -1, 1);
835 if (!mix->mclk_enabled && tsc->disable_clock != NULL) {
836 tsc->disable_clock(dev);
838 mutex_unlock(&mix->mutex);
841 static void tsc2301_mixer_delayed_power_down(struct work_struct *work)
843 struct tsc2301_mixer *mix = container_of(work, struct tsc2301_mixer,
844 delayed_power_down.work);
845 struct tsc2301 *tsc = mix->tsc;
847 mutex_lock(&mix->mutex);
848 if (!mix->delayed_pd_active) {
849 mutex_unlock(&mix->mutex);
852 mix->delayed_pd_active = 0;
853 mutex_unlock(&mix->mutex);
854 tsc2301_mixer_disable_mclk(&tsc->spi->dev);
858 * Allows audio controller driver to notify its usage of ADC and DAC
860 void tsc2301_mixer_set_power(struct device *dev, int dac, int adc)
862 struct tsc2301 *tsc = dev_get_drvdata(dev);
864 mutex_lock(&tsc->mixer->mutex);
865 tsc->mixer->adc_enabled = adc;
866 tsc->mixer->dac_enabled = dac;
868 /* update power state of all audio blocks */
869 tsc2301_power_ctrl(tsc, -1, 1);
870 mutex_unlock(&tsc->mixer->mutex);
874 * Registers TSC2301 ALSA Mixer controls for the given sound card
876 int tsc2301_mixer_register_controls(struct device *dev, struct snd_card *card)
878 struct tsc2301 *tsc = dev_get_drvdata(dev);
879 struct tsc2301_mixer *mix = tsc->mixer;
882 /* Register ALSA mixer controls */
883 for (i = 0; i < ARRAY_SIZE(snd_tsc2301_controls); i++) {
884 err = snd_ctl_add(card,
885 snd_ctl_new1(&snd_tsc2301_controls[i], tsc));
890 if (!mix->n_mixer_gpios)
893 /* Register additional GPIO controls if defined */
894 for (i = 0; i < mix->n_mixer_gpios; i++) {
895 const struct tsc2301_mixer_gpio *mg = mix->mixer_gpios + i;
896 struct snd_kcontrol *ctrlp;
897 struct snd_kcontrol_new ctrl =
898 TSC2301_BOOL((char *)mg->name, 0,
899 TSC2301_REG_GPIO, GPIO_INDEX,
900 mg->gpio, mg->inverted, mg->def_enable);
902 ctrlp = snd_ctl_new1(&ctrl, tsc);
903 err = snd_ctl_add(card, ctrlp);
911 int tsc2301_mixer_init(struct tsc2301 *tsc,
912 struct tsc2301_platform_data *pdata)
914 struct tsc2301_mixer *mix;
918 mix = kzalloc(sizeof(*mix), GFP_KERNEL);
924 mutex_init(&mix->mutex);
925 mix->platform_init = pdata->codec_init;
926 mix->platform_cleanup = pdata->codec_cleanup;
927 mix->pll_output = pdata->pll_output;
929 INIT_DELAYED_WORK(&mix->delayed_power_down,
930 tsc2301_mixer_delayed_power_down);
932 /* initialize shadow register default values */
934 w |= (pdata->mclk_ratio << 6) | (pdata->i2s_sample_rate << 2);
935 w |= pdata->i2s_format;
936 mix->shadow_regs[AUDCNTL_INDEX] = w;
937 mix->shadow_regs[ADCVOL_INDEX] = 0xd7d7;
938 mix->shadow_regs[DACVOL_INDEX] = 0xffff;
939 mix->shadow_regs[BPVOL_INDEX] = 0xe7e7;
940 mix->shadow_regs[PD_MISC_INDEX] = pdata->power_down_blocks;
942 /* if extra mixer controls configured, then configure associated
943 * GPIOs as output and drive their default state */
944 if (pdata->n_mixer_gpios) {
948 for (i = 0; i < pdata->n_mixer_gpios; i++) {
949 const struct tsc2301_mixer_gpio *mg;
952 mg = pdata->mixer_gpios + i;
954 w |= (1 << gpio) << 8;
955 w |= (mg->inverted ^ mg->def_enable) << gpio;
957 mix->shadow_regs[GPIO_INDEX] = w;
959 mix->mixer_gpios = kmalloc(sizeof(*pdata->mixer_gpios) *
960 pdata->n_mixer_gpios,
962 if (mix->mixer_gpios == NULL) {
966 memcpy(mix->mixer_gpios, pdata->mixer_gpios,
967 sizeof(*pdata->mixer_gpios) * pdata->n_mixer_gpios);
968 mix->n_mixer_gpios = pdata->n_mixer_gpios;
972 tsc2301_write_pll(tsc, pdata->pll_n, pdata->pll_a, pdata->pll_pdc,
973 0, mix->pll_output ? 0 : 1);
975 tsc2301_flush_shadow_regs(tsc);
977 if (mix->platform_init != NULL) {
978 err = mix->platform_init(&tsc->spi->dev);
985 if (mix->mixer_gpios != NULL)
986 kfree(mix->mixer_gpios);
992 void tsc2301_mixer_exit(struct tsc2301 *tsc)
994 struct tsc2301_mixer *mixer = tsc->mixer;
996 if (mixer->platform_cleanup != NULL)
997 mixer->platform_cleanup(&tsc->spi->dev);
999 if (mixer->mixer_gpios != NULL)
1000 kfree(mixer->mixer_gpios);
1003 MODULE_AUTHOR("Jarkko Nikula <jarkko.nikula@nokia.com>");
1004 MODULE_LICENSE("GPL");