?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
migration/vmstate: document VMStateFlags
[qemu/ar7.git] / hw / audio / sb16.c
blob6f8816cf64aa8c4e39f1df44bc7ae4d304e68615
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 "qemu/osdep.h"
25 #include "hw/hw.h"
26 #include "hw/audio/audio.h"
27 #include "audio/audio.h"
28 #include "hw/isa/isa.h"
29 #include "hw/qdev.h"
30 #include "qemu/timer.h"
31 #include "qemu/host-utils.h"
32
33 #define dolog(...) AUD_log ("sb16", __VA_ARGS__)
34
35 /* #define DEBUG */
36 /* #define DEBUG_SB16_MOST */
37
38 #ifdef DEBUG
39 #define ldebug(...) dolog (__VA_ARGS__)
40 #else
41 #define ldebug(...)
42 #endif
43
44 static const char e3[] = "COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
45
46 #define TYPE_SB16 "sb16"
47 #define SB16(obj) OBJECT_CHECK (SB16State, (obj), TYPE_SB16)
48
49 typedef struct SB16State {
50 ISADevice parent_obj;
51
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;
59 IsaDma *isa_dma;
60 IsaDma *isa_hdma;
61
62 int in_index;
63 int out_data_len;
64 int fmt_stereo;
65 int fmt_signed;
66 int fmt_bits;
67 audfmt_e fmt;
68 int dma_auto;
69 int block_size;
70 int fifo;
71 int freq;
72 int time_const;
73 int speaker;
74 int needed_bytes;
75 int cmd;
76 int use_hdma;
77 int highspeed;
78 int can_write;
79
80 int v2x6;
81
82 uint8_t csp_param;
83 uint8_t csp_value;
84 uint8_t csp_mode;
85 uint8_t csp_regs[256];
86 uint8_t csp_index;
87 uint8_t csp_reg83[4];
88 int csp_reg83r;
89 int csp_reg83w;
90
91 uint8_t in2_data[10];
92 uint8_t out_data[50];
93 uint8_t test_reg;
94 uint8_t last_read_byte;
95 int nzero;
96
97 int left_till_irq;
98
99 int dma_running;
100 int bytes_per_second;
101 int align;
102 int audio_free;
103 SWVoiceOut *voice;
104
105 QEMUTimer *aux_ts;
106 /* mixer state */
107 int mixer_nreg;
108 uint8_t mixer_regs[256];
109 } SB16State;
110
111 static void SB_audio_callback (void *opaque, int free);
112
113 static int magic_of_irq (int irq)
114 {
115 switch (irq) {
116 case 5:
117 return 2;
118 case 7:
119 return 4;
120 case 9:
121 return 1;
122 case 10:
123 return 8;
124 default:
125 dolog ("bad irq %d\n", irq);
126 return 2;
127 }
128 }
129
130 static int irq_of_magic (int magic)
131 {
132 switch (magic) {
133 case 1:
134 return 9;
135 case 2:
136 return 5;
137 case 4:
138 return 7;
139 case 8:
140 return 10;
141 default:
142 dolog ("bad irq magic %d\n", magic);
143 return -1;
144 }
145 }
146
147 #if 0
148 static void log_dsp (SB16State *dsp)
149 {
150 ldebug ("%s:%s:%d:%s:dmasize=%d:freq=%d:const=%d:speaker=%d\n",
151 dsp->fmt_stereo ? "Stereo" : "Mono",
152 dsp->fmt_signed ? "Signed" : "Unsigned",
153 dsp->fmt_bits,
154 dsp->dma_auto ? "Auto" : "Single",
155 dsp->block_size,
156 dsp->freq,
157 dsp->time_const,
158 dsp->speaker);
159 }
160 #endif
161
162 static void speaker (SB16State *s, int on)
163 {
164 s->speaker = on;
165 /* AUD_enable (s->voice, on); */
166 }
167
168 static void control (SB16State *s, int hold)
169 {
170 int dma = s->use_hdma ? s->hdma : s->dma;
171 IsaDma *isa_dma = s->use_hdma ? s->isa_hdma : s->isa_dma;
172 IsaDmaClass *k = ISADMA_GET_CLASS(isa_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 k->hold_DREQ(isa_dma, dma);
179 AUD_set_active_out (s->voice, 1);
180 }
181 else {
182 k->release_DREQ(isa_dma, 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 void dsp_write(void *opaque, uint32_t nport, uint32_t val)
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 uint32_t dsp_read(void *opaque, uint32_t nport)
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 void mixer_write_indexb(void *opaque, uint32_t nport, uint32_t val)
1062 {
1063 SB16State *s = opaque;
1064 (void) nport;
1065 s->mixer_nreg = val;
1066 }
1067
1068 static void mixer_write_datab(void *opaque, uint32_t nport, uint32_t val)
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 uint32_t mixer_read(void *opaque, uint32_t nport)
1125 {
1126 SB16State *s = opaque;
1127
1128 (void) nport;
1129 #ifndef DEBUG_SB16_MOST
1130 if (s->mixer_nreg != 0x82) {
1131 ldebug ("mixer_read[%#x] -> %#x\n",
1132 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]);
1133 }
1134 #else
1135 ldebug ("mixer_read[%#x] -> %#x\n",
1136 s->mixer_nreg, s->mixer_regs[s->mixer_nreg]);
1137 #endif
1138 return s->mixer_regs[s->mixer_nreg];
1139 }
1140
1141 static int write_audio (SB16State *s, int nchan, int dma_pos,
1142 int dma_len, int len)
1143 {
1144 IsaDma *isa_dma = nchan == s->dma ? s->isa_dma : s->isa_hdma;
1145 IsaDmaClass *k = ISADMA_GET_CLASS(isa_dma);
1146 int temp, net;
1147 uint8_t tmpbuf[4096];
1148
1149 temp = len;
1150 net = 0;
1151
1152 while (temp) {
1153 int left = dma_len - dma_pos;
1154 int copied;
1155 size_t to_copy;
1156
1157 to_copy = audio_MIN (temp, left);
1158 if (to_copy > sizeof (tmpbuf)) {
1159 to_copy = sizeof (tmpbuf);
1160 }
1161
1162 copied = k->read_memory(isa_dma, nchan, tmpbuf, dma_pos, to_copy);
1163 copied = AUD_write (s->voice, tmpbuf, copied);
1164
1165 temp -= copied;
1166 dma_pos = (dma_pos + copied) % dma_len;
1167 net += copied;
1168
1169 if (!copied) {
1170 break;
1171 }
1172 }
1173
1174 return net;
1175 }
1176
1177 static int SB_read_DMA (void *opaque, int nchan, int dma_pos, int dma_len)
1178 {
1179 SB16State *s = opaque;
1180 int till, copy, written, free;
1181
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;
1186 }
1187
1188 if (s->left_till_irq < 0) {
1189 s->left_till_irq = s->block_size;
1190 }
1191
1192 if (s->voice) {
1193 free = s->audio_free & ~s->align;
1194 if ((free <= 0) || !dma_len) {
1195 return dma_pos;
1196 }
1197 }
1198 else {
1199 free = dma_len;
1200 }
1201
1202 copy = free;
1203 till = s->left_till_irq;
1204
1205 #ifdef DEBUG_SB16_MOST
1206 dolog ("pos:%06d %d till:%d len:%d\n",
1207 dma_pos, free, till, dma_len);
1208 #endif
1209
1210 if (till <= copy) {
1211 if (s->dma_auto == 0) {
1212 copy = till;
1213 }
1214 }
1215
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;
1219
1220 if (s->left_till_irq <= 0) {
1221 s->mixer_regs[0x82] |= (nchan & 4) ? 2 : 1;
1222 qemu_irq_raise (s->pic);
1223 if (s->dma_auto == 0) {
1224 control (s, 0);
1225 speaker (s, 0);
1226 }
1227 }
1228
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
1234
1235 while (s->left_till_irq <= 0) {
1236 s->left_till_irq = s->block_size + s->left_till_irq;
1237 }
1238
1239 return dma_pos;
1240 }
1241
1242 static void SB_audio_callback (void *opaque, int free)
1243 {
1244 SB16State *s = opaque;
1245 s->audio_free = free;
1246 }
1247
1248 static int sb16_post_load (void *opaque, int version_id)
1249 {
1250 SB16State *s = opaque;
1251
1252 if (s->voice) {
1253 AUD_close_out (&s->card, s->voice);
1254 s->voice = NULL;
1255 }
1256
1257 if (s->dma_running) {
1258 if (s->freq) {
1259 struct audsettings as;
1260
1261 s->audio_free = 0;
1262
1263 as.freq = s->freq;
1264 as.nchannels = 1 << s->fmt_stereo;
1265 as.fmt = s->fmt;
1266 as.endianness = 0;
1267
1268 s->voice = AUD_open_out (
1269 &s->card,
1270 s->voice,
1271 "sb16",
1272 s,
1273 SB_audio_callback,
1274 &as
1275 );
1276 }
1277
1278 control (s, 1);
1279 speaker (s, s->speaker);
1280 }
1281 return 0;
1282 }
1283
1284 static const VMStateDescription vmstate_sb16 = {
1285 .name = "sb16",
1286 .version_id = 1,
1287 .minimum_version_id = 1,
1288 .post_load = sb16_post_load,
1289 .fields = (VMStateField[]) {
1290 VMSTATE_UINT32 (irq, SB16State),
1291 VMSTATE_UINT32 (dma, SB16State),
1292 VMSTATE_UINT32 (hdma, SB16State),
1293 VMSTATE_UINT32 (port, SB16State),
1294 VMSTATE_UINT32 (ver, SB16State),
1295 VMSTATE_INT32 (in_index, SB16State),
1296 VMSTATE_INT32 (out_data_len, SB16State),
1297 VMSTATE_INT32 (fmt_stereo, SB16State),
1298 VMSTATE_INT32 (fmt_signed, SB16State),
1299 VMSTATE_INT32 (fmt_bits, SB16State),
1300 VMSTATE_UINT32 (fmt, SB16State),
1301 VMSTATE_INT32 (dma_auto, SB16State),
1302 VMSTATE_INT32 (block_size, SB16State),
1303 VMSTATE_INT32 (fifo, SB16State),
1304 VMSTATE_INT32 (freq, SB16State),
1305 VMSTATE_INT32 (time_const, SB16State),
1306 VMSTATE_INT32 (speaker, SB16State),
1307 VMSTATE_INT32 (needed_bytes, SB16State),
1308 VMSTATE_INT32 (cmd, SB16State),
1309 VMSTATE_INT32 (use_hdma, SB16State),
1310 VMSTATE_INT32 (highspeed, SB16State),
1311 VMSTATE_INT32 (can_write, SB16State),
1312 VMSTATE_INT32 (v2x6, SB16State),
1313
1314 VMSTATE_UINT8 (csp_param, SB16State),
1315 VMSTATE_UINT8 (csp_value, SB16State),
1316 VMSTATE_UINT8 (csp_mode, SB16State),
1317 VMSTATE_UINT8 (csp_param, SB16State),
1318 VMSTATE_BUFFER (csp_regs, SB16State),
1319 VMSTATE_UINT8 (csp_index, SB16State),
1320 VMSTATE_BUFFER (csp_reg83, SB16State),
1321 VMSTATE_INT32 (csp_reg83r, SB16State),
1322 VMSTATE_INT32 (csp_reg83w, SB16State),
1323
1324 VMSTATE_BUFFER (in2_data, SB16State),
1325 VMSTATE_BUFFER (out_data, SB16State),
1326 VMSTATE_UINT8 (test_reg, SB16State),
1327 VMSTATE_UINT8 (last_read_byte, SB16State),
1328
1329 VMSTATE_INT32 (nzero, SB16State),
1330 VMSTATE_INT32 (left_till_irq, SB16State),
1331 VMSTATE_INT32 (dma_running, SB16State),
1332 VMSTATE_INT32 (bytes_per_second, SB16State),
1333 VMSTATE_INT32 (align, SB16State),
1334
1335 VMSTATE_INT32 (mixer_nreg, SB16State),
1336 VMSTATE_BUFFER (mixer_regs, SB16State),
1337
1338 VMSTATE_END_OF_LIST ()
1339 }
1340 };
1341
1342 static const MemoryRegionPortio sb16_ioport_list[] = {
1343 { 4, 1, 1, .write = mixer_write_indexb },
1344 { 5, 1, 1, .read = mixer_read, .write = mixer_write_datab },
1345 { 6, 1, 1, .read = dsp_read, .write = dsp_write },
1346 { 10, 1, 1, .read = dsp_read },
1347 { 12, 1, 1, .write = dsp_write },
1348 { 12, 4, 1, .read = dsp_read },
1349 PORTIO_END_OF_LIST (),
1350 };
1351
1352
1353 static void sb16_initfn (Object *obj)
1354 {
1355 SB16State *s = SB16 (obj);
1356
1357 s->cmd = -1;
1358 }
1359
1360 static void sb16_realizefn (DeviceState *dev, Error **errp)
1361 {
1362 ISADevice *isadev = ISA_DEVICE (dev);
1363 SB16State *s = SB16 (dev);
1364 IsaDmaClass *k;
1365
1366 isa_init_irq (isadev, &s->pic, s->irq);
1367
1368 s->mixer_regs[0x80] = magic_of_irq (s->irq);
1369 s->mixer_regs[0x81] = (1 << s->dma) | (1 << s->hdma);
1370 s->mixer_regs[0x82] = 2 << 5;
1371
1372 s->csp_regs[5] = 1;
1373 s->csp_regs[9] = 0xf8;
1374
1375 reset_mixer (s);
1376 s->aux_ts = timer_new_ns(QEMU_CLOCK_VIRTUAL, aux_timer, s);
1377 if (!s->aux_ts) {
1378 dolog ("warning: Could not create auxiliary timer\n");
1379 }
1380
1381 isa_register_portio_list (isadev, s->port, sb16_ioport_list, s, "sb16");
1382
1383 s->isa_hdma = isa_get_dma(isa_bus_from_device(isadev), s->hdma);
1384 k = ISADMA_GET_CLASS(s->isa_hdma);
1385 k->register_channel(s->isa_hdma, s->hdma, SB_read_DMA, s);
1386
1387 s->isa_dma = isa_get_dma(isa_bus_from_device(isadev), s->dma);
1388 k = ISADMA_GET_CLASS(s->isa_dma);
1389 k->register_channel(s->isa_dma, s->dma, SB_read_DMA, s);
1390
1391 s->can_write = 1;
1392
1393 AUD_register_card ("sb16", &s->card);
1394 }
1395
1396 static int SB16_init (ISABus *bus)
1397 {
1398 isa_create_simple (bus, TYPE_SB16);
1399 return 0;
1400 }
1401
1402 static Property sb16_properties[] = {
1403 DEFINE_PROP_UINT32 ("version", SB16State, ver, 0x0405), /* 4.5 */
1404 DEFINE_PROP_UINT32 ("iobase", SB16State, port, 0x220),
1405 DEFINE_PROP_UINT32 ("irq", SB16State, irq, 5),
1406 DEFINE_PROP_UINT32 ("dma", SB16State, dma, 1),
1407 DEFINE_PROP_UINT32 ("dma16", SB16State, hdma, 5),
1408 DEFINE_PROP_END_OF_LIST (),
1409 };
1410
1411 static void sb16_class_initfn (ObjectClass *klass, void *data)
1412 {
1413 DeviceClass *dc = DEVICE_CLASS (klass);
1414
1415 dc->realize = sb16_realizefn;
1416 set_bit(DEVICE_CATEGORY_SOUND, dc->categories);
1417 dc->desc = "Creative Sound Blaster 16";
1418 dc->vmsd = &vmstate_sb16;
1419 dc->props = sb16_properties;
1420 }
1421
1422 static const TypeInfo sb16_info = {
1423 .name = TYPE_SB16,
1424 .parent = TYPE_ISA_DEVICE,
1425 .instance_size = sizeof (SB16State),
1426 .instance_init = sb16_initfn,
1427 .class_init = sb16_class_initfn,
1428 };
1429
1430 static void sb16_register_types (void)
1431 {
1432 type_register_static (&sb16_info);
1433 isa_register_soundhw("sb16", "Creative Sound Blaster 16", SB16_init);
1434 }
1435
1436 type_init (sb16_register_types)
AR7 emulation for QEMU