/* $NetBSD: emdtv_dtv.c,v 1.17 2022/03/29 09:08:44 riastradh Exp $ */

/*-
* Copyright (c) 2008, 2011 Jared D. McNeill <[email protected]>
* 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 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 <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: emdtv_dtv.c,v 1.17 2022/03/29 09:08:44 riastradh Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/lwp.h>
#include <sys/conf.h>

#include <dev/usb/usb.h>
#include <dev/usb/usbdi.h>
#include <dev/usb/usbdi_util.h>
#include <dev/usb/usbdivar.h>
#include <dev/usb/usbdevs.h>

#include <dev/i2c/i2cvar.h>

#include <dev/usb/emdtvvar.h>
#include <dev/usb/emdtvreg.h>

static void             emdtv_dtv_get_devinfo(void *,
                           struct dvb_frontend_info *);
static int              emdtv_dtv_open(void *, int);
static void             emdtv_dtv_close(void *);
static int              emdtv_dtv_set_tuner(void *,
                           const struct dvb_frontend_parameters *);
static fe_status_t      emdtv_dtv_get_status(void *);
static uint16_t         emdtv_dtv_get_signal_strength(void *);
static uint16_t         emdtv_dtv_get_snr(void *);
static int              emdtv_dtv_start_transfer(void *,
                           void (*)(void *, const struct dtv_payload *),
                           void *);
static int              emdtv_dtv_stop_transfer(void *);

static int              emdtv_dtv_tuner_reset(void *);

static void             emdtv_dtv_isoc_startall(struct emdtv_softc *);
static int              emdtv_dtv_isoc_start(struct emdtv_softc *,
                           struct emdtv_isoc_xfer *);
static void             emdtv_dtv_isoc(struct usbd_xfer *, void *,
                           usbd_status);

static const struct dtv_hw_if emdtv_dtv_if = {
       .get_devinfo = emdtv_dtv_get_devinfo,
       .open = emdtv_dtv_open,
       .close = emdtv_dtv_close,
       .set_tuner = emdtv_dtv_set_tuner,
       .get_status = emdtv_dtv_get_status,
       .get_signal_strength = emdtv_dtv_get_signal_strength,
       .get_snr = emdtv_dtv_get_snr,
       .start_transfer = emdtv_dtv_start_transfer,
       .stop_transfer = emdtv_dtv_stop_transfer,
};

void
emdtv_dtv_attach(struct emdtv_softc *sc)
{
       usb_endpoint_descriptor_t *ed;
       usbd_status status;
       int i;

       for (i = 0; i < EMDTV_NXFERS; i++) {
               sc->sc_ix[i].ix_altix = (i & 1) ?
                   &sc->sc_ix[i - 1] : &sc->sc_ix[i + 1];
               sc->sc_ix[i].ix_sc = sc;
       }

       ed = usbd_interface2endpoint_descriptor(sc->sc_iface, 3);
       if (ed == NULL) {
               aprint_error_dev(sc->sc_dev, "couldn't find endpoint 3\n");
               return;
       }
       sc->sc_isoc_maxpacketsize = UGETW(ed->wMaxPacketSize);
       sc->sc_isoc_buflen = sc->sc_isoc_maxpacketsize * EMDTV_NFRAMES;

       aprint_debug_dev(sc->sc_dev, "calling usbd_open_pipe, ep 0x%02x\n",
           ed->bEndpointAddress);
       status = usbd_open_pipe(sc->sc_iface,
           ed->bEndpointAddress, USBD_EXCLUSIVE_USE|USBD_MPSAFE,
           &sc->sc_isoc_pipe);
       if (status != USBD_NORMAL_COMPLETION) {
               aprint_error_dev(sc->sc_dev, "couldn't open isoc pipe\n");
               usbd_set_interface(sc->sc_iface, 0);
               return;
       }

       emdtv_write_1(sc, UR_GET_STATUS, 0x48, 0x00);
       emdtv_write_1(sc, UR_GET_STATUS, 0x12, 0x77);
       usbd_delay_ms(sc->sc_udev, 6);

       emdtv_gpio_ctl(sc, EMDTV_GPIO_ANALOG_ON, false);
       emdtv_gpio_ctl(sc, EMDTV_GPIO_TS1_ON, true);
       emdtv_gpio_ctl(sc, EMDTV_GPIO_TUNER1_ON, true);
       emdtv_gpio_ctl(sc, EMDTV_GPIO_DEMOD1_RESET, true);
       usbd_delay_ms(sc->sc_udev, 100);

       emdtv_dtv_rescan(sc, NULL, NULL);
}

static void
emdtv_dtv_free_xfers(struct emdtv_softc *sc)
{

       for (size_t i = 0; i < EMDTV_NXFERS; i++)
               if (sc->sc_ix[i].ix_xfer) {
                       usbd_destroy_xfer(sc->sc_ix[i].ix_xfer);
                       sc->sc_ix[i].ix_xfer = NULL;
                       sc->sc_ix[i].ix_buf = NULL;
               }

       return;
}

void
emdtv_dtv_detach(struct emdtv_softc *sc, int flags)
{

       sc->sc_streaming = false;

       if (sc->sc_xc3028)
               xc3028_close(sc->sc_xc3028);
       if (sc->sc_lg3303)
               lg3303_close(sc->sc_lg3303);

       if (sc->sc_isoc_pipe) {
               usbd_abort_pipe(sc->sc_isoc_pipe);
               emdtv_dtv_free_xfers(sc);
               usbd_close_pipe(sc->sc_isoc_pipe);
               sc->sc_isoc_pipe = NULL;
       }
}

void
emdtv_dtv_rescan(struct emdtv_softc *sc, const char *ifattr, const int *locs)
{
       struct dtv_attach_args daa;

       daa.hw = &emdtv_dtv_if;
       daa.priv = sc;

       if (ifattr_match(ifattr, "dtvbus") && sc->sc_dtvdev == NULL)
               sc->sc_dtvdev = config_found(sc->sc_dev, &daa, dtv_print,
                   CFARGS(.iattr = "dtvbus"));
}

static void
emdtv_dtv_get_devinfo(void *priv, struct dvb_frontend_info *info)
{
       struct emdtv_softc *sc = priv;

       memset(info, 0, sizeof(*info));
       strlcpy(info->name, sc->sc_board->eb_name, sizeof(info->name));
       info->type = FE_ATSC;
       info->frequency_min = 54000000;
       info->frequency_max = 858000000;
       info->frequency_stepsize = 62500;
       info->caps = FE_CAN_8VSB;
}

static int
emdtv_dtv_open(void *priv, int flags)
{
       struct emdtv_softc *sc = priv;

       if (sc->sc_dying)
               return ENXIO;

       aprint_debug_dev(sc->sc_dev, "allocating isoc xfers (pktsz %d)\n",
           sc->sc_isoc_maxpacketsize);

       for (size_t i = 0; i < EMDTV_NXFERS; i++) {
               int error = usbd_create_xfer(sc->sc_isoc_pipe,
                   sc->sc_isoc_buflen, USBD_SHORT_XFER_OK, EMDTV_NFRAMES,
                   &sc->sc_ix[i].ix_xfer);
               if (error)
                       return error;
               sc->sc_ix[i].ix_buf = usbd_get_buffer(sc->sc_ix[i].ix_xfer);
               aprint_debug_dev(sc->sc_dev, "  ix[%zu] xfer %p buf %p\n",
                   i, sc->sc_ix[i].ix_xfer, sc->sc_ix[i].ix_buf);
       }

       switch (sc->sc_board->eb_tuner) {
       case EMDTV_TUNER_XC3028:
               if (sc->sc_xc3028 == NULL) {
                       sc->sc_xc3028 = xc3028_open(sc->sc_dev,
                           &sc->sc_i2c, 0x61 << 1, emdtv_dtv_tuner_reset, sc,
                           XC3028);
               }
               if (sc->sc_xc3028 == NULL) {
                       aprint_error_dev(sc->sc_dev, "couldn't open xc3028\n");
                       return ENXIO;
               }
               break;
       case EMDTV_TUNER_XC3028L:
               if (sc->sc_xc3028 == NULL) {
                       sc->sc_xc3028 = xc3028_open(sc->sc_dev,
                           &sc->sc_i2c, 0x61 << 1, emdtv_dtv_tuner_reset, sc,
                           XC3028L);
               }
               if (sc->sc_xc3028 == NULL) {
                       aprint_error_dev(sc->sc_dev, "couldn't open xc3028l\n");
                       return ENXIO;
               }
               break;
       default:
               aprint_error_dev(sc->sc_dev, "unsupported tuner (%d)\n",
                   sc->sc_board->eb_tuner);
               return EIO;
       }

       switch (sc->sc_board->eb_demod) {
       case EMDTV_DEMOD_LG3303:
               if (sc->sc_lg3303 == NULL) {
                       sc->sc_lg3303 = lg3303_open(sc->sc_dev,
                           &sc->sc_i2c, 0x1c, 0);
               }
               if (sc->sc_lg3303 == NULL) {
                       aprint_error_dev(sc->sc_dev, "couldn't open lg3303\n");
                       return ENXIO;
               }
               break;
       default:
               aprint_error_dev(sc->sc_dev, "unsupported demod (%d)\n",
                   sc->sc_board->eb_demod);
               return EIO;
       }

       return 0;
}

static void
emdtv_dtv_close(void *priv)
{
       struct emdtv_softc *sc = priv;

       emdtv_dtv_free_xfers(sc);
}

static int
emdtv_dtv_set_tuner(void *priv, const struct dvb_frontend_parameters *params)
{
       struct emdtv_softc *sc = priv;
       int error;

       /* Setup demod */
       error = ENXIO;
       if (sc->sc_lg3303)
               error = lg3303_set_modulation(sc->sc_lg3303,
                   params->u.vsb.modulation);
       if (error)
               return error;

       /* Setup tuner */
       error = ENXIO;
       if (sc->sc_xc3028)
               error = xc3028_tune_dtv(sc->sc_xc3028, params);

       return error;
}

