/*      $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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: psgpam.c,v 1.2 2022/06/11 14:45:37 tsutsui Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/endian.h>
#include <sys/kmem.h>
#include <sys/sysctl.h>

#include <sys/cpu.h>
#include <sys/audioio.h>
#include <dev/audio/audio_if.h>

#include <machine/autoconf.h>

#include <luna68k/dev/xpbusvar.h>
#include <luna68k/dev/psgpam_enc.h>
#include <luna68k/dev/xpcmd.h>
#include <luna68k/dev/xplx/xplxdefs.h>

#include <luna68k/luna68k/isr.h>

#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;
}