[linux-2.6-block.git] / drivers / media / usb / dvb-usb / dibusb-mb.c

// SPDX-License-Identifier: GPL-2.0-only
/* DVB USB compliant linux driver for mobile DVB-T USB devices based on
 * reference designs made by DiBcom (http://www.dibcom.fr/) (DiB3000M-B)
 *
 * Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@posteo.de)
 *
 * based on GPL code from DiBcom, which has
 * Copyright (C) 2004 Amaury Demol for DiBcom
 *
 * see Documentation/driver-api/media/drivers/dvb-usb.rst for more information
 */
#include "dibusb.h"

DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);

static int dib3000mb_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
{
	struct dvb_usb_adapter *adap = fe->dvb->priv;
	struct dibusb_state *st = adap->priv;

	return st->ops.tuner_pass_ctrl(fe, enable, st->tuner_addr);
}

static int dibusb_dib3000mb_frontend_attach(struct dvb_usb_adapter *adap)
{
	struct dib3000_config demod_cfg;
	struct dibusb_state *st = adap->priv;

	demod_cfg.demod_address = 0x8;

	adap->fe_adap[0].fe = dvb_attach(dib3000mb_attach, &demod_cfg,
					 &adap->dev->i2c_adap, &st->ops);
	if ((adap->fe_adap[0].fe) == NULL)
		return -ENODEV;

	adap->fe_adap[0].fe->ops.i2c_gate_ctrl = dib3000mb_i2c_gate_ctrl;

	return 0;
}

static int dibusb_thomson_tuner_attach(struct dvb_usb_adapter *adap)
{
	struct dibusb_state *st = adap->priv;

	st->tuner_addr = 0x61;

	dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, &adap->dev->i2c_adap,
		   DVB_PLL_TUA6010XS);
	return 0;
}

static int dibusb_panasonic_tuner_attach(struct dvb_usb_adapter *adap)
{
	struct dibusb_state *st = adap->priv;

	st->tuner_addr = 0x60;

	dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, &adap->dev->i2c_adap,
		   DVB_PLL_TDA665X);
	return 0;
}

/* Some of the Artec 1.1 device aren't equipped with the default tuner
 * (Thomson Cable), but with a Panasonic ENV77H11D5.  This function figures
 * this out. */
static int dibusb_tuner_probe_and_attach(struct dvb_usb_adapter *adap)
{
	u8 b[2] = { 0,0 }, b2[1];
	int ret = 0;
	struct i2c_msg msg[2] = {
		{ .flags = 0,        .buf = b,  .len = 2 },
		{ .flags = I2C_M_RD, .buf = b2, .len = 1 },
	};
	struct dibusb_state *st = adap->priv;

	/* the Panasonic sits on I2C addrass 0x60, the Thomson on 0x61 */
	msg[0].addr = msg[1].addr = st->tuner_addr = 0x60;

	if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
		adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 1);

	if (i2c_transfer(&adap->dev->i2c_adap, msg, 2) != 2) {
		err("tuner i2c write failed.");
		return -EREMOTEIO;
	}

	if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
		adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 0);

	if (b2[0] == 0xfe) {
		info("This device has the Thomson Cable onboard. Which is default.");
		ret = dibusb_thomson_tuner_attach(adap);
	} else {
		info("This device has the Panasonic ENV77H11D5 onboard.");
		ret = dibusb_panasonic_tuner_attach(adap);
	}

	return ret;
}

/* USB Driver stuff */
static struct dvb_usb_device_properties dibusb1_1_properties;
static struct dvb_usb_device_properties dibusb1_1_an2235_properties;
static struct dvb_usb_device_properties dibusb2_0b_properties;
static struct dvb_usb_device_properties artec_t1_usb2_properties;

static int dibusb_probe(struct usb_interface *intf,
		const struct usb_device_id *id)
{
	if (0 == dvb_usb_device_init(intf, &dibusb1_1_properties,
				     THIS_MODULE, NULL, adapter_nr) ||
	    0 == dvb_usb_device_init(intf, &dibusb1_1_an2235_properties,
				     THIS_MODULE, NULL, adapter_nr) ||
	    0 == dvb_usb_device_init(intf, &dibusb2_0b_properties,
				     THIS_MODULE, NULL, adapter_nr) ||
	    0 == dvb_usb_device_init(intf, &artec_t1_usb2_properties,
				     THIS_MODULE, NULL, adapter_nr))
		return 0;

	return -EINVAL;
}

/* do not change the order of the ID table */
enum {
	WIDEVIEW_DVBT_USB_COLD,
	WIDEVIEW_DVBT_USB_WARM,
	COMPRO_DVBU2000_COLD,
	COMPRO_DVBU2000_WARM,
	COMPRO_DVBU2000_UNK_COLD,
	DIBCOM_MOD3000_COLD,
	DIBCOM_MOD3000_WARM,
	EMPIA_VSTREAM_COLD,
	EMPIA_VSTREAM_WARM,
	GRANDTEC_DVBT_USB_COLD,
	GRANDTEC_DVBT_USB_WARM,
	GRANDTEC_MOD3000_COLD,
	GRANDTEC_MOD3000_WARM,
	UNK_HYPER_PALTEK_COLD,
	UNK_HYPER_PALTEK_WARM,
	VISIONPLUS_VP7041_COLD,
	VISIONPLUS_VP7041_WARM,
	TWINHAN_VP7041_COLD,
	TWINHAN_VP7041_WARM,
	ULTIMA_TVBOX_COLD,
	ULTIMA_TVBOX_WARM,
	ULTIMA_TVBOX_AN2235_COLD,
	ULTIMA_TVBOX_AN2235_WARM,
	ADSTECH_USB2_COLD,
	ADSTECH_USB2_WARM,
	KYE_DVB_T_COLD,
	KYE_DVB_T_WARM,
	KWORLD_VSTREAM_COLD,
	ULTIMA_TVBOX_USB2_COLD,
	ULTIMA_TVBOX_USB2_WARM,
	ULTIMA_TVBOX_ANCHOR_COLD,
};

