Merge tag 'kbuild-fixes-v5.1' of git://git.kernel.org/pub/scm/linux/kernel/git/masahi...
[muen/linux.git] / sound / pci / hda / patch_ca0132.c
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/mutex.h>
28 #include <linux/module.h>
29 #include <linux/firmware.h>
30 #include <linux/kernel.h>
31 #include <linux/types.h>
32 #include <linux/io.h>
33 #include <linux/pci.h>
34 #include <asm/io.h>
35 #include <sound/core.h>
36 #include <sound/hda_codec.h>
37 #include "hda_local.h"
38 #include "hda_auto_parser.h"
39 #include "hda_jack.h"
40
41 #include "ca0132_regs.h"
42
43 /* Enable this to see controls for tuning purpose. */
44 /*#define ENABLE_TUNING_CONTROLS*/
45
46 #ifdef ENABLE_TUNING_CONTROLS
47 #include <sound/tlv.h>
48 #endif
49
50 #define FLOAT_ZERO      0x00000000
51 #define FLOAT_ONE       0x3f800000
52 #define FLOAT_TWO       0x40000000
53 #define FLOAT_THREE     0x40400000
54 #define FLOAT_EIGHT     0x41000000
55 #define FLOAT_MINUS_5   0xc0a00000
56
57 #define UNSOL_TAG_DSP   0x16
58
59 #define DSP_DMA_WRITE_BUFLEN_INIT (1UL<<18)
60 #define DSP_DMA_WRITE_BUFLEN_OVLY (1UL<<15)
61
62 #define DMA_TRANSFER_FRAME_SIZE_NWORDS          8
63 #define DMA_TRANSFER_MAX_FRAME_SIZE_NWORDS      32
64 #define DMA_OVERLAY_FRAME_SIZE_NWORDS           2
65
66 #define MASTERCONTROL                           0x80
67 #define MASTERCONTROL_ALLOC_DMA_CHAN            10
68 #define MASTERCONTROL_QUERY_SPEAKER_EQ_ADDRESS  60
69
70 #define WIDGET_CHIP_CTRL      0x15
71 #define WIDGET_DSP_CTRL       0x16
72
73 #define MEM_CONNID_MICIN1     3
74 #define MEM_CONNID_MICIN2     5
75 #define MEM_CONNID_MICOUT1    12
76 #define MEM_CONNID_MICOUT2    14
77 #define MEM_CONNID_WUH        10
78 #define MEM_CONNID_DSP        16
79 #define MEM_CONNID_DMIC       100
80
81 #define SCP_SET    0
82 #define SCP_GET    1
83
84 #define EFX_FILE   "ctefx.bin"
85 #define DESKTOP_EFX_FILE   "ctefx-desktop.bin"
86 #define R3DI_EFX_FILE  "ctefx-r3di.bin"
87
88 #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP
89 MODULE_FIRMWARE(EFX_FILE);
90 MODULE_FIRMWARE(DESKTOP_EFX_FILE);
91 MODULE_FIRMWARE(R3DI_EFX_FILE);
92 #endif
93
94 static const char *const dirstr[2] = { "Playback", "Capture" };
95
96 #define NUM_OF_OUTPUTS 3
97 enum {
98         SPEAKER_OUT,
99         HEADPHONE_OUT,
100         SURROUND_OUT
101 };
102
103 enum {
104         DIGITAL_MIC,
105         LINE_MIC_IN
106 };
107
108 /* Strings for Input Source Enum Control */
109 static const char *const in_src_str[3] = {"Rear Mic", "Line", "Front Mic" };
110 #define IN_SRC_NUM_OF_INPUTS 3
111 enum {
112         REAR_MIC,
113         REAR_LINE_IN,
114         FRONT_MIC,
115 };
116
117 enum {
118 #define VNODE_START_NID    0x80
119         VNID_SPK = VNODE_START_NID,                     /* Speaker vnid */
120         VNID_MIC,
121         VNID_HP_SEL,
122         VNID_AMIC1_SEL,
123         VNID_HP_ASEL,
124         VNID_AMIC1_ASEL,
125         VNODE_END_NID,
126 #define VNODES_COUNT  (VNODE_END_NID - VNODE_START_NID)
127
128 #define EFFECT_START_NID    0x90
129 #define OUT_EFFECT_START_NID    EFFECT_START_NID
130         SURROUND = OUT_EFFECT_START_NID,
131         CRYSTALIZER,
132         DIALOG_PLUS,
133         SMART_VOLUME,
134         X_BASS,
135         EQUALIZER,
136         OUT_EFFECT_END_NID,
137 #define OUT_EFFECTS_COUNT  (OUT_EFFECT_END_NID - OUT_EFFECT_START_NID)
138
139 #define IN_EFFECT_START_NID  OUT_EFFECT_END_NID
140         ECHO_CANCELLATION = IN_EFFECT_START_NID,
141         VOICE_FOCUS,
142         MIC_SVM,
143         NOISE_REDUCTION,
144         IN_EFFECT_END_NID,
145 #define IN_EFFECTS_COUNT  (IN_EFFECT_END_NID - IN_EFFECT_START_NID)
146
147         VOICEFX = IN_EFFECT_END_NID,
148         PLAY_ENHANCEMENT,
149         CRYSTAL_VOICE,
150         EFFECT_END_NID,
151         OUTPUT_SOURCE_ENUM,
152         INPUT_SOURCE_ENUM,
153         XBASS_XOVER,
154         EQ_PRESET_ENUM,
155         SMART_VOLUME_ENUM,
156         MIC_BOOST_ENUM,
157         AE5_HEADPHONE_GAIN_ENUM,
158         AE5_SOUND_FILTER_ENUM,
159         ZXR_HEADPHONE_GAIN
160 #define EFFECTS_COUNT  (EFFECT_END_NID - EFFECT_START_NID)
161 };
162
163 /* Effects values size*/
164 #define EFFECT_VALS_MAX_COUNT 12
165
166 /*
167  * Default values for the effect slider controls, they are in order of their
168  * effect NID's. Surround, Crystalizer, Dialog Plus, Smart Volume, and then
169  * X-bass.
170  */
171 static const unsigned int effect_slider_defaults[] = {67, 65, 50, 74, 50};
172 /* Amount of effect level sliders for ca0132_alt controls. */
173 #define EFFECT_LEVEL_SLIDERS 5
174
175 /* Latency introduced by DSP blocks in milliseconds. */
176 #define DSP_CAPTURE_INIT_LATENCY        0
177 #define DSP_CRYSTAL_VOICE_LATENCY       124
178 #define DSP_PLAYBACK_INIT_LATENCY       13
179 #define DSP_PLAY_ENHANCEMENT_LATENCY    30
180 #define DSP_SPEAKER_OUT_LATENCY         7
181
182 struct ct_effect {
183         char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
184         hda_nid_t nid;
185         int mid; /*effect module ID*/
186         int reqs[EFFECT_VALS_MAX_COUNT]; /*effect module request*/
187         int direct; /* 0:output; 1:input*/
188         int params; /* number of default non-on/off params */
189         /*effect default values, 1st is on/off. */
190         unsigned int def_vals[EFFECT_VALS_MAX_COUNT];
191 };
192
193 #define EFX_DIR_OUT 0
194 #define EFX_DIR_IN  1
195
196 static const struct ct_effect ca0132_effects[EFFECTS_COUNT] = {
197         { .name = "Surround",
198           .nid = SURROUND,
199           .mid = 0x96,
200           .reqs = {0, 1},
201           .direct = EFX_DIR_OUT,
202           .params = 1,
203           .def_vals = {0x3F800000, 0x3F2B851F}
204         },
205         { .name = "Crystalizer",
206           .nid = CRYSTALIZER,
207           .mid = 0x96,
208           .reqs = {7, 8},
209           .direct = EFX_DIR_OUT,
210           .params = 1,
211           .def_vals = {0x3F800000, 0x3F266666}
212         },
213         { .name = "Dialog Plus",
214           .nid = DIALOG_PLUS,
215           .mid = 0x96,
216           .reqs = {2, 3},
217           .direct = EFX_DIR_OUT,
218           .params = 1,
219           .def_vals = {0x00000000, 0x3F000000}
220         },
221         { .name = "Smart Volume",
222           .nid = SMART_VOLUME,
223           .mid = 0x96,
224           .reqs = {4, 5, 6},
225           .direct = EFX_DIR_OUT,
226           .params = 2,
227           .def_vals = {0x3F800000, 0x3F3D70A4, 0x00000000}
228         },
229         { .name = "X-Bass",
230           .nid = X_BASS,
231           .mid = 0x96,
232           .reqs = {24, 23, 25},
233           .direct = EFX_DIR_OUT,
234           .params = 2,
235           .def_vals = {0x3F800000, 0x42A00000, 0x3F000000}
236         },
237         { .name = "Equalizer",
238           .nid = EQUALIZER,
239           .mid = 0x96,
240           .reqs = {9, 10, 11, 12, 13, 14,
241                         15, 16, 17, 18, 19, 20},
242           .direct = EFX_DIR_OUT,
243           .params = 11,
244           .def_vals = {0x00000000, 0x00000000, 0x00000000, 0x00000000,
245                        0x00000000, 0x00000000, 0x00000000, 0x00000000,
246                        0x00000000, 0x00000000, 0x00000000, 0x00000000}
247         },
248         { .name = "Echo Cancellation",
249           .nid = ECHO_CANCELLATION,
250           .mid = 0x95,
251           .reqs = {0, 1, 2, 3},
252           .direct = EFX_DIR_IN,
253           .params = 3,
254           .def_vals = {0x00000000, 0x3F3A9692, 0x00000000, 0x00000000}
255         },
256         { .name = "Voice Focus",
257           .nid = VOICE_FOCUS,
258           .mid = 0x95,
259           .reqs = {6, 7, 8, 9},
260           .direct = EFX_DIR_IN,
261           .params = 3,
262           .def_vals = {0x3F800000, 0x3D7DF3B6, 0x41F00000, 0x41F00000}
263         },
264         { .name = "Mic SVM",
265           .nid = MIC_SVM,
266           .mid = 0x95,
267           .reqs = {44, 45},
268           .direct = EFX_DIR_IN,
269           .params = 1,
270           .def_vals = {0x00000000, 0x3F3D70A4}
271         },
272         { .name = "Noise Reduction",
273           .nid = NOISE_REDUCTION,
274           .mid = 0x95,
275           .reqs = {4, 5},
276           .direct = EFX_DIR_IN,
277           .params = 1,
278           .def_vals = {0x3F800000, 0x3F000000}
279         },
280         { .name = "VoiceFX",
281           .nid = VOICEFX,
282           .mid = 0x95,
283           .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18},
284           .direct = EFX_DIR_IN,
285           .params = 8,
286           .def_vals = {0x00000000, 0x43C80000, 0x44AF0000, 0x44FA0000,
287                        0x3F800000, 0x3F800000, 0x3F800000, 0x00000000,
288                        0x00000000}
289         }
290 };
291
292 /* Tuning controls */
293 #ifdef ENABLE_TUNING_CONTROLS
294
295 enum {
296 #define TUNING_CTL_START_NID  0xC0
297         WEDGE_ANGLE = TUNING_CTL_START_NID,
298         SVM_LEVEL,
299         EQUALIZER_BAND_0,
300         EQUALIZER_BAND_1,
301         EQUALIZER_BAND_2,
302         EQUALIZER_BAND_3,
303         EQUALIZER_BAND_4,
304         EQUALIZER_BAND_5,
305         EQUALIZER_BAND_6,
306         EQUALIZER_BAND_7,
307         EQUALIZER_BAND_8,
308         EQUALIZER_BAND_9,
309         TUNING_CTL_END_NID
310 #define TUNING_CTLS_COUNT  (TUNING_CTL_END_NID - TUNING_CTL_START_NID)
311 };
312
313 struct ct_tuning_ctl {
314         char name[SNDRV_CTL_ELEM_ID_NAME_MAXLEN];
315         hda_nid_t parent_nid;
316         hda_nid_t nid;
317         int mid; /*effect module ID*/
318         int req; /*effect module request*/
319         int direct; /* 0:output; 1:input*/
320         unsigned int def_val;/*effect default values*/
321 };
322
323 static const struct ct_tuning_ctl ca0132_tuning_ctls[] = {
324         { .name = "Wedge Angle",
325           .parent_nid = VOICE_FOCUS,
326           .nid = WEDGE_ANGLE,
327           .mid = 0x95,
328           .req = 8,
329           .direct = EFX_DIR_IN,
330           .def_val = 0x41F00000
331         },
332         { .name = "SVM Level",
333           .parent_nid = MIC_SVM,
334           .nid = SVM_LEVEL,
335           .mid = 0x95,
336           .req = 45,
337           .direct = EFX_DIR_IN,
338           .def_val = 0x3F3D70A4
339         },
340         { .name = "EQ Band0",
341           .parent_nid = EQUALIZER,
342           .nid = EQUALIZER_BAND_0,
343           .mid = 0x96,
344           .req = 11,
345           .direct = EFX_DIR_OUT,
346           .def_val = 0x00000000
347         },
348         { .name = "EQ Band1",
349           .parent_nid = EQUALIZER,
350           .nid = EQUALIZER_BAND_1,
351           .mid = 0x96,
352           .req = 12,
353           .direct = EFX_DIR_OUT,
354           .def_val = 0x00000000
355         },
356         { .name = "EQ Band2",
357           .parent_nid = EQUALIZER,
358           .nid = EQUALIZER_BAND_2,
359           .mid = 0x96,
360           .req = 13,
361           .direct = EFX_DIR_OUT,
362           .def_val = 0x00000000
363         },
364         { .name = "EQ Band3",
365           .parent_nid = EQUALIZER,
366           .nid = EQUALIZER_BAND_3,
367           .mid = 0x96,
368           .req = 14,
369           .direct = EFX_DIR_OUT,
370           .def_val = 0x00000000
371         },
372         { .name = "EQ Band4",
373           .parent_nid = EQUALIZER,
374           .nid = EQUALIZER_BAND_4,
375           .mid = 0x96,
376           .req = 15,
377           .direct = EFX_DIR_OUT,
378           .def_val = 0x00000000
379         },
380         { .name = "EQ Band5",
381           .parent_nid = EQUALIZER,
382           .nid = EQUALIZER_BAND_5,
383           .mid = 0x96,
384           .req = 16,
385           .direct = EFX_DIR_OUT,
386           .def_val = 0x00000000
387         },
388         { .name = "EQ Band6",
389           .parent_nid = EQUALIZER,
390           .nid = EQUALIZER_BAND_6,
391           .mid = 0x96,
392           .req = 17,
393           .direct = EFX_DIR_OUT,
394           .def_val = 0x00000000
395         },
396         { .name = "EQ Band7",
397           .parent_nid = EQUALIZER,
398           .nid = EQUALIZER_BAND_7,
399           .mid = 0x96,
400           .req = 18,
401           .direct = EFX_DIR_OUT,
402           .def_val = 0x00000000
403         },
404         { .name = "EQ Band8",
405           .parent_nid = EQUALIZER,
406           .nid = EQUALIZER_BAND_8,
407           .mid = 0x96,
408           .req = 19,
409           .direct = EFX_DIR_OUT,
410           .def_val = 0x00000000
411         },
412         { .name = "EQ Band9",
413           .parent_nid = EQUALIZER,
414           .nid = EQUALIZER_BAND_9,
415           .mid = 0x96,
416           .req = 20,
417           .direct = EFX_DIR_OUT,
418           .def_val = 0x00000000
419         }
420 };
421 #endif
422
423 /* Voice FX Presets */
424 #define VOICEFX_MAX_PARAM_COUNT 9
425
426 struct ct_voicefx {
427         char *name;
428         hda_nid_t nid;
429         int mid;
430         int reqs[VOICEFX_MAX_PARAM_COUNT]; /*effect module request*/
431 };
432
433 struct ct_voicefx_preset {
434         char *name; /*preset name*/
435         unsigned int vals[VOICEFX_MAX_PARAM_COUNT];
436 };
437
438 static const struct ct_voicefx ca0132_voicefx = {
439         .name = "VoiceFX Capture Switch",
440         .nid = VOICEFX,
441         .mid = 0x95,
442         .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18}
443 };
444
445 static const struct ct_voicefx_preset ca0132_voicefx_presets[] = {
446         { .name = "Neutral",
447           .vals = { 0x00000000, 0x43C80000, 0x44AF0000,
448                     0x44FA0000, 0x3F800000, 0x3F800000,
449                     0x3F800000, 0x00000000, 0x00000000 }
450         },
451         { .name = "Female2Male",
452           .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
453                     0x44FA0000, 0x3F19999A, 0x3F866666,
454                     0x3F800000, 0x00000000, 0x00000000 }
455         },
456         { .name = "Male2Female",
457           .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
458                     0x450AC000, 0x4017AE14, 0x3F6B851F,
459                     0x3F800000, 0x00000000, 0x00000000 }
460         },
461         { .name = "ScrappyKid",
462           .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
463                     0x44FA0000, 0x40400000, 0x3F28F5C3,
464                     0x3F800000, 0x00000000, 0x00000000 }
465         },
466         { .name = "Elderly",
467           .vals = { 0x3F800000, 0x44324000, 0x44BB8000,
468                     0x44E10000, 0x3FB33333, 0x3FB9999A,
469                     0x3F800000, 0x3E3A2E43, 0x00000000 }
470         },
471         { .name = "Orc",
472           .vals = { 0x3F800000, 0x43EA0000, 0x44A52000,
473                     0x45098000, 0x3F266666, 0x3FC00000,
474                     0x3F800000, 0x00000000, 0x00000000 }
475         },
476         { .name = "Elf",
477           .vals = { 0x3F800000, 0x43C70000, 0x44AE6000,
478                     0x45193000, 0x3F8E147B, 0x3F75C28F,
479                     0x3F800000, 0x00000000, 0x00000000 }
480         },
481         { .name = "Dwarf",
482           .vals = { 0x3F800000, 0x43930000, 0x44BEE000,
483                     0x45007000, 0x3F451EB8, 0x3F7851EC,
484                     0x3F800000, 0x00000000, 0x00000000 }
485         },
486         { .name = "AlienBrute",
487           .vals = { 0x3F800000, 0x43BFC5AC, 0x44B28FDF,
488                     0x451F6000, 0x3F266666, 0x3FA7D945,
489                     0x3F800000, 0x3CF5C28F, 0x00000000 }
490         },
491         { .name = "Robot",
492           .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
493                     0x44FA0000, 0x3FB2718B, 0x3F800000,
494                     0xBC07010E, 0x00000000, 0x00000000 }
495         },
496         { .name = "Marine",
497           .vals = { 0x3F800000, 0x43C20000, 0x44906000,
498                     0x44E70000, 0x3F4CCCCD, 0x3F8A3D71,
499                     0x3F0A3D71, 0x00000000, 0x00000000 }
500         },
501         { .name = "Emo",
502           .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
503                     0x44FA0000, 0x3F800000, 0x3F800000,
504                     0x3E4CCCCD, 0x00000000, 0x00000000 }
505         },
506         { .name = "DeepVoice",
507           .vals = { 0x3F800000, 0x43A9C5AC, 0x44AA4FDF,
508                     0x44FFC000, 0x3EDBB56F, 0x3F99C4CA,
509                     0x3F800000, 0x00000000, 0x00000000 }
510         },
511         { .name = "Munchkin",
512           .vals = { 0x3F800000, 0x43C80000, 0x44AF0000,
513                     0x44FA0000, 0x3F800000, 0x3F1A043C,
514                     0x3F800000, 0x00000000, 0x00000000 }
515         }
516 };
517
518 /* ca0132 EQ presets, taken from Windows Sound Blaster Z Driver */
519
520 #define EQ_PRESET_MAX_PARAM_COUNT 11
521
522 struct ct_eq {
523         char *name;
524         hda_nid_t nid;
525         int mid;
526         int reqs[EQ_PRESET_MAX_PARAM_COUNT]; /*effect module request*/
527 };
528
529 struct ct_eq_preset {
530         char *name; /*preset name*/
531         unsigned int vals[EQ_PRESET_MAX_PARAM_COUNT];
532 };
533
534 static const struct ct_eq ca0132_alt_eq_enum = {
535         .name = "FX: Equalizer Preset Switch",
536         .nid = EQ_PRESET_ENUM,
537         .mid = 0x96,
538         .reqs = {10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20}
539 };
540
541
542 static const struct ct_eq_preset ca0132_alt_eq_presets[] = {
543         { .name = "Flat",
544          .vals = { 0x00000000, 0x00000000, 0x00000000,
545                    0x00000000, 0x00000000, 0x00000000,
546                    0x00000000, 0x00000000, 0x00000000,
547                    0x00000000, 0x00000000            }
548         },
549         { .name = "Acoustic",
550          .vals = { 0x00000000, 0x00000000, 0x3F8CCCCD,
551                    0x40000000, 0x00000000, 0x00000000,
552                    0x00000000, 0x00000000, 0x40000000,
553                    0x40000000, 0x40000000            }
554         },
555         { .name = "Classical",
556          .vals = { 0x00000000, 0x00000000, 0x40C00000,
557                    0x40C00000, 0x40466666, 0x00000000,
558                    0x00000000, 0x00000000, 0x00000000,
559                    0x40466666, 0x40466666            }
560         },
561         { .name = "Country",
562          .vals = { 0x00000000, 0xBF99999A, 0x00000000,
563                    0x3FA66666, 0x3FA66666, 0x3F8CCCCD,
564                    0x00000000, 0x00000000, 0x40000000,
565                    0x40466666, 0x40800000            }
566         },
567         { .name = "Dance",
568          .vals = { 0x00000000, 0xBF99999A, 0x40000000,
569                    0x40466666, 0x40866666, 0xBF99999A,
570                    0xBF99999A, 0x00000000, 0x00000000,
571                    0x40800000, 0x40800000            }
572         },
573         { .name = "Jazz",
574          .vals = { 0x00000000, 0x00000000, 0x00000000,
575                    0x3F8CCCCD, 0x40800000, 0x40800000,
576                    0x40800000, 0x00000000, 0x3F8CCCCD,
577                    0x40466666, 0x40466666            }
578         },
579         { .name = "New Age",
580          .vals = { 0x00000000, 0x00000000, 0x40000000,
581                    0x40000000, 0x00000000, 0x00000000,
582                    0x00000000, 0x3F8CCCCD, 0x40000000,
583                    0x40000000, 0x40000000            }
584         },
585         { .name = "Pop",
586          .vals = { 0x00000000, 0xBFCCCCCD, 0x00000000,
587                    0x40000000, 0x40000000, 0x00000000,
588                    0xBF99999A, 0xBF99999A, 0x00000000,
589                    0x40466666, 0x40C00000            }
590         },
591         { .name = "Rock",
592          .vals = { 0x00000000, 0xBF99999A, 0xBF99999A,
593                    0x3F8CCCCD, 0x40000000, 0xBF99999A,
594                    0xBF99999A, 0x00000000, 0x00000000,
595                    0x40800000, 0x40800000            }
596         },
597         { .name = "Vocal",
598          .vals = { 0x00000000, 0xC0000000, 0xBF99999A,
599                    0xBF99999A, 0x00000000, 0x40466666,
600                    0x40800000, 0x40466666, 0x00000000,
601                    0x00000000, 0x3F8CCCCD            }
602         }
603 };
604
605 /* DSP command sequences for ca0132_alt_select_out */
606 #define ALT_OUT_SET_MAX_COMMANDS 9 /* Max number of commands in sequence */
607 struct ca0132_alt_out_set {
608         char *name; /*preset name*/
609         unsigned char commands;
610         unsigned int mids[ALT_OUT_SET_MAX_COMMANDS];
611         unsigned int reqs[ALT_OUT_SET_MAX_COMMANDS];
612         unsigned int vals[ALT_OUT_SET_MAX_COMMANDS];
613 };
614
615 static const struct ca0132_alt_out_set alt_out_presets[] = {
616         { .name = "Line Out",
617           .commands = 7,
618           .mids = { 0x96, 0x96, 0x96, 0x8F,
619                     0x96, 0x96, 0x96 },
620           .reqs = { 0x19, 0x17, 0x18, 0x01,
621                     0x1F, 0x15, 0x3A },
622           .vals = { 0x3F000000, 0x42A00000, 0x00000000,
623                     0x00000000, 0x00000000, 0x00000000,
624                     0x00000000 }
625         },
626         { .name = "Headphone",
627           .commands = 7,
628           .mids = { 0x96, 0x96, 0x96, 0x8F,
629                     0x96, 0x96, 0x96 },
630           .reqs = { 0x19, 0x17, 0x18, 0x01,
631                     0x1F, 0x15, 0x3A },
632           .vals = { 0x3F000000, 0x42A00000, 0x00000000,
633                     0x00000000, 0x00000000, 0x00000000,
634                     0x00000000 }
635         },
636         { .name = "Surround",
637           .commands = 8,
638           .mids = { 0x96, 0x8F, 0x96, 0x96,
639                     0x96, 0x96, 0x96, 0x96 },
640           .reqs = { 0x18, 0x01, 0x1F, 0x15,
641                     0x3A, 0x1A, 0x1B, 0x1C },
642           .vals = { 0x00000000, 0x00000000, 0x00000000,
643                     0x00000000, 0x00000000, 0x00000000,
644                     0x00000000, 0x00000000 }
645         }
646 };
647
648 /*
649  * DSP volume setting structs. Req 1 is left volume, req 2 is right volume,
650  * and I don't know what the third req is, but it's always zero. I assume it's
651  * some sort of update or set command to tell the DSP there's new volume info.
652  */
653 #define DSP_VOL_OUT 0
654 #define DSP_VOL_IN  1
655
656 struct ct_dsp_volume_ctl {
657         hda_nid_t vnid;
658         int mid; /* module ID*/
659         unsigned int reqs[3]; /* scp req ID */
660 };
661
662 static const struct ct_dsp_volume_ctl ca0132_alt_vol_ctls[] = {
663         { .vnid = VNID_SPK,
664           .mid = 0x32,
665           .reqs = {3, 4, 2}
666         },
667         { .vnid = VNID_MIC,
668           .mid = 0x37,
669           .reqs = {2, 3, 1}
670         }
671 };
672
673 /* Values for ca0113_mmio_command_set for selecting output. */
674 #define AE5_CA0113_OUT_SET_COMMANDS 6
675 struct ae5_ca0113_output_set {
676         unsigned int group[AE5_CA0113_OUT_SET_COMMANDS];
677         unsigned int target[AE5_CA0113_OUT_SET_COMMANDS];
678         unsigned int vals[AE5_CA0113_OUT_SET_COMMANDS];
679 };
680
681 static const struct ae5_ca0113_output_set ae5_ca0113_output_presets[] = {
682         { .group =  { 0x30, 0x30, 0x48, 0x48, 0x48, 0x30 },
683           .target = { 0x2e, 0x30, 0x0d, 0x17, 0x19, 0x32 },
684           .vals =   { 0x00, 0x00, 0x40, 0x00, 0x00, 0x3f }
685         },
686         { .group =  { 0x30, 0x30, 0x48, 0x48, 0x48, 0x30 },
687           .target = { 0x2e, 0x30, 0x0d, 0x17, 0x19, 0x32 },
688           .vals =   { 0x3f, 0x3f, 0x00, 0x00, 0x00, 0x00 }
689         },
690         { .group =  { 0x30, 0x30, 0x48, 0x48, 0x48, 0x30 },
691           .target = { 0x2e, 0x30, 0x0d, 0x17, 0x19, 0x32 },
692           .vals =   { 0x00, 0x00, 0x40, 0x00, 0x00, 0x3f }
693         }
694 };
695
696 /* ae5 ca0113 command sequences to set headphone gain levels. */
697 #define AE5_HEADPHONE_GAIN_PRESET_MAX_COMMANDS 4
698 struct ae5_headphone_gain_set {
699         char *name;
700         unsigned int vals[AE5_HEADPHONE_GAIN_PRESET_MAX_COMMANDS];
701 };
702
703 static const struct ae5_headphone_gain_set ae5_headphone_gain_presets[] = {
704         { .name = "Low (16-31",
705           .vals = { 0xff, 0x2c, 0xf5, 0x32 }
706         },
707         { .name = "Medium (32-149",
708           .vals = { 0x38, 0xa8, 0x3e, 0x4c }
709         },
710         { .name = "High (150-600",
711           .vals = { 0xff, 0xff, 0xff, 0x7f }
712         }
713 };
714
715 struct ae5_filter_set {
716         char *name;
717         unsigned int val;
718 };
719
720 static const struct ae5_filter_set ae5_filter_presets[] = {
721         { .name = "Slow Roll Off",
722           .val = 0xa0
723         },
724         { .name = "Minimum Phase",
725           .val = 0xc0
726         },
727         { .name = "Fast Roll Off",
728           .val = 0x80
729         }
730 };
731
732 enum hda_cmd_vendor_io {
733         /* for DspIO node */
734         VENDOR_DSPIO_SCP_WRITE_DATA_LOW      = 0x000,
735         VENDOR_DSPIO_SCP_WRITE_DATA_HIGH     = 0x100,
736
737         VENDOR_DSPIO_STATUS                  = 0xF01,
738         VENDOR_DSPIO_SCP_POST_READ_DATA      = 0x702,
739         VENDOR_DSPIO_SCP_READ_DATA           = 0xF02,
740         VENDOR_DSPIO_DSP_INIT                = 0x703,
741         VENDOR_DSPIO_SCP_POST_COUNT_QUERY    = 0x704,
742         VENDOR_DSPIO_SCP_READ_COUNT          = 0xF04,
743
744         /* for ChipIO node */
745         VENDOR_CHIPIO_ADDRESS_LOW            = 0x000,
746         VENDOR_CHIPIO_ADDRESS_HIGH           = 0x100,
747         VENDOR_CHIPIO_STREAM_FORMAT          = 0x200,
748         VENDOR_CHIPIO_DATA_LOW               = 0x300,
749         VENDOR_CHIPIO_DATA_HIGH              = 0x400,
750
751         VENDOR_CHIPIO_8051_WRITE_DIRECT      = 0x500,
752         VENDOR_CHIPIO_8051_READ_DIRECT       = 0xD00,
753
754         VENDOR_CHIPIO_GET_PARAMETER          = 0xF00,
755         VENDOR_CHIPIO_STATUS                 = 0xF01,
756         VENDOR_CHIPIO_HIC_POST_READ          = 0x702,
757         VENDOR_CHIPIO_HIC_READ_DATA          = 0xF03,
758
759         VENDOR_CHIPIO_8051_DATA_WRITE        = 0x707,
760         VENDOR_CHIPIO_8051_DATA_READ         = 0xF07,
761         VENDOR_CHIPIO_8051_PMEM_READ         = 0xF08,
762         VENDOR_CHIPIO_8051_IRAM_WRITE        = 0x709,
763         VENDOR_CHIPIO_8051_IRAM_READ         = 0xF09,
764
765         VENDOR_CHIPIO_CT_EXTENSIONS_ENABLE   = 0x70A,
766         VENDOR_CHIPIO_CT_EXTENSIONS_GET      = 0xF0A,
767
768         VENDOR_CHIPIO_PLL_PMU_WRITE          = 0x70C,
769         VENDOR_CHIPIO_PLL_PMU_READ           = 0xF0C,
770         VENDOR_CHIPIO_8051_ADDRESS_LOW       = 0x70D,
771         VENDOR_CHIPIO_8051_ADDRESS_HIGH      = 0x70E,
772         VENDOR_CHIPIO_FLAG_SET               = 0x70F,
773         VENDOR_CHIPIO_FLAGS_GET              = 0xF0F,
774         VENDOR_CHIPIO_PARAM_SET              = 0x710,
775         VENDOR_CHIPIO_PARAM_GET              = 0xF10,
776
777         VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET  = 0x711,
778         VENDOR_CHIPIO_PORT_ALLOC_SET         = 0x712,
779         VENDOR_CHIPIO_PORT_ALLOC_GET         = 0xF12,
780         VENDOR_CHIPIO_PORT_FREE_SET          = 0x713,
781
782         VENDOR_CHIPIO_PARAM_EX_ID_GET        = 0xF17,
783         VENDOR_CHIPIO_PARAM_EX_ID_SET        = 0x717,
784         VENDOR_CHIPIO_PARAM_EX_VALUE_GET     = 0xF18,
785         VENDOR_CHIPIO_PARAM_EX_VALUE_SET     = 0x718,
786
787         VENDOR_CHIPIO_DMIC_CTL_SET           = 0x788,
788         VENDOR_CHIPIO_DMIC_CTL_GET           = 0xF88,
789         VENDOR_CHIPIO_DMIC_PIN_SET           = 0x789,
790         VENDOR_CHIPIO_DMIC_PIN_GET           = 0xF89,
791         VENDOR_CHIPIO_DMIC_MCLK_SET          = 0x78A,
792         VENDOR_CHIPIO_DMIC_MCLK_GET          = 0xF8A,
793
794         VENDOR_CHIPIO_EAPD_SEL_SET           = 0x78D
795 };
796
797 /*
798  *  Control flag IDs
799  */
800 enum control_flag_id {
801         /* Connection manager stream setup is bypassed/enabled */
802         CONTROL_FLAG_C_MGR                  = 0,
803         /* DSP DMA is bypassed/enabled */
804         CONTROL_FLAG_DMA                    = 1,
805         /* 8051 'idle' mode is disabled/enabled */
806         CONTROL_FLAG_IDLE_ENABLE            = 2,
807         /* Tracker for the SPDIF-in path is bypassed/enabled */
808         CONTROL_FLAG_TRACKER                = 3,
809         /* DigitalOut to Spdif2Out connection is disabled/enabled */
810         CONTROL_FLAG_SPDIF2OUT              = 4,
811         /* Digital Microphone is disabled/enabled */
812         CONTROL_FLAG_DMIC                   = 5,
813         /* ADC_B rate is 48 kHz/96 kHz */
814         CONTROL_FLAG_ADC_B_96KHZ            = 6,
815         /* ADC_C rate is 48 kHz/96 kHz */
816         CONTROL_FLAG_ADC_C_96KHZ            = 7,
817         /* DAC rate is 48 kHz/96 kHz (affects all DACs) */
818         CONTROL_FLAG_DAC_96KHZ              = 8,
819         /* DSP rate is 48 kHz/96 kHz */
820         CONTROL_FLAG_DSP_96KHZ              = 9,
821         /* SRC clock is 98 MHz/196 MHz (196 MHz forces rate to 96 KHz) */
822         CONTROL_FLAG_SRC_CLOCK_196MHZ       = 10,
823         /* SRC rate is 48 kHz/96 kHz (48 kHz disabled when clock is 196 MHz) */
824         CONTROL_FLAG_SRC_RATE_96KHZ         = 11,
825         /* Decode Loop (DSP->SRC->DSP) is disabled/enabled */
826         CONTROL_FLAG_DECODE_LOOP            = 12,
827         /* De-emphasis filter on DAC-1 disabled/enabled */
828         CONTROL_FLAG_DAC1_DEEMPHASIS        = 13,
829         /* De-emphasis filter on DAC-2 disabled/enabled */
830         CONTROL_FLAG_DAC2_DEEMPHASIS        = 14,
831         /* De-emphasis filter on DAC-3 disabled/enabled */
832         CONTROL_FLAG_DAC3_DEEMPHASIS        = 15,
833         /* High-pass filter on ADC_B disabled/enabled */
834         CONTROL_FLAG_ADC_B_HIGH_PASS        = 16,
835         /* High-pass filter on ADC_C disabled/enabled */
836         CONTROL_FLAG_ADC_C_HIGH_PASS        = 17,
837         /* Common mode on Port_A disabled/enabled */
838         CONTROL_FLAG_PORT_A_COMMON_MODE     = 18,
839         /* Common mode on Port_D disabled/enabled */
840         CONTROL_FLAG_PORT_D_COMMON_MODE     = 19,
841         /* Impedance for ramp generator on Port_A 16 Ohm/10K Ohm */
842         CONTROL_FLAG_PORT_A_10KOHM_LOAD     = 20,
843         /* Impedance for ramp generator on Port_D, 16 Ohm/10K Ohm */
844         CONTROL_FLAG_PORT_D_10KOHM_LOAD     = 21,
845         /* ASI rate is 48kHz/96kHz */
846         CONTROL_FLAG_ASI_96KHZ              = 22,
847         /* DAC power settings able to control attached ports no/yes */
848         CONTROL_FLAG_DACS_CONTROL_PORTS     = 23,
849         /* Clock Stop OK reporting is disabled/enabled */
850         CONTROL_FLAG_CONTROL_STOP_OK_ENABLE = 24,
851         /* Number of control flags */
852         CONTROL_FLAGS_MAX = (CONTROL_FLAG_CONTROL_STOP_OK_ENABLE+1)
853 };
854
855 /*
856  * Control parameter IDs
857  */
858 enum control_param_id {
859         /* 0: None, 1: Mic1In*/
860         CONTROL_PARAM_VIP_SOURCE               = 1,
861         /* 0: force HDA, 1: allow DSP if HDA Spdif1Out stream is idle */
862         CONTROL_PARAM_SPDIF1_SOURCE            = 2,
863         /* Port A output stage gain setting to use when 16 Ohm output
864          * impedance is selected*/
865         CONTROL_PARAM_PORTA_160OHM_GAIN        = 8,
866         /* Port D output stage gain setting to use when 16 Ohm output
867          * impedance is selected*/
868         CONTROL_PARAM_PORTD_160OHM_GAIN        = 10,
869
870         /*
871          * This control param name was found in the 8051 memory, and makes
872          * sense given the fact the AE-5 uses it and has the ASI flag set.
873          */
874         CONTROL_PARAM_ASI                      = 23,
875
876         /* Stream Control */
877
878         /* Select stream with the given ID */
879         CONTROL_PARAM_STREAM_ID                = 24,
880         /* Source connection point for the selected stream */
881         CONTROL_PARAM_STREAM_SOURCE_CONN_POINT = 25,
882         /* Destination connection point for the selected stream */
883         CONTROL_PARAM_STREAM_DEST_CONN_POINT   = 26,
884         /* Number of audio channels in the selected stream */
885         CONTROL_PARAM_STREAMS_CHANNELS         = 27,
886         /*Enable control for the selected stream */
887         CONTROL_PARAM_STREAM_CONTROL           = 28,
888
889         /* Connection Point Control */
890
891         /* Select connection point with the given ID */
892         CONTROL_PARAM_CONN_POINT_ID            = 29,
893         /* Connection point sample rate */
894         CONTROL_PARAM_CONN_POINT_SAMPLE_RATE   = 30,
895
896         /* Node Control */
897
898         /* Select HDA node with the given ID */
899         CONTROL_PARAM_NODE_ID                  = 31
900 };
901
902 /*
903  *  Dsp Io Status codes
904  */
905 enum hda_vendor_status_dspio {
906         /* Success */
907         VENDOR_STATUS_DSPIO_OK                       = 0x00,
908         /* Busy, unable to accept new command, the host must retry */
909         VENDOR_STATUS_DSPIO_BUSY                     = 0x01,
910         /* SCP command queue is full */
911         VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL   = 0x02,
912         /* SCP response queue is empty */
913         VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY = 0x03
914 };
915
916 /*
917  *  Chip Io Status codes
918  */
919 enum hda_vendor_status_chipio {
920         /* Success */
921         VENDOR_STATUS_CHIPIO_OK   = 0x00,
922         /* Busy, unable to accept new command, the host must retry */
923         VENDOR_STATUS_CHIPIO_BUSY = 0x01
924 };
925
926 /*
927  *  CA0132 sample rate
928  */
929 enum ca0132_sample_rate {
930         SR_6_000        = 0x00,
931         SR_8_000        = 0x01,
932         SR_9_600        = 0x02,
933         SR_11_025       = 0x03,
934         SR_16_000       = 0x04,
935         SR_22_050       = 0x05,
936         SR_24_000       = 0x06,
937         SR_32_000       = 0x07,
938         SR_44_100       = 0x08,
939         SR_48_000       = 0x09,
940         SR_88_200       = 0x0A,
941         SR_96_000       = 0x0B,
942         SR_144_000      = 0x0C,
943         SR_176_400      = 0x0D,
944         SR_192_000      = 0x0E,
945         SR_384_000      = 0x0F,
946
947         SR_COUNT        = 0x10,
948
949         SR_RATE_UNKNOWN = 0x1F
950 };
951
952 enum dsp_download_state {
953         DSP_DOWNLOAD_FAILED = -1,
954         DSP_DOWNLOAD_INIT   = 0,
955         DSP_DOWNLOADING     = 1,
956         DSP_DOWNLOADED      = 2
957 };
958
959 /* retrieve parameters from hda format */
960 #define get_hdafmt_chs(fmt)     (fmt & 0xf)
961 #define get_hdafmt_bits(fmt)    ((fmt >> 4) & 0x7)
962 #define get_hdafmt_rate(fmt)    ((fmt >> 8) & 0x7f)
963 #define get_hdafmt_type(fmt)    ((fmt >> 15) & 0x1)
964
965 /*
966  * CA0132 specific
967  */
968
969 struct ca0132_spec {
970         const struct snd_kcontrol_new *mixers[5];
971         unsigned int num_mixers;
972         const struct hda_verb *base_init_verbs;
973         const struct hda_verb *base_exit_verbs;
974         const struct hda_verb *chip_init_verbs;
975         const struct hda_verb *desktop_init_verbs;
976         struct hda_verb *spec_init_verbs;
977         struct auto_pin_cfg autocfg;
978
979         /* Nodes configurations */
980         struct hda_multi_out multiout;
981         hda_nid_t out_pins[AUTO_CFG_MAX_OUTS];
982         hda_nid_t dacs[AUTO_CFG_MAX_OUTS];
983         unsigned int num_outputs;
984         hda_nid_t input_pins[AUTO_PIN_LAST];
985         hda_nid_t adcs[AUTO_PIN_LAST];
986         hda_nid_t dig_out;
987         hda_nid_t dig_in;
988         unsigned int num_inputs;
989         hda_nid_t shared_mic_nid;
990         hda_nid_t shared_out_nid;
991         hda_nid_t unsol_tag_hp;
992         hda_nid_t unsol_tag_front_hp; /* for desktop ca0132 codecs */
993         hda_nid_t unsol_tag_amic1;
994
995         /* chip access */
996         struct mutex chipio_mutex; /* chip access mutex */
997         u32 curr_chip_addx;
998
999         /* DSP download related */
1000         enum dsp_download_state dsp_state;
1001         unsigned int dsp_stream_id;
1002         unsigned int wait_scp;
1003         unsigned int wait_scp_header;
1004         unsigned int wait_num_data;
1005         unsigned int scp_resp_header;
1006         unsigned int scp_resp_data[4];
1007         unsigned int scp_resp_count;
1008         bool alt_firmware_present;
1009         bool startup_check_entered;
1010         bool dsp_reload;
1011
1012         /* mixer and effects related */
1013         unsigned char dmic_ctl;
1014         int cur_out_type;
1015         int cur_mic_type;
1016         long vnode_lvol[VNODES_COUNT];
1017         long vnode_rvol[VNODES_COUNT];
1018         long vnode_lswitch[VNODES_COUNT];
1019         long vnode_rswitch[VNODES_COUNT];
1020         long effects_switch[EFFECTS_COUNT];
1021         long voicefx_val;
1022         long cur_mic_boost;
1023         /* ca0132_alt control related values */
1024         unsigned char in_enum_val;
1025         unsigned char out_enum_val;
1026         unsigned char mic_boost_enum_val;
1027         unsigned char smart_volume_setting;
1028         long fx_ctl_val[EFFECT_LEVEL_SLIDERS];
1029         long xbass_xover_freq;
1030         long eq_preset_val;
1031         unsigned int tlv[4];
1032         struct hda_vmaster_mute_hook vmaster_mute;
1033         /* AE-5 Control values */
1034         unsigned char ae5_headphone_gain_val;
1035         unsigned char ae5_filter_val;
1036         /* ZxR Control Values */
1037         unsigned char zxr_gain_set;
1038
1039         struct hda_codec *codec;
1040         struct delayed_work unsol_hp_work;
1041         int quirk;
1042
1043 #ifdef ENABLE_TUNING_CONTROLS
1044         long cur_ctl_vals[TUNING_CTLS_COUNT];
1045 #endif
1046         /*
1047          * The Recon3D, Sound Blaster Z, Sound Blaster ZxR, and Sound Blaster
1048          * AE-5 all use PCI region 2 to toggle GPIO and other currently unknown
1049          * things.
1050          */
1051         bool use_pci_mmio;
1052         void __iomem *mem_base;
1053
1054         /*
1055          * Whether or not to use the alt functions like alt_select_out,
1056          * alt_select_in, etc. Only used on desktop codecs for now, because of
1057          * surround sound support.
1058          */
1059         bool use_alt_functions;
1060
1061         /*
1062          * Whether or not to use alt controls:  volume effect sliders, EQ
1063          * presets, smart volume presets, and new control names with FX prefix.
1064          * Renames PlayEnhancement and CrystalVoice too.
1065          */
1066         bool use_alt_controls;
1067 };
1068
1069 /*
1070  * CA0132 quirks table
1071  */
1072 enum {
1073         QUIRK_NONE,
1074         QUIRK_ALIENWARE,
1075         QUIRK_ALIENWARE_M17XR4,
1076         QUIRK_SBZ,
1077         QUIRK_ZXR,
1078         QUIRK_ZXR_DBPRO,
1079         QUIRK_R3DI,
1080         QUIRK_R3D,
1081         QUIRK_AE5,
1082 };
1083
1084 #ifdef CONFIG_PCI
1085 #define ca0132_quirk(spec)              ((spec)->quirk)
1086 #define ca0132_use_pci_mmio(spec)       ((spec)->use_pci_mmio)
1087 #define ca0132_use_alt_functions(spec)  ((spec)->use_alt_functions)
1088 #define ca0132_use_alt_controls(spec)   ((spec)->use_alt_controls)
1089 #else
1090 #define ca0132_quirk(spec)              ({ (void)(spec); QUIRK_NONE; })
1091 #define ca0132_use_alt_functions(spec)  ({ (void)(spec); false; })
1092 #define ca0132_use_pci_mmio(spec)       ({ (void)(spec); false; })
1093 #define ca0132_use_alt_controls(spec)   ({ (void)(spec); false; })
1094 #endif
1095
1096 static const struct hda_pintbl alienware_pincfgs[] = {
1097         { 0x0b, 0x90170110 }, /* Builtin Speaker */
1098         { 0x0c, 0x411111f0 }, /* N/A */
1099         { 0x0d, 0x411111f0 }, /* N/A */
1100         { 0x0e, 0x411111f0 }, /* N/A */
1101         { 0x0f, 0x0321101f }, /* HP */
1102         { 0x10, 0x411111f0 }, /* Headset?  disabled for now */
1103         { 0x11, 0x03a11021 }, /* Mic */
1104         { 0x12, 0xd5a30140 }, /* Builtin Mic */
1105         { 0x13, 0x411111f0 }, /* N/A */
1106         { 0x18, 0x411111f0 }, /* N/A */
1107         {}
1108 };
1109
1110 /* Sound Blaster Z pin configs taken from Windows Driver */
1111 static const struct hda_pintbl sbz_pincfgs[] = {
1112         { 0x0b, 0x01017010 }, /* Port G -- Lineout FRONT L/R */
1113         { 0x0c, 0x014510f0 }, /* SPDIF Out 1 */
1114         { 0x0d, 0x014510f0 }, /* Digital Out */
1115         { 0x0e, 0x01c510f0 }, /* SPDIF In */
1116         { 0x0f, 0x0221701f }, /* Port A -- BackPanel HP */
1117         { 0x10, 0x01017012 }, /* Port D -- Center/LFE or FP Hp */
1118         { 0x11, 0x01017014 }, /* Port B -- LineMicIn2 / Rear L/R */
1119         { 0x12, 0x01a170f0 }, /* Port C -- LineIn1 */
1120         { 0x13, 0x908700f0 }, /* What U Hear In*/
1121         { 0x18, 0x50d000f0 }, /* N/A */
1122         {}
1123 };
1124
1125 /* Sound Blaster ZxR pin configs taken from Windows Driver */
1126 static const struct hda_pintbl zxr_pincfgs[] = {
1127         { 0x0b, 0x01047110 }, /* Port G -- Lineout FRONT L/R */
1128         { 0x0c, 0x414510f0 }, /* SPDIF Out 1 - Disabled*/
1129         { 0x0d, 0x014510f0 }, /* Digital Out */
1130         { 0x0e, 0x41c520f0 }, /* SPDIF In - Disabled*/
1131         { 0x0f, 0x0122711f }, /* Port A -- BackPanel HP */
1132         { 0x10, 0x01017111 }, /* Port D -- Center/LFE */
1133         { 0x11, 0x01017114 }, /* Port B -- LineMicIn2 / Rear L/R */
1134         { 0x12, 0x01a271f0 }, /* Port C -- LineIn1 */
1135         { 0x13, 0x908700f0 }, /* What U Hear In*/
1136         { 0x18, 0x50d000f0 }, /* N/A */
1137         {}
1138 };
1139
1140 /* Recon3D pin configs taken from Windows Driver */
1141 static const struct hda_pintbl r3d_pincfgs[] = {
1142         { 0x0b, 0x01014110 }, /* Port G -- Lineout FRONT L/R */
1143         { 0x0c, 0x014510f0 }, /* SPDIF Out 1 */
1144         { 0x0d, 0x014510f0 }, /* Digital Out */
1145         { 0x0e, 0x01c520f0 }, /* SPDIF In */
1146         { 0x0f, 0x0221401f }, /* Port A -- BackPanel HP */
1147         { 0x10, 0x01016011 }, /* Port D -- Center/LFE or FP Hp */
1148         { 0x11, 0x01011014 }, /* Port B -- LineMicIn2 / Rear L/R */
1149         { 0x12, 0x02a090f0 }, /* Port C -- LineIn1 */
1150         { 0x13, 0x908700f0 }, /* What U Hear In*/
1151         { 0x18, 0x50d000f0 }, /* N/A */
1152         {}
1153 };
1154
1155 /* Sound Blaster AE-5 pin configs taken from Windows Driver */
1156 static const struct hda_pintbl ae5_pincfgs[] = {
1157         { 0x0b, 0x01017010 }, /* Port G -- Lineout FRONT L/R */
1158         { 0x0c, 0x014510f0 }, /* SPDIF Out 1 */
1159         { 0x0d, 0x014510f0 }, /* Digital Out */
1160         { 0x0e, 0x01c510f0 }, /* SPDIF In */
1161         { 0x0f, 0x01017114 }, /* Port A -- Rear L/R. */
1162         { 0x10, 0x01017012 }, /* Port D -- Center/LFE or FP Hp */
1163         { 0x11, 0x01a170ff }, /* Port B -- LineMicIn2 / Rear Headphone */
1164         { 0x12, 0x01a170f0 }, /* Port C -- LineIn1 */
1165         { 0x13, 0x908700f0 }, /* What U Hear In*/
1166         { 0x18, 0x50d000f0 }, /* N/A */
1167         {}
1168 };
1169
1170 /* Recon3D integrated pin configs taken from Windows Driver */
1171 static const struct hda_pintbl r3di_pincfgs[] = {
1172         { 0x0b, 0x01014110 }, /* Port G -- Lineout FRONT L/R */
1173         { 0x0c, 0x014510f0 }, /* SPDIF Out 1 */
1174         { 0x0d, 0x014510f0 }, /* Digital Out */
1175         { 0x0e, 0x41c520f0 }, /* SPDIF In */
1176         { 0x0f, 0x0221401f }, /* Port A -- BackPanel HP */
1177         { 0x10, 0x01016011 }, /* Port D -- Center/LFE or FP Hp */
1178         { 0x11, 0x01011014 }, /* Port B -- LineMicIn2 / Rear L/R */
1179         { 0x12, 0x02a090f0 }, /* Port C -- LineIn1 */
1180         { 0x13, 0x908700f0 }, /* What U Hear In*/
1181         { 0x18, 0x500000f0 }, /* N/A */
1182         {}
1183 };
1184
1185 static const struct snd_pci_quirk ca0132_quirks[] = {
1186         SND_PCI_QUIRK(0x1028, 0x057b, "Alienware M17x R4", QUIRK_ALIENWARE_M17XR4),
1187         SND_PCI_QUIRK(0x1028, 0x0685, "Alienware 15 2015", QUIRK_ALIENWARE),
1188         SND_PCI_QUIRK(0x1028, 0x0688, "Alienware 17 2015", QUIRK_ALIENWARE),
1189         SND_PCI_QUIRK(0x1028, 0x0708, "Alienware 15 R2 2016", QUIRK_ALIENWARE),
1190         SND_PCI_QUIRK(0x1102, 0x0010, "Sound Blaster Z", QUIRK_SBZ),
1191         SND_PCI_QUIRK(0x1102, 0x0023, "Sound Blaster Z", QUIRK_SBZ),
1192         SND_PCI_QUIRK(0x1102, 0x0033, "Sound Blaster ZxR", QUIRK_SBZ),
1193         SND_PCI_QUIRK(0x1458, 0xA016, "Recon3Di", QUIRK_R3DI),
1194         SND_PCI_QUIRK(0x1458, 0xA026, "Gigabyte G1.Sniper Z97", QUIRK_R3DI),
1195         SND_PCI_QUIRK(0x1458, 0xA036, "Gigabyte GA-Z170X-Gaming 7", QUIRK_R3DI),
1196         SND_PCI_QUIRK(0x1102, 0x0013, "Recon3D", QUIRK_R3D),
1197         SND_PCI_QUIRK(0x1102, 0x0051, "Sound Blaster AE-5", QUIRK_AE5),
1198         {}
1199 };
1200
1201 /*
1202  * CA0132 codec access
1203  */
1204 static unsigned int codec_send_command(struct hda_codec *codec, hda_nid_t nid,
1205                 unsigned int verb, unsigned int parm, unsigned int *res)
1206 {
1207         unsigned int response;
1208         response = snd_hda_codec_read(codec, nid, 0, verb, parm);
1209         *res = response;
1210
1211         return ((response == -1) ? -1 : 0);
1212 }
1213
1214 static int codec_set_converter_format(struct hda_codec *codec, hda_nid_t nid,
1215                 unsigned short converter_format, unsigned int *res)
1216 {
1217         return codec_send_command(codec, nid, VENDOR_CHIPIO_STREAM_FORMAT,
1218                                 converter_format & 0xffff, res);
1219 }
1220
1221 static int codec_set_converter_stream_channel(struct hda_codec *codec,
1222                                 hda_nid_t nid, unsigned char stream,
1223                                 unsigned char channel, unsigned int *res)
1224 {
1225         unsigned char converter_stream_channel = 0;
1226
1227         converter_stream_channel = (stream << 4) | (channel & 0x0f);
1228         return codec_send_command(codec, nid, AC_VERB_SET_CHANNEL_STREAMID,
1229                                 converter_stream_channel, res);
1230 }
1231
1232 /* Chip access helper function */
1233 static int chipio_send(struct hda_codec *codec,
1234                        unsigned int reg,
1235                        unsigned int data)
1236 {
1237         unsigned int res;
1238         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1239
1240         /* send bits of data specified by reg */
1241         do {
1242                 res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
1243                                          reg, data);
1244                 if (res == VENDOR_STATUS_CHIPIO_OK)
1245                         return 0;
1246                 msleep(20);
1247         } while (time_before(jiffies, timeout));
1248
1249         return -EIO;
1250 }
1251
1252 /*
1253  * Write chip address through the vendor widget -- NOT protected by the Mutex!
1254  */
1255 static int chipio_write_address(struct hda_codec *codec,
1256                                 unsigned int chip_addx)
1257 {
1258         struct ca0132_spec *spec = codec->spec;
1259         int res;
1260
1261         if (spec->curr_chip_addx == chip_addx)
1262                         return 0;
1263
1264         /* send low 16 bits of the address */
1265         res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_LOW,
1266                           chip_addx & 0xffff);
1267
1268         if (res != -EIO) {
1269                 /* send high 16 bits of the address */
1270                 res = chipio_send(codec, VENDOR_CHIPIO_ADDRESS_HIGH,
1271                                   chip_addx >> 16);
1272         }
1273
1274         spec->curr_chip_addx = (res < 0) ? ~0U : chip_addx;
1275
1276         return res;
1277 }
1278
1279 /*
1280  * Write data through the vendor widget -- NOT protected by the Mutex!
1281  */
1282 static int chipio_write_data(struct hda_codec *codec, unsigned int data)
1283 {
1284         struct ca0132_spec *spec = codec->spec;
1285         int res;
1286
1287         /* send low 16 bits of the data */
1288         res = chipio_send(codec, VENDOR_CHIPIO_DATA_LOW, data & 0xffff);
1289
1290         if (res != -EIO) {
1291                 /* send high 16 bits of the data */
1292                 res = chipio_send(codec, VENDOR_CHIPIO_DATA_HIGH,
1293                                   data >> 16);
1294         }
1295
1296         /*If no error encountered, automatically increment the address
1297         as per chip behaviour*/
1298         spec->curr_chip_addx = (res != -EIO) ?
1299                                         (spec->curr_chip_addx + 4) : ~0U;
1300         return res;
1301 }
1302
1303 /*
1304  * Write multiple data through the vendor widget -- NOT protected by the Mutex!
1305  */
1306 static int chipio_write_data_multiple(struct hda_codec *codec,
1307                                       const u32 *data,
1308                                       unsigned int count)
1309 {
1310         int status = 0;
1311
1312         if (data == NULL) {
1313                 codec_dbg(codec, "chipio_write_data null ptr\n");
1314                 return -EINVAL;
1315         }
1316
1317         while ((count-- != 0) && (status == 0))
1318                 status = chipio_write_data(codec, *data++);
1319
1320         return status;
1321 }
1322
1323
1324 /*
1325  * Read data through the vendor widget -- NOT protected by the Mutex!
1326  */
1327 static int chipio_read_data(struct hda_codec *codec, unsigned int *data)
1328 {
1329         struct ca0132_spec *spec = codec->spec;
1330         int res;
1331
1332         /* post read */
1333         res = chipio_send(codec, VENDOR_CHIPIO_HIC_POST_READ, 0);
1334
1335         if (res != -EIO) {
1336                 /* read status */
1337                 res = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
1338         }
1339
1340         if (res != -EIO) {
1341                 /* read data */
1342                 *data = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
1343                                            VENDOR_CHIPIO_HIC_READ_DATA,
1344                                            0);
1345         }
1346
1347         /*If no error encountered, automatically increment the address
1348         as per chip behaviour*/
1349         spec->curr_chip_addx = (res != -EIO) ?
1350                                         (spec->curr_chip_addx + 4) : ~0U;
1351         return res;
1352 }
1353
1354 /*
1355  * Write given value to the given address through the chip I/O widget.
1356  * protected by the Mutex
1357  */
1358 static int chipio_write(struct hda_codec *codec,
1359                 unsigned int chip_addx, const unsigned int data)
1360 {
1361         struct ca0132_spec *spec = codec->spec;
1362         int err;
1363
1364         mutex_lock(&spec->chipio_mutex);
1365
1366         /* write the address, and if successful proceed to write data */
1367         err = chipio_write_address(codec, chip_addx);
1368         if (err < 0)
1369                 goto exit;
1370
1371         err = chipio_write_data(codec, data);
1372         if (err < 0)
1373                 goto exit;
1374
1375 exit:
1376         mutex_unlock(&spec->chipio_mutex);
1377         return err;
1378 }
1379
1380 /*
1381  * Write given value to the given address through the chip I/O widget.
1382  * not protected by the Mutex
1383  */
1384 static int chipio_write_no_mutex(struct hda_codec *codec,
1385                 unsigned int chip_addx, const unsigned int data)
1386 {
1387         int err;
1388
1389
1390         /* write the address, and if successful proceed to write data */
1391         err = chipio_write_address(codec, chip_addx);
1392         if (err < 0)
1393                 goto exit;
1394
1395         err = chipio_write_data(codec, data);
1396         if (err < 0)
1397                 goto exit;
1398
1399 exit:
1400         return err;
1401 }
1402
1403 /*
1404  * Write multiple values to the given address through the chip I/O widget.
1405  * protected by the Mutex
1406  */
1407 static int chipio_write_multiple(struct hda_codec *codec,
1408                                  u32 chip_addx,
1409                                  const u32 *data,
1410                                  unsigned int count)
1411 {
1412         struct ca0132_spec *spec = codec->spec;
1413         int status;
1414
1415         mutex_lock(&spec->chipio_mutex);
1416         status = chipio_write_address(codec, chip_addx);
1417         if (status < 0)
1418                 goto error;
1419
1420         status = chipio_write_data_multiple(codec, data, count);
1421 error:
1422         mutex_unlock(&spec->chipio_mutex);
1423
1424         return status;
1425 }
1426
1427 /*
1428  * Read the given address through the chip I/O widget
1429  * protected by the Mutex
1430  */
1431 static int chipio_read(struct hda_codec *codec,
1432                 unsigned int chip_addx, unsigned int *data)
1433 {
1434         struct ca0132_spec *spec = codec->spec;
1435         int err;
1436
1437         mutex_lock(&spec->chipio_mutex);
1438
1439         /* write the address, and if successful proceed to write data */
1440         err = chipio_write_address(codec, chip_addx);
1441         if (err < 0)
1442                 goto exit;
1443
1444         err = chipio_read_data(codec, data);
1445         if (err < 0)
1446                 goto exit;
1447
1448 exit:
1449         mutex_unlock(&spec->chipio_mutex);
1450         return err;
1451 }
1452
1453 /*
1454  * Set chip control flags through the chip I/O widget.
1455  */
1456 static void chipio_set_control_flag(struct hda_codec *codec,
1457                                     enum control_flag_id flag_id,
1458                                     bool flag_state)
1459 {
1460         unsigned int val;
1461         unsigned int flag_bit;
1462
1463         flag_bit = (flag_state ? 1 : 0);
1464         val = (flag_bit << 7) | (flag_id);
1465         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1466                             VENDOR_CHIPIO_FLAG_SET, val);
1467 }
1468
1469 /*
1470  * Set chip parameters through the chip I/O widget.
1471  */
1472 static void chipio_set_control_param(struct hda_codec *codec,
1473                 enum control_param_id param_id, int param_val)
1474 {
1475         struct ca0132_spec *spec = codec->spec;
1476         int val;
1477
1478         if ((param_id < 32) && (param_val < 8)) {
1479                 val = (param_val << 5) | (param_id);
1480                 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1481                                     VENDOR_CHIPIO_PARAM_SET, val);
1482         } else {
1483                 mutex_lock(&spec->chipio_mutex);
1484                 if (chipio_send(codec, VENDOR_CHIPIO_STATUS, 0) == 0) {
1485                         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1486                                             VENDOR_CHIPIO_PARAM_EX_ID_SET,
1487                                             param_id);
1488                         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1489                                             VENDOR_CHIPIO_PARAM_EX_VALUE_SET,
1490                                             param_val);
1491                 }
1492                 mutex_unlock(&spec->chipio_mutex);
1493         }
1494 }
1495
1496 /*
1497  * Set chip parameters through the chip I/O widget. NO MUTEX.
1498  */
1499 static void chipio_set_control_param_no_mutex(struct hda_codec *codec,
1500                 enum control_param_id param_id, int param_val)
1501 {
1502         int val;
1503
1504         if ((param_id < 32) && (param_val < 8)) {
1505                 val = (param_val << 5) | (param_id);
1506                 snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1507                                     VENDOR_CHIPIO_PARAM_SET, val);
1508         } else {
1509                 if (chipio_send(codec, VENDOR_CHIPIO_STATUS, 0) == 0) {
1510                         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1511                                             VENDOR_CHIPIO_PARAM_EX_ID_SET,
1512                                             param_id);
1513                         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1514                                             VENDOR_CHIPIO_PARAM_EX_VALUE_SET,
1515                                             param_val);
1516                 }
1517         }
1518 }
1519 /*
1520  * Connect stream to a source point, and then connect
1521  * that source point to a destination point.
1522  */
1523 static void chipio_set_stream_source_dest(struct hda_codec *codec,
1524                                 int streamid, int source_point, int dest_point)
1525 {
1526         chipio_set_control_param_no_mutex(codec,
1527                         CONTROL_PARAM_STREAM_ID, streamid);
1528         chipio_set_control_param_no_mutex(codec,
1529                         CONTROL_PARAM_STREAM_SOURCE_CONN_POINT, source_point);
1530         chipio_set_control_param_no_mutex(codec,
1531                         CONTROL_PARAM_STREAM_DEST_CONN_POINT, dest_point);
1532 }
1533
1534 /*
1535  * Set number of channels in the selected stream.
1536  */
1537 static void chipio_set_stream_channels(struct hda_codec *codec,
1538                                 int streamid, unsigned int channels)
1539 {
1540         chipio_set_control_param_no_mutex(codec,
1541                         CONTROL_PARAM_STREAM_ID, streamid);
1542         chipio_set_control_param_no_mutex(codec,
1543                         CONTROL_PARAM_STREAMS_CHANNELS, channels);
1544 }
1545
1546 /*
1547  * Enable/Disable audio stream.
1548  */
1549 static void chipio_set_stream_control(struct hda_codec *codec,
1550                                 int streamid, int enable)
1551 {
1552         chipio_set_control_param_no_mutex(codec,
1553                         CONTROL_PARAM_STREAM_ID, streamid);
1554         chipio_set_control_param_no_mutex(codec,
1555                         CONTROL_PARAM_STREAM_CONTROL, enable);
1556 }
1557
1558
1559 /*
1560  * Set sampling rate of the connection point. NO MUTEX.
1561  */
1562 static void chipio_set_conn_rate_no_mutex(struct hda_codec *codec,
1563                                 int connid, enum ca0132_sample_rate rate)
1564 {
1565         chipio_set_control_param_no_mutex(codec,
1566                         CONTROL_PARAM_CONN_POINT_ID, connid);
1567         chipio_set_control_param_no_mutex(codec,
1568                         CONTROL_PARAM_CONN_POINT_SAMPLE_RATE, rate);
1569 }
1570
1571 /*
1572  * Set sampling rate of the connection point.
1573  */
1574 static void chipio_set_conn_rate(struct hda_codec *codec,
1575                                 int connid, enum ca0132_sample_rate rate)
1576 {
1577         chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_ID, connid);
1578         chipio_set_control_param(codec, CONTROL_PARAM_CONN_POINT_SAMPLE_RATE,
1579                                  rate);
1580 }
1581
1582 /*
1583  * Writes to the 8051's internal address space directly instead of indirectly,
1584  * giving access to the special function registers located at addresses
1585  * 0x80-0xFF.
1586  */
1587 static void chipio_8051_write_direct(struct hda_codec *codec,
1588                 unsigned int addr, unsigned int data)
1589 {
1590         unsigned int verb;
1591
1592         verb = VENDOR_CHIPIO_8051_WRITE_DIRECT | data;
1593         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0, verb, addr);
1594 }
1595
1596 /*
1597  * Enable clocks.
1598  */
1599 static void chipio_enable_clocks(struct hda_codec *codec)
1600 {
1601         struct ca0132_spec *spec = codec->spec;
1602
1603         mutex_lock(&spec->chipio_mutex);
1604         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1605                             VENDOR_CHIPIO_8051_ADDRESS_LOW, 0);
1606         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1607                             VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff);
1608         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1609                             VENDOR_CHIPIO_8051_ADDRESS_LOW, 5);
1610         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1611                             VENDOR_CHIPIO_PLL_PMU_WRITE, 0x0b);
1612         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1613                             VENDOR_CHIPIO_8051_ADDRESS_LOW, 6);
1614         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
1615                             VENDOR_CHIPIO_PLL_PMU_WRITE, 0xff);
1616         mutex_unlock(&spec->chipio_mutex);
1617 }
1618
1619 /*
1620  * CA0132 DSP IO stuffs
1621  */
1622 static int dspio_send(struct hda_codec *codec, unsigned int reg,
1623                       unsigned int data)
1624 {
1625         int res;
1626         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1627
1628         /* send bits of data specified by reg to dsp */
1629         do {
1630                 res = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0, reg, data);
1631                 if ((res >= 0) && (res != VENDOR_STATUS_DSPIO_BUSY))
1632                         return res;
1633                 msleep(20);
1634         } while (time_before(jiffies, timeout));
1635
1636         return -EIO;
1637 }
1638
1639 /*
1640  * Wait for DSP to be ready for commands
1641  */
1642 static void dspio_write_wait(struct hda_codec *codec)
1643 {
1644         int status;
1645         unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1646
1647         do {
1648                 status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1649                                                 VENDOR_DSPIO_STATUS, 0);
1650                 if ((status == VENDOR_STATUS_DSPIO_OK) ||
1651                     (status == VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY))
1652                         break;
1653                 msleep(1);
1654         } while (time_before(jiffies, timeout));
1655 }
1656
1657 /*
1658  * Write SCP data to DSP
1659  */
1660 static int dspio_write(struct hda_codec *codec, unsigned int scp_data)
1661 {
1662         struct ca0132_spec *spec = codec->spec;
1663         int status;
1664
1665         dspio_write_wait(codec);
1666
1667         mutex_lock(&spec->chipio_mutex);
1668         status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_LOW,
1669                             scp_data & 0xffff);
1670         if (status < 0)
1671                 goto error;
1672
1673         status = dspio_send(codec, VENDOR_DSPIO_SCP_WRITE_DATA_HIGH,
1674                                     scp_data >> 16);
1675         if (status < 0)
1676                 goto error;
1677
1678         /* OK, now check if the write itself has executed*/
1679         status = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1680                                     VENDOR_DSPIO_STATUS, 0);
1681 error:
1682         mutex_unlock(&spec->chipio_mutex);
1683
1684         return (status == VENDOR_STATUS_DSPIO_SCP_COMMAND_QUEUE_FULL) ?
1685                         -EIO : 0;
1686 }
1687
1688 /*
1689  * Write multiple SCP data to DSP
1690  */
1691 static int dspio_write_multiple(struct hda_codec *codec,
1692                                 unsigned int *buffer, unsigned int size)
1693 {
1694         int status = 0;
1695         unsigned int count;
1696
1697         if (buffer == NULL)
1698                 return -EINVAL;
1699
1700         count = 0;
1701         while (count < size) {
1702                 status = dspio_write(codec, *buffer++);
1703                 if (status != 0)
1704                         break;
1705                 count++;
1706         }
1707
1708         return status;
1709 }
1710
1711 static int dspio_read(struct hda_codec *codec, unsigned int *data)
1712 {
1713         int status;
1714
1715         status = dspio_send(codec, VENDOR_DSPIO_SCP_POST_READ_DATA, 0);
1716         if (status == -EIO)
1717                 return status;
1718
1719         status = dspio_send(codec, VENDOR_DSPIO_STATUS, 0);
1720         if (status == -EIO ||
1721             status == VENDOR_STATUS_DSPIO_SCP_RESPONSE_QUEUE_EMPTY)
1722                 return -EIO;
1723
1724         *data = snd_hda_codec_read(codec, WIDGET_DSP_CTRL, 0,
1725                                    VENDOR_DSPIO_SCP_READ_DATA, 0);
1726
1727         return 0;
1728 }
1729
1730 static int dspio_read_multiple(struct hda_codec *codec, unsigned int *buffer,
1731                                unsigned int *buf_size, unsigned int size_count)
1732 {
1733         int status = 0;
1734         unsigned int size = *buf_size;
1735         unsigned int count;
1736         unsigned int skip_count;
1737         unsigned int dummy;
1738
1739         if (buffer == NULL)
1740                 return -1;
1741
1742         count = 0;
1743         while (count < size && count < size_count) {
1744                 status = dspio_read(codec, buffer++);
1745                 if (status != 0)
1746                         break;
1747                 count++;
1748         }
1749
1750         skip_count = count;
1751         if (status == 0) {
1752                 while (skip_count < size) {
1753                         status = dspio_read(codec, &dummy);
1754                         if (status != 0)
1755                                 break;
1756                         skip_count++;
1757                 }
1758         }
1759         *buf_size = count;
1760
1761         return status;
1762 }
1763
1764 /*
1765  * Construct the SCP header using corresponding fields
1766  */
1767 static inline unsigned int
1768 make_scp_header(unsigned int target_id, unsigned int source_id,
1769                 unsigned int get_flag, unsigned int req,
1770                 unsigned int device_flag, unsigned int resp_flag,
1771                 unsigned int error_flag, unsigned int data_size)
1772 {
1773         unsigned int header = 0;
1774
1775         header = (data_size & 0x1f) << 27;
1776         header |= (error_flag & 0x01) << 26;
1777         header |= (resp_flag & 0x01) << 25;
1778         header |= (device_flag & 0x01) << 24;
1779         header |= (req & 0x7f) << 17;
1780         header |= (get_flag & 0x01) << 16;
1781         header |= (source_id & 0xff) << 8;
1782         header |= target_id & 0xff;
1783
1784         return header;
1785 }
1786
1787 /*
1788  * Extract corresponding fields from SCP header
1789  */
1790 static inline void
1791 extract_scp_header(unsigned int header,
1792                    unsigned int *target_id, unsigned int *source_id,
1793                    unsigned int *get_flag, unsigned int *req,
1794                    unsigned int *device_flag, unsigned int *resp_flag,
1795                    unsigned int *error_flag, unsigned int *data_size)
1796 {
1797         if (data_size)
1798                 *data_size = (header >> 27) & 0x1f;
1799         if (error_flag)
1800                 *error_flag = (header >> 26) & 0x01;
1801         if (resp_flag)
1802                 *resp_flag = (header >> 25) & 0x01;
1803         if (device_flag)
1804                 *device_flag = (header >> 24) & 0x01;
1805         if (req)
1806                 *req = (header >> 17) & 0x7f;
1807         if (get_flag)
1808                 *get_flag = (header >> 16) & 0x01;
1809         if (source_id)
1810                 *source_id = (header >> 8) & 0xff;
1811         if (target_id)
1812                 *target_id = header & 0xff;
1813 }
1814
1815 #define SCP_MAX_DATA_WORDS  (16)
1816
1817 /* Structure to contain any SCP message */
1818 struct scp_msg {
1819         unsigned int hdr;
1820         unsigned int data[SCP_MAX_DATA_WORDS];
1821 };
1822
1823 static void dspio_clear_response_queue(struct hda_codec *codec)
1824 {
1825         unsigned int dummy = 0;
1826         int status = -1;
1827
1828         /* clear all from the response queue */
1829         do {
1830                 status = dspio_read(codec, &dummy);
1831         } while (status == 0);
1832 }
1833
1834 static int dspio_get_response_data(struct hda_codec *codec)
1835 {
1836         struct ca0132_spec *spec = codec->spec;
1837         unsigned int data = 0;
1838         unsigned int count;
1839
1840         if (dspio_read(codec, &data) < 0)
1841                 return -EIO;
1842
1843         if ((data & 0x00ffffff) == spec->wait_scp_header) {
1844                 spec->scp_resp_header = data;
1845                 spec->scp_resp_count = data >> 27;
1846                 count = spec->wait_num_data;
1847                 dspio_read_multiple(codec, spec->scp_resp_data,
1848                                     &spec->scp_resp_count, count);
1849                 return 0;
1850         }
1851
1852         return -EIO;
1853 }
1854
1855 /*
1856  * Send SCP message to DSP
1857  */
1858 static int dspio_send_scp_message(struct hda_codec *codec,
1859                                   unsigned char *send_buf,
1860                                   unsigned int send_buf_size,
1861                                   unsigned char *return_buf,
1862                                   unsigned int return_buf_size,
1863                                   unsigned int *bytes_returned)
1864 {
1865         struct ca0132_spec *spec = codec->spec;
1866         int status = -1;
1867         unsigned int scp_send_size = 0;
1868         unsigned int total_size;
1869         bool waiting_for_resp = false;
1870         unsigned int header;
1871         struct scp_msg *ret_msg;
1872         unsigned int resp_src_id, resp_target_id;
1873         unsigned int data_size, src_id, target_id, get_flag, device_flag;
1874
1875         if (bytes_returned)
1876                 *bytes_returned = 0;
1877
1878         /* get scp header from buffer */
1879         header = *((unsigned int *)send_buf);
1880         extract_scp_header(header, &target_id, &src_id, &get_flag, NULL,
1881                            &device_flag, NULL, NULL, &data_size);
1882         scp_send_size = data_size + 1;
1883         total_size = (scp_send_size * 4);
1884
1885         if (send_buf_size < total_size)
1886                 return -EINVAL;
1887
1888         if (get_flag || device_flag) {
1889                 if (!return_buf || return_buf_size < 4 || !bytes_returned)
1890                         return -EINVAL;
1891
1892                 spec->wait_scp_header = *((unsigned int *)send_buf);
1893
1894                 /* swap source id with target id */
1895                 resp_target_id = src_id;
1896                 resp_src_id = target_id;
1897                 spec->wait_scp_header &= 0xffff0000;
1898                 spec->wait_scp_header |= (resp_src_id << 8) | (resp_target_id);
1899                 spec->wait_num_data = return_buf_size/sizeof(unsigned int) - 1;
1900                 spec->wait_scp = 1;
1901                 waiting_for_resp = true;
1902         }
1903
1904         status = dspio_write_multiple(codec, (unsigned int *)send_buf,
1905                                       scp_send_size);
1906         if (status < 0) {
1907                 spec->wait_scp = 0;
1908                 return status;
1909         }
1910
1911         if (waiting_for_resp) {
1912                 unsigned long timeout = jiffies + msecs_to_jiffies(1000);
1913                 memset(return_buf, 0, return_buf_size);
1914                 do {
1915                         msleep(20);
1916                 } while (spec->wait_scp && time_before(jiffies, timeout));
1917                 waiting_for_resp = false;
1918                 if (!spec->wait_scp) {
1919                         ret_msg = (struct scp_msg *)return_buf;
1920                         memcpy(&ret_msg->hdr, &spec->scp_resp_header, 4);
1921                         memcpy(&ret_msg->data, spec->scp_resp_data,
1922                                spec->wait_num_data);
1923                         *bytes_returned = (spec->scp_resp_count + 1) * 4;
1924                         status = 0;
1925                 } else {
1926                         status = -EIO;
1927                 }
1928                 spec->wait_scp = 0;
1929         }
1930
1931         return status;
1932 }
1933
1934 /**
1935  * Prepare and send the SCP message to DSP
1936  * @codec: the HDA codec
1937  * @mod_id: ID of the DSP module to send the command
1938  * @req: ID of request to send to the DSP module
1939  * @dir: SET or GET
1940  * @data: pointer to the data to send with the request, request specific
1941  * @len: length of the data, in bytes
1942  * @reply: point to the buffer to hold data returned for a reply
1943  * @reply_len: length of the reply buffer returned from GET
1944  *
1945  * Returns zero or a negative error code.
1946  */
1947 static int dspio_scp(struct hda_codec *codec,
1948                 int mod_id, int src_id, int req, int dir, const void *data,
1949                 unsigned int len, void *reply, unsigned int *reply_len)
1950 {
1951         int status = 0;
1952         struct scp_msg scp_send, scp_reply;
1953         unsigned int ret_bytes, send_size, ret_size;
1954         unsigned int send_get_flag, reply_resp_flag, reply_error_flag;
1955         unsigned int reply_data_size;
1956
1957         memset(&scp_send, 0, sizeof(scp_send));
1958         memset(&scp_reply, 0, sizeof(scp_reply));
1959
1960         if ((len != 0 && data == NULL) || (len > SCP_MAX_DATA_WORDS))
1961                 return -EINVAL;
1962
1963         if (dir == SCP_GET && reply == NULL) {
1964                 codec_dbg(codec, "dspio_scp get but has no buffer\n");
1965                 return -EINVAL;
1966         }
1967
1968         if (reply != NULL && (reply_len == NULL || (*reply_len == 0))) {
1969                 codec_dbg(codec, "dspio_scp bad resp buf len parms\n");
1970                 return -EINVAL;
1971         }
1972
1973         scp_send.hdr = make_scp_header(mod_id, src_id, (dir == SCP_GET), req,
1974                                        0, 0, 0, len/sizeof(unsigned int));
1975         if (data != NULL && len > 0) {
1976                 len = min((unsigned int)(sizeof(scp_send.data)), len);
1977                 memcpy(scp_send.data, data, len);
1978         }
1979
1980         ret_bytes = 0;
1981         send_size = sizeof(unsigned int) + len;
1982         status = dspio_send_scp_message(codec, (unsigned char *)&scp_send,
1983                                         send_size, (unsigned char *)&scp_reply,
1984                                         sizeof(scp_reply), &ret_bytes);
1985
1986         if (status < 0) {
1987                 codec_dbg(codec, "dspio_scp: send scp msg failed\n");
1988                 return status;
1989         }
1990
1991         /* extract send and reply headers members */
1992         extract_scp_header(scp_send.hdr, NULL, NULL, &send_get_flag,
1993                            NULL, NULL, NULL, NULL, NULL);
1994         extract_scp_header(scp_reply.hdr, NULL, NULL, NULL, NULL, NULL,
1995                            &reply_resp_flag, &reply_error_flag,
1996                            &reply_data_size);
1997
1998         if (!send_get_flag)
1999                 return 0;
2000
2001         if (reply_resp_flag && !reply_error_flag) {
2002                 ret_size = (ret_bytes - sizeof(scp_reply.hdr))
2003                                         / sizeof(unsigned int);
2004
2005                 if (*reply_len < ret_size*sizeof(unsigned int)) {
2006                         codec_dbg(codec, "reply too long for buf\n");
2007                         return -EINVAL;
2008                 } else if (ret_size != reply_data_size) {
2009                         codec_dbg(codec, "RetLen and HdrLen .NE.\n");
2010                         return -EINVAL;
2011                 } else if (!reply) {
2012                         codec_dbg(codec, "NULL reply\n");
2013                         return -EINVAL;
2014                 } else {
2015                         *reply_len = ret_size*sizeof(unsigned int);
2016                         memcpy(reply, scp_reply.data, *reply_len);
2017                 }
2018         } else {
2019                 codec_dbg(codec, "reply ill-formed or errflag set\n");
2020                 return -EIO;
2021         }
2022
2023         return status;
2024 }
2025
2026 /*
2027  * Set DSP parameters
2028  */
2029 static int dspio_set_param(struct hda_codec *codec, int mod_id,
2030                         int src_id, int req, const void *data, unsigned int len)
2031 {
2032         return dspio_scp(codec, mod_id, src_id, req, SCP_SET, data, len, NULL,
2033                         NULL);
2034 }
2035
2036 static int dspio_set_uint_param(struct hda_codec *codec, int mod_id,
2037                         int req, const unsigned int data)
2038 {
2039         return dspio_set_param(codec, mod_id, 0x20, req, &data,
2040                         sizeof(unsigned int));
2041 }
2042
2043 static int dspio_set_uint_param_no_source(struct hda_codec *codec, int mod_id,
2044                         int req, const unsigned int data)
2045 {
2046         return dspio_set_param(codec, mod_id, 0x00, req, &data,
2047                         sizeof(unsigned int));
2048 }
2049
2050 /*
2051  * Allocate a DSP DMA channel via an SCP message
2052  */
2053 static int dspio_alloc_dma_chan(struct hda_codec *codec, unsigned int *dma_chan)
2054 {
2055         int status = 0;
2056         unsigned int size = sizeof(dma_chan);
2057
2058         codec_dbg(codec, "     dspio_alloc_dma_chan() -- begin\n");
2059         status = dspio_scp(codec, MASTERCONTROL, 0x20,
2060                         MASTERCONTROL_ALLOC_DMA_CHAN, SCP_GET, NULL, 0,
2061                         dma_chan, &size);
2062
2063         if (status < 0) {
2064                 codec_dbg(codec, "dspio_alloc_dma_chan: SCP Failed\n");
2065                 return status;
2066         }
2067
2068         if ((*dma_chan + 1) == 0) {
2069                 codec_dbg(codec, "no free dma channels to allocate\n");
2070                 return -EBUSY;
2071         }
2072
2073         codec_dbg(codec, "dspio_alloc_dma_chan: chan=%d\n", *dma_chan);
2074         codec_dbg(codec, "     dspio_alloc_dma_chan() -- complete\n");
2075
2076         return status;
2077 }
2078
2079 /*
2080  * Free a DSP DMA via an SCP message
2081  */
2082 static int dspio_free_dma_chan(struct hda_codec *codec, unsigned int dma_chan)
2083 {
2084         int status = 0;
2085         unsigned int dummy = 0;
2086
2087         codec_dbg(codec, "     dspio_free_dma_chan() -- begin\n");
2088         codec_dbg(codec, "dspio_free_dma_chan: chan=%d\n", dma_chan);
2089
2090         status = dspio_scp(codec, MASTERCONTROL, 0x20,
2091                         MASTERCONTROL_ALLOC_DMA_CHAN, SCP_SET, &dma_chan,
2092                         sizeof(dma_chan), NULL, &dummy);
2093
2094         if (status < 0) {
2095                 codec_dbg(codec, "dspio_free_dma_chan: SCP Failed\n");
2096                 return status;
2097         }
2098
2099         codec_dbg(codec, "     dspio_free_dma_chan() -- complete\n");
2100
2101         return status;
2102 }
2103
2104 /*
2105  * (Re)start the DSP
2106  */
2107 static int dsp_set_run_state(struct hda_codec *codec)
2108 {
2109         unsigned int dbg_ctrl_reg;
2110         unsigned int halt_state;
2111         int err;
2112
2113         err = chipio_read(codec, DSP_DBGCNTL_INST_OFFSET, &dbg_ctrl_reg);
2114         if (err < 0)
2115                 return err;
2116
2117         halt_state = (dbg_ctrl_reg & DSP_DBGCNTL_STATE_MASK) >>
2118                       DSP_DBGCNTL_STATE_LOBIT;
2119
2120         if (halt_state != 0) {
2121                 dbg_ctrl_reg &= ~((halt_state << DSP_DBGCNTL_SS_LOBIT) &
2122                                   DSP_DBGCNTL_SS_MASK);
2123                 err = chipio_write(codec, DSP_DBGCNTL_INST_OFFSET,
2124                                    dbg_ctrl_reg);
2125                 if (err < 0)
2126                         return err;
2127
2128                 dbg_ctrl_reg |= (halt_state << DSP_DBGCNTL_EXEC_LOBIT) &
2129                                 DSP_DBGCNTL_EXEC_MASK;
2130                 err = chipio_write(codec, DSP_DBGCNTL_INST_OFFSET,
2131                                    dbg_ctrl_reg);
2132                 if (err < 0)
2133                         return err;
2134         }
2135
2136         return 0;
2137 }
2138
2139 /*
2140  * Reset the DSP
2141  */
2142 static int dsp_reset(struct hda_codec *codec)
2143 {
2144         unsigned int res;
2145         int retry = 20;
2146
2147         codec_dbg(codec, "dsp_reset\n");
2148         do {
2149                 res = dspio_send(codec, VENDOR_DSPIO_DSP_INIT, 0);
2150                 retry--;
2151         } while (res == -EIO && retry);
2152
2153         if (!retry) {
2154                 codec_dbg(codec, "dsp_reset timeout\n");
2155                 return -EIO;
2156         }
2157
2158         return 0;
2159 }
2160
2161 /*
2162  * Convert chip address to DSP address
2163  */
2164 static unsigned int dsp_chip_to_dsp_addx(unsigned int chip_addx,
2165                                         bool *code, bool *yram)
2166 {
2167         *code = *yram = false;
2168
2169         if (UC_RANGE(chip_addx, 1)) {
2170                 *code = true;
2171                 return UC_OFF(chip_addx);
2172         } else if (X_RANGE_ALL(chip_addx, 1)) {
2173                 return X_OFF(chip_addx);
2174         } else if (Y_RANGE_ALL(chip_addx, 1)) {
2175                 *yram = true;
2176                 return Y_OFF(chip_addx);
2177         }
2178
2179         return INVALID_CHIP_ADDRESS;
2180 }
2181
2182 /*
2183  * Check if the DSP DMA is active
2184  */
2185 static bool dsp_is_dma_active(struct hda_codec *codec, unsigned int dma_chan)
2186 {
2187         unsigned int dma_chnlstart_reg;
2188
2189         chipio_read(codec, DSPDMAC_CHNLSTART_INST_OFFSET, &dma_chnlstart_reg);
2190
2191         return ((dma_chnlstart_reg & (1 <<
2192                         (DSPDMAC_CHNLSTART_EN_LOBIT + dma_chan))) != 0);
2193 }
2194
2195 static int dsp_dma_setup_common(struct hda_codec *codec,
2196                                 unsigned int chip_addx,
2197                                 unsigned int dma_chan,
2198                                 unsigned int port_map_mask,
2199                                 bool ovly)
2200 {
2201         int status = 0;
2202         unsigned int chnl_prop;
2203         unsigned int dsp_addx;
2204         unsigned int active;
2205         bool code, yram;
2206
2207         codec_dbg(codec, "-- dsp_dma_setup_common() -- Begin ---------\n");
2208
2209         if (dma_chan >= DSPDMAC_DMA_CFG_CHANNEL_COUNT) {
2210                 codec_dbg(codec, "dma chan num invalid\n");
2211                 return -EINVAL;
2212         }
2213
2214         if (dsp_is_dma_active(codec, dma_chan)) {
2215                 codec_dbg(codec, "dma already active\n");
2216                 return -EBUSY;
2217         }
2218
2219         dsp_addx = dsp_chip_to_dsp_addx(chip_addx, &code, &yram);
2220
2221         if (dsp_addx == INVALID_CHIP_ADDRESS) {
2222                 codec_dbg(codec, "invalid chip addr\n");
2223                 return -ENXIO;
2224         }
2225
2226         chnl_prop = DSPDMAC_CHNLPROP_AC_MASK;
2227         active = 0;
2228
2229         codec_dbg(codec, "   dsp_dma_setup_common()    start reg pgm\n");
2230
2231         if (ovly) {
2232                 status = chipio_read(codec, DSPDMAC_CHNLPROP_INST_OFFSET,
2233                                      &chnl_prop);
2234
2235                 if (status < 0) {
2236                         codec_dbg(codec, "read CHNLPROP Reg fail\n");
2237                         return status;
2238                 }
2239                 codec_dbg(codec, "dsp_dma_setup_common() Read CHNLPROP\n");
2240         }
2241
2242         if (!code)
2243                 chnl_prop &= ~(1 << (DSPDMAC_CHNLPROP_MSPCE_LOBIT + dma_chan));
2244         else
2245                 chnl_prop |=  (1 << (DSPDMAC_CHNLPROP_MSPCE_LOBIT + dma_chan));
2246
2247         chnl_prop &= ~(1 << (DSPDMAC_CHNLPROP_DCON_LOBIT + dma_chan));
2248
2249         status = chipio_write(codec, DSPDMAC_CHNLPROP_INST_OFFSET, chnl_prop);
2250         if (status < 0) {
2251                 codec_dbg(codec, "write CHNLPROP Reg fail\n");
2252                 return status;
2253         }
2254         codec_dbg(codec, "   dsp_dma_setup_common()    Write CHNLPROP\n");
2255
2256         if (ovly) {
2257                 status = chipio_read(codec, DSPDMAC_ACTIVE_INST_OFFSET,
2258                                      &active);
2259
2260                 if (status < 0) {
2261                         codec_dbg(codec, "read ACTIVE Reg fail\n");
2262                         return status;
2263                 }
2264                 codec_dbg(codec, "dsp_dma_setup_common() Read ACTIVE\n");
2265         }
2266
2267         active &= (~(1 << (DSPDMAC_ACTIVE_AAR_LOBIT + dma_chan))) &
2268                 DSPDMAC_ACTIVE_AAR_MASK;
2269
2270         status = chipio_write(codec, DSPDMAC_ACTIVE_INST_OFFSET, active);
2271         if (status < 0) {
2272                 codec_dbg(codec, "write ACTIVE Reg fail\n");
2273                 return status;
2274         }
2275
2276         codec_dbg(codec, "   dsp_dma_setup_common()    Write ACTIVE\n");
2277
2278         status = chipio_write(codec, DSPDMAC_AUDCHSEL_INST_OFFSET(dma_chan),
2279                               port_map_mask);
2280         if (status < 0) {
2281                 codec_dbg(codec, "write AUDCHSEL Reg fail\n");
2282                 return status;
2283         }
2284         codec_dbg(codec, "   dsp_dma_setup_common()    Write AUDCHSEL\n");
2285
2286         status = chipio_write(codec, DSPDMAC_IRQCNT_INST_OFFSET(dma_chan),
2287                         DSPDMAC_IRQCNT_BICNT_MASK | DSPDMAC_IRQCNT_CICNT_MASK);
2288         if (status < 0) {
2289                 codec_dbg(codec, "write IRQCNT Reg fail\n");
2290                 return status;
2291         }
2292         codec_dbg(codec, "   dsp_dma_setup_common()    Write IRQCNT\n");
2293
2294         codec_dbg(codec,
2295                    "ChipA=0x%x,DspA=0x%x,dmaCh=%u, "
2296                    "CHSEL=0x%x,CHPROP=0x%x,Active=0x%x\n",
2297                    chip_addx, dsp_addx, dma_chan,
2298                    port_map_mask, chnl_prop, active);
2299
2300         codec_dbg(codec, "-- dsp_dma_setup_common() -- Complete ------\n");
2301
2302         return 0;
2303 }
2304
2305 /*
2306  * Setup the DSP DMA per-transfer-specific registers
2307  */
2308 static int dsp_dma_setup(struct hda_codec *codec,
2309                         unsigned int chip_addx,
2310                         unsigned int count,
2311                         unsigned int dma_chan)
2312 {
2313         int status = 0;
2314         bool code, yram;
2315         unsigned int dsp_addx;
2316         unsigned int addr_field;
2317         unsigned int incr_field;
2318         unsigned int base_cnt;
2319         unsigned int cur_cnt;
2320         unsigned int dma_cfg = 0;
2321         unsigned int adr_ofs = 0;
2322         unsigned int xfr_cnt = 0;
2323         const unsigned int max_dma_count = 1 << (DSPDMAC_XFRCNT_BCNT_HIBIT -
2324                                                 DSPDMAC_XFRCNT_BCNT_LOBIT + 1);
2325
2326         codec_dbg(codec, "-- dsp_dma_setup() -- Begin ---------\n");
2327
2328         if (count > max_dma_count) {
2329                 codec_dbg(codec, "count too big\n");
2330                 return -EINVAL;
2331         }
2332
2333         dsp_addx = dsp_chip_to_dsp_addx(chip_addx, &code, &yram);
2334         if (dsp_addx == INVALID_CHIP_ADDRESS) {
2335                 codec_dbg(codec, "invalid chip addr\n");
2336                 return -ENXIO;
2337         }
2338
2339         codec_dbg(codec, "   dsp_dma_setup()    start reg pgm\n");
2340
2341         addr_field = dsp_addx << DSPDMAC_DMACFG_DBADR_LOBIT;
2342         incr_field   = 0;
2343
2344         if (!code) {
2345                 addr_field <<= 1;
2346                 if (yram)
2347                         addr_field |= (1 << DSPDMAC_DMACFG_DBADR_LOBIT);
2348
2349                 incr_field  = (1 << DSPDMAC_DMACFG_AINCR_LOBIT);
2350         }
2351
2352         dma_cfg = addr_field + incr_field;
2353         status = chipio_write(codec, DSPDMAC_DMACFG_INST_OFFSET(dma_chan),
2354                                 dma_cfg);
2355         if (status < 0) {
2356                 codec_dbg(codec, "write DMACFG Reg fail\n");
2357                 return status;
2358         }
2359         codec_dbg(codec, "   dsp_dma_setup()    Write DMACFG\n");
2360
2361         adr_ofs = (count - 1) << (DSPDMAC_DSPADROFS_BOFS_LOBIT +
2362                                                         (code ? 0 : 1));
2363
2364         status = chipio_write(codec, DSPDMAC_DSPADROFS_INST_OFFSET(dma_chan),
2365                                 adr_ofs);
2366         if (status < 0) {
2367                 codec_dbg(codec, "write DSPADROFS Reg fail\n");
2368                 return status;
2369         }
2370         codec_dbg(codec, "   dsp_dma_setup()    Write DSPADROFS\n");
2371
2372         base_cnt = (count - 1) << DSPDMAC_XFRCNT_BCNT_LOBIT;
2373
2374         cur_cnt  = (count - 1) << DSPDMAC_XFRCNT_CCNT_LOBIT;
2375
2376         xfr_cnt = base_cnt | cur_cnt;
2377
2378         status = chipio_write(codec,
2379                                 DSPDMAC_XFRCNT_INST_OFFSET(dma_chan), xfr_cnt);
2380         if (status < 0) {
2381                 codec_dbg(codec, "write XFRCNT Reg fail\n");
2382                 return status;
2383         }
2384         codec_dbg(codec, "   dsp_dma_setup()    Write XFRCNT\n");
2385
2386         codec_dbg(codec,
2387                    "ChipA=0x%x, cnt=0x%x, DMACFG=0x%x, "
2388                    "ADROFS=0x%x, XFRCNT=0x%x\n",
2389                    chip_addx, count, dma_cfg, adr_ofs, xfr_cnt);
2390
2391         codec_dbg(codec, "-- dsp_dma_setup() -- Complete ---------\n");
2392
2393         return 0;
2394 }
2395
2396 /*
2397  * Start the DSP DMA
2398  */
2399 static int dsp_dma_start(struct hda_codec *codec,
2400                          unsigned int dma_chan, bool ovly)
2401 {
2402         unsigned int reg = 0;
2403         int status = 0;
2404
2405         codec_dbg(codec, "-- dsp_dma_start() -- Begin ---------\n");
2406
2407         if (ovly) {
2408                 status = chipio_read(codec,
2409                                      DSPDMAC_CHNLSTART_INST_OFFSET, &reg);
2410
2411                 if (status < 0) {
2412                         codec_dbg(codec, "read CHNLSTART reg fail\n");
2413                         return status;
2414                 }
2415                 codec_dbg(codec, "-- dsp_dma_start()    Read CHNLSTART\n");
2416
2417                 reg &= ~(DSPDMAC_CHNLSTART_EN_MASK |
2418                                 DSPDMAC_CHNLSTART_DIS_MASK);
2419         }
2420
2421         status = chipio_write(codec, DSPDMAC_CHNLSTART_INST_OFFSET,
2422                         reg | (1 << (dma_chan + DSPDMAC_CHNLSTART_EN_LOBIT)));
2423         if (status < 0) {
2424                 codec_dbg(codec, "write CHNLSTART reg fail\n");
2425                 return status;
2426         }
2427         codec_dbg(codec, "-- dsp_dma_start() -- Complete ---------\n");
2428
2429         return status;
2430 }
2431
2432 /*
2433  * Stop the DSP DMA
2434  */
2435 static int dsp_dma_stop(struct hda_codec *codec,
2436                         unsigned int dma_chan, bool ovly)
2437 {
2438         unsigned int reg = 0;
2439         int status = 0;
2440
2441         codec_dbg(codec, "-- dsp_dma_stop() -- Begin ---------\n");
2442
2443         if (ovly) {
2444                 status = chipio_read(codec,
2445                                      DSPDMAC_CHNLSTART_INST_OFFSET, &reg);
2446
2447                 if (status < 0) {
2448                         codec_dbg(codec, "read CHNLSTART reg fail\n");
2449                         return status;
2450                 }
2451                 codec_dbg(codec, "-- dsp_dma_stop()    Read CHNLSTART\n");
2452                 reg &= ~(DSPDMAC_CHNLSTART_EN_MASK |
2453                                 DSPDMAC_CHNLSTART_DIS_MASK);
2454         }
2455
2456         status = chipio_write(codec, DSPDMAC_CHNLSTART_INST_OFFSET,
2457                         reg | (1 << (dma_chan + DSPDMAC_CHNLSTART_DIS_LOBIT)));
2458         if (status < 0) {
2459                 codec_dbg(codec, "write CHNLSTART reg fail\n");
2460                 return status;
2461         }
2462         codec_dbg(codec, "-- dsp_dma_stop() -- Complete ---------\n");
2463
2464         return status;
2465 }
2466
2467 /**
2468  * Allocate router ports
2469  *
2470  * @codec: the HDA codec
2471  * @num_chans: number of channels in the stream
2472  * @ports_per_channel: number of ports per channel
2473  * @start_device: start device
2474  * @port_map: pointer to the port list to hold the allocated ports
2475  *
2476  * Returns zero or a negative error code.
2477  */
2478 static int dsp_allocate_router_ports(struct hda_codec *codec,
2479                                      unsigned int num_chans,
2480                                      unsigned int ports_per_channel,
2481                                      unsigned int start_device,
2482                                      unsigned int *port_map)
2483 {
2484         int status = 0;
2485         int res;
2486         u8 val;
2487
2488         status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
2489         if (status < 0)
2490                 return status;
2491
2492         val = start_device << 6;
2493         val |= (ports_per_channel - 1) << 4;
2494         val |= num_chans - 1;
2495
2496         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
2497                             VENDOR_CHIPIO_PORT_ALLOC_CONFIG_SET,
2498                             val);
2499
2500         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
2501                             VENDOR_CHIPIO_PORT_ALLOC_SET,
2502                             MEM_CONNID_DSP);
2503
2504         status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
2505         if (status < 0)
2506                 return status;
2507
2508         res = snd_hda_codec_read(codec, WIDGET_CHIP_CTRL, 0,
2509                                 VENDOR_CHIPIO_PORT_ALLOC_GET, 0);
2510
2511         *port_map = res;
2512
2513         return (res < 0) ? res : 0;
2514 }
2515
2516 /*
2517  * Free router ports
2518  */
2519 static int dsp_free_router_ports(struct hda_codec *codec)
2520 {
2521         int status = 0;
2522
2523         status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
2524         if (status < 0)
2525                 return status;
2526
2527         snd_hda_codec_write(codec, WIDGET_CHIP_CTRL, 0,
2528                             VENDOR_CHIPIO_PORT_FREE_SET,
2529                             MEM_CONNID_DSP);
2530
2531         status = chipio_send(codec, VENDOR_CHIPIO_STATUS, 0);
2532
2533         return status;
2534 }
2535
2536 /*
2537  * Allocate DSP ports for the download stream
2538  */
2539 static int dsp_allocate_ports(struct hda_codec *codec,
2540                         unsigned int num_chans,
2541                         unsigned int rate_multi, unsigned int *port_map)
2542 {
2543         int status;
2544
2545         codec_dbg(codec, "     dsp_allocate_ports() -- begin\n");
2546
2547         if ((rate_multi != 1) && (rate_multi != 2) && (rate_multi != 4)) {
2548                 codec_dbg(codec, "bad rate multiple\n");
2549                 return -EINVAL;
2550         }
2551
2552         status = dsp_allocate_router_ports(codec, num_chans,
2553                                            rate_multi, 0, port_map);
2554
2555         codec_dbg(codec, "     dsp_allocate_ports() -- complete\n");
2556
2557         return status;
2558 }
2559
2560 static int dsp_allocate_ports_format(struct hda_codec *codec,
2561                         const unsigned short fmt,
2562                         unsigned int *port_map)
2563 {
2564         int status;
2565         unsigned int num_chans;
2566
2567         unsigned int sample_rate_div = ((get_hdafmt_rate(fmt) >> 0) & 3) + 1;
2568         unsigned int sample_rate_mul = ((get_hdafmt_rate(fmt) >> 3) & 3) + 1;
2569         unsigned int rate_multi = sample_rate_mul / sample_rate_div;
2570
2571         if ((rate_multi != 1) && (rate_multi != 2) && (rate_multi != 4)) {
2572                 codec_dbg(codec, "bad rate multiple\n");
2573                 return -EINVAL;
2574         }
2575
2576         num_chans = get_hdafmt_chs(fmt) + 1;
2577
2578         status = dsp_allocate_ports(codec, num_chans, rate_multi, port_map);
2579
2580         return status;
2581 }
2582
2583 /*
2584  * free DSP ports
2585  */
2586 static int dsp_free_ports(struct hda_codec *codec)
2587 {
2588         int status;
2589
2590         codec_dbg(codec, "     dsp_free_ports() -- begin\n");
2591
2592         status = dsp_free_router_ports(codec);
2593         if (status < 0) {
2594                 codec_dbg(codec, "free router ports fail\n");
2595                 return status;
2596         }
2597         codec_dbg(codec, "     dsp_free_ports() -- complete\n");
2598
2599         return status;
2600 }
2601
2602 /*
2603  *  HDA DMA engine stuffs for DSP code download
2604  */
2605 struct dma_engine {
2606         struct hda_codec *codec;
2607         unsigned short m_converter_format;
2608         struct snd_dma_buffer *dmab;
2609         unsigned int buf_size;
2610 };
2611
2612
2613 enum dma_state {
2614         DMA_STATE_STOP  = 0,
2615         DMA_STATE_RUN   = 1
2616 };
2617
2618 static int dma_convert_to_hda_format(struct hda_codec *codec,
2619                 unsigned int sample_rate,
2620                 unsigned short channels,
2621                 unsigned short *hda_format)
2622 {
2623         unsigned int format_val;
2624
2625         format_val = snd_hdac_calc_stream_format(sample_rate,
2626                                 channels, SNDRV_PCM_FORMAT_S32_LE, 32, 0);
2627
2628         if (hda_format)
2629                 *hda_format = (unsigned short)format_val;
2630
2631         return 0;
2632 }
2633
2634 /*
2635  *  Reset DMA for DSP download
2636  */
2637 static int dma_reset(struct dma_engine *dma)
2638 {
2639         struct hda_codec *codec = dma->codec;
2640         struct ca0132_spec *spec = codec->spec;
2641         int status;
2642
2643         if (dma->dmab->area)
2644                 snd_hda_codec_load_dsp_cleanup(codec, dma->dmab);
2645
2646         status = snd_hda_codec_load_dsp_prepare(codec,
2647                         dma->m_converter_format,
2648                         dma->buf_size,
2649                         dma->dmab);
2650         if (status < 0)
2651                 return status;
2652         spec->dsp_stream_id = status;
2653         return 0;
2654 }
2655
2656 static int dma_set_state(struct dma_engine *dma, enum dma_state state)
2657 {
2658         bool cmd;
2659
2660         switch (state) {
2661         case DMA_STATE_STOP:
2662                 cmd = false;
2663                 break;
2664         case DMA_STATE_RUN:
2665                 cmd = true;
2666                 break;
2667         default:
2668                 return 0;
2669         }
2670
2671         snd_hda_codec_load_dsp_trigger(dma->codec, cmd);
2672         return 0;
2673 }
2674
2675 static unsigned int dma_get_buffer_size(struct dma_engine *dma)
2676 {
2677         return dma->dmab->bytes;
2678 }
2679
2680 static unsigned char *dma_get_buffer_addr(struct dma_engine *dma)
2681 {
2682         return dma->dmab->area;
2683 }
2684
2685 static int dma_xfer(struct dma_engine *dma,
2686                 const unsigned int *data,
2687                 unsigned int count)
2688 {
2689         memcpy(dma->dmab->area, data, count);
2690         return 0;
2691 }
2692
2693 static void dma_get_converter_format(
2694                 struct dma_engine *dma,
2695                 unsigned short *format)
2696 {
2697         if (format)
2698                 *format = dma->m_converter_format;
2699 }
2700
2701 static unsigned int dma_get_stream_id(struct dma_engine *dma)
2702 {
2703         struct ca0132_spec *spec = dma->codec->spec;
2704
2705         return spec->dsp_stream_id;
2706 }
2707
2708 struct dsp_image_seg {
2709         u32 magic;
2710         u32 chip_addr;
2711         u32 count;
2712         u32 data[0];
2713 };
2714
2715 static const u32 g_magic_value = 0x4c46584d;
2716 static const u32 g_chip_addr_magic_value = 0xFFFFFF01;
2717
2718 static bool is_valid(const struct dsp_image_seg *p)
2719 {
2720         return p->magic == g_magic_value;
2721 }
2722
2723 static bool is_hci_prog_list_seg(const struct dsp_image_seg *p)
2724 {
2725         return g_chip_addr_magic_value == p->chip_addr;
2726 }
2727
2728 static bool is_last(const struct dsp_image_seg *p)
2729 {
2730         return p->count == 0;
2731 }
2732
2733 static size_t dsp_sizeof(const struct dsp_image_seg *p)
2734 {
2735         return sizeof(*p) + p->count*sizeof(u32);
2736 }
2737
2738 static const struct dsp_image_seg *get_next_seg_ptr(
2739                                 const struct dsp_image_seg *p)
2740 {
2741         return (struct dsp_image_seg *)((unsigned char *)(p) + dsp_sizeof(p));
2742 }
2743
2744 /*
2745  * CA0132 chip DSP transfer stuffs.  For DSP download.
2746  */
2747 #define INVALID_DMA_CHANNEL (~0U)
2748
2749 /*
2750  * Program a list of address/data pairs via the ChipIO widget.
2751  * The segment data is in the format of successive pairs of words.
2752  * These are repeated as indicated by the segment's count field.
2753  */
2754 static int dspxfr_hci_write(struct hda_codec *codec,
2755                         const struct dsp_image_seg *fls)
2756 {
2757         int status;
2758         const u32 *data;
2759         unsigned int count;
2760
2761         if (fls == NULL || fls->chip_addr != g_chip_addr_magic_value) {
2762                 codec_dbg(codec, "hci_write invalid params\n");
2763                 return -EINVAL;
2764         }
2765
2766         count = fls->count;
2767         data = (u32 *)(fls->data);
2768         while (count >= 2) {
2769                 status = chipio_write(codec, data[0], data[1]);
2770                 if (status < 0) {
2771                         codec_dbg(codec, "hci_write chipio failed\n");
2772                         return status;
2773                 }
2774                 count -= 2;
2775                 data  += 2;
2776         }
2777         return 0;
2778 }
2779
2780 /**
2781  * Write a block of data into DSP code or data RAM using pre-allocated
2782  * DMA engine.
2783  *
2784  * @codec: the HDA codec
2785  * @fls: pointer to a fast load image
2786  * @reloc: Relocation address for loading single-segment overlays, or 0 for
2787  *         no relocation
2788  * @dma_engine: pointer to DMA engine to be used for DSP download
2789  * @dma_chan: The number of DMA channels used for DSP download
2790  * @port_map_mask: port mapping
2791  * @ovly: TRUE if overlay format is required
2792  *
2793  * Returns zero or a negative error code.
2794  */
2795 static int dspxfr_one_seg(struct hda_codec *codec,
2796                         const struct dsp_image_seg *fls,
2797                         unsigned int reloc,
2798                         struct dma_engine *dma_engine,
2799                         unsigned int dma_chan,
2800                         unsigned int port_map_mask,
2801                         bool ovly)
2802 {
2803         int status = 0;
2804         bool comm_dma_setup_done = false;
2805         const unsigned int *data;
2806         unsigned int chip_addx;
2807         unsigned int words_to_write;
2808         unsigned int buffer_size_words;
2809         unsigned char *buffer_addx;
2810         unsigned short hda_format;
2811         unsigned int sample_rate_div;
2812         unsigned int sample_rate_mul;
2813         unsigned int num_chans;
2814         unsigned int hda_frame_size_words;
2815         unsigned int remainder_words;
2816         const u32 *data_remainder;
2817         u32 chip_addx_remainder;
2818         unsigned int run_size_words;
2819         const struct dsp_image_seg *hci_write = NULL;
2820         unsigned long timeout;
2821         bool dma_active;
2822
2823         if (fls == NULL)
2824                 return -EINVAL;
2825         if (is_hci_prog_list_seg(fls)) {
2826                 hci_write = fls;
2827                 fls = get_next_seg_ptr(fls);
2828         }
2829
2830         if (hci_write && (!fls || is_last(fls))) {
2831                 codec_dbg(codec, "hci_write\n");
2832                 return dspxfr_hci_write(codec, hci_write);
2833         }
2834
2835         if (fls == NULL || dma_engine == NULL || port_map_mask == 0) {
2836                 codec_dbg(codec, "Invalid Params\n");
2837                 return -EINVAL;
2838         }
2839
2840         data = fls->data;
2841         chip_addx = fls->chip_addr,
2842         words_to_write = fls->count;
2843
2844         if (!words_to_write)
2845                 return hci_write ? dspxfr_hci_write(codec, hci_write) : 0;
2846         if (reloc)
2847                 chip_addx = (chip_addx & (0xFFFF0000 << 2)) + (reloc << 2);
2848
2849         if (!UC_RANGE(chip_addx, words_to_write) &&
2850             !X_RANGE_ALL(chip_addx, words_to_write) &&
2851             !Y_RANGE_ALL(chip_addx, words_to_write)) {
2852                 codec_dbg(codec, "Invalid chip_addx Params\n");
2853                 return -EINVAL;
2854         }
2855
2856         buffer_size_words = (unsigned int)dma_get_buffer_size(dma_engine) /
2857                                         sizeof(u32);
2858
2859         buffer_addx = dma_get_buffer_addr(dma_engine);
2860
2861         if (buffer_addx == NULL) {
2862                 codec_dbg(codec, "dma_engine buffer NULL\n");
2863                 return -EINVAL;
2864         }
2865
2866         dma_get_converter_format(dma_engine, &hda_format);
2867         sample_rate_div = ((get_hdafmt_rate(hda_format) >> 0) & 3) + 1;
2868         sample_rate_mul = ((get_hdafmt_rate(hda_format) >> 3) & 3) + 1;
2869         num_chans = get_hdafmt_chs(hda_format) + 1;
2870
2871         hda_frame_size_words = ((sample_rate_div == 0) ? 0 :
2872                         (num_chans * sample_rate_mul / sample_rate_div));
2873
2874         if (hda_frame_size_words == 0) {
2875                 codec_dbg(codec, "frmsz zero\n");
2876                 return -EINVAL;
2877         }
2878
2879         buffer_size_words = min(buffer_size_words,
2880                                 (unsigned int)(UC_RANGE(chip_addx, 1) ?
2881                                 65536 : 32768));
2882         buffer_size_words -= buffer_size_words % hda_frame_size_words;
2883         codec_dbg(codec,
2884                    "chpadr=0x%08x frmsz=%u nchan=%u "
2885                    "rate_mul=%u div=%u bufsz=%u\n",
2886                    chip_addx, hda_frame_size_words, num_chans,
2887                    sample_rate_mul, sample_rate_div, buffer_size_words);
2888
2889         if (buffer_size_words < hda_frame_size_words) {
2890                 codec_dbg(codec, "dspxfr_one_seg:failed\n");
2891                 return -EINVAL;
2892         }
2893
2894         remainder_words = words_to_write % hda_frame_size_words;
2895         data_remainder = data;
2896         chip_addx_remainder = chip_addx;
2897
2898         data += remainder_words;
2899         chip_addx += remainder_words*sizeof(u32);
2900         words_to_write -= remainder_words;
2901
2902         while (words_to_write != 0) {
2903                 run_size_words = min(buffer_size_words, words_to_write);
2904                 codec_dbg(codec, "dspxfr (seg loop)cnt=%u rs=%u remainder=%u\n",
2905                             words_to_write, run_size_words, remainder_words);
2906                 dma_xfer(dma_engine, data, run_size_words*sizeof(u32));
2907                 if (!comm_dma_setup_done) {
2908                         status = dsp_dma_stop(codec, dma_chan, ovly);
2909                         if (status < 0)
2910                                 return status;
2911                         status = dsp_dma_setup_common(codec, chip_addx,
2912                                                 dma_chan, port_map_mask, ovly);
2913                         if (status < 0)
2914                                 return status;
2915                         comm_dma_setup_done = true;
2916                 }
2917
2918                 status = dsp_dma_setup(codec, chip_addx,
2919                                                 run_size_words, dma_chan);
2920                 if (status < 0)
2921                         return status;
2922                 status = dsp_dma_start(codec, dma_chan, ovly);
2923                 if (status < 0)
2924                         return status;
2925                 if (!dsp_is_dma_active(codec, dma_chan)) {
2926                         codec_dbg(codec, "dspxfr:DMA did not start\n");
2927                         return -EIO;
2928                 }
2929                 status = dma_set_state(dma_engine, DMA_STATE_RUN);
2930                 if (status < 0)
2931                         return status;
2932                 if (remainder_words != 0) {
2933                         status = chipio_write_multiple(codec,
2934                                                 chip_addx_remainder,
2935                                                 data_remainder,
2936                                                 remainder_words);
2937                         if (status < 0)
2938                                 return status;
2939                         remainder_words = 0;
2940                 }
2941                 if (hci_write) {
2942                         status = dspxfr_hci_write(codec, hci_write);
2943                         if (status < 0)
2944                                 return status;
2945                         hci_write = NULL;
2946                 }
2947
2948                 timeout = jiffies + msecs_to_jiffies(2000);
2949                 do {
2950                         dma_active = dsp_is_dma_active(codec, dma_chan);
2951                         if (!dma_active)
2952                                 break;
2953                         msleep(20);
2954                 } while (time_before(jiffies, timeout));
2955                 if (dma_active)
2956                         break;
2957
2958                 codec_dbg(codec, "+++++ DMA complete\n");
2959                 dma_set_state(dma_engine, DMA_STATE_STOP);
2960                 status = dma_reset(dma_engine);
2961
2962                 if (status < 0)
2963                         return status;
2964
2965                 data += run_size_words;
2966                 chip_addx += run_size_words*sizeof(u32);
2967                 words_to_write -= run_size_words;
2968         }
2969
2970         if (remainder_words != 0) {
2971                 status = chipio_write_multiple(codec, chip_addx_remainder,
2972                                         data_remainder, remainder_words);
2973         }
2974
2975         return status;
2976 }
2977
2978 /**
2979  * Write the entire DSP image of a DSP code/data overlay to DSP memories
2980  *
2981  * @codec: the HDA codec
2982  * @fls_data: pointer to a fast load image
2983  * @reloc: Relocation address for loading single-segment overlays, or 0 for
2984  *         no relocation
2985  * @sample_rate: sampling rate of the stream used for DSP download
2986  * @channels: channels of the stream used for DSP download
2987  * @ovly: TRUE if overlay format is required
2988  *
2989  * Returns zero or a negative error code.
2990  */
2991 static int dspxfr_image(struct hda_codec *codec,
2992                         const struct dsp_image_seg *fls_data,
2993                         unsigned int reloc,
2994                         unsigned int sample_rate,
2995                         unsigned short channels,
2996                         bool ovly)
2997 {
2998         struct ca0132_spec *spec = codec->spec;
2999         int status;
3000         unsigned short hda_format = 0;
3001         unsigned int response;
3002         unsigned char stream_id = 0;
3003         struct dma_engine *dma_engine;
3004         unsigned int dma_chan;
3005         unsigned int port_map_mask;
3006
3007         if (fls_data == NULL)
3008                 return -EINVAL;
3009
3010         dma_engine = kzalloc(sizeof(*dma_engine), GFP_KERNEL);
3011         if (!dma_engine)
3012                 return -ENOMEM;
3013
3014         dma_engine->dmab = kzalloc(sizeof(*dma_engine->dmab), GFP_KERNEL);
3015         if (!dma_engine->dmab) {
3016                 kfree(dma_engine);
3017                 return -ENOMEM;
3018         }
3019
3020         dma_engine->codec = codec;
3021         dma_convert_to_hda_format(codec, sample_rate, channels, &hda_format);
3022         dma_engine->m_converter_format = hda_format;
3023         dma_engine->buf_size = (ovly ? DSP_DMA_WRITE_BUFLEN_OVLY :
3024                         DSP_DMA_WRITE_BUFLEN_INIT) * 2;
3025
3026         dma_chan = ovly ? INVALID_DMA_CHANNEL : 0;
3027
3028         status = codec_set_converter_format(codec, WIDGET_CHIP_CTRL,
3029                                         hda_format, &response);
3030
3031         if (status < 0) {
3032                 codec_dbg(codec, "set converter format fail\n");
3033                 goto exit;
3034         }
3035
3036         status = snd_hda_codec_load_dsp_prepare(codec,
3037                                 dma_engine->m_converter_format,
3038                                 dma_engine->buf_size,
3039                                 dma_engine->dmab);
3040         if (status < 0)
3041                 goto exit;
3042         spec->dsp_stream_id = status;
3043
3044         if (ovly) {
3045                 status = dspio_alloc_dma_chan(codec, &dma_chan);
3046                 if (status < 0) {
3047                         codec_dbg(codec, "alloc dmachan fail\n");
3048                         dma_chan = INVALID_DMA_CHANNEL;
3049                         goto exit;
3050                 }
3051         }
3052
3053         port_map_mask = 0;
3054         status = dsp_allocate_ports_format(codec, hda_format,
3055                                         &port_map_mask);
3056         if (status < 0) {
3057                 codec_dbg(codec, "alloc ports fail\n");
3058                 goto exit;
3059         }
3060
3061         stream_id = dma_get_stream_id(dma_engine);
3062         status = codec_set_converter_stream_channel(codec,
3063                         WIDGET_CHIP_CTRL, stream_id, 0, &response);
3064         if (status < 0) {
3065                 codec_dbg(codec, "set stream chan fail\n");
3066                 goto exit;
3067         }
3068
3069         while ((fls_data != NULL) && !is_last(fls_data)) {
3070                 if (!is_valid(fls_data)) {
3071                         codec_dbg(codec, "FLS check fail\n");
3072                         status = -EINVAL;
3073                         goto exit;
3074                 }
3075                 status = dspxfr_one_seg(codec, fls_data, reloc,
3076                                         dma_engine, dma_chan,
3077                                         port_map_mask, ovly);
3078                 if (status < 0)
3079                         break;
3080
3081                 if (is_hci_prog_list_seg(fls_data))
3082                         fls_data = get_next_seg_ptr(fls_data);
3083
3084                 if ((fls_data != NULL) && !is_last(fls_data))
3085                         fls_data = get_next_seg_ptr(fls_data);
3086         }
3087
3088         if (port_map_mask != 0)
3089                 status = dsp_free_ports(codec);
3090
3091         if (status < 0)
3092                 goto exit;
3093
3094         status = codec_set_converter_stream_channel(codec,
3095                                 WIDGET_CHIP_CTRL, 0, 0, &response);
3096
3097 exit:
3098         if (ovly && (dma_chan != INVALID_DMA_CHANNEL))
3099                 dspio_free_dma_chan(codec, dma_chan);
3100
3101         if (dma_engine->dmab->area)
3102                 snd_hda_codec_load_dsp_cleanup(codec, dma_engine->dmab);
3103         kfree(dma_engine->dmab);
3104         kfree(dma_engine);
3105
3106         return status;
3107 }
3108
3109 /*
3110  * CA0132 DSP download stuffs.
3111  */
3112 static void dspload_post_setup(struct hda_codec *codec)
3113 {
3114         struct ca0132_spec *spec = codec->spec;
3115         codec_dbg(codec, "---- dspload_post_setup ------\n");
3116         if (!ca0132_use_alt_functions(spec)) {
3117                 /*set DSP speaker to 2.0 configuration*/
3118                 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x18), 0x08080080);
3119                 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x19), 0x3f800000);
3120
3121                 /*update write pointer*/
3122                 chipio_write(codec, XRAM_XRAM_INST_OFFSET(0x29), 0x00000002);
3123         }
3124 }
3125
3126 /**
3127  * dspload_image - Download DSP from a DSP Image Fast Load structure.
3128  *
3129  * @codec: the HDA codec
3130  * @fls: pointer to a fast load image
3131  * @ovly: TRUE if overlay format is required
3132  * @reloc: Relocation address for loading single-segment overlays, or 0 for
3133  *         no relocation
3134  * @autostart: TRUE if DSP starts after loading; ignored if ovly is TRUE
3135  * @router_chans: number of audio router channels to be allocated (0 means use
3136  *                internal defaults; max is 32)
3137  *
3138  * Download DSP from a DSP Image Fast Load structure. This structure is a
3139  * linear, non-constant sized element array of structures, each of which
3140  * contain the count of the data to be loaded, the data itself, and the
3141  * corresponding starting chip address of the starting data location.
3142  * Returns zero or a negative error code.
3143  */
3144 static int dspload_image(struct hda_codec *codec,
3145                         const struct dsp_image_seg *fls,
3146                         bool ovly,
3147                         unsigned int reloc,
3148                         bool autostart,
3149                         int router_chans)
3150 {
3151         int status = 0;
3152         unsigned int sample_rate;
3153         unsigned short channels;
3154
3155         codec_dbg(codec, "---- dspload_image begin ------\n");
3156         if (router_chans == 0) {
3157                 if (!ovly)
3158                         router_chans = DMA_TRANSFER_FRAME_SIZE_NWORDS;
3159                 else
3160                         router_chans = DMA_OVERLAY_FRAME_SIZE_NWORDS;
3161         }
3162
3163         sample_rate = 48000;
3164         channels = (unsigned short)router_chans;
3165
3166         while (channels > 16) {
3167                 sample_rate *= 2;
3168                 channels /= 2;
3169         }
3170
3171         do {
3172                 codec_dbg(codec, "Ready to program DMA\n");
3173                 if (!ovly)
3174                         status = dsp_reset(codec);
3175
3176                 if (status < 0)
3177                         break;
3178
3179                 codec_dbg(codec, "dsp_reset() complete\n");
3180                 status = dspxfr_image(codec, fls, reloc, sample_rate, channels,
3181                                       ovly);
3182
3183                 if (status < 0)
3184                         break;
3185
3186                 codec_dbg(codec, "dspxfr_image() complete\n");
3187                 if (autostart && !ovly) {
3188                         dspload_post_setup(codec);
3189                         status = dsp_set_run_state(codec);
3190                 }
3191
3192                 codec_dbg(codec, "LOAD FINISHED\n");
3193         } while (0);
3194
3195         return status;
3196 }
3197
3198 #ifdef CONFIG_SND_HDA_CODEC_CA0132_DSP
3199 static bool dspload_is_loaded(struct hda_codec *codec)
3200 {
3201         unsigned int data = 0;
3202         int status = 0;
3203
3204         status = chipio_read(codec, 0x40004, &data);
3205         if ((status < 0) || (data != 1))
3206                 return false;
3207
3208         return true;
3209 }
3210 #else
3211 #define dspload_is_loaded(codec)        false
3212 #endif
3213
3214 static bool dspload_wait_loaded(struct hda_codec *codec)
3215 {
3216         unsigned long timeout = jiffies + msecs_to_jiffies(2000);
3217
3218         do {
3219                 if (dspload_is_loaded(codec)) {
3220                         codec_info(codec, "ca0132 DSP downloaded and running\n");
3221                         return true;
3222                 }
3223                 msleep(20);
3224         } while (time_before(jiffies, timeout));
3225
3226         codec_err(codec, "ca0132 failed to download DSP\n");
3227         return false;
3228 }
3229
3230 /*
3231  * ca0113 related functions. The ca0113 acts as the HDA bus for the pci-e
3232  * based cards, and has a second mmio region, region2, that's used for special
3233  * commands.
3234  */
3235
3236 /*
3237  * For cards with PCI-E region2 (Sound Blaster Z/ZxR, Recon3D, and AE-5)
3238  * the mmio address 0x320 is used to set GPIO pins. The format for the data
3239  * The first eight bits are just the number of the pin. So far, I've only seen
3240  * this number go to 7.
3241  * AE-5 note: The AE-5 seems to use pins 2 and 3 to somehow set the color value
3242  * of the on-card LED. It seems to use pin 2 for data, then toggles 3 to on and
3243  * then off to send that bit.
3244  */
3245 static void ca0113_mmio_gpio_set(struct hda_codec *codec, unsigned int gpio_pin,
3246                 bool enable)
3247 {
3248         struct ca0132_spec *spec = codec->spec;
3249         unsigned short gpio_data;
3250
3251         gpio_data = gpio_pin & 0xF;
3252         gpio_data |= ((enable << 8) & 0x100);
3253
3254         writew(gpio_data, spec->mem_base + 0x320);
3255 }
3256
3257 /*
3258  * Special pci region2 commands that are only used by the AE-5. They follow
3259  * a set format, and require reads at certain points to seemingly 'clear'
3260  * the response data. My first tests didn't do these reads, and would cause
3261  * the card to get locked up until the memory was read. These commands
3262  * seem to work with three distinct values that I've taken to calling group,
3263  * target-id, and value.
3264  */
3265 static void ca0113_mmio_command_set(struct hda_codec *codec, unsigned int group,
3266                 unsigned int target, unsigned int value)
3267 {
3268         struct ca0132_spec *spec = codec->spec;
3269         unsigned int write_val;
3270
3271         writel(0x0000007e, spec->mem_base + 0x210);
3272         readl(spec->mem_base + 0x210);
3273         writel(0x0000005a, spec->mem_base + 0x210);
3274         readl(spec->mem_base + 0x210);
3275         readl(spec->mem_base + 0x210);
3276
3277         writel(0x00800005, spec->mem_base + 0x20c);
3278         writel(group, spec->mem_base + 0x804);
3279
3280         writel(0x00800005, spec->mem_base + 0x20c);
3281         write_val = (target & 0xff);
3282         write_val |= (value << 8);
3283
3284
3285         writel(write_val, spec->mem_base + 0x204);
3286         /*
3287          * Need delay here or else it goes too fast and works inconsistently.
3288          */
3289         msleep(20);
3290
3291         readl(spec->mem_base + 0x860);
3292         readl(spec->mem_base + 0x854);
3293         readl(spec->mem_base + 0x840);
3294
3295         writel(0x00800004, spec->mem_base + 0x20c);
3296         writel(0x00000000, spec->mem_base + 0x210);
3297         readl(spec->mem_base + 0x210);
3298         readl(spec->mem_base + 0x210);
3299 }
3300
3301 /*
3302  * This second type of command is used for setting the sound filter type.
3303  */
3304 static void ca0113_mmio_command_set_type2(struct hda_codec *codec,
3305                 unsigned int group, unsigned int target, unsigned int value)
3306 {
3307         struct ca0132_spec *spec = codec->spec;
3308         unsigned int write_val;
3309
3310         writel(0x0000007e, spec->mem_base + 0x210);
3311         readl(spec->mem_base + 0x210);
3312         writel(0x0000005a, spec->mem_base + 0x210);
3313         readl(spec->mem_base + 0x210);
3314         readl(spec->mem_base + 0x210);
3315
3316         writel(0x00800003, spec->mem_base + 0x20c);
3317         writel(group, spec->mem_base + 0x804);
3318
3319         writel(0x00800005, spec->mem_base + 0x20c);
3320         write_val = (target & 0xff);
3321         write_val |= (value << 8);
3322
3323
3324         writel(write_val, spec->mem_base + 0x204);
3325         msleep(20);
3326         readl(spec->mem_base + 0x860);
3327         readl(spec->mem_base + 0x854);
3328         readl(spec->mem_base + 0x840);
3329
3330         writel(0x00800004, spec->mem_base + 0x20c);
3331         writel(0x00000000, spec->mem_base + 0x210);
3332         readl(spec->mem_base + 0x210);
3333         readl(spec->mem_base + 0x210);
3334 }
3335
3336 /*
3337  * Setup GPIO for the other variants of Core3D.
3338  */
3339
3340 /*
3341  * Sets up the GPIO pins so that they are discoverable. If this isn't done,
3342  * the card shows as having no GPIO pins.
3343  */
3344 static void ca0132_gpio_init(struct hda_codec *codec)
3345 {
3346         struct ca0132_spec *spec = codec->spec;
3347
3348         switch (ca0132_quirk(spec)) {
3349         case QUIRK_SBZ:
3350         case QUIRK_AE5:
3351                 snd_hda_codec_write(codec, 0x01, 0, 0x793, 0x00);
3352                 snd_hda_codec_write(codec, 0x01, 0, 0x794, 0x53);
3353                 snd_hda_codec_write(codec, 0x01, 0, 0x790, 0x23);
3354                 break;
3355         case QUIRK_R3DI:
3356                 snd_hda_codec_write(codec, 0x01, 0, 0x793, 0x00);
3357                 snd_hda_codec_write(codec, 0x01, 0, 0x794, 0x5B);
3358                 break;
3359         default:
3360                 break;
3361         }
3362
3363 }
3364
3365 /* Sets the GPIO for audio output. */
3366 static void ca0132_gpio_setup(struct hda_codec *codec)
3367 {
3368         struct ca0132_spec *spec = codec->spec;
3369
3370         switch (ca0132_quirk(spec)) {
3371         case QUIRK_SBZ:
3372                 snd_hda_codec_write(codec, 0x01, 0,
3373                                 AC_VERB_SET_GPIO_DIRECTION, 0x07);
3374                 snd_hda_codec_write(codec, 0x01, 0,
3375                                 AC_VERB_SET_GPIO_MASK, 0x07);
3376                 snd_hda_codec_write(codec, 0x01, 0,
3377                                 AC_VERB_SET_GPIO_DATA, 0x04);
3378                 snd_hda_codec_write(codec, 0x01, 0,
3379                                 AC_VERB_SET_GPIO_DATA, 0x06);
3380                 break;
3381         case QUIRK_R3DI:
3382                 snd_hda_codec_write(codec, 0x01, 0,
3383                                 AC_VERB_SET_GPIO_DIRECTION, 0x1E);
3384                 snd_hda_codec_write(codec, 0x01, 0,
3385                                 AC_VERB_SET_GPIO_MASK, 0x1F);
3386                 snd_hda_codec_write(codec, 0x01, 0,
3387                                 AC_VERB_SET_GPIO_DATA, 0x0C);
3388                 break;
3389         default:
3390                 break;
3391         }
3392 }
3393
3394 /*
3395  * GPIO control functions for the Recon3D integrated.
3396  */
3397
3398 enum r3di_gpio_bit {
3399         /* Bit 1 - Switch between front/rear mic. 0 = rear, 1 = front */
3400         R3DI_MIC_SELECT_BIT = 1,
3401         /* Bit 2 - Switch between headphone/line out. 0 = Headphone, 1 = Line */
3402         R3DI_OUT_SELECT_BIT = 2,
3403         /*
3404          * I dunno what this actually does, but it stays on until the dsp
3405          * is downloaded.
3406          */
3407         R3DI_GPIO_DSP_DOWNLOADING = 3,
3408