I'm trying to hack the m920x driver for my "LifeView TV Walker Twin"
DVB-T USB 2.0. Having some success and some failure, cause I'm new
to this and I mostly don't know what I'm doing.
The device has an M9206, two TDA10046A, and two TDA8275A. Mine seems
to be permanently in the "warm" state now, so despite the work I did
to extract the firmware, it seems I don't need it at the moment.
I'm using the latest code from the main hg repository.
Questions :-
- It has 2 tuners and 2 demodulators. I think I found the two
demodulators, at addresses 0x10 and 0x16. I have no idea how to
represent two of them in the code. You'll notice that I call
dvb_attach twice, but it overwrites the return value.
Does m920x_state need to be extended for this?
- I have no idea where the two tuners are. I set up a loop to query
all 255 addresses and the module reports failure on the first one
then hangs trying to query the second one. The loop technique
worked to find the demodulators at least :-)
I'm running this under vmware emulation so it doesn't break the
host machine.
I've attached my hacked m9206.c module and kernel log.
Nick.
--
PGP Key ID = 0x418487E7 http://www.nick-andrew.net/
PGP Key fingerprint = B3ED 6894 8E49 1770 C24A 67E3 6266 6EB9 4184 87E7
"I'm not out to destroy Microsoft. That will just be a completely
unintentional side effect." -- Linus Torvalds, Sep 2003
/* DVB USB compliant linux driver for MSI Mega Sky 580 DVB-T USB2.0 receiver
*
* Copyright (C) 2006 Aapo Tahkola (aet@xxxxxxxxxxxxxx)
*
* 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, version 2.
*
* see Documentation/dvb/README.dvb-usb for more information
*/
#include "m920x.h"
#include "tda1004x.h"
#include "tda827x.h"
#include "qt1010.h"
/* debug */
static int dvb_usb_m920x_debug;
module_param_named(debug,dvb_usb_m920x_debug, int, 0644);
MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
static struct dvb_usb_rc_key megasky_rc_keys [] = {
{ 0x0, 0x12, KEY_POWER },
{ 0x0, 0x1e, KEY_CYCLEWINDOWS }, /* min/max */
{ 0x0, 0x02, KEY_CHANNELUP },
{ 0x0, 0x05, KEY_CHANNELDOWN },
{ 0x0, 0x03, KEY_VOLUMEUP },
{ 0x0, 0x06, KEY_VOLUMEDOWN },
{ 0x0, 0x04, KEY_MUTE },
{ 0x0, 0x07, KEY_OK }, /* TS */
{ 0x0, 0x08, KEY_STOP },
{ 0x0, 0x09, KEY_MENU }, /* swap */
{ 0x0, 0x0a, KEY_REWIND },
{ 0x0, 0x1b, KEY_PAUSE },
{ 0x0, 0x1f, KEY_FASTFORWARD },
{ 0x0, 0x0c, KEY_RECORD },
{ 0x0, 0x0d, KEY_CAMERA }, /* screenshot */
{ 0x0, 0x0e, KEY_COFFEE }, /* "MTS" */
};
static inline int m9206_read(struct usb_device *udev, u8 request, u16 value,\
u16 index, void *data, int size)
{
int ret;
ret = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0),
request, USB_TYPE_VENDOR | USB_DIR_IN,
value, index, data, size, 2000);
if (ret < 0) {
printk(KERN_INFO "m9206_read = error: %d\n", ret);
return ret;
}
if (ret != size) {
deb_rc("m9206_read: read %d of %d bytes\n", ret, size);
return -EIO;
}
return 0;
}
static inline int m9206_write(struct usb_device *udev, u8 request,
u16 value, u16 index)
{
int ret;
ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
request, USB_TYPE_VENDOR | USB_DIR_OUT,
value, index, NULL, 0, 2000);
return ret;
}
static int m9206_rc_init(struct usb_device *udev)
{
int ret = 0;
/* Remote controller init. */
if ((ret = m9206_write(udev, M9206_CORE, 0xa8, M9206_RC_INIT2)) != 0)
return ret;
if ((ret = m9206_write(udev, M9206_CORE, 0x51, M9206_RC_INIT1)) != 0)
return ret;
return ret;
}
static int m9206_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
{
struct m9206_state *m = d->priv;
int i, ret = 0;
u8 rc_state[2];
#if 0
if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
return -EAGAIN;
#endif
if ((ret = m9206_read(d->udev, M9206_CORE, 0x0, M9206_RC_STATE, rc_state, 1)) != 0)
goto unlock;
if ((ret = m9206_read(d->udev, M9206_CORE, 0x0, M9206_RC_KEY, rc_state + 1, 1)) != 0)
goto unlock;
for (i = 0; i < ARRAY_SIZE(megasky_rc_keys); i++)
if (megasky_rc_keys[i].data == rc_state[1]) {
*event = megasky_rc_keys[i].event;
switch(rc_state[0]) {
case 0x80:
*state = REMOTE_NO_KEY_PRESSED;
goto unlock;
case 0x93:
case 0x92:
m->rep_count = 0;
*state = REMOTE_KEY_PRESSED;
goto unlock;
case 0x91:
/* For comfort. */
if (++m->rep_count > 2)
*state = REMOTE_KEY_REPEAT;
goto unlock;
default:
deb_rc("Unexpected rc response %x\n", rc_state[0]);
*state = REMOTE_NO_KEY_PRESSED;
goto unlock;
}
}
if (rc_state[1] != 0)
deb_rc("Unknown rc key %x\n", rc_state[1]);
*state = REMOTE_NO_KEY_PRESSED;
unlock:
#if 0
mutex_unlock(&d->i2c_mutex);
#endif
return ret;
}
/* I2C */
static int m9206_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
int num)
{
struct dvb_usb_device *d = i2c_get_adapdata(adap);
struct m9206_state *m = d->priv;
int i;
int ret = 0;
if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
return -EAGAIN;
if (num > 2)
return -EINVAL;
for (i = 0; i < num; i++) {
if ((ret = m9206_write(d->udev, M9206_I2C, msg[i].addr, 0x80)) != 0)
goto unlock;
if ((ret = m9206_write(d->udev, M9206_I2C, msg[i].buf[0], 0x0)) != 0)
goto unlock;
if (i + 1 < num && msg[i + 1].flags & I2C_M_RD) {
int i2c_i;
for (i2c_i = 0; i2c_i < M9206_I2C_MAX; i2c_i++)
if (msg[i].addr == m->i2c_r[i2c_i].addr)
break;
if (i2c_i >= M9206_I2C_MAX) {
deb_rc("No magic for i2c addr!\n");
ret = -EINVAL;
goto unlock;
}
if ((ret = m9206_write(d->udev, M9206_I2C, m->i2c_r[i2c_i].magic, 0x80)) != 0)
goto unlock;
if ((ret = m9206_read(d->udev, M9206_I2C, 0x0, 0x60, msg[i + 1].buf, msg[i + 1].len)) != 0)
goto unlock;
i++;
} else {
if (msg[i].len != 2)
return -EINVAL;
if ((ret = m9206_write(d->udev, M9206_I2C, msg[i].buf[1], 0x40)) != 0)
goto unlock;
}
}
ret = i;
unlock:
mutex_unlock(&d->i2c_mutex);
return ret;
}
static u32 m9206_i2c_func(struct i2c_adapter *adapter)
{
return I2C_FUNC_I2C;
}
static struct i2c_algorithm m9206_i2c_algo = {
.master_xfer = m9206_i2c_xfer,
.functionality = m9206_i2c_func,
};
static int m9206_set_filter(struct dvb_usb_adapter *adap, int type, int idx,
int pid)
{
int ret = 0;
if (pid >= 0x8000)
return -EINVAL;
pid |= 0x8000;
if ((ret = m9206_write(adap->dev->udev, M9206_FILTER, pid, (type << 8) | (idx * 4) )) != 0)
return ret;
if ((ret = m9206_write(adap->dev->udev, M9206_FILTER, 0, (type << 8) | (idx * 4) )) != 0)
return ret;
return ret;
}
static int m9206_update_filters(struct dvb_usb_adapter *adap)
{
struct m9206_state *m = adap->dev->priv;
int enabled = m->filtering_enabled;
int i, ret = 0, filter = 0;
for (i = 0; i < M9206_MAX_FILTERS; i++)
if (m->filters[i] == 8192)
enabled = 0;
/* Disable all filters */
if ((ret = m9206_set_filter(adap, 0x81, 1, enabled)) != 0)
return ret;
for (i = 0; i < M9206_MAX_FILTERS; i++)
if ((ret = m9206_set_filter(adap, 0x81, i + 2, 0)) != 0)
return ret;
if ((ret = m9206_set_filter(adap, 0x82, 0, 0x0)) != 0)
return ret;
/* Set */
if (enabled) {
for (i = 0; i < M9206_MAX_FILTERS; i++) {
if (m->filters[i] == 0)
continue;
if ((ret = m9206_set_filter(adap, 0x81, filter + 2, m->filters[i])) != 0)
return ret;
filter++;
}
}
if ((ret = m9206_set_filter(adap, 0x82, 0, 0x02f5)) != 0)
return ret;
return ret;
}
static int m9206_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
{
struct m9206_state *m = adap->dev->priv;
m->filtering_enabled = onoff ? 1 : 0;
return m9206_update_filters(adap);
}
static int m9206_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
int onoff)
{
struct m9206_state *m = adap->dev->priv;
m->filters[index] = onoff ? pid : 0;
return m9206_update_filters(adap);
}
static int m9206_firmware_download(struct usb_device *udev,
const struct firmware *fw)
{
u16 value, index, size;
u8 read[4], *buff;
int i, pass, ret = 0;
deb_rc("Entering m9206_firmware_download\n");
buff = kmalloc(65536, GFP_KERNEL);
if ((ret = m9206_read(udev, M9206_FILTER, 0x0, 0x8000, read, 4)) != 0)
goto done;
deb_rc("%x %x %x %x\n", read[0], read[1], read[2], read[3]);
if ((ret = m9206_read(udev, M9206_FW, 0x0, 0x0, read, 1)) != 0)
goto done;
deb_rc("%x\n", read[0]);
for (pass = 0; pass < 2; pass++) {
deb_rc("Pass %d, fw->size is %d\n", pass, fw->size);
for (i = 0; i + (sizeof(u16) * 3) < fw->size;) {
int old_i = i;
value = le16_to_cpu(*(u16 *)(fw->data + i));
i += sizeof(u16);
index = le16_to_cpu(*(u16 *)(fw->data + i));
i += sizeof(u16);
size = le16_to_cpu(*(u16 *)(fw->data + i));
i += sizeof(u16);
deb_rc("Update i from %d to %d, value 0x%x, index %x, size %x\n", old_i, i, value, index, size);
if (pass == 1) {
/* Will stall if using fw->data ... */
memcpy(buff, fw->data + i, size);
ret = usb_control_msg(udev, usb_sndctrlpipe(udev,0),
M9206_FW,
USB_TYPE_VENDOR | USB_DIR_OUT,
value, index, buff, size, 20);
if (ret != size) {
deb_rc("error while uploading fw!\n");
ret = -EIO;
goto done;
}
msleep(3);
}
i += size;
}
if (i != fw->size) {
ret = -EINVAL;
deb_rc("Size mismatch, fw->size is %d, i is %d\n", fw->size, i);
goto done;
}
}
msleep(36);
/* m9206 will disconnect itself from the bus after this. */
(void) m9206_write(udev, M9206_CORE, 0x01, M9206_FW_GO);
deb_rc("firmware uploaded!\n");
done:
kfree(buff);
if (ret) {
deb_rc("Looks like it did not work: %d\n", ret);
}
return ret;
}
/* Callbacks for DVB USB */
static int megasky_identify_state(struct usb_device *udev,
struct dvb_usb_device_properties *props,
struct dvb_usb_device_description **desc,
int *cold)
{
struct usb_host_interface *alt;
deb_rc("Entering m9206_identify_state\n");
alt = usb_altnum_to_altsetting(usb_ifnum_to_if(udev, 0), 1);
*cold = (alt == NULL) ? 1 : 0;
deb_rc("Leaving m9206_identify_state: cold is %d\n", *cold);
return 0;
}
static struct tda1004x_config megasky_tda10046_config = {
//.demod_address = 0x1e,
// .no_tuner = 1,
.demod_address = 0x10,
.invert = 0,
.invert_oclk = 0,
.xtal_freq = TDA10046_XTAL_16M,
.if_freq = TDA10046_FREQ_045,
// .request_firmware = philips_tda1004x_request_firmware,
};
static struct tda1004x_config tvw_twin_tda10046_config1 = {
//.demod_address = 0x1e,
// .no_tuner = 1,
.demod_address = 0x10,
.invert = 0,
.invert_oclk = 0,
.xtal_freq = TDA10046_XTAL_16M,
.if_freq = TDA10046_FREQ_045,
// missing .tuner_address
// missing .tuner_config
// .request_firmware = philips_tda1004x_request_firmware,
};
static struct tda1004x_config tvw_twin_tda10046_config2 = {
//.demod_address = 0x1e,
// .no_tuner = 1,
.demod_address = 0x16,
.invert = 0,
.invert_oclk = 0,
.xtal_freq = TDA10046_XTAL_16M,
.if_freq = TDA10046_FREQ_045,
// missing .tuner_address
// missing .tuner_config
// .request_firmware = philips_tda1004x_request_firmware,
};
static int megasky_tda10046_attach(struct dvb_usb_adapter *adap)
{
struct m9206_state *m = adap->dev->priv;
int i;
int address;
deb_rc("Entering megasky_tda10046_attach!\n");
address = 0x10;
m->i2c_r[M9206_I2C_DEMOD].addr = address;
m->i2c_r[M9206_I2C_DEMOD].magic = address + 1;
if ((adap->fe = dvb_attach(tda10046_attach, &tvw_twin_tda10046_config1, &adap->dev->i2c_adap)) == NULL) {
deb_rc("megasky_tda10046_attach: dvb_attach failed at %x\n", address);
return -EIO;
}
address = 0x16;
m->i2c_r[M9206_I2C_DEMOD].addr = address;
m->i2c_r[M9206_I2C_DEMOD].magic = address + 1;
if ((adap->fe = dvb_attach(tda10046_attach, &tvw_twin_tda10046_config2, &adap->dev->i2c_adap)) == NULL) {
deb_rc("megasky_tda10046_attach: dvb_attach failed at %x\n", address);
return -EIO;
}
deb_rc("megasky_tda10046_attach: attached 2 demodulators\n");
return 0;
}
static struct tda827x_config megasky_tda8275_config = {
};
static struct qt1010_config megasky_qt1010_config = {
.i2c_address = 0xc4
};
static int megasky_tda8275_tuner_attach(struct dvb_usb_adapter *adap)
{
struct m9206_state *m = adap->dev->priv;
int i;
deb_rc("Entering megasky_tda8275_tuner_attach!\n");
#ifndef TEMPORARY
for (i = 2; i < 254; ++i, ++i) {
if (i == 0x10 || i == 0x11 || i == 0x16 || i == 0x17) {
deb_rc("Skipping %x\n", i);
continue;
}
deb_rc("Trying to attach tuner at i2c address %x\n", i);
m->i2c_r[M9206_I2C_TUNER].addr = i;
m->i2c_r[M9206_I2C_TUNER].magic = i + 1;
if (dvb_attach(tda827x_attach, adap->fe, i, &adap->dev->i2c_adap, &megasky_tda8275_config) != NULL) {
deb_rc("Tuner found at addredd %x!\n", i);
}
}
deb_rc("Leaving megasky_tda8275_tuner_attach: success\n");
return 0;
#endif
m->i2c_r[M9206_I2C_TUNER].addr = 0xc0;
m->i2c_r[M9206_I2C_TUNER].magic = 0xc1;
if (dvb_attach(tda827x_attach, adap->fe, 0xc0, &adap->dev->i2c_adap,
&megasky_tda8275_config) == NULL) {
deb_rc("megasky_tda8275_tuner_attach: dvb_attach failed\n");
return -ENODEV;
}
deb_rc("Leaving megasky_tda8275_tuner_attach: success\n");
return 0;
}
/* DVB USB Driver stuff */
static struct dvb_usb_device_properties megasky_properties;
static int m920x_probe(struct usb_interface *intf,
const struct usb_device_id *id)
{
struct dvb_usb_device *d;
struct usb_host_interface *alt;
int ret;
deb_rc("Entering m920x_probe:\n");
if ((ret = dvb_usb_device_init(intf, &megasky_properties, THIS_MODULE, &d)) == 0) {
deb_rc("probed!\n");
#ifdef DISABLE_SEE_IF_NOT_REQD
alt = usb_altnum_to_altsetting(intf, 1);
if (alt == NULL) {
deb_rc("not alt found!\n");
return -ENODEV;
}
ret = usb_set_interface(d->udev, alt->desc.bInterfaceNumber,
alt->desc.bAlternateSetting);
if (ret < 0)
return ret;
deb_rc("Changed to alternate setting!\n");
#endif
if ((ret = m9206_rc_init(d->udev)) != 0)
return ret;
}
if (ret) {
deb_rc("m920x_probe failed, return %d\n", ret);
} else {
deb_rc("m920x_probe succeeded, return %d\n", ret);
}
return ret;
}
static struct usb_device_id m920x_table [] = {
{ USB_DEVICE(0x10fd, 0x0514) }, /* cold */
{ USB_DEVICE(0x10fd, 0x0513) }, /* warm */
{ } /* Terminating entry */
};
MODULE_DEVICE_TABLE (usb, m920x_table);
static struct dvb_usb_device_properties megasky_properties = {
.caps = DVB_USB_IS_AN_I2C_ADAPTER,
.usb_ctrl = DEVICE_SPECIFIC,
.firmware = "dvb-usb-lifeview.bin",
.download_firmware = m9206_firmware_download,
.rc_interval = 100,
.rc_key_map = megasky_rc_keys,
.rc_key_map_size = ARRAY_SIZE(megasky_rc_keys),
.rc_query = m9206_rc_query,
.size_of_priv = sizeof(struct m9206_state),
.identify_state = megasky_identify_state,
.num_adapters = 1,
.adapter = {{
.caps = DVB_USB_ADAP_HAS_PID_FILTER |
DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
.pid_filter_count = 8,
.pid_filter = m9206_pid_filter,
.pid_filter_ctrl = m9206_pid_filter_ctrl,
.frontend_attach = megasky_tda10046_attach,
.tuner_attach = megasky_tda8275_tuner_attach,
.stream = {
.type = USB_BULK,
.count = 8,
.endpoint = 0x81,
.u = {
.bulk = {
.buffersize = 512,
}
}
},
}},
.i2c_algo = &m9206_i2c_algo,
.num_device_descs = 1,
.devices = {
{ .name = "LifeView TV Walker Twin DVB-T USB2.0",
.cold_ids = { &m920x_table[0], NULL },
.warm_ids = { &m920x_table[1], NULL },
},
}
};
static struct usb_driver m920x_driver = {
#if LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,15)
.owner = THIS_MODULE,
#endif
.name = "dvb_usb_m920x",
.probe = m920x_probe,
.disconnect = dvb_usb_device_exit,
.id_table = m920x_table,
};
/* module stuff */
static int __init m920x_module_init(void)
{
int ret;
if ((ret = usb_register(&m920x_driver))) {
err("usb_register failed. Error number %d", ret);
return ret;
}
return 0;
}
static void __exit m920x_module_exit(void)
{
/* deregister this driver from the USB subsystem */
usb_deregister(&m920x_driver);
}
module_init (m920x_module_init);
module_exit (m920x_module_exit);
MODULE_AUTHOR("Nick Andrew <nick@xxxxxxxxxxxxxxx>");
MODULE_DESCRIPTION("Driver LifeView TV Walker Twin DVB-T USB2.0 / Uli m920x");
MODULE_VERSION("0.1");
MODULE_LICENSE("GPL");
Feb 28 22:29:05 linuxdvb kernel: Entering m920x_probe:
Feb 28 22:29:05 linuxdvb kernel: check for cold 10fd 514
Feb 28 22:29:05 linuxdvb kernel: check for warm 10fd 513
Feb 28 22:29:05 linuxdvb kernel: Entering m9206_identify_state
Feb 28 22:29:05 linuxdvb kernel: Leaving m9206_identify_state: cold is 0
Feb 28 22:29:05 linuxdvb kernel: dvb-usb: found a 'LifeView TV Walker Twin DVB-T USB2.0' in warm state.
Feb 28 22:29:05 linuxdvb kernel: power control: 1
Feb 28 22:29:05 linuxdvb kernel: dvb-usb: will use the device's hardware PID filter (table count: 8).
Feb 28 22:29:05 linuxdvb kernel: all in all I will use 4096 bytes for streaming
Feb 28 22:29:05 linuxdvb kernel: allocating buffer 0
Feb 28 22:29:05 linuxdvb kernel: buffer 0: c68a6000 (dma: 109731840)
Feb 28 22:29:05 linuxdvb kernel: allocating buffer 1
Feb 28 22:29:05 linuxdvb kernel: buffer 1: c68a6200 (dma: 109732352)
Feb 28 22:29:05 linuxdvb kernel: allocating buffer 2
Feb 28 22:29:05 linuxdvb kernel: buffer 2: c68a6400 (dma: 109732864)
Feb 28 22:29:05 linuxdvb kernel: allocating buffer 3
Feb 28 22:29:05 linuxdvb kernel: buffer 3: c68a6600 (dma: 109733376)
Feb 28 22:29:05 linuxdvb kernel: allocating buffer 4
Feb 28 22:29:05 linuxdvb kernel: buffer 4: c68a6800 (dma: 109733888)
Feb 28 22:29:05 linuxdvb kernel: allocating buffer 5
Feb 28 22:29:05 linuxdvb kernel: buffer 5: c68a6a00 (dma: 109734400)
Feb 28 22:29:05 linuxdvb kernel: allocating buffer 6
Feb 28 22:29:05 linuxdvb kernel: buffer 6: c68a6c00 (dma: 109734912)
Feb 28 22:29:05 linuxdvb kernel: allocating buffer 7
Feb 28 22:29:05 linuxdvb kernel: buffer 7: c68a6e00 (dma: 109735424)
Feb 28 22:29:05 linuxdvb kernel: allocation successful
Feb 28 22:29:05 linuxdvb kernel: DVB: registering new adapter (LifeView TV Walker Twin DVB-T USB2.0).
Feb 28 22:29:05 linuxdvb kernel: Entering megasky_tda10046_attach!
Feb 28 22:29:05 linuxdvb kernel: tda1004x: Entering tda10046_attach
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_read_byte: reg=0x0
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_read_byte: success reg=0x0, data=0x46, ret=2
Feb 28 22:29:05 linuxdvb kernel: tda1004x: Leaving tda10046_attach: success
Feb 28 22:29:05 linuxdvb kernel: tda1004x: Entering tda10046_attach
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_read_byte: reg=0x0
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_read_byte: success reg=0x0, data=0x46, ret=2
Feb 28 22:29:05 linuxdvb kernel: tda1004x: Leaving tda10046_attach: success
Feb 28 22:29:05 linuxdvb kernel: megasky_tda10046_attach: attached 2 demodulators
Feb 28 22:29:05 linuxdvb kernel: dvb_register_frontend
Feb 28 22:29:05 linuxdvb kernel: DVB: registering frontend 0 (Philips TDA10046H DVB-T)...
Feb 28 22:29:05 linuxdvb kernel: Entering megasky_tda8275_tuner_attach!
Feb 28 22:29:05 linuxdvb kernel: Trying to attach tuner at i2c address 2
Feb 28 22:29:05 linuxdvb kernel: tda827x: tda827x_attach:
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_enable_tuner_i2c
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_write_mask: reg=0x7, mask=0x2, data=0x2
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_read_byte: reg=0x7
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_read_byte: success reg=0x7, data=0x1, ret=2
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_write_byteI: reg=0x7, data=0x3
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_write_byteI: success reg=0x7, data=0x3, ret=1
Feb 28 22:29:05 linuxdvb kernel: tda827x_attach: could not read from tuner at addr: 0x04
Feb 28 22:29:05 linuxdvb kernel: Trying to attach tuner at i2c address 4
Feb 28 22:29:05 linuxdvb kernel: tda827x: tda827x_attach:
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_enable_tuner_i2c
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_write_mask: reg=0x7, mask=0x2, data=0x2
Feb 28 22:29:05 linuxdvb kernel: tda1004x: tda1004x_read_byte: reg=0x7
_______________________________________________
linux-dvb mailing list
linux-dvb@xxxxxxxxxxx
http://www.linuxtv.org/cgi-bin/mailman/listinfo/linux-dvb
