[PATCH] dvb: usb: add TwinhanDTV StarBox support

Add driver for the TwinhanDTV StarBox and clones.

Thanks to Ralph Metzler for his initial work on this box and thanks to Twinhan
for their support.

Signed-off-by: Patrick Boettcher <pb@linuxtv.org>
Signed-off-by: Johannes Stezenbach <js@linuxtv.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

6 files changed, 765 insertions, 5 deletions

diff --git a/drivers/media/dvb/dvb-usb/Kconfig b/drivers/media/dvb/dvb-usb/Kconfig
index 612e5b087b1c..54e2b29076b1 100644
--- a/drivers/media/dvb/dvb-usb/Kconfig
+++ b/drivers/media/dvb/dvb-usb/Kconfig
@@ -93,13 +93,30 @@ config DVB_USB_DIGITV
           Say Y here to support the Nebula Electronics uDigitV USB2.0 DVB-T receiver.
 
 config DVB_USB_VP7045
-        tristate "TwinhanDTV Alpha/MagicBoxII and DNTV tinyUSB2 DVB-T USB2.0 support"
+        tristate "TwinhanDTV Alpha/MagicBoxII, DNTV tinyUSB2, Beetle USB2.0 support"
         depends on DVB_USB
         help
           Say Y here to support the
+
             TwinhanDTV Alpha (stick) (VP-7045),
-                TwinhanDTV MagicBox II (VP-7046) and
-                DigitalNow TinyUSB 2 DVB-t DVB-T USB2.0 receivers.
+                TwinhanDTV MagicBox II (VP-7046),
+                DigitalNow TinyUSB 2 DVB-t,
+                DigitalRise USB 2.0 Ter (Beetle) and
+                TYPHOON DVB-T USB DRIVE
+
+          DVB-T USB2.0 receivers.
+
+config DVB_USB_VP702X
+        tristate "TwinhanDTV StarBox and clones DVB-S USB2.0 support"
+        depends on DVB_USB
+        help
+          Say Y here to support the
+
+            TwinhanDTV StarBox,
+                DigitalRise USB Starbox and
+                TYPHOON DVB-S USB 2.0 BOX
+
+          DVB-S USB2.0 receivers.
 
 config DVB_USB_NOVA_T_USB2
         tristate "Hauppauge WinTV-NOVA-T usb2 DVB-T USB2.0 support"
diff --git a/drivers/media/dvb/dvb-usb/Makefile b/drivers/media/dvb/dvb-usb/Makefile
index 746d87ed6f32..2dc9aad9681e 100644
--- a/drivers/media/dvb/dvb-usb/Makefile
+++ b/drivers/media/dvb/dvb-usb/Makefile
@@ -4,6 +4,9 @@ obj-$(CONFIG_DVB_USB) += dvb-usb.o
 dvb-usb-vp7045-objs = vp7045.o vp7045-fe.o
 obj-$(CONFIG_DVB_USB_VP7045) += dvb-usb-vp7045.o
 
+dvb-usb-vp702x-objs = vp702x.o vp702x-fe.o
+obj-$(CONFIG_DVB_USB_VP702X) += dvb-usb-vp702x.o
+
 dvb-usb-dtt200u-objs = dtt200u.o dtt200u-fe.o
 obj-$(CONFIG_DVB_USB_DTT200U) += dvb-usb-dtt200u.o
 
diff --git a/drivers/media/dvb/dvb-usb/dvb-usb-ids.h b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
index 794d513a8480..2b249c75fb02 100644
--- a/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
+++ b/drivers/media/dvb/dvb-usb/dvb-usb-ids.h
@@ -52,12 +52,14 @@
 #define USB_PID_KWORLD_VSTREAM_WARM                     0x17df
 #define USB_PID_TWINHAN_VP7041_COLD                     0x3201
 #define USB_PID_TWINHAN_VP7041_WARM                     0x3202
+#define USB_PID_TWINHAN_VP7020_COLD                     0x3203
+#define USB_PID_TWINHAN_VP7020_WARM                     0x3204
 #define USB_PID_TWINHAN_VP7045_COLD                     0x3205
 #define USB_PID_TWINHAN_VP7045_WARM                     0x3206
