/* $NetBSD: psgpam.c,v 1.2 2022/06/11 14:45:37 tsutsui Exp $ */ /* * Copyright (c) 2018 Yosuke Sugahara. 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 AUTHOR ``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 AUTHOR 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. */ #include __KERNEL_RCSID(0, "$NetBSD: psgpam.c,v 1.2 2022/06/11 14:45:37 tsutsui Exp $"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ioconf.h" /* * Debug level: * 0: No debug logs * 1: action changes like open/close/set_format... * 2: + normal operations like read/write/ioctl... * 3: + TRACEs except interrupt * 4: + TRACEs including interrupt */ /* Note AUDIO_DEBUG should be sync'ed with src/sys/dev/audio/audio.c */ /* #define AUDIO_DEBUG 1 */ #if defined(AUDIO_DEBUG) #define DPRINTF(n, fmt...) do { \ if (psgpamdebug >= (n)) { \ if (cpu_intr_p()) { \ audio_mlog_printf(fmt); \ } else { \ audio_mlog_flush(); \ printf(fmt); \ } \ } \ } while (0) /* XXX Parasitic to audio.c... */ extern void audio_mlog_flush(void); extern void audio_mlog_printf(const char *, ...); static int psgpamdebug = AUDIO_DEBUG; #else #define DPRINTF(n, fmt...) __nothing #endif struct psgpam_softc { device_t sc_dev; vaddr_t sc_shm_base; vsize_t sc_shm_size; void (*sc_intr)(void *); void *sc_arg; kmutex_t sc_intr_lock; kmutex_t sc_thread_lock; int sc_isopen; int sc_started; int sc_outcount; int sc_xp_state; uint16_t sc_xp_addr; /* XP buffer addr */ int sc_xp_enc; int sc_xp_rept; int sc_xp_cycle_clk; int sc_xp_rept_clk; int sc_xp_rept_max; u_int sc_sample_rate; int sc_stride; int sc_dynamic; uint8_t *sc_start_ptr; uint8_t *sc_end_ptr; int sc_blksize; int sc_blkcount; int sc_cur_blk_id; struct psgpam_codecvar sc_psgpam_codecvar; }; static int psgpam_match(device_t, cfdata_t, void *); static void psgpam_attach(device_t, device_t, void *); /* MI audio layer interface */ static int psgpam_open(void *, int); static void psgpam_close(void *); static int psgpam_query_format(void *, audio_format_query_t *); static int psgpam_set_format(void *, int, const audio_params_t *, const audio_params_t *, audio_filter_reg_t *, audio_filter_reg_t *); static int psgpam_trigger_output(void *, void *, void *, int, void (*)(void *), void *, const audio_params_t *); static int psgpam_halt_output(void *); static int psgpam_getdev(void *, struct audio_device *); static int psgpam_set_port(void *, mixer_ctrl_t *); static int psgpam_get_port(void *, mixer_ctrl_t *); static int psgpam_query_devinfo(void *, mixer_devinfo_t *); static int psgpam_get_props(void *); static void psgpam_get_locks(void *, kmutex_t **, kmutex_t **); static int psgpam_round_blocksize(void *, int, int, const audio_params_t *); static size_t psgpam_round_buffersize(void *, int, size_t); static int psgpam_intr(void *); #if defined(AUDIO_DEBUG) static int psgpam_sysctl_debug(SYSCTLFN_PROTO); #endif static int psgpam_sysctl_enc(SYSCTLFN_PROTO); static int psgpam_sysctl_dynamic(SYSCTLFN_PROTO); CFATTACH_DECL_NEW(psgpam, sizeof(struct psgpam_softc), psgpam_match, psgpam_attach, NULL, NULL); static int psgpam_matched; static const struct audio_hw_if psgpam_hw_if = { .open = psgpam_open, .close = psgpam_close, .query_format = psgpam_query_format, .set_format = psgpam_set_format, .trigger_output = psgpam_trigger_output, .halt_output = psgpam_halt_output, .getdev = psgpam_getdev, .set_port = psgpam_set_port, .get_port = psgpam_get_port, .query_devinfo = psgpam_query_devinfo, .get_props = psgpam_get_props, .get_locks = psgpam_get_locks, .round_blocksize = psgpam_round_blocksize, .round_buffersize = psgpam_round_buffersize, }; static struct audio_device psgpam_device = { "PSG PAM", "0.2", "", }; static struct audio_format psgpam_format = { .mode = AUMODE_PLAY, .encoding = AUDIO_ENCODING_NONE, .validbits = 0, /* filled by query_format */ .precision = 0, /* filled by query_format */ .channels = 1, .channel_mask = AUFMT_MONAURAL, .frequency_type = 0, /* filled by query_format */ .frequency = { 0 }, /* filled by query_format */ }; static int psgpam_match(device_t parent, cfdata_t cf, void *aux) { struct xpbus_attach_args *xa = aux; if (psgpam_matched) return 0; /* Only the first generation LUNA has YM2149 at XP */ if (machtype != LUNA_I) return 0; if (strcmp(xa->xa_name, psgpam_cd.cd_name)) return 0; psgpam_matched = 1; return 1; } static void psgpam_attach(device_t parent, device_t self, void *aux) { struct psgpam_softc *sc; const struct sysctlnode *node; sc = device_private(self); sc->sc_dev = self; aprint_normal(": HD647180X I/O processor as PSG PAM\n"); sc->sc_shm_base = XP_SHM_BASE; sc->sc_shm_size = XP_SHM_SIZE; sc->sc_xp_enc = PAM_ENC_PAM2A; sc->sc_sample_rate = 8000; sc->sc_stride = 2; sc->sc_dynamic = 1; mutex_init(&sc->sc_thread_lock, MUTEX_DEFAULT, IPL_NONE); mutex_init(&sc->sc_intr_lock, MUTEX_DEFAULT, IPL_SCHED); isrlink_autovec(psgpam_intr, sc, 5, ISRPRI_TTYNOBUF); sysctl_createv(NULL, 0, NULL, &node, 0, CTLTYPE_NODE, device_xname(sc->sc_dev), SYSCTL_DESCR("psgpam"), NULL, 0, NULL, 0, CTL_HW, CTL_CREATE, CTL_EOL); if (node != NULL) { #if defined(AUDIO_DEBUG) sysctl_createv(NULL, 0, NULL, NULL, CTLFLAG_READWRITE, CTLTYPE_INT, "debug", SYSCTL_DESCR("PSGPAM debug"), psgpam_sysctl_debug, 0, (void *)sc, 0, CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL); #endif sysctl_createv(NULL, 0, NULL, NULL, CTLFLAG_READWRITE, CTLTYPE_INT, "enc", SYSCTL_DESCR("PSGPAM encoding"), psgpam_sysctl_enc, 0, (void *)sc, 0, CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL); sysctl_createv(NULL, 0, NULL, NULL, CTLFLAG_READWRITE, CTLTYPE_INT, "dynamic", SYSCTL_DESCR("PSGPAM dynamic offset"), psgpam_sysctl_dynamic, 0, (void *)sc, 0, CTL_HW, node->sysctl_num, CTL_CREATE, CTL_EOL); } audio_attach_mi(&psgpam_hw_if, sc, sc->sc_dev); } /* private functions */ static void psgpam_xp_query(struct psgpam_softc *sc) { u_int a; int r; if (!sc->sc_isopen) { a = xp_acquire(DEVID_PAM, 0); if (a == 0) { sc->sc_xp_cycle_clk = 65535; sc->sc_xp_rept_clk = 255; sc->sc_xp_rept_max = 0; DPRINTF(1, "XPLX BUSY!\n"); return; } xp_ensure_firmware(); } xp_writemem8(PAM_ENC, sc->sc_xp_enc); r = xp_cmd(DEVID_PAM, PAM_CMD_QUERY); if (r != XPLX_R_OK) { sc->sc_xp_cycle_clk = 65535; sc->sc_xp_rept_clk = 255; sc->sc_xp_rept_max = 0; DPRINTF(1, "XPLX QUERY FAIL: %d\n", r); } else { sc->sc_xp_cycle_clk = xp_readmem16le(PAM_CYCLE_CLK); sc->sc_xp_rept_clk = xp_readmem8(PAM_REPT_CLK); sc->sc_xp_rept_max = xp_readmem8(PAM_REPT_MAX); DPRINTF(1, "xp cycle_clk=%d rept_clk=%d rept_max=%d\n", sc->sc_xp_cycle_clk, sc->sc_xp_rept_clk, sc->sc_xp_rept_max); } if (!sc->sc_isopen) { xp_release(DEVID_PAM); } } static void psgpam_xp_start(struct psgpam_softc *sc) { DPRINTF(3, "XP PAM starting.."); if (xp_readmem8(PAM_RUN) != 0) { DPRINTF(1, "XP PAM already started???\n"); } psgpam_xp_query(sc); sc->sc_xp_rept = (XP_CPU_FREQ / sc->sc_sample_rate - sc->sc_xp_cycle_clk) / sc->sc_xp_rept_clk; if (sc->sc_xp_rept < 0) sc->sc_xp_rept = 0; if (sc->sc_xp_rept > sc->sc_xp_rept_max) sc->sc_xp_rept = sc->sc_xp_rept_max; xp_writemem8(PAM_REPT, sc->sc_xp_rept); DPRINTF(3, "ENC=%d REPT=%d\n", sc->sc_xp_enc, sc->sc_xp_rept); xp_intr5_enable(); xp_cmd_nowait(DEVID_PAM, PAM_CMD_START); DPRINTF(3, "XP PAM started\n"); } /* MI MD API */ static int psgpam_open(void *hdl, int flags) { struct psgpam_softc *sc; u_int a; DPRINTF(1, "%s: flags=0x%x\n", __func__, flags); sc = hdl; a = xp_acquire(DEVID_PAM, 0); if (a == 0) return EBUSY; /* firmware transfer */ xp_ensure_firmware(); sc->sc_xp_state = 0; sc->sc_started = 0; sc->sc_outcount = 0; sc->sc_isopen = 1; memset(xp_shmptr(PAM_BUF), XP_ATN_RESET, PAM_BUF_LEN); return 0; } static void psgpam_close(void *hdl) { struct psgpam_softc *sc; sc = hdl; xp_intr5_disable(); xp_release(DEVID_PAM); sc->sc_isopen = 0; DPRINTF(1, "%s\n", __func__); } static int psgpam_query_format(void *hdl, audio_format_query_t *afp) { struct psgpam_softc *sc; u_int freq; uint8_t rept_max; int clk; int i, n; #define XP_FREQ_MAXCOUNT 40 int f[XP_FREQ_MAXCOUNT]; if (afp->index != 0) return EINVAL; sc = hdl; psgpam_xp_query(sc); switch (sc->sc_xp_enc) { case PAM_ENC_PAM2A: case PAM_ENC_PAM2B: psgpam_format.validbits = 16; psgpam_format.precision = 16; break; case PAM_ENC_PAM3A: case PAM_ENC_PAM3B: psgpam_format.validbits = 32; psgpam_format.precision = 32; break; } /* convert xp's max to AUFMT's max */ rept_max = sc->sc_xp_rept_max + 1; if (rept_max <= AUFMT_MAX_FREQUENCIES) { /* all choice */ for (i = 0; i < rept_max; i++) { clk = sc->sc_xp_cycle_clk + i * sc->sc_xp_rept_clk; freq = XP_CPU_FREQ / clk; psgpam_format.frequency[i] = freq; } n = rept_max; } else { if (rept_max > XP_FREQ_MAXCOUNT) rept_max = XP_FREQ_MAXCOUNT; for (i = 0; i < rept_max; i++) { clk = sc->sc_xp_cycle_clk + i * sc->sc_xp_rept_clk; freq = XP_CPU_FREQ / clk; if (freq < 4000) break; f[i] = freq; } for (; i < XP_FREQ_MAXCOUNT; i++) f[i] = 0; /* * keep: first, last * remove: any unusable freq */ for (i = 1; i < rept_max - 1; i++) { if (( 4000 <= f[i] && f[i] < 6000 && f[i - 1] < 6000 && f[i + 1] > 4000) || ( 6000 <= f[i] && f[i] < 8000 && f[i - 1] < 8000 && f[i + 1] > 6000) || ( 8000 <= f[i] && f[i] < 12000 && f[i - 1] < 12000 && f[i + 1] > 8000) || (12000 <= f[i] && f[i] < 16000 && f[i - 1] < 16000 && f[i + 1] > 12000)) { f[i] = 0; } } n = 0; for (i = 0; i < rept_max; i++) { if (f[i] != 0) { psgpam_format.frequency[n] = f[i]; n++; if (n == AUFMT_MAX_FREQUENCIES) break; } } } psgpam_format.frequency_type = n; afp->fmt = psgpam_format; return 0; } static int psgpam_set_format(void *hdl, int setmode, const audio_params_t *play, const audio_params_t *rec, audio_filter_reg_t *pfil, audio_filter_reg_t *rfil) { /* called before open */ struct psgpam_softc *sc; sc = hdl; DPRINTF(1, "%s: mode=%d %s/%dbit/%dch/%dHz\n", __func__, setmode, audio_encoding_name(play->encoding), play->precision, play->channels, play->sample_rate); sc->sc_sample_rate = play->sample_rate; /* set filter */ switch (sc->sc_xp_enc) { case PAM_ENC_PAM2A: if (sc->sc_dynamic) { pfil->codec = psgpam_aint_to_pam2a_d; } else { pfil->codec = psgpam_aint_to_pam2a; } sc->sc_stride = 2; break; case PAM_ENC_PAM2B: if (sc->sc_dynamic) { pfil->codec = psgpam_aint_to_pam2b_d; } else { pfil->codec = psgpam_aint_to_pam2b; } sc->sc_stride = 2; break; case PAM_ENC_PAM3A: if (sc->sc_dynamic) { pfil->codec = psgpam_aint_to_pam3a_d; } else { pfil->codec = psgpam_aint_to_pam3a; } sc->sc_stride = 4; break; case PAM_ENC_PAM3B: if (sc->sc_dynamic) { pfil->codec = psgpam_aint_to_pam3b_d; } else { pfil->codec = psgpam_aint_to_pam3b; } sc->sc_stride = 4; break; } psgpam_init_context(&sc->sc_psgpam_codecvar, sc->sc_sample_rate); pfil->context = &sc->sc_psgpam_codecvar; return 0; } /* marking block */ static void psgpam_mark_blk(struct psgpam_softc *sc, int blk_id) { int markoffset; uint marker; markoffset = sc->sc_blksize * (blk_id + 1); if (blk_id == sc->sc_blkcount - 1) { marker = XP_ATN_RELOAD; } else { marker = XP_ATN_STAT; } /* marking */ uint8_t *start = sc->sc_start_ptr; if (sc->sc_stride == 2) { uint16_t *markptr = (uint16_t*)(start + markoffset); markptr -= 1; *markptr |= marker; } else { /* stride == 4 */ uint32_t *markptr = (uint32_t*)(start + markoffset); markptr -= 1; *markptr |= marker; } } static int psgpam_trigger_output(void *hdl, void *start, void *end, int blksize, void (*intr)(void *), void *intrarg, const audio_params_t *param) { void *dp; struct psgpam_softc *sc; sc = hdl; DPRINTF(2, "%s start=%p end=%p blksize=%d\n", __func__, start, end, blksize); sc->sc_outcount++; sc->sc_intr = intr; sc->sc_arg = intrarg; sc->sc_blksize = blksize; sc->sc_start_ptr = start; sc->sc_end_ptr = end; sc->sc_blkcount = (sc->sc_end_ptr - sc->sc_start_ptr) / sc->sc_blksize; sc->sc_xp_addr = PAM_BUF; psgpam_mark_blk(sc, 0); psgpam_mark_blk(sc, 1); /* transfer */ dp = xp_shmptr(sc->sc_xp_addr); memcpy(dp, start, blksize * 2); /* (preincrement variable in intr) */ sc->sc_cur_blk_id = 1; sc->sc_xp_addr += blksize; /* play start */ if (sc->sc_started == 0) { /* set flag first */ sc->sc_started = 1; psgpam_xp_start(sc); } return 0; } static int psgpam_halt_output(void *hdl) { struct psgpam_softc *sc = hdl; DPRINTF(2, "%s\n", __func__); xp_intr5_disable(); memset(xp_shmptr(PAM_BUF), XP_ATN_RESET, PAM_BUF_LEN); sc->sc_started = 0; sc->sc_xp_state = 0; return 0; } static int psgpam_getdev(void *hdl, struct audio_device *ret) { *ret = psgpam_device; return 0; } static int psgpam_set_port(void *hdl, mixer_ctrl_t *mc) { DPRINTF(2, "%s\n", __func__); return 0; } static int psgpam_get_port(void *hdl, mixer_ctrl_t *mc) { DPRINTF(2, "%s\n", __func__); return 0; } static int psgpam_query_devinfo(void *hdl, mixer_devinfo_t *di) { DPRINTF(2, "%s %d\n", __func__, di->index); switch (di->index) { default: return EINVAL; } return 0; } static int psgpam_get_props(void *hdl) { return AUDIO_PROP_PLAYBACK; } static void psgpam_get_locks(void *hdl, kmutex_t **intr, kmutex_t **thread) { struct psgpam_softc *sc = hdl; *intr = &sc->sc_intr_lock; *thread = &sc->sc_thread_lock; } static int psgpam_round_blocksize(void *hdl, int bs, int mode, const audio_params_t *param) { #if 0 if (bs < 16384) { return (16384 / bs) * bs; } else { return 16384; } #else return bs; #endif } static size_t psgpam_round_buffersize(void *hdl, int direction, size_t bufsize) { if (bufsize > 28 * 1024) { bufsize = 28 * 1024; } return bufsize; } static int psgpam_intr(void *hdl) { struct psgpam_softc *sc = hdl; xp_intr5_acknowledge(); DPRINTF(4, "psgpam intr\n"); sc->sc_cur_blk_id++; sc->sc_xp_addr += sc->sc_blksize; if (sc->sc_cur_blk_id == sc->sc_blkcount) { sc->sc_cur_blk_id = 0; sc->sc_xp_addr = PAM_BUF; } psgpam_mark_blk(sc, sc->sc_cur_blk_id); memcpy(xp_shmptr(sc->sc_xp_addr), sc->sc_start_ptr + sc->sc_cur_blk_id * sc->sc_blksize, sc->sc_blksize); mutex_spin_enter(&sc->sc_intr_lock); if (sc->sc_intr) { sc->sc_intr(sc->sc_arg); } else { DPRINTF(1, "psgpam_intr: spurious interrupt\n"); } mutex_spin_exit(&sc->sc_intr_lock); /* handled */ return 1; } #if defined(AUDIO_DEBUG) /* sysctl */ static int psgpam_sysctl_debug(SYSCTLFN_ARGS) { struct sysctlnode node; int t, error; node = *rnode; t = psgpamdebug; node.sysctl_data = &t; error = sysctl_lookup(SYSCTLFN_CALL(&node)); if (error || newp == NULL) { return error; } if (t < 0) return EINVAL; if (t > 4) return EINVAL; psgpamdebug = t; return 0; } #endif /* sysctl */ static int psgpam_sysctl_enc(SYSCTLFN_ARGS) { struct sysctlnode node; struct psgpam_softc *sc; int t, error; node = *rnode; sc = node.sysctl_data; t = sc->sc_xp_enc; node.sysctl_data = &t; error = sysctl_lookup(SYSCTLFN_CALL(&node)); if (error || newp == NULL) { return error; } if (t < PAM_ENC_PAM2A) return EINVAL; if (t > PAM_ENC_PAM3B) return EINVAL; sc->sc_xp_enc = t; return 0; } static int psgpam_sysctl_dynamic(SYSCTLFN_ARGS) { struct sysctlnode node; struct psgpam_softc *sc; int t, error; node = *rnode; sc = node.sysctl_data; t = sc->sc_dynamic; node.sysctl_data = &t; error = sysctl_lookup(SYSCTLFN_CALL(&node)); if (error || newp == NULL) { return error; } sc->sc_dynamic = t; return 0; }