V4L/DVB (7621): Add support for Hauppauge HVR950Q/HVR850/FusioHDTV7-USB
authorSteven Toth <stoth@hauppauge.com>
Sat, 19 Apr 2008 00:34:00 +0000 (21:34 -0300)
committerMauro Carvalho Chehab <mchehab@infradead.org>
Thu, 24 Apr 2008 17:09:42 +0000 (14:09 -0300)
Including support for the AU0828 USB Bridge.
Including support for the AU8522 ATSC/QAM Demodulator.
Including support for the AU8522 ATSC/QAM Demodulator.

Signed-off-by: Steven Toth <stoth@hauppauge.com>
Signed-off-by: Mauro Carvalho Chehab <mchehab@infradead.org>
15 files changed:
drivers/media/dvb/frontends/Kconfig
drivers/media/dvb/frontends/Makefile
drivers/media/dvb/frontends/au8522.c [new file with mode: 0644]
drivers/media/dvb/frontends/au8522.h [new file with mode: 0644]
drivers/media/video/Kconfig
drivers/media/video/Makefile
drivers/media/video/au0828/Kconfig [new file with mode: 0644]
drivers/media/video/au0828/Makefile [new file with mode: 0644]
drivers/media/video/au0828/au0828-cards.c [new file with mode: 0644]
drivers/media/video/au0828/au0828-cards.h [new file with mode: 0644]
drivers/media/video/au0828/au0828-core.c [new file with mode: 0644]
drivers/media/video/au0828/au0828-dvb.c [new file with mode: 0644]
drivers/media/video/au0828/au0828-i2c.c [new file with mode: 0644]
drivers/media/video/au0828/au0828-reg.h [new file with mode: 0644]
drivers/media/video/au0828/au0828.h [new file with mode: 0644]

index 4284a3092c14da8f0a49ef28732efc911b571d58..ae3659be323f4a81affada84ad6fa4b6437f15c1 100644 (file)
@@ -291,6 +291,14 @@ config DVB_S5H1409
          An ATSC 8VSB and QAM64/256 tuner module. Say Y when you want
          to support this frontend.
 
+config DVB_AU8522
+       tristate "Auvitek AU8522 based"
+       depends on DVB_CORE && I2C
+       default m if DVB_FE_CUSTOMISE
+       help
+         An ATSC 8VSB and QAM64/256 tuner module. Say Y when you want
+         to support this frontend.
+
 comment "Tuners/PLL support"
        depends on DVB_CORE
 
index 129367886bcc4663899c0c428e8b068475bd78c4..8e23a30ed3be11362edd9a19650c37f90eedae57 100644 (file)
@@ -53,3 +53,4 @@ obj-$(CONFIG_DVB_TUNER_MT2131) += mt2131.o
 obj-$(CONFIG_DVB_S5H1409) += s5h1409.o
 obj-$(CONFIG_DVB_TUNER_XC5000) += xc5000.o
 obj-$(CONFIG_DVB_TUNER_ITD1000) += itd1000.o
