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