static struct usb_device_id dibusb_dib3000mb_table[] = {
	DVB_USB_DEV(WIDEVIEW, WIDEVIEW_DVBT_USB_COLD),
	DVB_USB_DEV(WIDEVIEW, WIDEVIEW_DVBT_USB_WARM),
	DVB_USB_DEV(COMPRO, COMPRO_DVBU2000_COLD),
	DVB_USB_DEV(COMPRO, COMPRO_DVBU2000_WARM),
	DVB_USB_DEV(COMPRO_UNK, COMPRO_DVBU2000_UNK_COLD),
	DVB_USB_DEV(DIBCOM, DIBCOM_MOD3000_COLD),
	DVB_USB_DEV(DIBCOM, DIBCOM_MOD3000_WARM),
	DVB_USB_DEV(EMPIA, EMPIA_VSTREAM_COLD),
	DVB_USB_DEV(EMPIA, EMPIA_VSTREAM_WARM),
	DVB_USB_DEV(GRANDTEC, GRANDTEC_DVBT_USB_COLD),
	DVB_USB_DEV(GRANDTEC, GRANDTEC_DVBT_USB_WARM),
	DVB_USB_DEV(GRANDTEC, GRANDTEC_MOD3000_COLD),
	DVB_USB_DEV(GRANDTEC, GRANDTEC_MOD3000_WARM),
	DVB_USB_DEV(HYPER_PALTEK, UNK_HYPER_PALTEK_COLD),
	DVB_USB_DEV(HYPER_PALTEK, UNK_HYPER_PALTEK_WARM),
	DVB_USB_DEV(VISIONPLUS, VISIONPLUS_VP7041_COLD),
	DVB_USB_DEV(VISIONPLUS, VISIONPLUS_VP7041_WARM),
	DVB_USB_DEV(TWINHAN, TWINHAN_VP7041_COLD),
	DVB_USB_DEV(TWINHAN, TWINHAN_VP7041_WARM),
	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_COLD),
	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_WARM),
	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_AN2235_COLD),
	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_AN2235_WARM),
	DVB_USB_DEV(ADSTECH, ADSTECH_USB2_COLD),
	DVB_USB_DEV(ADSTECH, ADSTECH_USB2_WARM),
	DVB_USB_DEV(KYE, KYE_DVB_T_COLD),
	DVB_USB_DEV(KYE, KYE_DVB_T_WARM),
	DVB_USB_DEV(KWORLD, KWORLD_VSTREAM_COLD),
	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_USB2_COLD),
	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_USB2_WARM),
#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
	DVB_USB_DEV(ANCHOR, ULTIMA_TVBOX_ANCHOR_COLD),
#endif
	{ }
};

MODULE_DEVICE_TABLE (usb, dibusb_dib3000mb_table);

static struct dvb_usb_device_properties dibusb1_1_properties = {
	.caps =  DVB_USB_IS_AN_I2C_ADAPTER,

	.usb_ctrl = CYPRESS_AN2135,

	.firmware = "dvb-usb-dibusb-5.0.0.11.fw",

	.num_adapters = 1,
	.adapter = {
		{
		.num_frontends = 1,
		.fe = {{
			.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
			.pid_filter_count = 16,

			.streaming_ctrl   = dibusb_streaming_ctrl,
			.pid_filter       = dibusb_pid_filter,
			.pid_filter_ctrl  = dibusb_pid_filter_ctrl,
			.frontend_attach  = dibusb_dib3000mb_frontend_attach,
			.tuner_attach     = dibusb_tuner_probe_and_attach,

			/* parameter for the MPEG2-data transfer */
			.stream = {
				.type = USB_BULK,
				.count = 7,
				.endpoint = 0x02,
				.u = {
					.bulk = {
						.buffersize = 4096,
					}
				}
			},
		}},
			.size_of_priv     = sizeof(struct dibusb_state),
		}
	},

	.power_ctrl       = dibusb_power_ctrl,

	.rc.legacy = {
		.rc_interval      = DEFAULT_RC_INTERVAL,
		.rc_map_table     = rc_map_dibusb_table,
		.rc_map_size      = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
		.rc_query         = dibusb_rc_query,
	},

	.i2c_algo         = &dibusb_i2c_algo,

	.generic_bulk_ctrl_endpoint = 0x01,

