/* $NetBSD: emdtv.c,v 1.18 2022/06/26 22:49:09 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.c,v 1.18 2022/06/26 22:49:09 riastradh Exp $");

#include <sys/param.h>
#include <sys/systm.h>
#include <sys/device.h>
#include <sys/lwp.h>
#include <sys/module.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/usb/emdtvvar.h>
#include <dev/usb/emdtvreg.h>

static int      emdtv_match(device_t, cfdata_t, void *);
static void     emdtv_attach(device_t, device_t, void *);
static int      emdtv_detach(device_t, int);
static int      emdtv_rescan(device_t, const char *, const int *);
static void     emdtv_childdet(device_t, device_t);
static int      emdtv_activate(device_t, enum devact);

static bool     emdtv_read_eeprom(struct emdtv_softc *);
static void     emdtv_board_setup(struct emdtv_softc *);

static void     emdtv_default_board_init(struct emdtv_softc *);

CFATTACH_DECL2_NEW(emdtv, sizeof(struct emdtv_softc),
   emdtv_match, emdtv_attach, emdtv_detach, emdtv_activate,
   emdtv_rescan, emdtv_childdet);

static const struct usb_devno emdtv_devices[] = {
       { USB_VENDOR_AMD,       USB_PRODUCT_AMD_TV_WONDER_600_USB },
       { USB_VENDOR_PINNACLE,  USB_PRODUCT_PINNACLE_PCTV800E },
};

int emdtv_debug_regs = 0;

static int
emdtv_match(device_t parent, cfdata_t match, void *opaque)
{
       struct usb_attach_arg *uaa = opaque;

       return usb_lookup(emdtv_devices, uaa->uaa_vendor, uaa->uaa_product) != NULL ?
           UMATCH_VENDOR_PRODUCT : UMATCH_NONE;
}

static void
emdtv_attach(device_t parent, device_t self, void *opaque)
{
       struct emdtv_softc *sc = device_private(self);
       struct usb_attach_arg *uaa = opaque;
       struct usbd_device *dev = uaa->uaa_device;
       usbd_status status;
       char *devinfo;

       devinfo = usbd_devinfo_alloc(dev, 0);
       aprint_naive("\n");
       aprint_normal(": %s\n", devinfo);
       usbd_devinfo_free(devinfo);

       sc->sc_dev = self;
       sc->sc_udev = dev;

       sc->sc_vendor = uaa->uaa_vendor;
       sc->sc_product = uaa->uaa_product;

       emdtv_i2c_attach(sc);

       emdtv_read_eeprom(sc);

       sc->sc_board = emdtv_board_lookup(sc->sc_vendor, sc->sc_product);
       if (sc->sc_board == NULL) {
               aprint_error_dev(sc->sc_dev,
                   "unsupported board 0x%04x:0x%04x\n",
                   sc->sc_vendor, sc->sc_product);
               sc->sc_dying = true;
               return;
       }

       emdtv_write_1(sc, 0x02, 0xa0, 0x23);
       if (emdtv_read_1(sc, UR_GET_STATUS, 0x05) != 0) {
               (void)emdtv_read_1(sc, 0x02, 0xa0);
               if (emdtv_read_1(sc, 0x02, 0xa0) & 0x08)
                       aprint_debug_dev(sc->sc_dev,
                           "board requires manual gpio configuration\n");
       }

       emdtv_board_setup(sc);

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

       status = usbd_set_config_no(sc->sc_udev, 1, 1);
       if (status != USBD_NORMAL_COMPLETION) {
               aprint_error_dev(sc->sc_dev, "failed to set configuration"
                   ", err=%s\n", usbd_errstr(status));
               return;
       }

       status = usbd_device2interface_handle(sc->sc_udev, 0, &sc->sc_iface);
       if (status != USBD_NORMAL_COMPLETION) {
               aprint_error_dev(sc->sc_dev, "couldn't find iface handle\n");
               return;
       }

       status = usbd_set_interface(sc->sc_iface, 1);
       if (status != USBD_NORMAL_COMPLETION) {
               aprint_error_dev(sc->sc_dev, "couldn't set interface\n");
               return;
       }

       emdtv_dtv_attach(sc);
       emdtv_ir_attach(sc);
       sc->sc_subdevs_attached = true;
}

static int
emdtv_detach(device_t self, int flags)
{
       struct emdtv_softc *sc = device_private(self);
       usbd_status status;
       int error;

       sc->sc_dying = true;

       error = config_detach_children(self, flags);
       if (error)
               return error;

       if (sc->sc_subdevs_attached) {
               emdtv_ir_detach(sc, flags);
               emdtv_dtv_detach(sc, flags);
       }

       if (sc->sc_iface != NULL) {
               status = usbd_set_interface(sc->sc_iface, 0);
               if (status != USBD_NORMAL_COMPLETION)
                       aprint_error_dev(sc->sc_dev,
                           "couldn't stop stream: %s\n", usbd_errstr(status));
       }

       emdtv_i2c_detach(sc, flags);

       return 0;
}

int
emdtv_activate(device_t self, enum devact act)
{
       struct emdtv_softc *sc = device_private(self);

       switch (act) {
       case DVACT_DEACTIVATE:
               sc->sc_dying = true;
               break;
       }

       return 0;
}

static int
emdtv_rescan(device_t self, const char *ifattr, const int *locs)
{
       struct emdtv_softc *sc = device_private(self);

       emdtv_dtv_rescan(sc, ifattr, locs);

       return 0;
}

static void
emdtv_childdet(device_t self, device_t child)
{
       struct emdtv_softc *sc = device_private(self);

       if (child == sc->sc_cirdev)
               sc->sc_cirdev = NULL;
       if (child == sc->sc_dtvdev)
               sc->sc_dtvdev = NULL;
}

static bool
emdtv_read_eeprom(struct emdtv_softc *sc)
{
       i2c_addr_t ee = EM28XX_I2C_ADDR_EEPROM;
       uint8_t buf, *p = sc->sc_eeprom;
       struct emdtv_eeprom *eeprom = (struct emdtv_eeprom *)sc->sc_eeprom;
       int block, size = sizeof(sc->sc_eeprom);

       if (iic_exec(&sc->sc_i2c, I2C_OP_READ, ee, NULL, 0, NULL, 0, 0))
               return false;
       buf = 0;
       if (iic_exec(&sc->sc_i2c, I2C_OP_WRITE_WITH_STOP, ee, &buf, 1,
           NULL, 0, 0))
               return false;
       while (size > 0) {
               block = uimin(size, 16);
               if (iic_exec(&sc->sc_i2c, I2C_OP_READ, ee, NULL, 0,
                   p, block, 0))
                       return false;
               size -= block;
               p += block;
       }

       aprint_normal_dev(sc->sc_dev,
           "id 0x%08x vendor 0x%04x product 0x%04x\n",
           eeprom->id, eeprom->vendor, eeprom->product);

       sc->sc_vendor = eeprom->vendor;
       sc->sc_product = eeprom->product;

       return true;
}

static void
emdtv_board_setup(struct emdtv_softc *sc)
{
       switch (sc->sc_vendor) {
       case USB_VENDOR_EMPIA:
               switch (sc->sc_product) {
               case USB_PRODUCT_EMPIA_EM2883:
                       emdtv_write_1(sc, UR_GET_STATUS, EM28XX_XCLK_REG, 0x97);
                       emdtv_write_1(sc, UR_GET_STATUS, EM28XX_I2C_CLK_REG,
                           0x40);
                       delay(10000);
                       emdtv_write_1(sc, UR_GET_STATUS, 0x08, 0x2d);
                       delay(10000);
                       break;
               default:
                       aprint_normal_dev(sc->sc_dev,
                           "unknown EMPIA board 0x%04x/0x%04x\n",
                           sc->sc_vendor, sc->sc_product);
                       break;
               }
               break;
       case USB_VENDOR_AMD:
               switch (sc->sc_product) {
               case USB_PRODUCT_AMD_TV_WONDER_600_USB:
                       emdtv_default_board_init(sc);
                       break;
               default:
                       aprint_normal_dev(sc->sc_dev,
                           "unknown AMD board 0x%04x/0x%04x\n",
                           sc->sc_vendor, sc->sc_product);
               }
               break;
       case USB_VENDOR_PINNACLE:
               switch (sc->sc_product) {
               case USB_PRODUCT_PINNACLE_PCTV800E:
                       emdtv_default_board_init(sc);
                       break;
               default:
                       aprint_normal_dev(sc->sc_dev,
                           "unknown Pinnacle board 0x%04x/0x%04x\n",
                           sc->sc_vendor, sc->sc_product);
               }
               break;
       default:
               aprint_normal_dev(sc->sc_dev,
                   "unknown board 0x%04x:0x%04x\n",
                   sc->sc_vendor, sc->sc_product);
               break;
       }
}

/*
* Register read/write
*/
uint8_t
emdtv_read_1(struct emdtv_softc *sc, uint8_t req, uint16_t index)
{
       uint8_t val;
       emdtv_read_multi_1(sc, req, index, &val, 1);
       return val;
}

