/*      $NetBSD: opmbell.c,v 1.28 2019/11/10 21:16:33 chs Exp $ */

/*
* Copyright (c) 1995 MINOURA Makoto, Takuya Harakawa.
* 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.
* 3. All advertising materials mentioning features or use of this software
*    must display the following acknowledgement:
*      This product includes software developed by MINOURA Makoto,
*      Takuya Harakawa.
* 4. Neither the name of the authors may be used to endorse or promote
*    products derived from this software without specific prior written
*    permission.
*
* THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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.
*
*/

/*
* bell device driver
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: opmbell.c,v 1.28 2019/11/10 21:16:33 chs Exp $");

#include "bell.h"
#if NBELL > 0

#if NBELL > 1
#undef NBELL
#define NBELL 1
#endif

#include <sys/param.h>
#include <sys/errno.h>
#include <sys/uio.h>
#include <sys/device.h>
#include <sys/malloc.h>
#include <sys/file.h>
#include <sys/systm.h>
#include <sys/callout.h>
#include <sys/conf.h>
#include <sys/event.h>
#include <sys/kernel.h>

#include <machine/opmbellio.h>

#include <x68k/dev/opmvar.h>

#include "ioconf.h"

/* In opm.c. */
void opm_set_volume(int, int);
void opm_set_key(int, int);
void opm_set_voice(int, struct opm_voice *);
void opm_key_on(u_char);
void opm_key_off(u_char);

static u_int bell_pitchtokey(u_int);
static void bell_timeout(void *);

struct bell_softc {
       int sc_flags;
       u_char ch;
       u_char volume;
       u_int pitch;
       u_int msec;
       u_int key;
};

struct bell_softc *bell_softc;

callout_t bell_ch;

static struct opm_voice vtab[NBELL];

static struct opm_voice bell_voice = DEFAULT_BELL_VOICE;

/* sc_flags values */
#define BELLF_READ      0x01
#define BELLF_WRITE     0x02
#define BELLF_ALIVE     0x04
#define BELLF_OPEN      0x08
#define BELLF_OUT       0x10
#define BELLF_ON        0x20

#define UNIT(x)         minor(x)

void bell_on(struct bell_softc *);
void bell_off(struct bell_softc *);
void opm_bell(void);
void opm_bell_on(void);
void opm_bell_off(void);
int opm_bell_setup(struct bell_info *);
int bellmstohz(int);

dev_type_open(bellopen);
dev_type_close(bellclose);
dev_type_ioctl(bellioctl);

const struct cdevsw bell_cdevsw = {
       .d_open = bellopen,
       .d_close = bellclose,
       .d_read = noread,
       .d_write = nowrite,
       .d_ioctl = bellioctl,
       .d_stop = nostop,
       .d_tty = notty,
       .d_poll = nopoll,
       .d_mmap = nommap,
       .d_kqfilter = nokqfilter,
       .d_discard = nodiscard,
       .d_flag = 0
};

void
bellattach(int num)
{
       u_long size;
       struct bell_softc *sc;
       int unit;

       if (num <= 0)
               return;
       callout_init(&bell_ch, 0);
       size = num * sizeof(struct bell_softc);
       bell_softc = malloc(size, M_DEVBUF, M_WAITOK | M_ZERO);
       for (unit = 0; unit < num; unit++) {
               sc = &bell_softc[unit];
               sc->sc_flags = BELLF_ALIVE;
               sc->ch = BELL_CHANNEL;
               sc->volume = BELL_VOLUME;
               sc->pitch = BELL_PITCH;
               sc->msec = BELL_DURATION;
               sc->key = bell_pitchtokey(sc->pitch);

               /* setup initial voice parameter */
               memcpy(&vtab[unit], &bell_voice, sizeof(bell_voice));
               opm_set_voice(sc->ch, &vtab[unit]);

               printf("bell%d: YM2151 OPM bell emulation.\n", unit);
       }
}

int
bellopen(dev_t dev, int flags, int mode, struct lwp *l)
{
       int unit = UNIT(dev);
       struct bell_softc *sc = &bell_softc[unit];

       if (unit >= NBELL || !(sc->sc_flags & BELLF_ALIVE))
               return ENXIO;

       if (sc->sc_flags & BELLF_OPEN)
               return EBUSY;

       sc->sc_flags |= BELLF_OPEN;
       sc->sc_flags |= (flags & (FREAD | FWRITE));

       return 0;
}

