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 | #if PAGE_SIZE < 4096 |
32 | #error PAGE_SIZE is < 4k |
33 | #endif |
34 | |
35 | static int restore_dsp_rettings(struct echoaudio *chip); |
36 | |
37 | |
38 | /* Some vector commands involve the DSP reading or writing data to and from the |
39 | comm page; if you send one of these commands to the DSP, it will complete the |
40 | command and then write a non-zero value to the Handshake field in the |
41 | comm page. This function waits for the handshake to show up. */ |
42 | static int wait_handshake(struct echoaudio *chip) |
43 | { |
44 | int i; |
45 | |
46 | /* Wait up to 20ms for the handshake from the DSP */ |
47 | for (i = 0; i < HANDSHAKE_TIMEOUT; i++) { |
48 | /* Look for the handshake value */ |
49 | barrier(); |
50 | if (chip->comm_page->handshake) { |
51 | return 0; |
52 | } |
53 | udelay(1); |
54 | } |
55 | |
56 | dev_err(chip->card->dev, "wait_handshake(): Timeout waiting for DSP\n" ); |
57 | return -EBUSY; |
58 | } |
59 | |
60 | |
61 | |
62 | /* Much of the interaction between the DSP and the driver is done via vector |
63 | commands; send_vector writes a vector command to the DSP. Typically, this |
64 | causes the DSP to read or write fields in the comm page. |
65 | PCI posting is not required thanks to the handshake logic. */ |
66 | static int send_vector(struct echoaudio *chip, u32 command) |
67 | { |
68 | int i; |
69 | |
70 | wmb(); /* Flush all pending writes before sending the command */ |
71 | |
72 | /* Wait up to 100ms for the "vector busy" bit to be off */ |
73 | for (i = 0; i < VECTOR_BUSY_TIMEOUT; i++) { |
74 | if (!(get_dsp_register(chip, CHI32_VECTOR_REG) & |
75 | CHI32_VECTOR_BUSY)) { |
76 | set_dsp_register(chip, CHI32_VECTOR_REG, value: command); |
77 | /*if (i) DE_ACT(("send_vector time: %d\n", i));*/ |
78 | return 0; |
79 | } |
80 | udelay(1); |
81 | } |
82 | |
83 | dev_err(chip->card->dev, "timeout on send_vector\n" ); |
84 | return -EBUSY; |
85 | } |
86 | |
87 | |
88 | |
89 | /* write_dsp writes a 32-bit value to the DSP; this is used almost |
90 | exclusively for loading the DSP. */ |
91 | static int write_dsp(struct echoaudio *chip, u32 data) |
92 | { |
93 | u32 status, i; |
94 | |
95 | for (i = 0; i < 10000000; i++) { /* timeout = 10s */ |
96 | status = get_dsp_register(chip, CHI32_STATUS_REG); |
97 | if ((status & CHI32_STATUS_HOST_WRITE_EMPTY) != 0) { |
98 | set_dsp_register(chip, CHI32_DATA_REG, value: data); |
99 | wmb(); /* write it immediately */ |
100 | return 0; |
101 | } |
102 | udelay(1); |
103 | cond_resched(); |
104 | } |
105 | |
106 | chip->bad_board = true; /* Set true until DSP re-loaded */ |
107 | dev_dbg(chip->card->dev, "write_dsp: Set bad_board to true\n" ); |
108 | return -EIO; |
109 | } |
110 | |
111 | |
112 | |
113 | /* read_dsp reads a 32-bit value from the DSP; this is used almost |
114 | exclusively for loading the DSP and checking the status of the ASIC. */ |
115 | static int read_dsp(struct echoaudio *chip, u32 *data) |
116 | { |
117 | u32 status, i; |
118 | |
119 | for (i = 0; i < READ_DSP_TIMEOUT; i++) { |
120 | status = get_dsp_register(chip, CHI32_STATUS_REG); |
121 | if ((status & CHI32_STATUS_HOST_READ_FULL) != 0) { |
122 | *data = get_dsp_register(chip, CHI32_DATA_REG); |
123 | return 0; |
124 | } |
125 | udelay(1); |
126 | cond_resched(); |
127 | } |
128 | |
129 | chip->bad_board = true; /* Set true until DSP re-loaded */ |
130 | dev_err(chip->card->dev, "read_dsp: Set bad_board to true\n" ); |
131 | return -EIO; |
132 | } |
133 | |
134 | |
135 | |
136 | /**************************************************************************** |
137 | Firmware loading functions |
138 | ****************************************************************************/ |
139 | |
140 | /* This function is used to read back the serial number from the DSP; |
141 | this is triggered by the SET_COMMPAGE_ADDR command. |
142 | Only some early Echogals products have serial numbers in the ROM; |
143 | the serial number is not used, but you still need to do this as |
144 | part of the DSP load process. */ |
145 | static int read_sn(struct echoaudio *chip) |
146 | { |
147 | int i; |
148 | u32 sn[6]; |
149 | |
150 | for (i = 0; i < 5; i++) { |
151 | if (read_dsp(chip, data: &sn[i])) { |
152 | dev_err(chip->card->dev, |
153 | "Failed to read serial number\n" ); |
154 | return -EIO; |
155 | } |
156 | } |
157 | dev_dbg(chip->card->dev, |
158 | "Read serial number %08x %08x %08x %08x %08x\n" , |
159 | sn[0], sn[1], sn[2], sn[3], sn[4]); |
160 | return 0; |
161 | } |
162 | |
163 | |
164 | |
165 | #ifndef ECHOCARD_HAS_ASIC |
166 | /* This card has no ASIC, just return ok */ |
167 | static inline int check_asic_status(struct echoaudio *chip) |
168 | { |
169 | chip->asic_loaded = true; |
170 | return 0; |
171 | } |
172 | |
173 | #endif /* !ECHOCARD_HAS_ASIC */ |
174 | |
175 | |
176 | |
177 | #ifdef ECHOCARD_HAS_ASIC |
178 | |
179 | /* Load ASIC code - done after the DSP is loaded */ |
180 | static int load_asic_generic(struct echoaudio *chip, u32 cmd, short asic) |
181 | { |
182 | const struct firmware *fw; |
183 | int err; |
184 | u32 i, size; |
185 | u8 *code; |
186 | |
187 | err = get_firmware(&fw, chip, asic); |
188 | if (err < 0) { |
189 | dev_warn(chip->card->dev, "Firmware not found !\n" ); |
190 | return err; |
191 | } |
192 | |
193 | code = (u8 *)fw->data; |
194 | size = fw->size; |
195 | |
196 | /* Send the "Here comes the ASIC" command */ |
197 | if (write_dsp(chip, cmd) < 0) |
198 | goto la_error; |
199 | |
200 | /* Write length of ASIC file in bytes */ |
201 | if (write_dsp(chip, size) < 0) |
202 | goto la_error; |
203 | |
204 | for (i = 0; i < size; i++) { |
205 | if (write_dsp(chip, code[i]) < 0) |
206 | goto la_error; |
207 | } |
208 | |
209 | free_firmware(fw, chip); |
210 | return 0; |
211 | |
212 | la_error: |
213 | dev_err(chip->card->dev, "failed on write_dsp\n" ); |
214 | free_firmware(fw, chip); |
215 | return -EIO; |
216 | } |
217 | |
218 | #endif /* ECHOCARD_HAS_ASIC */ |
219 | |
220 | |
221 | |
222 | #ifdef DSP_56361 |
223 | |
224 | /* Install the resident loader for 56361 DSPs; The resident loader is on |
225 | the EPROM on the board for 56301 DSP. The resident loader is a tiny little |
226 | program that is used to load the real DSP code. */ |
227 | static int install_resident_loader(struct echoaudio *chip) |
228 | { |
229 | u32 address; |
230 | int index, words, i; |
231 | u16 *code; |
232 | u32 status; |
233 | const struct firmware *fw; |
234 | |
235 | /* 56361 cards only! This check is required by the old 56301-based |
236 | Mona and Gina24 */ |
237 | if (chip->device_id != DEVICE_ID_56361) |
238 | return 0; |
239 | |
240 | /* Look to see if the resident loader is present. If the resident |
241 | loader is already installed, host flag 5 will be on. */ |
242 | status = get_dsp_register(chip, CHI32_STATUS_REG); |
243 | if (status & CHI32_STATUS_REG_HF5) { |
244 | dev_dbg(chip->card->dev, |
245 | "Resident loader already installed; status is 0x%x\n" , |
246 | status); |
247 | return 0; |
248 | } |
249 | |
250 | i = get_firmware(&fw, chip, FW_361_LOADER); |
251 | if (i < 0) { |
252 | dev_warn(chip->card->dev, "Firmware not found !\n" ); |
253 | return i; |
254 | } |
255 | |
256 | /* The DSP code is an array of 16 bit words. The array is divided up |
257 | into sections. The first word of each section is the size in words, |
258 | followed by the section type. |
259 | Since DSP addresses and data are 24 bits wide, they each take up two |
260 | 16 bit words in the array. |
261 | This is a lot like the other loader loop, but it's not a loop, you |
262 | don't write the memory type, and you don't write a zero at the end. */ |
263 | |
264 | /* Set DSP format bits for 24 bit mode */ |
265 | set_dsp_register(chip, CHI32_CONTROL_REG, |
266 | get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900); |
267 | |
268 | code = (u16 *)fw->data; |
269 | |
270 | /* Skip the header section; the first word in the array is the size |
271 | of the first section, so the first real section of code is pointed |
272 | to by Code[0]. */ |
273 | index = code[0]; |
274 | |
275 | /* Skip the section size, LRS block type, and DSP memory type */ |
276 | index += 3; |
277 | |
278 | /* Get the number of DSP words to write */ |
279 | words = code[index++]; |
280 | |
281 | /* Get the DSP address for this block; 24 bits, so build from two words */ |
282 | address = ((u32)code[index] << 16) + code[index + 1]; |
283 | index += 2; |
284 | |
285 | /* Write the count to the DSP */ |
286 | if (write_dsp(chip, words)) { |
287 | dev_err(chip->card->dev, |
288 | "install_resident_loader: Failed to write word count!\n" ); |
289 | goto irl_error; |
290 | } |
291 | /* Write the DSP address */ |
292 | if (write_dsp(chip, address)) { |
293 | dev_err(chip->card->dev, |
294 | "install_resident_loader: Failed to write DSP address!\n" ); |
295 | goto irl_error; |
296 | } |
297 | /* Write out this block of code to the DSP */ |
298 | for (i = 0; i < words; i++) { |
299 | u32 data; |
300 | |
301 | data = ((u32)code[index] << 16) + code[index + 1]; |
302 | if (write_dsp(chip, data)) { |
303 | dev_err(chip->card->dev, |
304 | "install_resident_loader: Failed to write DSP code\n" ); |
305 | goto irl_error; |
306 | } |
307 | index += 2; |
308 | } |
309 | |
310 | /* Wait for flag 5 to come up */ |
311 | for (i = 0; i < 200; i++) { /* Timeout is 50us * 200 = 10ms */ |
312 | udelay(50); |
313 | status = get_dsp_register(chip, CHI32_STATUS_REG); |
314 | if (status & CHI32_STATUS_REG_HF5) |
315 | break; |
316 | } |
317 | |
318 | if (i == 200) { |
319 | dev_err(chip->card->dev, "Resident loader failed to set HF5\n" ); |
320 | goto irl_error; |
321 | } |
322 | |
323 | dev_dbg(chip->card->dev, "Resident loader successfully installed\n" ); |
324 | free_firmware(fw, chip); |
325 | return 0; |
326 | |
327 | irl_error: |
328 | free_firmware(fw, chip); |
329 | return -EIO; |
330 | } |
331 | |
332 | #endif /* DSP_56361 */ |
333 | |
334 | |
335 | static int load_dsp(struct echoaudio *chip, u16 *code) |
336 | { |
337 | u32 address, data; |
338 | int index, words, i; |
339 | |
340 | if (chip->dsp_code == code) { |
341 | dev_warn(chip->card->dev, "DSP is already loaded!\n" ); |
342 | return 0; |
343 | } |
344 | chip->bad_board = true; /* Set true until DSP loaded */ |
345 | chip->dsp_code = NULL; /* Current DSP code not loaded */ |
346 | chip->asic_loaded = false; /* Loading the DSP code will reset the ASIC */ |
347 | |
348 | dev_dbg(chip->card->dev, "load_dsp: Set bad_board to true\n" ); |
349 | |
350 | /* If this board requires a resident loader, install it. */ |
351 | #ifdef DSP_56361 |
352 | i = install_resident_loader(chip); |
353 | if (i < 0) |
354 | return i; |
355 | #endif |
356 | |
357 | /* Send software reset command */ |
358 | if (send_vector(chip, DSP_VC_RESET) < 0) { |
359 | dev_err(chip->card->dev, |
360 | "LoadDsp: send_vector DSP_VC_RESET failed, Critical Failure\n" ); |
361 | return -EIO; |
362 | } |
363 | /* Delay 10us */ |
364 | udelay(10); |
365 | |
366 | /* Wait 10ms for HF3 to indicate that software reset is complete */ |
367 | for (i = 0; i < 1000; i++) { /* Timeout is 10us * 1000 = 10ms */ |
368 | if (get_dsp_register(chip, CHI32_STATUS_REG) & |
369 | CHI32_STATUS_REG_HF3) |
370 | break; |
371 | udelay(10); |
372 | } |
373 | |
374 | if (i == 1000) { |
375 | dev_err(chip->card->dev, |
376 | "load_dsp: Timeout waiting for CHI32_STATUS_REG_HF3\n" ); |
377 | return -EIO; |
378 | } |
379 | |
380 | /* Set DSP format bits for 24 bit mode now that soft reset is done */ |
381 | set_dsp_register(chip, CHI32_CONTROL_REG, |
382 | value: get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900); |
383 | |
384 | /* Main loader loop */ |
385 | |
386 | index = code[0]; |
387 | for (;;) { |
388 | int block_type, mem_type; |
389 | |
390 | /* Total Block Size */ |
391 | index++; |
392 | |
393 | /* Block Type */ |
394 | block_type = code[index]; |
395 | if (block_type == 4) /* We're finished */ |
396 | break; |
397 | |
398 | index++; |
399 | |
400 | /* Memory Type P=0,X=1,Y=2 */ |
401 | mem_type = code[index++]; |
402 | |
403 | /* Block Code Size */ |
404 | words = code[index++]; |
405 | if (words == 0) /* We're finished */ |
406 | break; |
407 | |
408 | /* Start Address */ |
409 | address = ((u32)code[index] << 16) + code[index + 1]; |
410 | index += 2; |
411 | |
412 | if (write_dsp(chip, data: words) < 0) { |
413 | dev_err(chip->card->dev, |
414 | "load_dsp: failed to write number of DSP words\n" ); |
415 | return -EIO; |
416 | } |
417 | if (write_dsp(chip, data: address) < 0) { |
418 | dev_err(chip->card->dev, |
419 | "load_dsp: failed to write DSP address\n" ); |
420 | return -EIO; |
421 | } |
422 | if (write_dsp(chip, data: mem_type) < 0) { |
423 | dev_err(chip->card->dev, |
424 | "load_dsp: failed to write DSP memory type\n" ); |
425 | return -EIO; |
426 | } |
427 | /* Code */ |
428 | for (i = 0; i < words; i++, index+=2) { |
429 | data = ((u32)code[index] << 16) + code[index + 1]; |
430 | if (write_dsp(chip, data) < 0) { |
431 | dev_err(chip->card->dev, |
432 | "load_dsp: failed to write DSP data\n" ); |
433 | return -EIO; |
434 | } |
435 | } |
436 | } |
437 | |
438 | if (write_dsp(chip, data: 0) < 0) { /* We're done!!! */ |
439 | dev_err(chip->card->dev, |
440 | "load_dsp: Failed to write final zero\n" ); |
441 | return -EIO; |
442 | } |
443 | udelay(10); |
444 | |
445 | for (i = 0; i < 5000; i++) { /* Timeout is 100us * 5000 = 500ms */ |
446 | /* Wait for flag 4 - indicates that the DSP loaded OK */ |
447 | if (get_dsp_register(chip, CHI32_STATUS_REG) & |
448 | CHI32_STATUS_REG_HF4) { |
449 | set_dsp_register(chip, CHI32_CONTROL_REG, |
450 | value: get_dsp_register(chip, CHI32_CONTROL_REG) & ~0x1b00); |
451 | |
452 | if (write_dsp(chip, DSP_FNC_SET_COMMPAGE_ADDR) < 0) { |
453 | dev_err(chip->card->dev, |
454 | "load_dsp: Failed to write DSP_FNC_SET_COMMPAGE_ADDR\n" ); |
455 | return -EIO; |
456 | } |
457 | |
458 | if (write_dsp(chip, data: chip->comm_page_phys) < 0) { |
459 | dev_err(chip->card->dev, |
460 | "load_dsp: Failed to write comm page address\n" ); |
461 | return -EIO; |
462 | } |
463 | |
464 | /* Get the serial number via slave mode. |
465 | This is triggered by the SET_COMMPAGE_ADDR command. |
466 | We don't actually use the serial number but we have to |
467 | get it as part of the DSP init voodoo. */ |
468 | if (read_sn(chip) < 0) { |
469 | dev_err(chip->card->dev, |
470 | "load_dsp: Failed to read serial number\n" ); |
471 | return -EIO; |
472 | } |
473 | |
474 | chip->dsp_code = code; /* Show which DSP code loaded */ |
475 | chip->bad_board = false; /* DSP OK */ |
476 | return 0; |
477 | } |
478 | udelay(100); |
479 | } |
480 | |
481 | dev_err(chip->card->dev, |
482 | "load_dsp: DSP load timed out waiting for HF4\n" ); |
483 | return -EIO; |
484 | } |
485 | |
486 | |
487 | |
488 | /* load_firmware takes care of loading the DSP and any ASIC code. */ |
489 | static int load_firmware(struct echoaudio *chip) |
490 | { |
491 | const struct firmware *fw; |
492 | int box_type, err; |
493 | |
494 | if (snd_BUG_ON(!chip->comm_page)) |
495 | return -EPERM; |
496 | |
497 | /* See if the ASIC is present and working - only if the DSP is already loaded */ |
498 | if (chip->dsp_code) { |
499 | box_type = check_asic_status(chip); |
500 | if (box_type >= 0) |
501 | return box_type; |
502 | /* ASIC check failed; force the DSP to reload */ |
503 | chip->dsp_code = NULL; |
504 | } |
505 | |
506 | err = get_firmware(fw_entry: &fw, chip, fw_index: chip->dsp_code_to_load); |
507 | if (err < 0) |
508 | return err; |
509 | err = load_dsp(chip, code: (u16 *)fw->data); |
510 | free_firmware(fw_entry: fw, chip); |
511 | if (err < 0) |
512 | return err; |
513 | |
514 | box_type = load_asic(chip); |
515 | if (box_type < 0) |
516 | return box_type; /* error */ |
517 | |
518 | return box_type; |
519 | } |
520 | |
521 | |
522 | |
523 | /**************************************************************************** |
524 | Mixer functions |
525 | ****************************************************************************/ |
526 | |
527 | #if defined(ECHOCARD_HAS_INPUT_NOMINAL_LEVEL) || \ |
528 | defined(ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL) |
529 | |
530 | /* Set the nominal level for an input or output bus (true = -10dBV, false = +4dBu) */ |
531 | static int set_nominal_level(struct echoaudio *chip, u16 index, char consumer) |
532 | { |
533 | if (snd_BUG_ON(index >= num_busses_out(chip) + num_busses_in(chip))) |
534 | return -EINVAL; |
535 | |
536 | /* Wait for the handshake (OK even if ASIC is not loaded) */ |
537 | if (wait_handshake(chip)) |
538 | return -EIO; |
539 | |
540 | chip->nominal_level[index] = consumer; |
541 | |
542 | if (consumer) |
543 | chip->comm_page->nominal_level_mask |= cpu_to_le32(1 << index); |
544 | else |
545 | chip->comm_page->nominal_level_mask &= ~cpu_to_le32(1 << index); |
546 | |
547 | return 0; |
548 | } |
549 | |
550 | #endif /* ECHOCARD_HAS_*_NOMINAL_LEVEL */ |
551 | |
552 | |
553 | |
554 | /* Set the gain for a single physical output channel (dB). */ |
555 | static int set_output_gain(struct echoaudio *chip, u16 channel, s8 gain) |
556 | { |
557 | if (snd_BUG_ON(channel >= num_busses_out(chip))) |
558 | return -EINVAL; |
559 | |
560 | if (wait_handshake(chip)) |
561 | return -EIO; |
562 | |
563 | /* Save the new value */ |
564 | chip->output_gain[channel] = gain; |
565 | chip->comm_page->line_out_level[channel] = gain; |
566 | return 0; |
567 | } |
568 | |
569 | |
570 | |
571 | #ifdef ECHOCARD_HAS_MONITOR |
572 | /* Set the monitor level from an input bus to an output bus. */ |
573 | static int set_monitor_gain(struct echoaudio *chip, u16 output, u16 input, |
574 | s8 gain) |
575 | { |
576 | if (snd_BUG_ON(output >= num_busses_out(chip) || |
577 | input >= num_busses_in(chip))) |
578 | return -EINVAL; |
579 | |
580 | if (wait_handshake(chip)) |
581 | return -EIO; |
582 | |
583 | chip->monitor_gain[output][input] = gain; |
584 | chip->comm_page->monitors[monitor_index(chip, out: output, in: input)] = gain; |
585 | return 0; |
586 | } |
587 | #endif /* ECHOCARD_HAS_MONITOR */ |
588 | |
589 | |
590 | /* Tell the DSP to read and update output, nominal & monitor levels in comm page. */ |
591 | static int update_output_line_level(struct echoaudio *chip) |
592 | { |
593 | if (wait_handshake(chip)) |
594 | return -EIO; |
595 | clear_handshake(chip); |
596 | return send_vector(chip, DSP_VC_UPDATE_OUTVOL); |
597 | } |
598 | |
599 | |
600 | |
601 | /* Tell the DSP to read and update input levels in comm page */ |
602 | static int update_input_line_level(struct echoaudio *chip) |
603 | { |
604 | if (wait_handshake(chip)) |
605 | return -EIO; |
606 | clear_handshake(chip); |
607 | return send_vector(chip, DSP_VC_UPDATE_INGAIN); |
608 | } |
609 | |
610 | |
611 | |
612 | /* set_meters_on turns the meters on or off. If meters are turned on, the DSP |
613 | will write the meter and clock detect values to the comm page at about 30Hz */ |
614 | static void set_meters_on(struct echoaudio *chip, char on) |
615 | { |
616 | if (on && !chip->meters_enabled) { |
617 | send_vector(chip, DSP_VC_METERS_ON); |
618 | chip->meters_enabled = 1; |
619 | } else if (!on && chip->meters_enabled) { |
620 | send_vector(chip, DSP_VC_METERS_OFF); |
621 | chip->meters_enabled = 0; |
622 | memset((s8 *)chip->comm_page->vu_meter, ECHOGAIN_MUTED, |
623 | DSP_MAXPIPES); |
624 | memset((s8 *)chip->comm_page->peak_meter, ECHOGAIN_MUTED, |
625 | DSP_MAXPIPES); |
626 | } |
627 | } |
628 | |
629 | |
630 | |
631 | /* Fill out an the given array using the current values in the comm page. |
632 | Meters are written in the comm page by the DSP in this order: |
633 | Output busses |
634 | Input busses |
635 | Output pipes (vmixer cards only) |
636 | |
637 | This function assumes there are no more than 16 in/out busses or pipes |
638 | Meters is an array [3][16][2] of long. */ |
639 | static void get_audio_meters(struct echoaudio *chip, long *meters) |
640 | { |
641 | unsigned int i, m, n; |
642 | |
643 | for (i = 0 ; i < 96; i++) |
644 | meters[i] = 0; |
645 | |
646 | for (m = 0, n = 0, i = 0; i < num_busses_out(chip); i++, m++) { |
647 | meters[n++] = chip->comm_page->vu_meter[m]; |
648 | meters[n++] = chip->comm_page->peak_meter[m]; |
649 | } |
650 | |
651 | #ifdef ECHOCARD_ECHO3G |
652 | m = E3G_MAX_OUTPUTS; /* Skip unused meters */ |
653 | #endif |
654 | |
655 | for (n = 32, i = 0; i < num_busses_in(chip); i++, m++) { |
656 | meters[n++] = chip->comm_page->vu_meter[m]; |
657 | meters[n++] = chip->comm_page->peak_meter[m]; |
658 | } |
659 | #ifdef ECHOCARD_HAS_VMIXER |
660 | for (n = 64, i = 0; i < num_pipes_out(chip); i++, m++) { |
661 | meters[n++] = chip->comm_page->vu_meter[m]; |
662 | meters[n++] = chip->comm_page->peak_meter[m]; |
663 | } |
664 | #endif |
665 | } |
666 | |
667 | |
668 | |
669 | static int restore_dsp_rettings(struct echoaudio *chip) |
670 | { |
671 | int i, o, err; |
672 | |
673 | err = check_asic_status(chip); |
674 | if (err < 0) |
675 | return err; |
676 | |
677 | /* Gina20/Darla20 only. Should be harmless for other cards. */ |
678 | chip->comm_page->gd_clock_state = GD_CLOCK_UNDEF; |
679 | chip->comm_page->gd_spdif_status = GD_SPDIF_STATUS_UNDEF; |
680 | chip->comm_page->handshake = cpu_to_le32(0xffffffff); |
681 | |
682 | /* Restore output busses */ |
683 | for (i = 0; i < num_busses_out(chip); i++) { |
684 | err = set_output_gain(chip, channel: i, gain: chip->output_gain[i]); |
685 | if (err < 0) |
686 | return err; |
687 | } |
688 | |
689 | #ifdef ECHOCARD_HAS_VMIXER |
690 | for (i = 0; i < num_pipes_out(chip); i++) |
691 | for (o = 0; o < num_busses_out(chip); o++) { |
692 | err = set_vmixer_gain(chip, o, i, |
693 | chip->vmixer_gain[o][i]); |
694 | if (err < 0) |
695 | return err; |
696 | } |
697 | if (update_vmixer_level(chip) < 0) |
698 | return -EIO; |
699 | #endif /* ECHOCARD_HAS_VMIXER */ |
700 | |
701 | #ifdef ECHOCARD_HAS_MONITOR |
702 | for (o = 0; o < num_busses_out(chip); o++) |
703 | for (i = 0; i < num_busses_in(chip); i++) { |
704 | err = set_monitor_gain(chip, output: o, input: i, |
705 | gain: chip->monitor_gain[o][i]); |
706 | if (err < 0) |
707 | return err; |
708 | } |
709 | #endif /* ECHOCARD_HAS_MONITOR */ |
710 | |
711 | #ifdef ECHOCARD_HAS_INPUT_GAIN |
712 | for (i = 0; i < num_busses_in(chip); i++) { |
713 | err = set_input_gain(chip, i, chip->input_gain[i]); |
714 | if (err < 0) |
715 | return err; |
716 | } |
717 | #endif /* ECHOCARD_HAS_INPUT_GAIN */ |
718 | |
719 | err = update_output_line_level(chip); |
720 | if (err < 0) |
721 | return err; |
722 | |
723 | err = update_input_line_level(chip); |
724 | if (err < 0) |
725 | return err; |
726 | |
727 | err = set_sample_rate(chip, rate: chip->sample_rate); |
728 | if (err < 0) |
729 | return err; |
730 | |
731 | if (chip->meters_enabled) { |
732 | err = send_vector(chip, DSP_VC_METERS_ON); |
733 | if (err < 0) |
734 | return err; |
735 | } |
736 | |
737 | #ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH |
738 | if (set_digital_mode(chip, chip->digital_mode) < 0) |
739 | return -EIO; |
740 | #endif |
741 | |
742 | #ifdef ECHOCARD_HAS_DIGITAL_IO |
743 | if (set_professional_spdif(chip, chip->professional_spdif) < 0) |
744 | return -EIO; |
745 | #endif |
746 | |
747 | #ifdef ECHOCARD_HAS_PHANTOM_POWER |
748 | if (set_phantom_power(chip, chip->phantom_power) < 0) |
749 | return -EIO; |
750 | #endif |
751 | |
752 | #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK |
753 | /* set_input_clock() also restores automute setting */ |
754 | if (set_input_clock(chip, chip->input_clock) < 0) |
755 | return -EIO; |
756 | #endif |
757 | |
758 | #ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH |
759 | if (set_output_clock(chip, chip->output_clock) < 0) |
760 | return -EIO; |
761 | #endif |
762 | |
763 | if (wait_handshake(chip) < 0) |
764 | return -EIO; |
765 | clear_handshake(chip); |
766 | if (send_vector(chip, DSP_VC_UPDATE_FLAGS) < 0) |
767 | return -EIO; |
768 | |
769 | return 0; |
770 | } |
771 | |
772 | |
773 | |
774 | /**************************************************************************** |
775 | Transport functions |
776 | ****************************************************************************/ |
777 | |
778 | /* set_audio_format() sets the format of the audio data in host memory for |
779 | this pipe. Note that _MS_ (mono-to-stereo) playback modes are not used by ALSA |
780 | but they are here because they are just mono while capturing */ |
781 | static void set_audio_format(struct echoaudio *chip, u16 pipe_index, |
782 | const struct audioformat *format) |
783 | { |
784 | u16 dsp_format; |
785 | |
786 | dsp_format = DSP_AUDIOFORM_SS_16LE; |
787 | |
788 | /* Look for super-interleave (no big-endian and 8 bits) */ |
789 | if (format->interleave > 2) { |
790 | switch (format->bits_per_sample) { |
791 | case 16: |
792 | dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_16LE; |
793 | break; |
794 | case 24: |
795 | dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_24LE; |
796 | break; |
797 | case 32: |
798 | dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_32LE; |
799 | break; |
800 | } |
801 | dsp_format |= format->interleave; |
802 | } else if (format->data_are_bigendian) { |
803 | /* For big-endian data, only 32 bit samples are supported */ |
804 | switch (format->interleave) { |
805 | case 1: |
806 | dsp_format = DSP_AUDIOFORM_MM_32BE; |
807 | break; |
808 | #ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32 |
809 | case 2: |
810 | dsp_format = DSP_AUDIOFORM_SS_32BE; |
811 | break; |
812 | #endif |
813 | } |
814 | } else if (format->interleave == 1 && |
815 | format->bits_per_sample == 32 && !format->mono_to_stereo) { |
816 | /* 32 bit little-endian mono->mono case */ |
817 | dsp_format = DSP_AUDIOFORM_MM_32LE; |
818 | } else { |
819 | /* Handle the other little-endian formats */ |
820 | switch (format->bits_per_sample) { |
821 | case 8: |
822 | if (format->interleave == 2) |
823 | dsp_format = DSP_AUDIOFORM_SS_8; |
824 | else |
825 | dsp_format = DSP_AUDIOFORM_MS_8; |
826 | break; |
827 | default: |
828 | case 16: |
829 | if (format->interleave == 2) |
830 | dsp_format = DSP_AUDIOFORM_SS_16LE; |
831 | else |
832 | dsp_format = DSP_AUDIOFORM_MS_16LE; |
833 | break; |
834 | case 24: |
835 | if (format->interleave == 2) |
836 | dsp_format = DSP_AUDIOFORM_SS_24LE; |
837 | else |
838 | dsp_format = DSP_AUDIOFORM_MS_24LE; |
839 | break; |
840 | case 32: |
841 | if (format->interleave == 2) |
842 | dsp_format = DSP_AUDIOFORM_SS_32LE; |
843 | else |
844 | dsp_format = DSP_AUDIOFORM_MS_32LE; |
845 | break; |
846 | } |
847 | } |
848 | dev_dbg(chip->card->dev, |
849 | "set_audio_format[%d] = %x\n" , pipe_index, dsp_format); |
850 | chip->comm_page->audio_format[pipe_index] = cpu_to_le16(dsp_format); |
851 | } |
852 | |
853 | |
854 | |
855 | /* start_transport starts transport for a set of pipes. |
856 | The bits 1 in channel_mask specify what pipes to start. Only the bit of the |
857 | first channel must be set, regardless its interleave. |
858 | Same thing for pause_ and stop_ -trasport below. */ |
859 | static int start_transport(struct echoaudio *chip, u32 channel_mask, |
860 | u32 cyclic_mask) |
861 | { |
862 | |
863 | if (wait_handshake(chip)) |
864 | return -EIO; |
865 | |
866 | chip->comm_page->cmd_start |= cpu_to_le32(channel_mask); |
867 | |
868 | if (chip->comm_page->cmd_start) { |
869 | clear_handshake(chip); |
870 | send_vector(chip, DSP_VC_START_TRANSFER); |
871 | if (wait_handshake(chip)) |
872 | return -EIO; |
873 | /* Keep track of which pipes are transporting */ |
874 | chip->active_mask |= channel_mask; |
875 | chip->comm_page->cmd_start = 0; |
876 | return 0; |
877 | } |
878 | |
879 | dev_err(chip->card->dev, "start_transport: No pipes to start!\n" ); |
880 | return -EINVAL; |
881 | } |
882 | |
883 | |
884 | |
885 | static int pause_transport(struct echoaudio *chip, u32 channel_mask) |
886 | { |
887 | |
888 | if (wait_handshake(chip)) |
889 | return -EIO; |
890 | |
891 | chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask); |
892 | chip->comm_page->cmd_reset = 0; |
893 | if (chip->comm_page->cmd_stop) { |
894 | clear_handshake(chip); |
895 | send_vector(chip, DSP_VC_STOP_TRANSFER); |
896 | if (wait_handshake(chip)) |
897 | return -EIO; |
898 | /* Keep track of which pipes are transporting */ |
899 | chip->active_mask &= ~channel_mask; |
900 | chip->comm_page->cmd_stop = 0; |
901 | chip->comm_page->cmd_reset = 0; |
902 | return 0; |
903 | } |
904 | |
905 | dev_dbg(chip->card->dev, "pause_transport: No pipes to stop!\n" ); |
906 | return 0; |
907 | } |
908 | |
909 | |
910 | |
911 | static int stop_transport(struct echoaudio *chip, u32 channel_mask) |
912 | { |
913 | |
914 | if (wait_handshake(chip)) |
915 | return -EIO; |
916 | |
917 | chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask); |
918 | chip->comm_page->cmd_reset |= cpu_to_le32(channel_mask); |
919 | if (chip->comm_page->cmd_reset) { |
920 | clear_handshake(chip); |
921 | send_vector(chip, DSP_VC_STOP_TRANSFER); |
922 | if (wait_handshake(chip)) |
923 | return -EIO; |
924 | /* Keep track of which pipes are transporting */ |
925 | chip->active_mask &= ~channel_mask; |
926 | chip->comm_page->cmd_stop = 0; |
927 | chip->comm_page->cmd_reset = 0; |
928 | return 0; |
929 | } |
930 | |
931 | dev_dbg(chip->card->dev, "stop_transport: No pipes to stop!\n" ); |
932 | return 0; |
933 | } |
934 | |
935 | |
936 | |
937 | static inline int is_pipe_allocated(struct echoaudio *chip, u16 pipe_index) |
938 | { |
939 | return (chip->pipe_alloc_mask & (1 << pipe_index)); |
940 | } |
941 | |
942 | |
943 | |
944 | /* Stops everything and turns off the DSP. All pipes should be already |
945 | stopped and unallocated. */ |
946 | static int rest_in_peace(struct echoaudio *chip) |
947 | { |
948 | |
949 | /* Stops all active pipes (just to be sure) */ |
950 | stop_transport(chip, channel_mask: chip->active_mask); |
951 | |
952 | set_meters_on(chip, on: false); |
953 | |
954 | #ifdef ECHOCARD_HAS_MIDI |
955 | enable_midi_input(chip, false); |
956 | #endif |
957 | |
958 | /* Go to sleep */ |
959 | if (chip->dsp_code) { |
960 | /* Make load_firmware do a complete reload */ |
961 | chip->dsp_code = NULL; |
962 | /* Put the DSP to sleep */ |
963 | return send_vector(chip, DSP_VC_GO_COMATOSE); |
964 | } |
965 | return 0; |
966 | } |
967 | |
968 | |
969 | |
970 | /* Fills the comm page with default values */ |
971 | static int init_dsp_comm_page(struct echoaudio *chip) |
972 | { |
973 | /* Check if the compiler added extra padding inside the structure */ |
974 | if (offsetof(struct comm_page, midi_output) != 0xbe0) { |
975 | dev_err(chip->card->dev, |
976 | "init_dsp_comm_page() - Invalid struct comm_page structure\n" ); |
977 | return -EPERM; |
978 | } |
979 | |
980 | /* Init all the basic stuff */ |
981 | chip->card_name = ECHOCARD_NAME; |
982 | chip->bad_board = true; /* Set true until DSP loaded */ |
983 | chip->dsp_code = NULL; /* Current DSP code not loaded */ |
984 | chip->asic_loaded = false; |
985 | memset(chip->comm_page, 0, sizeof(struct comm_page)); |
986 | |
987 | /* Init the comm page */ |
988 | chip->comm_page->comm_size = |
989 | cpu_to_le32(sizeof(struct comm_page)); |
990 | chip->comm_page->handshake = cpu_to_le32(0xffffffff); |
991 | chip->comm_page->midi_out_free_count = |
992 | cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE); |
993 | chip->comm_page->sample_rate = cpu_to_le32(44100); |
994 | |
995 | /* Set line levels so we don't blast any inputs on startup */ |
996 | memset(chip->comm_page->monitors, ECHOGAIN_MUTED, MONITOR_ARRAY_SIZE); |
997 | memset(chip->comm_page->vmixer, ECHOGAIN_MUTED, VMIXER_ARRAY_SIZE); |
998 | |
999 | return 0; |
1000 | } |
1001 | |
1002 | |
1003 | |
1004 | /* This function initializes the chip structure with default values, ie. all |
1005 | * muted and internal clock source. Then it copies the settings to the DSP. |
1006 | * This MUST be called after the DSP is up and running ! |
1007 | */ |
1008 | static int init_line_levels(struct echoaudio *chip) |
1009 | { |
1010 | memset(chip->output_gain, ECHOGAIN_MUTED, sizeof(chip->output_gain)); |
1011 | memset(chip->input_gain, ECHOGAIN_MUTED, sizeof(chip->input_gain)); |
1012 | memset(chip->monitor_gain, ECHOGAIN_MUTED, sizeof(chip->monitor_gain)); |
1013 | memset(chip->vmixer_gain, ECHOGAIN_MUTED, sizeof(chip->vmixer_gain)); |
1014 | chip->input_clock = ECHO_CLOCK_INTERNAL; |
1015 | chip->output_clock = ECHO_CLOCK_WORD; |
1016 | chip->sample_rate = 44100; |
1017 | return restore_dsp_rettings(chip); |
1018 | } |
1019 | |
1020 | |
1021 | |
1022 | /* This is low level part of the interrupt handler. |
1023 | It returns -1 if the IRQ is not ours, or N>=0 if it is, where N is the number |
1024 | of midi data in the input queue. */ |
1025 | static int service_irq(struct echoaudio *chip) |
1026 | { |
1027 | int st; |
1028 | |
1029 | /* Read the DSP status register and see if this DSP generated this interrupt */ |
1030 | if (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_IRQ) { |
1031 | st = 0; |
1032 | #ifdef ECHOCARD_HAS_MIDI |
1033 | /* Get and parse midi data if present */ |
1034 | if (chip->comm_page->midi_input[0]) /* The count is at index 0 */ |
1035 | st = midi_service_irq(chip); /* Returns how many midi bytes we received */ |
1036 | #endif |
1037 | /* Clear the hardware interrupt */ |
1038 | chip->comm_page->midi_input[0] = 0; |
1039 | send_vector(chip, DSP_VC_ACK_INT); |
1040 | return st; |
1041 | } |
1042 | return -1; |
1043 | } |
1044 | |
1045 | |
1046 | |
1047 | |
1048 | /****************************************************************************** |
1049 | Functions for opening and closing pipes |
1050 | ******************************************************************************/ |
1051 | |
1052 | /* allocate_pipes is used to reserve audio pipes for your exclusive use. |
1053 | The call will fail if some pipes are already allocated. */ |
1054 | static int allocate_pipes(struct echoaudio *chip, struct audiopipe *pipe, |
1055 | int pipe_index, int interleave) |
1056 | { |
1057 | int i; |
1058 | u32 channel_mask; |
1059 | |
1060 | dev_dbg(chip->card->dev, |
1061 | "allocate_pipes: ch=%d int=%d\n" , pipe_index, interleave); |
1062 | |
1063 | if (chip->bad_board) |
1064 | return -EIO; |
1065 | |
1066 | for (channel_mask = i = 0; i < interleave; i++) |
1067 | channel_mask |= 1 << (pipe_index + i); |
1068 | if (chip->pipe_alloc_mask & channel_mask) { |
1069 | dev_err(chip->card->dev, |
1070 | "allocate_pipes: channel already open\n" ); |
1071 | return -EAGAIN; |
1072 | } |
1073 | |
1074 | chip->comm_page->position[pipe_index] = 0; |
1075 | chip->pipe_alloc_mask |= channel_mask; |
1076 | /* This driver uses cyclic buffers only */ |
1077 | chip->pipe_cyclic_mask |= channel_mask; |
1078 | pipe->index = pipe_index; |
1079 | pipe->interleave = interleave; |
1080 | pipe->state = PIPE_STATE_STOPPED; |
1081 | |
1082 | /* The counter register is where the DSP writes the 32 bit DMA |
1083 | position for a pipe. The DSP is constantly updating this value as |
1084 | it moves data. The DMA counter is in units of bytes, not samples. */ |
1085 | pipe->dma_counter = (__le32 *)&chip->comm_page->position[pipe_index]; |
1086 | *pipe->dma_counter = 0; |
1087 | return pipe_index; |
1088 | } |
1089 | |
1090 | |
1091 | |
1092 | static int free_pipes(struct echoaudio *chip, struct audiopipe *pipe) |
1093 | { |
1094 | u32 channel_mask; |
1095 | int i; |
1096 | |
1097 | if (snd_BUG_ON(!is_pipe_allocated(chip, pipe->index))) |
1098 | return -EINVAL; |
1099 | if (snd_BUG_ON(pipe->state != PIPE_STATE_STOPPED)) |
1100 | return -EINVAL; |
1101 | |
1102 | for (channel_mask = i = 0; i < pipe->interleave; i++) |
1103 | channel_mask |= 1 << (pipe->index + i); |
1104 | |
1105 | chip->pipe_alloc_mask &= ~channel_mask; |
1106 | chip->pipe_cyclic_mask &= ~channel_mask; |
1107 | return 0; |
1108 | } |
1109 | |
1110 | |
1111 | |
1112 | /****************************************************************************** |
1113 | Functions for managing the scatter-gather list |
1114 | ******************************************************************************/ |
1115 | |
1116 | static int sglist_init(struct echoaudio *chip, struct audiopipe *pipe) |
1117 | { |
1118 | pipe->sglist_head = 0; |
1119 | memset(pipe->sgpage.area, 0, PAGE_SIZE); |
1120 | chip->comm_page->sglist_addr[pipe->index].addr = |
1121 | cpu_to_le32(pipe->sgpage.addr); |
1122 | return 0; |
1123 | } |
1124 | |
1125 | |
1126 | |
1127 | static int sglist_add_mapping(struct echoaudio *chip, struct audiopipe *pipe, |
1128 | dma_addr_t address, size_t length) |
1129 | { |
1130 | int head = pipe->sglist_head; |
1131 | struct sg_entry *list = (struct sg_entry *)pipe->sgpage.area; |
1132 | |
1133 | if (head < MAX_SGLIST_ENTRIES - 1) { |
1134 | list[head].addr = cpu_to_le32(address); |
1135 | list[head].size = cpu_to_le32(length); |
1136 | pipe->sglist_head++; |
1137 | } else { |
1138 | dev_err(chip->card->dev, "SGlist: too many fragments\n" ); |
1139 | return -ENOMEM; |
1140 | } |
1141 | return 0; |
1142 | } |
1143 | |
1144 | |
1145 | |
1146 | static inline int sglist_add_irq(struct echoaudio *chip, struct audiopipe *pipe) |
1147 | { |
1148 | return sglist_add_mapping(chip, pipe, address: 0, length: 0); |
1149 | } |
1150 | |
1151 | |
1152 | |
1153 | static inline int sglist_wrap(struct echoaudio *chip, struct audiopipe *pipe) |
1154 | { |
1155 | return sglist_add_mapping(chip, pipe, address: pipe->sgpage.addr, length: 0); |
1156 | } |
1157 | |