void
emdtv_write_1(struct emdtv_softc *sc, uint8_t req, uint16_t index, uint8_t val)
{
       emdtv_write_multi_1(sc, req, index, &val, 1);
}

void
emdtv_read_multi_1(struct emdtv_softc *sc, uint8_t req, uint16_t index,
   uint8_t *datap, uint16_t count)
{
       usb_device_request_t request;
       usbd_status status;

       request.bmRequestType = UT_READ_VENDOR_DEVICE;
       request.bRequest = req;
       USETW(request.wValue, 0x0000);
       USETW(request.wIndex, index);
       USETW(request.wLength, count);

       KERNEL_LOCK(1, curlwp);
       status = usbd_do_request(sc->sc_udev, &request, datap);
       KERNEL_UNLOCK_ONE(curlwp);

       if (status != USBD_NORMAL_COMPLETION) {
               aprint_error_dev(sc->sc_dev, "couldn't read %x/%x: %s\n",
                   req, index, usbd_errstr(status));
               memset(datap, 0, count);
       }

       if (emdtv_debug_regs) {
               int i;
               printf("%s [%s] c0 %02x 00 00 %02x 00 01 00 <<<",
                   __func__, status == 0 ? " OK" : "NOK", req, index);
               for (i = 0; status == 0 && i < count; i++)
                       printf(" %02x", datap[i]);
               printf("\n");
       }
}

