hw/pcspk.c

   1 /*
   2  * QEMU PC speaker emulation
   3  *
   4  * Copyright (c) 2006 Joachim Henke
   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 "vl.h"
  26
  27 #define PCSPK_BUF_LEN 1792
  28 #define PCSPK_SAMPLE_RATE 32000
  29 #define PCSPK_MAX_FREQ (PCSPK_SAMPLE_RATE >> 1)
  30 #define PCSPK_MIN_COUNT ((PIT_FREQ + PCSPK_MAX_FREQ - 1) / PCSPK_MAX_FREQ)
  31
  32 typedef struct {
  33     uint8_t sample_buf[PCSPK_BUF_LEN];
  34     QEMUSoundCard card;
  35     SWVoiceOut *voice;
  36     PITState *pit;
  37     unsigned int pit_count;
  38     unsigned int samples;
  39     unsigned int play_pos;
  40     int data_on;
  41     int dummy_refresh_clock;
  42 } PCSpkState;
  43
  44 static const char *s_spk = "pcspk";
  45 static PCSpkState pcspk_state;
  46
  47 static inline void generate_samples(PCSpkState *s)
  48 {
  49     unsigned int i;
  50
  51     if (s->pit_count) {
  52         const uint32_t m = PCSPK_SAMPLE_RATE * s->pit_count;
  53         const uint32_t n = ((uint64_t)PIT_FREQ << 32) / m;
  54
  55         /* multiple of wavelength for gapless looping */
  56         s->samples = (PCSPK_BUF_LEN * PIT_FREQ / m * m / (PIT_FREQ >> 1) + 1) >> 1;
  57         for (i = 0; i < s->samples; ++i)
  58             s->sample_buf[i] = (64 & (n * i >> 25)) - 32;
  59     } else {
  60         s->samples = PCSPK_BUF_LEN;
  61         for (i = 0; i < PCSPK_BUF_LEN; ++i)
  62             s->sample_buf[i] = 128; /* silence */
  63     }
  64 }
  65
  66 static void pcspk_callback(void *opaque, int free)
  67 {
  68     PCSpkState *s = opaque;
  69     unsigned int n;
  70
  71     if (pit_get_mode(s->pit, 2) != 3)
  72         return;
  73
  74     n = pit_get_initial_count(s->pit, 2);
  75     /* avoid frequencies that are not reproducible with sample rate */
  76     if (n < PCSPK_MIN_COUNT)
  77         n = 0;
  78
  79     if (s->pit_count != n) {
  80         s->pit_count = n;
  81         s->play_pos = 0;
  82         generate_samples(s);
  83     }
  84
  85     while (free > 0) {
  86         n = audio_MIN(s->samples - s->play_pos, (unsigned int)free);
  87         n = AUD_write(s->voice, &s->sample_buf[s->play_pos], n);
  88         if (!n)
  89             break;
  90         s->play_pos = (s->play_pos + n) % s->samples;
  91         free -= n;
  92     }
  93 }
  94
  95 int pcspk_audio_init(AudioState *audio, qemu_irq *pic)
  96 {
  97     PCSpkState *s = &pcspk_state;
  98     audsettings_t as = {PCSPK_SAMPLE_RATE, 1, AUD_FMT_U8, 0};
  99
 100     if (!audio) {
 101         AUD_log(s_spk, "No audio state\n");
 102         return -1;
 103     }
 104     AUD_register_card(audio, s_spk, &s->card);
 105
 106     s->voice = AUD_open_out(&s->card, s->voice, s_spk, s, pcspk_callback, &as);
 107     if (!s->voice) {
 108         AUD_log(s_spk, "Could not open voice\n");
 109         return -1;
 110     }
 111
 112     return 0;
 113 }
 114
 115 static uint32_t pcspk_ioport_read(void *opaque, uint32_t addr)
 116 {
 117     PCSpkState *s = opaque;
 118     int out;
 119
 120     s->dummy_refresh_clock ^= (1 << 4);
 121     out = pit_get_out(s->pit, 2, qemu_get_clock(vm_clock)) << 5;
 122
 123     return pit_get_gate(s->pit, 2) | (s->data_on << 1) | s->dummy_refresh_clock | out;
 124 }
 125
 126 static void pcspk_ioport_write(void *opaque, uint32_t addr, uint32_t val)
 127 {
 128     PCSpkState *s = opaque;
 129     const int gate = val & 1;
 130
 131     s->data_on = (val >> 1) & 1;
 132     pit_set_gate(s->pit, 2, gate);
 133     if (s->voice) {
 134         if (gate) /* restart */
 135             s->play_pos = 0;
 136         AUD_set_active_out(s->voice, gate & s->data_on);
 137     }
 138 }
 139
 140 void pcspk_init(PITState *pit)
 141 {
 142     PCSpkState *s = &pcspk_state;
 143
 144     s->pit = pit;
 145     register_ioport_read(0x61, 1, 1, pcspk_ioport_read, s);
 146     register_ioport_write(0x61, 1, 1, pcspk_ioport_write, s);
 147 }