	.num_device_descs = 9,
	.devices = {
		{	"AVerMedia AverTV DVBT USB1.1",
			{ &dibusb_dib3000mb_table[WIDEVIEW_DVBT_USB_COLD],  NULL },
			{ &dibusb_dib3000mb_table[WIDEVIEW_DVBT_USB_WARM],  NULL },
		},
		{	"Compro Videomate DVB-U2000 - DVB-T USB1.1 (please confirm to linux-dvb)",
			{ &dibusb_dib3000mb_table[COMPRO_DVBU2000_COLD], &dibusb_dib3000mb_table[COMPRO_DVBU2000_UNK_COLD], NULL},
			{ &dibusb_dib3000mb_table[COMPRO_DVBU2000_WARM], NULL },
		},
		{	"DiBcom USB1.1 DVB-T reference design (MOD3000)",
			{ &dibusb_dib3000mb_table[DIBCOM_MOD3000_COLD],  NULL },
			{ &dibusb_dib3000mb_table[DIBCOM_MOD3000_WARM],  NULL },
		},
		{	"KWorld V-Stream XPERT DTV - DVB-T USB1.1",
			{ &dibusb_dib3000mb_table[EMPIA_VSTREAM_COLD], NULL },
			{ &dibusb_dib3000mb_table[EMPIA_VSTREAM_WARM], NULL },
		},
		{	"Grandtec USB1.1 DVB-T",
			{ &dibusb_dib3000mb_table[GRANDTEC_DVBT_USB_COLD],  &dibusb_dib3000mb_table[GRANDTEC_MOD3000_COLD], NULL },
			{ &dibusb_dib3000mb_table[GRANDTEC_DVBT_USB_WARM], &dibusb_dib3000mb_table[GRANDTEC_MOD3000_WARM], NULL },
		},
		{	"Unknown USB1.1 DVB-T device ???? please report the name to the author",
			{ &dibusb_dib3000mb_table[UNK_HYPER_PALTEK_COLD], NULL },
			{ &dibusb_dib3000mb_table[UNK_HYPER_PALTEK_WARM], NULL },
		},
		{	"TwinhanDTV USB-Ter USB1.1 / Magic Box I / HAMA USB1.1 DVB-T device",
			{ &dibusb_dib3000mb_table[VISIONPLUS_VP7041_COLD], &dibusb_dib3000mb_table[TWINHAN_VP7041_COLD], NULL},
			{ &dibusb_dib3000mb_table[VISIONPLUS_VP7041_WARM], &dibusb_dib3000mb_table[TWINHAN_VP7041_WARM], NULL},
		},
		{	"Artec T1 USB1.1 TVBOX with AN2135",
			{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_COLD], NULL },
			{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_WARM], NULL },
		},
		{	"VideoWalker DVB-T USB",
			{ &dibusb_dib3000mb_table[KYE_DVB_T_COLD], NULL },
			{ &dibusb_dib3000mb_table[KYE_DVB_T_WARM], NULL },
		},
	}
};

static struct dvb_usb_device_properties dibusb1_1_an2235_properties = {
	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
	.usb_ctrl = CYPRESS_AN2235,

	.firmware = "dvb-usb-dibusb-an2235-01.fw",

	.num_adapters = 1,
	.adapter = {
		{
		.num_frontends = 1,
		.fe = {{
			.caps = DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF | DVB_USB_ADAP_HAS_PID_FILTER,
			.pid_filter_count = 16,

			.streaming_ctrl   = dibusb_streaming_ctrl,
			.pid_filter       = dibusb_pid_filter,
			.pid_filter_ctrl  = dibusb_pid_filter_ctrl,
			.frontend_attach  = dibusb_dib3000mb_frontend_attach,
			.tuner_attach     = dibusb_tuner_probe_and_attach,

			/* parameter for the MPEG2-data transfer */
			.stream = {
				.type = USB_BULK,
				.count = 7,
				.endpoint = 0x02,
				.u = {
					.bulk = {
						.buffersize = 4096,
					}
				}
			},
		}},
			.size_of_priv     = sizeof(struct dibusb_state),
		},
	},
	.power_ctrl       = dibusb_power_ctrl,

	.rc.legacy = {
		.rc_interval      = DEFAULT_RC_INTERVAL,
		.rc_map_table     = rc_map_dibusb_table,
		.rc_map_size      = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
		.rc_query         = dibusb_rc_query,
	},

	.i2c_algo         = &dibusb_i2c_algo,

	.generic_bulk_ctrl_endpoint = 0x01,

#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
	.num_device_descs = 2,
#else
	.num_device_descs = 1,
#endif
	.devices = {
		{	"Artec T1 USB1.1 TVBOX with AN2235",
			{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_AN2235_COLD], NULL },
			{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_AN2235_WARM], NULL },
		},
#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
		{	"Artec T1 USB1.1 TVBOX with AN2235 (faulty USB IDs)",
			{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_ANCHOR_COLD], NULL },
			{ NULL },
		},
		{ NULL },
#endif
	}
};

static struct dvb_usb_device_properties dibusb2_0b_properties = {
	.caps = DVB_USB_IS_AN_I2C_ADAPTER,

	.usb_ctrl = CYPRESS_FX2,

	.firmware = "dvb-usb-adstech-usb2-02.fw",

	.num_adapters = 1,
	.adapter = {
		{
		.num_frontends = 1,
		.fe = {{
			.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
			.pid_filter_count = 16,

			.streaming_ctrl   = dibusb2_0_streaming_ctrl,
			.pid_filter       = dibusb_pid_filter,
			.pid_filter_ctrl  = dibusb_pid_filter_ctrl,
			.frontend_attach  = dibusb_dib3000mb_frontend_attach,
			.tuner_attach     = dibusb_thomson_tuner_attach,

			/* parameter for the MPEG2-data transfer */
			.stream = {
				.type = USB_BULK,
				.count = 7,
				.endpoint = 0x06,
				.u = {
					.bulk = {
						.buffersize = 4096,
					}
				}
			},
		}},
			.size_of_priv     = sizeof(struct dibusb_state),
		}
	},
	.power_ctrl       = dibusb2_0_power_ctrl,

	.rc.legacy = {
		.rc_interval      = DEFAULT_RC_INTERVAL,
		.rc_map_table     = rc_map_dibusb_table,
		.rc_map_size      = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
		.rc_query         = dibusb_rc_query,
	},

	.i2c_algo         = &dibusb_i2c_algo,

	.generic_bulk_ctrl_endpoint = 0x01,

	.num_device_descs = 2,
	.devices = {
		{	"KWorld/ADSTech Instant DVB-T USB2.0",
			{ &dibusb_dib3000mb_table[ADSTECH_USB2_COLD], NULL },
			{ &dibusb_dib3000mb_table[ADSTECH_USB2_WARM], NULL },
		},
		{	"KWorld Xpert DVB-T USB2.0",
			{ &dibusb_dib3000mb_table[KWORLD_VSTREAM_COLD], NULL },
			{ NULL }
		},
		{ NULL },
	}
};

static struct dvb_usb_device_properties artec_t1_usb2_properties = {
	.caps = DVB_USB_IS_AN_I2C_ADAPTER,