void
emdtv_write_multi_1(struct emdtv_softc *sc, uint8_t req, uint16_t index,
   const uint8_t *datap, uint16_t count)
{
       usb_device_request_t request;
       usbd_status status;

       request.bmRequestType = UT_WRITE_VENDOR_DEVICE;
       request.bRequest = req;
       USETW(request.wValue, 0x0000);
       USETW(request.wIndex, index);
       USETW(request.wLength, count);

       KERNEL_LOCK(1, curlwp);
       status = usbd_do_request(sc->sc_udev, &request, __UNCONST(datap));
       KERNEL_UNLOCK_ONE(curlwp);

       if (status != USBD_NORMAL_COMPLETION)
               aprint_error_dev(sc->sc_dev, "couldn't read %x/%x: %s\n",
                   req, index, usbd_errstr(status));

       if (emdtv_debug_regs) {
               int i;
               printf("%s [%s] 40 %02x 00 00 %02x 00 %02x 00 >>>",
                   __func__, status == 0 ? " OK" : "NOK",
                   req, index, count);
               for (i = 0; i < count; ++i)
                       printf(" %02x", datap[i]);
               printf("\n");
       }
}

bool
emdtv_gpio_ctl(struct emdtv_softc *sc, emdtv_gpio_reg_t gpioreg, bool onoff)
{
       const struct emdtv_board *eb = sc->sc_board;
       uint16_t gpio_value, reg;
       uint8_t gpio;
       uint8_t eeprom_offset = 0x3c;
       uint8_t val;

       if (sc->sc_board->eb_manual_gpio == false) {
               val = eeprom_offset + gpioreg;
               emdtv_write_1(sc, 0x03, 0xa0, val);
               gpio_value = emdtv_read_1(sc, 0x02, 0xa0);
       } else {
               const struct emdtv_gpio_regs *r = &eb->eb_gpio_regs;
               switch (gpioreg) {
               case EMDTV_GPIO_TS1_ON:
                       gpio_value = r->ts1_on;
                       break;
               case EMDTV_GPIO_ANALOG_ON:
                       gpio_value = r->a_on;
                       break;
               case EMDTV_GPIO_TUNER1_ON:
                       gpio_value = r->t1_on;
                       break;
               case EMDTV_GPIO_TUNER1_RESET:
                       gpio_value = r->t1_reset;
                               break;
               case EMDTV_GPIO_DEMOD1_RESET:
                       gpio_value = r->d1_reset;
                       break;
               default:
                       aprint_error_dev(sc->sc_dev,
                           "unknown gpio reg %d\n", gpioreg);
                       return false;
               }
       }

       if ((gpio_value & 0x80) == 0) {
               aprint_error_dev(sc->sc_dev,
                   "gpio reg %d not enabled\n", gpioreg);
               return false;
       }

       reg = gpio_value & 0x10 ? 0x04 : 0x08;
       gpio = emdtv_read_1(sc, UR_GET_STATUS, reg);
       if ((gpio_value & 0x40) == 0) {
               gpio &= ~((uint8_t)(1 << (gpio_value & 7)));

               if (onoff)
                       gpio |= ((gpio_value >> 5) & 1) << (gpio_value & 7);
               else
                       gpio |= (((gpio_value >> 5) & 1) ^ 1) <<
                           (gpio_value & 7);
               emdtv_write_1(sc, UR_GET_STATUS, reg, gpio);
       } else {
               gpio &= ~((uint8_t)(1 << (gpio_value & 0xf)));

               gpio |= ((gpio_value >> 5) & 1) << (gpio_value & 7);
               emdtv_write_1(sc, UR_GET_STATUS, reg, gpio);
               usbd_delay_ms(sc->sc_udev, 100);

               gpio &= ~((uint8_t)(1 << (gpio_value & 0xf)));
               gpio |= (((gpio_value >> 5) & 1) ^ 1) << (gpio_value & 7);
               emdtv_write_1(sc, UR_GET_STATUS, reg, gpio);
               usbd_delay_ms(sc->sc_udev, 100);
       }

       return true;
}

