/* * QEMU PC speaker emulation * * Copyright (c) 2006 Joachim Henke * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated documentation files (the "Software"), to deal * in the Software without restriction, including without limitation the rights * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell * copies of the Software, and to permit persons to whom the Software is * furnished to do so, subject to the following conditions: * * The above copyright notice and this permission notice shall be included in * all copies or substantial portions of the Software. * * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN * THE SOFTWARE. */ #include "qemu/osdep.h" #include "hw/isa/isa.h" #include "hw/audio/soundhw.h" #include "audio/audio.h" #include "qemu/module.h" #include "qemu/timer.h" #include "hw/timer/i8254.h" #include "migration/vmstate.h" #include "hw/audio/pcspk.h" #include "qapi/error.h" #define PCSPK_BUF_LEN 1792 #define PCSPK_SAMPLE_RATE 32000 #define PCSPK_MAX_FREQ (PCSPK_SAMPLE_RATE >> 1) #define PCSPK_MIN_COUNT DIV_ROUND_UP(PIT_FREQ, PCSPK_MAX_FREQ) #define PC_SPEAKER(obj) OBJECT_CHECK(PCSpkState, (obj), TYPE_PC_SPEAKER) typedef struct { ISADevice parent_obj; MemoryRegion ioport; uint32_t iobase; uint8_t sample_buf[PCSPK_BUF_LEN]; QEMUSoundCard card; SWVoiceOut *voice; void *pit; unsigned int pit_count; unsigned int samples; unsigned int play_pos; uint8_t data_on; uint8_t dummy_refresh_clock; bool migrate; } PCSpkState; static const char *s_spk = "pcspk"; static PCSpkState *pcspk_state; static inline void generate_samples(PCSpkState *s) { unsigned int i; if (s->pit_count) { const uint32_t m = PCSPK_SAMPLE_RATE * s->pit_count; const uint32_t n = ((uint64_t)PIT_FREQ << 32) / m; /* multiple of wavelength for gapless looping */ s->samples = (QEMU_ALIGN_DOWN(PCSPK_BUF_LEN * PIT_FREQ, m) / (PIT_FREQ >> 1) + 1) >> 1; for (i = 0; i < s->samples; ++i) s->sample_buf[i] = (64 & (n * i >> 25)) - 32; } else { s->samples = PCSPK_BUF_LEN; for (i = 0; i < PCSPK_BUF_LEN; ++i) s->sample_buf[i] = 128; /* silence */ } } static void pcspk_callback(void *opaque, int free) { PCSpkState *s = opaque; PITChannelInfo ch; unsigned int n; pit_get_channel_info(s->pit, 2, &ch); if (ch.mode != 3) { return; } n = ch.initial_count; /* avoid frequencies that are not reproducible with sample rate */ if (n < PCSPK_MIN_COUNT) n = 0; if (s->pit_count != n) { s->pit_count = n; s->play_pos = 0; generate_samples(s); } while (free > 0) { n = audio_MIN(s->samples - s->play_pos, (unsigned int)free); n = AUD_write(s->voice, &s->sample_buf[s->play_pos], n); if (!n) break; s->play_pos = (s->play_pos + n) % s->samples; free -= n; } } static int pcspk_audio_init(ISABus *bus) { PCSpkState *s = pcspk_state; struct audsettings as = {PCSPK_SAMPLE_RATE, 1, AUDIO_FORMAT_U8, 0}; AUD_register_card(s_spk, &s->card); s->voice = AUD_open_out(&s->card, s->voice, s_spk, s, pcspk_callback, &as); if (!s->voice) { AUD_log(s_spk, "Could not open voice\n"); return -1; } return 0; } static uint64_t pcspk_io_read(void *opaque, hwaddr addr, unsigned size) { PCSpkState *s = opaque; PITChannelInfo ch; pit_get_channel_info(s->pit, 2, &ch); s->dummy_refresh_clock ^= (1 << 4); return ch.gate | (s->data_on << 1) | s->dummy_refresh_clock | (ch.out << 5); } static void pcspk_io_write(void *opaque, hwaddr addr, uint64_t val, unsigned size) { PCSpkState *s = opaque; const int gate = val & 1; s->data_on = (val >> 1) & 1; pit_set_gate(s->pit, 2, gate); if (s->voice) { if (gate) /* restart */ s->play_pos = 0; AUD_set_active_out(s->voice, gate & s->data_on); } } static const MemoryRegionOps pcspk_io_ops = { .read = pcspk_io_read, .write = pcspk_io_write, .impl = { .min_access_size = 1, .max_access_size = 1, }, }; static void pcspk_initfn(Object *obj) { PCSpkState *s = PC_SPEAKER(obj); memory_region_init_io(&s->ioport, OBJECT(s), &pcspk_io_ops, s, "pcspk", 1); object_property_add_link(obj, "pit", TYPE_PIT_COMMON, (Object **)&s->pit, qdev_prop_allow_set_link_before_realize, 0, &error_abort); } static void pcspk_realizefn(DeviceState *dev, Error **errp) { ISADevice *isadev = ISA_DEVICE(dev); PCSpkState *s = PC_SPEAKER(dev); isa_register_ioport(isadev, &s->ioport, s->iobase); pcspk_state = s; } static bool migrate_needed(void *opaque) { PCSpkState *s = opaque; return s->migrate; } static const VMStateDescription vmstate_spk = { .name = "pcspk", .version_id = 1, .minimum_version_id = 1, .minimum_version_id_old = 1, .needed = migrate_needed, .fields = (VMStateField[]) { VMSTATE_UINT8(data_on, PCSpkState), VMSTATE_UINT8(dummy_refresh_clock, PCSpkState), VMSTATE_END_OF_LIST() } }; static Property pcspk_properties[] = { DEFINE_PROP_UINT32("iobase", PCSpkState, iobase, -1), DEFINE_PROP_BOOL("migrate", PCSpkState, migrate, true), DEFINE_PROP_END_OF_LIST(), }; static void pcspk_class_initfn(ObjectClass *klass, void *data) { DeviceClass *dc = DEVICE_CLASS(klass); dc->realize = pcspk_realizefn; set_bit(DEVICE_CATEGORY_SOUND, dc->categories); dc->vmsd = &vmstate_spk; dc->props = pcspk_properties; /* Reason: realize sets global pcspk_state */ /* Reason: pit object link */ dc->user_creatable = false; } static const TypeInfo pcspk_info = { .name = TYPE_PC_SPEAKER, .parent = TYPE_ISA_DEVICE, .instance_size = sizeof(PCSpkState), .instance_init = pcspk_initfn, .class_init = pcspk_class_initfn, }; static void pcspk_register(void) { type_register_static(&pcspk_info); isa_register_soundhw("pcspk", "PC speaker", pcspk_audio_init); } type_init(pcspk_register)