/* $NetBSD: lg3303.c,v 1.10 2017/06/01 02:45:10 chs Exp $ */

/*-
* Copyright 2007 Jason Harmening
* 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 AUTHOR 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 AUTHOR 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/param.h>
__KERNEL_RCSID(0, "$NetBSD: lg3303.c,v 1.10 2017/06/01 02:45:10 chs Exp $");

#include <sys/types.h>
#include <sys/kmem.h>
#include <sys/module.h>
#include <sys/bitops.h>

#include <dev/i2c/i2cvar.h>
#include <dev/i2c/lg3303var.h>
#include <dev/dtv/dtvif.h>
#include <dev/dtv/dtv_math.h>

#define REG_TOP_CONTROL         0x00
#define REG_IRQ_MASK            0x01
#define REG_IRQ_STATUS          0x02
#define REG_VSB_CARRIER_FREQ0   0x16
#define REG_VSB_CARRIER_FREQ1   0x17
#define REG_VSB_CARRIER_FREQ2   0x18
#define REG_VSB_CARRIER_FREQ3   0x19
#define REG_CARRIER_MSEQAM1     0x1a
#define REG_CARRIER_MSEQAM2     0x1b
#define REG_CARRIER_LOCK        0x1c
#define REG_TIMING_RECOVERY     0x1d
#define REG_AGC_DELAY0          0x2a
#define REG_AGC_DELAY1          0x2b
#define REG_AGC_DELAY2          0x2c
#define REG_AGC_RF_BANDWIDTH0   0x2d
#define REG_AGC_RF_BANDWIDTH1   0x2e
#define REG_AGC_RF_BANDWIDTH2   0x2f
#define REG_AGC_LOOP_BANDWIDTH0 0x30
#define REG_AGC_LOOP_BANDWIDTH1 0x31
#define REG_AGC_FUNC_CTRL1      0x32
#define REG_AGC_FUNC_CTRL2      0x33
#define REG_AGC_FUNC_CTRL3      0x34
#define REG_AGC_RFIF_ACC0       0x39
#define REG_AGC_RFIF_ACC1       0x3a
#define REG_AGC_RFIF_ACC2       0x3b
#define REG_AGC_STATUS          0x3f
#define REG_SYNC_STATUS_VSB     0x43
#define REG_DEMUX_CONTROL       0x66
#define REG_EQPH_ERR0           0x6e
#define REG_EQ_ERR1             0x6f
#define REG_EQ_ERR2             0x70
#define REG_PH_ERR1             0x71
#define REG_PH_ERR2             0x72
#define REG_PACKET_ERR_COUNTER1 0x8b
#define REG_PACKET_ERR_COUNTER2 0x8c

#define LG3303_DEFAULT_DELAY 250000

static int      lg3303_reset(struct lg3303 *);
static int      lg3303_init(struct lg3303 *);

struct lg3303 *
lg3303_open(device_t parent, i2c_tag_t i2c, i2c_addr_t addr, int flags)
{
       struct lg3303 *lg;

       lg = kmem_alloc(sizeof(*lg), KM_SLEEP);
       lg->parent = parent;
       lg->i2c = i2c;
       lg->i2c_addr = addr;
       lg->current_modulation = -1;
       lg->flags = flags;

       if (lg3303_init(lg) != 0) {
               kmem_free(lg, sizeof(*lg));
               return NULL;
       }

       device_printf(lg->parent, "lg3303: found @ 0x%02x\n", addr);

       return lg;
}

void
lg3303_close(struct lg3303 *lg)
{
       kmem_free(lg, sizeof(*lg));
}

static int
lg3303_write(struct lg3303 *lg, uint8_t *buf, size_t len)
{
       unsigned int i;
       uint8_t *p = buf;
       int error;

       for (i = 0; i < len - 1; i += 2) {
               error = iic_exec(lg->i2c, I2C_OP_WRITE_WITH_STOP, lg->i2c_addr,
                   p, 2, NULL, 0, 0);
               if (error)
                       return error;
               p += 2;
       }

       return 0;
}

static int
lg3303_read(struct lg3303 *lg, uint8_t reg, uint8_t *buf, size_t len)
{
       int error;

       error = iic_exec(lg->i2c, I2C_OP_WRITE, lg->i2c_addr,
           &reg, sizeof(reg), NULL, 0, 0);
       if (error)
               return error;
       return iic_exec(lg->i2c, I2C_OP_READ, lg->i2c_addr,
           NULL, 0, buf, len, 0);
}

static int
lg3303_reset(struct lg3303 *lg)
{
       uint8_t buffer[] = {REG_IRQ_STATUS, 0x00};
       int error = lg3303_write(lg, buffer, 2);
       if (error == 0) {
               buffer[1] = 0x01;
               error = lg3303_write(lg, buffer, 2);
       }
       return error;
}

static int
lg3303_init(struct lg3303 *lg)
{
       //static uint8_t init_data[] = {0x4c, 0x14, 0x87, 0xf3};
       static uint8_t init_data[] = {0x4c, 0x14};
       size_t len;
       int error;

#if notyet
       if (clock_polarity == DVB_IFC_POS_POL)
               len = 4;
       else
#endif
       len = 2;

       error = lg3303_write(lg, init_data, len);
       if (error == 0)
               lg3303_reset(lg);

       return error;
}

int
lg3303_set_modulation(struct lg3303 *lg, fe_modulation_t modulation)
{
       int error;
       static uint8_t vsb_data[] = {
               0x04, 0x00,
               0x0d, 0x40,
               0x0e, 0x87,
               0x0f, 0x8e,
               0x10, 0x01,
               0x47, 0x8b
       };
       static uint8_t qam_data[] = {
               0x04, 0x00,
               0x0d, 0x00,
               0x0e, 0x00,
               0x0f, 0x00,
               0x10, 0x00,
               0x51, 0x63,
               0x47, 0x66,
               0x48, 0x66,
               0x4d, 0x1a,
               0x49, 0x08,
               0x4a, 0x9b
       };
       uint8_t top_ctrl[] = {REG_TOP_CONTROL, 0x00};

       error = lg3303_reset(lg);
       if (error)
               return error;

       if (lg->flags & LG3303_CFG_SERIAL_INPUT)
               top_ctrl[1] = 0x40;

       switch (modulation) {
       case VSB_8:
               top_ctrl[1] |= 0x03;
               error = lg3303_write(lg, vsb_data, sizeof(vsb_data));
               if (error)
                       return error;
               break;
       case QAM_256:
               top_ctrl[1] |= 0x01;
               /* FALLTHROUGH */
       case QAM_64:
               error = lg3303_write(lg, qam_data, sizeof(qam_data));
               if (error)
                       return error;
               break;
       default:
               device_printf(lg->parent,
                   "lg3303: unsupported modulation type (%d)\n",
                   modulation);
               return EINVAL;
       }
       error = lg3303_write(lg, top_ctrl, sizeof(top_ctrl));
       if (error)
               return error;
       lg->current_modulation = modulation;
       lg3303_reset(lg);

       return error;
}

