blob: 83750e9fd7b4a3cc0290498ac1a267ee5c5da30f [file] [log] [blame]
Giuliano Pochinidd7b2542006-06-28 13:53:41 +02001/****************************************************************************
2
3 Copyright Echo Digital Audio Corporation (c) 1998 - 2004
4 All rights reserved
5 www.echoaudio.com
6
7 This file is part of Echo Digital Audio's generic driver library.
8
9 Echo Digital Audio's generic driver library is free software;
10 you can redistribute it and/or modify it under the terms of
11 the GNU General Public License as published by the Free Software
12 Foundation.
13
14 This program 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,
22 MA 02111-1307, USA.
23
24 *************************************************************************
25
26 Translation from C++ and adaptation for use in ALSA-Driver
27 were made by Giuliano Pochini <pochini@shiny.it>
28
29****************************************************************************/
30
31
32static int read_dsp(struct echoaudio *chip, u32 *data);
33static int set_professional_spdif(struct echoaudio *chip, char prof);
34static int load_asic_generic(struct echoaudio *chip, u32 cmd,
35 const struct firmware *asic);
36static int check_asic_status(struct echoaudio *chip);
37static int update_flags(struct echoaudio *chip);
38
39
40static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
41{
42 int err;
43
44 DE_INIT(("init_hw() - Layla20\n"));
Takashi Iwaida3cec32008-08-08 17:12:14 +020045 if (snd_BUG_ON((subdevice_id & 0xfff0) != LAYLA20))
46 return -ENODEV;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +020047
48 if ((err = init_dsp_comm_page(chip))) {
49 DE_INIT(("init_hw - could not initialize DSP comm page\n"));
50 return err;
51 }
52
53 chip->device_id = device_id;
54 chip->subdevice_id = subdevice_id;
55 chip->bad_board = TRUE;
56 chip->has_midi = TRUE;
57 chip->dsp_code_to_load = &card_fw[FW_LAYLA20_DSP];
58 chip->input_clock_types =
59 ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
60 ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_SUPER;
61 chip->output_clock_types =
62 ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_SUPER;
63
64 if ((err = load_firmware(chip)) < 0)
65 return err;
66 chip->bad_board = FALSE;
67
68 if ((err = init_line_levels(chip)) < 0)
69 return err;
70
71 err = set_professional_spdif(chip, TRUE);
72
73 DE_INIT(("init_hw done\n"));
74 return err;
75}
76
77
78
79static u32 detect_input_clocks(const struct echoaudio *chip)
80{
81 u32 clocks_from_dsp, clock_bits;
82
83 /* Map the DSP clock detect bits to the generic driver clock detect bits */
84 clocks_from_dsp = le32_to_cpu(chip->comm_page->status_clocks);
85
86 clock_bits = ECHO_CLOCK_BIT_INTERNAL;
87
88 if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_SPDIF)
89 clock_bits |= ECHO_CLOCK_BIT_SPDIF;
90
91 if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_WORD) {
92 if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_SUPER)
93 clock_bits |= ECHO_CLOCK_BIT_SUPER;
94 else
95 clock_bits |= ECHO_CLOCK_BIT_WORD;
96 }
97
98 return clock_bits;
99}
100
101
102
103/* ASIC status check - some cards have one or two ASICs that need to be
104loaded. Once that load is complete, this function is called to see if
105the load was successful.
106If this load fails, it does not necessarily mean that the hardware is
107defective - the external box may be disconnected or turned off.
108This routine sometimes fails for Layla20; for Layla20, the loop runs
1095 times and succeeds if it wins on three of the loops. */
110static int check_asic_status(struct echoaudio *chip)
111{
112 u32 asic_status;
113 int goodcnt, i;
114
115 chip->asic_loaded = FALSE;
116 for (i = goodcnt = 0; i < 5; i++) {
117 send_vector(chip, DSP_VC_TEST_ASIC);
118
119 /* The DSP will return a value to indicate whether or not
120 the ASIC is currently loaded */
121 if (read_dsp(chip, &asic_status) < 0) {
122 DE_ACT(("check_asic_status: failed on read_dsp\n"));
123 return -EIO;
124 }
125
126 if (asic_status == ASIC_ALREADY_LOADED) {
127 if (++goodcnt == 3) {
128 chip->asic_loaded = TRUE;
129 return 0;
130 }
131 }
132 }
133 return -EIO;
134}
135
136
137
138/* Layla20 has an ASIC in the external box */
139static int load_asic(struct echoaudio *chip)
140{
141 int err;
142
143 if (chip->asic_loaded)
144 return 0;
145
146 err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA_ASIC,
147 &card_fw[FW_LAYLA20_ASIC]);
148 if (err < 0)
149 return err;
150
151 /* Check if ASIC is alive and well. */
152 return check_asic_status(chip);
153}
154
155
156
157static int set_sample_rate(struct echoaudio *chip, u32 rate)
158{
Takashi Iwaida3cec32008-08-08 17:12:14 +0200159 if (snd_BUG_ON(rate < 8000 || rate > 50000))
160 return -EINVAL;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200161
162 /* Only set the clock for internal mode. Do not return failure,
163 simply treat it as a non-event. */
164 if (chip->input_clock != ECHO_CLOCK_INTERNAL) {
165 DE_ACT(("set_sample_rate: Cannot set sample rate - "
166 "clock not set to CLK_CLOCKININTERNAL\n"));
167 chip->comm_page->sample_rate = cpu_to_le32(rate);
168 chip->sample_rate = rate;
169 return 0;
170 }
171
172 if (wait_handshake(chip))
173 return -EIO;
174
175 DE_ACT(("set_sample_rate(%d)\n", rate));
176 chip->sample_rate = rate;
177 chip->comm_page->sample_rate = cpu_to_le32(rate);
178 clear_handshake(chip);
179 return send_vector(chip, DSP_VC_SET_LAYLA_SAMPLE_RATE);
180}
181
182
183
184static int set_input_clock(struct echoaudio *chip, u16 clock_source)
185{
186 u16 clock;
187 u32 rate;
188
189 DE_ACT(("set_input_clock:\n"));
190 rate = 0;
191 switch (clock_source) {
192 case ECHO_CLOCK_INTERNAL:
193 DE_ACT(("Set Layla20 clock to INTERNAL\n"));
194 rate = chip->sample_rate;
195 clock = LAYLA20_CLOCK_INTERNAL;
196 break;
197 case ECHO_CLOCK_SPDIF:
198 DE_ACT(("Set Layla20 clock to SPDIF\n"));
199 clock = LAYLA20_CLOCK_SPDIF;
200 break;
201 case ECHO_CLOCK_WORD:
202 DE_ACT(("Set Layla20 clock to WORD\n"));
203 clock = LAYLA20_CLOCK_WORD;
204 break;
205 case ECHO_CLOCK_SUPER:
206 DE_ACT(("Set Layla20 clock to SUPER\n"));
207 clock = LAYLA20_CLOCK_SUPER;
208 break;
209 default:
210 DE_ACT(("Input clock 0x%x not supported for Layla24\n",
211 clock_source));
212 return -EINVAL;
213 }
214 chip->input_clock = clock_source;
215
216 chip->comm_page->input_clock = cpu_to_le16(clock);
217 clear_handshake(chip);
218 send_vector(chip, DSP_VC_UPDATE_CLOCKS);
219
220 if (rate)
221 set_sample_rate(chip, rate);
222
223 return 0;
224}
225
226
227
228static int set_output_clock(struct echoaudio *chip, u16 clock)
229{
230 DE_ACT(("set_output_clock: %d\n", clock));
231 switch (clock) {
232 case ECHO_CLOCK_SUPER:
233 clock = LAYLA20_OUTPUT_CLOCK_SUPER;
234 break;
235 case ECHO_CLOCK_WORD:
236 clock = LAYLA20_OUTPUT_CLOCK_WORD;
237 break;
238 default:
239 DE_ACT(("set_output_clock wrong clock\n"));
240 return -EINVAL;
241 }
242
243 if (wait_handshake(chip))
244 return -EIO;
245
246 chip->comm_page->output_clock = cpu_to_le16(clock);
247 chip->output_clock = clock;
248 clear_handshake(chip);
249 return send_vector(chip, DSP_VC_UPDATE_CLOCKS);
250}
251
252
253
254/* Set input bus gain (one unit is 0.5dB !) */
255static int set_input_gain(struct echoaudio *chip, u16 input, int gain)
256{
Takashi Iwaida3cec32008-08-08 17:12:14 +0200257 if (snd_BUG_ON(input >= num_busses_in(chip)))
258 return -EINVAL;
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200259
260 if (wait_handshake(chip))
261 return -EIO;
262
263 chip->input_gain[input] = gain;
264 gain += GL20_INPUT_GAIN_MAGIC_NUMBER;
265 chip->comm_page->line_in_level[input] = gain;
266 return 0;
267}
268
269
270
271/* Tell the DSP to reread the flags from the comm page */
272static int update_flags(struct echoaudio *chip)
273{
274 if (wait_handshake(chip))
275 return -EIO;
276 clear_handshake(chip);
277 return send_vector(chip, DSP_VC_UPDATE_FLAGS);
278}
279
280
281
282static int set_professional_spdif(struct echoaudio *chip, char prof)
283{
284 DE_ACT(("set_professional_spdif %d\n", prof));
285 if (prof)
286 chip->comm_page->flags |=
Harvey Harrisone930e992009-02-11 14:49:30 -0800287 cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200288 else
289 chip->comm_page->flags &=
Harvey Harrisone930e992009-02-11 14:49:30 -0800290 ~cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
Giuliano Pochinidd7b2542006-06-28 13:53:41 +0200291 chip->professional_spdif = prof;
292 return update_flags(chip);
293}