12dc00adca9f3e2bd8cfde1f2fdbf280ab80451d
[linux-2.6.git] / sound / pci / echoaudio / layla24_dsp.c
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 Foundation.
12
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 59 Temple Place - Suite 330, Boston,
21    MA  02111-1307, USA.
22
23    *************************************************************************
24
25  Translation from C++ and adaptation for use in ALSA-Driver
26  were made by Giuliano Pochini <pochini@shiny.it>
27
28 ****************************************************************************/
29
30
31 static int write_control_reg(struct echoaudio *chip, u32 value, char force);
32 static int set_input_clock(struct echoaudio *chip, u16 clock);
33 static int set_professional_spdif(struct echoaudio *chip, char prof);
34 static int set_digital_mode(struct echoaudio *chip, u8 mode);
35 static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic);
36 static int check_asic_status(struct echoaudio *chip);
37
38
39 static int init_hw(struct echoaudio *chip, u16 device_id, u16 subdevice_id)
40 {
41         int err;
42
43         DE_INIT(("init_hw() - Layla24\n"));
44         if (snd_BUG_ON((subdevice_id & 0xfff0) != LAYLA24))
45                 return -ENODEV;
46
47         if ((err = init_dsp_comm_page(chip))) {
48                 DE_INIT(("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_LAYLA24_DSP;
57         chip->input_clock_types =
58                 ECHO_CLOCK_BIT_INTERNAL | ECHO_CLOCK_BIT_SPDIF |
59                 ECHO_CLOCK_BIT_WORD | ECHO_CLOCK_BIT_ADAT;
60         chip->digital_modes =
61                 ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_RCA |
62                 ECHOCAPS_HAS_DIGITAL_MODE_SPDIF_OPTICAL |
63                 ECHOCAPS_HAS_DIGITAL_MODE_ADAT;
64         chip->digital_mode =            DIGITAL_MODE_SPDIF_RCA;
65         chip->professional_spdif = FALSE;
66         chip->digital_in_automute = TRUE;
67
68         if ((err = load_firmware(chip)) < 0)
69                 return err;
70         chip->bad_board = FALSE;
71
72         if ((err = init_line_levels(chip)) < 0)
73                 return err;
74
75         err = set_digital_mode(chip, DIGITAL_MODE_SPDIF_RCA);
76         if (err < 0)
77                 return err;
78         err = set_professional_spdif(chip, TRUE);
79
80         DE_INIT(("init_hw done\n"));
81         return err;
82 }
83
84
85
86 static u32 detect_input_clocks(const struct echoaudio *chip)
87 {
88         u32 clocks_from_dsp, clock_bits;
89
90         /* Map the DSP clock detect bits to the generic driver clock detect bits */
91         clocks_from_dsp = le32_to_cpu(chip->comm_page->status_clocks);
92
93         clock_bits = ECHO_CLOCK_BIT_INTERNAL;
94
95         if (clocks_from_dsp & GML_CLOCK_DETECT_BIT_SPDIF)
96                 clock_bits |= ECHO_CLOCK_BIT_SPDIF;
97
98         if (clocks_from_dsp & GML_CLOCK_DETECT_BIT_ADAT)
99                 clock_bits |= ECHO_CLOCK_BIT_ADAT;
100
101         if (clocks_from_dsp & GML_CLOCK_DETECT_BIT_WORD)
102                 clock_bits |= ECHO_CLOCK_BIT_WORD;
103
104         return clock_bits;
105 }
106
107
108
109 /* Layla24 has an ASIC on the PCI card and another ASIC in the external box;
110 both need to be loaded. */
111 static int load_asic(struct echoaudio *chip)
112 {
113         int err;
114
115         if (chip->asic_loaded)
116                 return 1;
117
118         DE_INIT(("load_asic\n"));
119
120         /* Give the DSP a few milliseconds to settle down */
121         mdelay(10);
122
123         /* Load the ASIC for the PCI card */
124         err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA24_PCI_CARD_ASIC,
125                                 FW_LAYLA24_1_ASIC);
126         if (err < 0)
127                 return err;
128
129         chip->asic_code = FW_LAYLA24_2S_ASIC;
130
131         /* Now give the new ASIC a little time to set up */
132         mdelay(10);
133
134         /* Do the external one */
135         err = load_asic_generic(chip, DSP_FNC_LOAD_LAYLA24_EXTERNAL_ASIC,
136                                 FW_LAYLA24_2S_ASIC);
137         if (err < 0)
138                 return FALSE;
139
140         /* Now give the external ASIC a little time to set up */
141         mdelay(10);
142
143         /* See if it worked */
144         err = check_asic_status(chip);
145
146         /* Set up the control register if the load succeeded -
147            48 kHz, internal clock, S/PDIF RCA mode */
148         if (!err)
149                 err = write_control_reg(chip, GML_CONVERTER_ENABLE | GML_48KHZ,
150                                         TRUE);
151         
152         DE_INIT(("load_asic() done\n"));
153         return err;
154 }
155
156
157
158 static int set_sample_rate(struct echoaudio *chip, u32 rate)
159 {
160         u32 control_reg, clock, base_rate;
161
162         if (snd_BUG_ON(rate >= 50000 &&
163                        chip->digital_mode == DIGITAL_MODE_ADAT))
164                 return -EINVAL;
165
166         /* Only set the clock for internal mode. */
167         if (chip->input_clock != ECHO_CLOCK_INTERNAL) {
168                 DE_ACT(("set_sample_rate: Cannot set sample rate - "
169                         "clock not set to CLK_CLOCKININTERNAL\n"));
170                 /* Save the rate anyhow */
171                 chip->comm_page->sample_rate = cpu_to_le32(rate);
172                 chip->sample_rate = rate;
173                 return 0;
174         }
175
176         /* Get the control register & clear the appropriate bits */
177         control_reg = le32_to_cpu(chip->comm_page->control_register);
178         control_reg &= GML_CLOCK_CLEAR_MASK & GML_SPDIF_RATE_CLEAR_MASK;
179
180         clock = 0;
181
182         switch (rate) {
183         case 96000:
184                 clock = GML_96KHZ;
185                 break;
186         case 88200:
187                 clock = GML_88KHZ;
188                 break;
189         case 48000:
190                 clock = GML_48KHZ | GML_SPDIF_SAMPLE_RATE1;
191                 break;
192         case 44100:
193                 clock = GML_44KHZ;
194                 /* Professional mode */
195                 if (control_reg & GML_SPDIF_PRO_MODE)
196                         clock |= GML_SPDIF_SAMPLE_RATE0;
197                 break;
198         case 32000:
199                 clock = GML_32KHZ | GML_SPDIF_SAMPLE_RATE0 |
200                         GML_SPDIF_SAMPLE_RATE1;
201                 break;
202         case 22050:
203                 clock = GML_22KHZ;
204                 break;
205         case 16000:
206                 clock = GML_16KHZ;
207                 break;
208         case 11025:
209                 clock = GML_11KHZ;
210                 break;
211         case 8000:
212                 clock = GML_8KHZ;
213                 break;
214         default:
215                 /* If this is a non-standard rate, then the driver needs to
216                 use Layla24's special "continuous frequency" mode */
217                 clock = LAYLA24_CONTINUOUS_CLOCK;
218                 if (rate > 50000) {
219                         base_rate = rate >> 1;
220                         control_reg |= GML_DOUBLE_SPEED_MODE;
221                 } else {
222                         base_rate = rate;
223                 }
224
225                 if (base_rate < 25000)
226                         base_rate = 25000;
227
228                 if (wait_handshake(chip))
229                         return -EIO;
230
231                 chip->comm_page->sample_rate =
232                         cpu_to_le32(LAYLA24_MAGIC_NUMBER / base_rate - 2);
233
234                 clear_handshake(chip);
235                 send_vector(chip, DSP_VC_SET_LAYLA24_FREQUENCY_REG);
236         }
237
238         control_reg |= clock;
239
240         chip->comm_page->sample_rate = cpu_to_le32(rate);       /* ignored by the DSP ? */
241         chip->sample_rate = rate;
242         DE_ACT(("set_sample_rate: %d clock %d\n", rate, control_reg));
243
244         return write_control_reg(chip, control_reg, FALSE);
245 }
246
247
248
249 static int set_input_clock(struct echoaudio *chip, u16 clock)
250 {
251         u32 control_reg, clocks_from_dsp;
252
253         /* Mask off the clock select bits */
254         control_reg = le32_to_cpu(chip->comm_page->control_register) &
255                 GML_CLOCK_CLEAR_MASK;
256         clocks_from_dsp = le32_to_cpu(chip->comm_page->status_clocks);
257
258         /* Pick the new clock */
259         switch (clock) {
260         case ECHO_CLOCK_INTERNAL:
261                 DE_ACT(("Set Layla24 clock to INTERNAL\n"));
262                 chip->input_clock = ECHO_CLOCK_INTERNAL;
263                 return set_sample_rate(chip, chip->sample_rate);
264         case ECHO_CLOCK_SPDIF:
265                 if (chip->digital_mode == DIGITAL_MODE_ADAT)
266                         return -EAGAIN;
267                 control_reg |= GML_SPDIF_CLOCK;
268                 /* Layla24 doesn't support 96KHz S/PDIF */
269                 control_reg &= ~GML_DOUBLE_SPEED_MODE;
270                 DE_ACT(("Set Layla24 clock to SPDIF\n"));
271                 break;
272         case ECHO_CLOCK_WORD:
273                 control_reg |= GML_WORD_CLOCK;
274                 if (clocks_from_dsp & GML_CLOCK_DETECT_BIT_WORD96)
275                         control_reg |= GML_DOUBLE_SPEED_MODE;
276                 else
277                         control_reg &= ~GML_DOUBLE_SPEED_MODE;
278                 DE_ACT(("Set Layla24 clock to WORD\n"));
279                 break;
280         case ECHO_CLOCK_ADAT:
281                 if (chip->digital_mode != DIGITAL_MODE_ADAT)
282                         return -EAGAIN;
283                 control_reg |= GML_ADAT_CLOCK;
284                 control_reg &= ~GML_DOUBLE_SPEED_MODE;
285                 DE_ACT(("Set Layla24 clock to ADAT\n"));
286                 break;
287         default:
288                 DE_ACT(("Input clock 0x%x not supported for Layla24\n", clock));
289                 return -EINVAL;
290         }
291
292         chip->input_clock = clock;
293         return write_control_reg(chip, control_reg, TRUE);
294 }
295
296
297
298 /* Depending on what digital mode you want, Layla24 needs different ASICs
299 loaded.  This function checks the ASIC needed for the new mode and sees
300 if it matches the one already loaded. */
301 static int switch_asic(struct echoaudio *chip, short asic)
302 {
303         s8 *monitors;
304
305         /*  Check to see if this is already loaded */
306         if (asic != chip->asic_code) {
307                 monitors = kmemdup(chip->comm_page->monitors,
308                                         MONITOR_ARRAY_SIZE, GFP_KERNEL);
309                 if (! monitors)
310                         return -ENOMEM;
311
312                 memset(chip->comm_page->monitors, ECHOGAIN_MUTED,
313                        MONITOR_ARRAY_SIZE);
314
315                 /* Load the desired ASIC */
316                 if (load_asic_generic(chip, DSP_FNC_LOAD_LAYLA24_EXTERNAL_ASIC,
317                                       asic) < 0) {
318                         memcpy(chip->comm_page->monitors, monitors,
319                                MONITOR_ARRAY_SIZE);
320                         kfree(monitors);
321                         return -EIO;
322                 }
323                 chip->asic_code = asic;
324                 memcpy(chip->comm_page->monitors, monitors, MONITOR_ARRAY_SIZE);
325                 kfree(monitors);
326         }
327
328         return 0;
329 }
330
331
332
333 static int dsp_set_digital_mode(struct echoaudio *chip, u8 mode)
334 {
335         u32 control_reg;
336         int err, incompatible_clock;
337         short asic;
338
339         /* Set clock to "internal" if it's not compatible with the new mode */
340         incompatible_clock = FALSE;
341         switch (mode) {
342         case DIGITAL_MODE_SPDIF_OPTICAL:
343         case DIGITAL_MODE_SPDIF_RCA:
344                 if (chip->input_clock == ECHO_CLOCK_ADAT)
345                         incompatible_clock = TRUE;
346                 asic = FW_LAYLA24_2S_ASIC;
347                 break;
348         case DIGITAL_MODE_ADAT:
349                 if (chip->input_clock == ECHO_CLOCK_SPDIF)
350                         incompatible_clock = TRUE;
351                 asic = FW_LAYLA24_2A_ASIC;
352                 break;
353         default:
354                 DE_ACT(("Digital mode not supported: %d\n", mode));
355                 return -EINVAL;
356         }
357
358         if (incompatible_clock) {       /* Switch to 48KHz, internal */
359                 chip->sample_rate = 48000;
360                 spin_lock_irq(&chip->lock);
361                 set_input_clock(chip, ECHO_CLOCK_INTERNAL);
362                 spin_unlock_irq(&chip->lock);
363         }
364
365         /* switch_asic() can sleep */
366         if (switch_asic(chip, asic) < 0)
367                 return -EIO;
368
369         spin_lock_irq(&chip->lock);
370
371         /* Tweak the control register */
372         control_reg = le32_to_cpu(chip->comm_page->control_register);
373         control_reg &= GML_DIGITAL_MODE_CLEAR_MASK;
374
375         switch (mode) {
376         case DIGITAL_MODE_SPDIF_OPTICAL:
377                 control_reg |= GML_SPDIF_OPTICAL_MODE;
378                 break;
379         case DIGITAL_MODE_SPDIF_RCA:
380                 /* GML_SPDIF_OPTICAL_MODE bit cleared */
381                 break;
382         case DIGITAL_MODE_ADAT:
383                 control_reg |= GML_ADAT_MODE;
384                 control_reg &= ~GML_DOUBLE_SPEED_MODE;
385                 break;
386         }
387
388         err = write_control_reg(chip, control_reg, TRUE);
389         spin_unlock_irq(&chip->lock);
390         if (err < 0)
391                 return err;
392         chip->digital_mode = mode;
393
394         DE_ACT(("set_digital_mode to %d\n", mode));
395         return incompatible_clock;
396 }