/*-
 * spkr.c -- device driver for console speaker
 *
 * v1.4 by Eric S. Raymond (esr@snark.thyrsus.com) Aug 1993
 * modified for FreeBSD by Andrew A. Chernov <ache@astral.msk.su>
 * modified for PC98 by Kakefuda
 */

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/kernel.h>
#include <sys/module.h>
#include <sys/sx.h>
#include <sys/uio.h>
#include <sys/conf.h>
#include <sys/ctype.h>
#include <sys/malloc.h>
#include <machine/clock.h>
#include <dev/speaker/speaker.h>

static  d_open_t        spkropen;
static  d_close_t       spkrclose;
static  d_write_t       spkrwrite;
static  d_ioctl_t       spkrioctl;

static struct cdevsw spkr_cdevsw = {
        .d_version =    D_VERSION,
        .d_open =       spkropen,
        .d_close =      spkrclose,
        .d_write =      spkrwrite,
        .d_ioctl =      spkrioctl,
        .d_name =       "spkr",
};

static MALLOC_DEFINE(M_SPKR, "spkr", "Speaker buffer");

/*
 **************** MACHINE DEPENDENT PART STARTS HERE *************************
 * This section defines a function tone() which causes a tone of given
 * frequency and duration from the ISA console speaker.
 * Another function endtone() is defined to force sound off, and there is
 * also a rest() entry point to do pauses.
 *
 * Audible sound is generated using the Programmable Interval Timer (PIT) and
 * Programmable Peripheral Interface (PPI) attached to the ISA speaker. The
 * PPI controls whether sound is passed through at all; the PIT's channel 2 is
 * used to generate clicks (a square wave) of whatever frequency is desired.
 */

#define SPKRPRI PSOCK
static char endtone, endrest;

struct spkr_state;
static void tone(unsigned int thz, unsigned int centisecs);
static void rest(int centisecs);
static void playinit(struct spkr_state *state);
static void playtone(struct spkr_state *state, int pitch, int value, int sustain);
static void playstring(struct spkr_state *state, char *cp, size_t slen);

/* 
 * Emit tone of frequency thz for given number of centisecs 
 */
static void
tone(unsigned int thz, unsigned int centisecs)
{
        int timo;

        if (thz <= 0)
                return;

#ifdef DEBUG
        (void) printf("tone: thz=%d centisecs=%d\n", thz, centisecs);
#endif /* DEBUG */

        /*
         * Acquire the i8254 clock, configure it to drive the speaker
         * signal, and turn on the speaker.
         */
        if (timer_spkr_acquire()) {
                return;
        }
        /* Configure the speaker with the tone frequency. */
        timer_spkr_setfreq(thz);

        /*
         * Make the current thread sleep while the tone is being
         * emitted.
         */
        timo = centisecs * hz / 100;
        if (timo > 0)
                tsleep(&endtone, SPKRPRI | PCATCH, "spkrtn", timo);

        /*
         * Turn off the speaker and release the i8254 clock.
         */
        timer_spkr_release();
}

/*
 * Rest for given number of centisecs 
 */
static void
rest(int centisecs)
{
        int timo;

        /*
         * Set timeout to endrest function, then give up the timeslice.
         * This is so other processes can execute while the rest is being
         * waited out.
         */
#ifdef DEBUG
        (void) printf("rest: %d\n", centisecs);
#endif /* DEBUG */
        timo = centisecs * hz / 100;
        if (timo > 0)
                tsleep(&endrest, SPKRPRI | PCATCH, "spkrrs", timo);
}

/*
 **************** PLAY STRING INTERPRETER BEGINS HERE **********************
 * Play string interpretation is modelled on IBM BASIC 2.0's PLAY statement;
 * M[LNS] are missing; the ~ synonym and the _ slur mark and the octave-
 * tracking facility are added.
 * Requires tone(), rest(), and endtone(). String play is not interruptible
 * except possibly at physical block boundaries.
 */

#define dtoi(c)         ((c) - '0')

struct spkr_state {
        char *inbuf;    /* incoming melody buffer */

        int octave;     /* currently selected octave */
        int whole;      /* whole-note time at current tempo, in ticks */
        int value;      /* whole divisor for note time, quarter note = 1 */
        int fill;       /* controls spacing of notes */
        bool octtrack;  /* octave-tracking on? */
        bool octprefix; /* override current octave-tracking state? */
};

/*
 * Magic number avoidance...
 */
