/* $NetBSD: dtv_device.c,v 1.14 2022/03/31 19:30:15 pgoyette Exp $ */ /*- * Copyright (c) 2011 Jared D. McNeill * 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 Jared D. McNeill. * 4. Neither the name of The NetBSD Foundation nor the names of its * contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * 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. */ #include __KERNEL_RCSID(0, "$NetBSD: dtv_device.c,v 1.14 2022/03/31 19:30:15 pgoyette Exp $"); #include #include #include #include #include #include #include #include #include #include "ioconf.h" MODULE(MODULE_CLASS_DRIVER, dtv, NULL); static dev_type_open(dtvopen); static dev_type_close(dtvclose); static dev_type_read(dtvread); static dev_type_ioctl(dtvioctl); static dev_type_poll(dtvpoll); const struct cdevsw dtv_cdevsw = { .d_open = dtvopen, .d_close = dtvclose, .d_read = dtvread, .d_write = nowrite, .d_ioctl = dtvioctl, .d_stop = nostop, .d_tty = notty, .d_poll = dtvpoll, .d_mmap = nommap, .d_kqfilter = nokqfilter, .d_discard = nodiscard, .d_flag = D_OTHER | D_MPSAFE, }; static int dtv_match(device_t, cfdata_t, void *); static void dtv_attach(device_t, device_t, void *); static int dtv_detach(device_t, int); CFATTACH_DECL_NEW(dtv, sizeof(struct dtv_softc), dtv_match, dtv_attach, dtv_detach, NULL ); static int dtv_match(device_t parent, cfdata_t cfdata, void *aa) { return 1; } static void dtv_attach(device_t parent, device_t self, void *aa) { struct dtv_attach_args *daa = aa; struct dtv_softc *sc = device_private(self); struct dtv_stream *ds = &sc->sc_stream; struct dvb_frontend_info info; sc->sc_dev = self; sc->sc_hw = daa->hw; sc->sc_priv = daa->priv; sc->sc_open = 0; mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_NONE); ds->ds_nbufs = 0; ds->ds_buf = NULL; SIMPLEQ_INIT(&ds->ds_ingress); SIMPLEQ_INIT(&ds->ds_egress); mutex_init(&ds->ds_egress_lock, MUTEX_DEFAULT, IPL_SCHED); mutex_init(&ds->ds_ingress_lock, MUTEX_DEFAULT, IPL_SCHED); cv_init(&ds->ds_sample_cv, "dtv"); selinit(&ds->ds_sel); dtv_scatter_buf_init(&ds->ds_data); if (dtv_buffer_realloc(sc, DTV_DEFAULT_BUFSIZE) != 0) { aprint_error(": no memory\n"); sc->sc_dying = true; return; } mutex_init(&sc->sc_demux_lock, MUTEX_DEFAULT, IPL_SCHED); TAILQ_INIT(&sc->sc_demux_list); sc->sc_demux_runcnt = 0; dtv_device_get_devinfo(sc, &info); aprint_naive("\n"); aprint_normal(": %s", info.name); switch (info.type) { case FE_QPSK: aprint_normal(" [QPSK]"); break; case FE_QAM: aprint_normal(" [QAM]"); break; case FE_OFDM: aprint_normal(" [OFDM]"); break; case FE_ATSC: aprint_normal(" [ATSC]"); break; } aprint_normal("\n"); } static int dtv_detach(device_t self, int flags) { struct dtv_softc *sc = device_private(self); struct dtv_stream *ds = &sc->sc_stream; cv_destroy(&ds->ds_sample_cv); mutex_destroy(&ds->ds_ingress_lock); mutex_destroy(&ds->ds_egress_lock); seldestroy(&ds->ds_sel); dtv_buffer_realloc(sc, 0); dtv_scatter_buf_destroy(&ds->ds_data); mutex_destroy(&sc->sc_demux_lock); mutex_destroy(&sc->sc_lock); return 0; } #ifdef _MODULE #include "ioconf.c" #endif static int dtv_modcmd(modcmd_t cmd, void *arg) { #ifdef _MODULE int error, bmaj = -1, cmaj = -1; #endif switch (cmd) { case MODULE_CMD_INIT: #ifdef _MODULE error = devsw_attach("dtv", NULL, &bmaj, &dtv_cdevsw, &cmaj); if (error) return error; error = config_init_component(cfdriver_ioconf_dtv, cfattach_ioconf_dtv, cfdata_ioconf_dtv); if (error) devsw_detach(NULL, &dtv_cdevsw); return error; #else return 0; #endif case MODULE_CMD_FINI: #ifdef _MODULE error = config_fini_component(cfdriver_ioconf_dtv, cfattach_ioconf_dtv, cfdata_ioconf_dtv); if (error == 0) devsw_detach(NULL, &dtv_cdevsw); return error; #else return 0; #endif default: return ENOTTY; } } static int dtvopen(dev_t dev, int flags, int mode, lwp_t *l) { struct dtv_softc *sc; struct dtv_ts *ts; int error; if ((sc = device_lookup_private(&dtv_cd, DTVUNIT(dev))) == NULL) return ENXIO; if (sc->sc_dying == true) return ENODEV; ts = &sc->sc_ts; mutex_enter(&sc->sc_lock); if (sc->sc_open == 0) { error = dtv_device_open(sc, flags); if (error) return error; sc->sc_bufsize = DTV_DEFAULT_BUFSIZE; sc->sc_bufsize_chg = true; memset(ts->ts_pidfilter, 0, sizeof(ts->ts_pidfilter)); } ++sc->sc_open; mutex_exit(&sc->sc_lock); if (ISDTVDEMUX(dev)) return dtv_demux_open(sc, flags, mode, l); return 0; } static int dtvclose(dev_t dev, int flags, int mode, lwp_t *l) { struct dtv_softc *sc; if ((sc = device_lookup_private(&dtv_cd, DTVUNIT(dev))) == NULL) return ENXIO; dtv_common_close(sc); return 0; } static int dtvread(dev_t dev, struct uio *uio, int flags) { struct dtv_softc *sc; if ((sc = device_lookup_private(&dtv_cd, DTVUNIT(dev))) == NULL) return ENXIO; if (ISDTVDVR(dev)) return dtv_buffer_read(sc, uio, flags); return ENXIO; } static int dtvioctl(dev_t dev, u_long cmd, void *ptr, int flags, lwp_t *l) { struct dtv_softc *sc; if ((sc = device_lookup_private(&dtv_cd, DTVUNIT(dev))) == NULL) return ENXIO; if (ISDTVFRONTEND(dev)) { return dtv_frontend_ioctl(sc, cmd, ptr, flags); } return EINVAL; } static int dtvpoll(dev_t dev, int events, lwp_t *l) { struct dtv_softc *sc; if ((sc = device_lookup_private(&dtv_cd, DTVUNIT(dev))) == NULL) return POLLERR; if (ISDTVFRONTEND(dev)) { return POLLPRI|POLLIN; /* XXX event */ } else if (ISDTVDVR(dev)) { return dtv_buffer_poll(sc, events, l); } return POLLERR; } void dtv_common_close(struct dtv_softc *sc) { mutex_enter(&sc->sc_lock); KASSERT(sc->sc_open > 0); --sc->sc_open; if (sc->sc_open == 0) { dtv_device_close(sc); dtv_buffer_destroy(sc); } mutex_exit(&sc->sc_lock); }