Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Apple Sound Chip audio support for 68k Macintoshoes. 

This provies a sound device and support for wsbell(4).

Manual page to be added in a followup commit.

As posted to port-mac68k.
This commit is contained in:
nat 2024-03-13 07:55:28 +00:00
parent 1a2ee0e952
commit 6bfcb10538
7 changed files with 1187 additions and 2 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
sys/arch/mac68k/conf/AUDIO Normal file
View File

@ -0,0 +1,17 @@
# $NetBSD: AUDIO,v 1.1 2024/03/13 07:55:28 nat Exp $
#
# WSFB with audio enabled.
include "arch/mac68k/conf/WSFB"
no asc0 at obio?
# DEFQUALTY 0x0 22257 Monaural playback.
# LOWQUALITY 0x1 Half playback rate.
# HIGHQUALITY 0x2 Best Quality supported by ASC.
ascaudio* at obio? flags 0x0 # ASC/EASC audio
audio* at audiobus?
spkr* at audio? # PC speaker (synthesized)
wsbell* at spkr? # Console beep

17
sys/arch/mac68k/conf/AUDIOSBC Normal file
View File

@ -0,0 +1,17 @@
# $NetBSD: AUDIOSBC,v 1.1 2024/03/13 07:55:28 nat Exp $
#
# WSFB with audio enabled.
include "arch/mac68k/conf/WSFBSBC"
no asc0 at obio?
# DEFQUALTY 0x0 22257 Monaural playback.
# LOWQUALITY 0x1 Half playback rate.
# HIGHQUALITY 0x2 Best Quality supported by ASC.
ascaudio* at obio? flags 0x0 # ASC/EASC audio
audio* at audiobus?
spkr* at audio? # PC speaker (synthesized)
wsbell* at spkr? # Console beep

8
sys/arch/mac68k/conf/files.mac68k
View File

@ -1,4 +1,4 @@
# $NetBSD: files.mac68k,v 1.132 2024/01/09 04:16:25 thorpej Exp $
# $NetBSD: files.mac68k,v 1.133 2024/03/13 07:55:28 nat Exp $
# mac68k-specific configuration info
@ -43,10 +43,16 @@ device ams: wsmousedev
attach ams at adb
file arch/mac68k/dev/ams.c ams needs-flag
# ASC (beeper)
device asc
attach asc at obio
file arch/mac68k/obio/asc.c asc needs-flag
#ASC audio
device ascaudio: audiobus, auconv, mulaw, aurateconv, auvolconv
attach ascaudio at obio
file arch/mac68k/obio/ascaudio.c ascaudio needs-flag
device nubus { }
attach nubus at mainbus
file arch/mac68k/nubus/nubus.c nubus

3
sys/arch/mac68k/conf/majors.mac68k
View File

@ -1,4 +1,4 @@
# $NetBSD: majors.mac68k,v 1.27 2020/04/04 16:06:14 jdolecek Exp $
# $NetBSD: majors.mac68k,v 1.28 2024/03/13 07:55:28 nat Exp $
#
# Device majors for mac68k
#
@ -52,6 +52,7 @@ device-major ksyms char 52 ksyms
device-major wsfont char 53 wsfont
device-major cpi char 54 cpi
device-major sysmon char 55 sysmon
device-major audio char 56 audio
#device-major obsolete char 98 obsolete (nsmb)

970
sys/arch/mac68k/obio/ascaudio.c Normal file
View File