static void
emdtv_default_board_init(struct emdtv_softc *sc)
{
       emdtv_write_1(sc, UR_GET_STATUS, EM28XX_XCLK_REG, 0x27);
       emdtv_write_1(sc, UR_GET_STATUS, EM28XX_I2C_CLK_REG, 0x40);
       emdtv_write_1(sc, UR_GET_STATUS, 0x08, 0xff);
       emdtv_write_1(sc, UR_GET_STATUS, 0x04, 0x00);
       usbd_delay_ms(sc->sc_udev, 100);
       emdtv_write_1(sc, UR_GET_STATUS, 0x04, 0x08);
       usbd_delay_ms(sc->sc_udev, 100);
       emdtv_write_1(sc, UR_GET_STATUS, 0x08, 0xff);
       usbd_delay_ms(sc->sc_udev, 50);
       emdtv_write_1(sc, UR_GET_STATUS, 0x08, 0x2d);
       usbd_delay_ms(sc->sc_udev, 50);
       emdtv_write_1(sc, UR_GET_STATUS, 0x08, 0x3d);
       //emdtv_write_1(sc, UR_GET_STATUS, 0x0f, 0xa7);
       usbd_delay_ms(sc->sc_udev, 10);
}

MODULE(MODULE_CLASS_DRIVER, emdtv, "cir,lg3303,xc3028");

#ifdef _MODULE
#include "ioconf.c"
#endif

static int
emdtv_modcmd(modcmd_t cmd, void *opaque)
{
       switch (cmd) {
       case MODULE_CMD_INIT:
#ifdef _MODULE
               return config_init_component(cfdriver_ioconf_emdtv,
                   cfattach_ioconf_emdtv, cfdata_ioconf_emdtv);
#else
               return 0;
#endif
       case MODULE_CMD_FINI:
#ifdef _MODULE
               return config_fini_component(cfdriver_ioconf_emdtv,
                   cfattach_ioconf_emdtv, cfdata_ioconf_emdtv);
#else
               return 0;
#endif
       default:
               return ENOTTY;
       }
}

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.