Date: Sat, 5 Feb 2011 17:23:21 +0100 (CET) From: Yamagi Burmeister <lists@yamagi.org> To: freebsd-multimedia@freebsd.org Subject: [patch] webcamd support for TerraTec Cinergy TStick RC MK2 Message-ID: <alpine.BSF.2.00.1102051702470.82659@saya.home.yamagi.org>
next in thread | raw e-mail | index | archive | help
[-- Attachment #1 --] Hi, I recently bought a "TerraTec Cinergy TStick RC" in revision "MK2". This is currently unsupported by v4l and by webcamd but with somes hours hacking I was able to get i work. This stick is another af9015 device, the tuner is a rather uncommon tda18218. This work is based upon the patchset found here: http://media.cdn.ubuntu-de.org/forum/attachments/2489836/cinergy-stick-rc.patch.gz Attached are two patches. In case they're stripped by mailman they can be found on my webspace: http://deponie.yamagi.org/freebsd/dvbt/ Both patches are against webcamd r1724. cinergy_rc_mk2.diff This one adds support for the tda18218 tuner to v4l and the device id of the stick to af9015.c. This patch applies against the patched(!) v4l-dvb-abd3aac6644e/ directory. webcamd_r1724.diff This is the Makefile glue for the tda18218 tuner for the webcamd Makefile. It just adds the new file tda18218.c and the DCONFIG_MEDIA_TUNER_TDA18218 preprocessor makro. This device needs a firmware file named "dvb-usb-af9015.fw". For license reasons I won't upload it to my webspace but google is your friend... ---- Some information: dmesg: ugen2.2: <NEWMI> at usbus2 ukbd1: <NEWMI USB2.0 DVB-T TV Stick, class 0/0, rev 2.00/2.00, addr 2> on usbus2 kbd3 at ukbd1 usbconfig -u 2 -a 2 dump_device_desc: bLength = 0x0012 bDescriptorType = 0x0001 bcdUSB = 0x0200 bDeviceClass = 0x0000 bDeviceSubClass = 0x0000 bDeviceProtocol = 0x0000 bMaxPacketSize0 = 0x0040 idVendor = 0x0ccd idProduct = 0x0097 bcdDevice = 0x0200 iManufacturer = 0x0001 <NEWMI> iProduct = 0x0002 <USB2.0 DVB-T TV Stick> iSerialNumber = 0x0003 <010101010600001> bNumConfigurations = 0x0001 webcamd: Attached ugen2.2[0] to cuse unit 0 Creating /dev/dvb/adapter0/demux0 Creating /dev/dvb/adapter0/dvr0 Creating /dev/dvb/adapter0/frontend0 ---- Status: - Scan for dvb-t station with w_scan is working. All available stations are found. - Playback with mplayer works - Station switching with mplayer works ---- Little tutorial: % svn --username anonsvn --password anonsvn checkout \ svn://svn.turbocat.net/i4b/trunk/usbcam/ulinux % cd ulinux % make fetch % cd patches % ./do_patch.sh % cd .. % patch < webcamd_r1724.diff % patch < cinergy_rc_mk2.diff % make -j4 Ciao, Yamagi -- Homepage: www.yamagi.org Jabber: yamagi@yamagi.org GnuPG/GPG: 0xEFBCCBCB [-- Attachment #2 --] Index: Makefile =================================================================== --- Makefile (Revision 1724) +++ Makefile (Arbeitskopie) @@ -717,6 +717,7 @@ CFLAGS+= -DCONFIG_MEDIA_TUNER_QT1010 CFLAGS+= -DCONFIG_MEDIA_TUNER_SIMPLE CFLAGS+= -DCONFIG_MEDIA_TUNER_TDA18271 +CFLAGS+= -DCONFIG_MEDIA_TUNER_TDA18218 CFLAGS+= -DCONFIG_MEDIA_TUNER_TDA827X CFLAGS+= -DCONFIG_MEDIA_TUNER_TDA8290 CFLAGS+= -DCONFIG_MEDIA_TUNER_TDA9887 @@ -775,6 +776,7 @@ SRCS+= tda826x.c SRCS+= tda827x.c SRCS+= tda8290.c +SRCS+= tda18218.c SRCS+= tuner-simple.c SRCS+= tuner-types.c SRCS+= tuner-xc2028.c [-- Attachment #3 --] --- v4l-dvb-abd3aac6644e/linux/drivers/media/common/tuners/Kconfig.orig 2010-07-02 05:38:54.000000000 +0200 +++ v4l-dvb-abd3aac6644e/linux/drivers/media/common/tuners/Kconfig 2011-02-05 16:31:45.390146796 +0100 @@ -179,4 +179,11 @@ help A driver for the silicon tuner MAX2165 from Maxim. +config MEDIA_TUNER_TDA18218 + tristate "NXP TDA18218 silicon tuner" + depends on VIDEO_MEDIA && I2C + default m if MEDIA_TUNER_CUSTOMISE + help + A driver for the silicon tuner TDA18218 from NXP. + endif # MEDIA_TUNER_CUSTOMISE --- v4l-dvb-abd3aac6644e/linux/drivers/media/common/tuners/tda18218.c.orig 1970-01-01 01:00:00.000000000 +0100 +++ v4l-dvb-abd3aac6644e/linux/drivers/media/common/tuners/tda18218.c 2011-02-05 16:31:45.401175903 +0100 @@ -0,0 +1,471 @@ +/* + * Driver for NXP TDA18218 silicon tuner + * + * Copyright (C) 2010 Lauris Ding <lding@gmx.de> + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ +#include "tda18218.h" +#include "compat.h" +#include "tda18218_priv.h" + +static int tda18218_write_reg(struct dvb_frontend *fe, u8 reg, u8 val) +{ + struct tda18218_priv *priv = fe->tuner_priv; + u8 buf[2] = { reg, val }; + struct i2c_msg msg = { .addr = priv->cfg->i2c_address, .flags = 0, + .buf = buf, .len = 2 }; + int ret; + + if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl(fe, 1); + /* write register */ + ret = i2c_transfer(priv->i2c, &msg, 1); + if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl(fe, 0); + + if (ret != 1) + printk(KERN_WARNING "I2C write failed ret: %d reg: %02x\n", ret, reg); + + return (ret == 1 ? 0 : ret); +} + +static int tda18218_write_regs(struct dvb_frontend *fe, u8 reg, + u8 *val, u8 len) +{ + struct tda18218_priv *priv = fe->tuner_priv; + u8 buf[1+len]; + struct i2c_msg msg = { + .addr = priv->cfg->i2c_address, + .flags = 0, + .len = sizeof(buf), + .buf = buf }; + + int ret; + + buf[0] = reg; + memcpy(&buf[1], val, len); + + if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl(fe, 1); + ret = i2c_transfer(priv->i2c, &msg, 1); + if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl(fe, 1); + + if (ret != 1) + printk(KERN_WARNING "I2C write failed ret: %d reg: %02x len: %d\n", ret, reg, len); + + return (ret == 1 ? 0 : ret); +} + +/*static int tda18218_read_reg(struct tda18218_priv *priv, u16 reg, u8 *val) +{ + u8 obuf[3] = { reg >> 8, reg & 0xff, 0 }; + u8 ibuf[1]; + struct i2c_msg msg[2] = { + { + .addr = 0x3a, + .flags = 0, + .len = sizeof(obuf), + .buf = obuf + }, { + .addr = 0x3a, + .flags = I2C_M_RD, + .len = sizeof(ibuf), + .buf = ibuf + } + }; + + if (i2c_transfer(priv->i2c, msg, 2) != 2) { + printk(KERN_WARNING "I2C read failed reg:%04x\n", reg); + return -EREMOTEIO; + } + *val = ibuf[0]; + return 0; +}*/ + +static int tda18218_read_regs(struct dvb_frontend *fe) +{ + struct tda18218_priv *priv = fe->tuner_priv; + u8 *regs = priv->tda18218_regs; + u8 buf = 0x00; + int ret; + //int i; + struct i2c_msg msg[] = { + { .addr = 0xc0, .flags = 0, + .buf = &buf, .len = 1 }, + { .addr = 0xc0, .flags = I2C_M_RD, + .buf = regs, .len = 59 } + }; + + if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl(fe, 1); + + /* read all registers */ + ret = i2c_transfer(priv->i2c, msg, 2); + + if (fe->ops.i2c_gate_ctrl) + fe->ops.i2c_gate_ctrl(fe, 0); + + if (ret != 2) + printk(KERN_WARNING "I2C read failed ret: %d\n", ret); + + /*for(i = 0; i <= 58; i++) + printk("Register %d: %02x\n", i, 0xff & regs[i]);*/ + + return (ret == 2 ? 0 : ret); +} + +static int tda18218_set_params(struct dvb_frontend *fe, struct dvb_frontend_parameters *params) +{ + struct tda18218_priv *priv = fe->tuner_priv; + u8 *regs = priv->tda18218_regs; + u8 Fc, BP; + int i, ret; + u16 if1, bw; + u32 freq; + + u8 paramsbuf[4][6] = { + { 0x03, 0x1a }, + { 0x04, 0x0a }, + { 0x01, 0x0f }, + { 0x01, 0x0f }, + }; + + u8 agcbuf[][2] = { + { 0x1a, 0x0e }, + { 0x20, 0x60 }, + { 0x23, 0x02 }, + { 0x20, 0xa0 }, + { 0x23, 0x09 }, + { 0x20, 0xe0 }, + { 0x23, 0x0c }, + { 0x20, 0x40 }, + { 0x23, 0x01 }, + { 0x20, 0x80 }, + { 0x23, 0x08 }, + { 0x20, 0xc0 }, + { 0x23, 0x0b }, + { 0x24, 0x1c }, + { 0x24, 0x0c }, + }; + + switch (params->u.ofdm.bandwidth) { + case BANDWIDTH_6_MHZ: + bw = 6000; + Fc = 0; + break; + case BANDWIDTH_7_MHZ: + bw = 7000; + Fc = 1; + break; + case BANDWIDTH_8_MHZ: + bw = 8000; + Fc = 2; + break; + default: + printk(KERN_WARNING "Invalid bandwidth"); + return -EINVAL; + } + + if1 = bw / 2; + + if((params->frequency >= 174000000) && (params->frequency < 188000000)) { + BP = 3; + } + else if((params->frequency >= 188000000) && (params->frequency < 253000000)) { + BP = 4; + } + else if((params->frequency >= 253000000) && (params->frequency < 343000000)) { + BP = 5; + } + else if((params->frequency >= 343000000) && (params->frequency <= 870000000)) { + BP = 6; + } + else { + printk(KERN_WARNING "Frequency out of range"); + return -EINVAL; + } + + freq = params->frequency; + freq /= 1000; + freq +=if1; + freq *= 16; + + tda18218_read_regs(fe); + + paramsbuf[0][2] = regs[0x1a] | BP; + paramsbuf[0][3] = regs[0x1b] & ~3; + paramsbuf[0][3] = regs[0x1b] | Fc; + paramsbuf[0][4] = regs[0x1c] | 0x0a; + + paramsbuf[1][2] = freq >> 16; + paramsbuf[1][3] = freq >> 8; + paramsbuf[1][4] = (freq & 0xf0) | (regs[0x0c] & 0x0f); + paramsbuf[1][5] = 0xff; + paramsbuf[2][2] = regs[0x0f] | 0x40; + paramsbuf[3][2] = 0x09; + + tda18218_write_reg(fe, 0x04, 0x03); + + for(i = 0; i < ARRAY_SIZE(paramsbuf); i++) { + + /* write registers */ + ret = tda18218_write_regs(fe, paramsbuf[i][1], ¶msbuf[i][2], paramsbuf[i][0]); + + if (ret) + goto error; + } + for(i = 0; i < ARRAY_SIZE(agcbuf); i++) { + tda18218_write_reg(fe, agcbuf[i][0], agcbuf[i][1]); + } + + //tda18218_write_reg(fe, 0x03, 0x00); + //tda18218_write_reg(fe, 0x04, 0x00); + //tda18218_write_reg(fe, 0x20, 0xc7); + + msleep(60); + i = 0; + while(i < 10) { + tda18218_read_regs(fe); + if((regs[0x01] & 0x60) == 0x60) + printk(KERN_INFO "We've got a lock!"); break; + msleep(20); + i++; + } + + priv->bandwidth = params->u.ofdm.bandwidth; + priv->frequency = params->frequency; + return 0; +error: + return ret; +} + +static int tda18218_get_frequency(struct dvb_frontend *fe, u32 *frequency) +{ + struct tda18218_priv *priv = fe->tuner_priv; + *frequency = priv->frequency; + return 0; +} + +static int tda18218_get_bandwidth(struct dvb_frontend *fe, u32 *bandwidth) +{ + struct tda18218_priv *priv = fe->tuner_priv; + *bandwidth = priv->bandwidth; + return 0; +} + +static int tda18218_init(struct dvb_frontend *fe) +{ + //struct tda18218_priv *priv = fe->tuner_priv; + //u8 *regs = priv->tda18218_regs; + int i; + int ret; + + u8 initbuf[][18] = { + { 0x10, 0x05, 0x00, 0x00, 0xd0, 0x00, 0x40, 0x00, 0x00, 0x07, 0xff, 0x84, 0x09, 0x00, 0x13, 0x00, 0x00, 0x01 }, + { 0x0b, 0x15, 0x84, 0x09, 0xf0, 0x19, 0x0a, 0x0e, 0x29, 0x98, 0x00, 0x00, 0x58 }, + { 0x10, 0x24, 0x0c, 0x48, 0x85, 0xc9, 0xa7, 0x00, 0x00, 0x00, 0x30, 0x81, 0x80, 0x00, 0x39, 0x00, 0x8a, 0x00 }, + { 0x07, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf6, 0xf6 }, + }; + + u8 initbuf2[4]; + + for(i = 0; i < ARRAY_SIZE(initbuf); i++) { + + /* write registers */ + ret = tda18218_write_regs(fe, initbuf[i][1], &initbuf[i][2], initbuf[i][0]); + + if (ret != 0) { + printk(KERN_ERR "init: ERROR: i2c_transfer returned: %d\n", ret); + return -EREMOTEIO; + } + if(i == 1) { + tda18218_write_reg(fe, 0x22, 0x8c); + } + } + + tda18218_write_reg(fe, 0x05, 0x80); + tda18218_write_reg(fe, 0x05, 0x00); + tda18218_write_reg(fe, 0x05, 0x20); + tda18218_write_reg(fe, 0x05, 0x00); + tda18218_write_reg(fe, 0x27, 0xde); + tda18218_write_reg(fe, 0x17, 0xf8); + tda18218_write_reg(fe, 0x18, 0x0f); + tda18218_write_reg(fe, 0x1c, 0x8b); + tda18218_write_reg(fe, 0x29, 0x02); + tda18218_write_reg(fe, 0x19, 0x1a); + tda18218_write_reg(fe, 0x11, 0x13); + + initbuf2[0] = 0x0a; + initbuf2[1] = 0x5c; + initbuf2[2] = 0xc6; + initbuf2[3] = 0x07; + tda18218_write_regs(fe, initbuf2[0], &initbuf2[1], 3); + tda18218_write_reg(fe, 0x0f, 0x49); + tda18218_write_reg(fe, 0x05, 0x40); + tda18218_write_reg(fe, 0x05, 0x00); + tda18218_write_reg(fe, 0x05, 0x20); + tda18218_write_reg(fe, 0x11, 0xed); + tda18218_write_reg(fe, 0x0f, 0x49); + tda18218_write_reg(fe, 0x19, 0x2a); + tda18218_write_reg(fe, 0x05, 0x58); + tda18218_write_reg(fe, 0x05, 0x18); + tda18218_write_reg(fe, 0x05, 0x38); + tda18218_write_reg(fe, 0x29, 0x03); + tda18218_write_reg(fe, 0x19, 0x1a); + tda18218_write_reg(fe, 0x11, 0x13); + initbuf2[0] = 0x0a; + initbuf2[1] = 0xbe; + initbuf2[2] = 0x6e; + initbuf2[3] = 0x07; + tda18218_write_regs(fe, initbuf2[0], &initbuf2[1], 3); + tda18218_write_reg(fe, 0x0f, 0x49); + tda18218_write_reg(fe, 0x05, 0x58); + tda18218_write_reg(fe, 0x05, 0x18); + tda18218_write_reg(fe, 0x05, 0x38); + tda18218_write_reg(fe, 0x11, 0xed); + tda18218_write_reg(fe, 0x0f, 0x49); + tda18218_write_reg(fe, 0x19, 0x2a); + tda18218_write_reg(fe, 0x05, 0x58); + tda18218_write_reg(fe, 0x05, 0x18); + tda18218_write_reg(fe, 0x05, 0x38); + tda18218_write_reg(fe, 0x19, 0x0a); + tda18218_write_reg(fe, 0x27, 0xc9); + tda18218_write_reg(fe, 0x11, 0x13); + initbuf2[0] = 0x17; + initbuf2[1] = 0xf0; + initbuf2[2] = 0x19; + initbuf2[3] = 0x00; + tda18218_write_regs(fe, initbuf2[0], &initbuf2[1], 2); + tda18218_write_reg(fe, 0x1c, 0x98); + tda18218_write_reg(fe, 0x29, 0x03); + tda18218_write_reg(fe, 0x2a, 0x00); + tda18218_write_reg(fe, 0x2a, 0x01); + tda18218_write_reg(fe, 0x2a, 0x02); + tda18218_write_reg(fe, 0x2a, 0x03); + tda18218_write_reg(fe, 0x1c, 0x98); + tda18218_write_reg(fe, 0x18, 0x19); + tda18218_write_reg(fe, 0x22, 0x9c); + tda18218_write_reg(fe, 0x1f, 0x58); + tda18218_write_reg(fe, 0x24, 0x0c); + tda18218_write_reg(fe, 0x1c, 0x88); + tda18218_write_reg(fe, 0x20, 0x10); + tda18218_write_reg(fe, 0x21, 0x4c); + tda18218_write_reg(fe, 0x20, 0x00); + tda18218_write_reg(fe, 0x21, 0x48); + tda18218_write_reg(fe, 0x1f, 0x5b); + tda18218_write_reg(fe, 0x20, 0x00); + tda18218_write_reg(fe, 0x1f, 0x59); + tda18218_write_reg(fe, 0x20, 0x00); + tda18218_write_reg(fe, 0x1f, 0x5a); + tda18218_write_reg(fe, 0x20, 0x00); + tda18218_write_reg(fe, 0x1f, 0x5f); + tda18218_write_reg(fe, 0x20, 0x00); + tda18218_write_reg(fe, 0x1f, 0x5d); + tda18218_write_reg(fe, 0x20, 0x00); + tda18218_write_reg(fe, 0x1f, 0x5e); + tda18218_write_reg(fe, 0x20, 0x00); + tda18218_write_reg(fe, 0x20, 0x60); + tda18218_write_reg(fe, 0x23, 0x02); + tda18218_write_reg(fe, 0x20, 0xa0); + tda18218_write_reg(fe, 0x23, 0x09); + tda18218_write_reg(fe, 0x20, 0xe0); + tda18218_write_reg(fe, 0x23, 0x0c); + tda18218_write_reg(fe, 0x20, 0x40); + tda18218_write_reg(fe, 0x23, 0x01); + tda18218_write_reg(fe, 0x20, 0x80); + tda18218_write_reg(fe, 0x23, 0x08); + tda18218_write_reg(fe, 0x20, 0xc0); + tda18218_write_reg(fe, 0x23, 0x0b); + tda18218_write_reg(fe, 0x1c, 0x98); + tda18218_write_reg(fe, 0x22, 0x8c); + initbuf2[0] = 0x17; + initbuf2[1] = 0xb0; + initbuf2[2] = 0x59; + initbuf2[3] = 0x00; + //tda18218_write_regs(fe, initbuf2[0], &initbuf2[1], 2); + initbuf2[0] = 0x1a; + initbuf2[1] = 0x0e; + initbuf2[2] = 0x2a; + initbuf2[3] = 0x98; + tda18218_write_regs(fe, initbuf2[0], &initbuf2[1], 3); + initbuf2[0] = 0x17; + initbuf2[1] = 0xb0; + initbuf2[2] = 0x59; + initbuf2[3] = 0x00; + tda18218_write_regs(fe, initbuf2[0], &initbuf2[1], 2); + tda18218_write_reg(fe, 0x2d, 0x81); + tda18218_write_reg(fe, 0x29, 0x02); + + return 0; +} + +static int tda18218_release(struct dvb_frontend *fe) +{ + kfree(fe->tuner_priv); + fe->tuner_priv = NULL; + return 0; +} + +static const struct dvb_tuner_ops tda18218_tuner_ops = { + .info = { + .name = "NXP TDA18218", + .frequency_min = TDA18218_MIN_FREQ, + .frequency_max = TDA18218_MAX_FREQ, + .frequency_step = TDA18218_STEP, + }, + + .release = tda18218_release, + .init = tda18218_init, + + .set_params = tda18218_set_params, + .get_frequency = tda18218_get_frequency, + .get_bandwidth = tda18218_get_bandwidth, +}; + +struct dvb_frontend * tda18218_attach(struct dvb_frontend *fe, + struct i2c_adapter *i2c, + struct tda18218_config *cfg) +{ + struct tda18218_priv *priv = NULL; + + priv = kzalloc(sizeof(struct tda18218_priv), GFP_KERNEL); + if (priv == NULL) + return NULL; + + priv->cfg = cfg; + priv->i2c = i2c; + + fe->tuner_priv = priv; + + tda18218_read_regs(fe); + if (priv->tda18218_regs[0x00] != 0xc0) { + printk(KERN_WARNING "Device is not a TDA18218!\n"); + kfree(priv); + return NULL; + } + + printk(KERN_INFO "NXP TDA18218 successfully identified.\n"); + memcpy(&fe->ops.tuner_ops, &tda18218_tuner_ops, + sizeof(struct dvb_tuner_ops)); + + return fe; +} +EXPORT_SYMBOL(tda18218_attach); + +MODULE_DESCRIPTION("NXP TDA18218 silicon tuner driver"); +MODULE_AUTHOR("Lauris Ding <lding@gmx.de>"); +MODULE_VERSION("0.1"); +MODULE_LICENSE("GPL"); --- v4l-dvb-abd3aac6644e/linux/drivers/media/common/tuners/tda18218.h.orig 1970-01-01 01:00:00.000000000 +0100 +++ v4l-dvb-abd3aac6644e/linux/drivers/media/common/tuners/tda18218.h 2011-02-05 16:31:45.403181424 +0100 @@ -0,0 +1,44 @@ +/* + * Driver for NXP TDA18218 silicon tuner + * + * Copyright (C) 2010 Lauris Ding <lding@gmx.de> + * + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef TDA18218_H +#define TDA18218_H + +#include "dvb_frontend.h" + +struct tda18218_config { + u8 i2c_address; +}; + +#if defined(CONFIG_MEDIA_TUNER_TDA18218) || (defined(CONFIG_MEDIA_TUNER_TDA18218_MODULE) && defined(MODULE)) +extern struct dvb_frontend *tda18218_attach(struct dvb_frontend *fe, + struct i2c_adapter *i2c, + struct tda18218_config *cfg); +#else +static inline struct dvb_frontend *tda18218_attach(struct dvb_frontend *fe, + struct i2c_adapter *i2c, + struct tda18218_config *cfg) +{ + printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __func__); + return NULL; +} +#endif // CONFIG_MEDIA_TUNER_TDA18218 + +#endif --- v4l-dvb-abd3aac6644e/linux/drivers/media/common/tuners/tda18218_priv.h.orig 1970-01-01 01:00:00.000000000 +0100 +++ v4l-dvb-abd3aac6644e/linux/drivers/media/common/tuners/tda18218_priv.h 2011-02-05 16:31:45.406192087 +0100 @@ -0,0 +1,36 @@ +/* + * Driver for NXP TDA18218 silicon tuner + * + * Copyright (C) 2010 Lauris Ding <lding@gmx.de> + * 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. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + */ + +#ifndef TDA18218_PRIV_H +#define TDA18218_PRIV_H + +#define TDA18218_STEP 1000 /* 1 kHz */ +#define TDA18218_MIN_FREQ 174000000 /* 174 MHz */ +#define TDA18218_MAX_FREQ 864000000 /* 864 MHz */ + +struct tda18218_priv { + u8 tda18218_regs[0x3b]; + struct tda18218_config *cfg; + struct i2c_adapter *i2c; + + u32 frequency; + u32 bandwidth; +}; + +#endif --- v4l-dvb-abd3aac6644e/linux/drivers/media/dvb/dvb-usb/af9015.c.orig 2011-02-05 16:46:13.295011366 +0100 +++ v4l-dvb-abd3aac6644e/linux/drivers/media/dvb/dvb-usb/af9015.c 2011-02-05 16:31:45.410196128 +0100 @@ -33,6 +33,7 @@ #include "tda18271.h" #include "mxl5005s.h" #include "mc44s803.h" +#include "tda18218.h" static int dvb_usb_af9015_debug; module_param_named(debug, dvb_usb_af9015_debug, int, 0644); @@ -1042,8 +1043,8 @@ af9015_af9013_config[i].rf_spec_inv = 1; break; case AF9013_TUNER_TDA18218: - warn("tuner NXP TDA18218 not supported yet"); - return -ENODEV; + af9015_af9013_config[i].rf_spec_inv = 1; + break; default: warn("tuner id:%d not supported, please report!", val); return -ENODEV; @@ -1251,6 +1252,10 @@ .dig_out = 1, }; +static struct tda18218_config af9015_tda18218_config = { + .i2c_address = 0xc0, +}; + static int af9015_tuner_attach(struct dvb_usb_adapter *adap) { struct af9015_state *state = adap->dev->priv; @@ -1298,6 +1303,9 @@ ret = dvb_attach(mc44s803_attach, adap->fe, i2c_adap, &af9015_mc44s803_config) == NULL ? -ENODEV : 0; break; + case AF9013_TUNER_TDA18218: + ret = dvb_attach(tda18218_attach, adap->fe, i2c_adap, + &af9015_tda18218_config) == NULL ? -ENODEV : 0; case AF9013_TUNER_UNKNOWN: default: ret = -ENODEV; @@ -1342,6 +1350,7 @@ {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS)}, /* 30 */{USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T)}, {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4)}, + {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_RC)}, {0}, }; MODULE_DEVICE_TABLE(usb, af9015_usb_table); @@ -1618,7 +1627,7 @@ .i2c_algo = &af9015_i2c_algo, - .num_device_descs = 8, /* max 9 */ + .num_device_descs = 9, /* max 9 */ .devices = { { .name = "AverMedia AVerTV Volar GPS 805 (A805)", @@ -1663,6 +1672,12 @@ .cold_ids = {&af9015_usb_table[30], NULL}, .warm_ids = {NULL}, }, + { + .name = "TerraTec Cinergy T Stick RC", + .cold_ids = {&af9015_usb_table[32], NULL}, + .warm_ids = {NULL}, + }, + } }, }; --- v4l-dvb-abd3aac6644e/linux/drivers/media/dvb/dvb-usb/dvb-usb-ids.h.orig 2011-02-05 16:46:09.669711617 +0100 +++ v4l-dvb-abd3aac6644e/linux/drivers/media/dvb/dvb-usb/dvb-usb-ids.h 2011-02-05 16:32:29.349888269 +0100 @@ -184,6 +184,7 @@ #define USB_PID_TERRATEC_CINERGY_T_EXPRESS 0x0062 #define USB_PID_TERRATEC_CINERGY_T_USB_XE 0x0055 #define USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2 0x0069 +#define USB_PID_TERRATEC_CINERGY_T_STICK_RC 0x0097 #define USB_PID_TERRATEC_CINERGY_T_XXS 0x0078 #define USB_PID_TERRATEC_CINERGY_T_XXS_2 0x00ab #define USB_PID_TERRATEC_DVBS2CI_V1 0x10a4 --- v4l-dvb-abd3aac6644e/linux/drivers/media/dvb/frontends/af9013.c.orig 2010-07-02 05:38:54.000000000 +0200 +++ v4l-dvb-abd3aac6644e/linux/drivers/media/dvb/frontends/af9013.c 2011-02-05 16:31:45.417214752 +0100 @@ -488,6 +488,21 @@ break; } } + else if(state->config.tuner == AF9013_TUNER_TDA18218) { + switch (bw) { + case BANDWIDTH_6_MHZ: + if_sample_freq = 3000000; /* 3 MHz */ + break; + case BANDWIDTH_7_MHZ: + if_sample_freq = 3500000; /* 3.5 MHz */ + break; + case BANDWIDTH_8_MHZ: + default: + if_sample_freq = 4000000; /* 4 MHz */ + break; + } + } + while (if_sample_freq > (adc_freq / 2)) if_sample_freq = if_sample_freq - adc_freq; @@ -1390,6 +1405,7 @@ init = tuner_init_mt2060_2; break; case AF9013_TUNER_TDA18271: + case AF9013_TUNER_TDA18218: len = ARRAY_SIZE(tuner_init_tda18271); init = tuner_init_tda18271; break; --- v4l-dvb-abd3aac6644e/linux/drivers/media/dvb/frontends/af9013_priv.h.orig 2010-07-02 05:38:54.000000000 +0200 +++ v4l-dvb-abd3aac6644e/linux/drivers/media/dvb/frontends/af9013_priv.h 2011-02-05 16:31:45.420220654 +0100 @@ -790,7 +790,8 @@ }; /* NXP TDA18271 tuner init - AF9013_TUNER_TDA18271 = 156 */ + AF9013_TUNER_TDA18271 = 156 + AF9013_TUNER_TDA18218 = 179 */ static struct regdesc tuner_init_tda18271[] = { { 0x9bd5, 0, 8, 0x01 }, { 0x9bd6, 0, 8, 0x04 },
Want to link to this message? Use this URL: <https://mail-archive.FreeBSD.org/cgi/mid.cgi?alpine.BSF.2.00.1102051702470.82659>