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