qcow2: Improve check for overlapping allocations
[qemu/kevin.git] / hw / sb16.c
blobbd51cebfd8a8e4dd3b4d3d4457e61d7647c02543
1 /*
2 * QEMU Soundblaster 16 emulation
4 * Copyright (c) 2003-2005 Vassili Karpov (malc)
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:
13 * The above copyright notice and this permission notice shall be included in
14 * all copies or substantial portions of the Software.
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.
24 #include "hw/hw.h"
25 #include "hw/audiodev.h"
26 #include "audio/audio.h"
27 #include "hw/isa.h"
28 #include "hw/qdev.h"
29 #include "qemu/timer.h"
30 #include "qemu/host-utils.h"
32 #define dolog(...) AUD_log ("sb16", __VA_ARGS__)
34 /* #define DEBUG */
35 /* #define DEBUG_SB16_MOST */
37 #ifdef DEBUG
38 #define ldebug(...) dolog (__VA_ARGS__)
39 #else
40 #define ldebug(...)
41 #endif
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)
48 static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
50 typedef struct SB16State {
51 ISADevice dev;
52 QEMUSoundCard card;
53 qemu_irq pic;
54 uint32_t irq;
55 uint32_t dma;
56 uint32_t hdma;
57 uint32_t port;
58 uint32_t ver;
60 int in_index;
61 int out_data_len;
62 int fmt_stereo;
63 int fmt_signed;
64 int fmt_bits;
65 audfmt_e fmt;
66 int dma_auto;
67 int block_size;
68 int fifo;
69 int freq;
70 int time_const;
71 int speaker;
72 int needed_bytes;
73 int cmd;
74 int use_hdma;
75 int highspeed;
76 int can_write;
78 int v2x6;
80 uint8_t csp_param;
81 uint8_t csp_value;
82 uint8_t csp_mode;
83 uint8_t csp_regs[256];
84 uint8_t csp_index;
85 uint8_t csp_reg83[4];
86 int csp_reg83r;
87 int csp_reg83w;
89 uint8_t in2_data[10];
90 uint8_t out_data[50];
91 uint8_t test_reg;
92 uint8_t last_read_byte;
93 int nzero;
95 int left_till_irq;
97 int dma_running;
98 int bytes_per_second;
99 int align;
100 int audio_free;
101 SWVoiceOut *voice;
103 QEMUTimer *aux_ts;
104 /* mixer state */
105 int mixer_nreg;
106 uint8_t mixer_regs[256];
107 } SB16State;
109 static void SB_audio_callback (void *opaque, int free);
111 static int magic_of_irq (int irq)
113 switch (irq) {
114 case 5:
115 return 2;
116 case 7:
117 return 4;
118 case 9:
119 return 1;
120 case 10:
121 return 8;
122 default:
123 dolog ("bad irq %d\n", irq);
124 return 2;
128 static int irq_of_magic (int magic)
130 switch (magic) {
131 case 1:
132 return 9;
133 case 2:
134 return 5;
135 case 4:
136 return 7;
137 case 8:
138 return 10;
139 default:
140 dolog ("bad irq magic %d\n", magic);
141 return -1;
145 #if 0
146 static void log_dsp (SB16State *dsp)
148 ldebug ("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n",
149 dsp->fmt_stereo ? "Stereo" : "Mono",
150 dsp->fmt_signed ? "Signed" : "Unsigned",
151 dsp->fmt_bits,
152 dsp->dma_auto ? "Auto" : "Single",
153 dsp->block_size,
154 dsp->freq,
155 dsp->time_const,
156 dsp->speaker);
158 #endif
160 static void speaker (SB16State *s, int on)
162 s->speaker = on;
163 /* AUD_enable (s->voice, on); */
166 static void control (SB16State *s, int hold)
168 int dma = s->use_hdma ? s->hdma : s->dma;
169 s->dma_running = hold;
171 ldebug ("hold %d high %d dma %d\n", hold, s->use_hdma, dma);
173 if (hold) {
174 DMA_hold_DREQ (dma);
175 AUD_set_active_out (s->voice, 1);
177 else {
178 DMA_release_DREQ (dma);
179 AUD_set_active_out (s->voice, 0);
183 static void aux_timer (void *opaque)
185 SB16State *s = opaque;
186 s->can_write = 1;
187 qemu_irq_raise (s->pic);
190 #define DMA8_AUTO 1
191 #define DMA8_HIGH 2
193 static void continue_dma8 (SB16State *s)
195 if (s->freq > 0) {
196 struct audsettings as;
198 s->audio_free = 0;
200 as.freq = s->freq;
201 as.nchannels = 1 << s->fmt_stereo;
202 as.fmt = s->fmt;
203 as.endianness = 0;
205 s->voice = AUD_open_out (
206 &s->card,
207 s->voice,
208 "sb16",
210 SB_audio_callback,
215 control (s, 1);
218 static void dma_cmd8 (SB16State *s, int mask, int dma_len)
220 s->fmt = AUD_FMT_U8;
221 s->use_hdma = 0;
222 s->fmt_bits = 8;
223 s->fmt_signed = 0;
224 s->fmt_stereo = (s->mixer_regs[0x0e] & 2) != 0;
225 if (-1 == s->time_const) {
226 if (s->freq <= 0)
227 s->freq = 11025;
229 else {
230 int tmp = (256 - s->time_const);
231 s->freq = (1000000 + (tmp / 2)) / tmp;
234 if (dma_len != -1) {
235 s->block_size = dma_len << s->fmt_stereo;
237 else {
238 /* This is apparently the only way to make both Act1/PL
239 and SecondReality/FC work
241 Act1 sets block size via command 0x48 and it's an odd number
242 SR does the same with even number
243 Both use stereo, and Creatives own documentation states that
244 0x48 sets block size in bytes less one.. go figure */
245 s->block_size &= ~s->fmt_stereo;
248 s->freq >>= s->fmt_stereo;
249 s->left_till_irq = s->block_size;
250 s->bytes_per_second = (s->freq << s->fmt_stereo);
251 /* s->highspeed = (mask & DMA8_HIGH) != 0; */
252 s->dma_auto = (mask & DMA8_AUTO) != 0;
253 s->align = (1 << s->fmt_stereo) - 1;
255 if (s->block_size & s->align) {
256 dolog ("warning: misaligned block size %d, alignment %d\n",
257 s->block_size, s->align + 1);
260 ldebug ("freq %d, stereo %d, sign %d, bits %d, "
261 "dma %d, auto %d, fifo %d, high %d\n",
262 s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits,
263 s->block_size, s->dma_auto, s->fifo, s->highspeed);
265 continue_dma8 (s);
266 speaker (s, 1);
269 static void dma_cmd (SB16State *s, uint8_t cmd, uint8_t d0, int dma_len)
271 s->use_hdma = cmd < 0xc0;
272 s->fifo = (cmd >> 1) & 1;
273 s->dma_auto = (cmd >> 2) & 1;
274 s->fmt_signed = (d0 >> 4) & 1;
275 s->fmt_stereo = (d0 >> 5) & 1;
277 switch (cmd >> 4) {
278 case 11:
279 s->fmt_bits = 16;
280 break;
282 case 12:
283 s->fmt_bits = 8;
284 break;
287 if (-1 != s->time_const) {
288 #if 1
289 int tmp = 256 - s->time_const;
290 s->freq = (1000000 + (tmp / 2)) / tmp;
291 #else
292 /* s->freq = 1000000 / ((255 - s->time_const) << s->fmt_stereo); */
293 s->freq = 1000000 / ((255 - s->time_const));
294 #endif
295 s->time_const = -1;
298 s->block_size = dma_len + 1;
299 s->block_size <<= (s->fmt_bits == 16);
300 if (!s->dma_auto) {
301 /* It is clear that for DOOM and auto-init this value
302 shouldn't take stereo into account, while Miles Sound Systems
303 setsound.exe with single transfer mode wouldn't work without it
304 wonders of SB16 yet again */
305 s->block_size <<= s->fmt_stereo;
308 ldebug ("freq %d, stereo %d, sign %d, bits %d, "
309 "dma %d, auto %d, fifo %d, high %d\n",
310 s->freq, s->fmt_stereo, s->fmt_signed, s->fmt_bits,
311 s->block_size, s->dma_auto, s->fifo, s->highspeed);
313 if (16 == s->fmt_bits) {
314 if (s->fmt_signed) {
315 s->fmt = AUD_FMT_S16;
317 else {
318 s->fmt = AUD_FMT_U16;
321 else {
322 if (s->fmt_signed) {
323 s->fmt = AUD_FMT_S8;
325 else {
326 s->fmt = AUD_FMT_U8;
330 s->left_till_irq = s->block_size;
332 s->bytes_per_second = (s->freq << s->fmt_stereo) << (s->fmt_bits == 16);
333 s->highspeed = 0;
334 s->align = (1 << (s->fmt_stereo + (s->fmt_bits == 16))) - 1;
335 if (s->block_size & s->align) {
336 dolog ("warning: misaligned block size %d, alignment %d\n",
337 s->block_size, s->align + 1);
340 if (s->freq) {
341 struct audsettings as;
343 s->audio_free = 0;
345 as.freq = s->freq;
346 as.nchannels = 1 << s->fmt_stereo;
347 as.fmt = s->fmt;
348 as.endianness = 0;
350 s->voice = AUD_open_out (
351 &s->card,
352 s->voice,
353 "sb16",
355 SB_audio_callback,
360 control (s, 1);
361 speaker (s, 1);
364 static inline void dsp_out_data (SB16State *s, uint8_t val)
366 ldebug ("outdata %#x\n", val);
367 if ((size_t) s->out_data_len < sizeof (s->out_data)) {
368 s->out_data[s->out_data_len++] = val;
372 static inline uint8_t dsp_get_data (SB16State *s)
374 if (s->in_index) {
375 return s->in2_data[--s->in_index];
377 else {
378 dolog ("buffer underflow\n");
379 return 0;
383 static void command (SB16State *s, uint8_t cmd)
385 ldebug ("command %#x\n", cmd);
387 if (cmd > 0xaf && cmd < 0xd0) {
388 if (cmd & 8) {
389 dolog ("ADC not yet supported (command %#x)\n", cmd);
392 switch (cmd >> 4) {
393 case 11:
394 case 12:
395 break;
396 default:
397 dolog ("%#x wrong bits\n", cmd);
399 s->needed_bytes = 3;
401 else {
402 s->needed_bytes = 0;
404 switch (cmd) {
405 case 0x03:
406 dsp_out_data (s, 0x10); /* s->csp_param); */
407 goto warn;
409 case 0x04:
410 s->needed_bytes = 1;
411 goto warn;
413 case 0x05:
414 s->needed_bytes = 2;
415 goto warn;
417 case 0x08:
418 /* __asm__ ("int3"); */
419 goto warn;
421 case 0x0e:
422 s->needed_bytes = 2;
423 goto warn;
425 case 0x09:
426 dsp_out_data (s, 0xf8);
427 goto warn;
429 case 0x0f:
430 s->needed_bytes = 1;
431 goto warn;
433 case 0x10:
434 s->needed_bytes = 1;
435 goto warn;
437 case 0x14:
438 s->needed_bytes = 2;
439 s->block_size = 0;
440 break;
442 case 0x1c: /* Auto-Initialize DMA DAC, 8-bit */
443 dma_cmd8 (s, DMA8_AUTO, -1);
444 break;
446 case 0x20: /* Direct ADC, Juice/PL */
447 dsp_out_data (s, 0xff);
448 goto warn;
450 case 0x35:
451 dolog ("0x35 - MIDI command not implemented\n");
452 break;
454 case 0x40:
455 s->freq = -1;
456 s->time_const = -1;
457 s->needed_bytes = 1;
458 break;
460 case 0x41:
461 s->freq = -1;
462 s->time_const = -1;
463 s->needed_bytes = 2;
464 break;
466 case 0x42:
467 s->freq = -1;
468 s->time_const = -1;
469 s->needed_bytes = 2;
470 goto warn;
472 case 0x45:
473 dsp_out_data (s, 0xaa);
474 goto warn;
476 case 0x47: /* Continue Auto-Initialize DMA 16bit */
477 break;
479 case 0x48:
480 s->needed_bytes = 2;
481 break;
483 case 0x74:
484 s->needed_bytes = 2; /* DMA DAC, 4-bit ADPCM */
485 dolog ("0x75 - DMA DAC, 4-bit ADPCM not implemented\n");
486 break;
488 case 0x75: /* DMA DAC, 4-bit ADPCM Reference */
489 s->needed_bytes = 2;
490 dolog ("0x74 - DMA DAC, 4-bit ADPCM Reference not implemented\n");
491 break;
493 case 0x76: /* DMA DAC, 2.6-bit ADPCM */
494 s->needed_bytes = 2;
495 dolog ("0x74 - DMA DAC, 2.6-bit ADPCM not implemented\n");
496 break;
498 case 0x77: /* DMA DAC, 2.6-bit ADPCM Reference */
499 s->needed_bytes = 2;
500 dolog ("0x74 - DMA DAC, 2.6-bit ADPCM Reference not implemented\n");
501 break;
503 case 0x7d:
504 dolog ("0x7d - Autio-Initialize DMA DAC, 4-bit ADPCM Reference\n");
505 dolog ("not implemented\n");
506 break;
508 case 0x7f:
509 dolog (
510 "0x7d - Autio-Initialize DMA DAC, 2.6-bit ADPCM Reference\n"
512 dolog ("not implemented\n");
513 break;
515 case 0x80:
516 s->needed_bytes = 2;
517 break;
519 case 0x90:
520 case 0x91:
521 dma_cmd8 (s, ((cmd & 1) == 0) | DMA8_HIGH, -1);
522 break;
524 case 0xd0: /* halt DMA operation. 8bit */
525 control (s, 0);
526 break;
528 case 0xd1: /* speaker on */
529 speaker (s, 1);
530 break;
532 case 0xd3: /* speaker off */
533 speaker (s, 0);
534 break;
536 case 0xd4: /* continue DMA operation. 8bit */
537 /* KQ6 (or maybe Sierras audblst.drv in general) resets
538 the frequency between halt/continue */
539 continue_dma8 (s);
540 break;
542 case 0xd5: /* halt DMA operation. 16bit */
543 control (s, 0);
544 break;
546 case 0xd6: /* continue DMA operation. 16bit */
547 control (s, 1);
548 break;
550 case 0xd9: /* exit auto-init DMA after this block. 16bit */
551 s->dma_auto = 0;
552 break;
554 case 0xda: /* exit auto-init DMA after this block. 8bit */
555 s->dma_auto = 0;
556 break;
558 case 0xe0: /* DSP identification */
559 s->needed_bytes = 1;
560 break;
562 case 0xe1:
563 dsp_out_data (s, s->ver & 0xff);
564 dsp_out_data (s, s->ver >> 8);
565 break;
567 case 0xe2:
568 s->needed_bytes = 1;
569 goto warn;
571 case 0xe3:
573 int i;
574 for (i = sizeof (e3) - 1; i >= 0; --i)
575 dsp_out_data (s, e3[i]);
577 break;
579 case 0xe4: /* write test reg */
580 s->needed_bytes = 1;
581 break;
583 case 0xe7:
584 dolog ("Attempt to probe for ESS (0xe7)?\n");
585 break;
587 case 0xe8: /* read test reg */
588 dsp_out_data (s, s->test_reg);
589 break;
591 case 0xf2:
592 case 0xf3:
593 dsp_out_data (s, 0xaa);
594 s->mixer_regs[0x82] |= (cmd == 0xf2) ? 1 : 2;
595 qemu_irq_raise (s->pic);
596 break;
598 case 0xf9:
599 s->needed_bytes = 1;
600 goto warn;
602 case 0xfa:
603 dsp_out_data (s, 0);
604 goto warn;
606 case 0xfc: /* FIXME */
607 dsp_out_data (s, 0);
608 goto warn;
610 default:
611 dolog ("Unrecognized command %#x\n", cmd);
612 break;
616 if (!s->needed_bytes) {
617 ldebug ("\n");
620 exit:
621 if (!s->needed_bytes) {
622 s->cmd = -1;
624 else {
625 s->cmd = cmd;
627 return;
629 warn:
630 dolog ("warning: command %#x,%d is not truly understood yet\n",
631 cmd, s->needed_bytes);
632 goto exit;
636 static uint16_t dsp_get_lohi (SB16State *s)
638 uint8_t hi = dsp_get_data (s);
639 uint8_t lo = dsp_get_data (s);
640 return (hi << 8) | lo;
643 static uint16_t dsp_get_hilo (SB16State *s)
645 uint8_t lo = dsp_get_data (s);
646 uint8_t hi = dsp_get_data (s);
647 return (hi << 8) | lo;
650 static void complete (SB16State *s)
652 int d0, d1, d2;
653 ldebug ("complete command %#x, in_index %d, needed_bytes %d\n",
654 s->cmd, s->in_index, s->needed_bytes);
656 if (s->cmd > 0xaf && s->cmd < 0xd0) {
657 d2 = dsp_get_data (s);
658 d1 = dsp_get_data (s);
659 d0 = dsp_get_data (s);
661 if (s->cmd & 8) {
662 dolog ("ADC params cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
663 s->cmd, d0, d1, d2);
665 else {
666 ldebug ("cmd = %#x d0 = %d, d1 = %d, d2 = %d\n",
667 s->cmd, d0, d1, d2);
668 dma_cmd (s, s->cmd, d0, d1 + (d2 << 8));
671 else {
672 switch (s->cmd) {
673 case 0x04:
674 s->csp_mode = dsp_get_data (s);
675 s->csp_reg83r = 0;
676 s->csp_reg83w = 0;
677 ldebug ("CSP command 0x04: mode=%#x\n", s->csp_mode);
678 break;
680 case 0x05:
681 s->csp_param = dsp_get_data (s);
682 s->csp_value = dsp_get_data (s);
683 ldebug ("CSP command 0x05: param=%#x value=%#x\n",
684 s->csp_param,
685 s->csp_value);
686 break;
688 case 0x0e:
689 d0 = dsp_get_data (s);
690 d1 = dsp_get_data (s);
691 ldebug ("write CSP register %d <- %#x\n", d1, d0);
692 if (d1 == 0x83) {
693 ldebug ("0x83[%d] <- %#x\n", s->csp_reg83r, d0);
694 s->csp_reg83[s->csp_reg83r % 4] = d0;
695 s->csp_reg83r += 1;
697 else {
698 s->csp_regs[d1] = d0;
700 break;
702 case 0x0f:
703 d0 = dsp_get_data (s);
704 ldebug ("read CSP register %#x -> %#x, mode=%#x\n",
705 d0, s->csp_regs[d0], s->csp_mode);
706 if (d0 == 0x83) {
707 ldebug ("0x83[%d] -> %#x\n",
708 s->csp_reg83w,
709 s->csp_reg83[s->csp_reg83w % 4]);
710 dsp_out_data (s, s->csp_reg83[s->csp_reg83w % 4]);
711 s->csp_reg83w += 1;
713 else {
714 dsp_out_data (s, s->csp_regs[d0]);
716 break;
718 case 0x10:
719 d0 = dsp_get_data (s);
720 dolog ("cmd 0x10 d0=%#x\n", d0);
721 break;
723 case 0x14:
724 dma_cmd8 (s, 0, dsp_get_lohi (s) + 1);
725 break;
727 case 0x40:
728 s->time_const = dsp_get_data (s);
729 ldebug ("set time const %d\n", s->time_const);
730 break;
732 case 0x42: /* FT2 sets output freq with this, go figure */
733 #if 0
734 dolog ("cmd 0x42 might not do what it think it should\n");
735 #endif
736 case 0x41:
737 s->freq = dsp_get_hilo (s);
738 ldebug ("set freq %d\n", s->freq);
739 break;
741 case 0x48:
742 s->block_size = dsp_get_lohi (s) + 1;
743 ldebug ("set dma block len %d\n", s->block_size);
744 break;
746 case 0x74:
747 case 0x75:
748 case 0x76:
749 case 0x77:
750 /* ADPCM stuff, ignore */
751 break;
753 case 0x80:
755 int freq, samples, bytes;
756 int64_t ticks;
758 freq = s->freq > 0 ? s->freq : 11025;
759 samples = dsp_get_lohi (s) + 1;
760 bytes = samples << s->fmt_stereo << (s->fmt_bits == 16);
761 ticks = muldiv64 (bytes, get_ticks_per_sec (), freq);
762 if (ticks < get_ticks_per_sec () / 1024) {
763 qemu_irq_raise (s->pic);
765 else {
766 if (s->aux_ts) {
767 qemu_mod_timer (
768 s->aux_ts,
769 qemu_get_clock_ns (vm_clock) + ticks
773 ldebug ("mix silence %d %d %" PRId64 "\n", samples, bytes, ticks);
775 break;
777 case 0xe0:
778 d0 = dsp_get_data (s);
779 s->out_data_len = 0;
780 ldebug ("E0 data = %#x\n", d0);
781 dsp_out_data (s, ~d0);
782 break;
784 case 0xe2:
785 #ifdef DEBUG
786 d0 = dsp_get_data (s);
787 dolog ("E2 = %#x\n", d0);
788 #endif
789 break;
791 case 0xe4:
792 s->test_reg = dsp_get_data (s);
793 break;
795 case 0xf9:
796 d0 = dsp_get_data (s);
797 ldebug ("command 0xf9 with %#x\n", d0);
798 switch (d0) {
799 case 0x0e:
800 dsp_out_data (s, 0xff);
801 break;
803 case 0x0f:
804 dsp_out_data (s, 0x07);
805 break;
807 case 0x37:
808 dsp_out_data (s, 0x38);
809 break;
811 default:
812 dsp_out_data (s, 0x00);
813 break;
815 break;
817 default:
818 dolog ("complete: unrecognized command %#x\n", s->cmd);
819 return;
823 ldebug ("\n");
824 s->cmd = -1;
827 static void legacy_reset (SB16State *s)
829 struct audsettings as;
831 s->freq = 11025;
832 s->fmt_signed = 0;
833 s->fmt_bits = 8;
834 s->fmt_stereo = 0;
836 as.freq = s->freq;
837 as.nchannels = 1;
838 as.fmt = AUD_FMT_U8;
839 as.endianness = 0;
841 s->voice = AUD_open_out (
842 &s->card,
843 s->voice,
844 "sb16",
846 SB_audio_callback,
850 /* Not sure about that... */
851 /* AUD_set_active_out (s->voice, 1); */
854 static void reset (SB16State *s)
856 qemu_irq_lower (s->pic);
857 if (s->dma_auto) {
858 qemu_irq_raise (s->pic);
859 qemu_irq_lower (s->pic);
862 s->mixer_regs[0x82] = 0;
863 s->dma_auto = 0;
864 s->in_index = 0;
865 s->out_data_len = 0;
866 s->left_till_irq = 0;
867 s->needed_bytes = 0;
868 s->block_size = -1;
869 s->nzero = 0;
870 s->highspeed = 0;
871 s->v2x6 = 0;
872 s->cmd = -1;
874 dsp_out_data (s, 0xaa);
875 speaker (s, 0);
876 control (s, 0);
877 legacy_reset (s);
880 static IO_WRITE_PROTO (dsp_write)
882 SB16State *s = opaque;
883 int iport;
885 iport = nport - s->port;
887 ldebug ("write %#x <- %#x\n", nport, val);
888 switch (iport) {
889 case 0x06:
890 switch (val) {
891 case 0x00:
892 if (s->v2x6 == 1) {
893 reset (s);
895 s->v2x6 = 0;
896 break;
898 case 0x01:
899 case 0x03: /* FreeBSD kludge */
900 s->v2x6 = 1;
901 break;
903 case 0xc6:
904 s->v2x6 = 0; /* Prince of Persia, csp.sys, diagnose.exe */
905 break;
907 case 0xb8: /* Panic */
908 reset (s);
909 break;
911 case 0x39:
912 dsp_out_data (s, 0x38);
913 reset (s);
914 s->v2x6 = 0x39;
915 break;
917 default:
918 s->v2x6 = val;
919 break;
921 break;
923 case 0x0c: /* write data or command | write status */
924 /* if (s->highspeed) */
925 /* break; */
927 if (0 == s->needed_bytes) {
928 command (s, val);
929 #if 0
930 if (0 == s->needed_bytes) {
931 log_dsp (s);
933 #endif
935 else {
936 if (s->in_index == sizeof (s->in2_data)) {
937 dolog ("in data overrun\n");
939 else {
940 s->in2_data[s->in_index++] = val;
941 if (s->in_index == s->needed_bytes) {
942 s->needed_bytes = 0;
943 complete (s);
944 #if 0
945 log_dsp (s);
946 #endif
950 break;
952 default:
953 ldebug ("(nport=%#x, val=%#x)\n", nport, val);
954 break;
958 static IO_READ_PROTO (dsp_read)
960 SB16State *s = opaque;
961 int iport, retval, ack = 0;
963 iport = nport - s->port;
965 switch (iport) {
966 case 0x06: /* reset */
967 retval = 0xff;
968 break;
970 case 0x0a: /* read data */
971 if (s->out_data_len) {
972 retval = s->out_data[--s->out_data_len];
973 s->last_read_byte = retval;
975 else {
976 if (s->cmd != -1) {
977 dolog ("empty output buffer for command %#x\n",
978 s->cmd);
980 retval = s->last_read_byte;
981 /* goto error; */
983 break;
985 case 0x0c: /* 0 can write */
986 retval = s->can_write ? 0 : 0x80;
987 break;
989 case 0x0d: /* timer interrupt clear */
990 /* dolog ("timer interrupt clear\n"); */
991 retval = 0;
992 break;
994 case 0x0e: /* data available status | irq 8 ack */
995 retval = (!s->out_data_len || s->highspeed) ? 0 : 0x80;
996 if (s->mixer_regs[0x82] & 1) {
997 ack = 1;
998 s->mixer_regs[0x82] &= 1;
999 qemu_irq_lower (s->pic);
1001 break;
1003 case 0x0f: /* irq 16 ack */
1004 retval = 0xff;
1005 if (s->mixer_regs[0x82] & 2) {
1006 ack = 1;
1007 s->mixer_regs[0x82] &= 2;
1008 qemu_irq_lower (s->pic);
1010 break;
1012 default:
1013 goto error;
1016 if (!ack) {
1017 ldebug ("read %#x -> %#x\n", nport, retval);
1020 return retval;
1022 error:
1023 dolog ("warning: dsp_read %#x error\n", nport);
1024 return 0xff;
1027 static void reset_mixer (SB16State *s)
1029 int i;
1031 memset (s->mixer_regs, 0xff, 0x7f);
1032 memset (s->mixer_regs + 0x83, 0xff, sizeof (s->mixer_regs) - 0x83);
1034 s->mixer_regs[0x02] = 4; /* master volume 3bits */
1035 s->mixer_regs[0x06] = 4; /* MIDI volume 3bits */
1036 s->mixer_regs[0x08] = 0; /* CD volume 3bits */
1037 s->mixer_regs[0x0a] = 0; /* voice volume 2bits */
1039 /* d5=input filt, d3=lowpass filt, d1,d2=input source */
1040 s->mixer_regs[0x0c] = 0;
1042 /* d5=output filt, d1=stereo switch */
1043 s->mixer_regs[0x0e] = 0;
1045 /* voice volume L d5,d7, R d1,d3 */
1046 s->mixer_regs[0x04] = (4 << 5) | (4 << 1);
1047 /* master ... */
1048 s->mixer_regs[0x22] = (4 << 5) | (4 << 1);
1049 /* MIDI ... */
1050 s->mixer_regs[0x26] = (4 << 5) | (4 << 1);
1052 for (i = 0x30; i < 0x48; i++) {
1053 s->mixer_regs[i] = 0x20;
1057 static IO_WRITE_PROTO (mixer_write_indexb)
1059 SB16State *s = opaque;
1060 (void) nport;
1061 s->mixer_nreg = val;
1064 static IO_WRITE_PROTO (mixer_write_datab)
1066 SB16State *s = opaque;
1068 (void) nport;
1069 ldebug ("mixer_write [%#x] <- %#x\n", s->mixer_nreg, val);
1071 switch (s->mixer_nreg) {
1072 case 0x00:
1073 reset_mixer (s);
1074 break;
1076 case 0x80:
1078 int irq = irq_of_magic (val);
1079 ldebug ("setting irq to %d (val=%#x)\n", irq, val);
1080 if (irq > 0) {
1081 s->irq = irq;
1084 break;
1086 case 0x81:
1088 int dma, hdma;
1090 dma = ctz32 (val & 0xf);
1091 hdma = ctz32 (val & 0xf0);
1092 if (dma != s->dma || hdma != s->hdma) {
1093 dolog (
1094 "attempt to change DMA "
1095 "8bit %d(%d), 16bit %d(%d) (val=%#x)\n",
1096 dma, s->dma, hdma, s->hdma, val);
1098 #if 0
1099 s->dma = dma;
1100 s->hdma = hdma;
1101 #endif
1103 break;
1105 case 0x82:
1106 dolog ("attempt to write into IRQ status register (val=%#x)\n",
1107 val);
1108 return;
1110 default:
1111 if (s->mixer_nreg >= 0x80) {
1112 ldebug ("attempt to write mixer[%#x] <- %#x\n", s->mixer_nreg, val);
1114 break;
1117 s->mixer_regs[s->mixer_nreg] = val;
1120 static IO_WRITE_PROTO (mixer_write_indexw)
1122 mixer_write_indexb (opaque, nport, val & 0xff);
1123 mixer_write_datab (opaque, nport, (val >> 8) & 0xff);
1126 static IO_READ_PROTO (mixer_read)
1128 SB16State *s = opaque;
1130 (void) nport;
1131 #ifndef DEBUG_SB16_MOST
1132 if (s->mixer_nreg != 0x82) {
1133 ldebug ("mixer_read[%#x] -> %#x\n",
1134 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]);
1136 #else
1137 ldebug ("mixer_read[%#x] -> %#x\n",
1138 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]);
1139 #endif
1140 return s->mixer_regs[s->mixer_nreg];
1143 static int write_audio (SB16State *s, int nchan, int dma_pos,
1144 int dma_len, int len)
1146 int temp, net;
1147 uint8_t tmpbuf[4096];
1149 temp = len;
1150 net = 0;
1152 while (temp) {
1153 int left = dma_len - dma_pos;
1154 int copied;
1155 size_t to_copy;
1157 to_copy = audio_MIN (temp, left);
1158 if (to_copy > sizeof (tmpbuf)) {
1159 to_copy = sizeof (tmpbuf);
1162 copied = DMA_read_memory (nchan, tmpbuf, dma_pos, to_copy);
1163 copied = AUD_write (s->voice, tmpbuf, copied);
1165 temp -= copied;
1166 dma_pos = (dma_pos + copied) % dma_len;
1167 net += copied;
1169 if (!copied) {
1170 break;
1174 return net;
1177 static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len)
1179 SB16State *s = opaque;
1180 int till, copy, written, free;
1182 if (s->block_size <= 0) {
1183 dolog ("invalid block size=%d nchan=%d dma_pos=%d dma_len=%d\n",
1184 s->block_size, nchan, dma_pos, dma_len);
1185 return dma_pos;
1188 if (s->left_till_irq < 0) {
1189 s->left_till_irq = s->block_size;
1192 if (s->voice) {
1193 free = s->audio_free & ~s->align;
1194 if ((free <= 0) || !dma_len) {
1195 return dma_pos;
1198 else {
1199 free = dma_len;
1202 copy = free;
1203 till = s->left_till_irq;
1205 #ifdef DEBUG_SB16_MOST
1206 dolog ("pos:%06d %d till:%d len:%d\n",
1207 dma_pos, free, till, dma_len);
1208 #endif
1210 if (till <= copy) {
1211 if (0 == s->dma_auto) {
1212 copy = till;
1216 written = write_audio (s, nchan, dma_pos, dma_len, copy);
1217 dma_pos = (dma_pos + written) % dma_len;
1218 s->left_till_irq -= written;
1220 if (s->left_till_irq <= 0) {
1221 s->mixer_regs[0x82] |= (nchan & 4) ? 2 : 1;
1222 qemu_irq_raise (s->pic);
1223 if (0 == s->dma_auto) {
1224 control (s, 0);
1225 speaker (s, 0);
1229 #ifdef DEBUG_SB16_MOST
1230 ldebug ("pos %5d free %5d size %5d till % 5d copy %5d written %5d size %5d\n",
1231 dma_pos, free, dma_len, s->left_till_irq, copy, written,
1232 s->block_size);
1233 #endif
1235 while (s->left_till_irq <= 0) {
1236 s->left_till_irq = s->block_size + s->left_till_irq;
1239 return dma_pos;
1242 static void SB_audio_callback (void *opaque, int free)
1244 SB16State *s = opaque;
1245 s->audio_free = free;
1248 static int sb16_post_load (void *opaque, int version_id)
1250 SB16State *s = opaque;
1252 if (s->voice) {
1253 AUD_close_out (&s->card, s->voice);
1254 s->voice = NULL;
1257 if (s->dma_running) {
1258 if (s->freq) {
1259 struct audsettings as;
1261 s->audio_free = 0;
1263 as.freq = s->freq;
1264 as.nchannels = 1 << s->fmt_stereo;
1265 as.fmt = s->fmt;
1266 as.endianness = 0;
1268 s->voice = AUD_open_out (
1269 &s->card,
1270 s->voice,
1271 "sb16",
1273 SB_audio_callback,
1278 control (s, 1);
1279 speaker (s, s->speaker);
1281 return 0;
1284 static const VMStateDescription vmstate_sb16 = {
1285 .name = "sb16",
1286 .version_id = 1,
1287 .minimum_version_id = 1,
1288 .minimum_version_id_old = 1,
1289 .post_load = sb16_post_load,
1290 .fields = (VMStateField []) {
1291 VMSTATE_UINT32 (irq, SB16State),
1292 VMSTATE_UINT32 (dma, SB16State),
1293 VMSTATE_UINT32 (hdma, SB16State),
1294 VMSTATE_UINT32 (port, SB16State),
1295 VMSTATE_UINT32 (ver, SB16State),
1296 VMSTATE_INT32 (in_index, SB16State),
1297 VMSTATE_INT32 (out_data_len, SB16State),
1298 VMSTATE_INT32 (fmt_stereo, SB16State),
1299 VMSTATE_INT32 (fmt_signed, SB16State),
1300 VMSTATE_INT32 (fmt_bits, SB16State),
1301 VMSTATE_UINT32 (fmt, SB16State),
1302 VMSTATE_INT32 (dma_auto, SB16State),
1303 VMSTATE_INT32 (block_size, SB16State),
1304 VMSTATE_INT32 (fifo, SB16State),
1305 VMSTATE_INT32 (freq, SB16State),
1306 VMSTATE_INT32 (time_const, SB16State),
1307 VMSTATE_INT32 (speaker, SB16State),
1308 VMSTATE_INT32 (needed_bytes, SB16State),
1309 VMSTATE_INT32 (cmd, SB16State),
1310 VMSTATE_INT32 (use_hdma, SB16State),
1311 VMSTATE_INT32 (highspeed, SB16State),
1312 VMSTATE_INT32 (can_write, SB16State),
1313 VMSTATE_INT32 (v2x6, SB16State),
1315 VMSTATE_UINT8 (csp_param, SB16State),
1316 VMSTATE_UINT8 (csp_value, SB16State),
1317 VMSTATE_UINT8 (csp_mode, SB16State),
1318 VMSTATE_UINT8 (csp_param, SB16State),
1319 VMSTATE_BUFFER (csp_regs, SB16State),
1320 VMSTATE_UINT8 (csp_index, SB16State),
1321 VMSTATE_BUFFER (csp_reg83, SB16State),
1322 VMSTATE_INT32 (csp_reg83r, SB16State),
1323 VMSTATE_INT32 (csp_reg83w, SB16State),
1325 VMSTATE_BUFFER (in2_data, SB16State),
1326 VMSTATE_BUFFER (out_data, SB16State),
1327 VMSTATE_UINT8 (test_reg, SB16State),
1328 VMSTATE_UINT8 (last_read_byte, SB16State),
1330 VMSTATE_INT32 (nzero, SB16State),
1331 VMSTATE_INT32 (left_till_irq, SB16State),
1332 VMSTATE_INT32 (dma_running, SB16State),
1333 VMSTATE_INT32 (bytes_per_second, SB16State),
1334 VMSTATE_INT32 (align, SB16State),
1336 VMSTATE_INT32 (mixer_nreg, SB16State),
1337 VMSTATE_BUFFER (mixer_regs, SB16State),
1339 VMSTATE_END_OF_LIST ()
1343 static const MemoryRegionPortio sb16_ioport_list[] = {
1344 { 4, 1, 1, .write = mixer_write_indexb },
1345 { 4, 1, 2, .write = mixer_write_indexw },
1346 { 5, 1, 1, .read = mixer_read, .write = mixer_write_datab },
1347 { 6, 1, 1, .read = dsp_read, .write = dsp_write },
1348 { 10, 1, 1, .read = dsp_read },
1349 { 12, 1, 1, .write = dsp_write },
1350 { 12, 4, 1, .read = dsp_read },
1351 PORTIO_END_OF_LIST (),
1355 static int sb16_initfn (ISADevice *dev)
1357 SB16State *s;
1359 s = DO_UPCAST (SB16State, dev, dev);
1361 s->cmd = -1;
1362 isa_init_irq (dev, &s->pic, s->irq);
1364 s->mixer_regs[0x80] = magic_of_irq (s->irq);
1365 s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma);
1366 s->mixer_regs[0x82] = 2 << 5;
1368 s->csp_regs[5] = 1;
1369 s->csp_regs[9] = 0xf8;
1371 reset_mixer (s);
1372 s->aux_ts = qemu_new_timer_ns (vm_clock, aux_timer, s);
1373 if (!s->aux_ts) {
1374 dolog ("warning: Could not create auxiliary timer\n");
1377 isa_register_portio_list (dev, s->port, sb16_ioport_list, s, "sb16");
1379 DMA_register_channel (s->hdma, SB_read_DMA, s);
1380 DMA_register_channel (s->dma, SB_read_DMA, s);
1381 s->can_write = 1;
1383 AUD_register_card ("sb16", &s->card);
1384 return 0;
1387 int SB16_init (ISABus *bus)
1389 isa_create_simple (bus, "sb16");
1390 return 0;
1393 static Property sb16_properties[] = {
1394 DEFINE_PROP_HEX32 ("version", SB16State, ver, 0x0405), /* 4.5 */
1395 DEFINE_PROP_HEX32 ("iobase", SB16State, port, 0x220),
1396 DEFINE_PROP_UINT32 ("irq", SB16State, irq, 5),
1397 DEFINE_PROP_UINT32 ("dma", SB16State, dma, 1),
1398 DEFINE_PROP_UINT32 ("dma16", SB16State, hdma, 5),
1399 DEFINE_PROP_END_OF_LIST (),
1402 static void sb16_class_initfn (ObjectClass *klass, void *data)
1404 DeviceClass *dc = DEVICE_CLASS (klass);
1405 ISADeviceClass *ic = ISA_DEVICE_CLASS (klass);
1406 ic->init = sb16_initfn;
1407 dc->desc = "Creative Sound Blaster 16";
1408 dc->vmsd = &vmstate_sb16;
1409 dc->props = sb16_properties;
1412 static const TypeInfo sb16_info = {
1413 .name = "sb16",
1414 .parent = TYPE_ISA_DEVICE,
1415 .instance_size = sizeof (SB16State),
1416 .class_init = sb16_class_initfn,
1419 static void sb16_register_types (void)
1421 type_register_static (&sb16_info);
1424 type_init (sb16_register_types)