@ -0,0 +1,970 @@
/* $NetBSD: ascaudio.c,v 1.1 2024/03/13 07:55:28 nat Exp $ */
/*-
* Copyright (c) 2017, 2023 Nathanial Sloss <nathanialsloss@yahoo.com.au>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
/* Based on pad(4) and asc(4) */
#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: ascaudio.c,v 1.1 2024/03/13 07:55:28 nat Exp $");
#include <sys/types.h>
#include <sys/param.h>
#include <sys/conf.h>
#include <sys/buf.h>
#include <sys/kauth.h>
#include <sys/kmem.h>
#include <sys/kernel.h>
#include <sys/device.h>
#include <sys/proc.h>
#include <sys/audioio.h>
#include <sys/module.h>
#include <sys/atomic.h>
#include <uvm/uvm_extern.h>
#include <dev/audio/audio_if.h>
#include <dev/audio/audiovar.h>
#include <machine/autoconf.h>
#include <machine/cpu.h>
#include <machine/bus.h>
#include <machine/viareg.h>
#include <mac68k/obio/ascaudiovar.h>
#include <mac68k/obio/ascreg.h>
#include <mac68k/obio/obiovar.h>
#define MAC68K_ASCAUDIO_BASE 0x50f14000
#define MAC68K_IIFX_ASCAUDIO_BASE 0x50f10000
#define MAC68K_ASCAUDIO_LEN 0x1000
#define BUFSIZE 32768
#define PLAYBLKSIZE 8192
#define RECBLKSIZE 8192
static int ascaudiomatch(device_t, cfdata_t, void *);
static void ascaudioattach(device_t, device_t, void *);
CFATTACH_DECL_NEW(ascaudio, sizeof(struct ascaudio_softc),
ascaudiomatch, ascaudioattach, NULL, NULL);
extern struct cfdriver ascaudio_cd;
dev_type_open(ascaudioopen);
dev_type_close(ascaudioclose);
dev_type_read(ascaudioread);
dev_type_write(ascaudiowrite);
dev_type_ioctl(ascaudioioctl);
const struct cdevsw ascaudio_cdevsw = {
.d_open = ascaudioopen,
.d_close = ascaudioclose,
.d_read = ascaudioread,
.d_write = ascaudiowrite,
.d_ioctl = ascaudioioctl,
.d_stop = nostop,
.d_tty = notty,
.d_poll = nopoll,
.d_mmap = nommap,
.d_kqfilter = nokqfilter,
.d_discard = nodiscard,
.d_flag = 0
};
static int ascaudio_query_format(void *, struct audio_format_query *);
static int ascaudio_set_format(void *, int,
const audio_params_t *, const audio_params_t *,
audio_filter_reg_t *, audio_filter_reg_t *);
static int ascaudio_start_output(void *, void *, int,
void (*)(void *), void *);
static int ascaudio_start_input(void *, void *, int,
void (*)(void *), void *);
static int ascaudio_halt(void *);
static int ascaudio_set_port(void *, mixer_ctrl_t *);
static int ascaudio_get_port(void *, mixer_ctrl_t *);
static int ascaudio_getdev(void *, struct audio_device *);
static int ascaudio_query_devinfo(void *, mixer_devinfo_t *);
static int ascaudio_get_props(void *);
static int
ascaudio_round_blocksize(void *, int, int, const audio_params_t *);
static void ascaudio_get_locks(void *, kmutex_t **, kmutex_t **);
static void ascaudio_intr(void *);
static int ascaudio_intr_est(void *);
static void ascaudio_intr_enable(void);
static void ascaudio_done_output(void *);
static void ascaudio_done_input(void *);
static const struct audio_hw_if ascaudio_hw_if = {
.query_format = ascaudio_query_format,
.set_format = ascaudio_set_format,
.start_output = ascaudio_start_output,
.start_input = ascaudio_start_input,
.halt_output = ascaudio_halt,
.halt_input = ascaudio_halt,
.set_port = ascaudio_set_port,
.get_port = ascaudio_get_port,
.getdev = ascaudio_getdev,
.query_devinfo = ascaudio_query_devinfo,
.get_props = ascaudio_get_props,
.round_blocksize = ascaudio_round_blocksize,
.get_locks = ascaudio_get_locks,
};
#define EASC_VER 0xb0
enum {
ASC_OUTPUT_CLASS,
ASC_INPUT_CLASS,
ASC_OUTPUT_MASTER_VOLUME,
ASC_INPUT_DAC_VOLUME,
ASC_ENUM_LAST,
};
static int
ascaudiomatch(device_t parent, cfdata_t cf, void *aux)
{
struct obio_attach_args *oa = (struct obio_attach_args *)aux;
bus_addr_t addr;
bus_space_handle_t bsh;
int rval = 0;
if (oa->oa_addr != (-1))
addr = (bus_addr_t)oa->oa_addr;
else if (current_mac_model->machineid == MACH_MACTV)
return 0;
else if (current_mac_model->machineid == MACH_MACIIFX)
addr = (bus_addr_t)MAC68K_IIFX_ASCAUDIO_BASE;
else
addr = (bus_addr_t)MAC68K_ASCAUDIO_BASE;
if (bus_space_map(oa->oa_tag, addr, MAC68K_ASCAUDIO_LEN, 0, &bsh))
return (0);
if (mac68k_bus_space_probe(oa->oa_tag, bsh, 0, 1)) {
rval = 1;
} else
rval = 0;
bus_space_unmap(oa->oa_tag, bsh, MAC68K_ASCAUDIO_LEN);
return rval;
}
static void
ascaudioattach(device_t parent, device_t self, void *aux)
{
struct ascaudio_softc *sc = device_private(self);
struct obio_attach_args *oa = (struct obio_attach_args *)aux;
bus_addr_t addr;
uint8_t tmp;
sc->sc_dev = self;
sc->sc_tag = oa->oa_tag;
if (oa->oa_addr != (-1))
addr = (bus_addr_t)oa->oa_addr;
else if (current_mac_model->machineid == MACH_MACIIFX)
addr = (bus_addr_t)MAC68K_IIFX_ASCAUDIO_BASE;
else
addr = (bus_addr_t)MAC68K_ASCAUDIO_BASE;
if (bus_space_map(sc->sc_tag, addr, MAC68K_ASCAUDIO_LEN, 0,
&sc->sc_handle)) {
printf(": can't map memory space\n");
return;
}
/* Pull in the options flags. */
sc->sc_options = ((device_cfdata(self)->cf_flags) &
ASCAUDIO_OPTIONS_MASK);
sc->sc_playbuf = kmem_alloc(BUFSIZE, KM_SLEEP);
sc->sc_recbuf = kmem_alloc(BUFSIZE, KM_SLEEP);
sc->sc_rptr = sc->sc_recbuf;
sc->sc_getptr = sc->sc_recbuf;
sc->sc_wptr = sc->sc_playbuf;
sc->sc_putptr = sc->sc_playbuf;
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCMODE, MODESTOP);
sc->sc_ver = bus_space_read_1(oa->oa_tag, sc->sc_handle, 0x800);
if (sc->sc_options & HIGHQUALITY) {
tmp = bus_space_read_1(sc->sc_tag, sc->sc_handle, ASCRATE);
switch (tmp) {
case 2:
sc->sc_rate = 22050;
break;
case 3:
sc->sc_rate = 44100;
break;
default:
sc->sc_rate = 22254;
break;
}
tmp = bus_space_read_1(sc->sc_tag, sc->sc_handle, ASCTRL);
if (tmp & STEREO)
sc->sc_speakers = 2;
else
sc->sc_speakers = 1;
} else {
__USE(tmp);
sc->sc_rate = 22254;
sc->sc_speakers = 1;
}
if (sc->sc_options & LOWQUALITY) {
sc->sc_slowcpu = true;
if (sc->sc_slowcpu)
sc->sc_rate /= 2;
}
if (sc->sc_ver != EASC_VER)
printf(": Apple Sound Chip");
else
printf(": Enhanced Apple Sound Chip");
if (oa->oa_addr != (-1))
printf(" at %x", oa->oa_addr);
printf("\n");
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCMODE, MODESTOP);
if (mac68k_machine.aux_interrupts) {
intr_establish(ascaudio_intr_est, sc, ASCIRQ);
} else {
via2_register_irq(VIA2_ASC, ascaudio_intr, sc);
}
ascaudio_intr_enable();
mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE);
mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_HIGH);
callout_init(&sc->sc_pcallout, CALLOUT_MPSAFE);
callout_setfunc(&sc->sc_pcallout, ascaudio_done_output, sc);
callout_init(&sc->sc_rcallout, CALLOUT_MPSAFE);
callout_setfunc(&sc->sc_rcallout, ascaudio_done_input, sc);
sc->sc_vol = 255;
sc->sc_audiodev = audio_attach_mi(&ascaudio_hw_if, sc, sc->sc_dev);
if (!pmf_device_register(sc->sc_dev, NULL, NULL))
aprint_error_dev(sc->sc_dev,
"couldn't establish power handler\n");
if (sc->sc_ver != EASC_VER)
return;
if (sc->sc_options & HIGHQUALITY)
tmp = CDQUALITY;
else
tmp = MACDEFAULTS;
bus_space_write_1(sc->sc_tag, sc->sc_handle, FIFOCTRLA, tmp);
bus_space_write_1(sc->sc_tag, sc->sc_handle, FIFOCTRLB, tmp);
}
int
ascaudioopen(dev_t dev, int flag, int mode, struct lwp *l)
{
struct ascaudio_softc *sc;
sc = device_lookup_private(&ascaudio_cd, ASCAUDIOUNIT(dev));
if (sc == NULL)
return (ENXIO);
if (sc->sc_open)
return (EBUSY);
sc->sc_open = 1;
return (0);
}
int
ascaudioclose(dev_t dev, int flag, int mode, struct lwp *l)
{
struct ascaudio_softc *sc;
sc = device_lookup_private(&ascaudio_cd, ASCAUDIOUNIT(dev));
sc->sc_open = 0;
return (0);
}
int
ascaudioread(dev_t dev, struct uio *uio, int ioflag)
{
return (ENXIO);
}
int
ascaudiowrite(dev_t dev, struct uio *uio, int ioflag)
{
return (ENXIO);
}
int
ascaudioioctl(dev_t dev, u_long cmd, void *data, int flag, struct lwp *l)
{
int error;
#ifdef notyet
struct ascaudio_softc *sc;
int unit = ASCAUDIOUNIT(dev);
sc = device_lookup_private(&ascaudio_cd, unit);
#endif
error = 0;
switch (cmd) {
default:
error = EINVAL;
break;
}
return (error);
}
#define ASCAUDIO_NFORMATS 2
static int
ascaudio_query_format(void *opaque, struct audio_format_query *ae)
{
struct ascaudio_softc *sc = opaque;
const struct audio_format asc_formats[ASCAUDIO_NFORMATS] = {
{ .mode = AUMODE_PLAY,
.encoding = AUDIO_ENCODING_SLINEAR_LE,
.validbits = 8,
.precision = 8,
.channels = sc->sc_speakers,
.channel_mask = sc->sc_speakers == 2 ? AUFMT_STEREO :
AUFMT_MONAURAL,
.frequency_type = 1,
.frequency = { sc->sc_rate }, },
{ .mode = AUMODE_RECORD,
.encoding = AUDIO_ENCODING_SLINEAR_LE,
.validbits = 8,
.precision = 8,
.channels = 1,
.channel_mask = AUFMT_MONAURAL,
.frequency_type = 1,
.frequency = { 11025 }, }
};
return audio_query_format(asc_formats, ASCAUDIO_NFORMATS, ae);
}
static int
ascaudio_set_format(void *opaque, int setmode,
const audio_params_t *play, const audio_params_t *rec,
audio_filter_reg_t *pfil, audio_filter_reg_t *rfil)
{
struct ascaudio_softc *sc = opaque;
KASSERT(mutex_owned(&sc->sc_lock));
return 0;
}
static int
ascaudio_start_output(void *opaque, void *block, int blksize,
void (*intr)(void *), void *intrarg)
{
struct ascaudio_softc *sc;
uint8_t *loc, tmp;
int total;
sc = (struct ascaudio_softc *)opaque;
if (!sc)
return (ENODEV);
sc->sc_pintr = intr;
sc->sc_pintrarg = intrarg;
loc = block;
if (bus_space_read_1(sc->sc_tag, sc->sc_handle, ASCMODE) !=
MODEFIFO) {
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCMODE, MODESTOP);
if (sc->sc_ver == EASC_VER) {
/* disable half interrupts channel a */
bus_space_write_1(sc->sc_tag, sc->sc_handle, IRQA,
DISABLEHALFIRQ);
/* Disable half interrupts channel b */
bus_space_write_1(sc->sc_tag, sc->sc_handle, IRQB,
DISABLEHALFIRQ);
}
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCTEST, 0);
bus_space_write_1(sc->sc_tag, sc->sc_handle, FIFOPARAM,
CLEARFIFO);
tmp = 0;
bus_space_write_1(sc->sc_tag, sc->sc_handle, APLAYREC, tmp);
if (sc->sc_ver == EASC_VER) {
/* enable interrupts channel b */
bus_space_write_1(sc->sc_tag, sc->sc_handle, IRQB, 0);
}
}
/* set the volume */
tmp = sc->sc_vol >> 5;
/* set volume for channel b left and right speakers */
if (sc->sc_ver == EASC_VER) {
bus_space_write_1(sc->sc_tag, sc->sc_handle, A_LEFT_VOL, tmp);
bus_space_write_1(sc->sc_tag, sc->sc_handle, B_LEFT_VOL, tmp);
bus_space_write_1(sc->sc_tag, sc->sc_handle, A_RIGHT_VOL, tmp);
bus_space_write_1(sc->sc_tag, sc->sc_handle, B_RIGHT_VOL, tmp);
} else
bus_space_write_1(sc->sc_tag, sc->sc_handle, INTVOL, tmp << 5);
total = blksize;
if (sc->sc_putptr + blksize > sc->sc_playbuf + BUFSIZE)
total = sc->sc_playbuf + BUFSIZE - sc->sc_putptr;
memcpy(sc->sc_putptr, loc, total);
sc->sc_putptr += total;
loc += total;
total = blksize - total;
if (total) {
sc->sc_putptr = sc->sc_playbuf;
memcpy(sc->sc_playbuf, loc, total);
sc->sc_putptr += total;
}
sc->sc_avail += blksize;
if (sc->sc_avail > BUFSIZE)
sc->sc_avail = BUFSIZE;
/* start fifo playback */
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCMODE, MODEFIFO);
return 0;
}
static int
ascaudio_start_input(void *opaque, void *block, int blksize,
void (*intr)(void *), void *intrarg)
{
struct ascaudio_softc *sc;
uint8_t tmp;
int total;
sc = (struct ascaudio_softc *)opaque;
if (!sc)
return (ENODEV);
uint8_t *loc;
loc = block;
sc->sc_rintr = intr;
sc->sc_rintrarg = intrarg;
if (bus_space_read_1(sc->sc_tag, sc->sc_handle, ASCMODE) !=
MODEFIFO) {
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCMODE, MODESTOP);
if (sc->sc_ver == EASC_VER) {
/* disable half interrupts channel a */
bus_space_write_1(sc->sc_tag, sc->sc_handle, IRQA,
DISABLEHALFIRQ);
/* Disable half interrupts channel b */
bus_space_write_1(sc->sc_tag, sc->sc_handle, IRQB,
DISABLEHALFIRQ);
}
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCTEST, 0);
bus_space_write_1(sc->sc_tag, sc->sc_handle, FIFOPARAM,
CLEARFIFO);
tmp = RECORDA;
bus_space_write_1(sc->sc_tag, sc->sc_handle, APLAYREC, tmp);
bus_space_write_1(sc->sc_tag, sc->sc_handle, INTVOL, 0xa0);
if (sc->sc_ver == EASC_VER) {
/* enable interrupts channel a */
bus_space_write_1(sc->sc_tag, sc->sc_handle, IRQA, 0);
}
/* start fifo playback */
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCMODE, MODEFIFO);
return 0;
}
/* set the volume */
tmp = sc->sc_vol >> 5;
/* set volume for channel b left and right speakers */
if (sc->sc_ver == EASC_VER) {
bus_space_write_1(sc->sc_tag, sc->sc_handle, A_LEFT_VOL, tmp);
bus_space_write_1(sc->sc_tag, sc->sc_handle, B_LEFT_VOL, tmp);
bus_space_write_1(sc->sc_tag, sc->sc_handle, A_RIGHT_VOL, tmp);
bus_space_write_1(sc->sc_tag, sc->sc_handle, B_RIGHT_VOL, tmp);
} else
bus_space_write_1(sc->sc_tag, sc->sc_handle, INTVOL, tmp << 5);
total = blksize;
if (sc->sc_getptr + blksize > sc->sc_recbuf + BUFSIZE)
total = sc->sc_recbuf + BUFSIZE - sc->sc_getptr;
memcpy(loc, sc->sc_getptr, total);
sc->sc_getptr += total;
loc += total;
if (sc->sc_getptr >= sc->sc_recbuf + BUFSIZE)
sc->sc_getptr = sc->sc_recbuf;
total = blksize - total;
if (total) {
memcpy(loc, sc->sc_getptr, total);
sc->sc_getptr += total;
}
sc->sc_recavail -= blksize;
return 0;
}
static int
ascaudio_halt(void *opaque)
{
ascaudio_softc_t *sc;
sc = (ascaudio_softc_t *)opaque;
KASSERT(mutex_owned(&sc->sc_lock));
sc->sc_pintr = NULL;
sc->sc_pintrarg = NULL;
sc->sc_rintr = NULL;
sc->sc_rintrarg = NULL;
sc->sc_avail = 0;
sc->sc_recavail = 0;
callout_halt(&sc->sc_pcallout, &sc->sc_lock);
callout_halt(&sc->sc_rcallout, &sc->sc_lock);
bus_space_write_1(sc->sc_tag, sc->sc_handle, ASCMODE, MODESTOP);
bus_space_write_1(sc->sc_tag, sc->sc_handle, FIFOPARAM, CLEARFIFO);
sc->sc_rptr = sc->sc_recbuf;
sc->sc_getptr = sc->sc_recbuf;
sc->sc_wptr = sc->sc_playbuf;
sc->sc_putptr = sc->sc_playbuf;
if (sc->sc_ver != EASC_VER)
return 0;
/* disable half interrupts channel a */
bus_space_write_1(sc->sc_tag, sc->sc_handle, IRQA, DISABLEHALFIRQ);
/* disable half interrupts channel b */
bus_space_write_1(sc->sc_tag, sc->sc_handle, IRQB, DISABLEHALFIRQ);
return 0;
}
static int
ascaudio_getdev(void *opaque, struct audio_device *ret)
{
strlcpy(ret->name, "Apple ASC Audio", sizeof(ret->name));
strlcpy(ret->version, osrelease, sizeof(ret->version));
strlcpy(ret->config, "ascaudio", sizeof(ret->config));
return 0;
}
static int
ascaudio_set_port(void *opaque, mixer_ctrl_t *mc)
{
struct ascaudio_softc *sc = opaque;
KASSERT(mutex_owned(&sc->sc_lock));
switch (mc->dev) {
case ASC_OUTPUT_MASTER_VOLUME:
case ASC_INPUT_DAC_VOLUME:
if (mc->un.value.num_channels != 1)
return EINVAL;
sc->sc_vol = mc->un.value.level[AUDIO_MIXER_LEVEL_MONO];
return 0;
}
return ENXIO;
}
static int
ascaudio_get_port(void *opaque, mixer_ctrl_t *mc)
{
struct ascaudio_softc *sc = opaque;
KASSERT(mutex_owned(&sc->sc_lock));
switch (mc->dev) {
case ASC_OUTPUT_MASTER_VOLUME:
case ASC_INPUT_DAC_VOLUME:
if (mc->un.value.num_channels != 1)
return EINVAL;
mc->un.value.level[AUDIO_MIXER_LEVEL_MONO] = sc->sc_vol;
return 0;
}
return ENXIO;
}
static int
ascaudio_query_devinfo(void *opaque, mixer_devinfo_t *di)
{
ascaudio_softc_t *sc __diagused;
sc = (ascaudio_softc_t *)opaque;
KASSERT(mutex_owned(&sc->sc_lock));
switch (di->index) {
case ASC_OUTPUT_CLASS:
di->mixer_class = ASC_OUTPUT_CLASS;
strcpy(di->label.name, AudioCoutputs);
di->type = AUDIO_MIXER_CLASS;
di->next = di->prev = AUDIO_MIXER_LAST;
return 0;
case ASC_INPUT_CLASS:
di->mixer_class = ASC_INPUT_CLASS;
strcpy(di->label.name, AudioCinputs);
di->type = AUDIO_MIXER_CLASS;
di->next = di->prev = AUDIO_MIXER_LAST;
return 0;
case ASC_OUTPUT_MASTER_VOLUME:
di->mixer_class = ASC_OUTPUT_CLASS;
strcpy(di->label.name, AudioNmaster);
di->type = AUDIO_MIXER_VALUE;
di->next = di->prev = AUDIO_MIXER_LAST;
di->un.v.num_channels = 1;
strcpy(di->un.v.units.name, AudioNvolume);
return 0;
case ASC_INPUT_DAC_VOLUME:
di->mixer_class = ASC_INPUT_CLASS;
strcpy(di->label.name, AudioNdac);
di->type = AUDIO_MIXER_VALUE;
di->next = di->prev = AUDIO_MIXER_LAST;
di->un.v.num_channels = 1;
strcpy(di->un.v.units.name, AudioNvolume);
return 0;
}
return ENXIO;
}
static int
ascaudio_get_props(void *opaque)
{
return AUDIO_PROP_PLAYBACK | AUDIO_PROP_CAPTURE |
AUDIO_PROP_INDEPENDENT;
}
static int
ascaudio_round_blocksize(void *opaque, int blksize, int mode,
const audio_params_t *p)
{
ascaudio_softc_t *sc __diagused;
sc = (ascaudio_softc_t *)opaque;
KASSERT(mutex_owned(&sc->sc_lock));
if (mode == AUMODE_PLAY)
return PLAYBLKSIZE;
else
return RECBLKSIZE;
}
static void
ascaudio_get_locks(void *opaque, kmutex_t **intr, kmutex_t **thread)
{
ascaudio_softc_t *sc;
sc = (ascaudio_softc_t *)opaque;
*intr = &sc->sc_intr_lock;
*thread = &sc->sc_lock;
}
static int
ascaudio_intr_est(void *arg)
{
ascaudio_intr(arg);
return 0;
}
static void
ascaudio_intr(void *arg)
{
struct ascaudio_softc *sc = arg;
uint8_t status, val;
bool again;
int total, count, i;
if (!sc)
return;
if (!sc->sc_pintr && !sc->sc_rintr)
return;
mutex_enter(&sc->sc_intr_lock);
do {
status = bus_space_read_1(sc->sc_tag, sc->sc_handle,
FIFOSTATUS);
again = false;
count = 0;
if ((status & A_HALF) == 0)
count = 0x200;
if (count && ((status & A_FULL) == 0))
count = 0x400;
if (sc->sc_rintr && count) {
total = count;
if (sc->sc_rptr + count > sc->sc_recbuf + BUFSIZE)
count = sc->sc_recbuf + BUFSIZE - sc->sc_rptr;
while (total) {
for (i = 0; i < count; i++) {
val = bus_space_read_1(sc->sc_tag,
sc->sc_handle, FIFO_A);
val ^= 0x80;
*sc->sc_rptr++ = val;
}
if (sc->sc_rptr >= sc->sc_recbuf + BUFSIZE)
sc->sc_rptr = sc->sc_recbuf;
total -= count;
sc->sc_recavail += count;
}
if (sc->sc_recavail > BUFSIZE)
sc->sc_recavail = BUFSIZE;
}
count = 0;
if (status & B_FULL)
count = 0x400;
else if (status & B_HALF)
count = 0x200;
if (sc->sc_slowcpu)
count /= 2;
if (sc->sc_pintr && count) {
if (sc->sc_avail < count) {
if (sc->sc_pintr) {
for (i = 0; i < 0x200; i++) {
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_A,
0x80);
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_B,
0x80);
}
} else {
for (i = 0; i < 0x200; i++) {
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_B,
0x80);
}
}
} else if (sc->sc_slowcpu) {
for (i = 0; i < count; i++) {
val = *sc->sc_wptr++;
val ^= 0x80;
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_A, val);
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_B, val);
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_A, val);
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_B, val);
}
sc->sc_avail -= count;
again = true;
} else {
for (i = 0; i < count; i++) {
val = *sc->sc_wptr++;
val ^= 0x80;
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_A, val);
bus_space_write_1(sc->sc_tag,
sc->sc_handle, FIFO_B, val);
}
sc->sc_avail -= count;
again = true;
}
if (sc->sc_wptr >= sc->sc_playbuf + BUFSIZE)
sc->sc_wptr = sc->sc_playbuf;
}
if (sc->sc_pintr && (sc->sc_avail <= PLAYBLKSIZE))
callout_schedule(&sc->sc_pcallout, 0);
if (sc->sc_rintr && (sc->sc_recavail >= RECBLKSIZE))
callout_schedule(&sc->sc_rcallout, 0);
} while (again);
mutex_exit(&sc->sc_intr_lock);
}
static void
ascaudio_intr_enable(void)
{
int s;
s = splhigh();
if (VIA2 == VIA2OFF)
via2_reg(vIER) = 0x80 | V2IF_ASC;
else
via2_reg(rIER) = 0x80 | V2IF_ASC;
splx(s);
}
static void
ascaudio_done_output(void *arg)
{
struct ascaudio_softc *sc = arg;
mutex_enter(&sc->sc_intr_lock);
if (sc->sc_pintr)
(*sc->sc_pintr)(sc->sc_pintrarg);
mutex_exit(&sc->sc_intr_lock);
}
static void
ascaudio_done_input(void *arg)
{
struct ascaudio_softc *sc = arg;
mutex_enter(&sc->sc_intr_lock);
if (sc->sc_rintr)
(*sc->sc_rintr)(sc->sc_rintrarg);
mutex_exit(&sc->sc_intr_lock);
}
#ifdef _MODULE
MODULE(MODULE_CLASS_DRIVER, ascaudio, "audio");
static const struct cfiattrdata audiobuscf_iattrdata = {
"audiobus", 0, { { NULL, NULL, 0 }, }
};
static const struct cfiattrdata * const ascaudio_attrs[] = {
&audiobuscf_iattrdata, NULL
};
CFDRIVER_DECL(ascaudio, DV_DULL, ascaud_attrs);
extern struct cfattach ascaudio_ca;
static int ascaudioloc[] = { -1, -1 };
static struct cfdata ascaudio_cfdata[] = {
{
.cf_name = "ascaudio",
.cf_atname = "ascaudio",
.cf_unit = 0,
.cf_fstate = FSTATE_STAR,
.cf_loc = ascaudioloc,
.cf_flags = 0,
.cf_pspec = NULL,
},
{ NULL, NULL, 0, 0, NULL, 0, NULL }
};
static int
ascaudio_modcmd(modcmd_t cmd, void *arg)
{
devmajor_t cmajor = NODEVMAJOR, bmajor = NODEVMAJOR;
int error;
switch (cmd) {
case MODULE_CMD_INIT:
error = config_cfdriver_attach(&ascaudio_cd);
if (error) {
return error;
}
error = config_cfattach_attach(ascaudio_cd.cd_name, &ascaud_ca);
if (error) {
config_cfdriver_detach(&ascaudio_cd);
aprint_error("%s: unable to register cfattach\n",
ascaudio_cd.cd_name);
return error;
}
error = config_cfdata_attach(ascaudio_cfdata, 1);
if (error) {
config_cfattach_detach(ascaudio_cd.cd_name, &ascaud_ca);
config_cfdriver_detach(&ascaudio_cd);
aprint_error("%s: unable to register cfdata\n",
ascaudio_cd.cd_name);
return error;
}
error = devsw_attach(ascaudio_cd.cd_name, NULL, &bmajor,
&ascaudio_cdevsw, &cmajor);
if (error) {
error = config_cfdata_detach(ascaudio_cfdata);
if (error) {
return error;
}
config_cfattach_detach(ascaudio_cd.cd_name, &ascaud_ca);
config_cfdriver_detach(&ascaudio_cd);
aprint_error("%s: unable to register devsw\n",
ascaudio_cd.cd_name);
return error;
}
(void)config_attach_pseudo(ascaudio_cfdata);
return 0;
case MODULE_CMD_FINI:
error = config_cfdata_detach(ascaudio_cfdata);
if (error) {
return error;
}
config_cfattach_detach(ascaudio_cd.cd_name, &ascaud_ca);
config_cfdriver_detach(&ascaudio_cd);
devsw_detach(NULL, &ascaudio_cdevsw);
return 0;
default:
return ENOTTY;
}
}
#endif