+obj-$(CONFIG_DVB_AU8522) += au8522.o
diff --git a/drivers/media/dvb/frontends/au8522.c b/drivers/media/dvb/frontends/au8522.c
new file mode 100644 (file)
index 0000000..d3c44b9
--- /dev/null
@@ -0,0 +1,448 @@
+/*
+    Auvitek AU8522 QAM/8VSB demodulator driver
+
+    Copyright (C) 2008 Steven Toth <stoth@hauppauge.com>
+
+    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 <linux/kernel.h>
+#include <linux/init.h>
+#include <linux/module.h>
+#include <linux/string.h>
+#include <linux/slab.h>
+#include <linux/delay.h>
+#include "dvb_frontend.h"
+#include "dvb-pll.h"
+#include "au8522.h"
+
+struct au8522_state {
+
+       struct i2c_adapter* i2c;
+
+       /* configuration settings */
+       const struct au8522_config* config;
+
+       struct dvb_frontend frontend;
+
+       u32 current_frequency;
+       fe_modulation_t current_modulation;
+
+};
+
+static int debug = 0;
+#define dprintk        if (debug) printk
+
+/* 16 bit registers, 8 bit values */
+static int au8522_writereg(struct au8522_state* state, u16 reg, u8 data)
+{
+       int ret;
+       u8 buf [] = { reg >> 8, reg & 0xff, data };
+
+       struct i2c_msg msg = { .addr = state->config->demod_address,
+                              .flags = 0, .buf = buf, .len = 3 };
+
+       ret = i2c_transfer(state->i2c, &msg, 1);
+
+       if (ret != 1)
+               printk("%s: writereg error (reg == 0x%02x, val == 0x%04x, "
+                      "ret == %i)\n", __FUNCTION__, reg, data, ret);
+
+       return (ret != 1) ? -1 : 0;
+}
+
+static u8 au8522_readreg(struct au8522_state* state, u16 reg)
+{
+       int ret;
+       u8 b0 [] = { reg >> 8, reg & 0xff };
+       u8 b1 [] = { 0 };
+
+       struct i2c_msg msg [] = {
+               { .addr = state->config->demod_address, .flags = 0,
+                 .buf = b0, .len = 2 },
+               { .addr = state->config->demod_address, .flags = I2C_M_RD,
+                 .buf = b1, .len = 1 } };
+
+       ret = i2c_transfer(state->i2c, msg, 2);
+
+       if (ret != 2)
+               printk("%s: readreg error (ret == %i)\n", __FUNCTION__, ret);
+       return b1[0];
+}
+
+static int au8522_i2c_gate_ctrl(struct dvb_frontend* fe, int enable)
+{
+       struct au8522_state* state = fe->demodulator_priv;
+
+       dprintk("%s(%d)\n", __FUNCTION__, enable);
+
+       if (enable)
+               return au8522_writereg(state, 0x106, 1);
+       else
+               return au8522_writereg(state, 0x106, 0);
+}
+
+static int au8522_enable_modulation(struct dvb_frontend* fe,
+       fe_modulation_t m)
+{
+       struct au8522_state* state = fe->demodulator_priv;
+
+       dprintk("%s(0x%08x)\n", __FUNCTION__, m);
+
+       switch(m) {
+       case VSB_8:
+               dprintk("%s() VSB_8\n", __FUNCTION__);
+
+               //au8522_writereg(state, 0x410b, 0x84); // Serial
+
+               //au8522_writereg(state, 0x8090, 0x82);
+               au8522_writereg(state, 0x8090, 0x84);
+               au8522_writereg(state, 0x4092, 0x11);
+               au8522_writereg(state, 0x2005, 0x00);
+               au8522_writereg(state, 0x8091, 0x80);
+
+               au8522_writereg(state, 0x80a3, 0x0c);
+               au8522_writereg(state, 0x80a4, 0xe8);
+               au8522_writereg(state, 0x8081, 0xc4);
+               au8522_writereg(state, 0x80a5, 0x40);
+               au8522_writereg(state, 0x80a7, 0x40);
+               au8522_writereg(state, 0x80a6, 0x67);
+               au8522_writereg(state, 0x8262, 0x20);
+               au8522_writereg(state, 0x821c, 0x30);
+               au8522_writereg(state, 0x80d8, 0x1a);
+               au8522_writereg(state, 0x8227, 0xa0);
+               au8522_writereg(state, 0x8121, 0xff);
+               au8522_writereg(state, 0x80a8, 0xf0);
+               au8522_writereg(state, 0x80a9, 0x05);
+               au8522_writereg(state, 0x80aa, 0x77);
+               au8522_writereg(state, 0x80ab, 0xf0);
+               au8522_writereg(state, 0x80ac, 0x05);
+               au8522_writereg(state, 0x80ad, 0x77);
+               au8522_writereg(state, 0x80ae, 0x41);
+               au8522_writereg(state, 0x80af, 0x66);
+               au8522_writereg(state, 0x821b, 0xcc);
+               au8522_writereg(state, 0x821d, 0x80);
+               au8522_writereg(state, 0x80b5, 0xfb);
+               au8522_writereg(state, 0x80b6, 0x8e);
+               au8522_writereg(state, 0x80b7, 0x39);
+               au8522_writereg(state, 0x80a4, 0xe8);
+               au8522_writereg(state, 0x8231, 0x13);
+               break;
+       case QAM_64:
+       case QAM_256:
+               au8522_writereg(state, 0x80a3, 0x09);
+               au8522_writereg(state, 0x80a4, 0x00);
+               au8522_writereg(state, 0x8081, 0xc4);
+               au8522_writereg(state, 0x80a5, 0x40);
+               au8522_writereg(state, 0x80b5, 0xfb);
+               au8522_writereg(state, 0x80b6, 0x8e);
+               au8522_writereg(state, 0x80b7, 0x39);
+               au8522_writereg(state, 0x80aa, 0x77);
+               au8522_writereg(state, 0x80ad, 0x77);
+               au8522_writereg(state, 0x80a6, 0x67);
+               au8522_writereg(state, 0x8262, 0x20);
+               au8522_writereg(state, 0x821c, 0x30);
+               au8522_writereg(state, 0x80b8, 0x3e);
+               au8522_writereg(state, 0x80b9, 0xf0);
+               au8522_writereg(state, 0x80ba, 0x01);
+               au8522_writereg(state, 0x80bb, 0x18);
+               au8522_writereg(state, 0x80bc, 0x50);
+               au8522_writereg(state, 0x80bd, 0x00);
+               au8522_writereg(state, 0x80be, 0xea);
+               au8522_writereg(state, 0x80bf, 0xef);
+               au8522_writereg(state, 0x80c0, 0xfc);
+               au8522_writereg(state, 0x80c1, 0xbd);
+               au8522_writereg(state, 0x80c2, 0x1f);
+               au8522_writereg(state, 0x80c3, 0xfc);
+               au8522_writereg(state, 0x80c4, 0xdd);
+               au8522_writereg(state, 0x80c5, 0xaf);
+               au8522_writereg(state, 0x80c6, 0x00);
+               au8522_writereg(state, 0x80c7, 0x38);
+               au8522_writereg(state, 0x80c8, 0x30);
+               au8522_writereg(state, 0x80c9, 0x05);
+               au8522_writereg(state, 0x80ca, 0x4a);
+               au8522_writereg(state, 0x80cb, 0xd0);
+               au8522_writereg(state, 0x80cc, 0x01);
+               au8522_writereg(state, 0x80cd, 0xd9);
+               au8522_writereg(state, 0x80ce, 0x6f);
+               au8522_writereg(state, 0x80cf, 0xf9);
+               au8522_writereg(state, 0x80d0, 0x70);
+               au8522_writereg(state, 0x80d1, 0xdf);
+               au8522_writereg(state, 0x80d2, 0xf7);
+               au8522_writereg(state, 0x80d3, 0xc2);
+               au8522_writereg(state, 0x80d4, 0xdf);
+               au8522_writereg(state, 0x80d5, 0x02);
+               au8522_writereg(state, 0x80d6, 0x9a);
+               au8522_writereg(state, 0x80d7, 0xd0);
+               au8522_writereg(state, 0x8250, 0x0d);
+               au8522_writereg(state, 0x8251, 0xcd);
+               au8522_writereg(state, 0x8252, 0xe0);
+               au8522_writereg(state, 0x8253, 0x05);
+               au8522_writereg(state, 0x8254, 0xa7);
+               au8522_writereg(state, 0x8255, 0xff);
+               au8522_writereg(state, 0x8256, 0xed);
+               au8522_writereg(state, 0x8257, 0x5b);
+               au8522_writereg(state, 0x8258, 0xae);
+               au8522_writereg(state, 0x8259, 0xe6);
+               au8522_writereg(state, 0x825a, 0x3d);
+               au8522_writereg(state, 0x825b, 0x0f);
+               au8522_writereg(state, 0x825c, 0x0d);
+               au8522_writereg(state, 0x825d, 0xea);
+               au8522_writereg(state, 0x825e, 0xf2);
+               au8522_writereg(state, 0x825f, 0x51);
+               au8522_writereg(state, 0x8260, 0xf5);
+               au8522_writereg(state, 0x8261, 0x06);
+               au8522_writereg(state, 0x821a, 0x00);
+               au8522_writereg(state, 0x8546, 0x40);
+               au8522_writereg(state, 0x8210, 0x26);
+               au8522_writereg(state, 0x8211, 0xf6);
+               au8522_writereg(state, 0x8212, 0x84);
+               au8522_writereg(state, 0x8213, 0x02);
+               au8522_writereg(state, 0x8502, 0x01);
+               au8522_writereg(state, 0x8121, 0x04);
+               au8522_writereg(state, 0x8122, 0x04);
+               au8522_writereg(state, 0x852e, 0x10);
+               au8522_writereg(state, 0x80a4, 0xca);
+               au8522_writereg(state, 0x80a7, 0x40);
+               au8522_writereg(state, 0x8526, 0x01);
+               break;
+       default:
+               dprintk("%s() Invalid modulation\n", __FUNCTION__);
+               return -EINVAL;
+       }
+
+       state->current_modulation = m;
+
+       return 0;
+}
+
+/* Talk to the demod, set the FEC, GUARD, QAM settings etc */
+static int au8522_set_frontend (struct dvb_frontend* fe,
+       struct dvb_frontend_parameters *p)
+{
+       struct au8522_state* state = fe->demodulator_priv;
+
+       dprintk("%s(frequency=%d)\n", __FUNCTION__, p->frequency);
+
+       state->current_frequency = p->frequency;
+
+       au8522_enable_modulation(fe, p->u.vsb.modulation);
+
+       /* Allow the demod to settle */
+       msleep(100);
+
+       if (fe->ops.tuner_ops.set_params) {
+               if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 1);
+               fe->ops.tuner_ops.set_params(fe, p);
+               if (fe->ops.i2c_gate_ctrl) fe->ops.i2c_gate_ctrl(fe, 0);
+       }
+
+       return 0;
+}
+
+/* Reset the demod hardware and reset all of the configuration registers
+   to a default state. */
+static int au8522_init(struct dvb_frontend* fe)
+{
+       struct au8522_state* state = fe->demodulator_priv;
+       dprintk("%s()\n", __FUNCTION__);
+
+       au8522_writereg(state, 0xa4, 1 << 5);
+
+       au8522_i2c_gate_ctrl(fe, 1);
+
+       return 0;
+}
+
+static int au8522_read_status(struct dvb_frontend* fe, fe_status_t* status)
+{
+       struct au8522_state* state = fe->demodulator_priv;
+       u8 reg;
+       u32 tuner_status = 0;
+
+       *status = 0;
+
+       if (state->current_modulation == VSB_8) {
+               dprintk("%s() Checking VSB_8\n", __FUNCTION__);
+               //au8522_writereg(state, 0x80a4, 0x20);
+               reg = au8522_readreg(state, 0x4088);
+               if(reg & 0x01)
+                       *status |= FE_HAS_VITERBI;
+               if(reg & 0x02)
+                       *status |= FE_HAS_LOCK | FE_HAS_SYNC;
+       } else {
+               dprintk("%s() Checking QAM\n", __FUNCTION__);
+               reg = au8522_readreg(state, 0x4541);
+               if(reg & 0x80)
+                       *status |= FE_HAS_VITERBI;
+               if(reg & 0x20)
+                       *status |= FE_HAS_LOCK | FE_HAS_SYNC;
+       }
+
+       switch(state->config->status_mode) {
+       case AU8522_DEMODLOCKING:
+               dprintk("%s() DEMODLOCKING\n", __FUNCTION__);
+               if (*status & FE_HAS_VITERBI)
+                       *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
+               break;
+       case AU8522_TUNERLOCKING:
+               /* Get the tuner status */
+               dprintk("%s() TUNERLOCKING\n", __FUNCTION__);
+               if (fe->ops.tuner_ops.get_status) {
+                       if (fe->ops.i2c_gate_ctrl)
+                               fe->ops.i2c_gate_ctrl(fe, 1);
+
+                       fe->ops.tuner_ops.get_status(fe, &tuner_status);
+
+                       if (fe->ops.i2c_gate_ctrl)
+                               fe->ops.i2c_gate_ctrl(fe, 0);
+               }
+               if (tuner_status)
+                       *status |= FE_HAS_CARRIER | FE_HAS_SIGNAL;
+               break;
+       }
+
+       dprintk("%s() status 0x%08x\n", __FUNCTION__, *status);
+
+       return 0;
+}
+
+static int au8522_read_snr(struct dvb_frontend* fe, u16* snr)
+{
+       dprintk("%s()\n", __FUNCTION__);
+
+       *snr = 0;
+
+       return 0;
+}
+
+static int au8522_read_signal_strength(struct dvb_frontend* fe,
+                                       u16* signal_strength)
+{
+       return au8522_read_snr(fe, signal_strength);
+}
+
+static int au8522_read_ucblocks(struct dvb_frontend* fe, u32* ucblocks)
+{
+       struct au8522_state* state = fe->demodulator_priv;
+
+       *ucblocks = au8522_readreg(state, 0x4087);
+
+       return 0;
+}
+
+static int au8522_read_ber(struct dvb_frontend* fe, u32* ber)
+{
+       return au8522_read_ucblocks(fe, ber);
+}
+
+static int au8522_get_frontend(struct dvb_frontend* fe,
+                               struct dvb_frontend_parameters *p)
+{
+       struct au8522_state* state = fe->demodulator_priv;
+
+       p->frequency = state->current_frequency;
+       p->u.vsb.modulation = state->current_modulation;
+
+       return 0;
+}
+
+static int au8522_get_tune_settings(struct dvb_frontend* fe,
+                                    struct dvb_frontend_tune_settings *tune)
+{
+       tune->min_delay_ms = 1000;
+       return 0;
+}
+
+static void au8522_release(struct dvb_frontend* fe)
+{
+       struct au8522_state* state = fe->demodulator_priv;
+       kfree(state);
+}
+
+static struct dvb_frontend_ops au8522_ops;
+
+struct dvb_frontend* au8522_attach(const struct au8522_config* config,
+                                   struct i2c_adapter* i2c)
+{
+       struct au8522_state* state = NULL;
+
+       /* allocate memory for the internal state */
+       state = kmalloc(sizeof(struct au8522_state), GFP_KERNEL);
+       if (state == NULL)
+               goto error;
+
+       /* setup the state */
+       state->config = config;
+       state->i2c = i2c;
+       /* create dvb_frontend */
+       memcpy(&state->frontend.ops, &au8522_ops,
+              sizeof(struct dvb_frontend_ops));
+       state->frontend.demodulator_priv = state;
+
+       if (au8522_init(&state->frontend) != 0) {
+               printk(KERN_ERR "%s: Failed to initialize correctly\n",
+                       __FUNCTION__);
+               goto error;
+       }
+
+       /* Note: Leaving the I2C gate open here. */
+       au8522_i2c_gate_ctrl(&state->frontend, 1);
+
+       return &state->frontend;
+
+error:
+       kfree(state);
+       return NULL;
+}
+
+static struct dvb_frontend_ops au8522_ops = {
+
+       .info = {
+               .name                   = "Auvitek AU8522 QAM/8VSB Frontend",
+               .type                   = FE_ATSC,
+               .frequency_min          = 54000000,
+               .frequency_max          = 858000000,
+               .frequency_stepsize     = 62500,
+               .caps = FE_CAN_QAM_64 | FE_CAN_QAM_256 | FE_CAN_8VSB
+       },
+
+       .init                 = au8522_init,
+       .i2c_gate_ctrl        = au8522_i2c_gate_ctrl,
+       .set_frontend         = au8522_set_frontend,
+       .get_frontend         = au8522_get_frontend,
+       .get_tune_settings    = au8522_get_tune_settings,
+       .read_status          = au8522_read_status,
+       .read_ber             = au8522_read_ber,
+       .read_signal_strength = au8522_read_signal_strength,
+       .read_snr             = au8522_read_snr,
+       .read_ucblocks        = au8522_read_ucblocks,
+       .release              = au8522_release,
+};
+
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "Enable verbose debug messages");
+
+MODULE_DESCRIPTION("Auvitek AU8522 QAM-B/ATSC Demodulator driver");
+MODULE_AUTHOR("Steven Toth");
+MODULE_LICENSE("GPL");
+
+EXPORT_SYMBOL(au8522_attach);
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ */
diff --git a/drivers/media/dvb/frontends/au8522.h b/drivers/media/dvb/frontends/au8522.h
new file mode 100644 (file)
index 0000000..a756271
--- /dev/null
@@ -0,0 +1,55 @@
+/*
+    Auvitek AU8522 QAM/8VSB demodulator driver
+
+    Copyright (C) 2008 Steven Toth <stoth@hauppauge.com>
+
+    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 __AU8522_H__
+#define __AU8522_H__
+
+#include <linux/dvb/frontend.h>
+
+struct au8522_config
+{
+       /* the demodulator's i2c address */
+       u8 demod_address;
+
+       /* Return lock status based on tuner lock, or demod lock */
+#define AU8522_TUNERLOCKING 0
+#define AU8522_DEMODLOCKING 1
+       u8 status_mode;
+};
+
+#if defined(CONFIG_DVB_AU8522) || (defined(CONFIG_DVB_AU8522_MODULE) && defined(MODULE))
+extern struct dvb_frontend* au8522_attach(const struct au8522_config* config,
+                                          struct i2c_adapter* i2c);
+#else
+static inline struct dvb_frontend* au8522_attach(const struct au8522_config* config,
+                                                 struct i2c_adapter* i2c)
+{
+       printk(KERN_WARNING "%s: driver disabled by Kconfig\n", __FUNCTION__);
+       return NULL;
+}
+#endif /* CONFIG_DVB_AU8522 */
+
+#endif /* __AU8522_H__ */
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ */
index 54b9f84e9a3e1835d0ee85bcf9d8dddcd2620e61..fe9a4cc141414c18523cb11c1b97dd0138b8c111 100644 (file)
@@ -698,6 +698,8 @@ source "drivers/media/video/cx88/Kconfig"
 
 source "drivers/media/video/cx23885/Kconfig"
 