static fe_status_t
emdtv_dtv_get_status(void *priv)
{
       struct emdtv_softc *sc = priv;

       if (sc->sc_lg3303)
               return lg3303_get_dtv_status(sc->sc_lg3303);

       return 0;
}

uint16_t
emdtv_dtv_get_signal_strength(void *priv)
{
       struct emdtv_softc *sc = priv;

       if (sc->sc_lg3303)
               return lg3303_get_signal_strength(sc->sc_lg3303);

       return 0;
}

uint16_t
emdtv_dtv_get_snr(void *priv)
{
       struct emdtv_softc *sc = priv;

       if (sc->sc_lg3303)
               return lg3303_get_snr(sc->sc_lg3303);

       return 0;
}

static int
emdtv_dtv_start_transfer(void *priv,
   void (*cb)(void *, const struct dtv_payload *), void *arg)
{
       struct emdtv_softc *sc = priv;
       int s;

       s = splusb();

       sc->sc_streaming = true;
       sc->sc_dtvsubmitcb = cb;
       sc->sc_dtvsubmitarg = arg;

       aprint_debug_dev(sc->sc_dev, "starting isoc transactions\n");

       emdtv_dtv_isoc_startall(sc);
       splx(s);

       return 0;
}

static int
emdtv_dtv_stop_transfer(void *priv)
{
       struct emdtv_softc *sc = priv;

       aprint_debug_dev(sc->sc_dev, "stopping stream\n");

       sc->sc_streaming = false;

       KERNEL_LOCK(1, curlwp);
       if (sc->sc_isoc_pipe != NULL)
               usbd_abort_pipe(sc->sc_isoc_pipe);
       KERNEL_UNLOCK_ONE(curlwp);

       sc->sc_dtvsubmitcb = NULL;
       sc->sc_dtvsubmitarg = NULL;

       return 0;
}

