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