~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/sound/aoa/codecs/onyx.c

Version: ~ [ linux-5.3 ] ~ [ linux-5.2.15 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.73 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.144 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.193 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.193 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.73 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  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                 /* FIXME: program spdif channel control bits here so that
728                  *        userspace doesn't have to if it only plays pcm! */
729                 err = 0;
730                 goto out_unlock;
731         default:
732                 /* got some rate that the digital output can't do,
733                  * so disable and lock it */
734                 onyx_read_register(cii->codec_data, ONYX_REG_DIG_INFO4, &v);
735                 if (onyx_write_register(onyx,
736                                         ONYX_REG_DIG_INFO4,
737                                         v & ~ONYX_SPDIF_ENABLE))
738                         goto out_unlock;
739                 onyx->spdif_locked = 1;
740                 err = 0;
741                 goto out_unlock;
742         }
743 
744  out_unlock:
745         mutex_unlock(&onyx->mutex);
746 
747         return err;
748 }
749 
750 static int onyx_open(struct codec_info_item *cii,
751                      struct snd_pcm_substream *substream)
752 {
753         struct onyx *onyx = cii->codec_data;
754 
755         mutex_lock(&onyx->mutex);
756         onyx->open_count++;
757         mutex_unlock(&onyx->mutex);
758 
759         return 0;
760 }
761 
762 static int onyx_close(struct codec_info_item *cii,
763                       struct snd_pcm_substream *substream)
764 {
765         struct onyx *onyx = cii->codec_data;
766 
767         mutex_lock(&onyx->mutex);
768         onyx->open_count--;
769         if (!onyx->open_count)
770                 onyx->spdif_locked = onyx->analog_locked = 0;
771         mutex_unlock(&onyx->mutex);
772 
773         return 0;
774 }
775 
776 static int onyx_switch_clock(struct codec_info_item *cii,
777                              enum clock_switch what)
778 {
779         struct onyx *onyx = cii->codec_data;
780 
781         mutex_lock(&onyx->mutex);
782         /* this *MUST* be more elaborate later... */
783         switch (what) {
784         case CLOCK_SWITCH_PREPARE_SLAVE:
785                 onyx->codec.gpio->methods->all_amps_off(onyx->codec.gpio);
786                 break;
787         case CLOCK_SWITCH_SLAVE:
788                 onyx->codec.gpio->methods->all_amps_restore(onyx->codec.gpio);
789                 break;
790         default: /* silence warning */
791                 break;
792         }
793         mutex_unlock(&onyx->mutex);
794 
795         return 0;
796 }
797 
798 #ifdef CONFIG_PM
799 
800 static int onyx_suspend(struct codec_info_item *cii, pm_message_t state)
801 {
802         struct onyx *onyx = cii->codec_data;
803         u8 v;
804         int err = -ENXIO;
805 
806         mutex_lock(&onyx->mutex);
807         if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
808                 goto out_unlock;
809         onyx_write_register(onyx, ONYX_REG_CONTROL, v | ONYX_ADPSV | ONYX_DAPSV);
810         /* Apple does a sleep here but the datasheet says to do it on resume */
811         err = 0;
812  out_unlock:
813         mutex_unlock(&onyx->mutex);
814 
815         return err;
816 }
817 
818 static int onyx_resume(struct codec_info_item *cii)
819 {
820         struct onyx *onyx = cii->codec_data;
821         u8 v;
822         int err = -ENXIO;
823 
824         mutex_lock(&onyx->mutex);
825 
826         /* reset codec */
827         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
828         msleep(1);
829         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
830         msleep(1);
831         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
832         msleep(1);
833 
834         /* take codec out of suspend (if it still is after reset) */
835         if (onyx_read_register(onyx, ONYX_REG_CONTROL, &v))
836                 goto out_unlock;
837         onyx_write_register(onyx, ONYX_REG_CONTROL, v & ~(ONYX_ADPSV | ONYX_DAPSV));
838         /* FIXME: should divide by sample rate, but 8k is the lowest we go */
839         msleep(2205000/8000);
840         /* reset all values */
841         onyx_register_init(onyx);
842         err = 0;
843  out_unlock:
844         mutex_unlock(&onyx->mutex);
845 
846         return err;
847 }
848 
849 #endif /* CONFIG_PM */
850 
851 static struct codec_info onyx_codec_info = {
852         .transfers = onyx_transfers,
853         .sysclock_factor = 256,
854         .bus_factor = 64,
855         .owner = THIS_MODULE,
856         .usable = onyx_usable,
857         .prepare = onyx_prepare,
858         .open = onyx_open,
859         .close = onyx_close,
860         .switch_clock = onyx_switch_clock,
861 #ifdef CONFIG_PM
862         .suspend = onyx_suspend,
863         .resume = onyx_resume,
864 #endif
865 };
866 
867 static int onyx_init_codec(struct aoa_codec *codec)
868 {
869         struct onyx *onyx = codec_to_onyx(codec);
870         struct snd_kcontrol *ctl;
871         struct codec_info *ci = &onyx_codec_info;
872         u8 v;
873         int err;
874 
875         if (!onyx->codec.gpio || !onyx->codec.gpio->methods) {
876                 printk(KERN_ERR PFX "gpios not assigned!!\n");
877                 return -EINVAL;
878         }
879 
880         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
881         msleep(1);
882         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 1);
883         msleep(1);
884         onyx->codec.gpio->methods->set_hw_reset(onyx->codec.gpio, 0);
885         msleep(1);
886 
887         if (onyx_register_init(onyx)) {
888                 printk(KERN_ERR PFX "failed to initialise onyx registers\n");
889                 return -ENODEV;
890         }
891 
892         if (aoa_snd_device_new(SNDRV_DEV_LOWLEVEL, onyx, &ops)) {
893                 printk(KERN_ERR PFX "failed to create onyx snd device!\n");
894                 return -ENODEV;
895         }
896 
897         /* nothing connected? what a joke! */
898         if ((onyx->codec.connected & 0xF) == 0)
899                 return -ENOTCONN;
900 
901         /* if no inputs are present... */
902         if ((onyx->codec.connected & 0xC) == 0) {
903                 if (!onyx->codec_info)
904                         onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
905                 if (!onyx->codec_info)
906                         return -ENOMEM;
907                 ci = onyx->codec_info;
908                 *ci = onyx_codec_info;
909                 ci->transfers++;
910         }
911 
912         /* if no outputs are present... */
913         if ((onyx->codec.connected & 3) == 0) {
914                 if (!onyx->codec_info)
915                         onyx->codec_info = kmalloc(sizeof(struct codec_info), GFP_KERNEL);
916                 if (!onyx->codec_info)
917                         return -ENOMEM;
918                 ci = onyx->codec_info;
919                 /* this is fine as there have to be inputs
920                  * if we end up in this part of the code */
921                 *ci = onyx_codec_info;
922                 ci->transfers[1].formats = 0;
923         }
924 
925         if (onyx->codec.soundbus_dev->attach_codec(onyx->codec.soundbus_dev,
926                                                    aoa_get_card(),
927                                                    ci, onyx)) {
928                 printk(KERN_ERR PFX "error creating onyx pcm\n");
929                 return -ENODEV;
930         }
931 #define ADDCTL(n)                                                       \
932         do {                                                            \
933                 ctl = snd_ctl_new1(&n, onyx);                           \
934                 if (ctl) {                                              \
935                         ctl->id.device =                                \
936                                 onyx->codec.soundbus_dev->pcm->device;  \
937                         err = aoa_snd_ctl_add(ctl);                     \
938                         if (err)                                        \
939                                 goto error;                             \
940                 }                                                       \
941         } while (0)
942 
943         if (onyx->codec.soundbus_dev->pcm) {
944                 /* give the user appropriate controls
945                  * depending on what inputs are connected */
946                 if ((onyx->codec.connected & 0xC) == 0xC)
947                         ADDCTL(capture_source_control);
948                 else if (onyx->codec.connected & 4)
949                         onyx_set_capture_source(onyx, 0);
950                 else
951                         onyx_set_capture_source(onyx, 1);
952                 if (onyx->codec.connected & 0xC)
953                         ADDCTL(inputgain_control);
954 
955                 /* depending on what output is connected,
956                  * give the user appropriate controls */
957                 if (onyx->codec.connected & 1) {
958                         ADDCTL(volume_control);
959                         ADDCTL(mute_control);
960                         ADDCTL(ovr1_control);
961                         ADDCTL(flt0_control);
962                         ADDCTL(hpf_control);
963                         ADDCTL(dm12_control);
964                         /* spdif control defaults to off */
965                 }
966                 if (onyx->codec.connected & 2) {
967                         ADDCTL(onyx_spdif_mask);
968                         ADDCTL(onyx_spdif_ctrl);
969                 }
970                 if ((onyx->codec.connected & 3) == 3)
971                         ADDCTL(spdif_control);
972                 /* if only S/PDIF is connected, enable it unconditionally */
973                 if ((onyx->codec.connected & 3) == 2) {
974                         onyx_read_register(onyx, ONYX_REG_DIG_INFO4, &v);
975                         v |= ONYX_SPDIF_ENABLE;
976                         onyx_write_register(onyx, ONYX_REG_DIG_INFO4, v);
977                 }
978         }
979 #undef ADDCTL
980         printk(KERN_INFO PFX "attached to onyx codec via i2c\n");
981 
982         return 0;
983  error:
984         onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
985         snd_device_free(aoa_get_card(), onyx);
986         return err;
987 }
988 
989 static void onyx_exit_codec(struct aoa_codec *codec)
990 {
991         struct onyx *onyx = codec_to_onyx(codec);
992 
993         if (!onyx->codec.soundbus_dev) {
994                 printk(KERN_ERR PFX "onyx_exit_codec called without soundbus_dev!\n");
995                 return;
996         }
997         onyx->codec.soundbus_dev->detach_codec(onyx->codec.soundbus_dev, onyx);
998 }
999 
1000 static int onyx_i2c_probe(struct i2c_client *client,
1001                           const struct i2c_device_id *id)
1002 {
1003         struct device_node *node = client->dev.of_node;
1004         struct onyx *onyx;
1005         u8 dummy;
1006 
1007         onyx = kzalloc(sizeof(struct onyx), GFP_KERNEL);
1008 
1009         if (!onyx)
1010                 return -ENOMEM;
1011 
1012         mutex_init(&onyx->mutex);
1013         onyx->i2c = client;
1014         i2c_set_clientdata(client, onyx);
1015 
1016         /* we try to read from register ONYX_REG_CONTROL
1017          * to check if the codec is present */
1018         if (onyx_read_register(onyx, ONYX_REG_CONTROL, &dummy) != 0) {
1019                 printk(KERN_ERR PFX "failed to read control register\n");
1020                 goto fail;
1021         }
1022 
1023         strlcpy(onyx->codec.name, "onyx", MAX_CODEC_NAME_LEN);
1024         onyx->codec.owner = THIS_MODULE;
1025         onyx->codec.init = onyx_init_codec;
1026         onyx->codec.exit = onyx_exit_codec;
1027         onyx->codec.node = of_node_get(node);
1028 
1029         if (aoa_codec_register(&onyx->codec)) {
1030                 goto fail;
1031         }
1032         printk(KERN_DEBUG PFX "created and attached onyx instance\n");
1033         return 0;
1034  fail:
1035         kfree(onyx);
1036         return -ENODEV;
1037 }
1038 
1039 static int onyx_i2c_remove(struct i2c_client *client)
1040 {
1041         struct onyx *onyx = i2c_get_clientdata(client);
1042 
1043         aoa_codec_unregister(&onyx->codec);
1044         of_node_put(onyx->codec.node);
1045         kfree(onyx->codec_info);
1046         kfree(onyx);
1047         return 0;
1048 }
1049 
1050 static const struct i2c_device_id onyx_i2c_id[] = {
1051         { "MAC,pcm3052", 0 },
1052         { }
1053 };
1054 MODULE_DEVICE_TABLE(i2c,onyx_i2c_id);
1055 
1056 static struct i2c_driver onyx_driver = {
1057         .driver = {
1058                 .name = "aoa_codec_onyx",
1059                 .owner = THIS_MODULE,
1060         },
1061         .probe = onyx_i2c_probe,
1062         .remove = onyx_i2c_remove,
1063         .id_table = onyx_i2c_id,
1064 };
1065 
1066 module_i2c_driver(onyx_driver);
1067 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp