Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
onyx.c
Go to the documentation of this file.
1 /*
2  * Apple Onboard Audio driver for Onyx codec
3  *
4  * Copyright 2006 Johannes Berg <[email protected]>
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 <[email protected]>");
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;
54  spdif_locked:1,
55  analog_locked:1,
56  original_mute:2;
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;
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 {
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]
162  onyx_write_register(onyx, ONYX_REG_DAC_ATTEN_RIGHT,
163  ucontrol->value.integer.value[1]
165  mutex_unlock(&onyx->mutex);
166 
167  return 1;
168 }
169 
170 static struct snd_kcontrol_new volume_control = {
172  .name = "Master Playback Volume",
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 {
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] =
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;
224  n |= (ucontrol->value.integer.value[0] - INPUTGAIN_RANGE_SHIFT)
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 = {
234  .name = "Master Capture Volume",
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 
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 = {
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",
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;
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 = {
359  .name = "Master Playback Switch",
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 
434  MIXER,
439 SINGLE_BIT(ovr1,
440  MIXER,
441  "Oversampling Rate",
443  ONYX_OVR1,
444  0);
445 SINGLE_BIT(flt0,
446  MIXER,
447  "Fast Digital Filter Rolloff",
451 SINGLE_BIT(hpf,
452  MIXER,
453  "Highpass Filter",
457 SINGLE_BIT(dm12,
458  MIXER,
459  "Digital De-Emphasis",
462  0);
463 
464 static int onyx_spdif_info(struct snd_kcontrol *kcontrol,
465  struct snd_ctl_elem_info *uinfo)
466 {
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,
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 = {
544  .iface = SNDRV_CTL_ELEM_IFACE_PCM,
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[] = {
567 };
568 
569 static u8 initial_values[ARRAY_SIZE(register_map)] = {
570  0x80, 0x80, /* muted */
571  ONYX_MRST | ONYX_SRST, /* but handled specially! */
573  0, /* no deemphasis */
576  (-1 /*dB*/ + 8) & 0xF, /* line in selected, -1 dB gain*/
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 |
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 |
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 |
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 |
653  .rates = SNDRV_PCM_RATE_32000 |
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 |
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 =
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,
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,
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) {
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);