Merge remote-tracking branch 'remotes/kraxel/tags/audio-20190821-pull-request' into...
[qemu.git] / hw / audio / sb16.c
1 /*
2 * QEMU Soundblaster 16 emulation
3 *
4 * Copyright (c) 2003-2005 Vassili Karpov (malc)
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a copy
7 * of this software and associated documentation files (the "Software"), to deal
8 * in the Software without restriction, including without limitation the rights
9 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
10 * copies of the Software, and to permit persons to whom the Software is
11 * furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
21 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
22 * THE SOFTWARE.
23 */
24 #include "hw/hw.h"
25 #include "hw/audio/audio.h"
26 #include "audio/audio.h"
27 #include "hw/isa/isa.h"
28 #include "hw/qdev.h"
29 #include "qemu/timer.h"
30 #include "qemu/host-utils.h"
31
32 #define dolog(...) AUD_log ("sb16", __VA_ARGS__)
33
34 /* #define DEBUG */
35 /* #define DEBUG_SB16_MOST */
36
37 #ifdef DEBUG
38 #define ldebug(...) dolog (__VA_ARGS__)
39 #else
40 #define ldebug(...)
41 #endif
42
43 #define IO_READ_PROTO(name) \
44 uint32_t name (void *opaque, uint32_t nport)
45 #define IO_WRITE_PROTO(name) \
46 void name (void *opaque, uint32_t nport, uint32_t val)
47
48 static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
49
50 #define TYPE_SB16 "sb16"
51 #define SB16(obj) OBJECT_CHECK (SB16State, (obj), TYPE_SB16)
52
53 typedef struct SB16State {
54 ISADevice parent_obj;
55
56 QEMUSoundCard card;
57 qemu_irq pic;
58 uint32_t irq;
59 uint32_t dma;
60 uint32_t hdma;
61 uint32_t port;
62 uint32_t ver;
63
64 int in_index;
65 int out_data_len;
66 int fmt_stereo;
67 int fmt_signed;
68 int fmt_bits;
69 audfmt_e fmt;
70 int dma_auto;
71 int block_size;
72 int fifo;
73 int freq;
74 int time_const;
75 int speaker;
76 int needed_bytes;
77 int cmd;
78 int use_hdma;
79 int highspeed;
80 int can_write;
81
82 int v2x6;
83
84 uint8_t csp_param;
85 uint8_t csp_value;
86 uint8_t csp_mode;
87 uint8_t csp_regs[256];
88 uint8_t csp_index;
89 uint8_t csp_reg83[4];
90 int csp_reg83r;
91 int csp_reg83w;
92
93 uint8_t in2_data[10];
94 uint8_t out_data[50];
95 uint8_t test_reg;
96 uint8_t last_read_byte;
97 int nzero;
98
99 int left_till_irq;
100
101 int dma_running;
102 int bytes_per_second;
103 int align;
104 int audio_free;
105 SWVoiceOut *voice;
106
107 QEMUTimer *aux_ts;
108 /* mixer state */
109 int mixer_nreg;
110 uint8_t mixer_regs[256];
111 } SB16State;
112
113 static void SB_audio_callback (void *opaque, int free);
114
115 static int magic_of_irq (int irq)
116 {
117 switch (irq) {
118 case 5:
119 return 2;
120 case 7:
121 return 4;
122 case 9:
123 return 1;
124 case 10:
125 return 8;
126 default:
127 dolog ("bad irq %d\n", irq);
128 return 2;
129 }
130 }
131
132 static int irq_of_magic (int magic)
133 {
134 switch (magic) {
135 case 1:
136 return 9;
137 case 2:
138 return 5;
139 case 4:
140 return 7;
141 case 8:
142 return 10;
143 default:
144 dolog ("bad irq magic %d\n", magic);
145 return -1;
146 }
147 }
148
149 #if 0
150 static void log_dsp (SB16State *dsp)
151 {
152 ldebug ("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n",
153 dsp->fmt_stereo ? "Stereo" : "Mono",
154 dsp->fmt_signed ? "Signed" : "Unsigned",
155 dsp->fmt_bits,
156 dsp->dma_auto ? "Auto" : "Single",
157 dsp->block_size,
158 dsp->freq,
159 dsp->time_const,
160 dsp->speaker);
161 }
162 #endif
163
164 static void speaker (SB16State *s, int on)
165 {
166 s->speaker = on;
167 /* AUD_enable (s->voice, on); */
168 }
169
170 static void control (SB16State *s, int hold)
171 {
172 int dma = s->use_hdma ? s->hdma : s->dma;
173 s->dma_running = hold;
174
175 ldebug ("hold %d high %d dma %d\n", hold, s->use_hdma, dma);
176
177 if (hold) {
178 DMA_hold_DREQ (dma);
179 AUD_set_active_out (s->voice, 1);
180 }
181 else {
182 DMA_release_DREQ (dma);
183 AUD_set_active_out (s->voice, 0);
184 }
185 }
186
187 static void aux_timer (void *opaque)
188 {
189 SB16State *s = opaque;
190 s->can_write = 1;
191 qemu_irq_raise (s->pic);
192 }
193
194 #define DMA8_AUTO 1
195 #define DMA8_HIGH 2
196
197 static void continue_dma8 (SB16State *s)
198 {
199 if (s->freq > 0) {
200 struct audsettings as;
201
202 s->audio_free = 0;
203
204 as.freq = s->freq;
205 as.nchannels = 1 << s->fmt_stereo;
206 as.fmt = s->fmt;
207 as.endianness = 0;
208
209 s->voice = AUD_open_out (
210 &s->card,
211 s->voice,
212 "sb16",
213 s,
214 SB_audio_callback,
215 &as
216 );
217 }
218
219 control (s, 1);
220 }
221
222 static void dma_cmd8 (SB16State *s, int mask, int dma_len)
223 {
224 s->fmt = AUD_FMT_U8;
225 s->use_hdma = 0;
226 s->fmt_bits = 8;
227 s->fmt_signed = 0;
228 s->fmt_stereo = (s->mixer_regs[0x0e] & 2) != 0;
229 if (-1 == s->time_const) {
230 if (s->freq <= 0)
231 s->freq = 11025;
232 }
233 else {
234 int tmp = (256 - s->time_const);
235 s->freq = (1000000 + (tmp / 2)) / tmp;
236 }
237
238 if (dma_len != -1) {
239 s->block_size = dma_len << s->fmt_stereo;
240 }
241 else {
242 /* This is apparently the only way to make both Act1/PL
243 and SecondReality/FC work
244
245 Act1 sets block size via command 0x48 and it's an odd number
246 SR does the same with even number
247 Both use stereo, and Creatives own documentation states that
248 0x48 sets block size in bytes less one.. go figure */
249 s->block_size &= ~s->fmt_stereo;
250 }
251
252 s->freq >>= s->fmt_stereo;
253 s->left_till_irq = s->block_size;
254 s->bytes_per_second = (s->freq << s->fmt_stereo);
255 /* s->highspeed = (mask & DMA8_HIGH) != 0; */
256 s->dma_auto = (mask & DMA8_AUTO) != 0;
257 s->align = (1 << s->fmt_stereo) - 1;
258
259 if (s->block_size & s->align) {
260 dolog ("warning: misaligned block size %d, alignment %d\n",
261 s->block_size, s->align + 1);
262 }
263
264 ldebug ("freq %d, stereo %d, sign %d, bits %d, "
265 "dma %d, auto %d, fifo %d, high %d\n",
266 s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits,
267 s->block_size, s->dma_auto, s->fifo, s->highspeed);
268
269 continue_dma8 (s);
270 speaker (s, 1);
271 }
272
273 static void dma_cmd (SB16State *s, uint8_t cmd, uint8_t d0, int dma_len)
274 {
275 s->use_hdma = cmd < 0xc0;
276 s->fifo = (cmd >> 1) & 1;
277 s->dma_auto = (cmd >> 2) & 1;
278 s->fmt_signed = (d0 >> 4) & 1;
279 s->fmt_stereo = (d0 >> 5) & 1;
280
281 switch (cmd >> 4) {
282 case 11:
283 s->fmt_bits = 16;
284 break;
285
286 case 12:
287 s->fmt_bits = 8;
288 break;
289 }
290
291 if (-1 != s->time_const) {
292 #if 1
293 int tmp = 256 - s->time_const;
294 s->freq = (1000000 + (tmp / 2)) / tmp;
295 #else
296 /* s->freq = 1000000 / ((255 - s->time_const) << s->fmt_stereo); */
297 s->freq = 1000000 / ((255 - s->time_const));
298 #endif
299 s->time_const = -1;
300 }
301
302 s->block_size = dma_len + 1;
303 s->block_size <<= (s->fmt_bits == 16);
304 if (!s->dma_auto) {
305 /* It is clear that for DOOM and auto-init this value
306 shouldn't take stereo into account, while Miles Sound Systems
307 setsound.exe with single transfer mode wouldn't work without it
308 wonders of SB16 yet again */
309 s->block_size <<= s->fmt_stereo;
310 }
311
312 ldebug ("freq %d, stereo %d, sign %d, bits %d, "
313 "dma %d, auto %d, fifo %d, high %d\n",
314 s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits,
315 s->block_size, s->dma_auto, s->fifo, s->highspeed);
316
317 if (16 == s->fmt_bits) {
318 if (s->fmt_signed) {
319 s->fmt = AUD_FMT_S16;
320 }
321 else {
322 s->fmt = AUD_FMT_U16;
323 }
324 }
325 else {
326 if (s->fmt_signed) {
327 s->fmt = AUD_FMT_S8;
328 }
329 else {
330 s->fmt = AUD_FMT_U8;
331 }
332 }
333
334 s->left_till_irq = s->block_size;
335
336 s->bytes_per_second = (s->freq << s->fmt_stereo) << (s->fmt_bits == 16);
337 s->highspeed = 0;
338 s->align = (1 << (s->fmt_stereo + (s->fmt_bits == 16))) - 1;
339 if (s->block_size & s->align) {
340 dolog ("warning: misaligned block size %d, alignment %d\n",
341 s->block_size, s->align + 1);
342 }
343
344 if (s->freq) {
345 struct audsettings as;
346
347 s->audio_free = 0;
348
349 as.freq = s->freq;
350 as.nchannels = 1 << s->fmt_stereo;
351 as.fmt = s->fmt;
352 as.endianness = 0;
353
354 s->voice = AUD_open_out (
355 &s->card,
356 s->voice,
357 "sb16",
358 s,
359 SB_audio_callback,
360 &as
361 );
362 }
363
364 control (s, 1);
365 speaker (s, 1);
366 }
367
368 static inline void dsp_out_data (SB16State *s, uint8_t val)
369 {
370 ldebug ("outdata %#x\n", val);
371 if ((size_t) s->out_data_len < sizeof (s->out_data)) {
372 s->out_data[s->out_data_len++] = val;
373 }
374 }
375
376 static inline uint8_t dsp_get_data (SB16State *s)
377 {
378 if (s->in_index) {
379 return s->in2_data[--s->in_index];
380 }
381 else {
382 dolog ("buffer underflow\n");
383 return 0;
384 }
385 }
386
387 static void command (SB16State *s, uint8_t cmd)
388 {
389 ldebug ("command %#x\n", cmd);
390
391 if (cmd > 0xaf && cmd < 0xd0) {
392 if (cmd & 8) {
393 dolog ("ADC not yet supported (command %#x)\n", cmd);
394 }
395
396 switch (cmd >> 4) {
397 case 11:
398 case 12:
399 break;
400 default:
401 dolog ("%#x wrong bits\n", cmd);
402 }
403 s->needed_bytes = 3;
404 }
405 else {
406 s->needed_bytes = 0;
407
408 switch (cmd) {
409 case 0x03:
410 dsp_out_data (s, 0x10); /* s->csp_param); */
411 goto warn;
412
413 case 0x04:
414 s->needed_bytes = 1;
415 goto warn;
416
417 case 0x05:
418 s->needed_bytes = 2;
419 goto warn;
420
421 case 0x08:
422 /* __asm__ ("int3"); */
423 goto warn;
424
425 case 0x0e:
426 s->needed_bytes = 2;
427 goto warn;
428
429 case 0x09:
430 dsp_out_data (s, 0xf8);
431 goto warn;
432
433 case 0x0f:
434 s->needed_bytes = 1;
435 goto warn;
436
437 case 0x10:
438 s->needed_bytes = 1;
439 goto warn;
440
441 case 0x14:
442 s->needed_bytes = 2;
443 s->block_size = 0;
444 break;
445
446 case 0x1c: /* Auto-Initialize DMA DAC, 8-bit */
447 dma_cmd8 (s, DMA8_AUTO, -1);
448 break;
449
450 case 0x20: /* Direct ADC, Juice/PL */
451 dsp_out_data (s, 0xff);
452 goto warn;
453
454 case 0x35:
455 dolog ("0x35 - MIDI command not implemented\n");
456 break;
457
458 case 0x40:
459 s->freq = -1;
460 s->time_const = -1;
461 s->needed_bytes = 1;
462 break;
463
464 case 0x41:
465 s->freq = -1;
466 s->time_const = -1;
467 s->needed_bytes = 2;
468 break;
469
470 case 0x42:
471 s->freq = -1;
472 s->time_const = -1;
473 s->needed_bytes = 2;
474 goto warn;
475
476 case 0x45:
477 dsp_out_data (s, 0xaa);
478 goto warn;
479
480 case 0x47: /* Continue Auto-Initialize DMA 16bit */
481 break;
482
483 case 0x48:
484 s->needed_bytes = 2;
485 break;
486
487 case 0x74:
488 s->needed_bytes = 2; /* DMA DAC, 4-bit ADPCM */
489 dolog ("0x75 - DMA DAC, 4-bit ADPCM not implemented\n");
490 break;
491
492 case 0x75: /* DMA DAC, 4-bit ADPCM Reference */
493 s->needed_bytes = 2;
494 dolog ("0x74 - DMA DAC, 4-bit ADPCM Reference not implemented\n");
495 break;
496
497 case 0x76: /* DMA DAC, 2.6-bit ADPCM */
498 s->needed_bytes = 2;
499 dolog ("0x74 - DMA DAC, 2.6-bit ADPCM not implemented\n");
500 break;
501
502 case 0x77: /* DMA DAC, 2.6-bit ADPCM Reference */
503 s->needed_bytes = 2;
504 dolog ("0x74 - DMA DAC, 2.6-bit ADPCM Reference not implemented\n");
505 break;
506
507 case 0x7d:
508 dolog ("0x7d - Autio-Initialize DMA DAC, 4-bit ADPCM Reference\n");
509 dolog ("not implemented\n");
510 break;
511
512 case 0x7f:
513 dolog (
514 "0x7d - Autio-Initialize DMA DAC, 2.6-bit ADPCM Reference\n"
515 );
516 dolog ("not implemented\n");
517 break;
518
519 case 0x80:
520 s->needed_bytes = 2;
521 break;
522
523 case 0x90:
524 case 0x91:
525 dma_cmd8 (s, ((cmd & 1) == 0) | DMA8_HIGH, -1);
526 break;
527
528 case 0xd0: /* halt DMA operation. 8bit */
529 control (s, 0);
530 break;
531
532 case 0xd1: /* speaker on */
533 speaker (s, 1);
534 break;
535
536 case 0xd3: /* speaker off */
537 speaker (s, 0);
538 break;
539
540 case 0xd4: /* continue DMA operation. 8bit */
541 /* KQ6 (or maybe Sierras audblst.drv in general) resets
542 the frequency between halt/continue */
543 continue_dma8 (s);
544 break;
545
546 case 0xd5: /* halt DMA operation. 16bit */
547 control (s, 0);
548 break;
549
550 case 0xd6: /* continue DMA operation. 16bit */
551 control (s, 1);
552 break;
553
554 case 0xd9: /* exit auto-init DMA after this block. 16bit */
555 s->dma_auto = 0;
556 break;
557
558 case 0xda: /* exit auto-init DMA after this block. 8bit */
559 s->dma_auto = 0;
560 break;
561
562 case 0xe0: /* DSP identification */
563 s->needed_bytes = 1;
564 break;
565
566 case 0xe1:
567 dsp_out_data (s, s->ver & 0xff);
568 dsp_out_data (s, s->ver >> 8);
569 break;
570
571 case 0xe2:
572 s->needed_bytes = 1;
573 goto warn;
574
575 case 0xe3:
576 {
577 int i;
578 for (i = sizeof (e3) - 1; i >= 0; --i)
579 dsp_out_data (s, e3[i]);
580 }
581 break;
582
583 case 0xe4: /* write test reg */
584 s->needed_bytes = 1;
585 break;
586
587 case 0xe7:
588 dolog ("Attempt to probe for ESS (0xe7)?\n");
589 break;
590
591 case 0xe8: /* read test reg */
592 dsp_out_data (s, s->test_reg);
593 break;
594
595 case 0xf2:
596 case 0xf3:
597 dsp_out_data (s, 0xaa);
598 s->mixer_regs[0x82] |= (cmd == 0xf2) ? 1 : 2;
599 qemu_irq_raise (s->pic);
600 break;
601
602 case 0xf9:
603 s->needed_bytes = 1;
604 goto warn;
605
606 case 0xfa:
607 dsp_out_data (s, 0);
608 goto warn;
609
610 case 0xfc: /* FIXME */
611 dsp_out_data (s, 0);
612 goto warn;
613
614 default:
615 dolog ("Unrecognized command %#x\n", cmd);
616 break;
617 }
618 }
619
620 if (!s->needed_bytes) {
621 ldebug ("\n");
622 }
623
624 exit:
625 if (!s->needed_bytes) {
626 s->cmd = -1;
627 }
628 else {
629 s->cmd = cmd;
630 }
631 return;
632
633 warn:
634 dolog ("warning: command %#x,%d is not truly understood yet\n",
635 cmd, s->needed_bytes);
636 goto exit;
637
638 }
639
640 static uint16_t dsp_get_lohi (SB16State *s)
641 {
642 uint8_t hi = dsp_get_data (s);
643 uint8_t lo = dsp_get_data (s);
644 return (hi << 8) | lo;
645 }
646
647 static uint16_t dsp_get_hilo (SB16State *s)
648 {
649 uint8_t lo = dsp_get_data (s);
650 uint8_t hi = dsp_get_data (s);
651 return (hi << 8) | lo;
652 }
653
654 static void complete (SB16State *s)
655 {
656 int d0, d1, d2;
657 ldebug ("complete command %#x, in_index %d, needed_bytes %d\n",
658 s->cmd, s->in_index, s->needed_bytes);
659
660 if (s->cmd > 0xaf && s->cmd < 0xd0) {
661 d2 = dsp_get_data (s);
662 d1 = dsp_get_data (s);
663 d0 = dsp_get_data (s);
664
665 if (s->cmd & 8) {
666 dolog ("ADC params cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
667 s->cmd, d0, d1, d2);
668 }
669 else {
670 ldebug ("cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
671 s->cmd, d0, d1, d2);
672 dma_cmd (s, s->cmd, d0, d1 + (d2 << 8));
673 }
674 }
675 else {
676 switch (s->cmd) {
677 case 0x04:
678 s->csp_mode = dsp_get_data (s);
679 s->csp_reg83r = 0;
680 s->csp_reg83w = 0;
681 ldebug ("CSP command 0x04: mode=%#x\n", s->csp_mode);
682 break;
683
684 case 0x05:
685 s->csp_param = dsp_get_data (s);
686 s->csp_value = dsp_get_data (s);
687 ldebug ("CSP command 0x05: param=%#x value=%#x\n",
688 s->csp_param,
689 s->csp_value);
690 break;
691
692 case 0x0e:
693 d0 = dsp_get_data (s);
694 d1 = dsp_get_data (s);
695 ldebug ("write CSP register %d <- %#x\n", d1, d0);
696 if (d1 == 0x83) {
697 ldebug ("0x83[%d] <- %#x\n", s->csp_reg83r, d0);
698 s->csp_reg83[s->csp_reg83r % 4] = d0;
699 s->csp_reg83r += 1;
700 }
701 else {
702 s->csp_regs[d1] = d0;
703 }
704 break;
705
706 case 0x0f:
707 d0 = dsp_get_data (s);
708 ldebug ("read CSP register %#x -> %#x, mode=%#x\n",
709 d0, s->csp_regs[d0], s->csp_mode);
710 if (d0 == 0x83) {
711 ldebug ("0x83[%d] -> %#x\n",
712 s->csp_reg83w,
713 s->csp_reg83[s->csp_reg83w % 4]);
714 dsp_out_data (s, s->csp_reg83[s->csp_reg83w % 4]);
715 s->csp_reg83w += 1;
716 }
717 else {
718 dsp_out_data (s, s->csp_regs[d0]);
719 }
720 break;
721
722 case 0x10:
723 d0 = dsp_get_data (s);
724 dolog ("cmd 0x10 d0=%#x\n", d0);
725 break;
726
727 case 0x14:
728 dma_cmd8 (s, 0, dsp_get_lohi (s) + 1);
729 break;
730
731 case 0x40:
732 s->time_const = dsp_get_data (s);
733 ldebug ("set time const %d\n", s->time_const);
734 break;
735
736 case 0x42: /* FT2 sets output freq with this, go figure */
737 #if 0
738 dolog ("cmd 0x42 might not do what it think it should\n");
739 #endif
740 case 0x41:
741 s->freq = dsp_get_hilo (s);
742 ldebug ("set freq %d\n", s->freq);
743 break;
744
745 case 0x48:
746 s->block_size = dsp_get_lohi (s) + 1;
747 ldebug ("set dma block len %d\n", s->block_size);
748 break;
749
750 case 0x74:
751 case 0x75:
752 case 0x76:
753 case 0x77:
754 /* ADPCM stuff, ignore */
755 break;
756
757 case 0x80:
758 {
759 int freq, samples, bytes;
760 int64_t ticks;
761
762 freq = s->freq > 0 ? s->freq : 11025;
763 samples = dsp_get_lohi (s) + 1;
764 bytes = samples << s->fmt_stereo << (s->fmt_bits == 16);
765 ticks = muldiv64 (bytes, get_ticks_per_sec (), freq);
766 if (ticks < get_ticks_per_sec () / 1024) {
767 qemu_irq_raise (s->pic);
768 }
769 else {
770 if (s->aux_ts) {
771 timer_mod (
772 s->aux_ts,
773 qemu_clock_get_ns(QEMU_CLOCK_VIRTUAL) + ticks
774 );
775 }
776 }
777 ldebug ("mix silence %d %d %" PRId64 "\n", samples, bytes, ticks);
778 }
779 break;
780
781 case 0xe0:
782 d0 = dsp_get_data (s);
783 s->out_data_len = 0;
784 ldebug ("E0 data = %#x\n", d0);
785 dsp_out_data (s, ~d0);
786 break;
787
788 case 0xe2:
789 #ifdef DEBUG
790 d0 = dsp_get_data (s);
791 dolog ("E2 = %#x\n", d0);
792 #endif
793 break;
794
795 case 0xe4:
796 s->test_reg = dsp_get_data (s);
797 break;
798
799 case 0xf9:
800 d0 = dsp_get_data (s);
801 ldebug ("command 0xf9 with %#x\n", d0);
802 switch (d0) {
803 case 0x0e:
804 dsp_out_data (s, 0xff);
805 break;
806
807 case 0x0f:
808 dsp_out_data (s, 0x07);
809 break;
810
811 case 0x37:
812 dsp_out_data (s, 0x38);
813 break;
814
815 default:
816 dsp_out_data (s, 0x00);
817 break;
818 }
819 break;
820
821 default:
822 dolog ("complete: unrecognized command %#x\n", s->cmd);
823 return;
824 }
825 }
826
827 ldebug ("\n");
828 s->cmd = -1;
829 }
830
831 static void legacy_reset (SB16State *s)
832 {
833 struct audsettings as;
834
835 s->freq = 11025;
836 s->fmt_signed = 0;
837 s->fmt_bits = 8;
838 s->fmt_stereo = 0;
839
840 as.freq = s->freq;
841 as.nchannels = 1;
842 as.fmt = AUD_FMT_U8;
843 as.endianness = 0;
844
845 s->voice = AUD_open_out (
846 &s->card,
847 s->voice,
848 "sb16",
849 s,
850 SB_audio_callback,
851 &as
852 );
853
854 /* Not sure about that... */
855 /* AUD_set_active_out (s->voice, 1); */
856 }
857
858 static void reset (SB16State *s)
859 {
860 qemu_irq_lower (s->pic);
861 if (s->dma_auto) {
862 qemu_irq_raise (s->pic);
863 qemu_irq_lower (s->pic);
864 }
865
866 s->mixer_regs[0x82] = 0;
867 s->dma_auto = 0;
868 s->in_index = 0;
869 s->out_data_len = 0;
870 s->left_till_irq = 0;
871 s->needed_bytes = 0;
872 s->block_size = -1;
873 s->nzero = 0;
874 s->highspeed = 0;
875 s->v2x6 = 0;
876 s->cmd = -1;
877
878 dsp_out_data (s, 0xaa);
879 speaker (s, 0);
880 control (s, 0);
881 legacy_reset (s);
882 }
883
884 static IO_WRITE_PROTO (dsp_write)
885 {
886 SB16State *s = opaque;
887 int iport;
888
889 iport = nport - s->port;
890
891 ldebug ("write %#x <- %#x\n", nport, val);
892 switch (iport) {
893 case 0x06:
894 switch (val) {
895 case 0x00:
896 if (s->v2x6 == 1) {
897 reset (s);
898 }
899 s->v2x6 = 0;
900 break;
901
902 case 0x01:
903 case 0x03: /* FreeBSD kludge */
904 s->v2x6 = 1;
905 break;
906
907 case 0xc6:
908 s->v2x6 = 0; /* Prince of Persia, csp.sys, diagnose.exe */
909 break;
910
911 case 0xb8: /* Panic */
912 reset (s);
913 break;
914
915 case 0x39:
916 dsp_out_data (s, 0x38);
917 reset (s);
918 s->v2x6 = 0x39;
919 break;
920
921 default:
922 s->v2x6 = val;
923 break;
924 }
925 break;
926
927 case 0x0c: /* write data or command | write status */
928 /* if (s->highspeed) */
929 /* break; */
930
931 if (s->needed_bytes == 0) {
932 command (s, val);
933 #if 0
934 if (0 == s->needed_bytes) {
935 log_dsp (s);
936 }
937 #endif
938 }
939 else {
940 if (s->in_index == sizeof (s->in2_data)) {
941 dolog ("in data overrun\n");
942 }
943 else {
944 s->in2_data[s->in_index++] = val;
945 if (s->in_index == s->needed_bytes) {
946 s->needed_bytes = 0;
947 complete (s);
948 #if 0
949 log_dsp (s);
950 #endif
951 }
952 }
953 }
954 break;
955
956 default:
957 ldebug ("(nport=%#x, val=%#x)\n", nport, val);
958 break;
959 }
960 }
961
962 static IO_READ_PROTO (dsp_read)
963 {
964 SB16State *s = opaque;
965 int iport, retval, ack = 0;
966
967 iport = nport - s->port;
968
969 switch (iport) {
970 case 0x06: /* reset */
971 retval = 0xff;
972 break;
973
974 case 0x0a: /* read data */
975 if (s->out_data_len) {
976 retval = s->out_data[--s->out_data_len];
977 s->last_read_byte = retval;
978 }
979 else {
980 if (s->cmd != -1) {
981 dolog ("empty output buffer for command %#x\n",
982 s->cmd);
983 }
984 retval = s->last_read_byte;
985 /* goto error; */
986 }
987 break;
988
989 case 0x0c: /* 0 can write */
990 retval = s->can_write ? 0 : 0x80;
991 break;
992
993 case 0x0d: /* timer interrupt clear */
994 /* dolog ("timer interrupt clear\n"); */
995 retval = 0;
996 break;
997
998 case 0x0e: /* data available status | irq 8 ack */
999 retval = (!s->out_data_len || s->highspeed) ? 0 : 0x80;
1000 if (s->mixer_regs[0x82] & 1) {
1001 ack = 1;
1002 s->mixer_regs[0x82] &= ~1;
1003 qemu_irq_lower (s->pic);
1004 }
1005 break;
1006
1007 case 0x0f: /* irq 16 ack */
1008 retval = 0xff;
1009 if (s->mixer_regs[0x82] & 2) {
1010 ack = 1;
1011 s->mixer_regs[0x82] &= ~2;
1012 qemu_irq_lower (s->pic);
1013 }
1014 break;
1015
1016 default:
1017 goto error;
1018 }
1019
1020 if (!ack) {
1021 ldebug ("read %#x -> %#x\n", nport, retval);
1022 }
1023
1024 return retval;
1025
1026 error:
1027 dolog ("warning: dsp_read %#x error\n", nport);
1028 return 0xff;
1029 }
1030
1031 static void reset_mixer (SB16State *s)
1032 {
1033 int i;
1034
1035 memset (s->mixer_regs, 0xff, 0x7f);
1036 memset (s->mixer_regs + 0x83, 0xff, sizeof (s->mixer_regs) - 0x83);
1037
1038 s->mixer_regs[0x02] = 4; /* master volume 3bits */
1039 s->mixer_regs[0x06] = 4; /* MIDI volume 3bits */
1040 s->mixer_regs[0x08] = 0; /* CD volume 3bits */
1041 s->mixer_regs[0x0a] = 0; /* voice volume 2bits */
1042
1043 /* d5=input filt, d3=lowpass filt, d1,d2=input source */
1044 s->mixer_regs[0x0c] = 0;
1045
1046 /* d5=output filt, d1=stereo switch */
1047 s->mixer_regs[0x0e] = 0;
1048
1049 /* voice volume L d5,d7, R d1,d3 */
1050 s->mixer_regs[0x04] = (4 << 5) | (4 << 1);
1051 /* master ... */
1052 s->mixer_regs[0x22] = (4 << 5) | (4 << 1);
1053 /* MIDI ... */
1054 s->mixer_regs[0x26] = (4 << 5) | (4 << 1);
1055
1056 for (i = 0x30; i < 0x48; i++) {
1057 s->mixer_regs[i] = 0x20;
1058 }
1059 }
1060
1061 static IO_WRITE_PROTO (mixer_write_indexb)
1062 {
1063 SB16State *s = opaque;
1064 (void) nport;
1065 s->mixer_nreg = val;
1066 }
1067
1068 static IO_WRITE_PROTO (mixer_write_datab)
1069 {
1070 SB16State *s = opaque;
1071
1072 (void) nport;
1073 ldebug ("mixer_write [%#x] <- %#x\n", s->mixer_nreg, val);
1074
1075 switch (s->mixer_nreg) {
1076 case 0x00:
1077 reset_mixer (s);
1078 break;
1079
1080 case 0x80:
1081 {
1082 int irq = irq_of_magic (val);
1083 ldebug ("setting irq to %d (val=%#x)\n", irq, val);
1084 if (irq > 0) {
1085 s->irq = irq;
1086 }
1087 }
1088 break;
1089
1090 case 0x81:
1091 {
1092 int dma, hdma;
1093
1094 dma = ctz32 (val & 0xf);
1095 hdma = ctz32 (val & 0xf0);
1096 if (dma != s->dma || hdma != s->hdma) {
1097 dolog (
1098 "attempt to change DMA "
1099 "8bit %d(%d), 16bit %d(%d) (val=%#x)\n",
1100 dma, s->dma, hdma, s->hdma, val);
1101 }
1102 #if 0
1103 s->dma = dma;
1104 s->hdma = hdma;
1105 #endif
1106 }
1107 break;
1108
1109 case 0x82:
1110 dolog ("attempt to write into IRQ status register (val=%#x)\n",
1111 val);
1112 return;
1113
1114 default:
1115 if (s->mixer_nreg >= 0x80) {
1116 ldebug ("attempt to write mixer[%#x] <- %#x\n", s->mixer_nreg, val);
1117 }
1118 break;
1119 }
1120
1121 s->mixer_regs[s->mixer_nreg] = val;
1122 }
1123
1124 static IO_WRITE_PROTO (mixer_write_indexw)
1125 {
1126 mixer_write_indexb (opaque, nport, val & 0xff);
1127 mixer_write_datab (opaque, nport, (val >> 8) & 0xff);
1128 }
1129
1130 static IO_READ_PROTO (mixer_read)
1131 {
1132 SB16State *s = opaque;
1133
1134 (void) nport;
1135 #ifndef DEBUG_SB16_MOST
1136 if (s->mixer_nreg != 0x82) {
1137 ldebug ("mixer_read[%#x] -> %#x\n",
1138 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]);
1139 }
1140 #else
1141 ldebug ("mixer_read[%#x] -> %#x\n",
1142 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]);
1143 #endif
1144 return s->mixer_regs[s->mixer_nreg];
1145 }
1146
1147 static int write_audio (SB16State *s, int nchan, int dma_pos,
1148 int dma_len, int len)
1149 {
1150 int temp, net;
1151 uint8_t tmpbuf[4096];
1152
1153 temp = len;
1154 net = 0;
1155
1156 while (temp) {
1157 int left = dma_len - dma_pos;
1158 int copied;
1159 size_t to_copy;
1160
1161 to_copy = audio_MIN (temp, left);
1162 if (to_copy > sizeof (tmpbuf)) {
1163 to_copy = sizeof (tmpbuf);
1164 }
1165
1166 copied = DMA_read_memory (nchan, tmpbuf, dma_pos, to_copy);
1167 copied = AUD_write (s->voice, tmpbuf, copied);
1168
1169 temp -= copied;
1170 dma_pos = (dma_pos + copied) % dma_len;
1171 net += copied;
1172
1173 if (!copied) {
1174 break;
1175 }
1176 }
1177
1178 return net;
1179 }
1180
1181 static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len)
1182 {
1183 SB16State *s = opaque;
1184 int till, copy, written, free;
1185
1186 if (s->block_size <= 0) {
1187 dolog ("invalid block size=%d nchan=%d dma_pos=%d dma_len=%d\n",
1188 s->block_size, nchan, dma_pos, dma_len);
1189 return dma_pos;
1190 }
1191
1192 if (s->left_till_irq < 0) {
1193 s->left_till_irq = s->block_size;
1194 }
1195
1196 if (s->voice) {
1197 free = s->audio_free & ~s->align;
1198 if ((free <= 0) || !dma_len) {
1199 return dma_pos;
1200 }
1201 }
1202 else {
1203 free = dma_len;
1204 }
1205
1206 copy = free;
1207 till = s->left_till_irq;
1208
1209 #ifdef DEBUG_SB16_MOST
1210 dolog ("pos:%06d %d till:%d len:%d\n",
1211 dma_pos, free, till, dma_len);
1212 #endif
1213
1214 if (till <= copy) {
1215 if (s->dma_auto == 0) {
1216 copy = till;
1217 }
1218 }
1219
1220 written = write_audio (s, nchan, dma_pos, dma_len, copy);
1221 dma_pos = (dma_pos + written) % dma_len;
1222 s->left_till_irq -= written;
1223
1224 if (s->left_till_irq <= 0) {
1225 s->mixer_regs[0x82] |= (nchan & 4) ? 2 : 1;
1226 qemu_irq_raise (s->pic);
1227 if (s->dma_auto == 0) {
1228 control (s, 0);
1229 speaker (s, 0);
1230 }
1231 }
1232
1233 #ifdef DEBUG_SB16_MOST
1234 ldebug ("pos %5d free %5d size %5d till % 5d copy %5d written %5d size %5d\n",
1235 dma_pos, free, dma_len, s->left_till_irq, copy, written,
1236 s->block_size);
1237 #endif
1238
1239 while (s->left_till_irq <= 0) {
1240 s->left_till_irq = s->block_size + s->left_till_irq;
1241 }
1242
1243 return dma_pos;
1244 }
1245
1246 static void SB_audio_callback (void *opaque, int free)
1247 {
1248 SB16State *s = opaque;
1249 s->audio_free = free;
1250 }
1251
1252 static int sb16_post_load (void *opaque, int version_id)
1253 {
1254 SB16State *s = opaque;
1255
1256 if (s->voice) {
1257 AUD_close_out (&s->card, s->voice);
1258 s->voice = NULL;
1259 }
1260
1261 if (s->dma_running) {
1262 if (s->freq) {
1263 struct audsettings as;
1264
1265 s->audio_free = 0;
1266
1267 as.freq = s->freq;
1268 as.nchannels = 1 << s->fmt_stereo;
1269 as.fmt = s->fmt;
1270 as.endianness = 0;
1271
1272 s->voice = AUD_open_out (
1273 &s->card,
1274 s->voice,
1275 "sb16",
1276 s,
1277 SB_audio_callback,
1278 &as
1279 );
1280 }
1281
1282 control (s, 1);
1283 speaker (s, s->speaker);
1284 }
1285 return 0;
1286 }
1287
1288 static const VMStateDescription vmstate_sb16 = {
1289 .name = "sb16",
1290 .version_id = 1,
1291 .minimum_version_id = 1,
1292 .post_load = sb16_post_load,
1293 .fields = (VMStateField[]) {
1294 VMSTATE_UINT32 (irq, SB16State),
1295 VMSTATE_UINT32 (dma, SB16State),
1296 VMSTATE_UINT32 (hdma, SB16State),
1297 VMSTATE_UINT32 (port, SB16State),
1298 VMSTATE_UINT32 (ver, SB16State),
1299 VMSTATE_INT32 (in_index, SB16State),
1300 VMSTATE_INT32 (out_data_len, SB16State),
1301 VMSTATE_INT32 (fmt_stereo, SB16State),
1302 VMSTATE_INT32 (fmt_signed, SB16State),
1303 VMSTATE_INT32 (fmt_bits, SB16State),
1304 VMSTATE_UINT32 (fmt, SB16State),
1305 VMSTATE_INT32 (dma_auto, SB16State),
1306 VMSTATE_INT32 (block_size, SB16State),
1307 VMSTATE_INT32 (fifo, SB16State),
1308 VMSTATE_INT32 (freq, SB16State),
1309 VMSTATE_INT32 (time_const, SB16State),
1310 VMSTATE_INT32 (speaker, SB16State),
1311 VMSTATE_INT32 (needed_bytes, SB16State),
1312 VMSTATE_INT32 (cmd, SB16State),
1313 VMSTATE_INT32 (use_hdma, SB16State),
1314 VMSTATE_INT32 (highspeed, SB16State),
1315 VMSTATE_INT32 (can_write, SB16State),
1316 VMSTATE_INT32 (v2x6, SB16State),
1317
1318 VMSTATE_UINT8 (csp_param, SB16State),
1319 VMSTATE_UINT8 (csp_value, SB16State),
1320 VMSTATE_UINT8 (csp_mode, SB16State),
1321 VMSTATE_UINT8 (csp_param, SB16State),
1322 VMSTATE_BUFFER (csp_regs, SB16State),
1323 VMSTATE_UINT8 (csp_index, SB16State),
1324 VMSTATE_BUFFER (csp_reg83, SB16State),
1325 VMSTATE_INT32 (csp_reg83r, SB16State),
1326 VMSTATE_INT32 (csp_reg83w, SB16State),
1327
1328 VMSTATE_BUFFER (in2_data, SB16State),
1329 VMSTATE_BUFFER (out_data, SB16State),
1330 VMSTATE_UINT8 (test_reg, SB16State),
1331 VMSTATE_UINT8 (last_read_byte, SB16State),
1332
1333 VMSTATE_INT32 (nzero, SB16State),
1334 VMSTATE_INT32 (left_till_irq, SB16State),
1335 VMSTATE_INT32 (dma_running, SB16State),
1336 VMSTATE_INT32 (bytes_per_second, SB16State),
1337 VMSTATE_INT32 (align, SB16State),
1338
1339 VMSTATE_INT32 (mixer_nreg, SB16State),
1340 VMSTATE_BUFFER (mixer_regs, SB16State),
1341
1342 VMSTATE_END_OF_LIST ()
1343 }
1344 };
1345
1346 static const MemoryRegionPortio sb16_ioport_list[] = {
1347 { 4, 1, 1, .write = mixer_write_indexb },
1348 { 4, 1, 2, .write = mixer_write_indexw },
1349 { 5, 1, 1, .read = mixer_read, .write = mixer_write_datab },
1350 { 6, 1, 1, .read = dsp_read, .write = dsp_write },
1351 { 10, 1, 1, .read = dsp_read },
1352 { 12, 1, 1, .write = dsp_write },
1353 { 12, 4, 1, .read = dsp_read },
1354 PORTIO_END_OF_LIST (),
1355 };
1356
1357
1358 static void sb16_initfn (Object *obj)
1359 {
1360 SB16State *s = SB16 (obj);
1361
1362 s->cmd = -1;
1363 }
1364
1365 static void sb16_realizefn (DeviceState *dev, Error **errp)
1366 {
1367 ISADevice *isadev = ISA_DEVICE (dev);
1368 SB16State *s = SB16 (dev);
1369
1370 isa_init_irq (isadev, &s->pic, s->irq);
1371
1372 s->mixer_regs[0x80] = magic_of_irq (s->irq);
1373 s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma);
1374 s->mixer_regs[0x82] = 2 << 5;
1375
1376 s->csp_regs[5] = 1;
1377 s->csp_regs[9] = 0xf8;
1378
1379 reset_mixer (s);
1380 s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s);
1381 if (!s->aux_ts) {
1382 dolog ("warning: Could not create auxiliary timer\n");
1383 }
1384
1385 isa_register_portio_list (isadev, s->port, sb16_ioport_list, s, "sb16");
1386
1387 DMA_register_channel (s->hdma, SB_read_DMA, s);
1388 DMA_register_channel (s->dma, SB_read_DMA, s);
1389 s->can_write = 1;
1390
1391 AUD_register_card ("sb16", &s->card);
1392 }
1393
1394 static int SB16_init (ISABus *bus)
1395 {
1396 isa_create_simple (bus, TYPE_SB16);
1397 return 0;
1398 }
1399
1400 static Property sb16_properties[] = {
1401 DEFINE_PROP_UINT32 ("version", SB16State, ver, 0x0405), /* 4.5 */
1402 DEFINE_PROP_UINT32 ("iobase", SB16State, port, 0x220),
1403 DEFINE_PROP_UINT32 ("irq", SB16State, irq, 5),
1404 DEFINE_PROP_UINT32 ("dma", SB16State, dma, 1),
1405 DEFINE_PROP_UINT32 ("dma16", SB16State, hdma, 5),
1406 DEFINE_PROP_END_OF_LIST (),
1407 };
1408
1409 static void sb16_class_initfn (ObjectClass *klass, void *data)
1410 {
1411 DeviceClass *dc = DEVICE_CLASS (klass);
1412
1413 dc->realize = sb16_realizefn;
1414 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
1415 dc->desc = "Creative Sound Blaster 16";
1416 dc->vmsd = &vmstate_sb16;
1417 dc->props = sb16_properties;
1418 }
1419
1420 static const TypeInfo sb16_info = {
1421 .name = TYPE_SB16,
1422 .parent = TYPE_ISA_DEVICE,
1423 .instance_size = sizeof (SB16State),
1424 .instance_init = sb16_initfn,
1425 .class_init = sb16_class_initfn,
1426 };
1427
1428 static void sb16_register_types (void)
1429 {
1430 type_register_static (&sb16_info);
1431 isa_register_soundhw("sb16", "Creative Sound Blaster 16", SB16_init);
1432 }
1433
1434 type_init (sb16_register_types)