1 /****************************************************************************
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 
32 static int read_dsp(struct echoaudio *chip, u32 *data);
33 static int set_professional_spdif(struct echoaudio *chip, char prof);
34 static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic);
35 static int check_asic_status(struct echoaudio *chip);
36 static int update_flags(struct echoaudio *chip);
37 
38 
init_hw(struct echoaudio * chip,u16 device_id,u16 subdevice_id)39 static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
40 {
41 	int err;
42 
43 	if (snd_BUG_ON((subdevice_id & 0xfff0) != LAYLA20))
44 		return -ENODEV;
45 
46 	if ((err = init_dsp_comm_page(chip))) {
47 		dev_err(chip->card->dev,
48 			"init_hw - could not initialize DSP comm page\n");
49 		return err;
50 	}
51 
52 	chip->device_id = device_id;
53 	chip->subdevice_id = subdevice_id;
54 	chip->bad_board = true;
55 	chip->has_midi = true;
56 	chip->dsp_code_to_load = FW_LAYLA20_DSP;
57 	chip->input_clock_types =
58 		ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
59 		ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_SUPER;
60 	chip->output_clock_types =
61 		ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_SUPER;
62 
63 	if ((err = load_firmware(chip)) < 0)
64 		return err;
65 	chip->bad_board = false;
66 
67 	return err;
68 }
69 
70 
71 
set_mixer_defaults(struct echoaudio * chip)72 static int set_mixer_defaults(struct echoaudio *chip)
73 {
74 	chip->professional_spdif = false;
75 	return init_line_levels(chip);
76 }
77 
78 
79 
detect_input_clocks(const struct echoaudio * chip)80 static u32 detect_input_clocks(const struct echoaudio *chip)
81 {
82 	u32 clocks_from_dsp, clock_bits;
83 
84 	/* Map the DSP clock detect bits to the generic driver clock detect bits */
85 	clocks_from_dsp = le32_to_cpu(chip->comm_page->status_clocks);
86 
87 	clock_bits = ECHO_CLOCK_BIT_INTERNAL;
88 
89 	if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_SPDIF)
90 		clock_bits |= ECHO_CLOCK_BIT_SPDIF;
91 
92 	if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_WORD) {
93 		if (clocks_from_dsp & GLDM_CLOCK_DETECT_BIT_SUPER)
94 			clock_bits |= ECHO_CLOCK_BIT_SUPER;
95 		else
96 			clock_bits |= ECHO_CLOCK_BIT_WORD;
97 	}
98 
99 	return clock_bits;
100 }
101 
102 
103 
104 /* ASIC status check - some cards have one or two ASICs that need to be
105 loaded.  Once that load is complete, this function is called to see if
106 the load was successful.
107 If this load fails, it does not necessarily mean that the hardware is
108 defective - the external box may be disconnected or turned off.
109 This routine sometimes fails for Layla20; for Layla20, the loop runs
110 5 times and succeeds if it wins on three of the loops. */
check_asic_status(struct echoaudio * chip)111 static int check_asic_status(struct echoaudio *chip)
112 {
113 	u32 asic_status;
114 	int goodcnt, i;
115 
116 	chip->asic_loaded = false;
117 	for (i = goodcnt = 0; i < 5; i++) {
118 		send_vector(chip, DSP_VC_TEST_ASIC);
119 
120 		/* The DSP will return a value to indicate whether or not
121 		   the ASIC is currently loaded */
122 		if (read_dsp(chip, &asic_status) < 0) {
123 			dev_err(chip->card->dev,
124 				"check_asic_status: failed on read_dsp\n");
125 			return -EIO;
126 		}
127 
128 		if (asic_status == ASIC_ALREADY_LOADED) {
129 			if (++goodcnt == 3) {
130 				chip->asic_loaded = true;
131 				return 0;
132 			}
133 		}
134 	}
135 	return -EIO;
136 }
137 
138 
139 
140 /* Layla20 has an ASIC in the external box */
load_asic(struct echoaudio * chip)141 static int load_asic(struct echoaudio *chip)
142 {
143 	int err;
144 
145 	if (chip->asic_loaded)
146 		return 0;
147 
148 	err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA_ASIC,
149 				FW_LAYLA20_ASIC);
150 	if (err < 0)
151 		return err;
152 
153 	/* Check if ASIC is alive and well. */
154 	return check_asic_status(chip);
155 }
156 
157 
158 
set_sample_rate(struct echoaudio * chip,u32 rate)159 static int set_sample_rate(struct echoaudio *chip, u32 rate)
160 {
161 	if (snd_BUG_ON(rate < 8000 || rate > 50000))
162 		return -EINVAL;
163 
164 	/* Only set the clock for internal mode. Do not return failure,
165 	   simply treat it as a non-event. */
166 	if (chip->input_clock != ECHO_CLOCK_INTERNAL) {
167 		dev_warn(chip->card->dev,
168 			 "Cannot set sample rate - clock not set to CLK_CLOCKININTERNAL\n");
169 		chip->comm_page->sample_rate = cpu_to_le32(rate);
170 		chip->sample_rate = rate;
171 		return 0;
172 	}
173 
174 	if (wait_handshake(chip))
175 		return -EIO;
176 
177 	dev_dbg(chip->card->dev, "set_sample_rate(%d)\n", rate);
178 	chip->sample_rate = rate;
179 	chip->comm_page->sample_rate = cpu_to_le32(rate);
180 	clear_handshake(chip);
181 	return send_vector(chip, DSP_VC_SET_LAYLA_SAMPLE_RATE);
182 }
183 
184 
185 
set_input_clock(struct echoaudio * chip,u16 clock_source)186 static int set_input_clock(struct echoaudio *chip, u16 clock_source)
187 {
188 	u16 clock;
189 	u32 rate;
190 
191 	rate = 0;
192 	switch (clock_source) {
193 	case ECHO_CLOCK_INTERNAL:
194 		rate = chip->sample_rate;
195 		clock = LAYLA20_CLOCK_INTERNAL;
196 		break;
197 	case ECHO_CLOCK_SPDIF:
198 		clock = LAYLA20_CLOCK_SPDIF;
199 		break;
200 	case ECHO_CLOCK_WORD:
201 		clock = LAYLA20_CLOCK_WORD;
202 		break;
203 	case ECHO_CLOCK_SUPER:
204 		clock = LAYLA20_CLOCK_SUPER;
205 		break;
206 	default:
207 		dev_err(chip->card->dev,
208 			"Input clock 0x%x not supported for Layla24\n",
209 			clock_source);
210 		return -EINVAL;
211 	}
212 	chip->input_clock = clock_source;
213 
214 	chip->comm_page->input_clock = cpu_to_le16(clock);
215 	clear_handshake(chip);
216 	send_vector(chip, DSP_VC_UPDATE_CLOCKS);
217 
218 	if (rate)
219 		set_sample_rate(chip, rate);
220 
221 	return 0;
222 }
223 
224 
225 
set_output_clock(struct echoaudio * chip,u16 clock)226 static int set_output_clock(struct echoaudio *chip, u16 clock)
227 {
228 	switch (clock) {
229 	case ECHO_CLOCK_SUPER:
230 		clock = LAYLA20_OUTPUT_CLOCK_SUPER;
231 		break;
232 	case ECHO_CLOCK_WORD:
233 		clock = LAYLA20_OUTPUT_CLOCK_WORD;
234 		break;
235 	default:
236 		dev_err(chip->card->dev, "set_output_clock wrong clock\n");
237 		return -EINVAL;
238 	}
239 
240 	if (wait_handshake(chip))
241 		return -EIO;
242 
243 	chip->comm_page->output_clock = cpu_to_le16(clock);
244 	chip->output_clock = clock;
245 	clear_handshake(chip);
246 	return send_vector(chip, DSP_VC_UPDATE_CLOCKS);
247 }
248 
249 
250 
251 /* Set input bus gain (one unit is 0.5dB !) */
set_input_gain(struct echoaudio * chip,u16 input,int gain)252 static int set_input_gain(struct echoaudio *chip, u16 input, int gain)
253 {
254 	if (snd_BUG_ON(input >= num_busses_in(chip)))
255 		return -EINVAL;
256 
257 	if (wait_handshake(chip))
258 		return -EIO;
259 
260 	chip->input_gain[input] = gain;
261 	gain += GL20_INPUT_GAIN_MAGIC_NUMBER;
262 	chip->comm_page->line_in_level[input] = gain;
263 	return 0;
264 }
265 
266 
267 
268 /* Tell the DSP to reread the flags from the comm page */
update_flags(struct echoaudio * chip)269 static int update_flags(struct echoaudio *chip)
270 {
271 	if (wait_handshake(chip))
272 		return -EIO;
273 	clear_handshake(chip);
274 	return send_vector(chip, DSP_VC_UPDATE_FLAGS);
275 }
276 
277 
278 
set_professional_spdif(struct echoaudio * chip,char prof)279 static int set_professional_spdif(struct echoaudio *chip, char prof)
280 {
281 	if (prof)
282 		chip->comm_page->flags |=
283 			cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
284 	else
285 		chip->comm_page->flags &=
286 			~cpu_to_le32(DSP_FLAG_PROFESSIONAL_SPDIF);
287 	chip->professional_spdif = prof;
288 	return update_flags(chip);
289 }
290