static void
emdtv_dtv_isoc_startall(struct emdtv_softc *sc)
{
       int i;

       if (sc->sc_streaming == false || sc->sc_dying == true)
               return;

       for (i = 0; i < EMDTV_NXFERS; i += 2)
               emdtv_dtv_isoc_start(sc, &sc->sc_ix[i]);
}

static int
emdtv_dtv_isoc_start(struct emdtv_softc *sc, struct emdtv_isoc_xfer *ix)
{
       int i;

       if (sc->sc_isoc_pipe == NULL)
               return EIO;

       for (i = 0; i < EMDTV_NFRAMES; i++)
               ix->ix_frlengths[i] = sc->sc_isoc_maxpacketsize;

       usbd_setup_isoc_xfer(ix->ix_xfer,
                            ix,
                            ix->ix_frlengths,
                            EMDTV_NFRAMES,
                            USBD_SHORT_XFER_OK,
                            emdtv_dtv_isoc);

       KERNEL_LOCK(1, curlwp);
       usbd_transfer(ix->ix_xfer);
       KERNEL_UNLOCK_ONE(curlwp);

       return 0;
}

static void
emdtv_dtv_isoc(struct usbd_xfer *xfer, void * priv,
   usbd_status err)
{
       struct emdtv_isoc_xfer *ix = priv;
       struct emdtv_softc *sc = ix->ix_sc;
       struct dtv_payload payload;
       struct usbd_pipe *isoc = sc->sc_isoc_pipe;
       uint32_t len;
       uint8_t *buf;
       int i;

       KASSERT(xfer == ix->ix_xfer);

       if (sc->sc_dying || sc->sc_dtvsubmitcb == NULL)
               return;

       if (err) {
               if (err == USBD_STALLED) {
                       usbd_clear_endpoint_stall_async(isoc);
                       goto resched;
               }
               return;
       }

       usbd_get_xfer_status(xfer, NULL, NULL, &len, NULL);

       if (len == 0)
               goto resched;

       buf = usbd_get_buffer(xfer);
       if (buf == NULL)
               goto resched;

       for (i = 0; i < EMDTV_NFRAMES; i++, buf += sc->sc_isoc_maxpacketsize) {
               if (ix->ix_frlengths[i] == 0)
                       continue;
               payload.data = buf;
               payload.size = ix->ix_frlengths[i];
               sc->sc_dtvsubmitcb(sc->sc_dtvsubmitarg, &payload);
       }

resched:
       emdtv_dtv_isoc_start(sc, ix->ix_altix);
}

static int
emdtv_dtv_tuner_reset(void *opaque)
{
       struct emdtv_softc *sc = opaque;
       emdtv_gpio_ctl(sc, EMDTV_GPIO_TUNER1_RESET, true);
       return 0;
}

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.