	.usb_ctrl = CYPRESS_FX2,

	.firmware = "dvb-usb-dibusb-6.0.0.8.fw",

	.num_adapters = 1,
	.adapter = {
		{
		.num_frontends = 1,
		.fe = {{
			.caps = DVB_USB_ADAP_HAS_PID_FILTER | DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
			.pid_filter_count = 16,

			.streaming_ctrl   = dibusb2_0_streaming_ctrl,
			.pid_filter       = dibusb_pid_filter,
			.pid_filter_ctrl  = dibusb_pid_filter_ctrl,
			.frontend_attach  = dibusb_dib3000mb_frontend_attach,
			.tuner_attach     = dibusb_tuner_probe_and_attach,
			/* parameter for the MPEG2-data transfer */
			.stream = {
				.type = USB_BULK,
				.count = 7,
				.endpoint = 0x06,
				.u = {
					.bulk = {
						.buffersize = 4096,
					}
				}
			},
		}},
			.size_of_priv     = sizeof(struct dibusb_state),
		}
	},
	.power_ctrl       = dibusb2_0_power_ctrl,

	.rc.legacy = {
		.rc_interval      = DEFAULT_RC_INTERVAL,
		.rc_map_table     = rc_map_dibusb_table,
		.rc_map_size      = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
		.rc_query         = dibusb_rc_query,
	},

	.i2c_algo         = &dibusb_i2c_algo,

	.generic_bulk_ctrl_endpoint = 0x01,

	.num_device_descs = 1,
	.devices = {
		{	"Artec T1 USB2.0",
			{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_USB2_COLD], NULL },
			{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_USB2_WARM], NULL },
		},
		{ NULL },
	}
};

static struct usb_driver dibusb_driver = {
	.name		= "dvb_usb_dibusb_mb",
	.probe		= dibusb_probe,
	.disconnect = dvb_usb_device_exit,
	.id_table	= dibusb_dib3000mb_table,
};

module_usb_driver(dibusb_driver);

MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
MODULE_DESCRIPTION("Driver for DiBcom USB DVB-T devices (DiB3000M-B based)");
MODULE_VERSION("1.0");
MODULE_LICENSE("GPL");
Commit	Line	Data
fc7669c6	1	// SPDX-License-Identifier: GPL-2.0-only
776338e1 JS	2	/* DVB USB compliant linux driver for mobile DVB-T USB devices based on
	3	* reference designs made by DiBcom (http://www.dibcom.fr/) (DiB3000M-B)
	4	*
99e44da7	5	* Copyright (C) 2004-5 Patrick Boettcher (patrick.boettcher@posteo.de)
776338e1 JS	6	*
776338e1 JS	7	* based on GPL code from DiBcom, which has
99e44da7	8	* Copyright (C) 2004 Amaury Demol for DiBcom
776338e1	9	*
577a7ad3	10	* see Documentation/driver-api/media/drivers/dvb-usb.rst for more information
776338e1 JS	11	*/
	12	#include "dibusb.h"
	13
78e92006 JG	14	DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
78e92006 JG	15
6c08d929 MK	16	static int dib3000mb_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
	17	{
	18	struct dvb_usb_adapter *adap = fe->dvb->priv;
	19	struct dibusb_state *st = adap->priv;
	20
	21	return st->ops.tuner_pass_ctrl(fe, enable, st->tuner_addr);
	22	}
	23
4d43e13f	24	static int dibusb_dib3000mb_frontend_attach(struct dvb_usb_adapter *adap)
776338e1 JS	25	{
776338e1 JS	26	struct dib3000_config demod_cfg;
4d43e13f	27	struct dibusb_state *st = adap->priv;
776338e1 JS	28
776338e1 JS	29	demod_cfg.demod_address = 0x8;
776338e1	30
d4dd5ce7 MK	31	adap->fe_adap[0].fe = dvb_attach(dib3000mb_attach, &demod_cfg,
	32	&adap->dev->i2c_adap, &st->ops);
	33	if ((adap->fe_adap[0].fe) == NULL)
776338e1	34	return -ENODEV;
56760f07	35
77eed219	36	adap->fe_adap[0].fe->ops.i2c_gate_ctrl = dib3000mb_i2c_gate_ctrl;
776338e1 JS	37
	38	return 0;
	39	}
	40
4d43e13f	41	static int dibusb_thomson_tuner_attach(struct dvb_usb_adapter *adap)
8945c8c3	42	{
6c08d929 MK	43	struct dibusb_state *st = adap->priv;
	44
	45	st->tuner_addr = 0x61;
	46
77eed219	47	dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, &adap->dev->i2c_adap,
47a9991e	48	DVB_PLL_TUA6010XS);
fbfee868 MK	49	return 0;
	50	}
	51
	52	static int dibusb_panasonic_tuner_attach(struct dvb_usb_adapter *adap)
	53	{
6c08d929 MK	54	struct dibusb_state *st = adap->priv;
	55
	56	st->tuner_addr = 0x60;
	57
77eed219	58	dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60, &adap->dev->i2c_adap,
47a9991e	59	DVB_PLL_TDA665X);
8945c8c3 PB	60	return 0;
	61	}
	62
	63	/* Some of the Artec 1.1 device aren't equipped with the default tuner
776338e1 JS	64	* (Thomson Cable), but with a Panasonic ENV77H11D5. This function figures
776338e1 JS	65	* this out. */
4d43e13f	66	static int dibusb_tuner_probe_and_attach(struct dvb_usb_adapter *adap)
776338e1 JS	67	{
	68	u8 b[2] = { 0,0 }, b2[1];
	69	int ret = 0;
	70	struct i2c_msg msg[2] = {
	71	{ .flags = 0, .buf = b, .len = 2 },
	72	{ .flags = I2C_M_RD, .buf = b2, .len = 1 },
	73	};
6c08d929	74	struct dibusb_state *st = adap->priv;
776338e1 JS	75
776338e1 JS	76	/* the Panasonic sits on I2C addrass 0x60, the Thomson on 0x61 */
096bb77a	77	msg[0].addr = msg[1].addr = st->tuner_addr = 0x60;
776338e1	78
77eed219	79	if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
4594303b	80	adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 1);
776338e1	81
4d43e13f	82	if (i2c_transfer(&adap->dev->i2c_adap, msg, 2) != 2) {
776338e1	83	err("tuner i2c write failed.");
96f3a939	84	return -EREMOTEIO;
776338e1 JS	85	}
776338e1 JS	86
77eed219	87	if (adap->fe_adap[0].fe->ops.i2c_gate_ctrl)
4594303b	88	adap->fe_adap[0].fe->ops.i2c_gate_ctrl(adap->fe_adap[0].fe, 0);
776338e1 JS	89
776338e1 JS	90	if (b2[0] == 0xfe) {
1157020d	91	info("This device has the Thomson Cable onboard. Which is default.");
fbfee868	92	ret = dibusb_thomson_tuner_attach(adap);
776338e1	93	} else {
1157020d	94	info("This device has the Panasonic ENV77H11D5 onboard.");
fbfee868	95	ret = dibusb_panasonic_tuner_attach(adap);
776338e1 JS	96	}
	97
	98	return ret;
	99	}
	100
	101	/* USB Driver stuff */