77
sys/arch/mac68k/obio/ascaudiovar.h Normal file
View File

@ -0,0 +1,77 @@
/* $NetBSD: ascaudiovar.h,v 1.1 2024/03/13 07:55:28 nat Exp $ */
/*-
* Copyright (c) 2017, 2023 Nathanial Sloss <nathanialsloss@yahoo.com.au>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _SYS_ARCH_MAC68K_OBIO_ASCAUDIOVAR_H
#define _SYS_ARCH_MAC68K_OBIO_ASCAUDIOVAR_H
#define ASCAUDIOUNIT(d) ((d) & 0x7)
typedef struct ascaudio_softc {
device_t sc_dev;
bus_space_tag_t sc_tag;
bus_space_handle_t sc_handle;
int sc_open;
device_t sc_audiodev;
struct audio_encoding_set *sc_encodings;
void *sc_intr;
void (*sc_pintr)(void *);
void *sc_pintrarg;
void (*sc_rintr)(void *);
void *sc_rintrarg;
kmutex_t sc_lock;
kmutex_t sc_intr_lock;
callout_t sc_pcallout;
callout_t sc_rcallout;
uint8_t *sc_playbuf;
uint8_t *sc_wptr;
uint8_t *sc_putptr;
int sc_avail;
uint8_t *sc_recbuf;
uint8_t *sc_rptr;
uint8_t *sc_getptr;
int sc_recavail;
uint8_t sc_vol;
uint8_t sc_ver;
int sc_options; /* options for this instance. */
uint8_t sc_speakers;
uint sc_rate;
bool sc_slowcpu;
} ascaudio_softc_t;
#define LOWQUALITY 0x1
#define HIGHQUALITY 0x2
#define ASCAUDIO_OPTIONS_MASK (LOWQUALITY|HIGHQUALITY)
#define ASCAUDIO_OPTIONS_BITS "\10\2HIGHQUALITY\1LOWQUALITY"
#endif /* !_SYS_ARCH_MAC68K_OBIO_ASCAUDIOVAR_H */