fe_status_t
lg3303_get_dtv_status(struct lg3303 *lg)
{
       uint8_t reg = 0, value = 0x00;
       fe_status_t festatus = 0;
       int error = 0;

       error = lg3303_read(lg, 0x58, &value, sizeof(value));
       if (error)
               return 0;

       if (value & 0x01)
               festatus |= FE_HAS_SIGNAL;

       error = lg3303_read(lg, REG_CARRIER_LOCK, &value, sizeof(value));
       if (error)
               return 0;

       switch (lg->current_modulation) {
       case VSB_8:
               if (value & 0x80)
                       festatus |= FE_HAS_CARRIER;
               reg = 0x38;
               break;
       case QAM_64:
       case QAM_256:
               if ((value & 0x07) == 0x07)
                       festatus |= FE_HAS_CARRIER;
               reg = 0x8a;
               break;
       default:
               device_printf(lg->parent,
                   "lg3303: unsupported modulation type (%d)\n",
                   lg->current_modulation);
               return 0;
       }

       if ((festatus & FE_HAS_CARRIER) == 0)
               return festatus;

       error = lg3303_read(lg, reg, &value, sizeof(value));
       if (!error && (value & 0x01))
               festatus |= FE_HAS_LOCK;

       if (festatus & FE_HAS_LOCK)
               festatus |= (FE_HAS_SYNC | FE_HAS_VITERBI);

       return festatus;
}

uint16_t
lg3303_get_snr(struct lg3303 *lg)
{
       int64_t noise, snr_const;
       uint8_t buffer[5];
       int64_t snr;
       int error;

       switch (lg->current_modulation) {
       case VSB_8:
               error = lg3303_read(lg, REG_EQPH_ERR0, buffer, sizeof(buffer));
               if (error)
                       return 0;
               noise = ((buffer[0] & 7) << 16) | (buffer[3] << 8) | buffer[4];
               snr_const = 73957994;   /* log10(2560) * pow(2,24) */
               break;
       case QAM_64:
       case QAM_256:
               error = lg3303_read(lg, REG_CARRIER_MSEQAM1, buffer, 2);
               if (error)
                       return 0;
               noise = (buffer[0] << 8) | buffer[1];
               if (lg->current_modulation == QAM_64)
                       snr_const = 97939837;   /* log10(688128) * pow(2,24) */
               else
                       snr_const = 98026066;   /* log10(696320) * pow(2,24) */
               break;
       default:
               device_printf(lg->parent,
                   "lg3303: unsupported modulation type (%d)\n",
                   lg->current_modulation);
               return 0;
       }

       if (noise == 0)
               return 0;
       snr = dtv_intlog10(noise);
       if (snr > snr_const)
               return 0;
       return (10 * (snr_const - snr)) >> 16;
}

uint16_t
lg3303_get_signal_strength(struct lg3303 *lg)
{
       return ((uint32_t)lg3303_get_snr(lg) << 16) / 8960;
}

uint32_t
lg3303_get_ucblocks(struct lg3303 *lg)
{
       uint8_t buffer[2];
       int error;

       error = lg3303_read(lg, REG_PACKET_ERR_COUNTER1, buffer, sizeof(buffer));
       if (error)
               return 0;

       return (buffer[0] << 8) | buffer[1];
}

MODULE(MODULE_CLASS_DRIVER, lg3303, "i2cexec,dtv_math");

static int
lg3303_modcmd(modcmd_t cmd, void *opaque)
{
       if (cmd == MODULE_CMD_INIT || cmd == MODULE_CMD_FINI)
               return 0;
       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.