#define SECS_PER_MIN    60      /* seconds per minute */
#define WHOLE_NOTE      4       /* quarter notes per whole note */
#define MIN_VALUE       64      /* the most we can divide a note by */
#define DFLT_VALUE      4       /* default value (quarter-note) */
#define FILLTIME        8       /* for articulation, break note in parts */
#define STACCATO        6       /* 6/8 = 3/4 of note is filled */
#define NORMAL          7       /* 7/8ths of note interval is filled */
#define LEGATO          8       /* all of note interval is filled */
#define DFLT_OCTAVE     4       /* default octave */
#define MIN_TEMPO       32      /* minimum tempo */
#define DFLT_TEMPO      120     /* default tempo */
#define MAX_TEMPO       255     /* max tempo */
#define NUM_MULT        3       /* numerator of dot multiplier */
#define DENOM_MULT      2       /* denominator of dot multiplier */

/* letter to half-tone:  A   B  C  D  E  F  G */
static const int notetab[8] = {9, 11, 0, 2, 4, 5, 7};

/*
 * This is the American Standard A440 Equal-Tempered scale with frequencies
 * rounded to nearest integer. Thank Goddess for the good ol' CRC Handbook...
 * our octave 0 is standard octave 2.
 */
#define OCTAVE_NOTES    12      /* semitones per octave */
static const int pitchtab[] =
{
/*        C     C#    D     D#    E     F     F#    G     G#    A     A#    B*/
/* 0 */   65,   69,   73,   78,   82,   87,   93,   98,  103,  110,  117,  123,
/* 1 */  131,  139,  147,  156,  165,  175,  185,  196,  208,  220,  233,  247,
/* 2 */  262,  277,  294,  311,  330,  349,  370,  392,  415,  440,  466,  494,
/* 3 */  523,  554,  587,  622,  659,  698,  740,  784,  831,  880,  932,  988,
/* 4 */ 1047, 1109, 1175, 1245, 1319, 1397, 1480, 1568, 1661, 1760, 1865, 1975,
/* 5 */ 2093, 2217, 2349, 2489, 2637, 2794, 2960, 3136, 3322, 3520, 3729, 3951,
/* 6 */ 4186, 4435, 4698, 4978, 5274, 5588, 5920, 6272, 6644, 7040, 7459, 7902,
};

static void
playinit(struct spkr_state *state)
{
    state->octave = DFLT_OCTAVE;
    state->whole = (100 * SECS_PER_MIN * WHOLE_NOTE) / DFLT_TEMPO;
    state->fill = NORMAL;
    state->value = DFLT_VALUE;
    state->octtrack = false;
    state->octprefix = true;    /* act as though there was an initial O(n) */
}

/* 
 * Play tone of proper duration for current rhythm signature 
 */
static void
playtone(struct spkr_state *state, int pitch, int value, int sustain)
{
        int sound, silence, snum = 1, sdenom = 1;
        int whole = state->whole;
        int fill = state->fill;

        /* this weirdness avoids floating-point arithmetic */
        for (; sustain; sustain--) {
                /* See the BUGS section in the man page for discussion */
                snum *= NUM_MULT;
                sdenom *= DENOM_MULT;
        }

        if (value == 0 || sdenom == 0)
                return;

        if (pitch == -1)
                rest(whole * snum / (value * sdenom));
        else {
                sound = (whole * snum) / (value * sdenom)
                        - (whole * (FILLTIME - fill)) / (value * FILLTIME);
                silence = whole * (FILLTIME-fill) * snum / (FILLTIME * value * sdenom);

#ifdef DEBUG
                (void) printf("playtone: pitch %d for %d ticks, rest for %d ticks\n",
                        pitch, sound, silence);
#endif /* DEBUG */

                tone(pitchtab[pitch], sound);
                if (fill != LEGATO)
                        rest(silence);
        }
}

/*
 * Interpret and play an item from a notation string 
 */