97
sys/arch/mac68k/obio/ascreg.h Normal file
View File

@ -0,0 +1,97 @@
/* $NetBSD: ascreg.h,v 1.1 2024/03/13 07:55:28 nat Exp $ */
/*-
* Copyright (c) 2017, 2023 Nathanial Sloss <nathanialsloss@yahoo.com.au>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef _SYS_ARCH_MAC68K_OBIO_ASCREG_H
#define _SYS_ARCH_MAC68K_OBIO_ASCREG_H
#define ASCIRQ 5
#define FIFO_A 0
#define FIFO_B 0x400
#define FIFO_LEN 0x400
#define VERLOC 0x800
#define ASCMODE 0x801
#define MODESTOP 0
#define MODEFIFO 1
#define MODEWAVE 2 /* not in easc */
#define ASCTRL 0x802
#define UNDERRUN __BIT(7)
#define STEREO __BIT(1)
#define ANAPWM __BIT(0)
#define FIFOPARAM 0x803
#define CLEARFIFO __BIT(7)
#define NONCOMP __BIT(1)
#define ROMCOMP __BIT(0)
#define FIFOSTATUS 0x804
#define A_HALF __BIT(0)
#define A_FULL __BIT(1)
#define B_HALF __BIT(2)
#define B_FULL __BIT(3)
#define INTVOL 0x806 /* b2-b4 Int volume. b5-b7 ext. */
#define ASCRATE 0x807
#define MACFREQ 0 /* 22254 Hz */
#define F22KHZ 2 /* 22050 Hz */
#define F44KHZ 3 /* 44100 Hz */
#define APLAYREC 0x80a
#define RECORDA __BIT(0)
#define REC22KHZ __BIT(1)
#define ASCTEST 0x80f
#define A_WRITEPTRHI 0xf00
#define A_WRITEPTRLO 0xf01
#define A_READPTRHI 0xf02
#define A_READPTRLO 0xf03
#define B_WRITEPTRHI 0xf20
#define B_WRITEPTRLO 0xf21
#define B_READPTRHI 0xf22
#define B_READPTRLO 0xf23
#define A_LEFT_VOL 0xf06
#define A_RIGHT_VOL 0xf07
#define B_LEFT_VOL 0xf26
#define B_RIGHT_VOL 0xf27
#define FIFOCTRLA 0xf08
#define FIFOCTRLB 0xf28
#define CDQUALITY 0x81
#define MACDEFAULTS 0x80
#define IRQA 0xf09
#define IRQB 0xf29
#define DISABLEHALFIRQ __BIT(0)
#endif /* !_SYS_ARCH_MAC68K_OBIO_ASCREG_H */