?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH] efs: Remove incorrect unlock_kernel from failure path in efs_symlink_readpage()
[linux-2.6.git] / sound / ppc / tumbler.c
blob692c6117767859f3749602372b0cb61112466ece
1 /*
2 * PMac Tumbler/Snapper lowlevel functions
3 *
4 * Copyright (c) by Takashi Iwai <tiwai@suse.de>
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 *
20 * Rene Rebe <rene.rebe@gmx.net>:
21 * * update from shadow registers on wakeup and headphone plug
22 * * automatically toggle DRC on headphone plug
23 *
24 */
25
26
27 #include <sound/driver.h>
28 #include <linux/init.h>
29 #include <linux/delay.h>
30 #include <linux/i2c.h>
31 #include <linux/kmod.h>
32 #include <linux/slab.h>
33 #include <linux/interrupt.h>
34 #include <sound/core.h>
35 #include <asm/io.h>
36 #include <asm/irq.h>
37 #include <asm/machdep.h>
38 #include <asm/pmac_feature.h>
39 #include "pmac.h"
40 #include "tumbler_volume.h"
41
42 #undef DEBUG
43
44 #ifdef DEBUG
45 #define DBG(fmt...) printk(fmt)
46 #else
47 #define DBG(fmt...)
48 #endif
49
50 /* i2c address for tumbler */
51 #define TAS_I2C_ADDR 0x34
52
53 /* registers */
54 #define TAS_REG_MCS 0x01 /* main control */
55 #define TAS_REG_DRC 0x02
56 #define TAS_REG_VOL 0x04
57 #define TAS_REG_TREBLE 0x05
58 #define TAS_REG_BASS 0x06
59 #define TAS_REG_INPUT1 0x07
60 #define TAS_REG_INPUT2 0x08
61
62 /* tas3001c */
63 #define TAS_REG_PCM TAS_REG_INPUT1
64
65 /* tas3004 */
66 #define TAS_REG_LMIX TAS_REG_INPUT1
67 #define TAS_REG_RMIX TAS_REG_INPUT2
68 #define TAS_REG_MCS2 0x43 /* main control 2 */
69 #define TAS_REG_ACS 0x40 /* analog control */
70
71 /* mono volumes for tas3001c/tas3004 */
72 enum {
73 VOL_IDX_PCM_MONO, /* tas3001c only */
74 VOL_IDX_BASS, VOL_IDX_TREBLE,
75 VOL_IDX_LAST_MONO
76 };
77
78 /* stereo volumes for tas3004 */
79 enum {
80 VOL_IDX_PCM, VOL_IDX_PCM2, VOL_IDX_ADC,
81 VOL_IDX_LAST_MIX
82 };
83
84 struct pmac_gpio {
85 unsigned int addr;
86 u8 active_val;
87 u8 inactive_val;
88 u8 active_state;
89 };
90
91 struct pmac_tumbler {
92 struct pmac_keywest i2c;
93 struct pmac_gpio audio_reset;
94 struct pmac_gpio amp_mute;
95 struct pmac_gpio line_mute;
96 struct pmac_gpio line_detect;
97 struct pmac_gpio hp_mute;
98 struct pmac_gpio hp_detect;
99 int headphone_irq;
100 int lineout_irq;
101 unsigned int save_master_vol[2];
102 unsigned int master_vol[2];
103 unsigned int save_master_switch[2];
104 unsigned int master_switch[2];
105 unsigned int mono_vol[VOL_IDX_LAST_MONO];
106 unsigned int mix_vol[VOL_IDX_LAST_MIX][2]; /* stereo volumes for tas3004 */
107 int drc_range;
108 int drc_enable;
109 int capture_source;
110 int anded_reset;
111 int auto_mute_notify;
112 int reset_on_sleep;
113 u8 acs;
114 };
115
116
117 /*
118 */
119
120 static int send_init_client(struct pmac_keywest *i2c, unsigned int *regs)
121 {
122 while (*regs > 0) {
123 int err, count = 10;
124 do {
125 err = i2c_smbus_write_byte_data(i2c->client,
126 regs[0], regs[1]);
127 if (err >= 0)
128 break;
129 DBG("(W) i2c error %d\n", err);
130 mdelay(10);
131 } while (count--);
132 if (err < 0)
133 return -ENXIO;
134 regs += 2;
135 }
136 return 0;
137 }
138
139
140 static int tumbler_init_client(struct pmac_keywest *i2c)
141 {
142 static unsigned int regs[] = {
143 /* normal operation, SCLK=64fps, i2s output, i2s input, 16bit width */
144 TAS_REG_MCS, (1<<6)|(2<<4)|(2<<2)|0,
145 0, /* terminator */
146 };
147 DBG("(I) tumbler init client\n");
148 return send_init_client(i2c, regs);
149 }
150
151 static int snapper_init_client(struct pmac_keywest *i2c)
152 {
153 static unsigned int regs[] = {
154 /* normal operation, SCLK=64fps, i2s output, 16bit width */
155 TAS_REG_MCS, (1<<6)|(2<<4)|0,
156 /* normal operation, all-pass mode */
157 TAS_REG_MCS2, (1<<1),
158 /* normal output, no deemphasis, A input, power-up, line-in */
159 TAS_REG_ACS, 0,
160 0, /* terminator */
161 };
162 DBG("(I) snapper init client\n");
163 return send_init_client(i2c, regs);
164 }
165
166 /*
167 * gpio access
168 */
169 #define do_gpio_write(gp, val) \
170 pmac_call_feature(PMAC_FTR_WRITE_GPIO, NULL, (gp)->addr, val)
171 #define do_gpio_read(gp) \
172 pmac_call_feature(PMAC_FTR_READ_GPIO, NULL, (gp)->addr, 0)
173 #define tumbler_gpio_free(gp) /* NOP */
174
175 static void write_audio_gpio(struct pmac_gpio *gp, int active)
176 {
177 if (! gp->addr)
178 return;
179 active = active ? gp->active_val : gp->inactive_val;
180 do_gpio_write(gp, active);
181 DBG("(I) gpio %x write %d\n", gp->addr, active);
182 }
183
184 static int check_audio_gpio(struct pmac_gpio *gp)
185 {
186 int ret;
187
188 if (! gp->addr)
189 return 0;
190
191 ret = do_gpio_read(gp);
192
193 return (ret & 0xd) == (gp->active_val & 0xd);
194 }
195
196 static int read_audio_gpio(struct pmac_gpio *gp)
197 {
198 int ret;
199 if (! gp->addr)
200 return 0;
201 ret = ((do_gpio_read(gp) & 0x02) !=0);
202 return ret == gp->active_state;
203 }
204
205 /*
206 * update master volume
207 */
208 static int tumbler_set_master_volume(struct pmac_tumbler *mix)
209 {
210 unsigned char block[6];
211 unsigned int left_vol, right_vol;
212
213 if (! mix->i2c.client)
214 return -ENODEV;
215
216 if (! mix->master_switch[0])
217 left_vol = 0;
218 else {
219 left_vol = mix->master_vol[0];
220 if (left_vol >= ARRAY_SIZE(master_volume_table))
221 left_vol = ARRAY_SIZE(master_volume_table) - 1;
222 left_vol = master_volume_table[left_vol];
223 }
224 if (! mix->master_switch[1])
225 right_vol = 0;
226 else {
227 right_vol = mix->master_vol[1];
228 if (right_vol >= ARRAY_SIZE(master_volume_table))
229 right_vol = ARRAY_SIZE(master_volume_table) - 1;
230 right_vol = master_volume_table[right_vol];
231 }
232
233 block[0] = (left_vol >> 16) & 0xff;
234 block[1] = (left_vol >> 8) & 0xff;
235 block[2] = (left_vol >> 0) & 0xff;
236
237 block[3] = (right_vol >> 16) & 0xff;
238 block[4] = (right_vol >> 8) & 0xff;
239 block[5] = (right_vol >> 0) & 0xff;
240
241 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_VOL, 6,
242 block) < 0) {
243 snd_printk("failed to set volume \n");
244 return -EINVAL;
245 }
246 return 0;
247 }
248
249
250 /* output volume */
251 static int tumbler_info_master_volume(struct snd_kcontrol *kcontrol,
252 struct snd_ctl_elem_info *uinfo)
253 {
254 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
255 uinfo->count = 2;
256 uinfo->value.integer.min = 0;
257 uinfo->value.integer.max = ARRAY_SIZE(master_volume_table) - 1;
258 return 0;
259 }
260
261 static int tumbler_get_master_volume(struct snd_kcontrol *kcontrol,
262 struct snd_ctl_elem_value *ucontrol)
263 {
264 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
265 struct pmac_tumbler *mix = chip->mixer_data;
266 snd_assert(mix, return -ENODEV);
267 ucontrol->value.integer.value[0] = mix->master_vol[0];
268 ucontrol->value.integer.value[1] = mix->master_vol[1];
269 return 0;
270 }
271
272 static int tumbler_put_master_volume(struct snd_kcontrol *kcontrol,
273 struct snd_ctl_elem_value *ucontrol)
274 {
275 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
276 struct pmac_tumbler *mix = chip->mixer_data;
277 int change;
278
279 snd_assert(mix, return -ENODEV);
280 change = mix->master_vol[0] != ucontrol->value.integer.value[0] ||
281 mix->master_vol[1] != ucontrol->value.integer.value[1];
282 if (change) {
283 mix->master_vol[0] = ucontrol->value.integer.value[0];
284 mix->master_vol[1] = ucontrol->value.integer.value[1];
285 tumbler_set_master_volume(mix);
286 }
287 return change;
288 }
289
290 /* output switch */
291 static int tumbler_get_master_switch(struct snd_kcontrol *kcontrol,
292 struct snd_ctl_elem_value *ucontrol)
293 {
294 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
295 struct pmac_tumbler *mix = chip->mixer_data;
296 snd_assert(mix, return -ENODEV);
297 ucontrol->value.integer.value[0] = mix->master_switch[0];
298 ucontrol->value.integer.value[1] = mix->master_switch[1];
299 return 0;
300 }
301
302 static int tumbler_put_master_switch(struct snd_kcontrol *kcontrol,
303 struct snd_ctl_elem_value *ucontrol)
304 {
305 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
306 struct pmac_tumbler *mix = chip->mixer_data;
307 int change;
308
309 snd_assert(mix, return -ENODEV);
310 change = mix->master_switch[0] != ucontrol->value.integer.value[0] ||
311 mix->master_switch[1] != ucontrol->value.integer.value[1];
312 if (change) {
313 mix->master_switch[0] = !!ucontrol->value.integer.value[0];
314 mix->master_switch[1] = !!ucontrol->value.integer.value[1];
315 tumbler_set_master_volume(mix);
316 }
317 return change;
318 }
319
320
321 /*
322 * TAS3001c dynamic range compression
323 */
324
325 #define TAS3001_DRC_MAX 0x5f
326
327 static int tumbler_set_drc(struct pmac_tumbler *mix)
328 {
329 unsigned char val[2];
330
331 if (! mix->i2c.client)
332 return -ENODEV;
333
334 if (mix->drc_enable) {
335 val[0] = 0xc1; /* enable, 3:1 compression */
336 if (mix->drc_range > TAS3001_DRC_MAX)
337 val[1] = 0xf0;
338 else if (mix->drc_range < 0)
339 val[1] = 0x91;
340 else
341 val[1] = mix->drc_range + 0x91;
342 } else {
343 val[0] = 0;
344 val[1] = 0;
345 }
346
347 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
348 2, val) < 0) {
349 snd_printk("failed to set DRC\n");
350 return -EINVAL;
351 }
352 return 0;
353 }
354
355 /*
356 * TAS3004
357 */
358
359 #define TAS3004_DRC_MAX 0xef
360
361 static int snapper_set_drc(struct pmac_tumbler *mix)
362 {
363 unsigned char val[6];
364
365 if (! mix->i2c.client)
366 return -ENODEV;
367
368 if (mix->drc_enable)
369 val[0] = 0x50; /* 3:1 above threshold */
370 else
371 val[0] = 0x51; /* disabled */
372 val[1] = 0x02; /* 1:1 below threshold */
373 if (mix->drc_range > 0xef)
374 val[2] = 0xef;
375 else if (mix->drc_range < 0)
376 val[2] = 0x00;
377 else
378 val[2] = mix->drc_range;
379 val[3] = 0xb0;
380 val[4] = 0x60;
381 val[5] = 0xa0;
382
383 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, TAS_REG_DRC,
384 6, val) < 0) {
385 snd_printk("failed to set DRC\n");
386 return -EINVAL;
387 }
388 return 0;
389 }
390
391 static int tumbler_info_drc_value(struct snd_kcontrol *kcontrol,
392 struct snd_ctl_elem_info *uinfo)
393 {
394 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
395 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
396 uinfo->count = 1;
397 uinfo->value.integer.min = 0;
398 uinfo->value.integer.max =
399 chip->model == PMAC_TUMBLER ? TAS3001_DRC_MAX : TAS3004_DRC_MAX;
400 return 0;
401 }
402
403 static int tumbler_get_drc_value(struct snd_kcontrol *kcontrol,
404 struct snd_ctl_elem_value *ucontrol)
405 {
406 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
407 struct pmac_tumbler *mix;
408 if (! (mix = chip->mixer_data))
409 return -ENODEV;
410 ucontrol->value.integer.value[0] = mix->drc_range;
411 return 0;
412 }
413
414 static int tumbler_put_drc_value(struct snd_kcontrol *kcontrol,
415 struct snd_ctl_elem_value *ucontrol)
416 {
417 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
418 struct pmac_tumbler *mix;
419 int change;
420
421 if (! (mix = chip->mixer_data))
422 return -ENODEV;
423 change = mix->drc_range != ucontrol->value.integer.value[0];
424 if (change) {
425 mix->drc_range = ucontrol->value.integer.value[0];
426 if (chip->model == PMAC_TUMBLER)
427 tumbler_set_drc(mix);
428 else
429 snapper_set_drc(mix);
430 }
431 return change;
432 }
433
434 static int tumbler_get_drc_switch(struct snd_kcontrol *kcontrol,
435 struct snd_ctl_elem_value *ucontrol)
436 {
437 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
438 struct pmac_tumbler *mix;
439 if (! (mix = chip->mixer_data))
440 return -ENODEV;
441 ucontrol->value.integer.value[0] = mix->drc_enable;
442 return 0;
443 }
444
445 static int tumbler_put_drc_switch(struct snd_kcontrol *kcontrol,
446 struct snd_ctl_elem_value *ucontrol)
447 {
448 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
449 struct pmac_tumbler *mix;
450 int change;
451
452 if (! (mix = chip->mixer_data))
453 return -ENODEV;
454 change = mix->drc_enable != ucontrol->value.integer.value[0];
455 if (change) {
456 mix->drc_enable = !!ucontrol->value.integer.value[0];
457 if (chip->model == PMAC_TUMBLER)
458 tumbler_set_drc(mix);
459 else
460 snapper_set_drc(mix);
461 }
462 return change;
463 }
464
465
466 /*
467 * mono volumes
468 */
469
470 struct tumbler_mono_vol {
471 int index;
472 int reg;
473 int bytes;
474 unsigned int max;
475 unsigned int *table;
476 };
477
478 static int tumbler_set_mono_volume(struct pmac_tumbler *mix,
479 struct tumbler_mono_vol *info)
480 {
481 unsigned char block[4];
482 unsigned int vol;
483 int i;
484
485 if (! mix->i2c.client)
486 return -ENODEV;
487
488 vol = mix->mono_vol[info->index];
489 if (vol >= info->max)
490 vol = info->max - 1;
491 vol = info->table[vol];
492 for (i = 0; i < info->bytes; i++)
493 block[i] = (vol >> ((info->bytes - i - 1) * 8)) & 0xff;
494 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, info->reg,
495 info->bytes, block) < 0) {
496 snd_printk("failed to set mono volume %d\n", info->index);
497 return -EINVAL;
498 }
499 return 0;
500 }
501
502 static int tumbler_info_mono(struct snd_kcontrol *kcontrol,
503 struct snd_ctl_elem_info *uinfo)
504 {
505 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
506
507 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
508 uinfo->count = 1;
509 uinfo->value.integer.min = 0;
510 uinfo->value.integer.max = info->max - 1;
511 return 0;
512 }
513
514 static int tumbler_get_mono(struct snd_kcontrol *kcontrol,
515 struct snd_ctl_elem_value *ucontrol)
516 {
517 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
518 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
519 struct pmac_tumbler *mix;
520 if (! (mix = chip->mixer_data))
521 return -ENODEV;
522 ucontrol->value.integer.value[0] = mix->mono_vol[info->index];
523 return 0;
524 }
525
526 static int tumbler_put_mono(struct snd_kcontrol *kcontrol,
527 struct snd_ctl_elem_value *ucontrol)
528 {
529 struct tumbler_mono_vol *info = (struct tumbler_mono_vol *)kcontrol->private_value;
530 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
531 struct pmac_tumbler *mix;
532 int change;
533
534 if (! (mix = chip->mixer_data))
535 return -ENODEV;
536 change = mix->mono_vol[info->index] != ucontrol->value.integer.value[0];
537 if (change) {
538 mix->mono_vol[info->index] = ucontrol->value.integer.value[0];
539 tumbler_set_mono_volume(mix, info);
540 }
541 return change;
542 }
543
544 /* TAS3001c mono volumes */
545 static struct tumbler_mono_vol tumbler_pcm_vol_info = {
546 .index = VOL_IDX_PCM_MONO,
547 .reg = TAS_REG_PCM,
548 .bytes = 3,
549 .max = ARRAY_SIZE(mixer_volume_table),
550 .table = mixer_volume_table,
551 };
552
553 static struct tumbler_mono_vol tumbler_bass_vol_info = {
554 .index = VOL_IDX_BASS,
555 .reg = TAS_REG_BASS,
556 .bytes = 1,
557 .max = ARRAY_SIZE(bass_volume_table),
558 .table = bass_volume_table,
559 };
560
561 static struct tumbler_mono_vol tumbler_treble_vol_info = {
562 .index = VOL_IDX_TREBLE,
563 .reg = TAS_REG_TREBLE,
564 .bytes = 1,
565 .max = ARRAY_SIZE(treble_volume_table),
566 .table = treble_volume_table,
567 };
568
569 /* TAS3004 mono volumes */
570 static struct tumbler_mono_vol snapper_bass_vol_info = {
571 .index = VOL_IDX_BASS,
572 .reg = TAS_REG_BASS,
573 .bytes = 1,
574 .max = ARRAY_SIZE(snapper_bass_volume_table),
575 .table = snapper_bass_volume_table,
576 };
577
578 static struct tumbler_mono_vol snapper_treble_vol_info = {
579 .index = VOL_IDX_TREBLE,
580 .reg = TAS_REG_TREBLE,
581 .bytes = 1,
582 .max = ARRAY_SIZE(snapper_treble_volume_table),
583 .table = snapper_treble_volume_table,
584 };
585
586
587 #define DEFINE_MONO(xname,type) { \
588 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
589 .name = xname, \
590 .info = tumbler_info_mono, \
591 .get = tumbler_get_mono, \
592 .put = tumbler_put_mono, \
593 .private_value = (unsigned long)(&tumbler_##type##_vol_info), \
594 }
595
596 #define DEFINE_SNAPPER_MONO(xname,type) { \
597 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
598 .name = xname, \
599 .info = tumbler_info_mono, \
600 .get = tumbler_get_mono, \
601 .put = tumbler_put_mono, \
602 .private_value = (unsigned long)(&snapper_##type##_vol_info), \
603 }
604
605
606 /*
607 * snapper mixer volumes
608 */
609
610 static int snapper_set_mix_vol1(struct pmac_tumbler *mix, int idx, int ch, int reg)
611 {
612 int i, j, vol;
613 unsigned char block[9];
614
615 vol = mix->mix_vol[idx][ch];
616 if (vol >= ARRAY_SIZE(mixer_volume_table)) {
617 vol = ARRAY_SIZE(mixer_volume_table) - 1;
618 mix->mix_vol[idx][ch] = vol;
619 }
620
621 for (i = 0; i < 3; i++) {
622 vol = mix->mix_vol[i][ch];
623 vol = mixer_volume_table[vol];
624 for (j = 0; j < 3; j++)
625 block[i * 3 + j] = (vol >> ((2 - j) * 8)) & 0xff;
626 }
627 if (i2c_smbus_write_i2c_block_data(mix->i2c.client, reg,
628 9, block) < 0) {
629 snd_printk("failed to set mono volume %d\n", reg);
630 return -EINVAL;
631 }
632 return 0;
633 }
634
635 static int snapper_set_mix_vol(struct pmac_tumbler *mix, int idx)
636 {
637 if (! mix->i2c.client)
638 return -ENODEV;
639 if (snapper_set_mix_vol1(mix, idx, 0, TAS_REG_LMIX) < 0 ||
640 snapper_set_mix_vol1(mix, idx, 1, TAS_REG_RMIX) < 0)
641 return -EINVAL;
642 return 0;
643 }
644
645 static int snapper_info_mix(struct snd_kcontrol *kcontrol,
646 struct snd_ctl_elem_info *uinfo)
647 {
648 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
649 uinfo->count = 2;
650 uinfo->value.integer.min = 0;
651 uinfo->value.integer.max = ARRAY_SIZE(mixer_volume_table) - 1;
652 return 0;
653 }
654
655 static int snapper_get_mix(struct snd_kcontrol *kcontrol,
656 struct snd_ctl_elem_value *ucontrol)
657 {
658 int idx = (int)kcontrol->private_value;
659 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
660 struct pmac_tumbler *mix;
661 if (! (mix = chip->mixer_data))
662 return -ENODEV;
663 ucontrol->value.integer.value[0] = mix->mix_vol[idx][0];
664 ucontrol->value.integer.value[1] = mix->mix_vol[idx][1];
665 return 0;
666 }
667
668 static int snapper_put_mix(struct snd_kcontrol *kcontrol,
669 struct snd_ctl_elem_value *ucontrol)
670 {
671 int idx = (int)kcontrol->private_value;
672 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
673 struct pmac_tumbler *mix;
674 int change;
675
676 if (! (mix = chip->mixer_data))
677 return -ENODEV;
678 change = mix->mix_vol[idx][0] != ucontrol->value.integer.value[0] ||
679 mix->mix_vol[idx][1] != ucontrol->value.integer.value[1];
680 if (change) {
681 mix->mix_vol[idx][0] = ucontrol->value.integer.value[0];
682 mix->mix_vol[idx][1] = ucontrol->value.integer.value[1];
683 snapper_set_mix_vol(mix, idx);
684 }
685 return change;
686 }
687
688
689 /*
690 * mute switches. FIXME: Turn that into software mute when both outputs are muted
691 * to avoid codec reset on ibook M7
692 */
693
694 enum { TUMBLER_MUTE_HP, TUMBLER_MUTE_AMP, TUMBLER_MUTE_LINE };
695
696 static int tumbler_get_mute_switch(struct snd_kcontrol *kcontrol,
697 struct snd_ctl_elem_value *ucontrol)
698 {
699 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
700 struct pmac_tumbler *mix;
701 struct pmac_gpio *gp;
702 if (! (mix = chip->mixer_data))
703 return -ENODEV;
704 switch(kcontrol->private_value) {
705 case TUMBLER_MUTE_HP:
706 gp = &mix->hp_mute; break;
707 case TUMBLER_MUTE_AMP:
708 gp = &mix->amp_mute; break;
709 case TUMBLER_MUTE_LINE:
710 gp = &mix->line_mute; break;
711 default:
712 gp = NULL;
713 }
714 if (gp == NULL)
715 return -EINVAL;
716 ucontrol->value.integer.value[0] = !check_audio_gpio(gp);
717 return 0;
718 }
719
720 static int tumbler_put_mute_switch(struct snd_kcontrol *kcontrol,
721 struct snd_ctl_elem_value *ucontrol)
722 {
723 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
724 struct pmac_tumbler *mix;
725 struct pmac_gpio *gp;
726 int val;
727 #ifdef PMAC_SUPPORT_AUTOMUTE
728 if (chip->update_automute && chip->auto_mute)
729 return 0; /* don't touch in the auto-mute mode */
730 #endif
731 if (! (mix = chip->mixer_data))
732 return -ENODEV;
733 switch(kcontrol->private_value) {
734 case TUMBLER_MUTE_HP:
735 gp = &mix->hp_mute; break;
736 case TUMBLER_MUTE_AMP:
737 gp = &mix->amp_mute; break;
738 case TUMBLER_MUTE_LINE:
739 gp = &mix->line_mute; break;
740 default:
741 gp = NULL;
742 }
743 if (gp == NULL)
744 return -EINVAL;
745 val = ! check_audio_gpio(gp);
746 if (val != ucontrol->value.integer.value[0]) {
747 write_audio_gpio(gp, ! ucontrol->value.integer.value[0]);
748 return 1;
749 }
750 return 0;
751 }
752
753 static int snapper_set_capture_source(struct pmac_tumbler *mix)
754 {
755 if (! mix->i2c.client)
756 return -ENODEV;
757 if (mix->capture_source)
758 mix->acs = mix->acs |= 2;
759 else
760 mix->acs &= ~2;
761 return i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
762 }
763
764 static int snapper_info_capture_source(struct snd_kcontrol *kcontrol,
765 struct snd_ctl_elem_info *uinfo)
766 {
767 static char *texts[2] = {
768 "Line", "Mic"
769 };
770 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
771 uinfo->count = 1;
772 uinfo->value.enumerated.items = 2;
773 if (uinfo->value.enumerated.item > 1)
774 uinfo->value.enumerated.item = 1;
775 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
776 return 0;
777 }
778
779 static int snapper_get_capture_source(struct snd_kcontrol *kcontrol,
780 struct snd_ctl_elem_value *ucontrol)
781 {
782 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
783 struct pmac_tumbler *mix = chip->mixer_data;
784
785 snd_assert(mix, return -ENODEV);
786 ucontrol->value.integer.value[0] = mix->capture_source;
787 return 0;
788 }
789
790 static int snapper_put_capture_source(struct snd_kcontrol *kcontrol,
791 struct snd_ctl_elem_value *ucontrol)
792 {
793 struct snd_pmac *chip = snd_kcontrol_chip(kcontrol);
794 struct pmac_tumbler *mix = chip->mixer_data;
795 int change;
796
797 snd_assert(mix, return -ENODEV);
798 change = ucontrol->value.integer.value[0] != mix->capture_source;
799 if (change) {
800 mix->capture_source = !!ucontrol->value.integer.value[0];
801 snapper_set_capture_source(mix);
802 }
803 return change;
804 }
805
806 #define DEFINE_SNAPPER_MIX(xname,idx,ofs) { \
807 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,\
808 .name = xname, \
809 .info = snapper_info_mix, \
810 .get = snapper_get_mix, \
811 .put = snapper_put_mix, \
812 .index = idx,\
813 .private_value = ofs, \
814 }
815
816
817 /*
818 */
819 static struct snd_kcontrol_new tumbler_mixers[] __initdata = {
820 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
821 .name = "Master Playback Volume",
822 .info = tumbler_info_master_volume,
823 .get = tumbler_get_master_volume,
824 .put = tumbler_put_master_volume
825 },
826 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
827 .name = "Master Playback Switch",
828 .info = snd_pmac_boolean_stereo_info,
829 .get = tumbler_get_master_switch,
830 .put = tumbler_put_master_switch
831 },
832 DEFINE_MONO("Tone Control - Bass", bass),
833 DEFINE_MONO("Tone Control - Treble", treble),
834 DEFINE_MONO("PCM Playback Volume", pcm),
835 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
836 .name = "DRC Range",
837 .info = tumbler_info_drc_value,
838 .get = tumbler_get_drc_value,
839 .put = tumbler_put_drc_value
840 },
841 };
842
843 static struct snd_kcontrol_new snapper_mixers[] __initdata = {
844 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
845 .name = "Master Playback Volume",
846 .info = tumbler_info_master_volume,
847 .get = tumbler_get_master_volume,
848 .put = tumbler_put_master_volume
849 },
850 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
851 .name = "Master Playback Switch",
852 .info = snd_pmac_boolean_stereo_info,
853 .get = tumbler_get_master_switch,
854 .put = tumbler_put_master_switch
855 },
856 DEFINE_SNAPPER_MIX("PCM Playback Volume", 0, VOL_IDX_PCM),
857 DEFINE_SNAPPER_MIX("PCM Playback Volume", 1, VOL_IDX_PCM2),
858 DEFINE_SNAPPER_MIX("Monitor Mix Volume", 0, VOL_IDX_ADC),
859 DEFINE_SNAPPER_MONO("Tone Control - Bass", bass),
860 DEFINE_SNAPPER_MONO("Tone Control - Treble", treble),
861 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
862 .name = "DRC Range",
863 .info = tumbler_info_drc_value,
864 .get = tumbler_get_drc_value,
865 .put = tumbler_put_drc_value
866 },
867 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
868 .name = "Input Source", /* FIXME: "Capture Source" doesn't work properly */
869 .info = snapper_info_capture_source,
870 .get = snapper_get_capture_source,
871 .put = snapper_put_capture_source
872 },
873 };
874
875 static struct snd_kcontrol_new tumbler_hp_sw __initdata = {
876 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
877 .name = "Headphone Playback Switch",
878 .info = snd_pmac_boolean_mono_info,
879 .get = tumbler_get_mute_switch,
880 .put = tumbler_put_mute_switch,
881 .private_value = TUMBLER_MUTE_HP,
882 };
883 static struct snd_kcontrol_new tumbler_speaker_sw __initdata = {
884 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
885 .name = "PC Speaker Playback Switch",
886 .info = snd_pmac_boolean_mono_info,
887 .get = tumbler_get_mute_switch,
888 .put = tumbler_put_mute_switch,
889 .private_value = TUMBLER_MUTE_AMP,
890 };
891 static struct snd_kcontrol_new tumbler_lineout_sw __initdata = {
892 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
893 .name = "Line Out Playback Switch",
894 .info = snd_pmac_boolean_mono_info,
895 .get = tumbler_get_mute_switch,
896 .put = tumbler_put_mute_switch,
897 .private_value = TUMBLER_MUTE_LINE,
898 };
899 static struct snd_kcontrol_new tumbler_drc_sw __initdata = {
900 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
901 .name = "DRC Switch",
902 .info = snd_pmac_boolean_mono_info,
903 .get = tumbler_get_drc_switch,
904 .put = tumbler_put_drc_switch
905 };
906
907
908 #ifdef PMAC_SUPPORT_AUTOMUTE
909 /*
910 * auto-mute stuffs
911 */
912 static int tumbler_detect_headphone(struct snd_pmac *chip)
913 {
914 struct pmac_tumbler *mix = chip->mixer_data;
915 int detect = 0;
916
917 if (mix->hp_detect.addr)
918 detect |= read_audio_gpio(&mix->hp_detect);
919 return detect;
920 }
921
922 static int tumbler_detect_lineout(struct snd_pmac *chip)
923 {
924 struct pmac_tumbler *mix = chip->mixer_data;
925 int detect = 0;
926
927 if (mix->line_detect.addr)
928 detect |= read_audio_gpio(&mix->line_detect);
929 return detect;
930 }
931
932 static void check_mute(struct snd_pmac *chip, struct pmac_gpio *gp, int val, int do_notify,
933 struct snd_kcontrol *sw)
934 {
935 if (check_audio_gpio(gp) != val) {
936 write_audio_gpio(gp, val);
937 if (do_notify)
938 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
939 &sw->id);
940 }
941 }
942
943 static struct work_struct device_change;
944
945 static void device_change_handler(void *self)
946 {
947 struct snd_pmac *chip = self;
948 struct pmac_tumbler *mix;
949 int headphone, lineout;
950
951 if (!chip)
952 return;
953
954 mix = chip->mixer_data;
955 snd_assert(mix, return);
956
957 headphone = tumbler_detect_headphone(chip);
958 lineout = tumbler_detect_lineout(chip);
959
960 DBG("headphone: %d, lineout: %d\n", headphone, lineout);
961
962 if (headphone || lineout) {
963 /* unmute headphone/lineout & mute speaker */
964 if (headphone)
965 check_mute(chip, &mix->hp_mute, 0, mix->auto_mute_notify,
966 chip->master_sw_ctl);
967 if (lineout && mix->line_mute.addr != 0)
968 check_mute(chip, &mix->line_mute, 0, mix->auto_mute_notify,
969 chip->lineout_sw_ctl);
970 if (mix->anded_reset)
971 msleep(10);
972 check_mute(chip, &mix->amp_mute, 1, mix->auto_mute_notify,
973 chip->speaker_sw_ctl);
974 } else {
975 /* unmute speaker, mute others */
976 check_mute(chip, &mix->amp_mute, 0, mix->auto_mute_notify,
977 chip->speaker_sw_ctl);
978 if (mix->anded_reset)
979 msleep(10);
980 check_mute(chip, &mix->hp_mute, 1, mix->auto_mute_notify,
981 chip->master_sw_ctl);
982 if (mix->line_mute.addr != 0)
983 check_mute(chip, &mix->line_mute, 1, mix->auto_mute_notify,
984 chip->lineout_sw_ctl);
985 }
986 if (mix->auto_mute_notify)
987 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
988 &chip->hp_detect_ctl->id);
989
990 #ifdef CONFIG_SND_POWERMAC_AUTO_DRC
991 mix->drc_enable = ! (headphone || lineout);
992 if (mix->auto_mute_notify)
993 snd_ctl_notify(chip->card, SNDRV_CTL_EVENT_MASK_VALUE,
994 &chip->drc_sw_ctl->id);
995 if (chip->model == PMAC_TUMBLER)
996 tumbler_set_drc(mix);
997 else
998 snapper_set_drc(mix);
999 #endif
1000
1001 /* reset the master volume so the correct amplification is applied */
1002 tumbler_set_master_volume(mix);
1003 }
1004
1005 static void tumbler_update_automute(struct snd_pmac *chip, int do_notify)
1006 {
1007 if (chip->auto_mute) {
1008 struct pmac_tumbler *mix;
1009 mix = chip->mixer_data;
1010 snd_assert(mix, return);
1011 mix->auto_mute_notify = do_notify;
1012 schedule_work(&device_change);
1013 }
1014 }
1015 #endif /* PMAC_SUPPORT_AUTOMUTE */
1016
1017
1018 /* interrupt - headphone plug changed */
1019 static irqreturn_t headphone_intr(int irq, void *devid, struct pt_regs *regs)
1020 {
1021 struct snd_pmac *chip = devid;
1022 if (chip->update_automute && chip->initialized) {
1023 chip->update_automute(chip, 1);
1024 return IRQ_HANDLED;
1025 }
1026 return IRQ_NONE;
1027 }
1028
1029 /* look for audio-gpio device */
1030 static struct device_node *find_audio_device(const char *name)
1031 {
1032 struct device_node *np;
1033
1034 if (! (np = find_devices("gpio")))
1035 return NULL;
1036
1037 for (np = np->child; np; np = np->sibling) {
1038 char *property = get_property(np, "audio-gpio", NULL);
1039 if (property && strcmp(property, name) == 0)
1040 return np;
1041 }
1042 return NULL;
1043 }
1044
1045 /* look for audio-gpio device */
1046 static struct device_node *find_compatible_audio_device(const char *name)
1047 {
1048 struct device_node *np;
1049
1050 if (! (np = find_devices("gpio")))
1051 return NULL;
1052
1053 for (np = np->child; np; np = np->sibling) {
1054 if (device_is_compatible(np, name))
1055 return np;
1056 }
1057 return NULL;
1058 }
1059
1060 /* find an audio device and get its address */
1061 static long tumbler_find_device(const char *device, const char *platform,
1062 struct pmac_gpio *gp, int is_compatible)
1063 {
1064 struct device_node *node;
1065 u32 *base, addr;
1066
1067 if (is_compatible)
1068 node = find_compatible_audio_device(device);
1069 else
1070 node = find_audio_device(device);
1071 if (! node) {
1072 DBG("(W) cannot find audio device %s !\n", device);
1073 snd_printdd("cannot find device %s\n", device);
1074 return -ENODEV;
1075 }
1076
1077 base = (u32 *)get_property(node, "AAPL,address", NULL);
1078 if (! base) {
1079 base = (u32 *)get_property(node, "reg", NULL);
1080 if (!base) {
1081 DBG("(E) cannot find address for device %s !\n", device);
1082 snd_printd("cannot find address for device %s\n", device);
1083 return -ENODEV;
1084 }
1085 addr = *base;
1086 if (addr < 0x50)
1087 addr += 0x50;
1088 } else
1089 addr = *base;
1090
1091 gp->addr = addr & 0x0000ffff;
1092 /* Try to find the active state, default to 0 ! */
1093 base = (u32 *)get_property(node, "audio-gpio-active-state", NULL);
1094 if (base) {
1095 gp->active_state = *base;
1096 gp->active_val = (*base) ? 0x5 : 0x4;
1097 gp->inactive_val = (*base) ? 0x4 : 0x5;
1098 } else {
1099 u32 *prop = NULL;
1100 gp->active_state = 0;
1101 gp->active_val = 0x4;
1102 gp->inactive_val = 0x5;
1103 /* Here are some crude hacks to extract the GPIO polarity and
1104 * open collector informations out of the do-platform script
1105 * as we don't yet have an interpreter for these things
1106 */
1107 if (platform)
1108 prop = (u32 *)get_property(node, platform, NULL);
1109 if (prop) {
1110 if (prop[3] == 0x9 && prop[4] == 0x9) {
1111 gp->active_val = 0xd;
1112 gp->inactive_val = 0xc;
1113 }
1114 if (prop[3] == 0x1 && prop[4] == 0x1) {
1115 gp->active_val = 0x5;
1116 gp->inactive_val = 0x4;
1117 }
1118 }
1119 }
1120
1121 DBG("(I) GPIO device %s found, offset: %x, active state: %d !\n",
1122 device, gp->addr, gp->active_state);
1123
1124 return irq_of_parse_and_map(node, 0);
1125 }
1126
1127 /* reset audio */
1128 static void tumbler_reset_audio(struct snd_pmac *chip)
1129 {
1130 struct pmac_tumbler *mix = chip->mixer_data;
1131
1132 if (mix->anded_reset) {
1133 DBG("(I) codec anded reset !\n");
1134 write_audio_gpio(&mix->hp_mute, 0);
1135 write_audio_gpio(&mix->amp_mute, 0);
1136 msleep(200);
1137 write_audio_gpio(&mix->hp_mute, 1);
1138 write_audio_gpio(&mix->amp_mute, 1);
1139 msleep(100);
1140 write_audio_gpio(&mix->hp_mute, 0);
1141 write_audio_gpio(&mix->amp_mute, 0);
1142 msleep(100);
1143 } else {
1144 DBG("(I) codec normal reset !\n");
1145
1146 write_audio_gpio(&mix->audio_reset, 0);
1147 msleep(200);
1148 write_audio_gpio(&mix->audio_reset, 1);
1149 msleep(100);
1150 write_audio_gpio(&mix->audio_reset, 0);
1151 msleep(100);
1152 }
1153 }
1154
1155 #ifdef CONFIG_PM
1156 /* suspend mixer */
1157 static void tumbler_suspend(struct snd_pmac *chip)
1158 {
1159 struct pmac_tumbler *mix = chip->mixer_data;
1160
1161 if (mix->headphone_irq >= 0)
1162 disable_irq(mix->headphone_irq);
1163 if (mix->lineout_irq >= 0)
1164 disable_irq(mix->lineout_irq);
1165 mix->save_master_switch[0] = mix->master_switch[0];
1166 mix->save_master_switch[1] = mix->master_switch[1];
1167 mix->save_master_vol[0] = mix->master_vol[0];
1168 mix->save_master_vol[1] = mix->master_vol[1];
1169 mix->master_switch[0] = mix->master_switch[1] = 0;
1170 tumbler_set_master_volume(mix);
1171 if (!mix->anded_reset) {
1172 write_audio_gpio(&mix->amp_mute, 1);
1173 write_audio_gpio(&mix->hp_mute, 1);
1174 }
1175 if (chip->model == PMAC_SNAPPER) {
1176 mix->acs |= 1;
1177 i2c_smbus_write_byte_data(mix->i2c.client, TAS_REG_ACS, mix->acs);
1178 }
1179 if (mix->anded_reset) {
1180 write_audio_gpio(&mix->amp_mute, 1);
1181 write_audio_gpio(&mix->hp_mute, 1);
1182 } else
1183 write_audio_gpio(&mix->audio_reset, 1);
1184 }
1185
1186 /* resume mixer */
1187 static void tumbler_resume(struct snd_pmac *chip)
1188 {
1189 struct pmac_tumbler *mix = chip->mixer_data;
1190
1191 snd_assert(mix, return);
1192
1193 mix->acs &= ~1;
1194 mix->master_switch[0] = mix->save_master_switch[0];
1195 mix->master_switch[1] = mix->save_master_switch[1];
1196 mix->master_vol[0] = mix->save_master_vol[0];
1197 mix->master_vol[1] = mix->save_master_vol[1];
1198 tumbler_reset_audio(chip);
1199 if (mix->i2c.client && mix->i2c.init_client) {
1200 if (mix->i2c.init_client(&mix->i2c) < 0)
1201 printk(KERN_ERR "tumbler_init_client error\n");
1202 } else
1203 printk(KERN_ERR "tumbler: i2c is not initialized\n");
1204 if (chip->model == PMAC_TUMBLER) {
1205 tumbler_set_mono_volume(mix, &tumbler_pcm_vol_info);
1206 tumbler_set_mono_volume(mix, &tumbler_bass_vol_info);
1207 tumbler_set_mono_volume(mix, &tumbler_treble_vol_info);
1208 tumbler_set_drc(mix);
1209 } else {
1210 snapper_set_mix_vol(mix, VOL_IDX_PCM);
1211 snapper_set_mix_vol(mix, VOL_IDX_PCM2);
1212 snapper_set_mix_vol(mix, VOL_IDX_ADC);
1213 tumbler_set_mono_volume(mix, &snapper_bass_vol_info);
1214 tumbler_set_mono_volume(mix, &snapper_treble_vol_info);
1215 snapper_set_drc(mix);
1216 snapper_set_capture_source(mix);
1217 }
1218 tumbler_set_master_volume(mix);
1219 if (chip->update_automute)
1220 chip->update_automute(chip, 0);
1221 if (mix->headphone_irq >= 0) {
1222 unsigned char val;
1223
1224 enable_irq(mix->headphone_irq);
1225 /* activate headphone status interrupts */
1226 val = do_gpio_read(&mix->hp_detect);
1227 do_gpio_write(&mix->hp_detect, val | 0x80);
1228 }
1229 if (mix->lineout_irq >= 0)
1230 enable_irq(mix->lineout_irq);
1231 }
1232 #endif
1233
1234 /* initialize tumbler */
1235 static int __init tumbler_init(struct snd_pmac *chip)
1236 {
1237 int irq;
1238 struct pmac_tumbler *mix = chip->mixer_data;
1239 snd_assert(mix, return -EINVAL);
1240
1241 if (tumbler_find_device("audio-hw-reset",
1242 "platform-do-hw-reset",
1243 &mix->audio_reset, 0) < 0)
1244 tumbler_find_device("hw-reset",
1245 "platform-do-hw-reset",
1246 &mix->audio_reset, 1);
1247 if (tumbler_find_device("amp-mute",
1248 "platform-do-amp-mute",
1249 &mix->amp_mute, 0) < 0)
1250 tumbler_find_device("amp-mute",
1251 "platform-do-amp-mute",
1252 &mix->amp_mute, 1);
1253 if (tumbler_find_device("headphone-mute",
1254 "platform-do-headphone-mute",
1255 &mix->hp_mute, 0) < 0)
1256 tumbler_find_device("headphone-mute",
1257 "platform-do-headphone-mute",
1258 &mix->hp_mute, 1);
1259 if (tumbler_find_device("line-output-mute",
1260 "platform-do-lineout-mute",
1261 &mix->line_mute, 0) < 0)
1262 tumbler_find_device("line-output-mute",
1263 "platform-do-lineout-mute",
1264 &mix->line_mute, 1);
1265 irq = tumbler_find_device("headphone-detect",
1266 NULL, &mix->hp_detect, 0);
1267 if (irq <= NO_IRQ)
1268 irq = tumbler_find_device("headphone-detect",
1269 NULL, &mix->hp_detect, 1);
1270 if (irq <= NO_IRQ)
1271 irq = tumbler_find_device("keywest-gpio15",
1272 NULL, &mix->hp_detect, 1);
1273 mix->headphone_irq = irq;
1274 irq = tumbler_find_device("line-output-detect",
1275 NULL, &mix->line_detect, 0);
1276 if (irq <= NO_IRQ)
1277 irq = tumbler_find_device("line-output-detect",
1278 NULL, &mix->line_detect, 1);
1279 mix->lineout_irq = irq;
1280
1281 tumbler_reset_audio(chip);
1282
1283 return 0;
1284 }
1285
1286 static void tumbler_cleanup(struct snd_pmac *chip)
1287 {
1288 struct pmac_tumbler *mix = chip->mixer_data;
1289 if (! mix)
1290 return;
1291
1292 if (mix->headphone_irq >= 0)
1293 free_irq(mix->headphone_irq, chip);
1294 if (mix->lineout_irq >= 0)
1295 free_irq(mix->lineout_irq, chip);
1296 tumbler_gpio_free(&mix->audio_reset);
1297 tumbler_gpio_free(&mix->amp_mute);
1298 tumbler_gpio_free(&mix->hp_mute);
1299 tumbler_gpio_free(&mix->hp_detect);
1300 snd_pmac_keywest_cleanup(&mix->i2c);
1301 kfree(mix);
1302 chip->mixer_data = NULL;
1303 }
1304
1305 /* exported */
1306 int __init snd_pmac_tumbler_init(struct snd_pmac *chip)
1307 {
1308 int i, err;
1309 struct pmac_tumbler *mix;
1310 u32 *paddr;
1311 struct device_node *tas_node, *np;
1312 char *chipname;
1313
1314 #ifdef CONFIG_KMOD
1315 if (current->fs->root)
1316 request_module("i2c-powermac");
1317 #endif /* CONFIG_KMOD */
1318
1319 mix = kmalloc(sizeof(*mix), GFP_KERNEL);
1320 if (! mix)
1321 return -ENOMEM;
1322 memset(mix, 0, sizeof(*mix));
1323 mix->headphone_irq = -1;
1324
1325 chip->mixer_data = mix;
1326 chip->mixer_free = tumbler_cleanup;
1327 mix->anded_reset = 0;
1328 mix->reset_on_sleep = 1;
1329
1330 for (np = chip->node->child; np; np = np->sibling) {
1331 if (!strcmp(np->name, "sound")) {
1332 if (get_property(np, "has-anded-reset", NULL))
1333 mix->anded_reset = 1;
1334 if (get_property(np, "layout-id", NULL))
1335 mix->reset_on_sleep = 0;
1336 break;
1337 }
1338 }
1339 if ((err = tumbler_init(chip)) < 0)
1340 return err;
1341
1342 /* set up TAS */
1343 tas_node = find_devices("deq");
1344 if (tas_node == NULL)
1345 tas_node = find_devices("codec");
1346 if (tas_node == NULL)
1347 return -ENODEV;
1348
1349 paddr = (u32 *)get_property(tas_node, "i2c-address", NULL);
1350 if (paddr == NULL)
1351 paddr = (u32 *)get_property(tas_node, "reg", NULL);
1352 if (paddr)
1353 mix->i2c.addr = (*paddr) >> 1;
1354 else
1355 mix->i2c.addr = TAS_I2C_ADDR;
1356
1357 DBG("(I) TAS i2c address is: %x\n", mix->i2c.addr);
1358
1359 if (chip->model == PMAC_TUMBLER) {
1360 mix->i2c.init_client = tumbler_init_client;
1361 mix->i2c.name = "TAS3001c";
1362 chipname = "Tumbler";
1363 } else {
1364 mix->i2c.init_client = snapper_init_client;
1365 mix->i2c.name = "TAS3004";
1366 chipname = "Snapper";
1367 }
1368
1369 if ((err = snd_pmac_keywest_init(&mix->i2c)) < 0)
1370 return err;
1371
1372 /*
1373 * build mixers
1374 */
1375 sprintf(chip->card->mixername, "PowerMac %s", chipname);
1376
1377 if (chip->model == PMAC_TUMBLER) {
1378 for (i = 0; i < ARRAY_SIZE(tumbler_mixers); i++) {
1379 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&tumbler_mixers[i], chip))) < 0)
1380 return err;
1381 }
1382 } else {
1383 for (i = 0; i < ARRAY_SIZE(snapper_mixers); i++) {
1384 if ((err = snd_ctl_add(chip->card, snd_ctl_new1(&snapper_mixers[i], chip))) < 0)
1385 return err;
1386 }
1387 }
1388 chip->master_sw_ctl = snd_ctl_new1(&tumbler_hp_sw, chip);
1389 if ((err = snd_ctl_add(chip->card, chip->master_sw_ctl)) < 0)
1390 return err;
1391 chip->speaker_sw_ctl = snd_ctl_new1(&tumbler_speaker_sw, chip);
1392 if ((err = snd_ctl_add(chip->card, chip->speaker_sw_ctl)) < 0)
1393 return err;
1394 if (mix->line_mute.addr != 0) {
1395 chip->lineout_sw_ctl = snd_ctl_new1(&tumbler_lineout_sw, chip);
1396 if ((err = snd_ctl_add(chip->card, chip->lineout_sw_ctl)) < 0)
1397 return err;
1398 }
1399 chip->drc_sw_ctl = snd_ctl_new1(&tumbler_drc_sw, chip);
1400 if ((err = snd_ctl_add(chip->card, chip->drc_sw_ctl)) < 0)
1401 return err;
1402
1403 /* set initial DRC range to 60% */
1404 if (chip->model == PMAC_TUMBLER)
1405 mix->drc_range = (TAS3001_DRC_MAX * 6) / 10;
1406 else
1407 mix->drc_range = (TAS3004_DRC_MAX * 6) / 10;
1408 mix->drc_enable = 1; /* will be changed later if AUTO_DRC is set */
1409 if (chip->model == PMAC_TUMBLER)
1410 tumbler_set_drc(mix);
1411 else
1412 snapper_set_drc(mix);
1413
1414 #ifdef CONFIG_PM
1415 chip->suspend = tumbler_suspend;
1416 chip->resume = tumbler_resume;
1417 #endif
1418
1419 INIT_WORK(&device_change, device_change_handler, (void *)chip);
1420
1421 #ifdef PMAC_SUPPORT_AUTOMUTE
1422 if ((mix->headphone_irq >=0 || mix->lineout_irq >= 0)
1423 && (err = snd_pmac_add_automute(chip)) < 0)
1424 return err;
1425 chip->detect_headphone = tumbler_detect_headphone;
1426 chip->update_automute = tumbler_update_automute;
1427 tumbler_update_automute(chip, 0); /* update the status only */
1428
1429 /* activate headphone status interrupts */
1430 if (mix->headphone_irq >= 0) {
1431 unsigned char val;
1432 if ((err = request_irq(mix->headphone_irq, headphone_intr, 0,
1433 "Sound Headphone Detection", chip)) < 0)
1434 return 0;
1435 /* activate headphone status interrupts */
1436 val = do_gpio_read(&mix->hp_detect);
1437 do_gpio_write(&mix->hp_detect, val | 0x80);
1438 }
1439 if (mix->lineout_irq >= 0) {
1440 unsigned char val;
1441 if ((err = request_irq(mix->lineout_irq, headphone_intr, 0,
1442 "Sound Lineout Detection", chip)) < 0)
1443 return 0;
1444 /* activate headphone status interrupts */
1445 val = do_gpio_read(&mix->line_detect);
1446 do_gpio_write(&mix->line_detect, val | 0x80);
1447 }
1448 #endif
1449
1450 return 0;
1451 }
Linus' kernel tree