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