4d43e13f PB	102	static struct dvb_usb_device_properties dibusb1_1_properties;
	103	static struct dvb_usb_device_properties dibusb1_1_an2235_properties;
	104	static struct dvb_usb_device_properties dibusb2_0b_properties;
	105	static struct dvb_usb_device_properties artec_t1_usb2_properties;
776338e1 JS	106
	107	static int dibusb_probe(struct usb_interface *intf,
	108	const struct usb_device_id *id)
	109	{
78e92006 JG	110	if (0 == dvb_usb_device_init(intf, &dibusb1_1_properties,
	111	THIS_MODULE, NULL, adapter_nr) \|\|
	112	0 == dvb_usb_device_init(intf, &dibusb1_1_an2235_properties,
	113	THIS_MODULE, NULL, adapter_nr) \|\|
	114	0 == dvb_usb_device_init(intf, &dibusb2_0b_properties,
	115	THIS_MODULE, NULL, adapter_nr) \|\|
	116	0 == dvb_usb_device_init(intf, &artec_t1_usb2_properties,
	117	THIS_MODULE, NULL, adapter_nr))
776338e1 JS	118	return 0;
	119
	120	return -EINVAL;
	121	}
	122
	123	/* do not change the order of the ID table */
d763479a MCC	124	enum {
	125	WIDEVIEW_DVBT_USB_COLD,
	126	WIDEVIEW_DVBT_USB_WARM,
	127	COMPRO_DVBU2000_COLD,
	128	COMPRO_DVBU2000_WARM,
	129	COMPRO_DVBU2000_UNK_COLD,
	130	DIBCOM_MOD3000_COLD,
	131	DIBCOM_MOD3000_WARM,
	132	EMPIA_VSTREAM_COLD,
	133	EMPIA_VSTREAM_WARM,
	134	GRANDTEC_DVBT_USB_COLD,
	135	GRANDTEC_DVBT_USB_WARM,
	136	GRANDTEC_MOD3000_COLD,
	137	GRANDTEC_MOD3000_WARM,
	138	UNK_HYPER_PALTEK_COLD,
	139	UNK_HYPER_PALTEK_WARM,
	140	VISIONPLUS_VP7041_COLD,
	141	VISIONPLUS_VP7041_WARM,
	142	TWINHAN_VP7041_COLD,
	143	TWINHAN_VP7041_WARM,
	144	ULTIMA_TVBOX_COLD,
	145	ULTIMA_TVBOX_WARM,
	146	ULTIMA_TVBOX_AN2235_COLD,
	147	ULTIMA_TVBOX_AN2235_WARM,
	148	ADSTECH_USB2_COLD,
	149	ADSTECH_USB2_WARM,
	150	KYE_DVB_T_COLD,
	151	KYE_DVB_T_WARM,
	152	KWORLD_VSTREAM_COLD,
	153	ULTIMA_TVBOX_USB2_COLD,
	154	ULTIMA_TVBOX_USB2_WARM,
	155	ULTIMA_TVBOX_ANCHOR_COLD,
	156	};
68293ddb	157
d763479a MCC	158	static struct usb_device_id dibusb_dib3000mb_table[] = {
	159	DVB_USB_DEV(WIDEVIEW, WIDEVIEW_DVBT_USB_COLD),
	160	DVB_USB_DEV(WIDEVIEW, WIDEVIEW_DVBT_USB_WARM),
	161	DVB_USB_DEV(COMPRO, COMPRO_DVBU2000_COLD),
	162	DVB_USB_DEV(COMPRO, COMPRO_DVBU2000_WARM),
	163	DVB_USB_DEV(COMPRO_UNK, COMPRO_DVBU2000_UNK_COLD),
	164	DVB_USB_DEV(DIBCOM, DIBCOM_MOD3000_COLD),
	165	DVB_USB_DEV(DIBCOM, DIBCOM_MOD3000_WARM),
	166	DVB_USB_DEV(EMPIA, EMPIA_VSTREAM_COLD),
	167	DVB_USB_DEV(EMPIA, EMPIA_VSTREAM_WARM),
	168	DVB_USB_DEV(GRANDTEC, GRANDTEC_DVBT_USB_COLD),
	169	DVB_USB_DEV(GRANDTEC, GRANDTEC_DVBT_USB_WARM),
	170	DVB_USB_DEV(GRANDTEC, GRANDTEC_MOD3000_COLD),
	171	DVB_USB_DEV(GRANDTEC, GRANDTEC_MOD3000_WARM),
	172	DVB_USB_DEV(HYPER_PALTEK, UNK_HYPER_PALTEK_COLD),
	173	DVB_USB_DEV(HYPER_PALTEK, UNK_HYPER_PALTEK_WARM),
	174	DVB_USB_DEV(VISIONPLUS, VISIONPLUS_VP7041_COLD),
	175	DVB_USB_DEV(VISIONPLUS, VISIONPLUS_VP7041_WARM),
	176	DVB_USB_DEV(TWINHAN, TWINHAN_VP7041_COLD),
	177	DVB_USB_DEV(TWINHAN, TWINHAN_VP7041_WARM),
	178	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_COLD),
	179	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_WARM),
	180	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_AN2235_COLD),
	181	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_AN2235_WARM),
	182	DVB_USB_DEV(ADSTECH, ADSTECH_USB2_COLD),
	183	DVB_USB_DEV(ADSTECH, ADSTECH_USB2_WARM),
	184	DVB_USB_DEV(KYE, KYE_DVB_T_COLD),
	185	DVB_USB_DEV(KYE, KYE_DVB_T_WARM),
	186	DVB_USB_DEV(KWORLD, KWORLD_VSTREAM_COLD),
	187	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_USB2_COLD),
	188	DVB_USB_DEV(ULTIMA_ELECTRONIC, ULTIMA_TVBOX_USB2_WARM),
