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 if ((i = install_resident_loader(chip)) < 0)
353 return i;
354#endif
355
356
357 if (send_vector(chip, DSP_VC_RESET) < 0) {
358 dev_err(chip->card->dev,
359 "LoadDsp: send_vector DSP_VC_RESET failed, Critical Failure\n");
360 return -EIO;
361 }
362
363 udelay(10);
364
365
366 for (i = 0; i < 1000; i++) {
367 if (get_dsp_register(chip, CHI32_STATUS_REG) &
368 CHI32_STATUS_REG_HF3)
369 break;
370 udelay(10);
371 }
372
373 if (i == 1000) {
374 dev_err(chip->card->dev,
375 "load_dsp: Timeout waiting for CHI32_STATUS_REG_HF3\n");
376 return -EIO;
377 }
378
379
380 set_dsp_register(chip, CHI32_CONTROL_REG,
381 get_dsp_register(chip, CHI32_CONTROL_REG) | 0x900);
382
383
384
385 index = code[0];
386 for (;;) {
387 int block_type, mem_type;
388
389
390 index++;
391
392
393 block_type = code[index];
394 if (block_type == 4)
395 break;
396
397 index++;
398
399
400 mem_type = code[index++];
401
402
403 words = code[index++];
404 if (words == 0)
405 break;
406
407
408 address = ((u32)code[index] << 16) + code[index + 1];
409 index += 2;
410
411 if (write_dsp(chip, words) < 0) {
412 dev_err(chip->card->dev,
413 "load_dsp: failed to write number of DSP words\n");
414 return -EIO;
415 }
416 if (write_dsp(chip, address) < 0) {
417 dev_err(chip->card->dev,
418 "load_dsp: failed to write DSP address\n");
419 return -EIO;
420 }
421 if (write_dsp(chip, mem_type) < 0) {
422 dev_err(chip->card->dev,
423 "load_dsp: failed to write DSP memory type\n");
424 return -EIO;
425 }
426
427 for (i = 0; i < words; i++, index+=2) {
428 data = ((u32)code[index] << 16) + code[index + 1];
429 if (write_dsp(chip, data) < 0) {
430 dev_err(chip->card->dev,
431 "load_dsp: failed to write DSP data\n");
432 return -EIO;
433 }
434 }
435 }
436
437 if (write_dsp(chip, 0) < 0) {
438 dev_err(chip->card->dev,
439 "load_dsp: Failed to write final zero\n");
440 return -EIO;
441 }
442 udelay(10);
443
444 for (i = 0; i < 5000; i++) {
445
446 if (get_dsp_register(chip, CHI32_STATUS_REG) &
447 CHI32_STATUS_REG_HF4) {
448 set_dsp_register(chip, CHI32_CONTROL_REG,
449 get_dsp_register(chip, CHI32_CONTROL_REG) & ~0x1b00);
450
451 if (write_dsp(chip, DSP_FNC_SET_COMMPAGE_ADDR) < 0) {
452 dev_err(chip->card->dev,
453 "load_dsp: Failed to write DSP_FNC_SET_COMMPAGE_ADDR\n");
454 return -EIO;
455 }
456
457 if (write_dsp(chip, chip->comm_page_phys) < 0) {
458 dev_err(chip->card->dev,
459 "load_dsp: Failed to write comm page address\n");
460 return -EIO;
461 }
462
463
464
465
466
467 if (read_sn(chip) < 0) {
468 dev_err(chip->card->dev,
469 "load_dsp: Failed to read serial number\n");
470 return -EIO;
471 }
472
473 chip->dsp_code = code;
474 chip->bad_board = false;
475 return 0;
476 }
477 udelay(100);
478 }
479
480 dev_err(chip->card->dev,
481 "load_dsp: DSP load timed out waiting for HF4\n");
482 return -EIO;
483}
484
485
486
487
488static int load_firmware(struct echoaudio *chip)
489{
490 const struct firmware *fw;
491 int box_type, err;
492
493 if (snd_BUG_ON(!chip->comm_page))
494 return -EPERM;
495
496
497 if (chip->dsp_code) {
498 if ((box_type = check_asic_status(chip)) >= 0)
499 return box_type;
500
501 chip->dsp_code = NULL;
502 }
503
504 err = get_firmware(&fw, chip, chip->dsp_code_to_load);
505 if (err < 0)
506 return err;
507 err = load_dsp(chip, (u16 *)fw->data);
508 free_firmware(fw, chip);
509 if (err < 0)
510 return err;
511
512 if ((box_type = load_asic(chip)) < 0)
513 return box_type;
514
515 return box_type;
516}
517
518
519
520
521
522
523
524#if defined(ECHOCARD_HAS_INPUT_NOMINAL_LEVEL) || \
525 defined(ECHOCARD_HAS_OUTPUT_NOMINAL_LEVEL)
526
527
528static int set_nominal_level(struct echoaudio *chip, u16 index, char consumer)
529{
530 if (snd_BUG_ON(index >= num_busses_out(chip) + num_busses_in(chip)))
531 return -EINVAL;
532
533
534 if (wait_handshake(chip))
535 return -EIO;
536
537 chip->nominal_level[index] = consumer;
538
539 if (consumer)
540 chip->comm_page->nominal_level_mask |= cpu_to_le32(1 << index);
541 else
542 chip->comm_page->nominal_level_mask &= ~cpu_to_le32(1 << index);
543
544 return 0;
545}
546
547#endif
548
549
550
551
552static int set_output_gain(struct echoaudio *chip, u16 channel, s8 gain)
553{
554 if (snd_BUG_ON(channel >= num_busses_out(chip)))
555 return -EINVAL;
556
557 if (wait_handshake(chip))
558 return -EIO;
559
560
561 chip->output_gain[channel] = gain;
562 chip->comm_page->line_out_level[channel] = gain;
563 return 0;
564}
565
566
567
568#ifdef ECHOCARD_HAS_MONITOR
569
570static int set_monitor_gain(struct echoaudio *chip, u16 output, u16 input,
571 s8 gain)
572{
573 if (snd_BUG_ON(output >= num_busses_out(chip) ||
574 input >= num_busses_in(chip)))
575 return -EINVAL;
576
577 if (wait_handshake(chip))
578 return -EIO;
579
580 chip->monitor_gain[output][input] = gain;
581 chip->comm_page->monitors[monitor_index(chip, output, input)] = gain;
582 return 0;
583}
584#endif
585
586
587
588static int update_output_line_level(struct echoaudio *chip)
589{
590 if (wait_handshake(chip))
591 return -EIO;
592 clear_handshake(chip);
593 return send_vector(chip, DSP_VC_UPDATE_OUTVOL);
594}
595
596
597
598
599static int update_input_line_level(struct echoaudio *chip)
600{
601 if (wait_handshake(chip))
602 return -EIO;
603 clear_handshake(chip);
604 return send_vector(chip, DSP_VC_UPDATE_INGAIN);
605}
606
607
608
609
610
611static void set_meters_on(struct echoaudio *chip, char on)
612{
613 if (on && !chip->meters_enabled) {
614 send_vector(chip, DSP_VC_METERS_ON);
615 chip->meters_enabled = 1;
616 } else if (!on && chip->meters_enabled) {
617 send_vector(chip, DSP_VC_METERS_OFF);
618 chip->meters_enabled = 0;
619 memset((s8 *)chip->comm_page->vu_meter, ECHOGAIN_MUTED,
620 DSP_MAXPIPES);
621 memset((s8 *)chip->comm_page->peak_meter, ECHOGAIN_MUTED,
622 DSP_MAXPIPES);
623 }
624}
625
626
627
628
629
630
631
632
633
634
635
636static void get_audio_meters(struct echoaudio *chip, long *meters)
637{
638 unsigned int i, m, n;
639
640 for (i = 0 ; i < 96; i++)
641 meters[i] = 0;
642
643 for (m = 0, n = 0, i = 0; i < num_busses_out(chip); i++, m++) {
644 meters[n++] = chip->comm_page->vu_meter[m];
645 meters[n++] = chip->comm_page->peak_meter[m];
646 }
647
648#ifdef ECHOCARD_ECHO3G
649 m = E3G_MAX_OUTPUTS;
650#endif
651
652 for (n = 32, i = 0; i < num_busses_in(chip); i++, m++) {
653 meters[n++] = chip->comm_page->vu_meter[m];
654 meters[n++] = chip->comm_page->peak_meter[m];
655 }
656#ifdef ECHOCARD_HAS_VMIXER
657 for (n = 64, i = 0; i < num_pipes_out(chip); i++, m++) {
658 meters[n++] = chip->comm_page->vu_meter[m];
659 meters[n++] = chip->comm_page->peak_meter[m];
660 }
661#endif
662}
663
664
665
666static int restore_dsp_rettings(struct echoaudio *chip)
667{
668 int i, o, err;
669
670 if ((err = check_asic_status(chip)) < 0)
671 return err;
672
673
674 chip->comm_page->gd_clock_state = GD_CLOCK_UNDEF;
675 chip->comm_page->gd_spdif_status = GD_SPDIF_STATUS_UNDEF;
676 chip->comm_page->handshake = cpu_to_le32(0xffffffff);
677
678
679 for (i = 0; i < num_busses_out(chip); i++) {
680 err = set_output_gain(chip, i, chip->output_gain[i]);
681 if (err < 0)
682 return err;
683 }
684
685#ifdef ECHOCARD_HAS_VMIXER
686 for (i = 0; i < num_pipes_out(chip); i++)
687 for (o = 0; o < num_busses_out(chip); o++) {
688 err = set_vmixer_gain(chip, o, i,
689 chip->vmixer_gain[o][i]);
690 if (err < 0)
691 return err;
692 }
693 if (update_vmixer_level(chip) < 0)
694 return -EIO;
695#endif
696
697#ifdef ECHOCARD_HAS_MONITOR
698 for (o = 0; o < num_busses_out(chip); o++)
699 for (i = 0; i < num_busses_in(chip); i++) {
700 err = set_monitor_gain(chip, o, i,
701 chip->monitor_gain[o][i]);
702 if (err < 0)
703 return err;
704 }
705#endif
706
707#ifdef ECHOCARD_HAS_INPUT_GAIN
708 for (i = 0; i < num_busses_in(chip); i++) {
709 err = set_input_gain(chip, i, chip->input_gain[i]);
710 if (err < 0)
711 return err;
712 }
713#endif
714
715 err = update_output_line_level(chip);
716 if (err < 0)
717 return err;
718
719 err = update_input_line_level(chip);
720 if (err < 0)
721 return err;
722
723 err = set_sample_rate(chip, chip->sample_rate);
724 if (err < 0)
725 return err;
726
727 if (chip->meters_enabled) {
728 err = send_vector(chip, DSP_VC_METERS_ON);
729 if (err < 0)
730 return err;
731 }
732
733#ifdef ECHOCARD_HAS_DIGITAL_MODE_SWITCH
734 if (set_digital_mode(chip, chip->digital_mode) < 0)
735 return -EIO;
736#endif
737
738#ifdef ECHOCARD_HAS_DIGITAL_IO
739 if (set_professional_spdif(chip, chip->professional_spdif) < 0)
740 return -EIO;
741#endif
742
743#ifdef ECHOCARD_HAS_PHANTOM_POWER
744 if (set_phantom_power(chip, chip->phantom_power) < 0)
745 return -EIO;
746#endif
747
748#ifdef ECHOCARD_HAS_EXTERNAL_CLOCK
749
750 if (set_input_clock(chip, chip->input_clock) < 0)
751 return -EIO;
752#endif
753
754#ifdef ECHOCARD_HAS_OUTPUT_CLOCK_SWITCH
755 if (set_output_clock(chip, chip->output_clock) < 0)
756 return -EIO;
757#endif
758
759 if (wait_handshake(chip) < 0)
760 return -EIO;
761 clear_handshake(chip);
762 if (send_vector(chip, DSP_VC_UPDATE_FLAGS) < 0)
763 return -EIO;
764
765 return 0;
766}
767
768
769
770
771
772
773
774
775
776
777static void set_audio_format(struct echoaudio *chip, u16 pipe_index,
778 const struct audioformat *format)
779{
780 u16 dsp_format;
781
782 dsp_format = DSP_AUDIOFORM_SS_16LE;
783
784
785 if (format->interleave > 2) {
786 switch (format->bits_per_sample) {
787 case 16:
788 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_16LE;
789 break;
790 case 24:
791 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_24LE;
792 break;
793 case 32:
794 dsp_format = DSP_AUDIOFORM_SUPER_INTERLEAVE_32LE;
795 break;
796 }
797 dsp_format |= format->interleave;
798 } else if (format->data_are_bigendian) {
799
800 switch (format->interleave) {
801 case 1:
802 dsp_format = DSP_AUDIOFORM_MM_32BE;
803 break;
804#ifdef ECHOCARD_HAS_STEREO_BIG_ENDIAN32
805 case 2:
806 dsp_format = DSP_AUDIOFORM_SS_32BE;
807 break;
808#endif
809 }
810 } else if (format->interleave == 1 &&
811 format->bits_per_sample == 32 && !format->mono_to_stereo) {
812
813 dsp_format = DSP_AUDIOFORM_MM_32LE;
814 } else {
815
816 switch (format->bits_per_sample) {
817 case 8:
818 if (format->interleave == 2)
819 dsp_format = DSP_AUDIOFORM_SS_8;
820 else
821 dsp_format = DSP_AUDIOFORM_MS_8;
822 break;
823 default:
824 case 16:
825 if (format->interleave == 2)
826 dsp_format = DSP_AUDIOFORM_SS_16LE;
827 else
828 dsp_format = DSP_AUDIOFORM_MS_16LE;
829 break;
830 case 24:
831 if (format->interleave == 2)
832 dsp_format = DSP_AUDIOFORM_SS_24LE;
833 else
834 dsp_format = DSP_AUDIOFORM_MS_24LE;
835 break;
836 case 32:
837 if (format->interleave == 2)
838 dsp_format = DSP_AUDIOFORM_SS_32LE;
839 else
840 dsp_format = DSP_AUDIOFORM_MS_32LE;
841 break;
842 }
843 }
844 dev_dbg(chip->card->dev,
845 "set_audio_format[%d] = %x\n", pipe_index, dsp_format);
846 chip->comm_page->audio_format[pipe_index] = cpu_to_le16(dsp_format);
847}
848
849
850
851
852
853
854
855static int start_transport(struct echoaudio *chip, u32 channel_mask,
856 u32 cyclic_mask)
857{
858
859 if (wait_handshake(chip))
860 return -EIO;
861
862 chip->comm_page->cmd_start |= cpu_to_le32(channel_mask);
863
864 if (chip->comm_page->cmd_start) {
865 clear_handshake(chip);
866 send_vector(chip, DSP_VC_START_TRANSFER);
867 if (wait_handshake(chip))
868 return -EIO;
869
870 chip->active_mask |= channel_mask;
871 chip->comm_page->cmd_start = 0;
872 return 0;
873 }
874
875 dev_err(chip->card->dev, "start_transport: No pipes to start!\n");
876 return -EINVAL;
877}
878
879
880
881static int pause_transport(struct echoaudio *chip, u32 channel_mask)
882{
883
884 if (wait_handshake(chip))
885 return -EIO;
886
887 chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask);
888 chip->comm_page->cmd_reset = 0;
889 if (chip->comm_page->cmd_stop) {
890 clear_handshake(chip);
891 send_vector(chip, DSP_VC_STOP_TRANSFER);
892 if (wait_handshake(chip))
893 return -EIO;
894
895 chip->active_mask &= ~channel_mask;
896 chip->comm_page->cmd_stop = 0;
897 chip->comm_page->cmd_reset = 0;
898 return 0;
899 }
900
901 dev_warn(chip->card->dev, "pause_transport: No pipes to stop!\n");
902 return 0;
903}
904
905
906
907static int stop_transport(struct echoaudio *chip, u32 channel_mask)
908{
909
910 if (wait_handshake(chip))
911 return -EIO;
912
913 chip->comm_page->cmd_stop |= cpu_to_le32(channel_mask);
914 chip->comm_page->cmd_reset |= cpu_to_le32(channel_mask);
915 if (chip->comm_page->cmd_reset) {
916 clear_handshake(chip);
917 send_vector(chip, DSP_VC_STOP_TRANSFER);
918 if (wait_handshake(chip))
919 return -EIO;
920
921 chip->active_mask &= ~channel_mask;
922 chip->comm_page->cmd_stop = 0;
923 chip->comm_page->cmd_reset = 0;
924 return 0;
925 }
926
927 dev_warn(chip->card->dev, "stop_transport: No pipes to stop!\n");
928 return 0;
929}
930
931
932
933static inline int is_pipe_allocated(struct echoaudio *chip, u16 pipe_index)
934{
935 return (chip->pipe_alloc_mask & (1 << pipe_index));
936}
937
938
939
940
941
942static int rest_in_peace(struct echoaudio *chip)
943{
944
945
946 stop_transport(chip, chip->active_mask);
947
948 set_meters_on(chip, false);
949
950#ifdef ECHOCARD_HAS_MIDI
951 enable_midi_input(chip, false);
952#endif
953
954
955 if (chip->dsp_code) {
956
957 chip->dsp_code = NULL;
958
959 return send_vector(chip, DSP_VC_GO_COMATOSE);
960 }
961 return 0;
962}
963
964
965
966
967static int init_dsp_comm_page(struct echoaudio *chip)
968{
969
970 if (offsetof(struct comm_page, midi_output) != 0xbe0) {
971 dev_err(chip->card->dev,
972 "init_dsp_comm_page() - Invalid struct comm_page structure\n");
973 return -EPERM;
974 }
975
976
977 chip->card_name = ECHOCARD_NAME;
978 chip->bad_board = true;
979 chip->dsp_code = NULL;
980 chip->asic_loaded = false;
981 memset(chip->comm_page, 0, sizeof(struct comm_page));
982
983
984 chip->comm_page->comm_size =
985 cpu_to_le32(sizeof(struct comm_page));
986 chip->comm_page->handshake = cpu_to_le32(0xffffffff);
987 chip->comm_page->midi_out_free_count =
988 cpu_to_le32(DSP_MIDI_OUT_FIFO_SIZE);
989 chip->comm_page->sample_rate = cpu_to_le32(44100);
990
991
992 memset(chip->comm_page->monitors, ECHOGAIN_MUTED, MONITOR_ARRAY_SIZE);
993 memset(chip->comm_page->vmixer, ECHOGAIN_MUTED, VMIXER_ARRAY_SIZE);
994
995 return 0;
996}
997
998
999
1000
1001
1002
1003
1004static int init_line_levels(struct echoaudio *chip)
1005{
1006 memset(chip->output_gain, ECHOGAIN_MUTED, sizeof(chip->output_gain));
1007 memset(chip->input_gain, ECHOGAIN_MUTED, sizeof(chip->input_gain));
1008 memset(chip->monitor_gain, ECHOGAIN_MUTED, sizeof(chip->monitor_gain));
1009 memset(chip->vmixer_gain, ECHOGAIN_MUTED, sizeof(chip->vmixer_gain));
1010 chip->input_clock = ECHO_CLOCK_INTERNAL;
1011 chip->output_clock = ECHO_CLOCK_WORD;
1012 chip->sample_rate = 44100;
1013 return restore_dsp_rettings(chip);
1014}
1015
1016
1017
1018
1019
1020
1021static int service_irq(struct echoaudio *chip)
1022{
1023 int st;
1024
1025
1026 if (get_dsp_register(chip, CHI32_STATUS_REG) & CHI32_STATUS_IRQ) {
1027 st = 0;
1028#ifdef ECHOCARD_HAS_MIDI
1029
1030 if (chip->comm_page->midi_input[0])
1031 st = midi_service_irq(chip);
1032#endif
1033
1034 chip->comm_page->midi_input[0] = 0;
1035 send_vector(chip, DSP_VC_ACK_INT);
1036 return st;
1037 }
1038 return -1;
1039}
1040
1041
1042
1043
1044
1045
1046
1047
1048
1049
1050static int allocate_pipes(struct echoaudio *chip, struct audiopipe *pipe,
1051 int pipe_index, int interleave)
1052{
1053 int i;
1054 u32 channel_mask;
1055
1056 dev_dbg(chip->card->dev,
1057 "allocate_pipes: ch=%d int=%d\n", pipe_index, interleave);
1058
1059 if (chip->bad_board)
1060 return -EIO;
1061
1062 for (channel_mask = i = 0; i < interleave; i++)
1063 channel_mask |= 1 << (pipe_index + i);
1064 if (chip->pipe_alloc_mask & channel_mask) {
1065 dev_err(chip->card->dev,
1066 "allocate_pipes: channel already open\n");
1067 return -EAGAIN;
1068 }
1069
1070 chip->comm_page->position[pipe_index] = 0;
1071 chip->pipe_alloc_mask |= channel_mask;
1072
1073 chip->pipe_cyclic_mask |= channel_mask;
1074 pipe->index = pipe_index;
1075 pipe->interleave = interleave;
1076 pipe->state = PIPE_STATE_STOPPED;
1077
1078
1079
1080
1081 pipe->dma_counter = (__le32 *)&chip->comm_page->position[pipe_index];
1082 *pipe->dma_counter = 0;
1083 return pipe_index;
1084}
1085
1086
1087
1088static int free_pipes(struct echoaudio *chip, struct audiopipe *pipe)
1089{
1090 u32 channel_mask;
1091 int i;
1092
1093 if (snd_BUG_ON(!is_pipe_allocated(chip, pipe->index)))
1094 return -EINVAL;
1095 if (snd_BUG_ON(pipe->state != PIPE_STATE_STOPPED))
1096 return -EINVAL;
1097
1098 for (channel_mask = i = 0; i < pipe->interleave; i++)
1099 channel_mask |= 1 << (pipe->index + i);
1100
1101 chip->pipe_alloc_mask &= ~channel_mask;
1102 chip->pipe_cyclic_mask &= ~channel_mask;
1103 return 0;
1104}
1105
1106
1107
1108
1109
1110
1111
1112static int sglist_init(struct echoaudio *chip, struct audiopipe *pipe)
1113{
1114 pipe->sglist_head = 0;
1115 memset(pipe->sgpage.area, 0, PAGE_SIZE);
1116 chip->comm_page->sglist_addr[pipe->index].addr =
1117 cpu_to_le32(pipe->sgpage.addr);
1118 return 0;
1119}
1120
1121
1122
1123static int sglist_add_mapping(struct echoaudio *chip, struct audiopipe *pipe,
1124 dma_addr_t address, size_t length)
1125{
1126 int head = pipe->sglist_head;
1127 struct sg_entry *list = (struct sg_entry *)pipe->sgpage.area;
1128
1129 if (head < MAX_SGLIST_ENTRIES - 1) {
1130 list[head].addr = cpu_to_le32(address);
1131 list[head].size = cpu_to_le32(length);
1132 pipe->sglist_head++;
1133 } else {
1134 dev_err(chip->card->dev, "SGlist: too many fragments\n");
1135 return -ENOMEM;
1136 }
1137 return 0;
1138}
1139
1140
1141
1142static inline int sglist_add_irq(struct echoaudio *chip, struct audiopipe *pipe)
1143{
1144 return sglist_add_mapping(chip, pipe, 0, 0);
1145}
1146
1147
1148
1149static inline int sglist_wrap(struct echoaudio *chip, struct audiopipe *pipe)
1150{
1151 return sglist_add_mapping(chip, pipe, pipe->sgpage.addr, 0);
1152}
1153