int
bellclose(dev_t dev, int flags, int mode, struct lwp *l)
{
       int unit = UNIT(dev);
       struct bell_softc *sc = &bell_softc[unit];

       sc->sc_flags &= ~BELLF_OPEN;
       return 0;
}

int
bellioctl(dev_t dev, u_long cmd, void *addr, int flag, struct lwp *l)
{
       int unit = UNIT(dev);
       struct bell_softc *sc = &bell_softc[unit];

       switch (cmd) {
       case BELLIOCGPARAM:
         {
               struct bell_info *bp = (struct bell_info *)addr;
               if (!(sc->sc_flags & FREAD))
                       return EBADF;

               bp->volume = sc->volume;
               bp->pitch = sc->pitch;
               bp->msec = sc->msec;
               break;
         }

       case BELLIOCSPARAM:
         {
               struct bell_info *bp = (struct bell_info *)addr;

               if (!(sc->sc_flags & FWRITE))
                       return EBADF;

               return opm_bell_setup(bp);
         }

       case BELLIOCGVOICE:
               if (!(sc->sc_flags & FREAD))
                       return EBADF;

               if (addr == NULL)
                       return EFAULT;

               memcpy(addr, &vtab[unit], sizeof(struct opm_voice));
               break;

       case BELLIOCSVOICE:
               if (!(sc->sc_flags & FWRITE))
                       return EBADF;

               if (addr == NULL)
                       return EFAULT;

               memcpy(&vtab[unit], addr, sizeof(struct opm_voice));
               opm_set_voice(sc->ch, &vtab[unit]);
               break;

       default:
               return EINVAL;
       }
       return 0;
}

/*
* The next table is used for calculating KeyCode/KeyFraction pair
* from frequency.
*/