static void
playstring(struct spkr_state *state, char *cp, size_t slen)
{
        int pitch, oldfill, lastpitch = OCTAVE_NOTES * DFLT_OCTAVE;

#define GETNUM(cp, v)   for(v=0; isdigit(cp[1]) && slen > 0; ) \
                                {v = v * 10 + (*++cp - '0'); slen--;}
        for (; slen--; cp++) {
                int sustain, timeval, tempo;
                char c = toupper(*cp);

#ifdef DEBUG
                (void) printf("playstring: %c (%x)\n", c, c);
#endif /* DEBUG */

                switch (c) {
                case 'A':
                case 'B':
                case 'C':
                case 'D':
                case 'E':
                case 'F':
                case 'G':
                        /* compute pitch */
                        pitch = notetab[c - 'A'] + state->octave * OCTAVE_NOTES;

                        /* this may be followed by an accidental sign */
                        if (cp[1] == '#' || cp[1] == '+') {
                                ++pitch;
                                ++cp;
                                slen--;
                        } else if (cp[1] == '-') {
                                --pitch;
                                ++cp;
                                slen--;
                        }

                        /*
                         * If octave-tracking mode is on, and there has been no octave-
                         * setting prefix, find the version of the current letter note
                         * closest to the last regardless of octave.
                         */
                        if (state->octtrack && !state->octprefix) {
                                if (abs(pitch-lastpitch) > abs(pitch+OCTAVE_NOTES - 
                                        lastpitch)) {
                                        ++state->octave;
                                        pitch += OCTAVE_NOTES;
                                }

                                if (abs(pitch-lastpitch) > abs((pitch-OCTAVE_NOTES) - 
                                        lastpitch)) {
                                        --state->octave;
                                        pitch -= OCTAVE_NOTES;
                                }
                        }
                        state->octprefix = false;
                        lastpitch = pitch;

                        /* ...which may in turn be followed by an override time value */
                        GETNUM(cp, timeval);
                        if (timeval <= 0 || timeval > MIN_VALUE)
                                timeval = state->value;

                        /* ...and/or sustain dots */
                        for (sustain = 0; cp[1] == '.'; cp++) { 
                                slen--;
                                sustain++;
                        }

                        /* ...and/or a slur mark */
                        oldfill = state->fill;
                        if (cp[1] == '_') {
                                state->fill = LEGATO;
                                ++cp;
                                slen--;
                        }

                        /* time to emit the actual tone */
                        playtone(state, pitch, timeval, sustain);

                        state->fill = oldfill;
                        break;
                case 'O':
                        if (cp[1] == 'N' || cp[1] == 'n') {
                                state->octprefix = state->octtrack = false;
                                ++cp;
                                slen--;
                        } else if (cp[1] == 'L' || cp[1] == 'l') {
                                state->octtrack = true;
                                ++cp;
                                slen--;
                        } else {
                                GETNUM(cp, state->octave);
                                if (state->octave >= nitems(pitchtab) / OCTAVE_NOTES)
                                        state->octave = DFLT_OCTAVE;
                                state->octprefix = true;
                        }
                        break;
                case '>':
                        if (state->octave < nitems(pitchtab) / OCTAVE_NOTES - 1)
                                state->octave++;
                        state->octprefix = true;
                        break;
                case '<':
                        if (state->octave > 0)
                                state->octave--;
                        state->octprefix = true;
                        break;
                case 'N':
                        GETNUM(cp, pitch);
                        for (sustain = 0; cp[1] == '.'; cp++) {
                                slen--;
                                sustain++;
                        }
                        oldfill = state->fill;
                        if (cp[1] == '_') {
                                state->fill = LEGATO;
                                ++cp;
                                slen--;
                        }
                        playtone(state, pitch - 1, state->value, sustain);
                        state->fill = oldfill;
                        break;
                case 'L':
                        GETNUM(cp, state->value);
                        if (state->value <= 0 || state->value > MIN_VALUE)
                                state->value = DFLT_VALUE;
                        break;
                case 'P':
                case '~':
                        /* this may be followed by an override time value */
                        GETNUM(cp, timeval);
                        if (timeval <= 0 || timeval > MIN_VALUE)
                                timeval = state->value;
                        for (sustain = 0; cp[1] == '.'; cp++) {
                                slen--;
                                sustain++;
                        }
                        playtone(state, -1, timeval, sustain);
                        break;
                case 'T':
                        GETNUM(cp, tempo);
                        if (tempo < MIN_TEMPO || tempo > MAX_TEMPO)
                                tempo = DFLT_TEMPO;
                        state->whole = (100 * SECS_PER_MIN * WHOLE_NOTE) / tempo;
                        break;
                case 'M':
                        if (cp[1] == 'N' || cp[1] == 'n') {
                                state->fill = NORMAL;
                                ++cp;
                                slen--;
                        } else if (cp[1] == 'L' || cp[1] == 'l') {
                                state->fill = LEGATO;
                                ++cp;
                                slen--;
                        } else if (cp[1] == 'S' || cp[1] == 's') {
                                state->fill = STACCATO;
                                ++cp;
                                slen--;
                        }
                        break;
                }
        }
}

/*
 * ****************** UNIX DRIVER HOOKS BEGIN HERE **************************
 * This section implements driver hooks to run playstring() and the tone(),
 * endtone(), and rest() functions defined above.
 */