1157020d	189	#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
d763479a	190	DVB_USB_DEV(ANCHOR, ULTIMA_TVBOX_ANCHOR_COLD),
68293ddb	191	#endif
d763479a	192	{ }
776338e1	193	};
d763479a	194
776338e1 JS	195	MODULE_DEVICE_TABLE (usb, dibusb_dib3000mb_table);
776338e1 JS	196
4d43e13f PB	197	static struct dvb_usb_device_properties dibusb1_1_properties = {
4d43e13f PB	198	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
776338e1 JS	199
	200	.usb_ctrl = CYPRESS_AN2135,
	201
	202	.firmware = "dvb-usb-dibusb-5.0.0.11.fw",
	203
4d43e13f PB	204	.num_adapters = 1,
	205	.adapter = {
	206	{
77eed219 MK	207	.num_frontends = 1,
77eed219 MK	208	.fe = {{
4d43e13f PB	209	.caps = DVB_USB_ADAP_HAS_PID_FILTER \| DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4d43e13f PB	210	.pid_filter_count = 16,
776338e1	211
01451e72 PB	212	.streaming_ctrl = dibusb_streaming_ctrl,
	213	.pid_filter = dibusb_pid_filter,
	214	.pid_filter_ctrl = dibusb_pid_filter_ctrl,
	215	.frontend_attach = dibusb_dib3000mb_frontend_attach,
	216	.tuner_attach = dibusb_tuner_probe_and_attach,
776338e1	217
01451e72	218	/* parameter for the MPEG2-data transfer */
4d43e13f PB	219	.stream = {
4d43e13f PB	220	.type = USB_BULK,
01451e72 PB	221	.count = 7,
	222	.endpoint = 0x02,
	223	.u = {
	224	.bulk = {
	225	.buffersize = 4096,
	226	}
	227	}
	228	},
77eed219	229	}},
4d43e13f PB	230	.size_of_priv = sizeof(struct dibusb_state),
	231	}
	232	},
	233
	234	.power_ctrl = dibusb_power_ctrl,
	235
f72a27b8 MCC	236	.rc.legacy = {
f72a27b8 MCC	237	.rc_interval = DEFAULT_RC_INTERVAL,
2f4f58d6 MCC	238	.rc_map_table = rc_map_dibusb_table,
2f4f58d6 MCC	239	.rc_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
f72a27b8 MCC	240	.rc_query = dibusb_rc_query,
f72a27b8 MCC	241	},
4d43e13f PB	242
	243	.i2c_algo = &dibusb_i2c_algo,
	244
	245	.generic_bulk_ctrl_endpoint = 0x01,
776338e1	246
2f7f96b9	247	.num_device_descs = 9,
776338e1 JS	248	.devices = {
776338e1 JS	249	{ "AVerMedia AverTV DVBT USB1.1",
d763479a MCC	250	{ &dibusb_dib3000mb_table[WIDEVIEW_DVBT_USB_COLD], NULL },
d763479a MCC	251	{ &dibusb_dib3000mb_table[WIDEVIEW_DVBT_USB_WARM], NULL },
776338e1 JS	252	},
776338e1 JS	253	{ "Compro Videomate DVB-U2000 - DVB-T USB1.1 (please confirm to linux-dvb)",
d763479a MCC	254	{ &dibusb_dib3000mb_table[COMPRO_DVBU2000_COLD], &dibusb_dib3000mb_table[COMPRO_DVBU2000_UNK_COLD], NULL},
d763479a MCC	255	{ &dibusb_dib3000mb_table[COMPRO_DVBU2000_WARM], NULL },
776338e1 JS	256	},
776338e1 JS	257	{ "DiBcom USB1.1 DVB-T reference design (MOD3000)",
d763479a MCC	258	{ &dibusb_dib3000mb_table[DIBCOM_MOD3000_COLD], NULL },
d763479a MCC	259	{ &dibusb_dib3000mb_table[DIBCOM_MOD3000_WARM], NULL },
776338e1 JS	260	},
776338e1 JS	261	{ "KWorld V-Stream XPERT DTV - DVB-T USB1.1",
d763479a MCC	262	{ &dibusb_dib3000mb_table[EMPIA_VSTREAM_COLD], NULL },
d763479a MCC	263	{ &dibusb_dib3000mb_table[EMPIA_VSTREAM_WARM], NULL },
776338e1 JS	264	},
776338e1 JS	265	{ "Grandtec USB1.1 DVB-T",
d763479a MCC	266	{ &dibusb_dib3000mb_table[GRANDTEC_DVBT_USB_COLD], &dibusb_dib3000mb_table[GRANDTEC_MOD3000_COLD], NULL },
d763479a MCC	267	{ &dibusb_dib3000mb_table[GRANDTEC_DVBT_USB_WARM], &dibusb_dib3000mb_table[GRANDTEC_MOD3000_WARM], NULL },
776338e1	268	},
af901ca1	269	{ "Unknown USB1.1 DVB-T device ???? please report the name to the author",
d763479a MCC	270	{ &dibusb_dib3000mb_table[UNK_HYPER_PALTEK_COLD], NULL },
d763479a MCC	271	{ &dibusb_dib3000mb_table[UNK_HYPER_PALTEK_WARM], NULL },
776338e1 JS	272	},
776338e1 JS	273	{ "TwinhanDTV USB-Ter USB1.1 / Magic Box I / HAMA USB1.1 DVB-T device",
d763479a MCC	274	{ &dibusb_dib3000mb_table[VISIONPLUS_VP7041_COLD], &dibusb_dib3000mb_table[TWINHAN_VP7041_COLD], NULL},
d763479a MCC	275	{ &dibusb_dib3000mb_table[VISIONPLUS_VP7041_WARM], &dibusb_dib3000mb_table[TWINHAN_VP7041_WARM], NULL},
776338e1 JS	276	},
776338e1 JS	277	{ "Artec T1 USB1.1 TVBOX with AN2135",
d763479a MCC	278	{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_COLD], NULL },
d763479a MCC	279	{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_WARM], NULL },
776338e1	280	},
2f7f96b9	281	{ "VideoWalker DVB-T USB",
d763479a MCC	282	{ &dibusb_dib3000mb_table[KYE_DVB_T_COLD], NULL },
d763479a MCC	283	{ &dibusb_dib3000mb_table[KYE_DVB_T_WARM], NULL },
2f7f96b9	284	},
776338e1 JS	285	}
	286	};
	287