static u_int note[] = {
       0x0800, 0x0808, 0x0810, 0x081c,
       0x0824, 0x0830, 0x0838, 0x0844,
       0x084c, 0x0858, 0x0860, 0x086c,
       0x0874, 0x0880, 0x0888, 0x0890,
       0x089c, 0x08a4, 0x08b0, 0x08b8,
       0x08c4, 0x08cc, 0x08d8, 0x08e0,
       0x08ec, 0x08f4, 0x0900, 0x0908,
       0x0910, 0x091c, 0x0924, 0x092c,
       0x0938, 0x0940, 0x0948, 0x0954,
       0x095c, 0x0968, 0x0970, 0x0978,
       0x0984, 0x098c, 0x0994, 0x09a0,
       0x09a8, 0x09b4, 0x09bc, 0x09c4,
       0x09d0, 0x09d8, 0x09e0, 0x09ec,
       0x09f4, 0x0a00, 0x0a08, 0x0a10,
       0x0a18, 0x0a20, 0x0a28, 0x0a30,
       0x0a38, 0x0a44, 0x0a4c, 0x0a54,
       0x0a5c, 0x0a64, 0x0a6c, 0x0a74,
       0x0a80, 0x0a88, 0x0a90, 0x0a98,
       0x0aa0, 0x0aa8, 0x0ab0, 0x0ab8,
       0x0ac4, 0x0acc, 0x0ad4, 0x0adc,
       0x0ae4, 0x0aec, 0x0af4, 0x0c00,
       0x0c08, 0x0c10, 0x0c18, 0x0c20,
       0x0c28, 0x0c30, 0x0c38, 0x0c40,
       0x0c48, 0x0c50, 0x0c58, 0x0c60,
       0x0c68, 0x0c70, 0x0c78, 0x0c84,
       0x0c8c, 0x0c94, 0x0c9c, 0x0ca4,
       0x0cac, 0x0cb4, 0x0cbc, 0x0cc4,
       0x0ccc, 0x0cd4, 0x0cdc, 0x0ce4,
       0x0cec, 0x0cf4, 0x0d00, 0x0d04,
       0x0d0c, 0x0d14, 0x0d1c, 0x0d24,
       0x0d2c, 0x0d34, 0x0d3c, 0x0d44,
       0x0d4c, 0x0d54, 0x0d5c, 0x0d64,
       0x0d6c, 0x0d74, 0x0d7c, 0x0d80,
       0x0d88, 0x0d90, 0x0d98, 0x0da0,
       0x0da8, 0x0db0, 0x0db8, 0x0dc0,
       0x0dc8, 0x0dd0, 0x0dd8, 0x0de0,
       0x0de8, 0x0df0, 0x0df8, 0x0e00,
       0x0e04, 0x0e0c, 0x0e14, 0x0e1c,
       0x0e24, 0x0e28, 0x0e30, 0x0e38,
       0x0e40, 0x0e48, 0x0e50, 0x0e54,
       0x0e5c, 0x0e64, 0x0e6c, 0x0e74,
       0x0e7c, 0x0e80, 0x0e88, 0x0e90,
       0x0e98, 0x0ea0, 0x0ea8, 0x0eac,
       0x0eb4, 0x0ebc, 0x0ec4, 0x0ecc,
       0x0ed4, 0x0ed8, 0x0ee0, 0x0ee8,
       0x0ef0, 0x0ef8, 0x1000, 0x1004,
       0x100c, 0x1014, 0x1018, 0x1020,
       0x1028, 0x1030, 0x1034, 0x103c,
       0x1044, 0x104c, 0x1050, 0x1058,
       0x1060, 0x1064, 0x106c, 0x1074,
       0x107c, 0x1080, 0x1088, 0x1090,
       0x1098, 0x109c, 0x10a4, 0x10ac,
       0x10b0, 0x10b8, 0x10c0, 0x10c8,
       0x10cc, 0x10d4, 0x10dc, 0x10e4,
       0x10e8, 0x10f0, 0x10f8, 0x1100,
       0x1104, 0x110c, 0x1110, 0x1118,
       0x1120, 0x1124, 0x112c, 0x1134,
       0x1138, 0x1140, 0x1148, 0x114c,
       0x1154, 0x1158, 0x1160, 0x1168,
       0x116c, 0x1174, 0x117c, 0x1180,
       0x1188, 0x1190, 0x1194, 0x119c,
       0x11a4, 0x11a8, 0x11b0, 0x11b4,
       0x11bc, 0x11c4, 0x11c8, 0x11d0,
       0x11d8, 0x11dc, 0x11e4, 0x11ec,
       0x11f0, 0x11f8, 0x1200, 0x1204,
       0x120c, 0x1210, 0x1218, 0x121c,
       0x1224, 0x1228, 0x1230, 0x1238,
       0x123c, 0x1244, 0x1248, 0x1250,
       0x1254, 0x125c, 0x1260, 0x1268,
       0x1270, 0x1274, 0x127c, 0x1280,
       0x1288, 0x128c, 0x1294, 0x129c,
       0x12a0, 0x12a8, 0x12ac, 0x12b4,
       0x12b8, 0x12c0, 0x12c4, 0x12cc,
       0x12d4, 0x12d8, 0x12e0, 0x12e4,
       0x12ec, 0x12f0, 0x12f8, 0x1400,
       0x1404, 0x1408, 0x1410, 0x1414,
       0x141c, 0x1420, 0x1428, 0x142c,
       0x1434, 0x1438, 0x1440, 0x1444,
       0x1448, 0x1450, 0x1454, 0x145c,
       0x1460, 0x1468, 0x146c, 0x1474,
       0x1478, 0x1480, 0x1484, 0x1488,
       0x1490, 0x1494, 0x149c, 0x14a0,
       0x14a8, 0x14ac, 0x14b4, 0x14b8,
       0x14c0, 0x14c4, 0x14c8, 0x14d0,
       0x14d4, 0x14dc, 0x14e0, 0x14e8,
       0x14ec, 0x14f4, 0x14f8, 0x1500,
       0x1504, 0x1508, 0x1510, 0x1514,
       0x1518, 0x1520, 0x1524, 0x1528,
       0x1530, 0x1534, 0x1538, 0x1540,
       0x1544, 0x154c, 0x1550, 0x1554,
       0x155c, 0x1560, 0x1564, 0x156c,
       0x1570, 0x1574, 0x157c, 0x1580,
       0x1588, 0x158c, 0x1590, 0x1598,
       0x159c, 0x15a0, 0x15a8, 0x15ac,
       0x15b0, 0x15b8, 0x15bc, 0x15c4,
       0x15c8, 0x15cc, 0x15d4, 0x15d8,
       0x15dc, 0x15e4, 0x15e8, 0x15ec,
       0x15f4, 0x15f8, 0x1600, 0x1604,
       0x1608, 0x160c, 0x1614, 0x1618,
       0x161c, 0x1620, 0x1628, 0x162c,
       0x1630, 0x1638, 0x163c, 0x1640,
       0x1644, 0x164c, 0x1650, 0x1654,
       0x165c, 0x1660, 0x1664, 0x1668,
       0x1670, 0x1674, 0x1678, 0x1680,
       0x1684, 0x1688, 0x168c, 0x1694,
       0x1698, 0x169c, 0x16a0, 0x16a8,
       0x16ac, 0x16b0, 0x16b8, 0x16bc,
       0x16c0, 0x16c4, 0x16cc, 0x16d0,
       0x16d4, 0x16dc, 0x16e0, 0x16e4,
       0x16e8, 0x16f0, 0x16f4, 0x16f8,
};

