projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
ALSA: hda - Move up the fixup helper functions to the library module
[linux-2.6-block.git] / sound / pci / hda / patch_ca0132.c
CommitLineData
95c6e9cb
IM		 1/*
2 * HD audio interface patch for Creative CA0132 chip
3 *
4 * Copyright (c) 2011, Creative Technology Ltd.
5 *
6 * Based on patch_ca0110.c
7 * Copyright (c) 2008 Takashi Iwai <tiwai@suse.de>
8 *
9 * This driver is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This driver is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23
24#include <linux/init.h>
25#include <linux/delay.h>
26#include <linux/slab.h>
27#include <linux/pci.h>
28#include <linux/mutex.h>
da155d5b 29#include <linux/module.h>
95c6e9cb
IM		 30#include <sound/core.h>
31#include "hda_codec.h"
32#include "hda_local.h"
33
34#define WIDGET_CHIP_CTRL 0x15
35#define WIDGET_DSP_CTRL 0x16
36
37#define WUH_MEM_CONNID 10
38#define DSP_MEM_CONNID 16
39
40enum hda_cmd_vendor_io {
41 /* for DspIO node */
42 VENDOR_DSPIO_SCP_WRITE_DATA_LOW = 0x000,
43 VENDOR_DSPIO_SCP_WRITE_DATA_HIGH = 0x100,
44
45 VENDOR_DSPIO_STATUS = 0xF01,
46 VENDOR_DSPIO_SCP_POST_READ_DATA = 0x702,
47 VENDOR_DSPIO_SCP_READ_DATA = 0xF02,
48 VENDOR_DSPIO_DSP_INIT = 0x703,
49 VENDOR_DSPIO_SCP_POST_COUNT_QUERY = 0x704,
50 VENDOR_DSPIO_SCP_READ_COUNT = 0xF04,
51
52 /* for ChipIO node */
53 VENDOR_CHIPIO_ADDRESS_LOW = 0x000,
54 VENDOR_CHIPIO_ADDRESS_HIGH = 0x100,
55 VENDOR_CHIPIO_STREAM_FORMAT = 0x200,
56 VENDOR_CHIPIO_DATA_LOW = 0x300,
57 VENDOR_CHIPIO_DATA_HIGH = 0x400,
58
59 VENDOR_CHIPIO_GET_PARAMETER = 0xF00,
60 VENDOR_CHIPIO_STATUS = 0xF01,
61 VENDOR_CHIPIO_HIC_POST_READ = 0x702,
62 VENDOR_CHIPIO_HIC_READ_DATA = 0xF03,
63
64 VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE = 0x70A,
65
66 VENDOR_CHIPIO_PLL_PMU_WRITE = 0x70C,
67 VENDOR_CHIPIO_PLL_PMU_READ = 0xF0C,
68 VENDOR_CHIPIO_8051_ADDRESS_LOW = 0x70D,
69 VENDOR_CHIPIO_8051_ADDRESS_HIGH = 0x70E,
70 VENDOR_CHIPIO_FLAG_SET = 0x70F,
71 VENDOR_CHIPIO_FLAGS_GET = 0xF0F,
72 VENDOR_CHIPIO_PARAMETER_SET = 0x710,
73 VENDOR_CHIPIO_PARAMETER_GET = 0xF10,
74
75 VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET = 0x711,
76 VENDOR_CHIPIO_PORT_ALLOC_SET = 0x712,
77 VENDOR_CHIPIO_PORT_ALLOC_GET = 0xF12,
78 VENDOR_CHIPIO_PORT_FREE_SET = 0x713,
79
80 VENDOR_CHIPIO_PARAMETER_EX_ID_GET = 0xF17,
81 VENDOR_CHIPIO_PARAMETER_EX_ID_SET = 0x717,
82 VENDOR_CHIPIO_PARAMETER_EX_VALUE_GET = 0xF18,
83 VENDOR_CHIPIO_PARAMETER_EX_VALUE_SET = 0x718
84};
85
86/*
87 * Control flag IDs
88 */
89enum control_flag_id {
90 /* Connection manager stream setup is bypassed/enabled */
91 CONTROL_FLAG_C_MGR = 0,
92 /* DSP DMA is bypassed/enabled */
93 CONTROL_FLAG_DMA = 1,
94 /* 8051 'idle' mode is disabled/enabled */
95 CONTROL_FLAG_IDLE_ENABLE = 2,
96 /* Tracker for the SPDIF-in path is bypassed/enabled */
97 CONTROL_FLAG_TRACKER = 3,
98 /* DigitalOut to Spdif2Out connection is disabled/enabled */
99 CONTROL_FLAG_SPDIF2OUT = 4,
100 /* Digital Microphone is disabled/enabled */
101 CONTROL_FLAG_DMIC = 5,
102 /* ADC_B rate is 48 kHz/96 kHz */
103 CONTROL_FLAG_ADC_B_96KHZ = 6,
104 /* ADC_C rate is 48 kHz/96 kHz */
105 CONTROL_FLAG_ADC_C_96KHZ = 7,
106 /* DAC rate is 48 kHz/96 kHz (affects all DACs) */
107 CONTROL_FLAG_DAC_96KHZ = 8,
108 /* DSP rate is 48 kHz/96 kHz */
109 CONTROL_FLAG_DSP_96KHZ = 9,
110 /* SRC clock is 98 MHz/196 MHz (196 MHz forces rate to 96 KHz) */
111 CONTROL_FLAG_SRC_CLOCK_196MHZ = 10,
112 /* SRC rate is 48 kHz/96 kHz (48 kHz disabled when clock is 196 MHz) */
113 CONTROL_FLAG_SRC_RATE_96KHZ = 11,
114 /* Decode Loop (DSP->SRC->DSP) is disabled/enabled */
115 CONTROL_FLAG_DECODE_LOOP = 12,
116 /* De-emphasis filter on DAC-1 disabled/enabled */
117 CONTROL_FLAG_DAC1_DEEMPHASIS = 13,
118 /* De-emphasis filter on DAC-2 disabled/enabled */
119 CONTROL_FLAG_DAC2_DEEMPHASIS = 14,
120 /* De-emphasis filter on DAC-3 disabled/enabled */
121 CONTROL_FLAG_DAC3_DEEMPHASIS = 15,
122 /* High-pass filter on ADC_B disabled/enabled */
123 CONTROL_FLAG_ADC_B_HIGH_PASS = 16,
124 /* High-pass filter on ADC_C disabled/enabled */
125 CONTROL_FLAG_ADC_C_HIGH_PASS = 17,
126 /* Common mode on Port_A disabled/enabled */
127 CONTROL_FLAG_PORT_A_COMMON_MODE = 18,
128 /* Common mode on Port_D disabled/enabled */
129 CONTROL_FLAG_PORT_D_COMMON_MODE = 19,
130 /* Impedance for ramp generator on Port_A 16 Ohm/10K Ohm */
131 CONTROL_FLAG_PORT_A_10KOHM_LOAD = 20,
132 /* Impedance for ramp generator on Port_D, 16 Ohm/10K Ohm */
133 CONTROL_FLAG_PORT_D_10K0HM_LOAD = 21,
134 /* ASI rate is 48kHz/96kHz */
135 CONTROL_FLAG_ASI_96KHZ = 22,
136 /* DAC power settings able to control attached ports no/yes */
137 CONTROL_FLAG_DACS_CONTROL_PORTS = 23,
138 /* Clock Stop OK reporting is disabled/enabled */
139 CONTROL_FLAG_CONTROL_STOP_OK_ENABLE = 24,
140 /* Number of control flags */
141 CONTROL_FLAGS_MAX = (CONTROL_FLAG_CONTROL_STOP_OK_ENABLE+1)
142};
143
144/*
145 * Control parameter IDs
146 */
147enum control_parameter_id {
148 /* 0: force HDA, 1: allow DSP if HDA Spdif1Out stream is idle */
149 CONTROL_PARAM_SPDIF1_SOURCE = 2,
150
151 /* Stream Control */
152
153 /* Select stream with the given ID */
154 CONTROL_PARAM_STREAM_ID = 24,
155 /* Source connection point for the selected stream */
156 CONTROL_PARAM_STREAM_SOURCE_CONN_POINT = 25,
157 /* Destination connection point for the selected stream */
158 CONTROL_PARAM_STREAM_DEST_CONN_POINT = 26,
159 /* Number of audio channels in the selected stream */
160 CONTROL_PARAM_STREAMS_CHANNELS = 27,
161 /*Enable control for the selected stream */
162 CONTROL_PARAM_STREAM_CONTROL = 28,
163
164 /* Connection Point Control */
165
166 /* Select connection point with the given ID */
167 CONTROL_PARAM_CONN_POINT_ID = 29,
168 /* Connection point sample rate */
169 CONTROL_PARAM_CONN_POINT_SAMPLE_RATE = 30,
170
171 /* Node Control */
172
173 /* Select HDA node with the given ID */
174 CONTROL_PARAM_NODE_ID = 31
175};
176
177/*
178 * Dsp Io Status codes
179 */
180enum hda_vendor_status_dspio {
181 /* Success */
182 VENDOR_STATUS_DSPIO_OK = 0x00,
183 /* Busy, unable to accept new command, the host must retry */
184 VENDOR_STATUS_DSPIO_BUSY = 0x01,
185 /* SCP command queue is full */
186 VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL = 0x02,
187 /* SCP response queue is empty */
188 VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY = 0x03
189};
190
191/*
192 * Chip Io Status codes
193 */
194enum hda_vendor_status_chipio {
195 /* Success */
196 VENDOR_STATUS_CHIPIO_OK = 0x00,
197 /* Busy, unable to accept new command, the host must retry */
198 VENDOR_STATUS_CHIPIO_BUSY = 0x01
199};
200
201/*
202 * CA0132 sample rate
203 */
204enum ca0132_sample_rate {
205 SR_6_000 = 0x00,
206 SR_8_000 = 0x01,
207 SR_9_600 = 0x02,
208 SR_11_025 = 0x03,
209 SR_16_000 = 0x04,
210 SR_22_050 = 0x05,
211 SR_24_000 = 0x06,
212 SR_32_000 = 0x07,
213 SR_44_100 = 0x08,
214 SR_48_000 = 0x09,
215 SR_88_200 = 0x0A,
216 SR_96_000 = 0x0B,
217 SR_144_000 = 0x0C,
218 SR_176_400 = 0x0D,
219 SR_192_000 = 0x0E,
220 SR_384_000 = 0x0F,
221
222 SR_COUNT = 0x10,
223
224 SR_RATE_UNKNOWN = 0x1F
225};
226
227/*
228 * Scp Helper function
229 */
230enum get_set {
231 IS_SET = 0,
232 IS_GET = 1,
233};
234
235/*
236 * Duplicated from ca0110 codec
237 */
238
239static void init_output(struct hda_codec *codec, hda_nid_t pin, hda_nid_t dac)
240{
241 if (pin) {
cdd03ced 242 snd_hda_set_pin_ctl(codec, pin, PIN_HP);
95c6e9cb
IM		 243 if (get_wcaps(codec, pin) & AC_WCAP_OUT_AMP)
244 snd_hda_codec_write(codec, pin, 0,
245 AC_VERB_SET_AMP_GAIN_MUTE,
246 AMP_OUT_UNMUTE);
247 }
248 if (dac)
249 snd_hda_codec_write(codec, dac, 0,
250 AC_VERB_SET_AMP_GAIN_MUTE, AMP_OUT_ZERO);
251}
252
253static void init_input(struct hda_codec *codec, hda_nid_t pin, hda_nid_t adc)
254{
255 if (pin) {
4740860b
TI		 256 snd_hda_set_pin_ctl(codec, pin, PIN_IN |
257 snd_hda_get_default_vref(codec, pin));
95c6e9cb
IM		 258 if (get_wcaps(codec, pin) & AC_WCAP_IN_AMP)
259 snd_hda_codec_write(codec, pin, 0,
260 AC_VERB_SET_AMP_GAIN_MUTE,
261 AMP_IN_UNMUTE(0));
262 }
263 if (adc)
264 snd_hda_codec_write(codec, adc, 0, AC_VERB_SET_AMP_GAIN_MUTE,
265 AMP_IN_UNMUTE(0));
266}
267
268static char *dirstr[2] = { "Playback", "Capture" };
269
270static int _add_switch(struct hda_codec *codec, hda_nid_t nid, const char *pfx,
271 int chan, int dir)
272{
273 char namestr[44];
274 int type = dir ? HDA_INPUT : HDA_OUTPUT;
275 struct snd_kcontrol_new knew =
276 HDA_CODEC_MUTE_MONO(namestr, nid, chan, 0, type);
277 sprintf(namestr, "%s %s Switch", pfx, dirstr[dir]);
278 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
279}
280
281static int _add_volume(struct hda_codec *codec, hda_nid_t nid, const char *pfx,
282 int chan, int dir)
283{
284 char namestr[44];
285 int type = dir ? HDA_INPUT : HDA_OUTPUT;
286 struct snd_kcontrol_new knew =
287 HDA_CODEC_VOLUME_MONO(namestr, nid, chan, 0, type);
288 sprintf(namestr, "%s %s Volume", pfx, dirstr[dir]);
289 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
290}
291
292#define add_out_switch(codec, nid, pfx) _add_switch(codec, nid, pfx, 3, 0)
293#define add_out_volume(codec, nid, pfx) _add_volume(codec, nid, pfx, 3, 0)
294#define add_in_switch(codec, nid, pfx) _add_switch(codec, nid, pfx, 3, 1)
295#define add_in_volume(codec, nid, pfx) _add_volume(codec, nid, pfx, 3, 1)
296#define add_mono_switch(codec, nid, pfx, chan) \
297 _add_switch(codec, nid, pfx, chan, 0)
298#define add_mono_volume(codec, nid, pfx, chan) \
299 _add_volume(codec, nid, pfx, chan, 0)
300#define add_in_mono_switch(codec, nid, pfx, chan) \
301 _add_switch(codec, nid, pfx, chan, 1)
302#define add_in_mono_volume(codec, nid, pfx, chan) \
303 _add_volume(codec, nid, pfx, chan, 1)
304
305
306/*
307 * CA0132 specific
308 */
309
310struct ca0132_spec {
311 struct auto_pin_cfg autocfg;
312 struct hda_multi_out multiout;
313 hda_nid_t out_pins[AUTO_CFG_MAX_OUTS];
314 hda_nid_t dacs[AUTO_CFG_MAX_OUTS];
315 hda_nid_t hp_dac;
316 hda_nid_t input_pins[AUTO_PIN_LAST];
317 hda_nid_t adcs[AUTO_PIN_LAST];
318 hda_nid_t dig_out;
319 hda_nid_t dig_in;
320 unsigned int num_inputs;
321 long curr_hp_switch;
322 long curr_hp_volume[2];
323 long curr_speaker_switch;
324 struct mutex chipio_mutex;
325 const char *input_labels[AUTO_PIN_LAST];
326 struct hda_pcm pcm_rec[2]; /* PCM information */
327};
328
329/* Chip access helper function */
330static int chipio_send(struct hda_codec *codec,
331 unsigned int reg,
332 unsigned int data)
333{
334 unsigned int res;
335 int retry = 50;
336
337 /* send bits of data specified by reg */
338 do {
339 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
340 reg, data);
341 if (res == VENDOR_STATUS_CHIPIO_OK)
342 return 0;
343 } while (--retry);
344 return -EIO;
345}
346
347/*
348 * Write chip address through the vendor widget -- NOT protected by the Mutex!
349 */
350static int chipio_write_address(struct hda_codec *codec,
351 unsigned int chip_addx)
352{
353 int res;
354
355 /* send low 16 bits of the address */
356 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_LOW,
357 chip_addx & 0xffff);
358
359 if (res != -EIO) {
360 /* send high 16 bits of the address */
361 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_HIGH,
362 chip_addx >> 16);
363 }
364
365 return res;
366}
367
368/*
369 * Write data through the vendor widget -- NOT protected by the Mutex!
370 */
371
372static int chipio_write_data(struct hda_codec *codec, unsigned int data)
373{
374 int res;
375
376 /* send low 16 bits of the data */
377 res = chipio_send(codec, VENDOR_CHIPIO_DATA_LOW, data & 0xffff);
378
379 if (res != -EIO) {
380 /* send high 16 bits of the data */
381 res = chipio_send(codec, VENDOR_CHIPIO_DATA_HIGH,
382 data >> 16);
383 }
384
385 return res;
386}
387
388/*
389 * Read data through the vendor widget -- NOT protected by the Mutex!
390 */
391static int chipio_read_data(struct hda_codec *codec, unsigned int *data)
392{
393 int res;
394
395 /* post read */
396 res = chipio_send(codec, VENDOR_CHIPIO_HIC_POST_READ, 0);
397
398 if (res != -EIO) {
399 /* read status */
400 res = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
401 }
402
403 if (res != -EIO) {
404 /* read data */
405 *data = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
406 VENDOR_CHIPIO_HIC_READ_DATA,
407 0);
408 }
409
410 return res;
411}
412
413/*
414 * Write given value to the given address through the chip I/O widget.
415 * protected by the Mutex
416 */
417static int chipio_write(struct hda_codec *codec,
418 unsigned int chip_addx, const unsigned int data)
419{
420 struct ca0132_spec *spec = codec->spec;
421 int err;
422
423 mutex_lock(&spec->chipio_mutex);
424
425 /* write the address, and if successful proceed to write data */
426 err = chipio_write_address(codec, chip_addx);
427 if (err < 0)
428 goto exit;
429
430 err = chipio_write_data(codec, data);
431 if (err < 0)
432 goto exit;
433
434exit:
435 mutex_unlock(&spec->chipio_mutex);
436 return err;
437}
438
439/*
440 * Read the given address through the chip I/O widget
441 * protected by the Mutex
442 */
443static int chipio_read(struct hda_codec *codec,
444 unsigned int chip_addx, unsigned int *data)
445{
446 struct ca0132_spec *spec = codec->spec;
447 int err;
448
449 mutex_lock(&spec->chipio_mutex);
450
451 /* write the address, and if successful proceed to write data */
452 err = chipio_write_address(codec, chip_addx);
453 if (err < 0)
454 goto exit;
455
456 err = chipio_read_data(codec, data);
457 if (err < 0)
458 goto exit;
459
460exit:
461 mutex_unlock(&spec->chipio_mutex);
462 return err;
463}
464
465/*
466 * PCM stuffs
467 */
468static void ca0132_setup_stream(struct hda_codec *codec, hda_nid_t nid,
469 u32 stream_tag,
470 int channel_id, int format)
471{
472 unsigned int oldval, newval;
473
474 if (!nid)
475 return;
476
477 snd_printdd("ca0132_setup_stream: "
478 "NID=0x%x, stream=0x%x, channel=%d, format=0x%x\n",
479 nid, stream_tag, channel_id, format);
480
481 /* update the format-id if changed */
482 oldval = snd_hda_codec_read(codec, nid, 0,
483 AC_VERB_GET_STREAM_FORMAT,
484 0);
485 if (oldval != format) {
486 msleep(20);
487 snd_hda_codec_write(codec, nid, 0,
488 AC_VERB_SET_STREAM_FORMAT,
489 format);
490 }
491
492 oldval = snd_hda_codec_read(codec, nid, 0, AC_VERB_GET_CONV, 0);
493 newval = (stream_tag << 4) | channel_id;
494 if (oldval != newval) {
495 snd_hda_codec_write(codec, nid, 0,
496 AC_VERB_SET_CHANNEL_STREAMID,
497 newval);
498 }
499}
500
501static void ca0132_cleanup_stream(struct hda_codec *codec, hda_nid_t nid)
502{
503 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_STREAM_FORMAT, 0);
504 snd_hda_codec_write(codec, nid, 0, AC_VERB_SET_CHANNEL_STREAMID, 0);
505}
506
507/*
508 * PCM callbacks
509 */
510static int ca0132_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
511 struct hda_codec *codec,
512 unsigned int stream_tag,
513 unsigned int format,
514 struct snd_pcm_substream *substream)
515{
516 struct ca0132_spec *spec = codec->spec;
517
518 ca0132_setup_stream(codec, spec->dacs[0], stream_tag, 0, format);
519
520 return 0;
521}
522
523static int ca0132_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
524 struct hda_codec *codec,
525 struct snd_pcm_substream *substream)
526{
527 struct ca0132_spec *spec = codec->spec;
528
529 ca0132_cleanup_stream(codec, spec->dacs[0]);
530
531 return 0;
532}
533
534/*
535 * Digital out
536 */
537static int ca0132_dig_playback_pcm_prepare(struct hda_pcm_stream *hinfo,
538 struct hda_codec *codec,
539 unsigned int stream_tag,
540 unsigned int format,
541 struct snd_pcm_substream *substream)
542{
543 struct ca0132_spec *spec = codec->spec;
544
545 ca0132_setup_stream(codec, spec->dig_out, stream_tag, 0, format);
546
547 return 0;
548}
549
550static int ca0132_dig_playback_pcm_cleanup(struct hda_pcm_stream *hinfo,
551 struct hda_codec *codec,
552 struct snd_pcm_substream *substream)
553{
554 struct ca0132_spec *spec = codec->spec;
555
556 ca0132_cleanup_stream(codec, spec->dig_out);
557
558 return 0;
559}
560
561/*
562 * Analog capture
563 */
564static int ca0132_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
565 struct hda_codec *codec,
566 unsigned int stream_tag,
567 unsigned int format,
568 struct snd_pcm_substream *substream)
569{
570 struct ca0132_spec *spec = codec->spec;
571
572 ca0132_setup_stream(codec, spec->adcs[substream->number],
573 stream_tag, 0, format);
574
575 return 0;
576}
577
578static int ca0132_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
579 struct hda_codec *codec,
580 struct snd_pcm_substream *substream)
581{
582 struct ca0132_spec *spec = codec->spec;
583
584 ca0132_cleanup_stream(codec, spec->adcs[substream->number]);
585
586 return 0;
587}
588
589/*
590 * Digital capture
591 */
592static int ca0132_dig_capture_pcm_prepare(struct hda_pcm_stream *hinfo,
593 struct hda_codec *codec,
594 unsigned int stream_tag,
595 unsigned int format,
596 struct snd_pcm_substream *substream)
597{
598 struct ca0132_spec *spec = codec->spec;
599
600 ca0132_setup_stream(codec, spec->dig_in, stream_tag, 0, format);
601
602 return 0;
603}
604
605static int ca0132_dig_capture_pcm_cleanup(struct hda_pcm_stream *hinfo,
606 struct hda_codec *codec,
607 struct snd_pcm_substream *substream)
608{
609 struct ca0132_spec *spec = codec->spec;
610
611 ca0132_cleanup_stream(codec, spec->dig_in);
612
613 return 0;
614}
615
616/*
617 */
618static struct hda_pcm_stream ca0132_pcm_analog_playback = {
619 .substreams = 1,
620 .channels_min = 2,
621 .channels_max = 2,
622 .ops = {
623 .prepare = ca0132_playback_pcm_prepare,
624 .cleanup = ca0132_playback_pcm_cleanup
625 },
626};
627
628static struct hda_pcm_stream ca0132_pcm_analog_capture = {
629 .substreams = 1,
630 .channels_min = 2,
631 .channels_max = 2,
632 .ops = {
633 .prepare = ca0132_capture_pcm_prepare,
634 .cleanup = ca0132_capture_pcm_cleanup
635 },
636};
637
638static struct hda_pcm_stream ca0132_pcm_digital_playback = {
639 .substreams = 1,
640 .channels_min = 2,
641 .channels_max = 2,
642 .ops = {
643 .prepare = ca0132_dig_playback_pcm_prepare,
644 .cleanup = ca0132_dig_playback_pcm_cleanup
645 },
646};
647
648static struct hda_pcm_stream ca0132_pcm_digital_capture = {
649 .substreams = 1,
650 .channels_min = 2,
651 .channels_max = 2,
652 .ops = {
653 .prepare = ca0132_dig_capture_pcm_prepare,
654 .cleanup = ca0132_dig_capture_pcm_cleanup
655 },
656};
657
658static int ca0132_build_pcms(struct hda_codec *codec)
659{
660 struct ca0132_spec *spec = codec->spec;
661 struct hda_pcm *info = spec->pcm_rec;
662
663 codec->pcm_info = info;
664 codec->num_pcms = 0;
665
666 info->name = "CA0132 Analog";
667 info->stream[SNDRV_PCM_STREAM_PLAYBACK] = ca0132_pcm_analog_playback;
668 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dacs[0];
669 info->stream[SNDRV_PCM_STREAM_PLAYBACK].channels_max =
670 spec->multiout.max_channels;
671 info->stream[SNDRV_PCM_STREAM_CAPTURE] = ca0132_pcm_analog_capture;
672 info->stream[SNDRV_PCM_STREAM_CAPTURE].substreams = spec->num_inputs;
673 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->adcs[0];
674 codec->num_pcms++;
675
676 if (!spec->dig_out && !spec->dig_in)
677 return 0;
678
679 info++;
680 info->name = "CA0132 Digital";
681 info->pcm_type = HDA_PCM_TYPE_SPDIF;
682 if (spec->dig_out) {
683 info->stream[SNDRV_PCM_STREAM_PLAYBACK] =
684 ca0132_pcm_digital_playback;
685 info->stream[SNDRV_PCM_STREAM_PLAYBACK].nid = spec->dig_out;
686 }
687 if (spec->dig_in) {
688 info->stream[SNDRV_PCM_STREAM_CAPTURE] =
689 ca0132_pcm_digital_capture;
690 info->stream[SNDRV_PCM_STREAM_CAPTURE].nid = spec->dig_in;
691 }
692 codec->num_pcms++;
693
694 return 0;
695}
696
697#define REG_CODEC_MUTE 0x18b014
698#define REG_CODEC_HP_VOL_L 0x18b070
699#define REG_CODEC_HP_VOL_R 0x18b074
700
701static int ca0132_hp_switch_get(struct snd_kcontrol *kcontrol,
702 struct snd_ctl_elem_value *ucontrol)
703{
704 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
705 struct ca0132_spec *spec = codec->spec;
706 long *valp = ucontrol->value.integer.value;
707
708 *valp = spec->curr_hp_switch;
709 return 0;
710}
711
712static int ca0132_hp_switch_put(struct snd_kcontrol *kcontrol,
713 struct snd_ctl_elem_value *ucontrol)
714{
715 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
716 struct ca0132_spec *spec = codec->spec;
717 long *valp = ucontrol->value.integer.value;
718 unsigned int data;
719 int err;
720
721 /* any change? */
722 if (spec->curr_hp_switch == *valp)
723 return 0;
724
725 snd_hda_power_up(codec);
726
727 err = chipio_read(codec, REG_CODEC_MUTE, &data);
728 if (err < 0)
b97f6bfd 729 goto exit;
95c6e9cb
IM		 730
731 /* *valp 0 is mute, 1 is unmute */
732 data = (data & 0x7f) | (*valp ? 0 : 0x80);
b97f6bfd 733 err = chipio_write(codec, REG_CODEC_MUTE, data);
95c6e9cb 734 if (err < 0)
b97f6bfd 735 goto exit;
95c6e9cb
IM		 736
737 spec->curr_hp_switch = *valp;
738
b97f6bfd 739 exit:
95c6e9cb 740 snd_hda_power_down(codec);
b97f6bfd 741 return err < 0 ? err : 1;
95c6e9cb
IM		 742}
743
744static int ca0132_speaker_switch_get(struct snd_kcontrol *kcontrol,
745 struct snd_ctl_elem_value *ucontrol)
746{
747 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
748 struct ca0132_spec *spec = codec->spec;
749 long *valp = ucontrol->value.integer.value;
750
751 *valp = spec->curr_speaker_switch;
752 return 0;
753}
754
755static int ca0132_speaker_switch_put(struct snd_kcontrol *kcontrol,
756 struct snd_ctl_elem_value *ucontrol)
757{
758 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
759 struct ca0132_spec *spec = codec->spec;
760 long *valp = ucontrol->value.integer.value;
761 unsigned int data;
762 int err;
763
764 /* any change? */
765 if (spec->curr_speaker_switch == *valp)
766 return 0;
767
768 snd_hda_power_up(codec);
769
770 err = chipio_read(codec, REG_CODEC_MUTE, &data);
771 if (err < 0)
b97f6bfd 772 goto exit;
95c6e9cb
IM		 773
774 /* *valp 0 is mute, 1 is unmute */
775 data = (data & 0xef) | (*valp ? 0 : 0x10);
b97f6bfd 776 err = chipio_write(codec, REG_CODEC_MUTE, data);
95c6e9cb 777 if (err < 0)
b97f6bfd 778 goto exit;
95c6e9cb
IM		 779
780 spec->curr_speaker_switch = *valp;
781
b97f6bfd 782 exit:
95c6e9cb 783 snd_hda_power_down(codec);
b97f6bfd 784 return err < 0 ? err : 1;
95c6e9cb
IM		 785}
786
787static int ca0132_hp_volume_get(struct snd_kcontrol *kcontrol,
788 struct snd_ctl_elem_value *ucontrol)
789{
790 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
791 struct ca0132_spec *spec = codec->spec;
792 long *valp = ucontrol->value.integer.value;
793
794 *valp++ = spec->curr_hp_volume[0];
795 *valp = spec->curr_hp_volume[1];
796 return 0;
797}
798
799static int ca0132_hp_volume_put(struct snd_kcontrol *kcontrol,
800 struct snd_ctl_elem_value *ucontrol)
801{
802 struct hda_codec *codec = snd_kcontrol_chip(kcontrol);
803 struct ca0132_spec *spec = codec->spec;
804 long *valp = ucontrol->value.integer.value;
805 long left_vol, right_vol;
806 unsigned int data;
807 int val;
808 int err;
809
810 left_vol = *valp++;
811 right_vol = *valp;
812
813 /* any change? */
814 if ((spec->curr_hp_volume[0] == left_vol) &&
815 (spec->curr_hp_volume[1] == right_vol))
816 return 0;
817
818 snd_hda_power_up(codec);
819
820 err = chipio_read(codec, REG_CODEC_HP_VOL_L, &data);
821 if (err < 0)
b97f6bfd 822 goto exit;
95c6e9cb
IM		 823
824 val = 31 - left_vol;
825 data = (data & 0xe0) | val;
b97f6bfd 826 err = chipio_write(codec, REG_CODEC_HP_VOL_L, data);
95c6e9cb 827 if (err < 0)
b97f6bfd 828 goto exit;
95c6e9cb
IM		 829
830 val = 31 - right_vol;
831 data = (data & 0xe0) | val;
b97f6bfd 832 err = chipio_write(codec, REG_CODEC_HP_VOL_R, data);
95c6e9cb 833 if (err < 0)
b97f6bfd 834 goto exit;
95c6e9cb
IM		 835
836 spec->curr_hp_volume[0] = left_vol;
837 spec->curr_hp_volume[1] = right_vol;
838
b97f6bfd 839 exit:
95c6e9cb 840 snd_hda_power_down(codec);
b97f6bfd 841 return err < 0 ? err : 1;
95c6e9cb
IM		 842}
843
844static int add_hp_switch(struct hda_codec *codec, hda_nid_t nid)
845{
846 struct snd_kcontrol_new knew =
847 HDA_CODEC_MUTE_MONO("Headphone Playback Switch",
848 nid, 1, 0, HDA_OUTPUT);
849 knew.get = ca0132_hp_switch_get;
850 knew.put = ca0132_hp_switch_put;
851 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
852}
853
854static int add_hp_volume(struct hda_codec *codec, hda_nid_t nid)
855{
856 struct snd_kcontrol_new knew =
857 HDA_CODEC_VOLUME_MONO("Headphone Playback Volume",
858 nid, 3, 0, HDA_OUTPUT);
859 knew.get = ca0132_hp_volume_get;
860 knew.put = ca0132_hp_volume_put;
861 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
862}
863
864static int add_speaker_switch(struct hda_codec *codec, hda_nid_t nid)
865{
866 struct snd_kcontrol_new knew =
867 HDA_CODEC_MUTE_MONO("Speaker Playback Switch",
868 nid, 1, 0, HDA_OUTPUT);
869 knew.get = ca0132_speaker_switch_get;
870 knew.put = ca0132_speaker_switch_put;
871 return snd_hda_ctl_add(codec, nid, snd_ctl_new1(&knew, codec));
872}
873
874static void ca0132_fix_hp_caps(struct hda_codec *codec)
875{
876 struct ca0132_spec *spec = codec->spec;
877 struct auto_pin_cfg *cfg = &spec->autocfg;
878 unsigned int caps;
879
880 /* set mute-capable, 1db step, 32 steps, ofs 6 */
881 caps = 0x80031f06;
882 snd_hda_override_amp_caps(codec, cfg->hp_pins[0], HDA_OUTPUT, caps);
883}
884
885static int ca0132_build_controls(struct hda_codec *codec)
886{
887 struct ca0132_spec *spec = codec->spec;
888 struct auto_pin_cfg *cfg = &spec->autocfg;
889 int i, err;
890
891 if (spec->multiout.num_dacs) {
892 err = add_speaker_switch(codec, spec->out_pins[0]);
893 if (err < 0)
894 return err;
895 }
896
897 if (cfg->hp_outs) {
898 ca0132_fix_hp_caps(codec);
899 err = add_hp_switch(codec, cfg->hp_pins[0]);
900 if (err < 0)
901 return err;
902 err = add_hp_volume(codec, cfg->hp_pins[0]);
903 if (err < 0)
904 return err;
905 }
906
907 for (i = 0; i < spec->num_inputs; i++) {
908 const char *label = spec->input_labels[i];
909
910 err = add_in_switch(codec, spec->adcs[i], label);
911 if (err < 0)
912 return err;
913 err = add_in_volume(codec, spec->adcs[i], label);
914 if (err < 0)
915 return err;
916 if (cfg->inputs[i].type == AUTO_PIN_MIC) {
917 /* add Mic-Boost */
918 err = add_in_mono_volume(codec, spec->input_pins[i],
919 "Mic Boost", 1);
920 if (err < 0)
921 return err;
922 }
923 }
924
925 if (spec->dig_out) {
efb9f469
TI		 926 err = snd_hda_create_spdif_out_ctls(codec, spec->dig_out,
927 spec->dig_out);
95c6e9cb
IM		 928 if (err < 0)
929 return err;
930 err = add_out_volume(codec, spec->dig_out, "IEC958");
931 if (err < 0)
932 return err;
933 }
934
935 if (spec->dig_in) {
936 err = snd_hda_create_spdif_in_ctls(codec, spec->dig_in);
937 if (err < 0)
938 return err;
939 err = add_in_volume(codec, spec->dig_in, "IEC958");
b97f6bfd
TI		 940 if (err < 0)
941 return err;
95c6e9cb
IM		 942 }
943 return 0;
944}
945
946
947static void ca0132_set_ct_ext(struct hda_codec *codec, int enable)
948{
949 /* Set Creative extension */
950 snd_printdd("SET CREATIVE EXTENSION\n");
951 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
952 VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE,
953 enable);
954 msleep(20);
955}
956
957
958static void ca0132_config(struct hda_codec *codec)
959{
960 struct ca0132_spec *spec = codec->spec;
961 struct auto_pin_cfg *cfg = &spec->autocfg;
962
963 /* line-outs */
964 cfg->line_outs = 1;
965 cfg->line_out_pins[0] = 0x0b; /* front */
966 cfg->line_out_type = AUTO_PIN_LINE_OUT;
967
968 spec->dacs[0] = 0x02;
969 spec->out_pins[0] = 0x0b;
970 spec->multiout.dac_nids = spec->dacs;
971 spec->multiout.num_dacs = 1;
972 spec->multiout.max_channels = 2;
973
974 /* headphone */
975 cfg->hp_outs = 1;
976 cfg->hp_pins[0] = 0x0f;
977
978 spec->hp_dac = 0;
979 spec->multiout.hp_nid = 0;
980
981 /* inputs */
982 cfg->num_inputs = 2; /* Mic-in and line-in */
983 cfg->inputs[0].pin = 0x12;
984 cfg->inputs[0].type = AUTO_PIN_MIC;
985 cfg->inputs[1].pin = 0x11;
986 cfg->inputs[1].type = AUTO_PIN_LINE_IN;
987
988 /* Mic-in */
989 spec->input_pins[0] = 0x12;
990 spec->input_labels[0] = "Mic-In";
991 spec->adcs[0] = 0x07;
992
993 /* Line-In */
994 spec->input_pins[1] = 0x11;
995 spec->input_labels[1] = "Line-In";
996 spec->adcs[1] = 0x08;
997 spec->num_inputs = 2;
998}
999
1000static void ca0132_init_chip(struct hda_codec *codec)
1001{
1002 struct ca0132_spec *spec = codec->spec;
1003
1004 mutex_init(&spec->chipio_mutex);
1005}
1006
1007static void ca0132_exit_chip(struct hda_codec *codec)
1008{
1009 /* put any chip cleanup stuffs here. */
1010}
1011
1012static int ca0132_init(struct hda_codec *codec)
1013{
1014 struct ca0132_spec *spec = codec->spec;
1015 struct auto_pin_cfg *cfg = &spec->autocfg;
1016 int i;
1017
1018 for (i = 0; i < spec->multiout.num_dacs; i++) {
1019 init_output(codec, spec->out_pins[i],
1020 spec->multiout.dac_nids[i]);
1021 }
1022 init_output(codec, cfg->hp_pins[0], spec->hp_dac);
1023 init_output(codec, cfg->dig_out_pins[0], spec->dig_out);
1024
1025 for (i = 0; i < spec->num_inputs; i++)
1026 init_input(codec, spec->input_pins[i], spec->adcs[i]);
1027
1028 init_input(codec, cfg->dig_in_pin, spec->dig_in);
1029
1030 ca0132_set_ct_ext(codec, 1);
1031
1032 return 0;
1033}
1034
1035
1036static void ca0132_free(struct hda_codec *codec)
1037{
1038 ca0132_set_ct_ext(codec, 0);
1039 ca0132_exit_chip(codec);
1040 kfree(codec->spec);
1041}
1042
1043static struct hda_codec_ops ca0132_patch_ops = {
1044 .build_controls = ca0132_build_controls,
1045 .build_pcms = ca0132_build_pcms,
1046 .init = ca0132_init,
1047 .free = ca0132_free,
1048};
1049
1050
1051
1052static int patch_ca0132(struct hda_codec *codec)
1053{
1054 struct ca0132_spec *spec;
1055
1056 snd_printdd("patch_ca0132\n");
1057
1058 spec = kzalloc(sizeof(*spec), GFP_KERNEL);
1059 if (!spec)
1060 return -ENOMEM;
1061 codec->spec = spec;
1062
1063 ca0132_init_chip(codec);
1064
1065 ca0132_config(codec);
1066
1067 codec->patch_ops = ca0132_patch_ops;
1068
1069 return 0;
1070}
1071
1072/*
1073 * patch entries
1074 */
1075static struct hda_codec_preset snd_hda_preset_ca0132[] = {
1076 { .id = 0x11020011, .name = "CA0132", .patch = patch_ca0132 },
1077 {} /* terminator */
1078};
1079
1080MODULE_ALIAS("snd-hda-codec-id:11020011");
1081
1082MODULE_LICENSE("GPL");
1083MODULE_DESCRIPTION("Creative CA0132, CA0132 HD-audio codec");
1084
1085static struct hda_codec_preset_list ca0132_list = {
1086 .preset = snd_hda_preset_ca0132,
1087 .owner = THIS_MODULE,
1088};
1089
1090static int __init patch_ca0132_init(void)
1091{
1092 return snd_hda_add_codec_preset(&ca0132_list);
1093}
1094
1095static void __exit patch_ca0132_exit(void)
1096{
1097 snd_hda_delete_codec_preset(&ca0132_list);
1098}
1099
1100module_init(patch_ca0132_init)
1101module_exit(patch_ca0132_exit)
Linux 6.x block layer and io_uring tree(s)