+source "drivers/media/video/au0828/Kconfig"
+
 source "drivers/media/video/ivtv/Kconfig"
 
 config VIDEO_M32R_AR
index fe3be94afd109fc249f3f8ea8c9cd302e8162fcd..be14227f37269adb548577df17407aa52c6905ae 100644 (file)
@@ -143,5 +143,7 @@ obj-$(CONFIG_SOC_CAMERA)    += soc_camera.o
 obj-$(CONFIG_SOC_CAMERA_MT9M001)       += mt9m001.o
 obj-$(CONFIG_SOC_CAMERA_MT9V022)       += mt9v022.o
 
+obj-$(CONFIG_VIDEO_AU0828) += au0828/
+
 EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
 EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
diff --git a/drivers/media/video/au0828/Kconfig b/drivers/media/video/au0828/Kconfig
new file mode 100644 (file)
index 0000000..38d68ee
--- /dev/null
@@ -0,0 +1,10 @@
+
+config VIDEO_AU0828
+       tristate "Auvitek AU0828 support"
+       depends on VIDEO_DEV && I2C && INPUT
+       select I2C_ALGOBIT
+       ---help---
+         This is a video4linux driver for Auvitek's USB device.
+
+         To compile this driver as a module, choose M here: the
+         module will be called ambarella
diff --git a/drivers/media/video/au0828/Makefile b/drivers/media/video/au0828/Makefile
new file mode 100644 (file)
index 0000000..9f4f572
--- /dev/null
@@ -0,0 +1,9 @@
+au0828-objs    := au0828-core.o au0828-i2c.o au0828-cards.o au0828-dvb.o
+
+obj-$(CONFIG_VIDEO_AU0828) += au0828.o
+
+EXTRA_CFLAGS += -Idrivers/media/video
+EXTRA_CFLAGS += -Idrivers/media/dvb/dvb-core
+EXTRA_CFLAGS += -Idrivers/media/dvb/frontends
+
+EXTRA_CFLAGS += $(extra-cflags-y) $(extra-cflags-m)
diff --git a/drivers/media/video/au0828/au0828-cards.c b/drivers/media/video/au0828/au0828-cards.c
new file mode 100644 (file)
index 0000000..c4cb11e
--- /dev/null
@@ -0,0 +1,144 @@
+/*
+ *  Driver for the Auvitek USB bridge
+ *
+ *  Copyright (c) 2008 Steven Toth <stoth@hauppauge.com>
+ *
+ *  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 "au0828.h"
+#include "au0828-cards.h"
+
+#define _dbg(level, fmt, arg...)\
+       do {\
+               if (debug >= level) \
+                       printk(KERN_DEBUG DRIVER_NAME "/0: " fmt, ## arg);\
+       } while (0)
+
+struct au0828_board au0828_boards[] = {
+       [AU0828_BOARD_UNKNOWN] = {
+               .name   = "Unknown board",
+       },
+       [AU0828_BOARD_HAUPPAUGE_HVR850] = {
+               .name   = "Hauppauge HVR850",
+       },
+       [AU0828_BOARD_HAUPPAUGE_HVR950Q] = {
+               .name   = "Hauppauge HVR950Q",
+       },
+       [AU0828_BOARD_DVICO_FUSIONHDTV7] = {
+               .name   = "DViCO FusionHDTV USB",
+       },
+};
+const unsigned int au0828_bcount = ARRAY_SIZE(au0828_boards);
+
+/* Tuner callback function for au0828 boards. Currently only needed
+ * for HVR1500Q, which has an xc5000 tuner.
+ */
+int au0828_tuner_callback(void *priv, int command, int arg)
+{
+       struct au0828_dev *dev = priv;
+
+       switch(dev->board) {
+       case AU0828_BOARD_HAUPPAUGE_HVR850:
+       case AU0828_BOARD_HAUPPAUGE_HVR950Q:
+       case AU0828_BOARD_DVICO_FUSIONHDTV7:
+               if(command == 0) {
+                       /* Tuner Reset Command from xc5000 */
+                       /* Drive the tuner into reset and out */
+                       au0828_clear(dev, REG_001, 2);
+                       mdelay(200);
+                       au0828_set(dev, REG_001, 2);
+                       mdelay(50);
+                       return 0;
+               }
+               else {
+                       printk(KERN_ERR
+                               "%s(): Unknown command.\n", __FUNCTION__);
+                       return -EINVAL;
+               }
+               break;
+       }
+
+       return 0; /* Should never be here */
+}
+
+/*
+ * The bridge has between 8 and 12 gpios.
+ * Regs 1 and 0 deal with output enables.
+ * Regs 3 and 2 * deal with direction.
+ */
+void au0828_gpio_setup(struct au0828_dev *dev)
+{
+       switch(dev->board) {
+       case AU0828_BOARD_HAUPPAUGE_HVR850:
+       case AU0828_BOARD_HAUPPAUGE_HVR950Q:
+               /* GPIO's
+                * 4 - CS5340
+                * 5 - AU8522 Demodulator
+                * 6 - eeprom W/P
+                * 9 - XC5000 Tuner
+                */
+
+               /* Into reset */
+               au0828_write(dev, REG_003, 0x02);
+               au0828_write(dev, REG_002, 0x88 | 0x20);
+               au0828_write(dev, REG_001, 0x0);
+               au0828_write(dev, REG_000, 0x0);
+               msleep(100);
+
+               /* Out of reset */
+               au0828_write(dev, REG_003, 0x02);
+               au0828_write(dev, REG_001, 0x02);
+               au0828_write(dev, REG_002, 0x88 | 0x20);
+               au0828_write(dev, REG_000, 0x88 | 0x20 | 0x40);
+               msleep(250);
+               break;
+       case AU0828_BOARD_DVICO_FUSIONHDTV7:
+               /* GPIO's
+                * 6 - ?
+                * 8 - AU8522 Demodulator
+                * 9 - XC5000 Tuner
+                */
+
+               /* Into reset */
+               au0828_write(dev, REG_003, 0x02);
+               au0828_write(dev, REG_002, 0xa0);
+               au0828_write(dev, REG_001, 0x0);
+               au0828_write(dev, REG_000, 0x0);
+               msleep(100);
+
+               /* Out of reset */
+               au0828_write(dev, REG_003, 0x02);
+               au0828_write(dev, REG_002, 0xa0);
+               au0828_write(dev, REG_001, 0x02);
+               au0828_write(dev, REG_000, 0xa0);
+               msleep(250);
+               break;
+       }
+}
+
+/* table of devices that work with this driver */
+struct usb_device_id au0828_usb_id_table [] = {
+       { USB_DEVICE(0x2040, 0x7200),
+               .driver_info = AU0828_BOARD_HAUPPAUGE_HVR950Q },
+       { USB_DEVICE(0x2040, 0x7240),
+               .driver_info = AU0828_BOARD_HAUPPAUGE_HVR850 },
+       { USB_DEVICE(0x0fe9, 0xd620),
+               .driver_info = AU0828_BOARD_DVICO_FUSIONHDTV7 },
+       { },
+};
+
+MODULE_DEVICE_TABLE(usb, au0828_usb_id_table);
diff --git a/drivers/media/video/au0828/au0828-cards.h b/drivers/media/video/au0828/au0828-cards.h
new file mode 100644 (file)
index 0000000..e26f54a
--- /dev/null
@@ -0,0 +1,25 @@
+/*
+ *  Driver for the Auvitek USB bridge
+ *
+ *  Copyright (c) 2008 Steven Toth <stoth@hauppauge.com>
+ *
+ *  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.
+ */
+
+#define AU0828_BOARD_UNKNOWN           0
+#define AU0828_BOARD_HAUPPAUGE_HVR950Q 1
+#define AU0828_BOARD_HAUPPAUGE_HVR850  2
+#define AU0828_BOARD_DVICO_FUSIONHDTV7 3
diff --git a/drivers/media/video/au0828/au0828-core.c b/drivers/media/video/au0828/au0828-core.c
new file mode 100644 (file)
index 0000000..8d0b8a8
--- /dev/null
@@ -0,0 +1,252 @@
+/*
+ *  Driver for the Auvitek USB bridge
+ *
+ *  Copyright (c) 2008 Steven Toth <stoth@hauppauge.com>
+ *
+ *  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 <linux/module.h>
+#include <linux/videodev2.h>
+#include <media/v4l2-common.h>
+#include <linux/mutex.h>
+
+#include "au0828.h"
+
+static unsigned int debug;
+module_param(debug, int, 0644);
+MODULE_PARM_DESC(debug, "enable debug messages");
+
+#define _err(fmt, arg...)\
+       do {\
+               printk(KERN_ERR DRIVER_NAME "/0: " fmt, ## arg);\
+       } while (0)
+
+#define _info(fmt, arg...)\
+       do {\
+               printk(KERN_INFO DRIVER_NAME "/0: " fmt, ## arg);\
+       } while (0)
+
+#define _dbg(level, fmt, arg...)\
+       do {\
+               if (debug >= level) \
+                       printk(KERN_DEBUG DRIVER_NAME "/0: " fmt, ## arg);\
+       } while (0)
+
+#define _AU0828_BULKPIPE 0x03
+#define _BULKPIPESIZE 0xffff
+
+static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
+       u16 index, unsigned char *cp, u16 size);
+static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
+       u16 index, unsigned char *cp, u16 size);
+
+/* USB Direction */
+#define CMD_REQUEST_IN         0x00
+#define CMD_REQUEST_OUT                0x01
+
+u32 au0828_readreg(struct au0828_dev *dev, u16 reg)
+{
+       recv_control_msg(dev, CMD_REQUEST_IN, 0, reg, dev->ctrlmsg, 1);
+       _dbg(3,"%s(0x%x) = 0x%x\n", __FUNCTION__, reg, dev->ctrlmsg[0]);
+       return dev->ctrlmsg[0];
+}
+
+u32 au0828_writereg(struct au0828_dev *dev, u16 reg, u32 val)
+{
+       _dbg(3,"%s(0x%x, 0x%x)\n", __FUNCTION__, reg, val);
+       return send_control_msg(dev, CMD_REQUEST_OUT, val, reg, dev->ctrlmsg, 0);
+}
+
+static void cmd_msg_dump(struct au0828_dev *dev)
+{
+       int i;
+
+       for (i = 0;i < sizeof(dev->ctrlmsg); i+=16)
+               _dbg(1,"%s() %02x %02x %02x %02x %02x %02x %02x %02x %02x %02x "
+                       "%02x %02x %02x %02x %02x %02x\n",
+                       __FUNCTION__,
+                       dev->ctrlmsg[i+0], dev->ctrlmsg[i+1],
+                       dev->ctrlmsg[i+2], dev->ctrlmsg[i+3],
+                       dev->ctrlmsg[i+4], dev->ctrlmsg[i+5],
+                       dev->ctrlmsg[i+6], dev->ctrlmsg[i+7],
+                       dev->ctrlmsg[i+8], dev->ctrlmsg[i+9],
+                       dev->ctrlmsg[i+10], dev->ctrlmsg[i+11],
+                       dev->ctrlmsg[i+12], dev->ctrlmsg[i+13],
+                       dev->ctrlmsg[i+14], dev->ctrlmsg[i+15]);
+}
+
+static int send_control_msg(struct au0828_dev *dev, u16 request, u32 value,
+       u16 index, unsigned char *cp, u16 size)
+{
+       int status = -ENODEV;
+       mutex_lock(&dev->mutex);
+       if (dev->usbdev) {
+
+               /* cp must be memory that has been allocated by kmalloc */
+               status = usb_control_msg(dev->usbdev,
+                               usb_sndctrlpipe(dev->usbdev, 0),
+                               request,
+                               USB_DIR_OUT | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                               value, index,
+                               cp, size, 1000);
+
+               status = min(status, 0);
+
+               if (status < 0) {
+                       _err("%s() Failed sending control message, error %d.\n",
+                               __FUNCTION__,
+                               status);
+               }
+
+       }
+       mutex_unlock(&dev->mutex);
+       return status;
+}
+
+static int recv_control_msg(struct au0828_dev *dev, u16 request, u32 value,
+       u16 index, unsigned char *cp, u16 size)
+{
+       int status = -ENODEV;
+       mutex_lock(&dev->mutex);
+       if (dev->usbdev) {
+
+               memset(dev->ctrlmsg, 0, sizeof(dev->ctrlmsg));
+
+               /* cp must be memory that has been allocated by kmalloc */
+               status = usb_control_msg(dev->usbdev,
+                               usb_rcvctrlpipe(dev->usbdev, 0),
+                               request,
+                               USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE,
+                               value, index,
+                               cp, size, 1000);
+
+               status = min(status, 0);
+
+               if (status < 0) {
+                       _err("%s() Failed receiving ctrl msg, error %d.\n",
+                               __FUNCTION__,
+                               status);
+               }
+               else
+                       if (debug > 4)
+                               cmd_msg_dump(dev);
+       }
+       mutex_unlock(&dev->mutex);
+       return status;
+}
+static void au0828_usb_disconnect(struct usb_interface *interface)
+{
+       struct au0828_dev *dev = usb_get_intfdata(interface);
+
+       _dbg(1,"%s()\n", __FUNCTION__);
+
+       /* Digital TV */
+       au0828_dvb_unregister(dev);
+
+       /* I2C */
+       au0828_i2c_unregister(dev);
+
+       usb_set_intfdata(interface, NULL);
+
+       mutex_lock(&dev->mutex);
+       dev->usbdev = NULL;
+       mutex_unlock(&dev->mutex);
+
+       kfree(dev);
+
+}
+
+static int au0828_usb_probe (struct usb_interface *interface,
+       const struct usb_device_id *id)
+{
+       int ifnum;
+       struct au0828_dev *dev;
+       struct usb_device *usbdev = interface_to_usbdev(interface);
+
+       ifnum = interface->altsetting->desc.bInterfaceNumber;
+
+       if (ifnum != 0)
+               return -ENODEV;
+
+       _dbg(1,"%s() vendor id 0x%x device id 0x%x ifnum:%d\n",
+               __FUNCTION__,
+               le16_to_cpu(usbdev->descriptor.idVendor),
+               le16_to_cpu(usbdev->descriptor.idProduct),
+               ifnum);
+
+       dev = kzalloc(sizeof(*dev), GFP_KERNEL);
+       if (dev == NULL) {
+               _err("Unable to allocate memory\n");
+               return -ENOMEM;
+       }
+
+       mutex_init(&dev->mutex);
+       mutex_init(&dev->dvb.lock);
+       dev->usbdev = usbdev;
+       dev->board = id->driver_info;
+
+       usb_set_intfdata(interface, dev);
+
+       /* Power Up the bridge */
+       au0828_write(dev, REG_600, 1 << 4);
+
+       /* Bring up the GPIO's and supporting devices */
+       au0828_gpio_setup(dev);
+
+       /* I2C */
+       au0828_i2c_register(dev);
+
+       /* Digital TV */
+       au0828_dvb_register(dev);
+
+       _info("Registered device AU0828 [%s]\n",
+               au0828_boards[dev->board].name);
+
+       return 0;
+}
+
+static struct usb_driver au0828_usb_driver = {
+       .name           = DRIVER_NAME,
+       .probe          = au0828_usb_probe,
+       .disconnect     = au0828_usb_disconnect,
+       .id_table       = au0828_usb_id_table,
+};
+
+static int __init au0828_init(void)
+{
+       int ret;
+
+       _info("au0828 driver loaded\n");
+
+       ret = usb_register(&au0828_usb_driver);
+       if (ret)
+               _err("usb_register failed, error = %d\n", ret);
+
+       return ret;
+}
+
+static void __exit au0828_exit(void)
+{
+       usb_deregister(&au0828_usb_driver);
+}
+
+module_init(au0828_init);
+module_exit(au0828_exit);
+
+MODULE_DESCRIPTION("Driver for Auvitek AU0828 based products");
+MODULE_AUTHOR("Steven Toth <stoth@hauppauge.com>");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/video/au0828/au0828-dvb.c b/drivers/media/video/au0828/au0828-dvb.c
new file mode 100644 (file)
index 0000000..3c8a29e
--- /dev/null
@@ -0,0 +1,371 @@
+/*
+ *  Driver for the Auvitek USB bridge
+ *
+ *  Copyright (c) 2008 Steven Toth <stoth@hauppauge.com>
+ *
+ *  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 <linux/module.h>
+#include <linux/init.h>
+#include <linux/device.h>
+#include <linux/suspend.h>
+#include <media/v4l2-common.h>
+
+#include "au0828.h"
+
+#include "au8522.h"
+#include "xc5000.h"
+
+DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
+
+unsigned int dvb_debug = 1;
+
+#define _dbg(level, fmt, arg...)\
+       do { if (dvb_debug >= level)\
+               printk(KERN_DEBUG "%s/0: " fmt, DRIVER_NAME, ## arg);\
+       } while (0)
+
+static struct au8522_config hauppauge_hvr950q_config = {
+       .demod_address = 0x8e >> 1,
+       .status_mode   = AU8522_DEMODLOCKING,
+};
+
+static struct xc5000_config hauppauge_hvr950q_tunerconfig = {
+       .i2c_address      = 0x61,
+       .if_khz           = 6000,
+       .tuner_callback   = au0828_tuner_callback
+};
+
+/*-------------------------------------------------------------------*/
+static void urb_completion(struct urb *purb)
+{
+       u8 *ptr;
+       struct au0828_dev *dev = purb->context;
+       int ptype = usb_pipetype(purb->pipe);
+
+       if (dev->urb_streaming == 0)
+               return;
+
+       if (ptype != PIPE_BULK) {
+               printk(KERN_ERR "%s() Unsupported URB type %d\n", __FUNCTION__, ptype);
+               return;
+       }
+
+       ptr = (u8 *)purb->transfer_buffer;
+
+       /* Feed the transport payload into the kernel demux */
+       dvb_dmx_swfilter_packets(&dev->dvb.demux, purb->transfer_buffer, purb->actual_length / 188);
+
+       /* Clean the buffer before we requeue */
+       memset(purb->transfer_buffer, 0, URB_BUFSIZE);
+
+       /* Requeue URB */
+       usb_submit_urb(purb, GFP_ATOMIC);
+}
+
+static int stop_urb_transfer(struct au0828_dev *dev)
+{
+       int i;
+
+       printk(KERN_INFO "%s()\n", __FUNCTION__);
+
+       /* FIXME:  Do we need to free the transfer_buffers? */
+       for (i = 0; i < URB_COUNT; i++) {
+               usb_kill_urb(dev->urbs[i]);
+               kfree(dev->urbs[i]->transfer_buffer);
+               usb_free_urb(dev->urbs[i]);
+       }
+
+       dev->urb_streaming = 0;
+
+       return 0;
+}
+
+#define _AU0828_BULKPIPE 0x83
+#define _BULKPIPESIZE 0xe522
+
+static int start_urb_transfer(struct au0828_dev *dev)
+{
+       struct urb *purb;
+       int i, ret = -ENOMEM;
+       unsigned int pipe = usb_rcvbulkpipe(dev->usbdev, _AU0828_BULKPIPE);
+       int pipesize = usb_maxpacket(dev->usbdev, pipe, usb_pipeout(pipe));
+       int packets = _BULKPIPESIZE / pipesize;
+       int transfer_buflen = packets * pipesize;
+
+       printk(KERN_INFO "%s() transfer_buflen = %d\n", __FUNCTION__, transfer_buflen);
+
+       if (dev->urb_streaming) {
+               printk("%s: iso xfer already running!\n", __FUNCTION__);
+               return 0;
+       }
+
+       for (i = 0; i < URB_COUNT; i++) {
+
+               dev->urbs[i] = usb_alloc_urb(0, GFP_KERNEL);
+               if (!dev->urbs[i]) {
+                       goto err;
+               }
+
+               purb = dev->urbs[i];
+
+               purb->transfer_buffer = kzalloc(URB_BUFSIZE, GFP_KERNEL);
+               if (!purb->transfer_buffer) {
+                       usb_free_urb(purb);
+                       dev->urbs[i] = 0;
+                       goto err;
+               }
+
+               purb->status = -EINPROGRESS;
+               usb_fill_bulk_urb(purb,
+                                 dev->usbdev,
+                                 usb_rcvbulkpipe(dev->usbdev, _AU0828_BULKPIPE),
+                                 purb->transfer_buffer,
+                                 URB_BUFSIZE,
+                                 urb_completion,
+                                 dev);
+
+       }
+
+       for (i = 0; i < URB_COUNT; i++) {
+               ret = usb_submit_urb(dev->urbs[i], GFP_ATOMIC);
+               if (ret != 0) {
+                       stop_urb_transfer(dev);
+                       printk("%s: failed urb submission, err = %d\n", __FUNCTION__, ret);
+                       return ret;
+               }
+       }
+
+       dev->urb_streaming = 1;
+       ret = 0;
+
+err:
+       return ret;
+}
+
+static int au0828_dvb_start_feed(struct dvb_demux_feed *feed)
+{
+       struct dvb_demux *demux = feed->demux;
+       struct au0828_dev *dev = (struct au0828_dev *) demux->priv;
+       struct au0828_dvb *dvb = &dev->dvb;
+       int ret = 0;
+
+       printk(KERN_INFO "%s() pid = 0x%x index = %d\n", __FUNCTION__, feed->pid, feed->index);
+
+       if (!demux->dmx.frontend)
+               return -EINVAL;
+
+       printk(KERN_INFO "%s() Preparing, feeding = %d\n", __FUNCTION__, dvb->feeding);
+       if (dvb) {
+               mutex_lock(&dvb->lock);
+               if (dvb->feeding++ == 0) {
+                       printk(KERN_INFO "%s() Starting Transport DMA\n",
+                               __FUNCTION__);
+                       au0828_write(dev, 0x608, 0x90);
+                       au0828_write(dev, 0x609, 0x72);
+                       au0828_write(dev, 0x60a, 0x71);
+                       au0828_write(dev, 0x60b, 0x01);
+                       ret = start_urb_transfer(dev);
+               }
+               mutex_unlock(&dvb->lock);
+       }
+
+       return ret;
+}
+
+static int au0828_dvb_stop_feed(struct dvb_demux_feed *feed)
+{
+       struct dvb_demux *demux = feed->demux;
+       struct au0828_dev *dev = (struct au0828_dev *) demux->priv;
+       struct au0828_dvb *dvb = &dev->dvb;
+       int ret = 0;
+
+       printk(KERN_INFO "%s() pid = 0x%x index = %d\n", __FUNCTION__, feed->pid, feed->index);
+
+       if (dvb) {
+               mutex_lock(&dvb->lock);
+               if (--dvb->feeding == 0) {
+                       printk(KERN_INFO "%s() Stopping Transport DMA\n",
+                               __FUNCTION__);
+                       au0828_write(dev, 0x608, 0x00);
+                       au0828_write(dev, 0x609, 0x00);
+                       au0828_write(dev, 0x60a, 0x00);
+                       au0828_write(dev, 0x60b, 0x00);
+                       ret = stop_urb_transfer(dev);
+               }
+               mutex_unlock(&dvb->lock);
+       }
+
+       return ret;
+}
+
+int dvb_register(struct au0828_dev *dev)
+{
+       struct au0828_dvb *dvb = &dev->dvb;
+       int result;
+
+       /* register adapter */
+       result = dvb_register_adapter(&dvb->adapter, DRIVER_NAME, THIS_MODULE,
+                                     &dev->usbdev->dev, adapter_nr);
+       if (result < 0) {
+               printk(KERN_WARNING "%s: dvb_register_adapter failed (errno = %d)\n",
+                      DRIVER_NAME, result);
+               goto fail_adapter;
+       }
+       dvb->adapter.priv = dev;
+
+       /* register frontend */
+       result = dvb_register_frontend(&dvb->adapter, dvb->frontend);
+       if (result < 0) {
+               printk(KERN_WARNING "%s: dvb_register_frontend failed (errno = %d)\n",
+                      DRIVER_NAME, result);
+               goto fail_frontend;
+       }
+
+       /* register demux stuff */
+       dvb->demux.dmx.capabilities =
+               DMX_TS_FILTERING | DMX_SECTION_FILTERING |
+               DMX_MEMORY_BASED_FILTERING;
+       dvb->demux.priv       = dev;
+       dvb->demux.filternum  = 256;
+       dvb->demux.feednum    = 256;
+       dvb->demux.start_feed = au0828_dvb_start_feed;
+       dvb->demux.stop_feed  = au0828_dvb_stop_feed;
+       result = dvb_dmx_init(&dvb->demux);
+       if (result < 0) {
+               printk(KERN_WARNING "%s: dvb_dmx_init failed (errno = %d)\n",
+                      DRIVER_NAME, result);
+               goto fail_dmx;
+       }
+
+       dvb->dmxdev.filternum    = 256;
+       dvb->dmxdev.demux        = &dvb->demux.dmx;
+       dvb->dmxdev.capabilities = 0;
+       result = dvb_dmxdev_init(&dvb->dmxdev, &dvb->adapter);
+       if (result < 0) {
+               printk(KERN_WARNING "%s: dvb_dmxdev_init failed (errno = %d)\n",
+                      DRIVER_NAME, result);
+               goto fail_dmxdev;
+       }
+
+       dvb->fe_hw.source = DMX_FRONTEND_0;
+       result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_hw);
+       if (result < 0) {
+               printk(KERN_WARNING "%s: add_frontend failed (DMX_FRONTEND_0, errno = %d)\n",
+                      DRIVER_NAME, result);
+               goto fail_fe_hw;
+       }
+
+       dvb->fe_mem.source = DMX_MEMORY_FE;
+       result = dvb->demux.dmx.add_frontend(&dvb->demux.dmx, &dvb->fe_mem);
+       if (result < 0) {
+               printk(KERN_WARNING "%s: add_frontend failed (DMX_MEMORY_FE, errno = %d)\n",
+                      DRIVER_NAME, result);
+               goto fail_fe_mem;
+       }
+
+       result = dvb->demux.dmx.connect_frontend(&dvb->demux.dmx, &dvb->fe_hw);
+       if (result < 0) {
+               printk(KERN_WARNING "%s: connect_frontend failed (errno = %d)\n",
+                      DRIVER_NAME, result);
+               goto fail_fe_conn;
+       }
+
+       /* register network adapter */
+       dvb_net_init(&dvb->adapter, &dvb->net, &dvb->demux.dmx);
+       return 0;
+
+fail_fe_conn:
+       dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
+fail_fe_mem:
+       dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
+fail_fe_hw:
+       dvb_dmxdev_release(&dvb->dmxdev);
+fail_dmxdev:
+       dvb_dmx_release(&dvb->demux);
+fail_dmx:
+       dvb_unregister_frontend(dvb->frontend);
+fail_frontend:
+       dvb_frontend_detach(dvb->frontend);
+       dvb_unregister_adapter(&dvb->adapter);
+fail_adapter:
+       return result;
+}
+
+void au0828_dvb_unregister(struct au0828_dev *dev)
+{
+       struct au0828_dvb *dvb = &dev->dvb;
+
+       dvb_net_release(&dvb->net);
+       dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_mem);
+       dvb->demux.dmx.remove_frontend(&dvb->demux.dmx, &dvb->fe_hw);
+       dvb_dmxdev_release(&dvb->dmxdev);
+       dvb_dmx_release(&dvb->demux);
+       dvb_unregister_frontend(dvb->frontend);
+       dvb_frontend_detach(dvb->frontend);
+       dvb_unregister_adapter(&dvb->adapter);
+}
+
+/* All the DVB attach calls go here, this function get's modified
+ * for each new card. No other function in this file needs
+ * to change.
+ */
+int au0828_dvb_register(struct au0828_dev *dev)
+{
+       struct au0828_dvb *dvb = &dev->dvb;
+       int ret;
+
+       /* init frontend */
+       switch (dev->board) {
+       case AU0828_BOARD_HAUPPAUGE_HVR850:
+       case AU0828_BOARD_HAUPPAUGE_HVR950Q:
+       case AU0828_BOARD_DVICO_FUSIONHDTV7:
+               dvb->frontend = dvb_attach(au8522_attach,
+                               &hauppauge_hvr950q_config,
+                               &dev->i2c_adap);
+               if (dvb->frontend != NULL) {
+                       hauppauge_hvr950q_tunerconfig.priv = dev;
+                       dvb_attach(xc5000_attach, dvb->frontend,
+                               &dev->i2c_adap,
+                               &hauppauge_hvr950q_tunerconfig);
+               }
+               break;
+       default:
+               printk("The frontend of your DVB/ATSC card isn't supported yet\n");
+               break;
+       }
+       if (NULL == dvb->frontend) {
+               printk("Frontend initialization failed\n");
+               return -1;
+       }
+
+       /* Put the analog decoder in standby to keep it quiet */
+       au0828_call_i2c_clients(dev, TUNER_SET_STANDBY, NULL);
+
+       if (dvb->frontend->ops.analog_ops.standby)
+               dvb->frontend->ops.analog_ops.standby(dvb->frontend);
+
+       /* register everything */
+       ret = dvb_register(dev);
+       if (ret < 0) {
+               if (dvb->frontend->ops.release)
+                       dvb->frontend->ops.release(dvb->frontend);
+               return ret;
+       }
+
+       return 0;
+}
diff --git a/drivers/media/video/au0828/au0828-i2c.c b/drivers/media/video/au0828/au0828-i2c.c
new file mode 100644 (file)
index 0000000..3e74824
--- /dev/null
@@ -0,0 +1,402 @@
+/*
+ *  Driver for the Auvitek AU0828 USB bridge
+ *
+ *  Copyright (c) 2008 Steven Toth <stoth@hauppauge.com>
+ *
+ *  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 <linux/module.h>
+#include <linux/moduleparam.h>
+#include <linux/init.h>
+#include <linux/delay.h>
+#include <asm/io.h>
+
+#include "au0828.h"
+
+#include <media/v4l2-common.h>
+
+static unsigned int i2c_debug;
+module_param(i2c_debug, int, 0644);
+MODULE_PARM_DESC(i2c_debug, "enable debug messages [i2c]");
+
+static unsigned int i2c_scan = 0;
+module_param(i2c_scan, int, 0444);
+MODULE_PARM_DESC(i2c_scan, "scan i2c bus at insmod time");
+
+#define dprintk(level, fmt, arg...)\
+       do { if (i2c_debug >= level)\
+               printk(KERN_DEBUG "%s/0: " fmt, DRIVER_NAME, ## arg);\
+       } while (0)
+
+#define I2C_WAIT_DELAY 512
+#define I2C_WAIT_RETRY 64
+
+static inline int i2c_slave_did_write_ack(struct i2c_adapter *i2c_adap)
+{
+       struct au0828_dev *dev = i2c_adap->algo_data;
+       return au0828_read(dev, REG_201) & 0x08 ? 0 : 1;
+}
+
+static inline int i2c_slave_did_read_ack(struct i2c_adapter *i2c_adap)
+{
+       struct au0828_dev *dev = i2c_adap->algo_data;
+       return au0828_read(dev, REG_201) & 0x02 ? 0 : 1;
+}
+
+static int i2c_wait_read_ack(struct i2c_adapter *i2c_adap)
+{
+       int count;
+
+       for (count = 0; count < I2C_WAIT_RETRY; count++) {
+               if (!i2c_slave_did_read_ack(i2c_adap))
+                       break;
+               udelay(I2C_WAIT_DELAY);
+       }
+
+       if (I2C_WAIT_RETRY == count)
+               return 0;
+
+       return 1;
+}
+
+static inline int i2c_is_read_busy(struct i2c_adapter *i2c_adap)
+{
+       struct au0828_dev *dev = i2c_adap->algo_data;
+       return au0828_read(dev, REG_201) & 0x01 ? 0 : 1;
+}
+
+static int i2c_wait_read_done(struct i2c_adapter *i2c_adap)
+{
+       int count;
+
+       for (count = 0; count < I2C_WAIT_RETRY; count++) {
+               if (!i2c_is_read_busy(i2c_adap))
+                       break;
+               udelay(I2C_WAIT_DELAY);
+       }
+
+       if (I2C_WAIT_RETRY == count)
+               return 0;
+
+       return 1;
+}
+
+static inline int i2c_is_write_done(struct i2c_adapter *i2c_adap)
+{
+       struct au0828_dev *dev = i2c_adap->algo_data;
+       return au0828_read(dev, REG_201) & 0x04 ? 1 : 0;
+}
+
+static int i2c_wait_write_done(struct i2c_adapter *i2c_adap)
+{
+       int count;
+
+       for (count = 0; count < I2C_WAIT_RETRY; count++) {
+               if (i2c_is_write_done(i2c_adap))
+                       break;
+               udelay(I2C_WAIT_DELAY);
+       }
+
+       if (I2C_WAIT_RETRY == count)
+               return 0;
+
+       return 1;
+}
+
+static inline int i2c_is_busy(struct i2c_adapter *i2c_adap)
+{
+       struct au0828_dev *dev = i2c_adap->algo_data;
+       return au0828_read(dev, REG_201) & 0x10 ? 1 : 0;
+}
+
+static int i2c_wait_done(struct i2c_adapter *i2c_adap)
+{
+       int count;
+
+       for (count = 0; count < I2C_WAIT_RETRY; count++) {
+               if (!i2c_is_busy(i2c_adap))
+                       break;
+               udelay(I2C_WAIT_DELAY);
+       }
+
+       if (I2C_WAIT_RETRY == count)
+               return 0;
+
+       return 1;
+}
+
+/* FIXME: Implement join handling correctly */
+static int i2c_sendbytes(struct i2c_adapter *i2c_adap,
+       const struct i2c_msg *msg, int joined_rlen)
+{
+       int i, strobe = 0;
+       struct au0828_dev *dev = i2c_adap->algo_data;
+
+       dprintk(1, "%s()\n", __FUNCTION__);
+
+       au0828_write(dev, REG_2FF, 0x01);
+       au0828_write(dev, REG_202, 0x07);
+
+       /* Hardware needs 8 bit addresses */
+       au0828_write(dev, REG_203, msg->addr << 1);
+
+       if (i2c_debug)
+               dprintk(1, "SEND: %02x\n", msg->addr);
+
+       for (i=0; i < msg->len;) {
+
+               if (i2c_debug)
+                       dprintk(1, " %02x\n", msg->buf[i]);
+
+               au0828_write(dev, REG_205, msg->buf[i]);
+
+               strobe++;
+               i++;
+
+               if ((strobe >= 4) || (i >= msg->len)) {
+
+                       /* Strobe the byte into the bus */
+                       if (i < msg->len)
+                               au0828_write(dev, REG_200, 0x41);
+                       else
+                               au0828_write(dev, REG_200, 0x01);
+
+                       /* Reset strobe trigger */
+                       strobe = 0;
+
+                       if (!i2c_wait_write_done(i2c_adap))
+                               return -EIO;
+
+               }
+
+       }
+       if (!i2c_wait_done(i2c_adap))
+               return -EIO;
+
+       if (i2c_debug)
+               dprintk(1, "\n");
+
+       return msg->len;
+}
+
+/* FIXME: Implement join handling correctly */
+static int i2c_readbytes(struct i2c_adapter *i2c_adap,
+       const struct i2c_msg *msg, int joined)
+{
+       struct au0828_dev *dev = i2c_adap->algo_data;
+       int i;
+
+       dprintk(1, "%s()\n", __FUNCTION__);
+
+       au0828_write(dev, REG_2FF, 0x01);
+       au0828_write(dev, REG_202, 0x07);
+
+       /* Hardware needs 8 bit addresses */
+       au0828_write(dev, REG_203, msg->addr << 1);
+
+       if (i2c_debug)
+               dprintk(1, " RECV:\n");
+
+       /* Deal with i2c_scan */
+       if (msg->len == 0) {
+               au0828_write(dev, REG_200, 0x20);
+               if (i2c_wait_read_ack(i2c_adap))
+                       return -EIO;
+               return 0;
+       }
+
+       for (i=0; i < msg->len;) {
+
+               i++;
+
+               if (i < msg->len)
+                       au0828_write(dev, REG_200, 0x60);
+               else
+                       au0828_write(dev, REG_200, 0x20);
+
+               if (!i2c_wait_read_done(i2c_adap))
+                       return -EIO;
+
+               msg->buf[i-1] = au0828_read(dev, REG_209) & 0xff;
+
+               if (i2c_debug)
+                       dprintk(1, " %02x\n", msg->buf[i-1]);
+       }
+       if (!i2c_wait_done(i2c_adap))
+               return -EIO;
+
+       if (i2c_debug)
+               dprintk(1, "\n");
+
+       return msg->len;
+}
+
+static int i2c_xfer(struct i2c_adapter *i2c_adap,
+                   struct i2c_msg *msgs, int num)
+{
+       int i, retval = 0;
+
+       dprintk(1, "%s(num = %d)\n", __FUNCTION__, num);
+
+       for (i = 0 ; i < num; i++) {
+               dprintk(1, "%s(num = %d) addr = 0x%02x  len = 0x%x\n",
+                       __FUNCTION__, num, msgs[i].addr, msgs[i].len);
+               if (msgs[i].flags & I2C_M_RD) {
+                       /* read */
+                       retval = i2c_readbytes(i2c_adap, &msgs[i], 0);
+               } else if (i + 1 < num && (msgs[i + 1].flags & I2C_M_RD) &&
+                          msgs[i].addr == msgs[i + 1].addr) {
+                       /* write then read from same address */
+                       retval = i2c_sendbytes(i2c_adap, &msgs[i],
+                                              msgs[i + 1].len);
+                       if (retval < 0)
+                               goto err;
+                       i++;
+                       retval = i2c_readbytes(i2c_adap, &msgs[i], 1);
+               } else {
+                       /* write */
+                       retval = i2c_sendbytes(i2c_adap, &msgs[i], 0);
+               }
+               if (retval < 0)
+                       goto err;
+       }
+       return num;
+
+err:
+       return retval;
+}
+
+static int attach_inform(struct i2c_client *client)
+{
+       dprintk(1, "%s i2c attach [addr=0x%x,client=%s]\n",
+               client->driver->driver.name, client->addr, client->name);
+
+       if (!client->driver->command)
+               return 0;
+
+       return 0;
+}
+
+static int detach_inform(struct i2c_client *client)
+{
+       dprintk(1, "i2c detach [client=%s]\n", client->name);
+
+       return 0;
+}
+
+void au0828_call_i2c_clients(struct au0828_dev *dev,
+                             unsigned int cmd, void *arg)
+{
+       if (dev->i2c_rc != 0)
+               return;
+
+       i2c_clients_command(&dev->i2c_adap, cmd, arg);
+}
+
+static u32 au0828_functionality(struct i2c_adapter *adap)
+{
+       return I2C_FUNC_SMBUS_EMUL | I2C_FUNC_I2C;
+}
+
+static struct i2c_algorithm au0828_i2c_algo_template = {
+       .master_xfer    = i2c_xfer,
+       .functionality  = au0828_functionality,
+};
+
+/* ----------------------------------------------------------------------- */
+
+static struct i2c_adapter au0828_i2c_adap_template = {
+       .name              = DRIVER_NAME,
+       .owner             = THIS_MODULE,
+       .id                = I2C_HW_B_AU0828,
+       .algo              = &au0828_i2c_algo_template,
+       .class             = I2C_CLASS_TV_ANALOG,
+       .client_register   = attach_inform,
+       .client_unregister = detach_inform,
+};
+
+static struct i2c_client au0828_i2c_client_template = {
+       .name   = "au0828 internal",
+};
+
+static char *i2c_devs[128] = {
+       [ 0x8e >> 1 ] = "au8522",
+       [ 0xa0 >> 1 ] = "eeprom",
+       [ 0xc2 >> 1 ] = "tuner/xc5000",
+};
+
+static void do_i2c_scan(char *name, struct i2c_client *c)
+{
+       unsigned char buf;
+       int i, rc;
+
+       for (i = 0; i < 128; i++) {
+               c->addr = i;
+               rc = i2c_master_recv(c, &buf, 0);
+               if (rc < 0)
+                       continue;
+               printk("%s: i2c scan: found device @ 0x%x  [%s]\n",
+                      name, i << 1, i2c_devs[i] ? i2c_devs[i] : "???");
+       }
+}
+
+/* init + register i2c algo-bit adapter */
+int au0828_i2c_register(struct au0828_dev *dev)
+{
+       dprintk(1, "%s()\n", __FUNCTION__);
+
+       memcpy(&dev->i2c_adap, &au0828_i2c_adap_template,
+              sizeof(dev->i2c_adap));
+       memcpy(&dev->i2c_algo, &au0828_i2c_algo_template,
+              sizeof(dev->i2c_algo));
+       memcpy(&dev->i2c_client, &au0828_i2c_client_template,
+              sizeof(dev->i2c_client));
+
+       dev->i2c_adap.dev.parent = &dev->usbdev->dev;
+
+       strlcpy(dev->i2c_adap.name, DRIVER_NAME,
+               sizeof(dev->i2c_adap.name));
+
+       dev->i2c_algo.data = dev;
+       dev->i2c_adap.algo_data = dev;
+       i2c_set_adapdata(&dev->i2c_adap, dev);
+       i2c_add_adapter(&dev->i2c_adap);
+
+       dev->i2c_client.adapter = &dev->i2c_adap;
+
+       if (0 == dev->i2c_rc) {
+               printk("%s: i2c bus registered\n", DRIVER_NAME);
+               if (i2c_scan)
+                       do_i2c_scan(DRIVER_NAME, &dev->i2c_client);
+       } else
+               printk("%s: i2c bus register FAILED\n", DRIVER_NAME);
+       return dev->i2c_rc;
+}
+
+int au0828_i2c_unregister(struct au0828_dev *dev)
+{
+       i2c_del_adapter(&dev->i2c_adap);
+       return 0;
+}
+
+/* ----------------------------------------------------------------------- */
+
+/*
+ * Local variables:
+ * c-basic-offset: 8
+ * End:
+ */
diff --git a/drivers/media/video/au0828/au0828-reg.h b/drivers/media/video/au0828/au0828-reg.h
new file mode 100644 (file)
index 0000000..c501f6a
--- /dev/null
@@ -0,0 +1,35 @@
+/*
+ *  Driver for the Auvitek USB bridge
+ *
+ *  Copyright (c) 2008 Steven Toth <stoth@hauppauge.com>
+ *
+ *  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.
+ */
+
+#define REG_000 0x000
+#define REG_001 0x001
+#define REG_002 0x002
+#define REG_003 0x003
+
+#define REG_200 0x200
+#define REG_201 0x201
+#define REG_202 0x202
+#define REG_203 0x203
+#define REG_205 0x205
+#define REG_209 0x209
+#define REG_2FF 0x2ff
+
+#define REG_600 0x600
diff --git a/drivers/media/video/au0828/au0828.h b/drivers/media/video/au0828/au0828.h
new file mode 100644 (file)
index 0000000..5172276
--- /dev/null
@@ -0,0 +1,117 @@
+/*
+ *  Driver for the Auvitek AU0828 USB bridge
+ *
+ *  Copyright (c) 2008 Steven Toth <stoth@hauppauge.com>
+ *
+ *  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 <linux/usb.h>
+#include <linux/i2c.h>
+#include <linux/i2c-algo-bit.h>
+
+/* DVB */
+#include "demux.h"
+#include "dmxdev.h"
+#include "dvb_demux.h"
+#include "dvb_frontend.h"
+#include "dvb_net.h"
+#include "dvbdev.h"
+
+#include "au0828-reg.h"
+#include "au0828-cards.h"
+
+#define DRIVER_NAME "au0828"
+#define URB_COUNT   16
+//#define URB_BUFSIZE (312 * 188)
+#define URB_BUFSIZE (0xe522)
+
+struct au0828_board {
+       char *name;
+};
+
+struct au0828_dvb {
+       struct mutex lock;
+       struct dvb_adapter adapter;
+       struct dvb_frontend *frontend;
+       struct dvb_demux demux;
+       struct dmxdev dmxdev;
+       struct dmx_frontend fe_hw;
+       struct dmx_frontend fe_mem;
+       struct dvb_net net;
+       int feeding;
+};
+
+struct au0828_dev {
+       struct mutex mutex;
+       struct usb_device       *usbdev;
+       int                     board;
+       u8                      ctrlmsg[64];
+
+       /* I2C */
+       struct i2c_adapter              i2c_adap;
+       struct i2c_algo_bit_data        i2c_algo;
+       struct i2c_client               i2c_client;
+       u32                             i2c_rc;
+
+       /* Digital */
+       struct au0828_dvb               dvb;
+
+       /* USB / URB Related */
+       int             urb_streaming;
+       struct urb      *urbs[URB_COUNT];
+
+};
+
+struct au0828_buff {
+       struct au0828_dev       *dev;
+       struct urb              *purb;
+       struct list_head        buff_list;
+};
+
+/* ----------------------------------------------------------- */
+#define au0828_read(dev,reg) au0828_readreg(dev,reg)
+#define au0828_write(dev,reg,value) au0828_writereg(dev,reg,value)
+#define au0828_andor(dev,reg,mask,value) \
+ au0828_writereg(dev,reg,(au0828_readreg(dev,reg)&~(mask))|((value)&(mask)))
+
+#define au0828_set(dev,reg,bit) au0828_andor(dev,(reg),(bit),(bit))
+#define au0828_clear(dev,reg,bit) au0828_andor(dev,(reg),(bit),0)
+
+/* ----------------------------------------------------------- */
+/* au0828-core.c */
+extern u32 au0828_read(struct au0828_dev *dev, u16 reg);
+extern u32 au0828_write(struct au0828_dev *dev, u16 reg, u32 val);
+
+/* ----------------------------------------------------------- */
+/* au0828-cards.c */
+extern struct au0828_board au0828_boards[];
+extern struct usb_device_id au0828_usb_id_table[];
+extern const unsigned int au0828_bcount;
+extern void au0828_gpio_setup(struct au0828_dev *dev);
+extern int au0828_tuner_callback(void *priv, int command, int arg);
+
+/* ----------------------------------------------------------- */
+/* au0828-i2c.c */
+extern int au0828_i2c_register(struct au0828_dev *dev);
+extern int au0828_i2c_unregister(struct au0828_dev *dev);
+extern void au0828_call_i2c_clients(struct au0828_dev *dev,
+       unsigned int cmd, void *arg);
+
+/* ----------------------------------------------------------- */
+/* au0828-dvb.c */
+extern int au0828_dvb_register(struct au0828_dev *dev);
+extern void au0828_dvb_unregister(struct au0828_dev *dev);