4d43e13f PB	288	static struct dvb_usb_device_properties dibusb1_1_an2235_properties = {
4d43e13f PB	289	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
776338e1 JS	290	.usb_ctrl = CYPRESS_AN2235,
	291
	292	.firmware = "dvb-usb-dibusb-an2235-01.fw",
	293
4d43e13f PB	294	.num_adapters = 1,
	295	.adapter = {
	296	{
77eed219 MK	297	.num_frontends = 1,
77eed219 MK	298	.fe = {{
4d43e13f PB	299	.caps = DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF \| DVB_USB_ADAP_HAS_PID_FILTER,
4d43e13f PB	300	.pid_filter_count = 16,
776338e1	301
01451e72 PB	302	.streaming_ctrl = dibusb_streaming_ctrl,
	303	.pid_filter = dibusb_pid_filter,
	304	.pid_filter_ctrl = dibusb_pid_filter_ctrl,
	305	.frontend_attach = dibusb_dib3000mb_frontend_attach,
	306	.tuner_attach = dibusb_tuner_probe_and_attach,
776338e1	307
01451e72	308	/* parameter for the MPEG2-data transfer */
4d43e13f PB	309	.stream = {
4d43e13f PB	310	.type = USB_BULK,
01451e72 PB	311	.count = 7,
	312	.endpoint = 0x02,
	313	.u = {
	314	.bulk = {
	315	.buffersize = 4096,
	316	}
	317	}
	318	},
77eed219	319	}},
4d43e13f PB	320	.size_of_priv = sizeof(struct dibusb_state),
	321	},
	322	},
	323	.power_ctrl = dibusb_power_ctrl,
	324
f72a27b8 MCC	325	.rc.legacy = {
f72a27b8 MCC	326	.rc_interval = DEFAULT_RC_INTERVAL,
2f4f58d6 MCC	327	.rc_map_table = rc_map_dibusb_table,
2f4f58d6 MCC	328	.rc_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
f72a27b8 MCC	329	.rc_query = dibusb_rc_query,
f72a27b8 MCC	330	},
4d43e13f PB	331
	332	.i2c_algo = &dibusb_i2c_algo,
	333
	334	.generic_bulk_ctrl_endpoint = 0x01,
776338e1	335
1157020d	336	#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
68293ddb JS	337	.num_device_descs = 2,
68293ddb JS	338	#else
776338e1	339	.num_device_descs = 1,
68293ddb	340	#endif
776338e1 JS	341	.devices = {
776338e1 JS	342	{ "Artec T1 USB1.1 TVBOX with AN2235",
d763479a MCC	343	{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_AN2235_COLD], NULL },
d763479a MCC	344	{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_AN2235_WARM], NULL },
776338e1	345	},
1157020d	346	#ifdef CONFIG_DVB_USB_DIBUSB_MB_FAULTY
68293ddb	347	{ "Artec T1 USB1.1 TVBOX with AN2235 (faulty USB IDs)",
d763479a	348	{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_ANCHOR_COLD], NULL },
68293ddb JS	349	{ NULL },
68293ddb JS	350	},
1157020d	351	{ NULL },
68293ddb	352	#endif
776338e1 JS	353	}
	354	};
	355