static u_int
bell_pitchtokey(u_int pitch)
{
       int i, oct;
       u_int key;

       i = 16 * pitch / 440;
       for (oct = -1; i > 0; i >>= 1, oct++)
               ;

       i  = (pitch * 16 - (440 * (1 << oct))) / (1 << oct);
       key = (oct << 12) + note[i];

       return key;
}

/*
* The next table is a little trikcy table of volume factors.
* Its values have been calculated as table[i] = -15 * log10(i/100)
* with an obvious exception for i = 0; This log-table converts a linear
* volume-scaling (0...100) to a logarithmic scaling as present in the
* OPM chips. so: Volume 50% = 6 db.
*/

static u_char vol_table[] = {
       0x7f, 0x35, 0x2d, 0x28, 0x25, 0x22, 0x20, 0x1e,
       0x1d, 0x1b, 0x1a, 0x19, 0x18, 0x17, 0x16, 0x15,
       0x15, 0x14, 0x13, 0x13, 0x12, 0x12, 0x11, 0x11,
       0x10, 0x10, 0x0f, 0x0f, 0x0e, 0x0e, 0x0d, 0x0d,
       0x0d, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b, 0x0b, 0x0a,
       0x0a, 0x0a, 0x0a, 0x09, 0x09, 0x09, 0x08, 0x08,
       0x08, 0x08, 0x08, 0x07, 0x07, 0x07, 0x07, 0x06,
       0x06, 0x06, 0x06, 0x06, 0x05, 0x05, 0x05, 0x05,
       0x05, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x03,
       0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x02, 0x02,
       0x02, 0x02, 0x02, 0x02, 0x02, 0x01, 0x01, 0x01,
       0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
       0x00, 0x00, 0x00, 0x00, 0x00,
};

void
bell_on(struct bell_softc *sc)
{
       int sps;

       sps = spltty();
       opm_set_volume(sc->ch, vol_table[sc->volume]);
       opm_set_key(sc->ch, sc->key);
       splx(sps);

       opm_key_on(sc->ch);
       sc->sc_flags |= BELLF_ON;
}

void
bell_off(struct bell_softc *sc)
{
       if (sc->sc_flags & BELLF_ON) {
               opm_key_off(sc->ch);
               sc->sc_flags &= ~BELLF_ON;
       }
}

void
opm_bell(void)
{
       struct bell_softc *sc = &bell_softc[0];
       int ticks;

       if (sc->msec != 0) {
               if (sc->sc_flags & BELLF_OUT) {
                       bell_timeout(0);
               } else if (sc->sc_flags & BELLF_ON)
                       return;

               ticks = bellmstohz(sc->msec);

               bell_on(sc);
               sc->sc_flags |= BELLF_OUT;

               callout_reset(&bell_ch, ticks, bell_timeout, NULL);
       }
}

static void
bell_timeout(void *arg)
{
       struct bell_softc *sc = &bell_softc[0];

       sc->sc_flags &= ~BELLF_OUT;
       bell_off(sc);
       callout_stop(&bell_ch);
}

void
opm_bell_on(void)
{
       struct bell_softc *sc = &bell_softc[0];

       if (sc->sc_flags & BELLF_OUT)
               bell_timeout(0);
       if (sc->sc_flags & BELLF_ON)
               return;

       bell_on(sc);
}

void
opm_bell_off(void)
{
       struct bell_softc *sc = &bell_softc[0];

       if (sc->sc_flags & BELLF_ON)
               bell_off(sc);
}

int
opm_bell_setup(struct bell_info *data)
{
       struct bell_softc *sc = &bell_softc[0];

       /* bounds check */
       if (data->pitch > MAXBPITCH || data->pitch < MINBPITCH ||
           data->volume > MAXBVOLUME || data->msec > MAXBTIME) {
               return EINVAL;
       } else {
               sc->volume = data->volume;
               sc->pitch = data->pitch;
               sc->msec = data->msec;
               sc->key = bell_pitchtokey(data->pitch);
       }
       return 0;
}

int
bellmstohz(int m)
{
       int h = m;

       if (h > 0) {
               h = h * hz / 1000;
               if (h == 0)
                       h = 1000 / hz;
       }
       return h;
}

#endif

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.