Merge branch 'tracing/core-v2' into tracing-for-linus
[linux-2.6] / sound / pci / echoaudio / echoaudio_dsp.c
1 /****************************************************************************
2
3    Copyright Echo Digital Audio Corporation (c) 1998 - 2004
4    All rights reserved
5    www.echoaudio.com
6
7    This file is part of Echo Digital Audio's generic driver library.
8
9    Echo Digital Audio's generic driver library is free software;
10    you can redistribute it and/or modify it under the terms of
11    the GNU General Public License as published by the Free Software
12    Foundation.
13
14    This program is distributed in the hope that it will be useful,
15    but WITHOUT ANY WARRANTY; without even the implied warranty of
16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17    GNU General Public License for more details.
18
19    You should have received a copy of the GNU General Public License
20    along with this program; if not, write to the Free Software
21    Foundation, Inc., 59 Temple Place - Suite 330, Boston,
22    MA  02111-1307, USA.
23
24    *************************************************************************
25
26  Translation from C++ and adaptation for use in ALSA-Driver
27  were made by Giuliano Pochini <pochini@shiny.it>
28
29 ****************************************************************************/
30
31 #if PAGE_SIZE < 4096
32 #error PAGE_SIZE is < 4k
33 #endif
34
35 static int restore_dsp_rettings(struct echoaudio *chip);
36
37
38 /* Some vector commands involve the DSP reading or writing data to and from the
39 comm page; if you send one of these commands to the DSP, it will complete the
40 command and then write a non-zero value to the Handshake field in the
41 comm page.  This function waits for the handshake to show up. */
42 static int wait_handshake(struct echoaudio *chip)
43 {
44         int i;
45
46         /* Wait up to 20ms for the handshake from the DSP */
47         for (i = 0; i < HANDSHAKE_TIMEOUT; i++) {
48                 /* Look for the handshake value */
49                 barrier();
50                 if (chip->comm_page->handshake) {
51                         return 0;
52                 }
53                 udelay(1);
54         }
55
56         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. */
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. */
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. */
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. */
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 */
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 */
178 static int load_asic_generic(struct echoaudio *chip, u32 cmd,
179                              const struct firmware *asic)
180 {
181         const struct firmware *fw;
182         int err;
183         u32 i, size;
184         u8 *code;
185
186         if ((err = get_firmware(&fw, asic, chip)) < 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. */
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         if ((i = get_firmware(&fw, &card_fw[FW_361_LOADER], chip)) < 0) {
249                 snd_printk(KERN_WARNING "Firmware not found !\n");
250                 return i;
251         }
252
253         /* The DSP code is an array of 16 bit words.  The array is divided up
254         into sections.  The first word of each section is the size in words,
255         followed by the section type.
256         Since DSP addresses and data are 24 bits wide, they each take up two
257         16 bit words in the array.
258         This is a lot like the other loader loop, but it's not a loop, you
259         don't write the memory type, and you don't write a zero at the end. */
260
261         /* Set DSP format bits for 24 bit mode */
262         set_dsp_register(chip, CHI32_CONTROL_REG,
263                          get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900);
264
265         code = (u16 *)fw->data;
266
267         /* Skip the header section; the first word in the array is the size
268         of the first section, so the first real section of code is pointed
269         to by Code[0]. */
270         index = code[0];
271
272         /* Skip the section size, LRS block type, and DSP memory type */
273         index += 3;
274
275         /* Get the number of DSP words to write */
276         words = code[index++];
277
278         /* Get the DSP address for this block; 24 bits, so build from two words */
279         address = ((u32)code[index] << 16) + code[index + 1];
280         index += 2;
281
282         /* Write the count to the DSP */
283         if (write_dsp(chip, words)) {
284                 DE_INIT(("install_resident_loader: Failed to write word count!\n"));
285                 goto irl_error;
286         }
287         /* Write the DSP address */
288         if (write_dsp(chip, address)) {
289                 DE_INIT(("install_resident_loader: Failed to write DSP address!\n"));
290                 goto irl_error;
291         }
292         /* Write out this block of code to the DSP */
293         for (i = 0; i < words; i++) {
294                 u32 data;
295
296                 data = ((u32)code[index] << 16) + code[index + 1];
297                 if (write_dsp(chip, data)) {
298                         DE_INIT(("install_resident_loader: Failed to write DSP code\n"));
299                         goto irl_error;
300                 }
301                 index += 2;
302         }
303
304         /* Wait for flag 5 to come up */
305         for (i = 0; i < 200; i++) {     /* Timeout is 50us * 200 = 10ms */
306                 udelay(50);
307                 status = get_dsp_register(chip, CHI32_STATUS_REG);
308                 if (status & CHI32_STATUS_REG_HF5)
309                         break;
310         }
311
312         if (i == 200) {
313                 DE_INIT(("Resident loader failed to set HF5\n"));
314                 goto irl_error;
315         }
316
317         DE_INIT(("Resident loader successfully installed\n"));
318         free_firmware(fw);
319         return 0;
320
321 irl_error:
322         free_firmware(fw);
323         return -EIO;
324 }
325
326 #endif /* DSP_56361 */
327
328
329 static int load_dsp(struct echoaudio *chip, u16 *code)
330 {
331         u32 address, data;
332         int index, words, i;
333
334         if (chip->dsp_code == code) {
335                 DE_INIT(("DSP is already loaded!\n"));
336                 return 0;
337         }
338         chip->bad_board = TRUE;         /* Set TRUE until DSP loaded */
339         chip->dsp_code = NULL;          /* Current DSP code not loaded */
340         chip->asic_loaded = FALSE;      /* Loading the DSP code will reset the ASIC */
341
342         DE_INIT(("load_dsp: Set bad_board to TRUE\n"));
343
344         /* If this board requires a resident loader, install it. */
345 #ifdef DSP_56361
346         if ((i = install_resident_loader(chip)) < 0)
347                 return i;
348 #endif
349
350         /* Send software reset command */
351         if (send_vector(chip, DSP_VC_RESET) < 0) {
352                 DE_INIT(("LoadDsp: send_vector DSP_VC_RESET failed, Critical Failure\n"));
353                 return -EIO;
354         }
355         /* Delay 10us */
356         udelay(10);
357
358         /* Wait 10ms for HF3 to indicate that software reset is complete */
359         for (i = 0; i < 1000; i++) {    /* Timeout is 10us * 1000 = 10ms */
360                 if (get_dsp_register(chip, CHI32_STATUS_REG) &
361                     CHI32_STATUS_REG_HF3)
362                         break;
363                 udelay(10);
364         }
365
366         if (i == 1000) {
367                 DE_INIT(("load_dsp: Timeout waiting for CHI32_STATUS_REG_HF3\n"));
368                 return -EIO;
369         }
370
371         /* Set DSP format bits for 24 bit mode now that soft reset is done */
372         set_dsp_register(chip, CHI32_CONTROL_REG,
373                          get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900);
374
375         /* Main loader loop */
376
377         index = code[0];
378         for (;;) {
379                 int block_type, mem_type;
380
381                 /* Total Block Size */
382                 index++;
383
384                 /* Block Type */
385                 block_type = code[index];
386                 if (block_type == 4)    /* We're finished */
387                         break;
388
389                 index++;
390
391                 /* Memory Type  P=0,X=1,Y=2 */
392                 mem_type = code[index++];
393
394                 /* Block Code Size */
395                 words = code[index++];
396                 if (words == 0)         /* We're finished */
397                         break;
398
399                 /* Start Address */
400                 address = ((u32)code[index] << 16) + code[index + 1];
401                 index += 2;
402
403                 if (write_dsp(chip, words) < 0) {
404                         DE_INIT(("load_dsp: failed to write number of DSP words\n"));
405                         return -EIO;
406                 }
407                 if (write_dsp(chip, address) < 0) {
408                         DE_INIT(("load_dsp: failed to write DSP address\n"));
409                         return -EIO;
410                 }
411                 if (write_dsp(chip, mem_type) < 0) {
412                         DE_INIT(("load_dsp: failed to write DSP memory type\n"));
413                         return -EIO;
414                 }
415                 /* Code */
416                 for (i = 0; i < words; i++, index+=2) {
417                         data = ((u32)code[index] << 16) + code[index + 1];
418                         if (write_dsp(chip, data) < 0) {
419                                 DE_INIT(("load_dsp: failed to write DSP data\n"));
420                                 return -EIO;
421                         }
422                 }
423         }
424
425         if (write_dsp(chip, 0) < 0) {   /* We're done!!! */
426                 DE_INIT(("load_dsp: Failed to write final zero\n"));
427                 return -EIO;
428         }
429         udelay(10);
430
431         for (i = 0; i < 5000; i++) {    /* Timeout is 100us * 5000 = 500ms */
432                 /* Wait for flag 4 - indicates that the DSP loaded OK */
433                 if (get_dsp_register(chip, CHI32_STATUS_REG) &
434                     CHI32_STATUS_REG_HF4) {
435                         set_dsp_register(chip, CHI32_CONTROL_REG,
436                                          get_dsp_register(chip, CHI32_CONTROL_REG) & ~0x1b00);
437
438                         if (write_dsp(chip, DSP_FNC_SET_COMMPAGE_ADDR) < 0) {
439                                 DE_INIT(("load_dsp: Failed to write DSP_FNC_SET_COMMPAGE_ADDR\n"));
440                                 return -EIO;
441                         }
442
443                         if (write_dsp(chip, chip->comm_page_phys) < 0) {
444                                 DE_INIT(("load_dsp: Failed to write comm page address\n"));
445                                 return -EIO;
446                         }
447
448                         /* Get the serial number via slave mode.
449                         This is triggered by the SET_COMMPAGE_ADDR command.
450                         We don't actually use the serial number but we have to
451                         get it as part of the DSP init voodoo. */
452                         if (read_sn(chip) < 0) {
453                                 DE_INIT(("load_dsp: Failed to read serial number\n"));
454                                 return -EIO;
455                         }
456
457                         chip->dsp_code = code;          /* Show which DSP code loaded */
458                         chip->bad_board = FALSE;        /* DSP OK */
459                         DE_INIT(("load_dsp: OK!\n"));
460                         return 0;
461                 }
462                 udelay(100);
463         }
464
465         DE_INIT(("load_dsp: DSP load timed out waiting for HF4\n"));
466         return -EIO;
467 }
468
469
470
471 /* load_firmware takes care of loading the DSP and any ASIC code. */
472 static int load_firmware(struct echoaudio *chip)
473 {
474         const struct firmware *fw;
475         int box_type, err;
476
477         if (snd_BUG_ON(!chip->dsp_code_to_load || !chip->comm_page))
478                 return -EPERM;
479
480         /* See if the ASIC is present and working - only if the DSP is already loaded */
481         if (chip->dsp_code) {
482                 if ((box_type = check_asic_status(chip)) >= 0)
483                         return box_type;
484                 /* ASIC check failed; force the DSP to reload */
485                 chip->dsp_code = NULL;
486         }
487
488         if ((err = get_firmware(&fw, chip->dsp_code_to_load, chip)) < 0)
489                 return err;
490         err = load_dsp(chip, (u16 *)fw->data);
491         free_firmware(fw);
492         if (err < 0)
493                 return err;
494
495         if ((box_type = load_asic(chip)) < 0)
496                 return box_type;        /* error */
497
498         if ((err = restore_dsp_rettings(chip)) < 0)
499                 return err;
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) */
514 static 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). */
538 static 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. */
556 static 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. */
574 static 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 */
585 static 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
596 will write the meter and clock detect values to the comm page at about 30Hz */
597 static 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.
615 Meters 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
620 This function assumes there are no more than 16 in/out busses or pipes
621 Meters is an array [3][16][2] of long. */
622 static 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
658 static int restore_dsp_rettings(struct echoaudio *chip)
659 {
660         int 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         if ((err = set_sample_rate(chip, chip->sample_rate)) < 0)
672                 return err;
673
674         if (chip->meters_enabled)
675                 if (send_vector(chip, DSP_VC_METERS_ON) < 0)
676                         return -EIO;
677
678 #ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
679         if (set_input_clock(chip, chip->input_clock) < 0)
680                 return -EIO;
681 #endif
682
683 #ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH
684         if (set_output_clock(chip, chip->output_clock) < 0)
685                 return -EIO;
686 #endif
687
688         if (update_output_line_level(chip) < 0)
689                 return -EIO;
690
691         if (update_input_line_level(chip) < 0)
692                 return -EIO;
693
694 #ifdef ECHOCARD_HAS_VMIXER
695         if (update_vmixer_level(chip) < 0)
696                 return -EIO;
697 #endif
698
699         if (wait_handshake(chip) < 0)
700                 return -EIO;
701         clear_handshake(chip);
702
703         DE_INIT(("restore_dsp_rettings done\n"));
704         return send_vector(chip, DSP_VC_UPDATE_FLAGS);
705 }
706
707
708
709 /****************************************************************************
710         Transport functions
711  ****************************************************************************/
712
713 /* set_audio_format() sets the format of the audio data in host memory for
714 this pipe.  Note that _MS_ (mono-to-stereo) playback modes are not used by ALSA
715 but they are here because they are just mono while capturing */
716 static void set_audio_format(struct echoaudio *chip, u16 pipe_index,
717                              const struct audioformat *format)
718 {
719         u16 dsp_format;
720
721         dsp_format = DSP_AUDIOFORM_SS_16LE;
722
723         /* Look for super-interleave (no big-endian and 8 bits) */
724         if (format->interleave > 2) {
725                 switch (format->bits_per_sample) {
726                 case 16:
727                         dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_16LE;
728                         break;
729                 case 24:
730                         dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_24LE;
731                         break;
732                 case 32:
733                         dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_32LE;
734                         break;
735                 }
736                 dsp_format |= format->interleave;
737         } else if (format->data_are_bigendian) {
738                 /* For big-endian data, only 32 bit samples are supported */
739                 switch (format->interleave) {
740                 case 1:
741                         dsp_format = DSP_AUDIOFORM_MM_32BE;
742                         break;
743 #ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
744                 case 2:
745                         dsp_format = DSP_AUDIOFORM_SS_32BE;
746                         break;
747 #endif
748                 }
749         } else if (format->interleave == 1 &&
750                    format->bits_per_sample == 32 && !format->mono_to_stereo) {
751                 /* 32 bit little-endian mono->mono case */
752                 dsp_format = DSP_AUDIOFORM_MM_32LE;
753         } else {
754                 /* Handle the other little-endian formats */
755                 switch (format->bits_per_sample) {
756                 case 8:
757                         if (format->interleave == 2)
758                                 dsp_format = DSP_AUDIOFORM_SS_8;
759                         else
760                                 dsp_format = DSP_AUDIOFORM_MS_8;
761                         break;
762                 default:
763                 case 16:
764                         if (format->interleave == 2)
765                                 dsp_format = DSP_AUDIOFORM_SS_16LE;
766                         else
767                                 dsp_format = DSP_AUDIOFORM_MS_16LE;
768                         break;
769                 case 24:
770                         if (format->interleave == 2)
771                                 dsp_format = DSP_AUDIOFORM_SS_24LE;
772                         else
773                                 dsp_format = DSP_AUDIOFORM_MS_24LE;
774                         break;
775                 case 32:
776                         if (format->interleave == 2)
777                                 dsp_format = DSP_AUDIOFORM_SS_32LE;
778                         else
779                                 dsp_format = DSP_AUDIOFORM_MS_32LE;
780                         break;
781                 }
782         }
783         DE_ACT(("set_audio_format[%d] = %x\n", pipe_index, dsp_format));
784         chip->comm_page->audio_format[pipe_index] = cpu_to_le16(dsp_format);
785 }
786
787
788
789 /* start_transport starts transport for a set of pipes.
790 The bits 1 in channel_mask specify what pipes to start. Only the bit of the
791 first channel must be set, regardless its interleave.
792 Same thing for pause_ and stop_ -trasport below. */
793 static int start_transport(struct echoaudio *chip, u32 channel_mask,
794                            u32 cyclic_mask)
795 {
796         DE_ACT(("start_transport %x\n", channel_mask));
797
798         if (wait_handshake(chip))
799                 return -EIO;
800
801         chip->comm_page->cmd_start |= cpu_to_le32(channel_mask);
802
803         if (chip->comm_page->cmd_start) {
804                 clear_handshake(chip);
805                 send_vector(chip, DSP_VC_START_TRANSFER);
806                 if (wait_handshake(chip))
807                         return -EIO;
808                 /* Keep track of which pipes are transporting */
809                 chip->active_mask |= channel_mask;
810                 chip->comm_page->cmd_start = 0;
811                 return 0;
812         }
813
814         DE_ACT(("start_transport: No pipes to start!\n"));
815         return -EINVAL;
816 }
817
818
819
820 static int pause_transport(struct echoaudio *chip, u32 channel_mask)
821 {
822         DE_ACT(("pause_transport %x\n", channel_mask));
823
824         if (wait_handshake(chip))
825                 return -EIO;
826
827         chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask);
828         chip->comm_page->cmd_reset = 0;
829         if (chip->comm_page->cmd_stop) {
830                 clear_handshake(chip);
831                 send_vector(chip, DSP_VC_STOP_TRANSFER);
832                 if (wait_handshake(chip))
833                         return -EIO;
834                 /* Keep track of which pipes are transporting */
835                 chip->active_mask &= ~channel_mask;
836                 chip->comm_page->cmd_stop = 0;
837                 chip->comm_page->cmd_reset = 0;
838                 return 0;
839         }
840
841         DE_ACT(("pause_transport: No pipes to stop!\n"));
842         return 0;
843 }
844
845
846
847 static int stop_transport(struct echoaudio *chip, u32 channel_mask)
848 {
849         DE_ACT(("stop_transport %x\n", channel_mask));
850
851         if (wait_handshake(chip))
852                 return -EIO;
853
854         chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask);
855         chip->comm_page->cmd_reset |= cpu_to_le32(channel_mask);
856         if (chip->comm_page->cmd_reset) {
857                 clear_handshake(chip);
858                 send_vector(chip, DSP_VC_STOP_TRANSFER);
859                 if (wait_handshake(chip))
860                         return -EIO;
861                 /* Keep track of which pipes are transporting */
862                 chip->active_mask &= ~channel_mask;
863                 chip->comm_page->cmd_stop = 0;
864                 chip->comm_page->cmd_reset = 0;
865                 return 0;
866         }
867
868         DE_ACT(("stop_transport: No pipes to stop!\n"));
869         return 0;
870 }
871
872
873
874 static inline int is_pipe_allocated(struct echoaudio *chip, u16 pipe_index)
875 {
876         return (chip->pipe_alloc_mask & (1 << pipe_index));
877 }
878
879
880
881 /* Stops everything and turns off the DSP. All pipes should be already
882 stopped and unallocated. */
883 static int rest_in_peace(struct echoaudio *chip)
884 {
885         DE_ACT(("rest_in_peace() open=%x\n", chip->pipe_alloc_mask));
886
887         /* Stops all active pipes (just to be sure) */
888         stop_transport(chip, chip->active_mask);
889
890         set_meters_on(chip, FALSE);
891
892 #ifdef ECHOCARD_HAS_MIDI
893         enable_midi_input(chip, FALSE);
894 #endif
895
896         /* Go to sleep */
897         if (chip->dsp_code) {
898                 /* Make load_firmware do a complete reload */
899                 chip->dsp_code = NULL;
900                 /* Put the DSP to sleep */
901                 return send_vector(chip, DSP_VC_GO_COMATOSE);
902         }
903         return 0;
904 }
905
906
907
908 /* Fills the comm page with default values */
909 static int init_dsp_comm_page(struct echoaudio *chip)
910 {
911         /* Check if the compiler added extra padding inside the structure */
912         if (offsetof(struct comm_page, midi_output) != 0xbe0) {
913                 DE_INIT(("init_dsp_comm_page() - Invalid struct comm_page structure\n"));
914                 return -EPERM;
915         }
916
917         /* Init all the basic stuff */
918         chip->card_name = ECHOCARD_NAME;
919         chip->bad_board = TRUE; /* Set TRUE until DSP loaded */
920         chip->dsp_code = NULL;  /* Current DSP code not loaded */
921         chip->digital_mode = DIGITAL_MODE_NONE;
922         chip->input_clock = ECHO_CLOCK_INTERNAL;
923         chip->output_clock = ECHO_CLOCK_WORD;
924         chip->asic_loaded = FALSE;
925         memset(chip->comm_page, 0, sizeof(struct comm_page));
926
927         /* Init the comm page */
928         chip->comm_page->comm_size =
929                 cpu_to_le32(sizeof(struct comm_page));
930         chip->comm_page->handshake = 0xffffffff;
931         chip->comm_page->midi_out_free_count =
932                 cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE);
933         chip->comm_page->sample_rate = cpu_to_le32(44100);
934         chip->sample_rate = 44100;
935
936         /* Set line levels so we don't blast any inputs on startup */
937         memset(chip->comm_page->monitors, ECHOGAIN_MUTED, MONITOR_ARRAY_SIZE);
938         memset(chip->comm_page->vmixer, ECHOGAIN_MUTED, VMIXER_ARRAY_SIZE);
939
940         return 0;
941 }
942
943
944
945 /* This function initializes the several volume controls for busses and pipes.
946 This MUST be called after the DSP is up and running ! */
947 static int init_line_levels(struct echoaudio *chip)
948 {
949         int st, i, o;
950
951         DE_INIT(("init_line_levels\n"));
952
953         /* Mute output busses */
954         for (i = 0; i < num_busses_out(chip); i++)
955                 if ((st = set_output_gain(chip, i, ECHOGAIN_MUTED)))
956                         return st;
957         if ((st = update_output_line_level(chip)))
958                 return st;
959
960 #ifdef ECHOCARD_HAS_VMIXER
961         /* Mute the Vmixer */
962         for (i = 0; i < num_pipes_out(chip); i++)
963                 for (o = 0; o < num_busses_out(chip); o++)
964                         if ((st = set_vmixer_gain(chip, o, i, ECHOGAIN_MUTED)))
965                                 return st;
966         if ((st = update_vmixer_level(chip)))
967                 return st;
968 #endif /* ECHOCARD_HAS_VMIXER */
969
970 #ifdef ECHOCARD_HAS_MONITOR
971         /* Mute the monitor mixer */
972         for (o = 0; o < num_busses_out(chip); o++)
973                 for (i = 0; i < num_busses_in(chip); i++)
974                         if ((st = set_monitor_gain(chip, o, i, ECHOGAIN_MUTED)))
975                                 return st;
976         if ((st = update_output_line_level(chip)))
977                 return st;
978 #endif /* ECHOCARD_HAS_MONITOR */
979
980 #ifdef ECHOCARD_HAS_INPUT_GAIN
981         for (i = 0; i < num_busses_in(chip); i++)
982                 if ((st = set_input_gain(chip, i, ECHOGAIN_MUTED)))
983                         return st;
984         if ((st = update_input_line_level(chip)))
985                 return st;
986 #endif /* ECHOCARD_HAS_INPUT_GAIN */
987
988         return 0;
989 }
990
991
992
993 /* This is low level part of the interrupt handler.
994 It returns -1 if the IRQ is not ours, or N>=0 if it is, where N is the number
995 of midi data in the input queue. */
996 static int service_irq(struct echoaudio *chip)
997 {
998         int st;
999
1000         /* Read the DSP status register and see if this DSP generated this interrupt */
1001         if (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_IRQ) {
1002                 st = 0;
1003 #ifdef ECHOCARD_HAS_MIDI
1004                 /* Get and parse midi data if present */
1005                 if (chip->comm_page->midi_input[0])     /* The count is at index 0 */
1006                         st = midi_service_irq(chip);    /* Returns how many midi bytes we received */
1007 #endif
1008                 /* Clear the hardware interrupt */
1009                 chip->comm_page->midi_input[0] = 0;
1010                 send_vector(chip, DSP_VC_ACK_INT);
1011                 return st;
1012         }
1013         return -1;
1014 }
1015
1016
1017
1018
1019 /******************************************************************************
1020         Functions for opening and closing pipes
1021  ******************************************************************************/
1022
1023 /* allocate_pipes is used to reserve audio pipes for your exclusive use.
1024 The call will fail if some pipes are already allocated. */
1025 static int allocate_pipes(struct echoaudio *chip, struct audiopipe *pipe,
1026                           int pipe_index, int interleave)
1027 {
1028         int i;
1029         u32 channel_mask;
1030         char is_cyclic;
1031
1032         DE_ACT(("allocate_pipes: ch=%d int=%d\n", pipe_index, interleave));
1033
1034         if (chip->bad_board)
1035                 return -EIO;
1036
1037         is_cyclic = 1;  /* This driver uses cyclic buffers only */
1038
1039         for (channel_mask = i = 0; i < interleave; i++)
1040                 channel_mask |= 1 << (pipe_index + i);
1041         if (chip->pipe_alloc_mask & channel_mask) {
1042                 DE_ACT(("allocate_pipes: channel already open\n"));
1043                 return -EAGAIN;
1044         }
1045
1046         chip->comm_page->position[pipe_index] = 0;
1047         chip->pipe_alloc_mask |= channel_mask;
1048         if (is_cyclic)
1049                 chip->pipe_cyclic_mask |= channel_mask;
1050         pipe->index = pipe_index;
1051         pipe->interleave = interleave;
1052         pipe->state = PIPE_STATE_STOPPED;
1053
1054         /* The counter register is where the DSP writes the 32 bit DMA
1055         position for a pipe.  The DSP is constantly updating this value as
1056         it moves data. The DMA counter is in units of bytes, not samples. */
1057         pipe->dma_counter = &chip->comm_page->position[pipe_index];
1058         *pipe->dma_counter = 0;
1059         DE_ACT(("allocate_pipes: ok\n"));
1060         return pipe_index;
1061 }
1062
1063
1064
1065 static int free_pipes(struct echoaudio *chip, struct audiopipe *pipe)
1066 {
1067         u32 channel_mask;
1068         int i;
1069
1070         DE_ACT(("free_pipes: Pipe %d\n", pipe->index));
1071         if (snd_BUG_ON(!is_pipe_allocated(chip, pipe->index)))
1072                 return -EINVAL;
1073         if (snd_BUG_ON(pipe->state != PIPE_STATE_STOPPED))
1074                 return -EINVAL;
1075
1076         for (channel_mask = i = 0; i < pipe->interleave; i++)
1077                 channel_mask |= 1 << (pipe->index + i);
1078
1079         chip->pipe_alloc_mask &= ~channel_mask;
1080         chip->pipe_cyclic_mask &= ~channel_mask;
1081         return 0;
1082 }
1083
1084
1085
1086 /******************************************************************************
1087         Functions for managing the scatter-gather list
1088 ******************************************************************************/
1089
1090 static int sglist_init(struct echoaudio *chip, struct audiopipe *pipe)
1091 {
1092         pipe->sglist_head = 0;
1093         memset(pipe->sgpage.area, 0, PAGE_SIZE);
1094         chip->comm_page->sglist_addr[pipe->index].addr =
1095                 cpu_to_le32(pipe->sgpage.addr);
1096         return 0;
1097 }
1098
1099
1100
1101 static int sglist_add_mapping(struct echoaudio *chip, struct audiopipe *pipe,
1102                                 dma_addr_t address, size_t length)
1103 {
1104         int head = pipe->sglist_head;
1105         struct sg_entry *list = (struct sg_entry *)pipe->sgpage.area;
1106
1107         if (head < MAX_SGLIST_ENTRIES - 1) {
1108                 list[head].addr = cpu_to_le32(address);
1109                 list[head].size = cpu_to_le32(length);
1110                 pipe->sglist_head++;
1111         } else {
1112                 DE_ACT(("SGlist: too many fragments\n"));
1113                 return -ENOMEM;
1114         }
1115         return 0;
1116 }
1117
1118
1119
1120 static inline int sglist_add_irq(struct echoaudio *chip, struct audiopipe *pipe)
1121 {
1122         return sglist_add_mapping(chip, pipe, 0, 0);
1123 }
1124
1125
1126
1127 static inline int sglist_wrap(struct echoaudio *chip, struct audiopipe *pipe)
1128 {
1129         return sglist_add_mapping(chip, pipe, pipe->sgpage.addr, 0);
1130 }