/*
 * we use a lock to prevent interleaving of melodies written
 * concurrently from two different threads.
 */
static struct sx spkr_op_locked;

static void
spkr_dtor(void *data)
{
        struct spkr_state *state = data;

        free(state->inbuf, M_SPKR);
        free(state, M_SPKR);
}

static int
spkropen(struct cdev *dev, int flags, int fmt, struct thread *td)
{
        struct spkr_state *state;
        int error;
#ifdef DEBUG
        (void) printf("spkropen: entering with dev = %s\n", devtoname(dev));
#endif /* DEBUG */

        /* allocate per-fd state */
        state = malloc(sizeof(*state), M_SPKR, M_WAITOK | M_ZERO);
        state->inbuf = malloc(DEV_BSIZE, M_SPKR, M_WAITOK);

        /* initialize playstring state */
        playinit(state);

        /* store in the current fd private data */
        error = devfs_set_cdevpriv(state, spkr_dtor);
        if (error) {
                free(state->inbuf, M_SPKR);
                free(state, M_SPKR);
                return (error);
        }

        return (0);
}

static int
spkrwrite(struct cdev *dev, struct uio *uio, int ioflag)
{
        struct spkr_state *state;
        int error;
        unsigned n;

#ifdef DEBUG
        printf("spkrwrite: entering with dev = %s, count = %zd\n",
                devtoname(dev), uio->uio_resid);
#endif /* DEBUG */

        /* is the melody too long? */
        if (uio->uio_resid > (DEV_BSIZE - 1))
                return (E2BIG);

        /* get this fd's state */
        error = devfs_get_cdevpriv((void **)&state);
        if (error)
                return (error);

        /* copy melody from userspace */
        n = uio->uio_resid;
        error = uiomove(state->inbuf, n, uio);
        if (error)
                return (error);
        state->inbuf[n] = '\0';

        /* play the melody. */
        sx_xlock(&spkr_op_locked);
        playstring(state, state->inbuf, n);
        sx_xunlock(&spkr_op_locked);

        return (0);
}

static int
spkrclose(struct cdev *dev, int flags, int fmt, struct thread *td)
{
#ifdef DEBUG
        (void) printf("spkrclose: entering with dev = %s\n", devtoname(dev));
#endif /* DEBUG */

        wakeup(&endtone);
        wakeup(&endrest);
        /* devfs_clear_cdevpriv() calls spkr_dtor automatically */
        return (0);
}

static int
spkrioctl(struct cdev *dev, unsigned long cmd, caddr_t cmdarg, int flags,
    struct thread *td)
{
#ifdef DEBUG
        (void) printf("spkrioctl: entering with dev = %s, cmd = %lx\n",
                devtoname(dev), cmd);
#endif /* DEBUG */

        if (cmd == SPKRTONE) {
                tone_t  *tp = (tone_t *)cmdarg;

                sx_xlock(&spkr_op_locked);
                if (tp->frequency == 0)
                        rest(tp->duration);
                else
                        tone(tp->frequency, tp->duration);
                sx_xunlock(&spkr_op_locked);
                return (0);
        } else if (cmd == SPKRTUNE) {
                tone_t  *tp = (tone_t *)(*(caddr_t *)cmdarg);
                tone_t ttp;
                int error;

                sx_xlock(&spkr_op_locked);
                for (; ; tp++) {
                        error = copyin(tp, &ttp, sizeof(tone_t));
                        if (error) {
                                sx_xunlock(&spkr_op_locked);
                                return (error);
                        }

                        if (ttp.duration == 0)
                                break;

                        if (ttp.frequency == 0)
                                rest(ttp.duration);
                        else
                                tone(ttp.frequency, ttp.duration);
                }
                sx_xunlock(&spkr_op_locked);
                return (0);
        }
        return (EINVAL);
}

static struct cdev *speaker_dev;

/*
 * Module handling
 */
static int
speaker_modevent(module_t mod, int type, void *data)
{
        int error = 0;

        switch(type) {
        case MOD_LOAD:
                sx_init(&spkr_op_locked, "spkr");
                speaker_dev = make_dev(&spkr_cdevsw, 0,
                    UID_ROOT, GID_WHEEL, 0600, "speaker");
                break;
        case MOD_SHUTDOWN:
        case MOD_UNLOAD:
                destroy_dev(speaker_dev);
                sx_destroy(&spkr_op_locked);
                break;
        default:
                error = EOPNOTSUPP;
        }
        return (error);
}

DEV_MODULE(speaker, speaker_modevent, NULL);