?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
GUI: Fix Tomato RAF theme for all builds. Compilation typo.
[tomato.git] / release / src-rt-6.x.4708 / linux / linux-2.6.36 / sound / aoa / codecs / onyx.c
blob1b3e1f616860eee19fbae1cd8fd0caa5bfed86a0
1 /*
2 * Apple Onboard Audio driver for Onyx codec
3 *
4 * Copyright 2006 Johannes Berg <johannes@sipsolutions.net>
5 *
6 * GPL v2, can be found in COPYING.
7 *
8 *
9 * This is a driver for the pcm3052 codec chip (codenamed Onyx)
10 * that is present in newer Apple hardware (with digital output).
11 *
12 * The Onyx codec has the following connections (listed by the bit
13 * to be used in aoa_codec.connected):
14 * 0: analog output
15 * 1: digital output
16 * 2: line input
17 * 3: microphone input
18 * Note that even though I know of no machine that has for example
19 * the digital output connected but not the analog, I have handled
20 * all the different cases in the code so that this driver may serve
21 * as a good example of what to do.
22 *
23 * NOTE: This driver assumes that there's at most one chip to be
24 * used with one alsa card, in form of creating all kinds
25 * of mixer elements without regard for their existence.
26 * But snd-aoa assumes that there's at most one card, so
27 * this means you can only have one onyx on a system. This
28 * should probably be fixed by changing the assumption of
29 * having just a single card on a system, and making the
30 * 'card' pointer accessible to anyone who needs it instead
31 * of hiding it in the aoa_snd_* functions...
32 *
33 */
34 #include <linux/delay.h>
35 #include <linux/module.h>
36 #include <linux/slab.h>
37 MODULE_AUTHOR("Johannes Berg <johannes@sipsolutions.net>");
38 MODULE_LICENSE("GPL");
39 MODULE_DESCRIPTION("pcm3052 (onyx) codec driver for snd-aoa");
40
41 #include "onyx.h"
42 #include "../aoa.h"
43 #include "../soundbus/soundbus.h"
44
45
46 #define PFX "snd-aoa-codec-onyx: "
47
48 struct onyx {
49 /* cache registers 65 to 80, they are write-only! */
50 u8 cache[16];
51 struct i2c_client *i2c;
52 struct aoa_codec codec;
53 u32 initialised:1,
54 spdif_locked:1,
55 analog_locked:1,
56 original_mute:2;
57 int open_count;
58 struct codec_info *codec_info;
59
60 /* mutex serializes concurrent access to the device
61 * and this structure.
62 */
63 struct mutex mutex;
64 };
65 #define codec_to_onyx(c) container_of(c, struct onyx, codec)
66
67 /* both return 0 if all ok, else on error */
68 static int onyx_read_register(struct onyx *onyx, u8 reg, u8 *value)
69 {
70 s32 v;
71
72 if (reg != ONYX_REG_CONTROL) {
73 *value = onyx->cache[reg-FIRSTREGISTER];
74 return 0;
75 }
76 v = i2c_smbus_read_byte_data(onyx->i2c, reg);
77 if (v < 0)
78 return -1;
79 *value = (u8)v;
80 onyx->cache[ONYX_REG_CONTROL-FIRSTREGISTER] = *value;
81 return 0;
82 }
83
84 static int onyx_write_register(struct onyx *onyx, u8 reg, u8 value)
85 {
86 int result;
87
88 result = i2c_smbus_write_byte_data(onyx->i2c, reg, value);
89 if (!result)
90 onyx->cache[reg-FIRSTREGISTER] = value;
91 return result;
92 }
93
94 /* alsa stuff */
95
96 static int onyx_dev_register(struct snd_device *dev)
97 {
98 return 0;
99 }
100
101 static struct snd_device_ops ops = {
102 .dev_register = onyx_dev_register,
103 };
104
105 /* this is necessary because most alsa mixer programs
106 * can't properly handle the negative range */
107 #define VOLUME_RANGE_SHIFT 128
108
109 static int onyx_snd_vol_info(struct snd_kcontrol *kcontrol,
110 struct snd_ctl_elem_info *uinfo)
111 {
112 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
113 uinfo->count = 2;
114 uinfo->value.integer.min = -128 + VOLUME_RANGE_SHIFT;
115 uinfo->value.integer.max = -1 + VOLUME_RANGE_SHIFT;
116 return 0;
117 }
118
119 static int onyx_snd_vol_get(struct snd_kcontrol *kcontrol,
120 struct snd_ctl_elem_value *ucontrol)
121 {
122 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
123 s8 l, r;
124
125 mutex_lock(&onyx->mutex);
126 onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l);
127 onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r);
128 mutex_unlock(&onyx->mutex);
129
130 ucontrol->value.integer.value[0] = l + VOLUME_RANGE_SHIFT;
131 ucontrol->value.integer.value[1] = r + VOLUME_RANGE_SHIFT;
132
133 return 0;
134 }
135
136 static int onyx_snd_vol_put(struct snd_kcontrol *kcontrol,
137 struct snd_ctl_elem_value *ucontrol)
138 {
139 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
140 s8 l, r;
141
142 if (ucontrol->value.integer.value[0] < -128 + VOLUME_RANGE_SHIFT ||
143 ucontrol->value.integer.value[0] > -1 + VOLUME_RANGE_SHIFT)
144 return -EINVAL;
145 if (ucontrol->value.integer.value[1] < -128 + VOLUME_RANGE_SHIFT ||
146 ucontrol->value.integer.value[1] > -1 + VOLUME_RANGE_SHIFT)
147 return -EINVAL;
148
149 mutex_lock(&onyx->mutex);
150 onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_LEFT, &l);
151 onyx_read_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT, &r);
152
153 if (l + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[0] &&
154 r + VOLUME_RANGE_SHIFT == ucontrol->value.integer.value[1]) {
155 mutex_unlock(&onyx->mutex);
156 return 0;
157 }
158
159 onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_LEFT,
160 ucontrol->value.integer.value[0]
161 - VOLUME_RANGE_SHIFT);
162 onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT,
163 ucontrol->value.integer.value[1]
164 - VOLUME_RANGE_SHIFT);
165 mutex_unlock(&onyx->mutex);
166
167 return 1;
168 }
169
170 static struct snd_kcontrol_new volume_control = {
171 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
172 .name = "Master Playback Volume",
173 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
174 .info = onyx_snd_vol_info,
175 .get = onyx_snd_vol_get,
176 .put = onyx_snd_vol_put,
177 };
178
179 /* like above, this is necessary because a lot
180 * of alsa mixer programs don't handle ranges
181 * that don't start at 0 properly.
182 * even alsamixer is one of them... */
183 #define INPUTGAIN_RANGE_SHIFT (-3)
184
185 static int onyx_snd_inputgain_info(struct snd_kcontrol *kcontrol,
186 struct snd_ctl_elem_info *uinfo)
187 {
188 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
189 uinfo->count = 1;
190 uinfo->value.integer.min = 3 + INPUTGAIN_RANGE_SHIFT;
191 uinfo->value.integer.max = 28 + INPUTGAIN_RANGE_SHIFT;
192 return 0;
193 }
194
195 static int onyx_snd_inputgain_get(struct snd_kcontrol *kcontrol,
196 struct snd_ctl_elem_value *ucontrol)
197 {
198 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
199 u8 ig;
200
201 mutex_lock(&onyx->mutex);
202 onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &ig);
203 mutex_unlock(&onyx->mutex);
204
205 ucontrol->value.integer.value[0] =
206 (ig & ONYX_ADC_PGA_GAIN_MASK) + INPUTGAIN_RANGE_SHIFT;
207
208 return 0;
209 }
210
211 static int onyx_snd_inputgain_put(struct snd_kcontrol *kcontrol,
212 struct snd_ctl_elem_value *ucontrol)
213 {
214 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
215 u8 v, n;
216
217 if (ucontrol->value.integer.value[0] < 3 + INPUTGAIN_RANGE_SHIFT ||
218 ucontrol->value.integer.value[0] > 28 + INPUTGAIN_RANGE_SHIFT)
219 return -EINVAL;
220 mutex_lock(&onyx->mutex);
221 onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
222 n = v;
223 n &= ~ONYX_ADC_PGA_GAIN_MASK;
224 n |= (ucontrol->value.integer.value[0] - INPUTGAIN_RANGE_SHIFT)
225 & ONYX_ADC_PGA_GAIN_MASK;
226 onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, n);
227 mutex_unlock(&onyx->mutex);
228
229 return n != v;
230 }
231
232 static struct snd_kcontrol_new inputgain_control = {
233 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
234 .name = "Master Capture Volume",
235 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
236 .info = onyx_snd_inputgain_info,
237 .get = onyx_snd_inputgain_get,
238 .put = onyx_snd_inputgain_put,
239 };
240
241 static int onyx_snd_capture_source_info(struct snd_kcontrol *kcontrol,
242 struct snd_ctl_elem_info *uinfo)
243 {
244 static char *texts[] = { "Line-In", "Microphone" };
245
246 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
247 uinfo->count = 1;
248 uinfo->value.enumerated.items = 2;
249 if (uinfo->value.enumerated.item > 1)
250 uinfo->value.enumerated.item = 1;
251 strcpy(uinfo->value.enumerated.name, texts[uinfo->value.enumerated.item]);
252 return 0;
253 }
254
255 static int onyx_snd_capture_source_get(struct snd_kcontrol *kcontrol,
256 struct snd_ctl_elem_value *ucontrol)
257 {
258 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
259 s8 v;
260
261 mutex_lock(&onyx->mutex);
262 onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
263 mutex_unlock(&onyx->mutex);
264
265 ucontrol->value.enumerated.item[0] = !!(v&ONYX_ADC_INPUT_MIC);
266
267 return 0;
268 }
269
270 static void onyx_set_capture_source(struct onyx *onyx, int mic)
271 {
272 s8 v;
273
274 mutex_lock(&onyx->mutex);
275 onyx_read_register(onyx, ONYX_REG_ADC_CONTROL, &v);
276 v &= ~ONYX_ADC_INPUT_MIC;
277 if (mic)
278 v |= ONYX_ADC_INPUT_MIC;
279 onyx_write_register(onyx, ONYX_REG_ADC_CONTROL, v);
280 mutex_unlock(&onyx->mutex);
281 }
282
283 static int onyx_snd_capture_source_put(struct snd_kcontrol *kcontrol,
284 struct snd_ctl_elem_value *ucontrol)
285 {
286 if (ucontrol->value.enumerated.item[0] > 1)
287 return -EINVAL;
288 onyx_set_capture_source(snd_kcontrol_chip(kcontrol),
289 ucontrol->value.enumerated.item[0]);
290 return 1;
291 }
292
293 static struct snd_kcontrol_new capture_source_control = {
294 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
295 /* If we name this 'Input Source', it properly shows up in
296 * alsamixer as a selection, * but it's shown under the
297 * 'Playback' category.
298 * If I name it 'Capture Source', it shows up in strange
299 * ways (two bools of which one can be selected at a
300 * time) but at least it's shown in the 'Capture'
301 * category.
302 * I was told that this was due to backward compatibility,
303 * but I don't understand then why the mangling is *not*
304 * done when I name it "Input Source".....
305 */
306 .name = "Capture Source",
307 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
308 .info = onyx_snd_capture_source_info,
309 .get = onyx_snd_capture_source_get,
310 .put = onyx_snd_capture_source_put,
311 };
312
313 #define onyx_snd_mute_info snd_ctl_boolean_stereo_info
314
315 static int onyx_snd_mute_get(struct snd_kcontrol *kcontrol,
316 struct snd_ctl_elem_value *ucontrol)
317 {
318 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
319 u8 c;
320
321 mutex_lock(&onyx->mutex);
322 onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &c);
323 mutex_unlock(&onyx->mutex);
324
325 ucontrol->value.integer.value[0] = !(c & ONYX_MUTE_LEFT);
326 ucontrol->value.integer.value[1] = !(c & ONYX_MUTE_RIGHT);
327
328 return 0;
329 }
330
331 static int onyx_snd_mute_put(struct snd_kcontrol *kcontrol,
332 struct snd_ctl_elem_value *ucontrol)
333 {
334 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
335 u8 v = 0, c = 0;
336 int err = -EBUSY;
337
338 mutex_lock(&onyx->mutex);
339 if (onyx->analog_locked)
340 goto out_unlock;
341
342 onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
343 c = v;
344 c &= ~(ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT);
345 if (!ucontrol->value.integer.value[0])
346 c |= ONYX_MUTE_LEFT;
347 if (!ucontrol->value.integer.value[1])
348 c |= ONYX_MUTE_RIGHT;
349 err = onyx_write_register(onyx, ONYX_REG_DAC_CONTROL, c);
350
351 out_unlock:
352 mutex_unlock(&onyx->mutex);
353
354 return !err ? (v != c) : err;
355 }
356
357 static struct snd_kcontrol_new mute_control = {
358 .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
359 .name = "Master Playback Switch",
360 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
361 .info = onyx_snd_mute_info,
362 .get = onyx_snd_mute_get,
363 .put = onyx_snd_mute_put,
364 };
365
366
367 #define onyx_snd_single_bit_info snd_ctl_boolean_mono_info
368
369 #define FLAG_POLARITY_INVERT 1
370 #define FLAG_SPDIFLOCK 2
371
372 static int onyx_snd_single_bit_get(struct snd_kcontrol *kcontrol,
373 struct snd_ctl_elem_value *ucontrol)
374 {
375 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
376 u8 c;
377 long int pv = kcontrol->private_value;
378 u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT;
379 u8 address = (pv >> 8) & 0xff;
380 u8 mask = pv & 0xff;
381
382 mutex_lock(&onyx->mutex);
383 onyx_read_register(onyx, address, &c);
384 mutex_unlock(&onyx->mutex);
385
386 ucontrol->value.integer.value[0] = !!(c & mask) ^ polarity;
387
388 return 0;
389 }
390
391 static int onyx_snd_single_bit_put(struct snd_kcontrol *kcontrol,
392 struct snd_ctl_elem_value *ucontrol)
393 {
394 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
395 u8 v = 0, c = 0;
396 int err;
397 long int pv = kcontrol->private_value;
398 u8 polarity = (pv >> 16) & FLAG_POLARITY_INVERT;
399 u8 spdiflock = (pv >> 16) & FLAG_SPDIFLOCK;
400 u8 address = (pv >> 8) & 0xff;
401 u8 mask = pv & 0xff;
402
403 mutex_lock(&onyx->mutex);
404 if (spdiflock && onyx->spdif_locked) {
405 /* even if alsamixer doesn't care.. */
406 err = -EBUSY;
407 goto out_unlock;
408 }
409 onyx_read_register(onyx, address, &v);
410 c = v;
411 c &= ~(mask);
412 if (!!ucontrol->value.integer.value[0] ^ polarity)
413 c |= mask;
414 err = onyx_write_register(onyx, address, c);
415
416 out_unlock:
417 mutex_unlock(&onyx->mutex);
418
419 return !err ? (v != c) : err;
420 }
421
422 #define SINGLE_BIT(n, type, description, address, mask, flags) \
423 static struct snd_kcontrol_new n##_control = { \
424 .iface = SNDRV_CTL_ELEM_IFACE_##type, \
425 .name = description, \
426 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE, \
427 .info = onyx_snd_single_bit_info, \
428 .get = onyx_snd_single_bit_get, \
429 .put = onyx_snd_single_bit_put, \
430 .private_value = (flags << 16) | (address << 8) | mask \
431 }
432
433 SINGLE_BIT(spdif,
434 MIXER,
435 SNDRV_CTL_NAME_IEC958("", PLAYBACK, SWITCH),
436 ONYX_REG_DIG_INFO4,
437 ONYX_SPDIF_ENABLE,
438 FLAG_SPDIFLOCK);
439 SINGLE_BIT(ovr1,
440 MIXER,
441 "Oversampling Rate",
442 ONYX_REG_DAC_CONTROL,
443 ONYX_OVR1,
444 0);
445 SINGLE_BIT(flt0,
446 MIXER,
447 "Fast Digital Filter Rolloff",
448 ONYX_REG_DAC_FILTER,
449 ONYX_ROLLOFF_FAST,
450 FLAG_POLARITY_INVERT);
451 SINGLE_BIT(hpf,
452 MIXER,
453 "Highpass Filter",
454 ONYX_REG_ADC_HPF_BYPASS,
455 ONYX_HPF_DISABLE,
456 FLAG_POLARITY_INVERT);
457 SINGLE_BIT(dm12,
458 MIXER,
459 "Digital De-Emphasis",
460 ONYX_REG_DAC_DEEMPH,
461 ONYX_DIGDEEMPH_CTRL,
462 0);
463
464 static int onyx_spdif_info(struct snd_kcontrol *kcontrol,
465 struct snd_ctl_elem_info *uinfo)
466 {
467 uinfo->type = SNDRV_CTL_ELEM_TYPE_IEC958;
468 uinfo->count = 1;
469 return 0;
470 }
471
472 static int onyx_spdif_mask_get(struct snd_kcontrol *kcontrol,
473 struct snd_ctl_elem_value *ucontrol)
474 {
475 /* datasheet page 30, all others are 0 */
476 ucontrol->value.iec958.status[0] = 0x3e;
477 ucontrol->value.iec958.status[1] = 0xff;
478
479 ucontrol->value.iec958.status[3] = 0x3f;
480 ucontrol->value.iec958.status[4] = 0x0f;
481
482 return 0;
483 }
484
485 static struct snd_kcontrol_new onyx_spdif_mask = {
486 .access = SNDRV_CTL_ELEM_ACCESS_READ,
487 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
488 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,CON_MASK),
489 .info = onyx_spdif_info,
490 .get = onyx_spdif_mask_get,
491 };
492
493 static int onyx_spdif_get(struct snd_kcontrol *kcontrol,
494 struct snd_ctl_elem_value *ucontrol)
495 {
496 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
497 u8 v;
498
499 mutex_lock(&onyx->mutex);
500 onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v);
501 ucontrol->value.iec958.status[0] = v & 0x3e;
502
503 onyx_read_register(onyx, ONYX_REG_DIG_INFO2, &v);
504 ucontrol->value.iec958.status[1] = v;
505
506 onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v);
507 ucontrol->value.iec958.status[3] = v & 0x3f;
508
509 onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
510 ucontrol->value.iec958.status[4] = v & 0x0f;
511 mutex_unlock(&onyx->mutex);
512
513 return 0;
514 }
515
516 static int onyx_spdif_put(struct snd_kcontrol *kcontrol,
517 struct snd_ctl_elem_value *ucontrol)
518 {
519 struct onyx *onyx = snd_kcontrol_chip(kcontrol);
520 u8 v;
521
522 mutex_lock(&onyx->mutex);
523 onyx_read_register(onyx, ONYX_REG_DIG_INFO1, &v);
524 v = (v & ~0x3e) | (ucontrol->value.iec958.status[0] & 0x3e);
525 onyx_write_register(onyx, ONYX_REG_DIG_INFO1, v);
526
527 v = ucontrol->value.iec958.status[1];
528 onyx_write_register(onyx, ONYX_REG_DIG_INFO2, v);
529
530 onyx_read_register(onyx, ONYX_REG_DIG_INFO3, &v);
531 v = (v & ~0x3f) | (ucontrol->value.iec958.status[3] & 0x3f);
532 onyx_write_register(onyx, ONYX_REG_DIG_INFO3, v);
533
534 onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
535 v = (v & ~0x0f) | (ucontrol->value.iec958.status[4] & 0x0f);
536 onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
537 mutex_unlock(&onyx->mutex);
538
539 return 1;
540 }
541
542 static struct snd_kcontrol_new onyx_spdif_ctrl = {
543 .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
544 .iface = SNDRV_CTL_ELEM_IFACE_PCM,
545 .name = SNDRV_CTL_NAME_IEC958("",PLAYBACK,DEFAULT),
546 .info = onyx_spdif_info,
547 .get = onyx_spdif_get,
548 .put = onyx_spdif_put,
549 };
550
551 /* our registers */
552
553 static u8 register_map[] = {
554 ONYX_REG_DAC_ATTEN_LEFT,
555 ONYX_REG_DAC_ATTEN_RIGHT,
556 ONYX_REG_CONTROL,
557 ONYX_REG_DAC_CONTROL,
558 ONYX_REG_DAC_DEEMPH,
559 ONYX_REG_DAC_FILTER,
560 ONYX_REG_DAC_OUTPHASE,
561 ONYX_REG_ADC_CONTROL,
562 ONYX_REG_ADC_HPF_BYPASS,
563 ONYX_REG_DIG_INFO1,
564 ONYX_REG_DIG_INFO2,
565 ONYX_REG_DIG_INFO3,
566 ONYX_REG_DIG_INFO4
567 };
568
569 static u8 initial_values[ARRAY_SIZE(register_map)] = {
570 0x80, 0x80, /* muted */
571 ONYX_MRST | ONYX_SRST, /* but handled specially! */
572 ONYX_MUTE_LEFT | ONYX_MUTE_RIGHT,
573 0, /* no deemphasis */
574 ONYX_DAC_FILTER_ALWAYS,
575 ONYX_OUTPHASE_INVERTED,
576 (-1 /*dB*/ + 8) & 0xF, /* line in selected, -1 dB gain*/
577 ONYX_ADC_HPF_ALWAYS,
578 (1<<2), /* pcm audio */
579 2, /* category: pcm coder */
580 0, /* sampling frequency 44.1 kHz, clock accuracy level II */
581 1 /* 24 bit depth */
582 };
583
584 /* reset registers of chip, either to initial or to previous values */
585 static int onyx_register_init(struct onyx *onyx)
586 {
587 int i;
588 u8 val;
589 u8 regs[sizeof(initial_values)];
590
591 if (!onyx->initialised) {
592 memcpy(regs, initial_values, sizeof(initial_values));
593 if (onyx_read_register(onyx, ONYX_REG_CONTROL, &val))
594 return -1;
595 val &= ~ONYX_SILICONVERSION;
596 val |= initial_values[3];
597 regs[3] = val;
598 } else {
599 for (i=0; i<sizeof(register_map); i++)
600 regs[i] = onyx->cache[register_map[i]-FIRSTREGISTER];
601 }
602
603 for (i=0; i<sizeof(register_map); i++) {
604 if (onyx_write_register(onyx, register_map[i], regs[i]))
605 return -1;
606 }
607 onyx->initialised = 1;
608 return 0;
609 }
610
611 static struct transfer_info onyx_transfers[] = {
612 /* this is first so we can skip it if no input is present...
613 * No hardware exists with that, but it's here as an example
614 * of what to do :) */
615 {
616 /* analog input */
617 .formats = SNDRV_PCM_FMTBIT_S8 |
618 SNDRV_PCM_FMTBIT_S16_BE |
619 SNDRV_PCM_FMTBIT_S24_BE,
620 .rates = SNDRV_PCM_RATE_8000_96000,
621 .transfer_in = 1,
622 .must_be_clock_source = 0,
623 .tag = 0,
624 },
625 {
626 /* if analog and digital are currently off, anything should go,
627 * so this entry describes everything we can do... */
628 .formats = SNDRV_PCM_FMTBIT_S8 |
629 SNDRV_PCM_FMTBIT_S16_BE |
630 SNDRV_PCM_FMTBIT_S24_BE
631 #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
632 | SNDRV_PCM_FMTBIT_COMPRESSED_16BE
633 #endif
634 ,
635 .rates = SNDRV_PCM_RATE_8000_96000,
636 .tag = 0,
637 },
638 {
639 /* analog output */
640 .formats = SNDRV_PCM_FMTBIT_S8 |
641 SNDRV_PCM_FMTBIT_S16_BE |
642 SNDRV_PCM_FMTBIT_S24_BE,
643 .rates = SNDRV_PCM_RATE_8000_96000,
644 .transfer_in = 0,
645 .must_be_clock_source = 0,
646 .tag = 1,
647 },
648 {
649 /* digital pcm output, also possible for analog out */
650 .formats = SNDRV_PCM_FMTBIT_S8 |
651 SNDRV_PCM_FMTBIT_S16_BE |
652 SNDRV_PCM_FMTBIT_S24_BE,
653 .rates = SNDRV_PCM_RATE_32000 |
654 SNDRV_PCM_RATE_44100 |
655 SNDRV_PCM_RATE_48000,
656 .transfer_in = 0,
657 .must_be_clock_source = 0,
658 .tag = 2,
659 },
660 #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
661 /* Once alsa gets supports for this kind of thing we can add it... */
662 {
663 /* digital compressed output */
664 .formats = SNDRV_PCM_FMTBIT_COMPRESSED_16BE,
665 .rates = SNDRV_PCM_RATE_32000 |
666 SNDRV_PCM_RATE_44100 |
667 SNDRV_PCM_RATE_48000,
668 .tag = 2,
669 },
670 #endif
671 {}
672 };
673
674 static int onyx_usable(struct codec_info_item *cii,
675 struct transfer_info *ti,
676 struct transfer_info *out)
677 {
678 u8 v;
679 struct onyx *onyx = cii->codec_data;
680 int spdif_enabled, analog_enabled;
681
682 mutex_lock(&onyx->mutex);
683 onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
684 spdif_enabled = !!(v & ONYX_SPDIF_ENABLE);
685 onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
686 analog_enabled =
687 (v & (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT))
688 != (ONYX_MUTE_RIGHT|ONYX_MUTE_LEFT);
689 mutex_unlock(&onyx->mutex);
690
691 switch (ti->tag) {
692 case 0: return 1;
693 case 1: return analog_enabled;
694 case 2: return spdif_enabled;
695 }
696 return 1;
697 }
698
699 static int onyx_prepare(struct codec_info_item *cii,
700 struct bus_info *bi,
701 struct snd_pcm_substream *substream)
702 {
703 u8 v;
704 struct onyx *onyx = cii->codec_data;
705 int err = -EBUSY;
706
707 mutex_lock(&onyx->mutex);
708
709 #ifdef SNDRV_PCM_FMTBIT_COMPRESSED_16BE
710 if (substream->runtime->format == SNDRV_PCM_FMTBIT_COMPRESSED_16BE) {
711 /* mute and lock analog output */
712 onyx_read_register(onyx, ONYX_REG_DAC_CONTROL, &v);
713 if (onyx_write_register(onyx,
714 ONYX_REG_DAC_CONTROL,
715 v | ONYX_MUTE_RIGHT | ONYX_MUTE_LEFT))
716 goto out_unlock;
717 onyx->analog_locked = 1;
718 err = 0;
719 goto out_unlock;
720 }
721 #endif
722 switch (substream->runtime->rate) {
723 case 32000:
724 case 44100:
725 case 48000:
726 /* these rates are ok for all outputs */
727 err = 0;
728 goto out_unlock;
729 default:
730 /* got some rate that the digital output can't do,
731 * so disable and lock it */
732 onyx_read_register(cii->codec_data, ONYX_REG_DIG_INFO4, &v);
733 if (onyx_write_register(onyx,
734 ONYX_REG_DIG_INFO4,
735 v & ~ONYX_SPDIF_ENABLE))
736 goto out_unlock;
737 onyx->spdif_locked = 1;
738 err = 0;
739 goto out_unlock;
740 }
741
742 out_unlock:
743 mutex_unlock(&onyx->mutex);
744
745 return err;
746 }
747
748 static int onyx_open(struct codec_info_item *cii,
749 struct snd_pcm_substream *substream)
750 {
751 struct onyx *onyx = cii->codec_data;
752
753 mutex_lock(&onyx->mutex);
754 onyx->open_count++;
755 mutex_unlock(&onyx->mutex);
756
757 return 0;
758 }
759
760 static int onyx_close(struct codec_info_item *cii,
761 struct snd_pcm_substream *substream)
762 {
763 struct onyx *onyx = cii->codec_data;
764
765 mutex_lock(&onyx->mutex);
766 onyx->open_count--;
767 if (!onyx->open_count)
768 onyx->spdif_locked = onyx->analog_locked = 0;
769 mutex_unlock(&onyx->mutex);
770
771 return 0;
772 }
773
774 static int onyx_switch_clock(struct codec_info_item *cii,
775 enum clock_switch what)
776 {
777 struct onyx *onyx = cii->codec_data;
778
779 mutex_lock(&onyx->mutex);
780 /* this *MUST* be more elaborate later... */
781 switch (what) {
782 case CLOCK_SWITCH_PREPARE_SLAVE:
783 onyx->codec.gpio->methods->all_amps_off(onyx->codec.gpio);
784 break;
785 case CLOCK_SWITCH_SLAVE:
786 onyx->codec.gpio->methods->all_amps_restore(onyx->codec.gpio);
787 break;
788 default: /* silence warning */
789 break;
790 }
791 mutex_unlock(&onyx->mutex);
792
793 return 0;
794 }
795
796 #ifdef CONFIG_PM
797
798 static int onyx_suspend(struct codec_info_item *cii, pm_message_t state)
799 {
800 struct onyx *onyx = cii->codec_data;
801 u8 v;
802 int err = -ENXIO;
803
804 mutex_lock(&onyx->mutex);
805 if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
806 goto out_unlock;
807 onyx_write_register(onyx, ONYX_REG_CONTROL, v | ONYX_ADPSV | ONYX_DAPSV);
808 /* Apple does a sleep here but the datasheet says to do it on resume */
809 err = 0;
810 out_unlock:
811 mutex_unlock(&onyx->mutex);
812
813 return err;
814 }
815
816 static int onyx_resume(struct codec_info_item *cii)
817 {
818 struct onyx *onyx = cii->codec_data;
819 u8 v;
820 int err = -ENXIO;
821
822 mutex_lock(&onyx->mutex);
823
824 /* reset codec */
825 onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
826 msleep(1);
827 onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
828 msleep(1);
829 onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
830 msleep(1);
831
832 /* take codec out of suspend (if it still is after reset) */
833 if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
834 goto out_unlock;
835 onyx_write_register(onyx, ONYX_REG_CONTROL, v & ~(ONYX_ADPSV | ONYX_DAPSV));
836 msleep(2205000/8000);
837 /* reset all values */
838 onyx_register_init(onyx);
839 err = 0;
840 out_unlock:
841 mutex_unlock(&onyx->mutex);
842
843 return err;
844 }
845
846 #endif /* CONFIG_PM */
847
848 static struct codec_info onyx_codec_info = {
849 .transfers = onyx_transfers,
850 .sysclock_factor = 256,
851 .bus_factor = 64,
852 .owner = THIS_MODULE,
853 .usable = onyx_usable,
854 .prepare = onyx_prepare,
855 .open = onyx_open,
856 .close = onyx_close,
857 .switch_clock = onyx_switch_clock,
858 #ifdef CONFIG_PM
859 .suspend = onyx_suspend,
860 .resume = onyx_resume,
861 #endif
862 };
863
864 static int onyx_init_codec(struct aoa_codec *codec)
865 {
866 struct onyx *onyx = codec_to_onyx(codec);
867 struct snd_kcontrol *ctl;
868 struct codec_info *ci = &onyx_codec_info;
869 u8 v;
870 int err;
871
872 if (!onyx->codec.gpio || !onyx->codec.gpio->methods) {
873 printk(KERN_ERR PFX "gpios not assigned!!\n");
874 return -EINVAL;
875 }
876
877 onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
878 msleep(1);
879 onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
880 msleep(1);
881 onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
882 msleep(1);
883
884 if (onyx_register_init(onyx)) {
885 printk(KERN_ERR PFX "failed to initialise onyx registers\n");
886 return -ENODEV;
887 }
888
889 if (aoa_snd_device_new(SNDRV_DEV_LOWLEVEL, onyx, &ops)) {
890 printk(KERN_ERR PFX "failed to create onyx snd device!\n");
891 return -ENODEV;
892 }
893
894 /* nothing connected? what a joke! */
895 if ((onyx->codec.connected & 0xF) == 0)
896 return -ENOTCONN;
897
898 /* if no inputs are present... */
899 if ((onyx->codec.connected & 0xC) == 0) {
900 if (!onyx->codec_info)
901 onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
902 if (!onyx->codec_info)
903 return -ENOMEM;
904 ci = onyx->codec_info;
905 *ci = onyx_codec_info;
906 ci->transfers++;
907 }
908
909 /* if no outputs are present... */
910 if ((onyx->codec.connected & 3) == 0) {
911 if (!onyx->codec_info)
912 onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
913 if (!onyx->codec_info)
914 return -ENOMEM;
915 ci = onyx->codec_info;
916 /* this is fine as there have to be inputs
917 * if we end up in this part of the code */
918 *ci = onyx_codec_info;
919 ci->transfers[1].formats = 0;
920 }
921
922 if (onyx->codec.soundbus_dev->attach_codec(onyx->codec.soundbus_dev,
923 aoa_get_card(),
924 ci, onyx)) {
925 printk(KERN_ERR PFX "error creating onyx pcm\n");
926 return -ENODEV;
927 }
928 #define ADDCTL(n) \
929 do { \
930 ctl = snd_ctl_new1(&n, onyx); \
931 if (ctl) { \
932 ctl->id.device = \
933 onyx->codec.soundbus_dev->pcm->device; \
934 err = aoa_snd_ctl_add(ctl); \
935 if (err) \
936 goto error; \
937 } \
938 } while (0)
939
940 if (onyx->codec.soundbus_dev->pcm) {
941 /* give the user appropriate controls
942 * depending on what inputs are connected */
943 if ((onyx->codec.connected & 0xC) == 0xC)
944 ADDCTL(capture_source_control);
945 else if (onyx->codec.connected & 4)
946 onyx_set_capture_source(onyx, 0);
947 else
948 onyx_set_capture_source(onyx, 1);
949 if (onyx->codec.connected & 0xC)
950 ADDCTL(inputgain_control);
951
952 /* depending on what output is connected,
953 * give the user appropriate controls */
954 if (onyx->codec.connected & 1) {
955 ADDCTL(volume_control);
956 ADDCTL(mute_control);
957 ADDCTL(ovr1_control);
958 ADDCTL(flt0_control);
959 ADDCTL(hpf_control);
960 ADDCTL(dm12_control);
961 /* spdif control defaults to off */
962 }
963 if (onyx->codec.connected & 2) {
964 ADDCTL(onyx_spdif_mask);
965 ADDCTL(onyx_spdif_ctrl);
966 }
967 if ((onyx->codec.connected & 3) == 3)
968 ADDCTL(spdif_control);
969 /* if only S/PDIF is connected, enable it unconditionally */
970 if ((onyx->codec.connected & 3) == 2) {
971 onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
972 v |= ONYX_SPDIF_ENABLE;
973 onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
974 }
975 }
976 #undef ADDCTL
977 printk(KERN_INFO PFX "attached to onyx codec via i2c\n");
978
979 return 0;
980 error:
981 onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
982 snd_device_free(aoa_get_card(), onyx);
983 return err;
984 }
985
986 static void onyx_exit_codec(struct aoa_codec *codec)
987 {
988 struct onyx *onyx = codec_to_onyx(codec);
989
990 if (!onyx->codec.soundbus_dev) {
991 printk(KERN_ERR PFX "onyx_exit_codec called without soundbus_dev!\n");
992 return;
993 }
994 onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
995 }
996
997 static int onyx_create(struct i2c_adapter *adapter,
998 struct device_node *node,
999 int addr)
1000 {
1001 struct i2c_board_info info;
1002 struct i2c_client *client;
1003
1004 memset(&info, 0, sizeof(struct i2c_board_info));
1005 strlcpy(info.type, "aoa_codec_onyx", I2C_NAME_SIZE);
1006 info.addr = addr;
1007 info.platform_data = node;
1008 client = i2c_new_device(adapter, &info);
1009 if (!client)
1010 return -ENODEV;
1011
1012 /*
1013 * We know the driver is already loaded, so the device should be
1014 * already bound. If not it means binding failed, which suggests
1015 * the device doesn't really exist and should be deleted.
1016 * Ideally this would be replaced by better checks _before_
1017 * instantiating the device.
1018 */
1019 if (!client->driver) {
1020 i2c_unregister_device(client);
1021 return -ENODEV;
1022 }
1023
1024 /*
1025 * Let i2c-core delete that device on driver removal.
1026 * This is safe because i2c-core holds the core_lock mutex for us.
1027 */
1028 list_add_tail(&client->detected, &client->driver->clients);
1029 return 0;
1030 }
1031
1032 static int onyx_i2c_probe(struct i2c_client *client,
1033 const struct i2c_device_id *id)
1034 {
1035 struct device_node *node = client->dev.platform_data;
1036 struct onyx *onyx;
1037 u8 dummy;
1038
1039 onyx = kzalloc(sizeof(struct onyx), GFP_KERNEL);
1040
1041 if (!onyx)
1042 return -ENOMEM;
1043
1044 mutex_init(&onyx->mutex);
1045 onyx->i2c = client;
1046 i2c_set_clientdata(client, onyx);
1047
1048 /* we try to read from register ONYX_REG_CONTROL
1049 * to check if the codec is present */
1050 if (onyx_read_register(onyx, ONYX_REG_CONTROL, &dummy) != 0) {
1051 printk(KERN_ERR PFX "failed to read control register\n");
1052 goto fail;
1053 }
1054
1055 strlcpy(onyx->codec.name, "onyx", MAX_CODEC_NAME_LEN);
1056 onyx->codec.owner = THIS_MODULE;
1057 onyx->codec.init = onyx_init_codec;
1058 onyx->codec.exit = onyx_exit_codec;
1059 onyx->codec.node = of_node_get(node);
1060
1061 if (aoa_codec_register(&onyx->codec)) {
1062 goto fail;
1063 }
1064 printk(KERN_DEBUG PFX "created and attached onyx instance\n");
1065 return 0;
1066 fail:
1067 i2c_set_clientdata(client, NULL);
1068 kfree(onyx);
1069 return -ENODEV;
1070 }
1071
1072 static int onyx_i2c_attach(struct i2c_adapter *adapter)
1073 {
1074 struct device_node *busnode, *dev = NULL;
1075 struct pmac_i2c_bus *bus;
1076
1077 bus = pmac_i2c_adapter_to_bus(adapter);
1078 if (bus == NULL)
1079 return -ENODEV;
1080 busnode = pmac_i2c_get_bus_node(bus);
1081
1082 while ((dev = of_get_next_child(busnode, dev)) != NULL) {
1083 if (of_device_is_compatible(dev, "pcm3052")) {
1084 const u32 *addr;
1085 printk(KERN_DEBUG PFX "found pcm3052\n");
1086 addr = of_get_property(dev, "reg", NULL);
1087 if (!addr)
1088 return -ENODEV;
1089 return onyx_create(adapter, dev, (*addr)>>1);
1090 }
1091 }
1092
1093 /* if that didn't work, try desperate mode for older
1094 * machines that have stuff missing from the device tree */
1095
1096 if (!of_device_is_compatible(busnode, "k2-i2c"))
1097 return -ENODEV;
1098
1099 printk(KERN_DEBUG PFX "found k2-i2c, checking if onyx chip is on it\n");
1100 /* probe both possible addresses for the onyx chip */
1101 if (onyx_create(adapter, NULL, 0x46) == 0)
1102 return 0;
1103 return onyx_create(adapter, NULL, 0x47);
1104 }
1105
1106 static int onyx_i2c_remove(struct i2c_client *client)
1107 {
1108 struct onyx *onyx = i2c_get_clientdata(client);
1109
1110 aoa_codec_unregister(&onyx->codec);
1111 of_node_put(onyx->codec.node);
1112 if (onyx->codec_info)
1113 kfree(onyx->codec_info);
1114 i2c_set_clientdata(client, onyx);
1115 kfree(onyx);
1116 return 0;
1117 }
1118
1119 static const struct i2c_device_id onyx_i2c_id[] = {
1120 { "aoa_codec_onyx", 0 },
1121 { }
1122 };
1123
1124 static struct i2c_driver onyx_driver = {
1125 .driver = {
1126 .name = "aoa_codec_onyx",
1127 .owner = THIS_MODULE,
1128 },
1129 .attach_adapter = onyx_i2c_attach,
1130 .probe = onyx_i2c_probe,
1131 .remove = onyx_i2c_remove,
1132 .id_table = onyx_i2c_id,
1133 };
1134
1135 static int __init onyx_init(void)
1136 {
1137 return i2c_add_driver(&onyx_driver);
1138 }
1139
1140 static void __exit onyx_exit(void)
1141 {
1142 i2c_del_driver(&onyx_driver);
1143 }
1144
1145 module_init(onyx_init);
1146 module_exit(onyx_exit);
Tomato firmware and modifications.