-#define USB_PID_DNTV_TINYUSB2_COLD                      0x3223
-#define USB_PID_DNTV_TINYUSB2_WARM                      0x3224
 #define USB_PID_TWINHAN_VP7021_COLD                     0x3207
 #define USB_PID_TWINHAN_VP7021_WARM                     0x3208
+#define USB_PID_DNTV_TINYUSB2_COLD                      0x3223
+#define USB_PID_DNTV_TINYUSB2_WARM                      0x3224
 #define USB_PID_ULTIMA_TVBOX_COLD                       0x8105
 #define USB_PID_ULTIMA_TVBOX_WARM                       0x8106
 #define USB_PID_ULTIMA_TVBOX_AN2235_COLD        0x8107
diff --git a/drivers/media/dvb/dvb-usb/vp702x-fe.c b/drivers/media/dvb/dvb-usb/vp702x-fe.c
new file mode 100644
index 000000000000..f20d8dbd0be8
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp702x-fe.c
@@ -0,0 +1,339 @@
+/* DVB frontend part of the Linux driver for the TwinhanDTV StarBox USB2.0
+ * DVB-S receiver.
+ *
+ * Copyright (C) 2005 Ralph Metzler <rjkm@metzlerbros.de>
+ *                    Metzler Brothers Systementwicklung GbR
+ *
+ * Copyright (C) 2005 Patrick Boettcher <patrick.boettcher@desy.de>
+ *
+ * Thanks to Twinhan who kindly provided hardware and information.
+ *
+ * This file can be removed soon, after the DST-driver is rewritten to provice
+ * the frontend-controlling separately.
+ *
+ *      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 "vp702x.h"
+
+struct vp702x_fe_state {
+        struct dvb_frontend fe;
+        struct dvb_usb_device *d;
+
+        fe_sec_voltage_t voltage;
+        fe_sec_tone_mode_t tone_mode;
+
+        u8 lnb_buf[8];
+
+        u8 lock;
+        u8 sig;
+        u8 snr;
+
+        unsigned long next_status_check;
+        unsigned long status_check_interval;
+};
+
+static int vp702x_fe_refresh_state(struct vp702x_fe_state *st)
+{
+        u8 buf[10];
+        if (time_after(jiffies,st->next_status_check)) {
+                vp702x_usb_in_op(st->d,READ_STATUS,0,0,buf,10);
+
+                st->lock = buf[4];
+                vp702x_usb_in_op(st->d,READ_TUNER_REG_REQ,0x11,0,&st->snr,1);
+                vp702x_usb_in_op(st->d,READ_TUNER_REG_REQ,0x15,0,&st->sig,1);
+
+                st->next_status_check = jiffies + (st->status_check_interval*HZ)/1000;
+        }
+        return 0;
+}
+
+static u8 vp702x_chksum(u8 *buf,int f, int count)
+{
+        u8 s = 0;
+        int i;
+        for (i = f; i < f+count; i++)
+                s += buf[i];
+        return ~s+1;
+}
+
+static int vp702x_fe_read_status(struct dvb_frontend* fe, fe_status_t *status)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+        deb_fe("%s\n",__FUNCTION__);
+
+        if (st->lock == 0)
+                *status = FE_HAS_LOCK | FE_HAS_SYNC | FE_HAS_VITERBI | FE_HAS_SIGNAL | FE_HAS_CARRIER;
+        else
+                *status = 0;
+
+        deb_fe("real state: %x\n",*status);
+        *status = 0x1f;
+
+        if (*status & FE_HAS_LOCK)
+                st->status_check_interval = 1000;
+        else
+                st->status_check_interval = 250;
+        return 0;
+}
+
+/* not supported by this Frontend */
+static int vp702x_fe_read_ber(struct dvb_frontend* fe, u32 *ber)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+        *ber = 0;
+        return 0;
+}
+
+/* not supported by this Frontend */
+static int vp702x_fe_read_unc_blocks(struct dvb_frontend* fe, u32 *unc)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+        *unc = 0;
+        return 0;
+}
+
+static int vp702x_fe_read_signal_strength(struct dvb_frontend* fe, u16 *strength)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+
+        *strength = (st->sig << 8) | st->sig;
+        return 0;
+}
+
+static int vp702x_fe_read_snr(struct dvb_frontend* fe, u16 *snr)
+{
+        u8 _snr;
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        vp702x_fe_refresh_state(st);
+
+        _snr = (st->snr & 0x1f) * 0xff / 0x1f;
+        *snr = (_snr << 8) | _snr;
+        return 0;
+}
+
+static int vp702x_fe_get_tune_settings(struct dvb_frontend* fe, struct dvb_frontend_tune_settings *tune)
+{
+        deb_fe("%s\n",__FUNCTION__);
+        tune->min_delay_ms = 2000;
+        return 0;
+}
+
+static int vp702x_fe_set_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        u32 freq = fep->frequency/1000;
+        /*CalFrequency*/
+/*      u16 frequencyRef[16] = { 2, 4, 8, 16, 32, 64, 128, 256, 24, 5, 10, 20, 40, 80, 160, 320 }; */
+        u64 sr;
+        u8 cmd[8] = { 0 },ibuf[10];
+
+        cmd[0] = (freq >> 8) & 0x7f;
+        cmd[1] =  freq       & 0xff;
+        cmd[2] = 1; /* divrate == 4 -> frequencyRef[1] -> 1 here */
+
+        sr = (u64) (fep->u.qpsk.symbol_rate/1000) << 20;
+        do_div(sr,88000);
+        cmd[3] = (sr >> 12) & 0xff;
+        cmd[4] = (sr >> 4)  & 0xff;
+        cmd[5] = (sr << 4)  & 0xf0;
+
+        deb_fe("setting frontend to: %u -> %u (%x) LNB-based GHz, symbolrate: %d -> %Lu (%Lx)\n",
+                        fep->frequency,freq,freq, fep->u.qpsk.symbol_rate, sr, sr);
+
+/*      if (fep->inversion == INVERSION_ON)
+                cmd[6] |= 0x80; */
+
+        if (st->voltage == SEC_VOLTAGE_18)
+                cmd[6] |= 0x40;
+
+/*      if (fep->u.qpsk.symbol_rate > 8000000)
+                cmd[6] |= 0x20;
+
+        if (fep->frequency < 1531000)
+                cmd[6] |= 0x04;
+
+        if (st->tone_mode == SEC_TONE_ON)
+                cmd[6] |= 0x01;*/
+
+        cmd[7] = vp702x_chksum(cmd,0,7);
+
+        st->status_check_interval = 250;
+        st->next_status_check = jiffies;
+
+        vp702x_usb_in_op(st->d, RESET_TUNER, 0, 0, NULL, 0);
+        msleep(30);
+        vp702x_usb_inout_op(st->d,cmd,8,ibuf,10,100);
+
+        if (ibuf[2] == 0 && ibuf[3] == 0)
+                deb_fe("tuning failed.\n");
+        else
+                deb_fe("tuning succeeded.\n");
+
+        return 0;
+}
+
+static int vp702x_fe_get_frontend(struct dvb_frontend* fe,
+                                  struct dvb_frontend_parameters *fep)
+{
+        deb_fe("%s\n",__FUNCTION__);
+        return 0;
+}
+
+static int vp702x_fe_send_diseqc_msg (struct dvb_frontend* fe,
+                                    struct dvb_diseqc_master_cmd *m)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        u8 cmd[8],ibuf[10];
+        memset(cmd,0,8);
+
+        deb_fe("%s\n",__FUNCTION__);
+
+        if (m->msg_len > 4)
+                return -EINVAL;
+
+        cmd[1] = SET_DISEQC_CMD;
+        cmd[2] = m->msg_len;
+        memcpy(&cmd[3], m->msg, m->msg_len);
+        cmd[7] = vp702x_chksum(cmd,0,7);
+
+        vp702x_usb_inout_op(st->d,cmd,8,ibuf,10,100);
+
+        if (ibuf[2] == 0 && ibuf[3] == 0)
+                deb_fe("diseqc cmd failed.\n");
+        else
+                deb_fe("diseqc cmd succeeded.\n");
+
+        return 0;
+}
+
+static int vp702x_fe_send_diseqc_burst (struct dvb_frontend* fe, fe_sec_mini_cmd_t burst)
+{
+        deb_fe("%s\n",__FUNCTION__);
+        return 0;
+}
+
+static int vp702x_fe_set_tone(struct dvb_frontend* fe, fe_sec_tone_mode_t tone)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        u8 ibuf[10];
+        deb_fe("%s\n",__FUNCTION__);
+
+        st->tone_mode = tone;
+
+        if (tone == SEC_TONE_ON)
+                st->lnb_buf[2] = 0x02;
+        else
+                st->lnb_buf[2] = 0x00;
+
+        st->lnb_buf[7] = vp702x_chksum(st->lnb_buf,0,7);
+
+        vp702x_usb_inout_op(st->d,st->lnb_buf,8,ibuf,10,100);
+        if (ibuf[2] == 0 && ibuf[3] == 0)
+                deb_fe("set_tone cmd failed.\n");
+        else
+                deb_fe("set_tone cmd succeeded.\n");
+
+        return 0;
+}
+
+static int vp702x_fe_set_voltage (struct dvb_frontend* fe, fe_sec_voltage_t
+                voltage)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        u8 ibuf[10];
+        deb_fe("%s\n",__FUNCTION__);
+
+        st->voltage = voltage;
+
+        if (voltage != SEC_VOLTAGE_OFF)
+                st->lnb_buf[4] = 0x01;
+        else
+                st->lnb_buf[4] = 0x00;
+
+        st->lnb_buf[7] = vp702x_chksum(st->lnb_buf,0,7);
+
+        vp702x_usb_inout_op(st->d,st->lnb_buf,8,ibuf,10,100);
+        if (ibuf[2] == 0 && ibuf[3] == 0)
+                deb_fe("set_voltage cmd failed.\n");
+        else
+                deb_fe("set_voltage cmd succeeded.\n");
+
+        return 0;
+}
+
+static void vp702x_fe_release(struct dvb_frontend* fe)
+{
+        struct vp702x_fe_state *st = fe->demodulator_priv;
+        kfree(st);
+}
+
+static struct dvb_frontend_ops vp702x_fe_ops;
+
+struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d)
+{
+        struct vp702x_fe_state *s = kmalloc(sizeof(struct vp702x_fe_state), GFP_KERNEL);
+        if (s == NULL)
+                goto error;
+        memset(s,0,sizeof(struct vp702x_fe_state));
+
+        s->d = d;
+        s->fe.ops = &vp702x_fe_ops;
+        s->fe.demodulator_priv = s;
+
+        s->lnb_buf[1] = SET_LNB_POWER;
+        s->lnb_buf[3] = 0xff; /* 0=tone burst, 2=data burst, ff=off */
+
+        goto success;
+error:
+        return NULL;
+success:
+        return &s->fe;
+}
+
+
+static struct dvb_frontend_ops vp702x_fe_ops = {
+        .info = {
+                .name           = "Twinhan DST-like frontend (VP7021/VP7020) DVB-S",
+                .type           = FE_QPSK,
+                .frequency_min       = 950000,
+                .frequency_max       = 2150000,
+                .frequency_stepsize  = 1000,   /* kHz for QPSK frontends */
+                .frequency_tolerance = 0,
+                .symbol_rate_min     = 1000000,
+                .symbol_rate_max     = 45000000,
+                .symbol_rate_tolerance = 500,  /* ppm */
+                .caps = FE_CAN_FEC_1_2 | FE_CAN_FEC_2_3 | FE_CAN_FEC_3_4 |
+                FE_CAN_FEC_5_6 | FE_CAN_FEC_7_8 |
+                FE_CAN_QPSK |
+                FE_CAN_FEC_AUTO
+        },
+        .release = vp702x_fe_release,
+
+        .init = NULL,
+        .sleep = NULL,
+
+        .set_frontend = vp702x_fe_set_frontend,
+        .get_frontend = vp702x_fe_get_frontend,
+        .get_tune_settings = vp702x_fe_get_tune_settings,
+
+        .read_status = vp702x_fe_read_status,
+        .read_ber = vp702x_fe_read_ber,
+        .read_signal_strength = vp702x_fe_read_signal_strength,
+        .read_snr = vp702x_fe_read_snr,
+        .read_ucblocks = vp702x_fe_read_unc_blocks,
+
+        .diseqc_send_master_cmd = vp702x_fe_send_diseqc_msg,
+        .diseqc_send_burst = vp702x_fe_send_diseqc_burst,
+        .set_tone = vp702x_fe_set_tone,
+        .set_voltage = vp702x_fe_set_voltage,
+};
diff --git a/drivers/media/dvb/dvb-usb/vp702x.c b/drivers/media/dvb/dvb-usb/vp702x.c
new file mode 100644
index 000000000000..1f5034ca1152
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp702x.c
@@ -0,0 +1,290 @@
+/* DVB USB compliant Linux driver for the TwinhanDTV StarBox USB2.0 DVB-S
+ * receiver.
+ *
+ * Copyright (C) 2005 Ralph Metzler <rjkm@metzlerbros.de>
+ *                    Metzler Brothers Systementwicklung GbR
+ *
+ * Copyright (C) 2005 Patrick Boettcher <patrick.boettcher@desy.de>
+ *
+ * Thanks to Twinhan who kindly provided hardware and information.
+ *
+ *      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 "vp702x.h"
+
+/* debug */
+int dvb_usb_vp702x_debug;
+module_param_named(debug,dvb_usb_vp702x_debug, int, 0644);
+MODULE_PARM_DESC(debug, "set debugging level (1=info,xfer=2,rc=4 (or-able))." DVB_USB_DEBUG_STATUS);
+
+struct vp702x_state {
+        u8 pid_table[17]; /* [16] controls the pid_table state */
+};
+
+/* check for mutex FIXME */
+int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
+{
+        int ret = 0,try = 0;
+
+        while (ret >= 0 && ret != blen && try < 3) {
+                ret = usb_control_msg(d->udev,
+                        usb_rcvctrlpipe(d->udev,0),
+                        req,
+                        USB_TYPE_VENDOR | USB_DIR_IN,
+                        value,index,b,blen,
+                        2000);
+                deb_info("reading number %d (ret: %d)\n",try,ret);
+                try++;
+        }
+
+        if (ret < 0 || ret != blen) {
+                warn("usb in operation failed.");
+                ret = -EIO;
+        } else
+                ret = 0;
+
+        deb_xfer("in: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
+        debug_dump(b,blen,deb_xfer);
+
+        return ret;
+}
+
+int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen)
+{
+        deb_xfer("out: req. %x, val: %x, ind: %x, buffer: ",req,value,index);
+        debug_dump(b,blen,deb_xfer);
+
+        if (usb_control_msg(d->udev,
+                        usb_sndctrlpipe(d->udev,0),
+                        req,
+                        USB_TYPE_VENDOR | USB_DIR_OUT,
+                        value,index,b,blen,
+                        2000) != blen) {
+                warn("usb out operation failed.");
+                return -EIO;
+        } else
+                return 0;
+}
+
+int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec)
+{
+        int ret;
+
+        if ((ret = down_interruptible(&d->usb_sem)))
+                return ret;
+
+        if ((ret = vp702x_usb_out_op(d,REQUEST_OUT,0,0,o,olen)) < 0)
+                goto unlock;
+        msleep(msec);
+        ret = vp702x_usb_in_op(d,REQUEST_IN,0,0,i,ilen);
+
+unlock:
+        up(&d->usb_sem);
+
+        return ret;
+}
+
+int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, int olen, u8 *i, int ilen, int msec)
+{
+        u8 bout[olen+2];
+        u8 bin[ilen+1];
+        int ret = 0;
+
+        bout[0] = 0x00;
+        bout[1] = cmd;
+        memcpy(&bout[2],o,olen);
+
+        ret = vp702x_usb_inout_op(d, bout, olen+2, bin, ilen+1,msec);
+
+        if (ret == 0)
+                memcpy(i,&bin[1],ilen);
+
+        return ret;
+}
+
+static int vp702x_pid_filter(struct dvb_usb_device *d, int index, u16 pid, int onoff)
+{
+        struct vp702x_state *st = d->priv;
+        u8 buf[9];
+
+        if (onoff) {
+                st->pid_table[16]   |=   1 << index;
+                st->pid_table[index*2]   = (pid >> 8) & 0xff;
+                st->pid_table[index*2+1] =  pid       & 0xff;
+        } else {
+                st->pid_table[16]   &= ~(1 << index);
+                st->pid_table[index*2] = st->pid_table[index*2+1] = 0;
+        }
+
+        return vp702x_usb_inout_cmd(d,SET_PID_FILTER,st->pid_table,17,buf,9,10);
+}
+
+static int vp702x_power_ctrl(struct dvb_usb_device *d, int onoff)
+{
+        vp702x_usb_in_op(d,RESET_TUNER,0,0,NULL,0);
+
+        vp702x_usb_in_op(d,SET_TUNER_POWER_REQ,0,onoff,NULL,0);
+        return vp702x_usb_in_op(d,SET_TUNER_POWER_REQ,0,onoff,NULL,0);
+}
+
+/* keys for the enclosed remote control */
+static struct dvb_usb_rc_key vp702x_rc_keys[] = {
+        { 0x00, 0x01, KEY_1 },
+        { 0x00, 0x02, KEY_2 },
+};
+
+/* remote control stuff (does not work with my box) */
+static int vp702x_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
+{
+        u8 key[10];
+        int i;
+
+/* remove the following return to enabled remote querying */
+        return 0;
+
+        vp702x_usb_in_op(d,READ_REMOTE_REQ,0,0,key,10);
+
+        deb_rc("remote query key: %x %d\n",key[1],key[1]);
+
+        if (key[1] == 0x44) {
+                *state = REMOTE_NO_KEY_PRESSED;
+                return 0;
+        }
+
+        for (i = 0; i < ARRAY_SIZE(vp702x_rc_keys); i++)
+                if (vp702x_rc_keys[i].custom == key[1]) {
+                        *state = REMOTE_KEY_PRESSED;
+                        *event = vp702x_rc_keys[i].event;
+                        break;
+                }
+        return 0;
+}
+
+static int vp702x_read_mac_addr(struct dvb_usb_device *d,u8 mac[6])
+{
+        u8 macb[9];
+        if (vp702x_usb_inout_cmd(d, GET_MAC_ADDRESS, NULL, 0, macb, 9, 10))
+                return -EIO;
+        memcpy(mac,&macb[3],6);
+        return 0;
+}
+
+static int vp702x_frontend_attach(struct dvb_usb_device *d)
+{
+        u8 buf[9] = { 0 };
+
+        if (vp702x_usb_inout_cmd(d, GET_SYSTEM_STRING, NULL, 0, buf, 9, 10))
+                return -EIO;
+
+        buf[8] = '\0';
+        info("system string: %s",&buf[1]);
+
+        d->fe = vp702x_fe_attach(d);
+        return 0;
+}
+
+static struct dvb_usb_properties vp702x_properties;
+
+static int vp702x_usb_probe(struct usb_interface *intf,
+                const struct usb_device_id *id)
+{
+        struct usb_device *udev = interface_to_usbdev(intf);
+
+        usb_clear_halt(udev,usb_sndctrlpipe(udev,0));
+        usb_clear_halt(udev,usb_rcvctrlpipe(udev,0));
+
+        return dvb_usb_device_init(intf,&vp702x_properties,THIS_MODULE);
+}
+
+static struct usb_device_id vp702x_usb_table [] = {
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_COLD) },
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7021_WARM) },
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_COLD) },
+            { USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TWINHAN_VP7020_WARM) },
+            { 0 },
+};
+MODULE_DEVICE_TABLE(usb, vp702x_usb_table);
+
+static struct dvb_usb_properties vp702x_properties = {
+        .caps = DVB_USB_HAS_PID_FILTER | DVB_USB_NEED_PID_FILTERING,
+        .pid_filter_count = 8, /* !!! */
+
+        .usb_ctrl = CYPRESS_FX2,
+        .firmware = "dvb-usb-vp702x-01.fw",
+
+        .pid_filter       = vp702x_pid_filter,
+        .power_ctrl       = vp702x_power_ctrl,
+        .frontend_attach  = vp702x_frontend_attach,
+        .read_mac_address = vp702x_read_mac_addr,
+
+        .rc_key_map       = vp702x_rc_keys,
+        .rc_key_map_size  = ARRAY_SIZE(vp702x_rc_keys),
+        .rc_interval      = 400,
+        .rc_query         = vp702x_rc_query,
+
+        .size_of_priv     = sizeof(struct vp702x_state),
+
+        /* parameter for the MPEG2-data transfer */
+        .urb = {
+                .type = DVB_USB_BULK,
+                .count = 7,
+                .endpoint = 0x02,
+                .u = {
+                        .bulk = {
+                                .buffersize = 4096,
+                        }
+                }
+        },
+
+        .num_device_descs = 2,
+        .devices = {
+                { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7021)",
+                  .cold_ids = { &vp702x_usb_table[0], NULL },
+                  .warm_ids = { &vp702x_usb_table[1], NULL },
+                },
+                { .name = "TwinhanDTV StarBox DVB-S USB2.0 (VP7020)",
+                  .cold_ids = { &vp702x_usb_table[2], NULL },
+                  .warm_ids = { &vp702x_usb_table[3], NULL },
+                },
+                { 0 },
+        }
+};
+
+/* usb specific object needed to register this driver with the usb subsystem */
+static struct usb_driver vp702x_usb_driver = {
+        .owner          = THIS_MODULE,
+        .name           = "dvb-usb-vp702x",
+        .probe          = vp702x_usb_probe,
+        .disconnect = dvb_usb_device_exit,
+        .id_table       = vp702x_usb_table,
+};
+
+/* module stuff */
+static int __init vp702x_usb_module_init(void)
+{
+        int result;
+        if ((result = usb_register(&vp702x_usb_driver))) {
+                err("usb_register failed. (%d)",result);
+                return result;
+        }
+
+        return 0;
+}
+
+static void __exit vp702x_usb_module_exit(void)
+{
+        /* deregister this driver from the USB subsystem */
+        usb_deregister(&vp702x_usb_driver);
+}
+
+module_init(vp702x_usb_module_init);
+module_exit(vp702x_usb_module_exit);
+
+MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
+MODULE_DESCRIPTION("Driver for Twinhan StarBox DVB-S USB2.0 and clones");
+MODULE_VERSION("1.0-alpha");
+MODULE_LICENSE("GPL");
diff --git a/drivers/media/dvb/dvb-usb/vp702x.h b/drivers/media/dvb/dvb-usb/vp702x.h
new file mode 100644
index 000000000000..4a3e8c7eca2b
--- /dev/null
+++ b/drivers/media/dvb/dvb-usb/vp702x.h
@@ -0,0 +1,109 @@
+#ifndef _DVB_USB_VP7021_H_
+#define _DVB_USB_VP7021_H_
+
+#define DVB_USB_LOG_PREFIX "vp702x"
+#include "dvb-usb.h"
+
+extern int dvb_usb_vp702x_debug;
+#define deb_info(args...) dprintk(dvb_usb_vp702x_debug,0x01,args)
+#define deb_xfer(args...) dprintk(dvb_usb_vp702x_debug,0x02,args)
+#define deb_rc(args...)   dprintk(dvb_usb_vp702x_debug,0x04,args)
+#define deb_fe(args...)   dprintk(dvb_usb_vp702x_debug,0x08,args)
+
+/* commands are read and written with USB control messages */
+
+/* consecutive read/write operation */
+#define REQUEST_OUT       0xB2
+#define REQUEST_IN                0xB3
+
+/* the out-buffer of these consecutive operations contain sub-commands when b[0] = 0
+ * request: 0xB2; i: 0; v: 0; b[0] = 0, b[1] = subcmd, additional buffer
+ * the returning buffer looks as follows
+ * request: 0xB3; i: 0; v: 0; b[0] = 0xB3, additional buffer */
+
+#define GET_TUNER_STATUS  0x05
+/* additional in buffer:
+ * 0   1   2    3              4   5   6               7       8
+ * N/A N/A 0x05 signal-quality N/A N/A signal-strength lock==0 N/A */
+
+#define GET_SYSTEM_STRING 0x06
+/* additional in buffer:
+ * 0   1   2   3   4   5   6   7   8
+ * N/A 'U' 'S' 'B' '7' '0' '2' 'X' N/A */
+
+#define SET_DISEQC_CMD    0x08
+/* additional out buffer:
+ * 0    1  2  3  4
+ * len  X1 X2 X3 X4
+ * additional in buffer:
+ * 0   1 2
+ * N/A 0 0   b[1] == b[2] == 0 -> success otherwise not */
+
+#define SET_LNB_POWER     0x09
+/* additional out buffer:
+ * 0    1    2
+ * 0x00 0xff 1 = on, 0 = off
+ * additional in buffer:
+ * 0   1 2
+ * N/A 0 0   b[1] == b[2] == 0 -> success otherwise not */
+
+#define GET_MAC_ADDRESS   0x0A
+/* #define GET_MAC_ADDRESS   0x0B */
+/* additional in buffer:
+ * 0   1   2            3    4    5    6    7    8
+ * N/A N/A 0x0A or 0x0B MAC0 MAC1 MAC2 MAC3 MAC4 MAC5 */
+
+#define SET_PID_FILTER    0x11
+/* additional in buffer:
+ * 0        1        ... 14       15       16
+ * PID0_MSB PID0_LSB ... PID7_MSB PID7_LSB PID_active (bits) */
+
+/* request: 0xB2; i: 0; v: 0;
+ * b[0] != 0 -> tune and lock a channel
+ * 0     1     2       3      4      5      6    7
+ * freq0 freq1 divstep srate0 srate1 srate2 flag chksum
+ */
+
+
+/* one direction requests */
+#define READ_REMOTE_REQ       0xB4
+/* IN  i: 0; v: 0; b[0] == request, b[1] == key */
+
+#define READ_PID_NUMBER_REQ   0xB5
+/* IN  i: 0; v: 0; b[0] == request, b[1] == 0, b[2] = pid number */
+
+#define WRITE_EEPROM_REQ      0xB6
+/* OUT i: offset; v: value to write; no extra buffer */
+
+#define READ_EEPROM_REQ       0xB7
+/* IN  i: bufferlen; v: offset; buffer with bufferlen bytes */
+
+#define READ_STATUS           0xB8
+/* IN  i: 0; v: 0; bufferlen 10 */
+
+#define READ_TUNER_REG_REQ    0xB9
+/* IN  i: 0; v: register; b[0] = value */
+
+#define READ_FX2_REG_REQ      0xBA
+/* IN  i: offset; v: 0; b[0] = value */
+
+#define WRITE_FX2_REG_REQ     0xBB
+/* OUT i: offset; v: value to write; 1 byte extra buffer */
+
+#define SET_TUNER_POWER_REQ   0xBC
+/* IN  i: 0 = power off, 1 = power on */
+
+#define WRITE_TUNER_REG_REQ   0xBD
+/* IN  i: register, v: value to write, no extra buffer */
+
+#define RESET_TUNER           0xBE
+/* IN  i: 0, v: 0, no extra buffer */
+
+extern struct dvb_frontend * vp702x_fe_attach(struct dvb_usb_device *d);
+
+extern int vp702x_usb_inout_op(struct dvb_usb_device *d, u8 *o, int olen, u8 *i, int ilen, int msec);
+extern int vp702x_usb_inout_cmd(struct dvb_usb_device *d, u8 cmd, u8 *o, int olen, u8 *i, int ilen, int msec);
+extern int vp702x_usb_in_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen);
+extern int vp702x_usb_out_op(struct dvb_usb_device *d, u8 req, u16 value, u16 index, u8 *b, int blen);
+
+#endif