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