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