ALSA: hda - Add quirk for MacBook Pro 5,5 with CS4206
[linux-2.6.git] / sound / pci / hda / patch_cirrus.c
1 /*
2  * HD audio interface patch for Cirrus Logic CS420x chip
3  *
4  * Copyright (c) 2009 Takashi Iwai <tiwai@suse.de>
5  *
6  *  This driver is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 2 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This driver is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, write to the Free Software
18  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
19  */
20
21 #include <linux/init.h>
22 #include <linux/delay.h>
23 #include <linux/slab.h>
24 #include <linux/pci.h>
25 #include <sound/core.h>
26 #include "hda_codec.h"
27 #include "hda_local.h"
28
29 /*
30  */
31
32 struct cs_spec {
33         int board_config;
34         struct auto_pin_cfg autocfg;
35         struct hda_multi_out multiout;
36         struct snd_kcontrol *vmaster_sw;
37         struct snd_kcontrol *vmaster_vol;
38
39         hda_nid_t dac_nid[AUTO_CFG_MAX_OUTS];
40         hda_nid_t slave_dig_outs[2];
41
42         unsigned int input_idx[AUTO_PIN_LAST];
43         unsigned int capsrc_idx[AUTO_PIN_LAST];
44         hda_nid_t adc_nid[AUTO_PIN_LAST];
45         unsigned int adc_idx[AUTO_PIN_LAST];
46         unsigned int num_inputs;
47         unsigned int cur_input;
48         unsigned int automic_idx;
49         hda_nid_t cur_adc;
50         unsigned int cur_adc_stream_tag;
51         unsigned int cur_adc_format;
52         hda_nid_t dig_in;
53
54         struct hda_bind_ctls *capture_bind[2];
55
56         struct hda_pcm pcm_rec[2];      /* PCM information */
57
58         unsigned int hp_detect:1;
59         unsigned int mic_detect:1;
60 };
61
62 /* available models */
63 enum {
64         CS420X_MBP55,
65         CS420X_AUTO,
66         CS420X_MODELS
67 };
68
69 /* Vendor-specific processing widget */
70 #define CS420X_VENDOR_NID       0x11
71 #define CS_DIG_OUT1_PIN_NID     0x10
72 #define CS_DIG_OUT2_PIN_NID     0x15
73 #define CS_DMIC1_PIN_NID        0x12
74 #define CS_DMIC2_PIN_NID        0x0e
75
76 /* coef indices */
77 #define IDX_SPDIF_STAT          0x0000
78 #define IDX_SPDIF_CTL           0x0001
79 #define IDX_ADC_CFG             0x0002
80 /* SZC bitmask, 4 modes below:
81  * 0 = immediate,
82  * 1 = digital immediate, analog zero-cross
83  * 2 = digtail & analog soft-ramp
84  * 3 = digital soft-ramp, analog zero-cross
85  */
86 #define   CS_COEF_ADC_SZC_MASK          (3 << 0)
87 #define   CS_COEF_ADC_MIC_SZC_MODE      (3 << 0) /* SZC setup for mic */
88 #define   CS_COEF_ADC_LI_SZC_MODE       (3 << 0) /* SZC setup for line-in */
89 /* PGA mode: 0 = differential, 1 = signle-ended */
90 #define   CS_COEF_ADC_MIC_PGA_MODE      (1 << 5) /* PGA setup for mic */
91 #define   CS_COEF_ADC_LI_PGA_MODE       (1 << 6) /* PGA setup for line-in */
92 #define IDX_DAC_CFG             0x0003
93 /* SZC bitmask, 4 modes below:
94  * 0 = Immediate
95  * 1 = zero-cross
96  * 2 = soft-ramp
97  * 3 = soft-ramp on zero-cross
98  */
99 #define   CS_COEF_DAC_HP_SZC_MODE       (3 << 0) /* nid 0x02 */
100 #define   CS_COEF_DAC_LO_SZC_MODE       (3 << 2) /* nid 0x03 */
101 #define   CS_COEF_DAC_SPK_SZC_MODE      (3 << 4) /* nid 0x04 */
102
103 #define IDX_BEEP_CFG            0x0004
104 /* 0x0008 - test reg key */
105 /* 0x0009 - 0x0014 -> 12 test regs */
106 /* 0x0015 - visibility reg */
107
108
109 static int cs_vendor_coef_get(struct hda_codec *codec, unsigned int idx)
110 {
111         snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0,
112                             AC_VERB_SET_COEF_INDEX, idx);
113         return snd_hda_codec_read(codec, CS420X_VENDOR_NID, 0,
114                                   AC_VERB_GET_PROC_COEF, 0);
115 }
116
117 static void cs_vendor_coef_set(struct hda_codec *codec, unsigned int idx,
118                                unsigned int coef)
119 {
120         snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0,
121                             AC_VERB_SET_COEF_INDEX, idx);
122         snd_hda_codec_write(codec, CS420X_VENDOR_NID, 0,
123                             AC_VERB_SET_PROC_COEF, coef);
124 }
125
126
127 #define HP_EVENT        1
128 #define MIC_EVENT       2
129
130 /*
131  * PCM callbacks
132  */
133 static int cs_playback_pcm_open(struct hda_pcm_stream *hinfo,
134                                 struct hda_codec *codec,
135                                 struct snd_pcm_substream *substream)
136 {
137         struct cs_spec *spec = codec->spec;
138         return snd_hda_multi_out_analog_open(codec, &spec->multiout, substream,
139                                              hinfo);
140 }
141
142 static int cs_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
143                                    struct hda_codec *codec,
144                                    unsigned int stream_tag,
145                                    unsigned int format,
146                                    struct snd_pcm_substream *substream)
147 {
148         struct cs_spec *spec = codec->spec;
149         return snd_hda_multi_out_analog_prepare(codec, &spec->multiout,
150                                                 stream_tag, format, substream);
151 }
152
153 static int cs_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
154                                    struct hda_codec *codec,
155                                    struct snd_pcm_substream *substream)
156 {
157         struct cs_spec *spec = codec->spec;
158         return snd_hda_multi_out_analog_cleanup(codec, &spec->multiout);
159 }
160
161 /*
162  * Digital out
163  */
164 static int cs_dig_playback_pcm_open(struct hda_pcm_stream *hinfo,
165                                     struct hda_codec *codec,
166                                     struct snd_pcm_substream *substream)
167 {
168         struct cs_spec *spec = codec->spec;
169         return snd_hda_multi_out_dig_open(codec, &spec->multiout);
170 }
171
172 static int cs_dig_playback_pcm_close(struct hda_pcm_stream *hinfo,
173                                      struct hda_codec *codec,
174                                      struct snd_pcm_substream *substream)
175 {
176         struct cs_spec *spec = codec->spec;
177         return snd_hda_multi_out_dig_close(codec, &spec->multiout);
178 }
179
180 static int cs_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
181                                        struct hda_codec *codec,
182                                        unsigned int stream_tag,
183                                        unsigned int format,
184                                        struct snd_pcm_substream *substream)
185 {
186         struct cs_spec *spec = codec->spec;
187         return snd_hda_multi_out_dig_prepare(codec, &spec->multiout, stream_tag,
188                                              format, substream);
189 }
190
191 static int cs_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
192                                        struct hda_codec *codec,
193                                        struct snd_pcm_substream *substream)
194 {
195         struct cs_spec *spec = codec->spec;
196         return snd_hda_multi_out_dig_cleanup(codec, &spec->multiout);
197 }
198
199 /*
200  * Analog capture
201  */
202 static int cs_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
203                                   struct hda_codec *codec,
204                                   unsigned int stream_tag,
205                                   unsigned int format,
206                                   struct snd_pcm_substream *substream)
207 {
208         struct cs_spec *spec = codec->spec;
209         spec->cur_adc = spec->adc_nid[spec->cur_input];
210         spec->cur_adc_stream_tag = stream_tag;
211         spec->cur_adc_format = format;
212         snd_hda_codec_setup_stream(codec, spec->cur_adc, stream_tag, 0, format);
213         return 0;
214 }
215
216 static int cs_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
217                                   struct hda_codec *codec,
218                                   struct snd_pcm_substream *substream)
219 {
220         struct cs_spec *spec = codec->spec;
221         snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
222         spec->cur_adc = 0;
223         return 0;
224 }
225
226 /*
227  */
228 static struct hda_pcm_stream cs_pcm_analog_playback = {
229         .substreams = 1,
230         .channels_min = 2,
231         .channels_max = 2,
232         .ops = {
233                 .open = cs_playback_pcm_open,
234                 .prepare = cs_playback_pcm_prepare,
235                 .cleanup = cs_playback_pcm_cleanup
236         },
237 };
238
239 static struct hda_pcm_stream cs_pcm_analog_capture = {
240         .substreams = 1,
241         .channels_min = 2,
242         .channels_max = 2,
243         .ops = {
244                 .prepare = cs_capture_pcm_prepare,
245                 .cleanup = cs_capture_pcm_cleanup
246         },
247 };
248
249 static struct hda_pcm_stream cs_pcm_digital_playback = {
250         .substreams = 1,
251         .channels_min = 2,
252         .channels_max = 2,
253         .ops = {
254                 .open = cs_dig_playback_pcm_open,
255                 .close = cs_dig_playback_pcm_close,
256                 .prepare = cs_dig_playback_pcm_prepare,
257                 .cleanup = cs_dig_playback_pcm_cleanup
258         },
259 };
260
261 static struct hda_pcm_stream cs_pcm_digital_capture = {
262         .substreams = 1,
263         .channels_min = 2,
264         .channels_max = 2,
265 };
266
267 static int cs_build_pcms(struct hda_codec *codec)
268 {
269         struct cs_spec *spec = codec->spec;
270         struct hda_pcm *info = spec->pcm_rec;
271
272         codec->pcm_info = info;
273         codec->num_pcms = 0;
274
275         info->name = "Cirrus Analog";
276         info->stream[SNDRV_PCM_STREAM_PLAYBACK] = cs_pcm_analog_playback;
277         info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dac_nid[0];
278         info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
279                 spec->multiout.max_channels;
280         info->stream[SNDRV_PCM_STREAM_CAPTURE] = cs_pcm_analog_capture;
281         info->stream[SNDRV_PCM_STREAM_CAPTURE].nid =
282                 spec->adc_nid[spec->cur_input];
283         codec->num_pcms++;
284
285         if (!spec->multiout.dig_out_nid && !spec->dig_in)
286                 return 0;
287
288         info++;
289         info->name = "Cirrus Digital";
290         info->pcm_type = spec->autocfg.dig_out_type[0];
291         if (!info->pcm_type)
292                 info->pcm_type = HDA_PCM_TYPE_SPDIF;
293         if (spec->multiout.dig_out_nid) {
294                 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
295                         cs_pcm_digital_playback;
296                 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid =
297                         spec->multiout.dig_out_nid;
298         }
299         if (spec->dig_in) {
300                 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
301                         cs_pcm_digital_capture;
302                 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
303         }
304         codec->num_pcms++;
305
306         return 0;
307 }
308
309 /*
310  * parse codec topology
311  */
312
313 static hda_nid_t get_dac(struct hda_codec *codec, hda_nid_t pin)
314 {
315         hda_nid_t dac;
316         if (!pin)
317                 return 0;
318         if (snd_hda_get_connections(codec, pin, &dac, 1) != 1)
319                 return 0;
320         return dac;
321 }
322
323 static int is_ext_mic(struct hda_codec *codec, unsigned int idx)
324 {
325         struct cs_spec *spec = codec->spec;
326         struct auto_pin_cfg *cfg = &spec->autocfg;
327         hda_nid_t pin = cfg->input_pins[idx];
328         unsigned int val = snd_hda_query_pin_caps(codec, pin);
329         if (!(val & AC_PINCAP_PRES_DETECT))
330                 return 0;
331         val = snd_hda_codec_get_pincfg(codec, pin);
332         return (get_defcfg_connect(val) == AC_JACK_PORT_COMPLEX);
333 }
334
335 static hda_nid_t get_adc(struct hda_codec *codec, hda_nid_t pin,
336                          unsigned int *idxp)
337 {
338         int i;
339         hda_nid_t nid;
340
341         nid = codec->start_nid;
342         for (i = 0; i < codec->num_nodes; i++, nid++) {
343                 hda_nid_t pins[2];
344                 unsigned int type;
345                 int j, nums;
346                 type = (get_wcaps(codec, nid) & AC_WCAP_TYPE)
347                         >> AC_WCAP_TYPE_SHIFT;
348                 if (type != AC_WID_AUD_IN)
349                         continue;
350                 nums = snd_hda_get_connections(codec, nid, pins,
351                                                ARRAY_SIZE(pins));
352                 if (nums <= 0)
353                         continue;
354                 for (j = 0; j < nums; j++) {
355                         if (pins[j] == pin) {
356                                 *idxp = j;
357                                 return nid;
358                         }
359                 }
360         }
361         return 0;
362 }
363
364 static int is_active_pin(struct hda_codec *codec, hda_nid_t nid)
365 {
366         struct cs_spec *spec = codec->spec;
367         unsigned int val;
368         val = snd_hda_codec_get_pincfg(codec, nid);
369         return (get_defcfg_connect(val) != AC_JACK_PORT_NONE);
370 }
371
372 static int parse_output(struct hda_codec *codec)
373 {
374         struct cs_spec *spec = codec->spec;
375         struct auto_pin_cfg *cfg = &spec->autocfg;
376         int i, err, extra_nids;
377         hda_nid_t dac;
378
379         for (i = 0; i < cfg->line_outs; i++) {
380                 dac = get_dac(codec, cfg->line_out_pins[i]);
381                 if (!dac)
382                         break;
383                 spec->dac_nid[i] = dac;
384         }
385         spec->multiout.num_dacs = i;
386         spec->multiout.dac_nids = spec->dac_nid;
387         spec->multiout.max_channels = i * 2;
388
389         /* add HP and speakers */
390         extra_nids = 0;
391         for (i = 0; i < cfg->hp_outs; i++) {
392                 dac = get_dac(codec, cfg->hp_pins[i]);
393                 if (!dac)
394                         break;
395                 if (!i)
396                         spec->multiout.hp_nid = dac;
397                 else
398                         spec->multiout.extra_out_nid[extra_nids++] = dac;
399         }
400         for (i = 0; i < cfg->speaker_outs; i++) {
401                 dac = get_dac(codec, cfg->speaker_pins[i]);
402                 if (!dac)
403                         break;
404                 spec->multiout.extra_out_nid[extra_nids++] = dac;
405         }
406
407         if (cfg->line_out_type == AUTO_PIN_SPEAKER_OUT) {
408                 cfg->speaker_outs = cfg->line_outs;
409                 memcpy(cfg->speaker_pins, cfg->line_out_pins,
410                        sizeof(cfg->speaker_pins));
411                 cfg->line_outs = 0;
412         }
413
414         return 0;
415 }
416
417 static int parse_input(struct hda_codec *codec)
418 {
419         struct cs_spec *spec = codec->spec;
420         struct auto_pin_cfg *cfg = &spec->autocfg;
421         int i, n, err;
422
423         for (i = 0; i < AUTO_PIN_LAST; i++) {
424                 hda_nid_t pin = cfg->input_pins[i];
425                 struct snd_kcontrol *kctl;
426                 if (!pin)
427                         continue;
428                 spec->input_idx[spec->num_inputs] = i;
429                 spec->capsrc_idx[i] = spec->num_inputs++;
430                 spec->cur_input = i;
431                 spec->adc_nid[i] = get_adc(codec, pin, &spec->adc_idx[i]);
432         }
433         if (!spec->num_inputs)
434                 return 0;
435
436         /* check whether the automatic mic switch is available */
437         if (spec->num_inputs == 2 &&
438             spec->adc_nid[AUTO_PIN_MIC] && spec->adc_nid[AUTO_PIN_FRONT_MIC]) {
439                 if (is_ext_mic(codec, cfg->input_pins[AUTO_PIN_FRONT_MIC])) {
440                         if (!is_ext_mic(codec, cfg->input_pins[AUTO_PIN_MIC])) {
441                                 spec->mic_detect = 1;
442                                 spec->automic_idx = AUTO_PIN_FRONT_MIC;
443                         }
444                 } else {
445                         if (is_ext_mic(codec, cfg->input_pins[AUTO_PIN_MIC])) {
446                                 spec->mic_detect = 1;
447                                 spec->automic_idx = AUTO_PIN_MIC;
448                         }
449                 }
450         }
451         return 0;
452 }
453
454
455 static int parse_digital_output(struct hda_codec *codec)
456 {
457         struct cs_spec *spec = codec->spec;
458         struct auto_pin_cfg *cfg = &spec->autocfg;
459         hda_nid_t nid;
460         int err;
461
462         if (!cfg->dig_outs)
463                 return 0;
464         if (snd_hda_get_connections(codec, cfg->dig_out_pins[0], &nid, 1) < 1)
465                 return 0;
466         spec->multiout.dig_out_nid = nid;
467         spec->multiout.share_spdif = 1;
468         if (cfg->dig_outs > 1 &&
469             snd_hda_get_connections(codec, cfg->dig_out_pins[1], &nid, 1) > 0) {
470                 spec->slave_dig_outs[0] = nid;
471                 codec->slave_dig_outs = spec->slave_dig_outs;
472         }
473         return 0;
474 }
475
476 static int parse_digital_input(struct hda_codec *codec)
477 {
478         struct cs_spec *spec = codec->spec;
479         struct auto_pin_cfg *cfg = &spec->autocfg;
480         int idx;
481
482         if (cfg->dig_in_pin)
483                 spec->dig_in = get_adc(codec, cfg->dig_in_pin, &idx);
484         return 0;
485 }
486
487 /*
488  * create mixer controls
489  */
490
491 static const char *dir_sfx[2] = { "Playback", "Capture" };
492
493 static int add_mute(struct hda_codec *codec, const char *name, int index,
494                     unsigned int pval, int dir, struct snd_kcontrol **kctlp)
495 {
496         char tmp[32];
497         struct snd_kcontrol_new knew =
498                 HDA_CODEC_MUTE_IDX(tmp, index, 0, 0, HDA_OUTPUT);
499         knew.private_value = pval;
500         snprintf(tmp, sizeof(tmp), "%s %s Switch", name, dir_sfx[dir]);
501         *kctlp = snd_ctl_new1(&knew, codec);
502         return snd_hda_ctl_add(codec, *kctlp);
503 }
504
505 static int add_volume(struct hda_codec *codec, const char *name,
506                       int index, unsigned int pval, int dir,
507                       struct snd_kcontrol **kctlp)
508 {
509         char tmp[32];
510         struct snd_kcontrol_new knew =
511                 HDA_CODEC_VOLUME_IDX(tmp, index, 0, 0, HDA_OUTPUT);
512         knew.private_value = pval;
513         snprintf(tmp, sizeof(tmp), "%s %s Volume", name, dir_sfx[dir]);
514         *kctlp = snd_ctl_new1(&knew, codec);
515         return snd_hda_ctl_add(codec, *kctlp);
516 }
517
518 static void fix_volume_caps(struct hda_codec *codec, hda_nid_t dac)
519 {
520         unsigned int caps;
521
522         /* set the upper-limit for mixer amp to 0dB */
523         caps = query_amp_caps(codec, dac, HDA_OUTPUT);
524         caps &= ~(0x7f << AC_AMPCAP_NUM_STEPS_SHIFT);
525         caps |= ((caps >> AC_AMPCAP_OFFSET_SHIFT) & 0x7f)
526                 << AC_AMPCAP_NUM_STEPS_SHIFT;
527         snd_hda_override_amp_caps(codec, dac, HDA_OUTPUT, caps);
528 }
529
530 static int add_vmaster(struct hda_codec *codec, hda_nid_t dac)
531 {
532         struct cs_spec *spec = codec->spec;
533         unsigned int tlv[4];
534         int err;
535
536         spec->vmaster_sw =
537                 snd_ctl_make_virtual_master("Master Playback Switch", NULL);
538         err = snd_hda_ctl_add(codec, spec->vmaster_sw);
539         if (err < 0)
540                 return err;
541
542         snd_hda_set_vmaster_tlv(codec, dac, HDA_OUTPUT, tlv);
543         spec->vmaster_vol =
544                 snd_ctl_make_virtual_master("Master Playback Volume", tlv);
545         err = snd_hda_ctl_add(codec, spec->vmaster_vol);
546         if (err < 0)
547                 return err;
548         return 0;
549 }
550
551 static int add_output(struct hda_codec *codec, hda_nid_t dac, int idx,
552                       int num_ctls, int type)
553 {
554         struct cs_spec *spec = codec->spec;
555         const char *name;
556         int err, index;
557         struct snd_kcontrol *kctl;
558         static char *speakers[] = {
559                 "Front Speaker", "Surround Speaker", "Bass Speaker"
560         };
561         static char *line_outs[] = {
562                 "Front Line-Out", "Surround Line-Out", "Bass Line-Out"
563         };
564
565         fix_volume_caps(codec, dac);
566         if (!spec->vmaster_sw) {
567                 err = add_vmaster(codec, dac);
568                 if (err < 0)
569                         return err;
570         }
571
572         index = 0;
573         switch (type) {
574         case AUTO_PIN_HP_OUT:
575                 name = "Headphone";
576                 index = idx;
577                 break;
578         case AUTO_PIN_SPEAKER_OUT:
579                 if (num_ctls > 1)
580                         name = speakers[idx];
581                 else
582                         name = "Speaker";
583                 break;
584         default:
585                 if (num_ctls > 1)
586                         name = line_outs[idx];
587                 else
588                         name = "Line-Out";
589                 break;
590         }
591
592         err = add_mute(codec, name, index,
593                        HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
594         if (err < 0)
595                 return err;
596         err = snd_ctl_add_slave(spec->vmaster_sw, kctl);
597         if (err < 0)
598                 return err;
599
600         err = add_volume(codec, name, index,
601                          HDA_COMPOSE_AMP_VAL(dac, 3, 0, HDA_OUTPUT), 0, &kctl);
602         if (err < 0)
603                 return err;
604         err = snd_ctl_add_slave(spec->vmaster_vol, kctl);
605         if (err < 0)
606                 return err;
607
608         return 0;
609 }               
610
611 static int build_output(struct hda_codec *codec)
612 {
613         struct cs_spec *spec = codec->spec;
614         struct auto_pin_cfg *cfg = &spec->autocfg;
615         int i, err;
616
617         for (i = 0; i < cfg->line_outs; i++) {
618                 err = add_output(codec, get_dac(codec, cfg->line_out_pins[i]),
619                                  i, cfg->line_outs, cfg->line_out_type);
620                 if (err < 0)
621                         return err;
622         }
623         for (i = 0; i < cfg->hp_outs; i++) {
624                 err = add_output(codec, get_dac(codec, cfg->hp_pins[i]),
625                                  i, cfg->hp_outs, AUTO_PIN_HP_OUT);
626                 if (err < 0)
627                         return err;
628         }
629         for (i = 0; i < cfg->speaker_outs; i++) {
630                 err = add_output(codec, get_dac(codec, cfg->speaker_pins[i]),
631                                  i, cfg->speaker_outs, AUTO_PIN_SPEAKER_OUT);
632                 if (err < 0)
633                         return err;
634         }
635         return 0;
636 }
637
638 /*
639  */
640
641 static struct snd_kcontrol_new cs_capture_ctls[] = {
642         HDA_BIND_SW("Capture Switch", 0),
643         HDA_BIND_VOL("Capture Volume", 0),
644 };
645
646 static int change_cur_input(struct hda_codec *codec, unsigned int idx,
647                             int force)
648 {
649         struct cs_spec *spec = codec->spec;
650         struct auto_pin_cfg *cfg = &spec->autocfg;
651         
652         if (spec->cur_input == idx && !force)
653                 return 0;
654         if (spec->cur_adc && spec->cur_adc != spec->adc_nid[idx]) {
655                 /* stream is running, let's swap the current ADC */
656                 snd_hda_codec_cleanup_stream(codec, spec->cur_adc);
657                 spec->cur_adc = spec->adc_nid[idx];
658                 snd_hda_codec_setup_stream(codec, spec->cur_adc,
659                                            spec->cur_adc_stream_tag, 0,
660                                            spec->cur_adc_format);
661         }
662         snd_hda_codec_write(codec, spec->cur_adc, 0,
663                             AC_VERB_SET_CONNECT_SEL,
664                             spec->adc_idx[idx]);
665         spec->cur_input = idx;
666         return 1;
667 }
668
669 static int cs_capture_source_info(struct snd_kcontrol *kcontrol,
670                                   struct snd_ctl_elem_info *uinfo)
671 {
672         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
673         struct cs_spec *spec = codec->spec;
674         unsigned int idx;
675
676         uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
677         uinfo->count = 1;
678         uinfo->value.enumerated.items = spec->num_inputs;
679         if (uinfo->value.enumerated.item >= spec->num_inputs)
680                 uinfo->value.enumerated.item = spec->num_inputs - 1;
681         idx = spec->input_idx[uinfo->value.enumerated.item];
682         strcpy(uinfo->value.enumerated.name, auto_pin_cfg_labels[idx]);
683         return 0;
684 }
685
686 static int cs_capture_source_get(struct snd_kcontrol *kcontrol,
687                                  struct snd_ctl_elem_value *ucontrol)
688 {
689         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
690         struct cs_spec *spec = codec->spec;
691         ucontrol->value.enumerated.item[0] = spec->capsrc_idx[spec->cur_input];
692         return 0;
693 }
694
695 static int cs_capture_source_put(struct snd_kcontrol *kcontrol,
696                                  struct snd_ctl_elem_value *ucontrol)
697 {
698         struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
699         struct cs_spec *spec = codec->spec;
700         unsigned int idx = ucontrol->value.enumerated.item[0];
701
702         if (idx >= spec->num_inputs)
703                 return -EINVAL;
704         idx = spec->input_idx[idx];
705         return change_cur_input(codec, idx, 0);
706 }
707
708 static struct snd_kcontrol_new cs_capture_source = {
709         .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
710         .name = "Capture Source",
711         .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
712         .info = cs_capture_source_info,
713         .get = cs_capture_source_get,
714         .put = cs_capture_source_put,
715 };
716
717 static struct hda_bind_ctls *make_bind_capture(struct hda_codec *codec,
718                                                struct hda_ctl_ops *ops)
719 {
720         struct cs_spec *spec = codec->spec;
721         struct hda_bind_ctls *bind;
722         int i, n;
723
724         bind = kzalloc(sizeof(*bind) + sizeof(long) * (spec->num_inputs + 1),
725                        GFP_KERNEL);
726         if (!bind)
727                 return NULL;
728         bind->ops = ops;
729         n = 0;
730         for (i = 0; i < AUTO_PIN_LAST; i++) {
731                 if (!spec->adc_nid[i])
732                         continue;
733                 bind->values[n++] =
734                         HDA_COMPOSE_AMP_VAL(spec->adc_nid[i], 3,
735                                             spec->adc_idx[i], HDA_INPUT);
736         }
737         return bind;
738 }
739
740 static int build_input(struct hda_codec *codec)
741 {
742         struct cs_spec *spec = codec->spec;
743         int i, err;
744
745         if (!spec->num_inputs)
746                 return 0;
747
748         /* make bind-capture */
749         spec->capture_bind[0] = make_bind_capture(codec, &snd_hda_bind_sw);
750         spec->capture_bind[1] = make_bind_capture(codec, &snd_hda_bind_vol);
751         for (i = 0; i < 2; i++) {
752                 struct snd_kcontrol *kctl;
753                 if (!spec->capture_bind[i])
754                         return -ENOMEM;
755                 kctl = snd_ctl_new1(&cs_capture_ctls[i], codec);
756                 if (!kctl)
757                         return -ENOMEM;
758                 kctl->private_value = (long)spec->capture_bind[i];
759                 err = snd_hda_ctl_add(codec, kctl);
760                 if (err < 0)
761                         return err;
762         }
763         
764         if (spec->num_inputs > 1 && !spec->mic_detect) {
765                 err = snd_hda_ctl_add(codec,
766                                       snd_ctl_new1(&cs_capture_source, codec));
767                 if (err < 0)
768                         return err;
769         }
770
771         return 0;
772 }
773
774 /*
775  */
776
777 static int build_digital_output(struct hda_codec *codec)
778 {
779         struct cs_spec *spec = codec->spec;
780         int err;
781
782         err = snd_hda_create_spdif_out_ctls(codec, spec->multiout.dig_out_nid);
783         if (err < 0)
784                 return err;
785         err = snd_hda_create_spdif_share_sw(codec, &spec->multiout);
786         if (err < 0)
787                 return err;
788         return 0;
789 }
790
791 static int build_digital_input(struct hda_codec *codec)
792 {
793         struct cs_spec *spec = codec->spec;
794         if (spec->dig_in)
795                 return snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
796         return 0;
797 }
798
799 /*
800  * auto-mute and auto-mic switching
801  */
802
803 static void cs_automute(struct hda_codec *codec)
804 {
805         struct cs_spec *spec = codec->spec;
806         struct auto_pin_cfg *cfg = &spec->autocfg;
807         unsigned int caps, present, hp_present;
808         hda_nid_t nid;
809         int i;
810
811         hp_present = 0;
812         for (i = 0; i < cfg->hp_outs; i++) {
813                 nid = cfg->hp_pins[i];
814                 caps = snd_hda_query_pin_caps(codec, nid);
815                 if (!(caps & AC_PINCAP_PRES_DETECT))
816                         continue;
817                 if (caps & AC_PINCAP_TRIG_REQ)
818                         snd_hda_codec_read(codec, nid, 0,
819                                            AC_VERB_SET_PIN_SENSE, 0);
820                 present = snd_hda_codec_read(codec, nid, 0,
821                                              AC_VERB_GET_PIN_SENSE, 0);
822                 hp_present |= (present & AC_PINSENSE_PRESENCE) != 0;
823                 if (hp_present)
824                         break;
825         }
826         for (i = 0; i < cfg->speaker_outs; i++) {
827                 nid = cfg->speaker_pins[i];
828                 snd_hda_codec_write(codec, nid, 0,
829                                     AC_VERB_SET_PIN_WIDGET_CONTROL,
830                                     hp_present ? 0 : PIN_OUT);
831         }
832 }
833
834 static void cs_automic(struct hda_codec *codec)
835 {
836         struct cs_spec *spec = codec->spec;
837         struct auto_pin_cfg *cfg = &spec->autocfg;
838         hda_nid_t nid;
839         unsigned int caps, present;
840         
841         nid = cfg->input_pins[spec->automic_idx];
842         caps = snd_hda_query_pin_caps(codec, nid);
843         if (caps & AC_PINCAP_TRIG_REQ)
844                 snd_hda_codec_read(codec, nid, 0, AC_VERB_SET_PIN_SENSE, 0);
845         present = snd_hda_codec_read(codec, nid, 0,
846                                      AC_VERB_GET_PIN_SENSE, 0);
847         if (present & AC_PINSENSE_PRESENCE)
848                 change_cur_input(codec, spec->automic_idx, 0);
849         else {
850                 unsigned int imic = (spec->automic_idx == AUTO_PIN_MIC) ?
851                         AUTO_PIN_FRONT_MIC : AUTO_PIN_MIC;
852                 change_cur_input(codec, imic, 0);
853         }
854 }
855
856 /*
857  */
858
859 static void init_output(struct hda_codec *codec)
860 {
861         struct cs_spec *spec = codec->spec;
862         struct auto_pin_cfg *cfg = &spec->autocfg;
863         int i;
864
865         /* mute first */
866         for (i = 0; i < spec->multiout.num_dacs; i++)
867                 snd_hda_codec_write(codec, spec->multiout.dac_nids[i], 0,
868                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
869         if (spec->multiout.hp_nid)
870                 snd_hda_codec_write(codec, spec->multiout.hp_nid, 0,
871                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
872         for (i = 0; i < ARRAY_SIZE(spec->multiout.extra_out_nid); i++) {
873                 if (!spec->multiout.extra_out_nid[i])
874                         break;
875                 snd_hda_codec_write(codec, spec->multiout.extra_out_nid[i], 0,
876                                     AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_MUTE);
877         }
878
879         /* set appropriate pin controls */
880         for (i = 0; i < cfg->line_outs; i++)
881                 snd_hda_codec_write(codec, cfg->line_out_pins[i], 0,
882                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
883         for (i = 0; i < cfg->hp_outs; i++) {
884                 hda_nid_t nid = cfg->hp_pins[i];
885                 snd_hda_codec_write(codec, nid, 0,
886                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_HP);
887                 if (!cfg->speaker_outs)
888                         continue;
889                 if (get_wcaps(codec, nid) & AC_WCAP_UNSOL_CAP) {
890                         snd_hda_codec_write(codec, nid, 0,
891                                             AC_VERB_SET_UNSOLICITED_ENABLE,
892                                             AC_USRSP_EN | HP_EVENT);
893                         spec->hp_detect = 1;
894                 }
895         }
896         for (i = 0; i < cfg->speaker_outs; i++)
897                 snd_hda_codec_write(codec, cfg->speaker_pins[i], 0,
898                                     AC_VERB_SET_PIN_WIDGET_CONTROL, PIN_OUT);
899         if (spec->hp_detect)
900                 cs_automute(codec);
901 }
902
903 static void init_input(struct hda_codec *codec)
904 {
905         struct cs_spec *spec = codec->spec;
906         struct auto_pin_cfg *cfg = &spec->autocfg;
907         unsigned int coef;
908         int i;
909
910         for (i = 0; i < AUTO_PIN_LAST; i++) {
911                 unsigned int ctl;
912                 hda_nid_t pin = cfg->input_pins[i];
913                 if (!pin || !spec->adc_nid[i])
914                         continue;
915                 /* set appropriate pin control and mute first */
916                 ctl = PIN_IN;
917                 if (i <= AUTO_PIN_FRONT_MIC) {
918                         unsigned int caps = snd_hda_query_pin_caps(codec, pin);
919                         caps >>= AC_PINCAP_VREF_SHIFT;
920                         if (caps & AC_PINCAP_VREF_80)
921                                 ctl = PIN_VREF80;
922                 }
923                 snd_hda_codec_write(codec, pin, 0,
924                                     AC_VERB_SET_PIN_WIDGET_CONTROL, ctl);
925                 snd_hda_codec_write(codec, spec->adc_nid[i], 0,
926                                     AC_VERB_SET_AMP_GAIN_MUTE,
927                                     AMP_IN_MUTE(spec->adc_idx[i]));
928                 if (spec->mic_detect && spec->automic_idx == i)
929                         snd_hda_codec_write(codec, pin, 0,
930                                             AC_VERB_SET_UNSOLICITED_ENABLE,
931                                             AC_USRSP_EN | MIC_EVENT);
932         }
933         change_cur_input(codec, spec->cur_input, 1);
934         if (spec->mic_detect)
935                 cs_automic(codec);
936
937         coef = 0x000a; /* ADC1/2 - Digital and Analog Soft Ramp */
938         if (is_active_pin(codec, CS_DMIC2_PIN_NID))
939                 coef |= 0x0500; /* DMIC2 enable 2 channels, disable GPIO1 */
940         if (is_active_pin(codec, CS_DMIC1_PIN_NID))
941                 coef |= 0x1800; /* DMIC1 enable 2 channels, disable GPIO0 
942                                  * No effect if SPDIF_OUT2 is slected in 
943                                  * IDX_SPDIF_CTL.
944                                   */
945         cs_vendor_coef_set(codec, IDX_ADC_CFG, coef);
946 }
947
948 static struct hda_verb cs_coef_init_verbs[] = {
949         {0x11, AC_VERB_SET_PROC_STATE, 1},
950         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
951         {0x11, AC_VERB_SET_PROC_COEF,
952          (0x002a /* DAC1/2/3 SZCMode Soft Ramp */
953           | 0x0040 /* Mute DACs on FIFO error */
954           | 0x1000 /* Enable DACs High Pass Filter */
955           | 0x0400 /* Disable Coefficient Auto increment */
956           )},
957         /* Beep */
958         {0x11, AC_VERB_SET_COEF_INDEX, IDX_DAC_CFG},
959         {0x11, AC_VERB_SET_PROC_COEF, 0x0007}, /* Enable Beep thru DAC1/2/3 */
960
961         {} /* terminator */
962 };
963
964 /* SPDIF setup */
965 static void init_digital(struct hda_codec *codec)
966 {
967         unsigned int coef;
968
969         coef = 0x0002; /* SRC_MUTE soft-mute on SPDIF (if no lock) */
970         coef |= 0x0008; /* Replace with mute on error */
971         if (is_active_pin(codec, CS_DIG_OUT2_PIN_NID))
972                 coef |= 0x4000; /* RX to TX1 or TX2 Loopthru / SPDIF2
973                                  * SPDIF_OUT2 is shared with GPIO1 and
974                                  * DMIC_SDA2.
975                                  */
976         cs_vendor_coef_set(codec, IDX_SPDIF_CTL, coef);
977 }
978
979 static int cs_init(struct hda_codec *codec)
980 {
981         struct cs_spec *spec = codec->spec;
982
983         snd_hda_sequence_write(codec, cs_coef_init_verbs);
984         init_output(codec);
985         init_input(codec);
986         init_digital(codec);
987         return 0;
988 }
989
990 static int cs_build_controls(struct hda_codec *codec)
991 {
992         struct cs_spec *spec = codec->spec;
993         int err;
994
995         err = build_output(codec);
996         if (err < 0)
997                 return err;
998         err = build_input(codec);
999         if (err < 0)
1000                 return err;
1001         err = build_digital_output(codec);
1002         if (err < 0)
1003                 return err;
1004         err = build_digital_input(codec);
1005         if (err < 0)
1006                 return err;
1007         return cs_init(codec);
1008 }
1009
1010 static void cs_free(struct hda_codec *codec)
1011 {
1012         struct cs_spec *spec = codec->spec;
1013         kfree(spec->capture_bind[0]);
1014         kfree(spec->capture_bind[1]);
1015         kfree(codec->spec);
1016 }
1017
1018 static void cs_unsol_event(struct hda_codec *codec, unsigned int res)
1019 {
1020         switch ((res >> 26) & 0x7f) {
1021         case HP_EVENT:
1022                 cs_automute(codec);
1023                 break;
1024         case MIC_EVENT:
1025                 cs_automic(codec);
1026                 break;
1027         }
1028 }
1029
1030 static struct hda_codec_ops cs_patch_ops = {
1031         .build_controls = cs_build_controls,
1032         .build_pcms = cs_build_pcms,
1033         .init = cs_init,
1034         .free = cs_free,
1035         .unsol_event = cs_unsol_event,
1036 };
1037
1038 static int cs_parse_auto_config(struct hda_codec *codec)
1039 {
1040         struct cs_spec *spec = codec->spec;
1041         int err;
1042
1043         err = snd_hda_parse_pin_def_config(codec, &spec->autocfg, NULL);
1044         if (err < 0)
1045                 return err;
1046         return 0;
1047 }
1048
1049 static const char *cs420x_models[CS420X_MODELS] = {
1050         [CS420X_MBP55] = "mbp55",
1051         [CS420X_AUTO] = "auto",
1052 };
1053
1054
1055 static struct snd_pci_quirk cs420x_cfg_tbl[] = {
1056         SND_PCI_QUIRK(0x10de, 0xcb79, "MacBookPro 5,5", CS420X_MBP55),
1057         {} /* terminator */
1058 };
1059
1060 struct cs_pincfg {
1061         hda_nid_t nid;
1062         u32 val;
1063 };
1064
1065 static struct cs_pincfg mbp55_pincfgs[] = {
1066         { 0x09, 0x012b4030 },
1067         { 0x0a, 0x90100121 },
1068         { 0x0b, 0x90100120 },
1069         { 0x0c, 0x400000f0 },
1070         { 0x0d, 0x90a00110 },
1071         { 0x0e, 0x400000f0 },
1072         { 0x0f, 0x400000f0 },
1073         { 0x10, 0x014be040 },
1074         { 0x12, 0x400000f0 },
1075         { 0x15, 0x400000f0 },
1076         {} /* terminator */
1077 };
1078
1079 static struct cs_pincfg *cs_pincfgs[CS420X_MODELS] = {
1080         [CS420X_MBP55] = mbp55_pincfgs,
1081 };
1082
1083 static void fix_pincfg(struct hda_codec *codec, int model)
1084 {
1085         const struct cs_pincfg *cfg = cs_pincfgs[model];
1086         if (!cfg)
1087                 return;
1088         for (; cfg->nid; cfg++)
1089                 snd_hda_codec_set_pincfg(codec, cfg->nid, cfg->val);
1090 }
1091
1092
1093 static int patch_cs420x(struct hda_codec *codec)
1094 {
1095         struct cs_spec *spec;
1096         int err;
1097
1098         spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1099         if (!spec)
1100                 return -ENOMEM;
1101         codec->spec = spec;
1102
1103         spec->board_config =
1104                 snd_hda_check_board_config(codec, CS420X_MODELS,
1105                                            cs420x_models, cs420x_cfg_tbl);
1106         if (spec->board_config >= 0)
1107                 fix_pincfg(codec, spec->board_config);
1108
1109         err = cs_parse_auto_config(codec);
1110         if (err < 0)
1111                 goto error;
1112
1113         err = parse_output(codec);
1114         if (err < 0)
1115                 goto error;
1116         err = parse_input(codec);
1117         if (err < 0)
1118                 goto error;
1119         err = parse_digital_output(codec);
1120         if (err < 0)
1121                 goto error;
1122         err = parse_digital_input(codec);
1123         if (err < 0)
1124                 goto error;
1125
1126         codec->patch_ops = cs_patch_ops;
1127
1128         return 0;
1129
1130  error:
1131         kfree(codec->spec);
1132         codec->spec = NULL;
1133         return err;
1134 }
1135
1136
1137 /*
1138  * patch entries
1139  */
1140 static struct hda_codec_preset snd_hda_preset_cirrus[] = {
1141         { .id = 0x10134206, .name = "CS4206", .patch = patch_cs420x },
1142         { .id = 0x10134207, .name = "CS4207", .patch = patch_cs420x },
1143         {} /* terminator */
1144 };
1145
1146 MODULE_ALIAS("snd-hda-codec-id:10134206");
1147 MODULE_ALIAS("snd-hda-codec-id:10134207");
1148
1149 MODULE_LICENSE("GPL");
1150 MODULE_DESCRIPTION("Cirrus Logic HD-audio codec");
1151
1152 static struct hda_codec_preset_list cirrus_list = {
1153         .preset = snd_hda_preset_cirrus,
1154         .owner = THIS_MODULE,
1155 };
1156
1157 static int __init patch_cirrus_init(void)
1158 {
1159         return snd_hda_add_codec_preset(&cirrus_list);
1160 }
1161
1162 static void __exit patch_cirrus_exit(void)
1163 {
1164         snd_hda_delete_codec_preset(&cirrus_list);
1165 }
1166
1167 module_init(patch_cirrus_init)
1168 module_exit(patch_cirrus_exit)