4d43e13f PB	356	static struct dvb_usb_device_properties dibusb2_0b_properties = {
4d43e13f PB	357	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
c251ef61	358
776338e1 JS	359	.usb_ctrl = CYPRESS_FX2,
776338e1 JS	360
8945c8c3	361	.firmware = "dvb-usb-adstech-usb2-02.fw",
776338e1	362
4d43e13f PB	363	.num_adapters = 1,
	364	.adapter = {
	365	{
77eed219 MK	366	.num_frontends = 1,
77eed219 MK	367	.fe = {{
4d43e13f PB	368	.caps = DVB_USB_ADAP_HAS_PID_FILTER \| DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4d43e13f PB	369	.pid_filter_count = 16,
776338e1	370
01451e72 PB	371	.streaming_ctrl = dibusb2_0_streaming_ctrl,
	372	.pid_filter = dibusb_pid_filter,
	373	.pid_filter_ctrl = dibusb_pid_filter_ctrl,
	374	.frontend_attach = dibusb_dib3000mb_frontend_attach,
	375	.tuner_attach = dibusb_thomson_tuner_attach,
	376
	377	/* parameter for the MPEG2-data transfer */
4d43e13f PB	378	.stream = {
4d43e13f PB	379	.type = USB_BULK,
01451e72 PB	380	.count = 7,
	381	.endpoint = 0x06,
	382	.u = {
	383	.bulk = {
	384	.buffersize = 4096,
	385	}
	386	}
	387	},
77eed219	388	}},
4d43e13f PB	389	.size_of_priv = sizeof(struct dibusb_state),
	390	}
	391	},
	392	.power_ctrl = dibusb2_0_power_ctrl,
	393
f72a27b8 MCC	394	.rc.legacy = {
f72a27b8 MCC	395	.rc_interval = DEFAULT_RC_INTERVAL,
2f4f58d6 MCC	396	.rc_map_table = rc_map_dibusb_table,
2f4f58d6 MCC	397	.rc_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
f72a27b8 MCC	398	.rc_query = dibusb_rc_query,
f72a27b8 MCC	399	},
4d43e13f PB	400
	401	.i2c_algo = &dibusb_i2c_algo,
	402
	403	.generic_bulk_ctrl_endpoint = 0x01,
776338e1	404
e69339d9	405	.num_device_descs = 2,
776338e1	406	.devices = {
e69339d9	407	{ "KWorld/ADSTech Instant DVB-T USB2.0",
d763479a MCC	408	{ &dibusb_dib3000mb_table[ADSTECH_USB2_COLD], NULL },
d763479a MCC	409	{ &dibusb_dib3000mb_table[ADSTECH_USB2_WARM], NULL },
776338e1	410	},
e69339d9	411	{ "KWorld Xpert DVB-T USB2.0",
d763479a	412	{ &dibusb_dib3000mb_table[KWORLD_VSTREAM_COLD], NULL },
e69339d9 PB	413	{ NULL }
e69339d9 PB	414	},
1157020d	415	{ NULL },
776338e1 JS	416	}
	417	};
	418
4d43e13f PB	419	static struct dvb_usb_device_properties artec_t1_usb2_properties = {
4d43e13f PB	420	.caps = DVB_USB_IS_AN_I2C_ADAPTER,
f6f4b725 PB	421
	422	.usb_ctrl = CYPRESS_FX2,
	423
	424	.firmware = "dvb-usb-dibusb-6.0.0.8.fw",
	425
4d43e13f PB	426	.num_adapters = 1,
	427	.adapter = {
	428	{
77eed219 MK	429	.num_frontends = 1,
77eed219 MK	430	.fe = {{
4d43e13f PB	431	.caps = DVB_USB_ADAP_HAS_PID_FILTER \| DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
4d43e13f PB	432	.pid_filter_count = 16,
f6f4b725	433
01451e72 PB	434	.streaming_ctrl = dibusb2_0_streaming_ctrl,
	435	.pid_filter = dibusb_pid_filter,
	436	.pid_filter_ctrl = dibusb_pid_filter_ctrl,
	437	.frontend_attach = dibusb_dib3000mb_frontend_attach,
	438	.tuner_attach = dibusb_tuner_probe_and_attach,
	439	/* parameter for the MPEG2-data transfer */
4d43e13f PB	440	.stream = {
4d43e13f PB	441	.type = USB_BULK,
01451e72 PB	442	.count = 7,
	443	.endpoint = 0x06,
	444	.u = {
	445	.bulk = {
	446	.buffersize = 4096,
	447	}
	448	}
	449	},
77eed219	450	}},
4d43e13f PB	451	.size_of_priv = sizeof(struct dibusb_state),
	452	}
	453	},
	454	.power_ctrl = dibusb2_0_power_ctrl,
	455
f72a27b8 MCC	456	.rc.legacy = {
f72a27b8 MCC	457	.rc_interval = DEFAULT_RC_INTERVAL,
2f4f58d6 MCC	458	.rc_map_table = rc_map_dibusb_table,
2f4f58d6 MCC	459	.rc_map_size = 111, /* wow, that is ugly ... I want to load it to the driver dynamically */
f72a27b8 MCC	460	.rc_query = dibusb_rc_query,
f72a27b8 MCC	461	},
4d43e13f PB	462
	463	.i2c_algo = &dibusb_i2c_algo,
	464
	465	.generic_bulk_ctrl_endpoint = 0x01,
f6f4b725 PB	466
	467	.num_device_descs = 1,
	468	.devices = {
	469	{ "Artec T1 USB2.0",
d763479a MCC	470	{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_USB2_COLD], NULL },
d763479a MCC	471	{ &dibusb_dib3000mb_table[ULTIMA_TVBOX_USB2_WARM], NULL },
f6f4b725	472	},
1157020d	473	{ NULL },
f6f4b725 PB	474	}
	475	};
	476
776338e1	477	static struct usb_driver dibusb_driver = {
63b5c1c4	478	.name = "dvb_usb_dibusb_mb",
776338e1 JS	479	.probe = dibusb_probe,
	480	.disconnect = dvb_usb_device_exit,
	481	.id_table = dibusb_dib3000mb_table,
	482	};
	483
ecb3b2b3	484	module_usb_driver(dibusb_driver);
776338e1	485
99e44da7	486	MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
776338e1 JS	487	MODULE_DESCRIPTION("Driver for DiBcom USB DVB-T devices (DiB3000M-B based)");
	488	MODULE_VERSION("1.0");
	489	MODULE_LICENSE("GPL");