linux/drivers/media/dvb-frontends/tda18271c2dd.c

// SPDX-License-Identifier: GPL-2.0-only
/*
 * tda18271c2dd: Driver for the TDA18271C2 tuner
 *
 * Copyright (C) 2010 Digital Devices GmbH
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/firmware.h>
#include <linux/i2c.h>
#include <asm/div64.h>

#include <media/dvb_frontend.h>
#include "tda18271c2dd.h"

/* Max transfer size done by I2C transfer functions */
#define MAX_XFER_SIZE …

struct SStandardParam { … };

struct SMap { … };

struct SMapI { … };

struct SMap2 { … };

struct SRFBandMap { … };

enum ERegister { … };

struct tda_state { … };

static int PowerScan(struct tda_state *state,
		     u8 RFBand, u32 RF_in,
		     u32 *pRF_Out, bool *pbcal);

static int i2c_readn(struct i2c_adapter *adapter, u8 adr, u8 *data, int len)
{ … }

static int i2c_write(struct i2c_adapter *adap, u8 adr, u8 *data, int len)
{ … }

static int WriteRegs(struct tda_state *state,
		     u8 SubAddr, u8 *Regs, u16 nRegs)
{ … }

static int WriteReg(struct tda_state *state, u8 SubAddr, u8 Reg)
{ … }

static int Read(struct tda_state *state, u8 * Regs)
{ … }

static int ReadExtented(struct tda_state *state, u8 * Regs)
{ … }

static int UpdateRegs(struct tda_state *state, u8 RegFrom, u8 RegTo)
{ … }
static int UpdateReg(struct tda_state *state, u8 Reg)
{ … }

#include "tda18271c2dd_maps.h"

static void reset(struct tda_state *state)
{ … }

static bool SearchMap1(const struct SMap map[], u32 frequency, u8 *param)
{ … }

static bool SearchMap2(const struct SMapI map[], u32 frequency, s32 *param)
{ … }

static bool SearchMap3(const struct SMap2 map[], u32 frequency, u8 *param1,
		       u8 *param2)
{ … }

static bool SearchMap4(const struct SRFBandMap map[], u32 frequency, u8 *rfband)
{ … }

static int ThermometerRead(struct tda_state *state, u8 *pTM_Value)
{ … }

static int StandBy(struct tda_state *state)
{ … }

static int CalcMainPLL(struct tda_state *state, u32 freq)
{ … }

static int CalcCalPLL(struct tda_state *state, u32 freq)
{ … }

static int CalibrateRF(struct tda_state *state,
		       u8 RFBand, u32 freq, s32 *pCprog)
{ … }

static int RFTrackingFiltersInit(struct tda_state *state,
				 u8 RFBand)
{ … }

static int PowerScan(struct tda_state *state,
		     u8 RFBand, u32 RF_in, u32 *pRF_Out, bool *pbcal)
{ … }

static int PowerScanInit(struct tda_state *state)
{ … }

static int CalcRFFilterCurve(struct tda_state *state)
{ … }

static int FixedContentsI2CUpdate(struct tda_state *state)
{ … }

static int InitCal(struct tda_state *state)
{
	int status = 0;

	do {
		status = FixedContentsI2CUpdate(state);
		if (status < 0)
			break;
		status = CalcRFFilterCurve(state);
		if (status < 0)
			break;
		status = StandBy(state);
		if (status < 0)
			break;
		/* m_bInitDone = true; */
	} while (0);
	return status;
};

static int RFTrackingFiltersCorrection(struct tda_state *state,
				       u32 Frequency)
{ … }

static int ChannelConfiguration(struct tda_state *state,
				u32 Frequency, int Standard)
{ … }

static int sleep(struct dvb_frontend *fe)
{ … }

static int init(struct dvb_frontend *fe)
{ … }

static void release(struct dvb_frontend *fe)
{ … }


static int set_params(struct dvb_frontend *fe)
{ … }

#if 0
static int GetSignalStrength(s32 *pSignalStrength, u32 RFAgc, u32 IFAgc)
{
	if (IFAgc < 500) {
		/* Scale this from 0 to 50000 */
		*pSignalStrength = IFAgc * 100;
	} else {
		/* Scale range 500-1500 to 50000-80000 */
		*pSignalStrength = 50000 + (IFAgc - 500) * 30;
	}

	return 0;
}
#endif

static int get_if_frequency(struct dvb_frontend *fe, u32 *frequency)
{ … }

static int get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth)
{ … }


static const struct dvb_tuner_ops tuner_ops = …;

struct dvb_frontend *tda18271c2dd_attach(struct dvb_frontend *fe,
					 struct i2c_adapter *i2c, u8 adr)
{ … }
EXPORT_SYMBOL_GPL(…);

MODULE_DESCRIPTION(…) …;
MODULE_AUTHOR(…) …;
MODULE_LICENSE(…) …;