1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
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
39
40
41
42static int wait_handshake(struct echoaudio *chip)
43{
44 int i;
45
46
47 for (i = 0; i < HANDSHAKE_TIMEOUT; i++) {
48
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
63
64
65
66static int send_vector(struct echoaudio *chip, u32 command)
67{
68 int i;
69
70 wmb();
71
72
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
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
90
91static int write_dsp(struct echoaudio *chip, u32 data)
92{
93 u32 status, i;
94
95 for (i = 0; i < 10000000; i++) {
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();
100 return 0;
101 }
102 udelay(1);
103 cond_resched();
104 }
105
106 chip->bad_board = true;
107 dev_dbg(chip->card->dev, "write_dsp: Set bad_board to true\n");
108 return -EIO;
109}
110
111
112
113
114
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;
130 dev_err(chip->card->dev, "read_dsp: Set bad_board to true\n");
131 return -EIO;
132}
133
134
135
136
137
138
139
140
141
142
143
144
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 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
167static inline int check_asic_status(struct echoaudio *chip)
168{
169 chip->asic_loaded = true;
170 return 0;
171}
172
173#endif
174
175
176
177#ifdef ECHOCARD_HAS_ASIC
178
179
180static 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
197 if (write_dsp(chip, cmd) < 0)
198 goto la_error;
199
200
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
212la_error:
213 dev_err(chip->card->dev, "failed on write_dsp\n");
214 free_firmware(fw, chip);
215 return -EIO;
216}
217
218#endif
219
220
221
222#ifdef DSP_56361
223
224
225
226
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
236
237 if (chip->device_id != DEVICE_ID_56361)
238 return 0;
239
240
241
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
257
258
259
260
261
262
263
264
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
271
272
273 index = code[0];
274
275
276 index += 3;
277
278
279 words = code[index++];
280
281
282 address = ((u32)code[index] << 16) + code[index + 1];
283 index += 2;
284
285
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
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
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
311 for (i = 0; i < 200; i++) {
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
327irl_error:
328 free_firmware(fw, chip);
329 return -EIO;
330}
331
332#endif
333
334
335static 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;
345 chip->dsp_code = NULL;
346 chip->asic_loaded = false;
347
348 dev_dbg(chip->card->dev, "load_dsp: Set bad_board to true\n");
349
350
351#ifdef DSP_56361
352 i = install_resident_loader(chip);
353 if (i < 0)
354 return i;
355#endif
356
357
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
364 udelay(10);
365
366
367 for (i = 0; i < 1000; i++) {
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
381 set_dsp_register(chip, CHI32_CONTROL_REG,
382 get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900);
383
384
385
386 index = code[0];
387 for (;;) {
388 int block_type, mem_type;
389
390
391 index++;
392
393
394 block_type = code[index];
395 if (block_type == 4)
396 break;
397
398 index++;
399
400
401 mem_type = code[index++];
402
403
404 words = code[index++];
405 if (words == 0)
406 break;
407
408
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
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) {
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++) {
446
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
465
466
467
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;
475 chip->bad_board = false;
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
489static 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
498 if (chip->dsp_code) {
499 box_type = check_asic_status(chip);
500 if (box_type >= 0)
501 return box_type;
502
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;
517
518 return box_type;
519}
520
521
522
523
524
525
526
527#if defined(ECHOCARD_HAS_INPUT_NOMINAL_LEVEL) || \
528 defined(ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL)
529
530
531static 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
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
551
552
553
554
555static 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
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
573static 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
588
589
590
591static 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
602static 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
613
614static 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
632
633
634
635
636
637
638
639static 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;
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
669static 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
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
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
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
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
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
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
776
777
778
779
780
781static 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
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
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
817 dsp_format = DSP_AUDIOFORM_MM_32LE;
818 } else {
819
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
856
857
858
859static 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
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
885static 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
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
911static 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
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
937static 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
945
946static int rest_in_peace(struct echoaudio *chip)
947{
948
949
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
959 if (chip->dsp_code) {
960
961 chip->dsp_code = NULL;
962
963 return send_vector(chip, DSP_VC_GO_COMATOSE);
964 }
965 return 0;
966}
967
968
969
970
971static int init_dsp_comm_page(struct echoaudio *chip)
972{
973
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
981 chip->card_name = ECHOCARD_NAME;
982 chip->bad_board = true;
983 chip->dsp_code = NULL;
984 chip->asic_loaded = false;
985 memset(chip->comm_page, 0, sizeof(struct comm_page));
986
987
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
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
1005
1006
1007
1008static 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
1023
1024
1025static int service_irq(struct echoaudio *chip)
1026{
1027 int st;
1028
1029
1030 if (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_IRQ) {
1031 st = 0;
1032#ifdef ECHOCARD_HAS_MIDI
1033
1034 if (chip->comm_page->midi_input[0])
1035 st = midi_service_irq(chip);
1036#endif
1037
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
1050
1051
1052
1053
1054static 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
1077 chip->pipe_cyclic_mask |= channel_mask;
1078 pipe->index = pipe_index;
1079 pipe->interleave = interleave;
1080 pipe->state = PIPE_STATE_STOPPED;
1081
1082
1083
1084
1085 pipe->dma_counter = (__le32 *)&chip->comm_page->position[pipe_index];
1086 *pipe->dma_counter = 0;
1087 return pipe_index;
1088}
1089
1090
1091
1092static 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
1114
1115
1116static 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
1127static 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
1146static 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
1153static inline int sglist_wrap(struct echoaudio *chip, struct audiopipe *pipe)
1154{
1155 return sglist_add_mapping(chip, pipe, pipe->sgpage.addr, 0);
1156}
1157