media: dvb: earth-pt1: decompose pt1 driver into sub drivers (b732539e) · Commits · e / devices / android_kernel_fairphone_FP4

drivers/media/pci/pt1/Kconfig

+3 −0

Original line number	Diff line number	Diff line
		config DVB_PT1
		tristate "PT1 cards"
		depends on DVB_CORE && PCI && I2C
		select DVB_TC90522 if MEDIA_SUBDRV_AUTOSELECT
		select DVB_PLL if MEDIA_SUBDRV_AUTOSELECT
		select MEDIA_TUNER_QM1D1B0004 if MEDIA_SUBDRV_AUTOSELECT
		help
		Support for Earthsoft PT1 PCI cards.

drivers/media/pci/pt1/Makefile

+2 −1

Original line number	Diff line number	Diff line
		earth-pt1-objs := pt1.o va1j5jf8007s.o va1j5jf8007t.o
		earth-pt1-objs := pt1.o

		obj-$(CONFIG_DVB_PT1) += earth-pt1.o

		ccflags-y += -Idrivers/media/dvb-frontends
		ccflags-y += -Idrivers/media/tuners

drivers/media/pci/pt1/pt1.c

+222 −107

Original line number	Diff line number	Diff line
		@@ -26,6 +26,8 @@
		#include <linux/kthread.h>
		#include <linux/freezer.h>
		#include <linux/ratelimit.h>
		#include <linux/string.h>
		#include <linux/i2c.h>

		#include <media/dvbdev.h>
		#include <media/dvb_demux.h>
		@@ -33,8 +35,9 @@
		#include <media/dvb_net.h>
		#include <media/dvb_frontend.h>

		#include "va1j5jf8007t.h"
		#include "va1j5jf8007s.h"
		#include "tc90522.h"
		#include "qm1d1b0004.h"
		#include "dvb-pll.h"

		#define DRIVER_NAME "earth-pt1"

		@@ -63,6 +66,11 @@ struct pt1_table {
		struct pt1_buffer bufs[PT1_NR_BUFS];
		};

		enum pt1_fe_clk {
		PT1_FE_CLK_20MHZ, /* PT1 */
		PT1_FE_CLK_25MHZ, /* PT2 */
		};

		#define PT1_NR_ADAPS 4

		struct pt1_adapter;
		@@ -81,6 +89,8 @@ struct pt1 {
		struct mutex lock;
		int power;
		int reset;

		enum pt1_fe_clk fe_clk;
		};

		struct pt1_adapter {
		@@ -97,6 +107,8 @@ struct pt1_adapter {
		int users;
		struct dmxdev dmxdev;
		struct dvb_frontend *fe;
		struct i2c_client *demod_i2c_client;
		struct i2c_client *tuner_i2c_client;
		int (orig_set_voltage)(struct dvb_frontend fe,
		enum fe_sec_voltage voltage);
		int (orig_sleep)(struct dvb_frontend fe);
		@@ -106,6 +118,144 @@ struct pt1_adapter {
		int sleep;
		};

		union pt1_tuner_config {
		struct qm1d1b0004_config qm1d1b0004;
		struct dvb_pll_config tda6651;
		};

		struct pt1_config {
		struct i2c_board_info demod_info;
		struct tc90522_config demod_cfg;

		struct i2c_board_info tuner_info;
		union pt1_tuner_config tuner_cfg;
		};

		static const struct pt1_config pt1_configs[PT1_NR_ADAPS] = {
		{
		.demod_info = {
		I2C_BOARD_INFO(TC90522_I2C_DEV_SAT, 0x1b),
		},
		.tuner_info = {
		I2C_BOARD_INFO("qm1d1b0004", 0x60),
		},
		},
		{
		.demod_info = {
		I2C_BOARD_INFO(TC90522_I2C_DEV_TER, 0x1a),
		},
		.tuner_info = {
		I2C_BOARD_INFO("tda665x_earthpt1", 0x61),
		},
		},
		{
		.demod_info = {
		I2C_BOARD_INFO(TC90522_I2C_DEV_SAT, 0x19),
		},
		.tuner_info = {
		I2C_BOARD_INFO("qm1d1b0004", 0x60),
		},
		},
		{
		.demod_info = {
		I2C_BOARD_INFO(TC90522_I2C_DEV_TER, 0x18),
		},
		.tuner_info = {
		I2C_BOARD_INFO("tda665x_earthpt1", 0x61),
		},
		},
		};

		static const u8 va1j5jf8007s_20mhz_configs[][2] = {
		{0x04, 0x02}, {0x0d, 0x55}, {0x11, 0x40}, {0x13, 0x80}, {0x17, 0x01},
		{0x1c, 0x0a}, {0x1d, 0xaa}, {0x1e, 0x20}, {0x1f, 0x88}, {0x51, 0xb0},
		{0x52, 0x89}, {0x53, 0xb3}, {0x5a, 0x2d}, {0x5b, 0xd3}, {0x85, 0x69},
		{0x87, 0x04}, {0x8e, 0x02}, {0xa3, 0xf7}, {0xa5, 0xc0},
		};

		static const u8 va1j5jf8007s_25mhz_configs[][2] = {
		{0x04, 0x02}, {0x11, 0x40}, {0x13, 0x80}, {0x17, 0x01}, {0x1c, 0x0a},
		{0x1d, 0xaa}, {0x1e, 0x20}, {0x1f, 0x88}, {0x51, 0xb0}, {0x52, 0x89},
		{0x53, 0xb3}, {0x5a, 0x2d}, {0x5b, 0xd3}, {0x85, 0x69}, {0x87, 0x04},
		{0x8e, 0x26}, {0xa3, 0xf7}, {0xa5, 0xc0},
		};

		static const u8 va1j5jf8007t_20mhz_configs[][2] = {
		{0x03, 0x90}, {0x14, 0x8f}, {0x1c, 0x2a}, {0x1d, 0xa8}, {0x1e, 0xa2},
		{0x22, 0x83}, {0x31, 0x0d}, {0x32, 0xe0}, {0x39, 0xd3}, {0x3a, 0x00},
		{0x3b, 0x11}, {0x3c, 0x3f},
		{0x5c, 0x40}, {0x5f, 0x80}, {0x75, 0x02}, {0x76, 0x4e}, {0x77, 0x03},
		{0xef, 0x01}
		};

		static const u8 va1j5jf8007t_25mhz_configs[][2] = {
		{0x03, 0x90}, {0x1c, 0x2a}, {0x1d, 0xa8}, {0x1e, 0xa2}, {0x22, 0x83},
		{0x3a, 0x04}, {0x3b, 0x11}, {0x3c, 0x3f}, {0x5c, 0x40}, {0x5f, 0x80},
		{0x75, 0x0a}, {0x76, 0x4c}, {0x77, 0x03}, {0xef, 0x01}
		};

		static int config_demod(struct i2c_client *cl, enum pt1_fe_clk clk)
		{
		int ret;
		u8 buf[2] = {0x01, 0x80};
		bool is_sat;
		const u8 (*cfg_data)[2];
		int i, len;

		ret = i2c_master_send(cl, buf, 2);
		if (ret < 0)
		return ret;
		usleep_range(30000, 50000);

		is_sat = !strncmp(cl->name, TC90522_I2C_DEV_SAT, I2C_NAME_SIZE);
		if (is_sat) {
		struct i2c_msg msg[2];
		u8 wbuf, rbuf;

		wbuf = 0x07;
		msg[0].addr = cl->addr;
		msg[0].flags = 0;
		msg[0].len = 1;
		msg[0].buf = &wbuf;

		msg[1].addr = cl->addr;
		msg[1].flags = I2C_M_RD;
		msg[1].len = 1;
		msg[1].buf = &rbuf;
		ret = i2c_transfer(cl->adapter, msg, 2);
		if (ret < 0)
		return ret;
		if (rbuf != 0x41)
		return -EIO;
		}

		/* frontend init */
		if (clk == PT1_FE_CLK_20MHZ) {
		if (is_sat) {
		cfg_data = va1j5jf8007s_20mhz_configs;
		len = ARRAY_SIZE(va1j5jf8007s_20mhz_configs);
		} else {
		cfg_data = va1j5jf8007t_20mhz_configs;
		len = ARRAY_SIZE(va1j5jf8007t_20mhz_configs);
		}
		} else {
		if (is_sat) {
		cfg_data = va1j5jf8007s_25mhz_configs;
		len = ARRAY_SIZE(va1j5jf8007s_25mhz_configs);
		} else {
		cfg_data = va1j5jf8007t_25mhz_configs;
		len = ARRAY_SIZE(va1j5jf8007t_25mhz_configs);
		}
		}

		for (i = 0; i < len; i++) {
		ret = i2c_master_send(cl, cfg_data[i], 2);
		if (ret < 0)
		return ret;
		}
		return 0;
		}

		static void pt1_write_reg(struct pt1 *pt1, int reg, u32 data)
		{
		writel(data, pt1->regs + reg * 4);
		@@ -589,30 +739,33 @@ static int pt1_set_voltage(struct dvb_frontend *fe, enum fe_sec_voltage voltage)
		static int pt1_sleep(struct dvb_frontend *fe)
		{
		struct pt1_adapter *adap;
		int ret;

		adap = container_of(fe->dvb, struct pt1_adapter, adap);
		adap->sleep = 1;
		pt1_update_power(adap->pt1);

		ret = 0;
		if (adap->orig_sleep)
		return adap->orig_sleep(fe);
		else
		return 0;
		ret = adap->orig_sleep(fe);

		adap->sleep = 1;
		pt1_update_power(adap->pt1);
		return ret;
		}

		static int pt1_wakeup(struct dvb_frontend *fe)
		{
		struct pt1_adapter *adap;
		int ret;

		adap = container_of(fe->dvb, struct pt1_adapter, adap);
		adap->sleep = 0;
		pt1_update_power(adap->pt1);
		schedule_timeout_uninterruptible((HZ + 999) / 1000);

		if (adap->orig_init)
		return adap->orig_init(fe);
		else
		return 0;
		ret = config_demod(adap->demod_i2c_client, adap->pt1->fe_clk);
		if (ret == 0 && adap->orig_init)
		ret = adap->orig_init(fe);
		return ret;
		}

		static void pt1_free_adapter(struct pt1_adapter *adap)
		@@ -735,6 +888,8 @@ static int pt1_init_adapters(struct pt1 *pt1)
		static void pt1_cleanup_frontend(struct pt1_adapter *adap)
		{
		dvb_unregister_frontend(adap->fe);
		dvb_module_release(adap->tuner_i2c_client);
		dvb_module_release(adap->demod_i2c_client);
		}

		static int pt1_init_frontend(struct pt1_adapter adap, struct dvb_frontend fe)
		@@ -763,112 +918,70 @@ static void pt1_cleanup_frontends(struct pt1 *pt1)
		pt1_cleanup_frontend(pt1->adaps[i]);
		}

		struct pt1_config {
		struct va1j5jf8007s_config va1j5jf8007s_config;
		struct va1j5jf8007t_config va1j5jf8007t_config;
		};

		static const struct pt1_config pt1_configs[2] = {
		{
		{
		.demod_address = 0x1b,
		.frequency = VA1J5JF8007S_20MHZ,
		},
		{
		.demod_address = 0x1a,
		.frequency = VA1J5JF8007T_20MHZ,
		},
		}, {
		{
		.demod_address = 0x19,
		.frequency = VA1J5JF8007S_20MHZ,
		},
		{
		.demod_address = 0x18,
		.frequency = VA1J5JF8007T_20MHZ,
		},
		},
		};

		static const struct pt1_config pt2_configs[2] = {
		{
		{
		.demod_address = 0x1b,
		.frequency = VA1J5JF8007S_25MHZ,
		},
		{
		.demod_address = 0x1a,
		.frequency = VA1J5JF8007T_25MHZ,
		},
		}, {
		{
		.demod_address = 0x19,
		.frequency = VA1J5JF8007S_25MHZ,
		},
		{
		.demod_address = 0x18,
		.frequency = VA1J5JF8007T_25MHZ,
		},
		},
		};

		static int pt1_init_frontends(struct pt1 *pt1)
		{
		int i, j;
		struct i2c_adapter *i2c_adap;
		const struct pt1_config configs, config;
		struct dvb_frontend *fe[4];
		int i;
		int ret;

		i = 0;
		j = 0;

		i2c_adap = &pt1->i2c_adap;
		configs = pt1->pdev->device == 0x211a ? pt1_configs : pt2_configs;
		do {
		config = &configs[i / 2];
		for (i = 0; i < ARRAY_SIZE(pt1_configs); i++) {
		const struct i2c_board_info *info;
		struct tc90522_config dcfg;
		struct i2c_client *cl;

		fe[i] = va1j5jf8007s_attach(&config->va1j5jf8007s_config,
		i2c_adap);
		if (!fe[i]) {
		ret = -ENODEV; /* This does not sound nice... */
		goto err;
		}
		i++;
		info = &pt1_configs[i].demod_info;
		dcfg = pt1_configs[i].demod_cfg;
		dcfg.tuner_i2c = NULL;

		fe[i] = va1j5jf8007t_attach(&config->va1j5jf8007t_config,
		i2c_adap);
		if (!fe[i]) {
		ret = -ENODEV;
		goto err;
		}
		i++;
		cl = dvb_module_probe("tc90522", info->type, &pt1->i2c_adap,
		info->addr, &dcfg);
		if (!cl)
		goto fe_unregister;
		pt1->adaps[i]->demod_i2c_client = cl;

		if (!strncmp(cl->name, TC90522_I2C_DEV_SAT,
		strlen(TC90522_I2C_DEV_SAT))) {
		struct qm1d1b0004_config tcfg;

		info = &pt1_configs[i].tuner_info;
		tcfg = pt1_configs[i].tuner_cfg.qm1d1b0004;
		tcfg.fe = dcfg.fe;
		cl = dvb_module_probe("qm1d1b0004",
		info->type, dcfg.tuner_i2c,
		info->addr, &tcfg);
		} else {
		struct dvb_pll_config tcfg;

		ret = va1j5jf8007s_prepare(fe[i - 2]);
		if (ret < 0)
		goto err;
		info = &pt1_configs[i].tuner_info;
		tcfg = pt1_configs[i].tuner_cfg.tda6651;
		tcfg.fe = dcfg.fe;
		cl = dvb_module_probe("dvb_pll",
		info->type, dcfg.tuner_i2c,
		info->addr, &tcfg);
		}
		if (!cl)
		goto demod_release;
		pt1->adaps[i]->tuner_i2c_client = cl;

		ret = va1j5jf8007t_prepare(fe[i - 1]);
		ret = pt1_init_frontend(pt1->adaps[i], dcfg.fe);
		if (ret < 0)
		goto err;

		} while (i < 4);

		do {
		ret = pt1_init_frontend(pt1->adaps[j], fe[j]);
		if (ret < 0)
		goto err;
		} while (++j < 4);
		goto tuner_release;
		}

		return 0;

		err:
		while (i-- > j)
		fe[i]->ops.release(fe[i]);

		while (j--)
		dvb_unregister_frontend(fe[j]);

		tuner_release:
		dvb_module_release(pt1->adaps[i]->tuner_i2c_client);
		demod_release:
		dvb_module_release(pt1->adaps[i]->demod_i2c_client);
		fe_unregister:
		dev_warn(&pt1->pdev->dev, "failed to init FE(%d).\n", i);
		i--;
		for (; i >= 0; i--) {
		dvb_unregister_frontend(pt1->adaps[i]->fe);
		dvb_module_release(pt1->adaps[i]->tuner_i2c_client);
		dvb_module_release(pt1->adaps[i]->demod_i2c_client);
		}
		return ret;
		}

		@@ -1112,6 +1225,8 @@ static int pt1_probe(struct pci_dev pdev, const struct pci_device_id ent)
		mutex_init(&pt1->lock);
		pt1->pdev = pdev;
		pt1->regs = regs;
		pt1->fe_clk = (pdev->device == 0x211a) ?
		PT1_FE_CLK_20MHZ : PT1_FE_CLK_25MHZ;
		pci_set_drvdata(pdev, pt1);

		ret = pt1_init_adapters(pt1);

drivers/media/pci/pt1/va1j5jf8007s.c

deleted100644 → 0

+0 −732

File deleted.

Preview size limit exceeded, changes collapsed.

drivers/media/pci/pt1/va1j5jf8007s.h

deleted100644 → 0

+0 −42

Original line number	Diff line number	Diff line
		/*
		* ISDB-S driver for VA1J5JF8007/VA1J5JF8011
		*
		* Copyright (C) 2009 HIRANO Takahito <hiranotaka@zng.info>
		*
		* based on pt1dvr - http://pt1dvr.sourceforge.jp/
		* by Tomoaki Ishikawa <tomy@users.sourceforge.jp>
		*
		* This program is free software; you can redistribute it and/or modify
		* it under the terms of the GNU General Public License as published by
		* the Free Software Foundation; either version 2 of the License, or
		* (at your option) any later version.
		*
		* This program is distributed in the hope that it will be useful,
		* but WITHOUT ANY WARRANTY; without even the implied warranty of
		* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		* GNU General Public License for more details.
		*/

		#ifndef VA1J5JF8007S_H
		#define VA1J5JF8007S_H

		enum va1j5jf8007s_frequency {
		VA1J5JF8007S_20MHZ,
		VA1J5JF8007S_25MHZ,
		};

		struct va1j5jf8007s_config {
		u8 demod_address;
		enum va1j5jf8007s_frequency frequency;
		};

		struct i2c_adapter;

		struct dvb_frontend *
		va1j5jf8007s_attach(const struct va1j5jf8007s_config *config,
		struct i2c_adapter *adap);

		/* must be called after va1j5jf8007t_attach */
		int va1j5jf8007s_prepare(struct dvb_frontend *fe);

		#endif