source: src/linux/universal/linux-4.9/drivers/media/usb/dvb-usb/cxusb.c @ 31885

Last change on this file since 31885 was 31885, checked in by brainslayer, 5 weeks ago

update

File size: 58.1 KB
Line 
1/* DVB USB compliant linux driver for Conexant USB reference design.
2 *
3 * The Conexant reference design I saw on their website was only for analogue
4 * capturing (using the cx25842). The box I took to write this driver (reverse
5 * engineered) is the one labeled Medion MD95700. In addition to the cx25842
6 * for analogue capturing it also has a cx22702 DVB-T demodulator on the main
7 * board. Besides it has a atiremote (X10) and a USB2.0 hub onboard.
8 *
9 * Maybe it is a little bit premature to call this driver cxusb, but I assume
10 * the USB protocol is identical or at least inherited from the reference
11 * design, so it can be reused for the "analogue-only" device (if it will
12 * appear at all).
13 *
14 * TODO: Use the cx25840-driver for the analogue part
15 *
16 * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@posteo.de)
17 * Copyright (C) 2006 Michael Krufky (mkrufky@linuxtv.org)
18 * Copyright (C) 2006, 2007 Chris Pascoe (c.pascoe@itee.uq.edu.au)
19 *
20 *   This program is free software; you can redistribute it and/or modify it
21 *   under the terms of the GNU General Public License as published by the Free
22 *   Software Foundation, version 2.
23 *
24 * see Documentation/dvb/README.dvb-usb for more information
25 */
26#include <media/tuner.h>
27#include <linux/vmalloc.h>
28#include <linux/slab.h>
29
30#include "cxusb.h"
31
32#include "cx22702.h"
33#include "lgdt330x.h"
34#include "mt352.h"
35#include "mt352_priv.h"
36#include "zl10353.h"
37#include "tuner-xc2028.h"
38#include "tuner-simple.h"
39#include "mxl5005s.h"
40#include "max2165.h"
41#include "dib7000p.h"
42#include "dib0070.h"
43#include "lgs8gxx.h"
44#include "atbm8830.h"
45#include "si2168.h"
46#include "si2157.h"
47
48/* debug */
49static int dvb_usb_cxusb_debug;
50module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
51MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
52
53DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
54
55#define deb_info(args...)   dprintk(dvb_usb_cxusb_debug, 0x03, args)
56#define deb_i2c(args...)    dprintk(dvb_usb_cxusb_debug, 0x02, args)
57
58static int cxusb_ctrl_msg(struct dvb_usb_device *d,
59                          u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
60{
61        struct cxusb_state *st = d->priv;
62        int ret;
63
64        if (1 + wlen > MAX_XFER_SIZE) {
65                warn("i2c wr: len=%d is too big!\n", wlen);
66                return -EOPNOTSUPP;
67        }
68
69        if (rlen > MAX_XFER_SIZE) {
70                warn("i2c rd: len=%d is too big!\n", rlen);
71                return -EOPNOTSUPP;
72        }
73
74        mutex_lock(&d->data_mutex);
75        st->data[0] = cmd;
76        memcpy(&st->data[1], wbuf, wlen);
77        ret = dvb_usb_generic_rw(d, st->data, 1 + wlen, st->data, rlen, 0);
78        if (!ret && rbuf && rlen)
79                memcpy(rbuf, st->data, rlen);
80
81        mutex_unlock(&d->data_mutex);
82        return ret;
83}
84
85/* GPIO */
86static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
87{
88        struct cxusb_state *st = d->priv;
89        u8 o[2], i;
90
91        if (st->gpio_write_state[GPIO_TUNER] == onoff)
92                return;
93
94        o[0] = GPIO_TUNER;
95        o[1] = onoff;
96        cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
97
98        if (i != 0x01)
99                deb_info("gpio_write failed.\n");
100
101        st->gpio_write_state[GPIO_TUNER] = onoff;
102}
103
104static int cxusb_bluebird_gpio_rw(struct dvb_usb_device *d, u8 changemask,
105                                 u8 newval)
106{
107        u8 o[2], gpio_state;
108        int rc;
109
110        o[0] = 0xff & ~changemask;      /* mask of bits to keep */
111        o[1] = newval & changemask;     /* new values for bits  */
112
113        rc = cxusb_ctrl_msg(d, CMD_BLUEBIRD_GPIO_RW, o, 2, &gpio_state, 1);
114        if (rc < 0 || (gpio_state & changemask) != (newval & changemask))
115                deb_info("bluebird_gpio_write failed.\n");
116
117        return rc < 0 ? rc : gpio_state;
118}
119
120static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device *d, u8 pin, int low)
121{
122        cxusb_bluebird_gpio_rw(d, pin, low ? 0 : pin);
123        msleep(5);
124        cxusb_bluebird_gpio_rw(d, pin, low ? pin : 0);
125}
126
127static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff)
128{
129        cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40);
130}
131
132static int cxusb_d680_dmb_gpio_tuner(struct dvb_usb_device *d,
133                u8 addr, int onoff)
134{
135        u8  o[2] = {addr, onoff};
136        u8  i;
137        int rc;
138
139        rc = cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
140
141        if (rc < 0)
142                return rc;
143        if (i == 0x01)
144                return 0;
145        else {
146                deb_info("gpio_write failed.\n");
147                return -EIO;
148        }
149}
150
151/* I2C */
152static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
153                          int num)
154{
155        struct dvb_usb_device *d = i2c_get_adapdata(adap);
156        int ret;
157        int i;
158
159        if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
160                return -EAGAIN;
161
162        for (i = 0; i < num; i++) {
163
164                if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_MEDION)
165                        switch (msg[i].addr) {
166                        case 0x63:
167                                cxusb_gpio_tuner(d, 0);
168                                break;
169                        default:
170                                cxusb_gpio_tuner(d, 1);
171                                break;
172                        }
173
174                if (msg[i].flags & I2C_M_RD) {
175                        /* read only */
176                        u8 obuf[3], ibuf[MAX_XFER_SIZE];
177
178                        if (1 + msg[i].len > sizeof(ibuf)) {
179                                warn("i2c rd: len=%d is too big!\n",
180                                     msg[i].len);
181                                ret = -EOPNOTSUPP;
182                                goto unlock;
183                        }
184                        obuf[0] = 0;
185                        obuf[1] = msg[i].len;
186                        obuf[2] = msg[i].addr;
187                        if (cxusb_ctrl_msg(d, CMD_I2C_READ,
188                                           obuf, 3,
189                                           ibuf, 1+msg[i].len) < 0) {
190                                warn("i2c read failed");
191                                break;
192                        }
193                        memcpy(msg[i].buf, &ibuf[1], msg[i].len);
194                } else if (i+1 < num && (msg[i+1].flags & I2C_M_RD) &&
195                           msg[i].addr == msg[i+1].addr) {
196                        /* write to then read from same address */
197                        u8 obuf[MAX_XFER_SIZE], ibuf[MAX_XFER_SIZE];
198
199                        if (3 + msg[i].len > sizeof(obuf)) {
200                                warn("i2c wr: len=%d is too big!\n",
201                                     msg[i].len);
202                                ret = -EOPNOTSUPP;
203                                goto unlock;
204                        }
205                        if (1 + msg[i + 1].len > sizeof(ibuf)) {
206                                warn("i2c rd: len=%d is too big!\n",
207                                     msg[i + 1].len);
208                                ret = -EOPNOTSUPP;
209                                goto unlock;
210                        }
211                        obuf[0] = msg[i].len;
212                        obuf[1] = msg[i+1].len;
213                        obuf[2] = msg[i].addr;
214                        memcpy(&obuf[3], msg[i].buf, msg[i].len);
215
216                        if (cxusb_ctrl_msg(d, CMD_I2C_READ,
217                                           obuf, 3+msg[i].len,
218                                           ibuf, 1+msg[i+1].len) < 0)
219                                break;
220
221                        if (ibuf[0] != 0x08)
222                                deb_i2c("i2c read may have failed\n");
223
224                        memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
225
226                        i++;
227                } else {
228                        /* write only */
229                        u8 obuf[MAX_XFER_SIZE], ibuf;
230
231                        if (2 + msg[i].len > sizeof(obuf)) {
232                                warn("i2c wr: len=%d is too big!\n",
233                                     msg[i].len);
234                                ret = -EOPNOTSUPP;
235                                goto unlock;
236                        }
237                        obuf[0] = msg[i].addr;
238                        obuf[1] = msg[i].len;
239                        memcpy(&obuf[2], msg[i].buf, msg[i].len);
240
241                        if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf,
242                                           2+msg[i].len, &ibuf,1) < 0)
243                                break;
244                        if (ibuf != 0x08)
245                                deb_i2c("i2c write may have failed\n");
246                }
247        }
248
249        if (i == num)
250                ret = num;
251        else
252                ret = -EREMOTEIO;
253
254unlock:
255        mutex_unlock(&d->i2c_mutex);
256        return ret;
257}
258
259static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
260{
261        return I2C_FUNC_I2C;
262}
263
264static struct i2c_algorithm cxusb_i2c_algo = {
265        .master_xfer   = cxusb_i2c_xfer,
266        .functionality = cxusb_i2c_func,
267};
268
269static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
270{
271        u8 b = 0;
272        if (onoff)
273                return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
274        else
275                return cxusb_ctrl_msg(d, CMD_POWER_OFF, &b, 1, NULL, 0);
276}
277
278static int cxusb_aver_power_ctrl(struct dvb_usb_device *d, int onoff)
279{
280        int ret;
281        if (!onoff)
282                return cxusb_ctrl_msg(d, CMD_POWER_OFF, NULL, 0, NULL, 0);
283        if (d->state == DVB_USB_STATE_INIT &&
284            usb_set_interface(d->udev, 0, 0) < 0)
285                err("set interface failed");
286        do {} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, 0, NULL, 0)) &&
287                   !(ret = cxusb_ctrl_msg(d, 0x15, NULL, 0, NULL, 0)) &&
288                   !(ret = cxusb_ctrl_msg(d, 0x17, NULL, 0, NULL, 0)) && 0);
289        if (!ret) {
290                /* FIXME: We don't know why, but we need to configure the
291                 * lgdt3303 with the register settings below on resume */
292                int i;
293                u8 buf, bufs[] = {
294                        0x0e, 0x2, 0x00, 0x7f,
295                        0x0e, 0x2, 0x02, 0xfe,
296                        0x0e, 0x2, 0x02, 0x01,
297                        0x0e, 0x2, 0x00, 0x03,
298                        0x0e, 0x2, 0x0d, 0x40,
299                        0x0e, 0x2, 0x0e, 0x87,
300                        0x0e, 0x2, 0x0f, 0x8e,
301                        0x0e, 0x2, 0x10, 0x01,
302                        0x0e, 0x2, 0x14, 0xd7,
303                        0x0e, 0x2, 0x47, 0x88,
304                };
305                msleep(20);
306                for (i = 0; i < sizeof(bufs)/sizeof(u8); i += 4/sizeof(u8)) {
307                        ret = cxusb_ctrl_msg(d, CMD_I2C_WRITE,
308                                             bufs+i, 4, &buf, 1);
309                        if (ret)
310                                break;
311                        if (buf != 0x8)
312                                return -EREMOTEIO;
313                }
314        }
315        return ret;
316}
317
318static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff)
319{
320        u8 b = 0;
321        if (onoff)
322                return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
323        else
324                return 0;
325}
326
327static int cxusb_nano2_power_ctrl(struct dvb_usb_device *d, int onoff)
328{
329        int rc = 0;
330
331        rc = cxusb_power_ctrl(d, onoff);
332        if (!onoff)
333                cxusb_nano2_led(d, 0);
334
335        return rc;
336}
337
338static int cxusb_d680_dmb_power_ctrl(struct dvb_usb_device *d, int onoff)
339{
340        int ret;
341        u8  b;
342        ret = cxusb_power_ctrl(d, onoff);
343        if (!onoff)
344                return ret;
345
346        msleep(128);
347        cxusb_ctrl_msg(d, CMD_DIGITAL, NULL, 0, &b, 1);
348        msleep(100);
349        return ret;
350}
351
352static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
353{
354        u8 buf[2] = { 0x03, 0x00 };
355        if (onoff)
356                cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0);
357        else
358                cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
359
360        return 0;
361}
362
363static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
364{
365        if (onoff)
366                cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_ON, NULL, 0, NULL, 0);
367        else
368                cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_OFF,
369                               NULL, 0, NULL, 0);
370        return 0;
371}
372
373static void cxusb_d680_dmb_drain_message(struct dvb_usb_device *d)
374{
375        int       ep = d->props.generic_bulk_ctrl_endpoint;
376        const int timeout = 100;
377        const int junk_len = 32;
378        u8        *junk;
379        int       rd_count;
380
381        /* Discard remaining data in video pipe */
382        junk = kmalloc(junk_len, GFP_KERNEL);
383        if (!junk)
384                return;
385        while (1) {
386                if (usb_bulk_msg(d->udev,
387                        usb_rcvbulkpipe(d->udev, ep),
388                        junk, junk_len, &rd_count, timeout) < 0)
389                        break;
390                if (!rd_count)
391                        break;
392        }
393        kfree(junk);
394}
395
396static void cxusb_d680_dmb_drain_video(struct dvb_usb_device *d)
397{
398        struct usb_data_stream_properties *p = &d->props.adapter[0].fe[0].stream;
399        const int timeout = 100;
400        const int junk_len = p->u.bulk.buffersize;
401        u8        *junk;
402        int       rd_count;
403
404        /* Discard remaining data in video pipe */
405        junk = kmalloc(junk_len, GFP_KERNEL);
406        if (!junk)
407                return;
408        while (1) {
409                if (usb_bulk_msg(d->udev,
410                        usb_rcvbulkpipe(d->udev, p->endpoint),
411                        junk, junk_len, &rd_count, timeout) < 0)
412                        break;
413                if (!rd_count)
414                        break;
415        }
416        kfree(junk);
417}
418
419static int cxusb_d680_dmb_streaming_ctrl(
420                struct dvb_usb_adapter *adap, int onoff)
421{
422        if (onoff) {
423                u8 buf[2] = { 0x03, 0x00 };
424                cxusb_d680_dmb_drain_video(adap->dev);
425                return cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON,
426                        buf, sizeof(buf), NULL, 0);
427        } else {
428                int ret = cxusb_ctrl_msg(adap->dev,
429                        CMD_STREAMING_OFF, NULL, 0, NULL, 0);
430                return ret;
431        }
432}
433
434static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
435{
436        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
437        u8 ircode[4];
438        int i;
439
440        cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4);
441
442        *event = 0;
443        *state = REMOTE_NO_KEY_PRESSED;
444
445        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
446                if (rc5_custom(&keymap[i]) == ircode[2] &&
447                    rc5_data(&keymap[i]) == ircode[3]) {
448                        *event = keymap[i].keycode;
449                        *state = REMOTE_KEY_PRESSED;
450
451                        return 0;
452                }
453        }
454
455        return 0;
456}
457
458static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d, u32 *event,
459                                    int *state)
460{
461        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
462        u8 ircode[4];
463        int i;
464        struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
465                               .buf = ircode, .len = 4 };
466
467        *event = 0;
468        *state = REMOTE_NO_KEY_PRESSED;
469
470        if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1)
471                return 0;
472
473        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
474                if (rc5_custom(&keymap[i]) == ircode[1] &&
475                    rc5_data(&keymap[i]) == ircode[2]) {
476                        *event = keymap[i].keycode;
477                        *state = REMOTE_KEY_PRESSED;
478
479                        return 0;
480                }
481        }
482
483        return 0;
484}
485
486static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
487                int *state)
488{
489        struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
490        u8 ircode[2];
491        int i;
492
493        *event = 0;
494        *state = REMOTE_NO_KEY_PRESSED;
495
496        if (cxusb_ctrl_msg(d, 0x10, NULL, 0, ircode, 2) < 0)
497                return 0;
498
499        for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
500                if (rc5_custom(&keymap[i]) == ircode[0] &&
501                    rc5_data(&keymap[i]) == ircode[1]) {
502                        *event = keymap[i].keycode;
503                        *state = REMOTE_KEY_PRESSED;
504
505                        return 0;
506                }
507        }
508
509        return 0;
510}
511
512static struct rc_map_table rc_map_dvico_mce_table[] = {
513        { 0xfe02, KEY_TV },
514        { 0xfe0e, KEY_MP3 },
515        { 0xfe1a, KEY_DVD },
516        { 0xfe1e, KEY_FAVORITES },
517        { 0xfe16, KEY_SETUP },
518        { 0xfe46, KEY_POWER2 },
519        { 0xfe0a, KEY_EPG },
520        { 0xfe49, KEY_BACK },
521        { 0xfe4d, KEY_MENU },
522        { 0xfe51, KEY_UP },
523        { 0xfe5b, KEY_LEFT },
524        { 0xfe5f, KEY_RIGHT },
525        { 0xfe53, KEY_DOWN },
526        { 0xfe5e, KEY_OK },
527        { 0xfe59, KEY_INFO },
528        { 0xfe55, KEY_TAB },
529        { 0xfe0f, KEY_PREVIOUSSONG },/* Replay */
530        { 0xfe12, KEY_NEXTSONG },       /* Skip */
531        { 0xfe42, KEY_ENTER      },     /* Windows/Start */
532        { 0xfe15, KEY_VOLUMEUP },
533        { 0xfe05, KEY_VOLUMEDOWN },
534        { 0xfe11, KEY_CHANNELUP },
535        { 0xfe09, KEY_CHANNELDOWN },
536        { 0xfe52, KEY_CAMERA },
537        { 0xfe5a, KEY_TUNER },  /* Live */
538        { 0xfe19, KEY_OPEN },
539        { 0xfe0b, KEY_1 },
540        { 0xfe17, KEY_2 },
541        { 0xfe1b, KEY_3 },
542        { 0xfe07, KEY_4 },
543        { 0xfe50, KEY_5 },
544        { 0xfe54, KEY_6 },
545        { 0xfe48, KEY_7 },
546        { 0xfe4c, KEY_8 },
547        { 0xfe58, KEY_9 },
548        { 0xfe13, KEY_ANGLE },  /* Aspect */
549        { 0xfe03, KEY_0 },
550        { 0xfe1f, KEY_ZOOM },
551        { 0xfe43, KEY_REWIND },
552        { 0xfe47, KEY_PLAYPAUSE },
553        { 0xfe4f, KEY_FASTFORWARD },
554        { 0xfe57, KEY_MUTE },
555        { 0xfe0d, KEY_STOP },
556        { 0xfe01, KEY_RECORD },
557        { 0xfe4e, KEY_POWER },
558};
559
560static struct rc_map_table rc_map_dvico_portable_table[] = {
561        { 0xfc02, KEY_SETUP },       /* Profile */
562        { 0xfc43, KEY_POWER2 },
563        { 0xfc06, KEY_EPG },
564        { 0xfc5a, KEY_BACK },
565        { 0xfc05, KEY_MENU },
566        { 0xfc47, KEY_INFO },
567        { 0xfc01, KEY_TAB },
568        { 0xfc42, KEY_PREVIOUSSONG },/* Replay */
569        { 0xfc49, KEY_VOLUMEUP },
570        { 0xfc09, KEY_VOLUMEDOWN },
571        { 0xfc54, KEY_CHANNELUP },
572        { 0xfc0b, KEY_CHANNELDOWN },
573        { 0xfc16, KEY_CAMERA },
574        { 0xfc40, KEY_TUNER },  /* ATV/DTV */
575        { 0xfc45, KEY_OPEN },
576        { 0xfc19, KEY_1 },
577        { 0xfc18, KEY_2 },
578        { 0xfc1b, KEY_3 },
579        { 0xfc1a, KEY_4 },
580        { 0xfc58, KEY_5 },
581        { 0xfc59, KEY_6 },
582        { 0xfc15, KEY_7 },
583        { 0xfc14, KEY_8 },
584        { 0xfc17, KEY_9 },
585        { 0xfc44, KEY_ANGLE },  /* Aspect */
586        { 0xfc55, KEY_0 },
587        { 0xfc07, KEY_ZOOM },
588        { 0xfc0a, KEY_REWIND },
589        { 0xfc08, KEY_PLAYPAUSE },
590        { 0xfc4b, KEY_FASTFORWARD },
591        { 0xfc5b, KEY_MUTE },
592        { 0xfc04, KEY_STOP },
593        { 0xfc56, KEY_RECORD },
594        { 0xfc57, KEY_POWER },
595        { 0xfc41, KEY_UNKNOWN },    /* INPUT */
596        { 0xfc00, KEY_UNKNOWN },    /* HD */
597};
598
599static struct rc_map_table rc_map_d680_dmb_table[] = {
600        { 0x0038, KEY_UNKNOWN },        /* TV/AV */
601        { 0x080c, KEY_ZOOM },
602        { 0x0800, KEY_0 },
603        { 0x0001, KEY_1 },
604        { 0x0802, KEY_2 },
605        { 0x0003, KEY_3 },
606        { 0x0804, KEY_4 },
607        { 0x0005, KEY_5 },
608        { 0x0806, KEY_6 },
609        { 0x0007, KEY_7 },
610        { 0x0808, KEY_8 },
611        { 0x0009, KEY_9 },
612        { 0x000a, KEY_MUTE },
613        { 0x0829, KEY_BACK },
614        { 0x0012, KEY_CHANNELUP },
615        { 0x0813, KEY_CHANNELDOWN },
616        { 0x002b, KEY_VOLUMEUP },
617        { 0x082c, KEY_VOLUMEDOWN },
618        { 0x0020, KEY_UP },
619        { 0x0821, KEY_DOWN },
620        { 0x0011, KEY_LEFT },
621        { 0x0810, KEY_RIGHT },
622        { 0x000d, KEY_OK },
623        { 0x081f, KEY_RECORD },
624        { 0x0017, KEY_PLAYPAUSE },
625        { 0x0816, KEY_PLAYPAUSE },
626        { 0x000b, KEY_STOP },
627        { 0x0827, KEY_FASTFORWARD },
628        { 0x0026, KEY_REWIND },
629        { 0x081e, KEY_UNKNOWN },    /* Time Shift */
630        { 0x000e, KEY_UNKNOWN },    /* Snapshot */
631        { 0x082d, KEY_UNKNOWN },    /* Mouse Cursor */
632        { 0x000f, KEY_UNKNOWN },    /* Minimize/Maximize */
633        { 0x0814, KEY_UNKNOWN },    /* Shuffle */
634        { 0x0025, KEY_POWER },
635};
636
637static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
638{
639        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x28 };
640        static u8 reset []         = { RESET,      0x80 };
641        static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
642        static u8 agc_cfg []       = { AGC_TARGET, 0x28, 0x20 };
643        static u8 gpp_ctl_cfg []   = { GPP_CTL,    0x33 };
644        static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
645
646        mt352_write(fe, clock_config,   sizeof(clock_config));
647        udelay(200);
648        mt352_write(fe, reset,          sizeof(reset));
649        mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
650
651        mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
652        mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
653        mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
654
655        return 0;
656}
657
658static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
659{       /* used in both lgz201 and th7579 */
660        static u8 clock_config []  = { CLOCK_CTL,  0x38, 0x29 };
661        static u8 reset []         = { RESET,      0x80 };
662        static u8 adc_ctl_1_cfg [] = { ADC_CTL_1,  0x40 };
663        static u8 agc_cfg []       = { AGC_TARGET, 0x24, 0x20 };
664        static u8 gpp_ctl_cfg []   = { GPP_CTL,    0x33 };
665        static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
666
667        mt352_write(fe, clock_config,   sizeof(clock_config));
668        udelay(200);
669        mt352_write(fe, reset,          sizeof(reset));
670        mt352_write(fe, adc_ctl_1_cfg,  sizeof(adc_ctl_1_cfg));
671
672        mt352_write(fe, agc_cfg,        sizeof(agc_cfg));
673        mt352_write(fe, gpp_ctl_cfg,    sizeof(gpp_ctl_cfg));
674        mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
675        return 0;
676}
677
678static struct cx22702_config cxusb_cx22702_config = {
679        .demod_address = 0x63,
680        .output_mode = CX22702_PARALLEL_OUTPUT,
681};
682
683static struct lgdt330x_config cxusb_lgdt3303_config = {
684        .demod_address = 0x0e,
685        .demod_chip    = LGDT3303,
686};
687
688static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
689        .demod_address       = 0x0e,
690        .demod_chip          = LGDT3303,
691        .clock_polarity_flip = 2,
692};
693
694static struct mt352_config cxusb_dee1601_config = {
695        .demod_address = 0x0f,
696        .demod_init    = cxusb_dee1601_demod_init,
697};
698
699static struct zl10353_config cxusb_zl10353_dee1601_config = {
700        .demod_address = 0x0f,
701        .parallel_ts = 1,
702};
703
704static struct mt352_config cxusb_mt352_config = {
705        /* used in both lgz201 and th7579 */
706        .demod_address = 0x0f,
707        .demod_init    = cxusb_mt352_demod_init,
708};
709
710static struct zl10353_config cxusb_zl10353_xc3028_config = {
711        .demod_address = 0x0f,
712        .if2 = 45600,
713        .no_tuner = 1,
714        .parallel_ts = 1,
715};
716
717static struct zl10353_config cxusb_zl10353_xc3028_config_no_i2c_gate = {
718        .demod_address = 0x0f,
719        .if2 = 45600,
720        .no_tuner = 1,
721        .parallel_ts = 1,
722        .disable_i2c_gate_ctrl = 1,
723};
724
725static struct mt352_config cxusb_mt352_xc3028_config = {
726        .demod_address = 0x0f,
727        .if2 = 4560,
728        .no_tuner = 1,
729        .demod_init = cxusb_mt352_demod_init,
730};
731
732/* FIXME: needs tweaking */
733static struct mxl5005s_config aver_a868r_tuner = {
734        .i2c_address     = 0x63,
735        .if_freq         = 6000000UL,
736        .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
737        .agc_mode        = MXL_SINGLE_AGC,
738        .tracking_filter = MXL_TF_C,
739        .rssi_enable     = MXL_RSSI_ENABLE,
740        .cap_select      = MXL_CAP_SEL_ENABLE,
741        .div_out         = MXL_DIV_OUT_4,
742        .clock_out       = MXL_CLOCK_OUT_DISABLE,
743        .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
744        .top             = MXL5005S_TOP_25P2,
745        .mod_mode        = MXL_DIGITAL_MODE,
746        .if_mode         = MXL_ZERO_IF,
747        .AgcMasterByte   = 0x00,
748};
749
750/* FIXME: needs tweaking */
751static struct mxl5005s_config d680_dmb_tuner = {
752        .i2c_address     = 0x63,
753        .if_freq         = 36125000UL,
754        .xtal_freq       = CRYSTAL_FREQ_16000000HZ,
755        .agc_mode        = MXL_SINGLE_AGC,
756        .tracking_filter = MXL_TF_C,
757        .rssi_enable     = MXL_RSSI_ENABLE,
758        .cap_select      = MXL_CAP_SEL_ENABLE,
759        .div_out         = MXL_DIV_OUT_4,
760        .clock_out       = MXL_CLOCK_OUT_DISABLE,
761        .output_load     = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
762        .top             = MXL5005S_TOP_25P2,
763        .mod_mode        = MXL_DIGITAL_MODE,
764        .if_mode         = MXL_ZERO_IF,
765        .AgcMasterByte   = 0x00,
766};
767
768static struct max2165_config mygica_d689_max2165_cfg = {
769        .i2c_address = 0x60,
770        .osc_clk = 20
771};
772
773/* Callbacks for DVB USB */
774static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
775{
776        dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
777                   &adap->dev->i2c_adap, 0x61,
778                   TUNER_PHILIPS_FMD1216ME_MK3);
779        return 0;
780}
781
782static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
783{
784        dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
785                   NULL, DVB_PLL_THOMSON_DTT7579);
786        return 0;
787}
788
789static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
790{
791        dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, NULL, DVB_PLL_LG_Z201);
792        return 0;
793}
794
795static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
796{
797        dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
798                   NULL, DVB_PLL_THOMSON_DTT7579);
799        return 0;
800}
801
802static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
803{
804        dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
805                   &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
806        return 0;
807}
808
809static int dvico_bluebird_xc2028_callback(void *ptr, int component,
810                                          int command, int arg)
811{
812        struct dvb_usb_adapter *adap = ptr;
813        struct dvb_usb_device *d = adap->dev;
814
815        switch (command) {
816        case XC2028_TUNER_RESET:
817                deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
818                cxusb_bluebird_gpio_pulse(d, 0x01, 1);
819                break;
820        case XC2028_RESET_CLK:
821                deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
822                break;
823        default:
824                deb_info("%s: unknown command %d, arg %d\n", __func__,
825                         command, arg);
826                return -EINVAL;
827        }
828
829        return 0;
830}
831
832static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
833{
834        struct dvb_frontend      *fe;
835        struct xc2028_config      cfg = {
836                .i2c_adap  = &adap->dev->i2c_adap,
837                .i2c_addr  = 0x61,
838        };
839        static struct xc2028_ctrl ctl = {
840                .fname       = XC2028_DEFAULT_FIRMWARE,
841                .max_len     = 64,
842                .demod       = XC3028_FE_ZARLINK456,
843        };
844
845        /* FIXME: generalize & move to common area */
846        adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback;
847
848        fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg);
849        if (fe == NULL || fe->ops.tuner_ops.set_config == NULL)
850                return -EIO;
851
852        fe->ops.tuner_ops.set_config(fe, &ctl);
853
854        return 0;
855}
856
857static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
858{
859        dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
860                   &adap->dev->i2c_adap, &aver_a868r_tuner);
861        return 0;
862}
863
864static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
865{
866        struct dvb_frontend *fe;
867        fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
868                        &adap->dev->i2c_adap, &d680_dmb_tuner);
869        return (fe == NULL) ? -EIO : 0;
870}
871
872static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap)
873{
874        struct dvb_frontend *fe;
875        fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe,
876                        &adap->dev->i2c_adap, &mygica_d689_max2165_cfg);
877        return (fe == NULL) ? -EIO : 0;
878}
879
880static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
881{
882        u8 b;
883        if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
884                err("set interface failed");
885
886        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
887
888        adap->fe_adap[0].fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
889                                         &adap->dev->i2c_adap);
890        if ((adap->fe_adap[0].fe) != NULL)
891                return 0;
892
893        return -EIO;
894}
895
896static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
897{
898        if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
899                err("set interface failed");
900
901        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
902
903        adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach,
904                                         &cxusb_lgdt3303_config,
905                                         &adap->dev->i2c_adap);
906        if ((adap->fe_adap[0].fe) != NULL)
907                return 0;
908
909        return -EIO;
910}
911
912static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
913{
914        adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
915                              &adap->dev->i2c_adap);
916        if (adap->fe_adap[0].fe != NULL)
917                return 0;
918
919        return -EIO;
920}
921
922static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
923{
924        /* used in both lgz201 and th7579 */
925        if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
926                err("set interface failed");
927
928        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
929
930        adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
931                                         &adap->dev->i2c_adap);
932        if ((adap->fe_adap[0].fe) != NULL)
933                return 0;
934
935        return -EIO;
936}
937
938static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
939{
940        if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
941                err("set interface failed");
942
943        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
944
945        adap->fe_adap[0].fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
946                                         &adap->dev->i2c_adap);
947        if ((adap->fe_adap[0].fe) != NULL)
948                return 0;
949
950        adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
951                                         &cxusb_zl10353_dee1601_config,
952                                         &adap->dev->i2c_adap);
953        if ((adap->fe_adap[0].fe) != NULL)
954                return 0;
955
956        return -EIO;
957}
958
959static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
960{
961        u8 ircode[4];
962        int i;
963        struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
964                               .buf = ircode, .len = 4 };
965
966        if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
967                err("set interface failed");
968
969        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
970
971        /* reset the tuner and demodulator */
972        cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
973        cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
974        cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
975
976        adap->fe_adap[0].fe =
977                dvb_attach(zl10353_attach,
978                           &cxusb_zl10353_xc3028_config_no_i2c_gate,
979                           &adap->dev->i2c_adap);
980        if ((adap->fe_adap[0].fe) == NULL)
981                return -EIO;
982
983        /* try to determine if there is no IR decoder on the I2C bus */
984        for (i = 0; adap->dev->props.rc.legacy.rc_map_table != NULL && i < 5; i++) {
985                msleep(20);
986                if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
987                        goto no_IR;
988                if (ircode[0] == 0 && ircode[1] == 0)
989                        continue;
990                if (ircode[2] + ircode[3] != 0xff) {
991no_IR:
992                        adap->dev->props.rc.legacy.rc_map_table = NULL;
993                        info("No IR receiver detected on this device.");
994                        break;
995                }
996        }
997
998        return 0;
999}
1000
1001static struct dibx000_agc_config dib7070_agc_config = {
1002        .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
1003
1004        /*
1005         * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
1006         * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
1007         * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
1008         */
1009        .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
1010                 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
1011        .inv_gain = 600,
1012        .time_stabiliz = 10,
1013        .alpha_level = 0,
1014        .thlock = 118,
1015        .wbd_inv = 0,
1016        .wbd_ref = 3530,
1017        .wbd_sel = 1,
1018        .wbd_alpha = 5,
1019        .agc1_max = 65535,
1020        .agc1_min = 0,
1021        .agc2_max = 65535,
1022        .agc2_min = 0,
1023        .agc1_pt1 = 0,
1024        .agc1_pt2 = 40,
1025        .agc1_pt3 = 183,
1026        .agc1_slope1 = 206,
1027        .agc1_slope2 = 255,
1028        .agc2_pt1 = 72,
1029        .agc2_pt2 = 152,
1030        .agc2_slope1 = 88,
1031        .agc2_slope2 = 90,
1032        .alpha_mant = 17,
1033        .alpha_exp = 27,
1034        .beta_mant = 23,
1035        .beta_exp = 51,
1036        .perform_agc_softsplit = 0,
1037};
1038
1039static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
1040        .internal = 60000,
1041        .sampling = 15000,
1042        .pll_prediv = 1,
1043        .pll_ratio = 20,
1044        .pll_range = 3,
1045        .pll_reset = 1,
1046        .pll_bypass = 0,
1047        .enable_refdiv = 0,
1048        .bypclk_div = 0,
1049        .IO_CLK_en_core = 1,
1050        .ADClkSrc = 1,
1051        .modulo = 2,
1052        /* refsel, sel, freq_15k */
1053        .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
1054        .ifreq = (0 << 25) | 0,
1055        .timf = 20452225,
1056        .xtal_hz = 12000000,
1057};
1058
1059static struct dib7000p_config cxusb_dualdig4_rev2_config = {
1060        .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
1061        .output_mpeg2_in_188_bytes = 1,
1062
1063        .agc_config_count = 1,
1064        .agc = &dib7070_agc_config,
1065        .bw  = &dib7070_bw_config_12_mhz,
1066        .tuner_is_baseband = 1,
1067        .spur_protect = 1,
1068
1069        .gpio_dir = 0xfcef,
1070        .gpio_val = 0x0110,
1071
1072        .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1073
1074        .hostbus_diversity = 1,
1075};
1076
1077struct dib0700_adapter_state {
1078        int (*set_param_save)(struct dvb_frontend *);
1079        struct dib7000p_ops dib7000p_ops;
1080};
1081
1082static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
1083{
1084        struct dib0700_adapter_state *state = adap->priv;
1085
1086        if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1087                err("set interface failed");
1088
1089        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1090
1091        cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1092
1093        if (!dvb_attach(dib7000p_attach, &state->dib7000p_ops))
1094                return -ENODEV;
1095
1096        if (state->dib7000p_ops.i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
1097                                       &cxusb_dualdig4_rev2_config) < 0) {
1098                printk(KERN_WARNING "Unable to enumerate dib7000p\n");
1099                return -ENODEV;
1100        }
1101
1102        adap->fe_adap[0].fe = state->dib7000p_ops.init(&adap->dev->i2c_adap, 0x80,
1103                                              &cxusb_dualdig4_rev2_config);
1104        if (adap->fe_adap[0].fe == NULL)
1105                return -EIO;
1106
1107        return 0;
1108}
1109
1110static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1111{
1112        struct dvb_usb_adapter *adap = fe->dvb->priv;
1113        struct dib0700_adapter_state *state = adap->priv;
1114
1115        return state->dib7000p_ops.set_gpio(fe, 8, 0, !onoff);
1116}
1117
1118static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1119{
1120        return 0;
1121}
1122
1123static struct dib0070_config dib7070p_dib0070_config = {
1124        .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1125        .reset = dib7070_tuner_reset,
1126        .sleep = dib7070_tuner_sleep,
1127        .clock_khz = 12000,
1128};
1129
1130static int dib7070_set_param_override(struct dvb_frontend *fe)
1131{
1132        struct dtv_frontend_properties *p = &fe->dtv_property_cache;
1133        struct dvb_usb_adapter *adap = fe->dvb->priv;
1134        struct dib0700_adapter_state *state = adap->priv;
1135
1136        u16 offset;
1137        u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
1138        switch (band) {
1139        case BAND_VHF: offset = 950; break;
1140        default:
1141        case BAND_UHF: offset = 550; break;
1142        }
1143
1144        state->dib7000p_ops.set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1145
1146        return state->set_param_save(fe);
1147}
1148
1149static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1150{
1151        struct dib0700_adapter_state *st = adap->priv;
1152        struct i2c_adapter *tun_i2c;
1153
1154        /*
1155         * No need to call dvb7000p_attach here, as it was called
1156         * already, as frontend_attach method is called first, and
1157         * tuner_attach is only called on sucess.
1158         */
1159        tun_i2c = st->dib7000p_ops.get_i2c_master(adap->fe_adap[0].fe,
1160                                        DIBX000_I2C_INTERFACE_TUNER, 1);
1161
1162        if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
1163            &dib7070p_dib0070_config) == NULL)
1164                return -ENODEV;
1165
1166        st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1167        adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1168        return 0;
1169}
1170
1171static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1172{
1173        if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1174                err("set interface failed");
1175
1176        cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1177
1178        /* reset the tuner and demodulator */
1179        cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1180        cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1181        cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1182
1183        adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
1184                                         &cxusb_zl10353_xc3028_config,
1185                                         &adap->dev->i2c_adap);
1186        if ((adap->fe_adap[0].fe) != NULL)
1187                return 0;
1188
1189        adap->fe_adap[0].fe = dvb_attach(mt352_attach,
1190                                         &cxusb_mt352_xc3028_config,
1191                                         &adap->dev->i2c_adap);
1192        if ((adap->fe_adap[0].fe) != NULL)
1193                return 0;
1194
1195        return -EIO;
1196}
1197
1198static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1199        .prod = LGS8GXX_PROD_LGS8GL5,
1200        .demod_address = 0x19,
1201        .serial_ts = 0,
1202        .ts_clk_pol = 0,
1203        .ts_clk_gated = 1,
1204        .if_clk_freq = 30400, /* 30.4 MHz */
1205        .if_freq = 5725, /* 5.725 MHz */
1206        .if_neg_center = 0,
1207        .ext_adc = 0,
1208        .adc_signed = 0,
1209        .if_neg_edge = 0,
1210};
1211
1212static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1213{
1214        struct dvb_usb_device *d = adap->dev;
1215        int n;
1216
1217        /* Select required USB configuration */
1218        if (usb_set_interface(d->udev, 0, 0) < 0)
1219                err("set interface failed");
1220
1221        /* Unblock all USB pipes */
1222        usb_clear_halt(d->udev,
1223                usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1224        usb_clear_halt(d->udev,
1225                usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1226        usb_clear_halt(d->udev,
1227                usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1228
1229        /* Drain USB pipes to avoid hang after reboot */
1230        for (n = 0;  n < 5;  n++) {
1231                cxusb_d680_dmb_drain_message(d);
1232                cxusb_d680_dmb_drain_video(d);
1233                msleep(200);
1234        }
1235
1236        /* Reset the tuner */
1237        if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1238                err("clear tuner gpio failed");
1239                return -EIO;
1240        }
1241        msleep(100);
1242        if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1243                err("set tuner gpio failed");
1244                return -EIO;
1245        }
1246        msleep(100);
1247
1248        /* Attach frontend */
1249        adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap);
1250        if (adap->fe_adap[0].fe == NULL)
1251                return -EIO;
1252
1253        return 0;
1254}
1255
1256static struct atbm8830_config mygica_d689_atbm8830_cfg = {
1257        .prod = ATBM8830_PROD_8830,
1258        .demod_address = 0x40,
1259        .serial_ts = 0,
1260        .ts_sampling_edge = 1,
1261        .ts_clk_gated = 0,
1262        .osc_clk_freq = 30400, /* in kHz */
1263        .if_freq = 0, /* zero IF */
1264        .zif_swap_iq = 1,
1265        .agc_min = 0x2E,
1266        .agc_max = 0x90,
1267        .agc_hold_loop = 0,
1268};
1269
1270static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
1271{
1272        struct dvb_usb_device *d = adap->dev;
1273
1274        /* Select required USB configuration */
1275        if (usb_set_interface(d->udev, 0, 0) < 0)
1276                err("set interface failed");
1277
1278        /* Unblock all USB pipes */
1279        usb_clear_halt(d->udev,
1280                usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1281        usb_clear_halt(d->udev,
1282                usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1283        usb_clear_halt(d->udev,
1284                usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1285
1286
1287        /* Reset the tuner */
1288        if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1289                err("clear tuner gpio failed");
1290                return -EIO;
1291        }
1292        msleep(100);
1293        if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1294                err("set tuner gpio failed");
1295                return -EIO;
1296        }
1297        msleep(100);
1298
1299        /* Attach frontend */
1300        adap->fe_adap[0].fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg,
1301                &d->i2c_adap);
1302        if (adap->fe_adap[0].fe == NULL)
1303                return -EIO;
1304
1305        return 0;
1306}
1307
1308static int cxusb_mygica_t230_frontend_attach(struct dvb_usb_adapter *adap)
1309{
1310        struct dvb_usb_device *d = adap->dev;
1311        struct cxusb_state *st = d->priv;
1312        struct i2c_adapter *adapter;
1313        struct i2c_client *client_demod;
1314        struct i2c_client *client_tuner;
1315        struct i2c_board_info info;
1316        struct si2168_config si2168_config;
1317        struct si2157_config si2157_config;
1318
1319        /* Select required USB configuration */
1320        if (usb_set_interface(d->udev, 0, 0) < 0)
1321                err("set interface failed");
1322
1323        /* Unblock all USB pipes */
1324        usb_clear_halt(d->udev,
1325                usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1326        usb_clear_halt(d->udev,
1327                usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1328        usb_clear_halt(d->udev,
1329                usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
1330
1331        /* attach frontend */
1332        si2168_config.i2c_adapter = &adapter;
1333        si2168_config.fe = &adap->fe_adap[0].fe;
1334        si2168_config.ts_mode = SI2168_TS_PARALLEL;
1335        si2168_config.ts_clock_inv = 1;
1336        memset(&info, 0, sizeof(struct i2c_board_info));
1337        strlcpy(info.type, "si2168", I2C_NAME_SIZE);
1338        info.addr = 0x64;
1339        info.platform_data = &si2168_config;
1340        request_module(info.type);
1341        client_demod = i2c_new_device(&d->i2c_adap, &info);
1342        if (client_demod == NULL || client_demod->dev.driver == NULL)
1343                return -ENODEV;
1344
1345        if (!try_module_get(client_demod->dev.driver->owner)) {
1346                i2c_unregister_device(client_demod);
1347                return -ENODEV;
1348        }
1349
1350        st->i2c_client_demod = client_demod;
1351
1352        /* attach tuner */
1353        memset(&si2157_config, 0, sizeof(si2157_config));
1354        si2157_config.fe = adap->fe_adap[0].fe;
1355        si2157_config.if_port = 1;
1356        memset(&info, 0, sizeof(struct i2c_board_info));
1357        strlcpy(info.type, "si2157", I2C_NAME_SIZE);
1358        info.addr = 0x60;
1359        info.platform_data = &si2157_config;
1360        request_module(info.type);
1361        client_tuner = i2c_new_device(adapter, &info);
1362        if (client_tuner == NULL || client_tuner->dev.driver == NULL) {
1363                module_put(client_demod->dev.driver->owner);
1364                i2c_unregister_device(client_demod);
1365                return -ENODEV;
1366        }
1367        if (!try_module_get(client_tuner->dev.driver->owner)) {
1368                i2c_unregister_device(client_tuner);
1369                module_put(client_demod->dev.driver->owner);
1370                i2c_unregister_device(client_demod);
1371                return -ENODEV;
1372        }
1373
1374        st->i2c_client_tuner = client_tuner;
1375
1376        return 0;
1377}
1378
1379/*
1380 * DViCO has shipped two devices with the same USB ID, but only one of them
1381 * needs a firmware download.  Check the device class details to see if they
1382 * have non-default values to decide whether the device is actually cold or
1383 * not, and forget a match if it turns out we selected the wrong device.
1384 */
1385static int bluebird_fx2_identify_state(struct usb_device *udev,
1386                                       struct dvb_usb_device_properties *props,
1387                                       struct dvb_usb_device_description **desc,
1388                                       int *cold)
1389{
1390        int wascold = *cold;
1391
1392        *cold = udev->descriptor.bDeviceClass == 0xff &&
1393                udev->descriptor.bDeviceSubClass == 0xff &&
1394                udev->descriptor.bDeviceProtocol == 0xff;
1395
1396        if (*cold && !wascold)
1397                *desc = NULL;
1398
1399        return 0;
1400}
1401
1402/*
1403 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1404 * firmware file before download.
1405 */
1406
1407static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
1408static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1409                                                  const struct firmware *fw)
1410{
1411        int pos;
1412
1413        for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1414                int idoff = dvico_firmware_id_offsets[pos];
1415
1416                if (fw->size < idoff + 4)
1417                        continue;
1418
1419                if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1420                    fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
1421                        struct firmware new_fw;
1422                        u8 *new_fw_data = vmalloc(fw->size);
1423                        int ret;
1424
1425                        if (!new_fw_data)
1426                                return -ENOMEM;
1427
1428                        memcpy(new_fw_data, fw->data, fw->size);
1429                        new_fw.size = fw->size;
1430                        new_fw.data = new_fw_data;
1431
1432                        new_fw_data[idoff + 2] =
1433                                le16_to_cpu(udev->descriptor.idProduct) + 1;
1434                        new_fw_data[idoff + 3] =
1435                                le16_to_cpu(udev->descriptor.idProduct) >> 8;
1436
1437                        ret = usb_cypress_load_firmware(udev, &new_fw,
1438                                                        CYPRESS_FX2);
1439                        vfree(new_fw_data);
1440                        return ret;
1441                }
1442        }
1443
1444        return -EINVAL;
1445}
1446
1447/* DVB USB Driver stuff */
1448static struct dvb_usb_device_properties cxusb_medion_properties;
1449static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1450static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1451static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1452static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
1453static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
1454static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
1455static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
1456static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
1457static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
1458static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
1459static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
1460static struct dvb_usb_device_properties cxusb_mygica_t230_properties;
1461
1462static int cxusb_probe(struct usb_interface *intf,
1463                       const struct usb_device_id *id)
1464{
1465        if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
1466                                     THIS_MODULE, NULL, adapter_nr) ||
1467            0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
1468                                     THIS_MODULE, NULL, adapter_nr) ||
1469            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
1470                                     THIS_MODULE, NULL, adapter_nr) ||
1471            0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
1472                                     THIS_MODULE, NULL, adapter_nr) ||
1473            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
1474                                     THIS_MODULE, NULL, adapter_nr) ||
1475            0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
1476                                     THIS_MODULE, NULL, adapter_nr) ||
1477            0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
1478                                     THIS_MODULE, NULL, adapter_nr) ||
1479            0 == dvb_usb_device_init(intf,
1480                                &cxusb_bluebird_nano2_needsfirmware_properties,
1481                                     THIS_MODULE, NULL, adapter_nr) ||
1482            0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1483                                     THIS_MODULE, NULL, adapter_nr) ||
1484            0 == dvb_usb_device_init(intf,
1485                                     &cxusb_bluebird_dualdig4_rev2_properties,
1486                                     THIS_MODULE, NULL, adapter_nr) ||
1487            0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1488                                     THIS_MODULE, NULL, adapter_nr) ||
1489            0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
1490                                     THIS_MODULE, NULL, adapter_nr) ||
1491            0 == dvb_usb_device_init(intf, &cxusb_mygica_t230_properties,
1492                                     THIS_MODULE, NULL, adapter_nr) ||
1493            0)
1494                return 0;
1495
1496        return -EINVAL;
1497}
1498
1499static void cxusb_disconnect(struct usb_interface *intf)
1500{
1501        struct dvb_usb_device *d = usb_get_intfdata(intf);
1502        struct cxusb_state *st = d->priv;
1503        struct i2c_client *client;
1504
1505        /* remove I2C client for tuner */
1506        client = st->i2c_client_tuner;
1507        if (client) {
1508                module_put(client->dev.driver->owner);
1509                i2c_unregister_device(client);
1510        }
1511
1512        /* remove I2C client for demodulator */
1513        client = st->i2c_client_demod;
1514        if (client) {
1515                module_put(client->dev.driver->owner);
1516                i2c_unregister_device(client);
1517        }
1518
1519        dvb_usb_device_exit(intf);
1520}
1521
1522enum cxusb_table_index {
1523        MEDION_MD95700,
1524        DVICO_BLUEBIRD_LG064F_COLD,
1525        DVICO_BLUEBIRD_LG064F_WARM,
1526        DVICO_BLUEBIRD_DUAL_1_COLD,
1527        DVICO_BLUEBIRD_DUAL_1_WARM,
1528        DVICO_BLUEBIRD_LGZ201_COLD,
1529        DVICO_BLUEBIRD_LGZ201_WARM,
1530        DVICO_BLUEBIRD_TH7579_COLD,
1531        DVICO_BLUEBIRD_TH7579_WARM,
1532        DIGITALNOW_BLUEBIRD_DUAL_1_COLD,
1533        DIGITALNOW_BLUEBIRD_DUAL_1_WARM,
1534        DVICO_BLUEBIRD_DUAL_2_COLD,
1535        DVICO_BLUEBIRD_DUAL_2_WARM,
1536        DVICO_BLUEBIRD_DUAL_4,
1537        DVICO_BLUEBIRD_DVB_T_NANO_2,
1538        DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM,
1539        AVERMEDIA_VOLAR_A868R,
1540        DVICO_BLUEBIRD_DUAL_4_REV_2,
1541        CONEXANT_D680_DMB,
1542        MYGICA_D689,
1543        MYGICA_T230,
1544        NR__cxusb_table_index
1545};
1546
1547static struct usb_device_id cxusb_table[NR__cxusb_table_index + 1] = {
1548        [MEDION_MD95700] = {
1549                USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700)
1550        },
1551        [DVICO_BLUEBIRD_LG064F_COLD] = {
1552                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD)
1553        },
1554        [DVICO_BLUEBIRD_LG064F_WARM] = {
1555                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM)
1556        },
1557        [DVICO_BLUEBIRD_DUAL_1_COLD] = {
1558                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD)
1559        },
1560        [DVICO_BLUEBIRD_DUAL_1_WARM] = {
1561                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM)
1562        },
1563        [DVICO_BLUEBIRD_LGZ201_COLD] = {
1564                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD)
1565        },
1566        [DVICO_BLUEBIRD_LGZ201_WARM] = {
1567                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM)
1568        },
1569        [DVICO_BLUEBIRD_TH7579_COLD] = {
1570                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD)
1571        },
1572        [DVICO_BLUEBIRD_TH7579_WARM] = {
1573                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM)
1574        },
1575        [DIGITALNOW_BLUEBIRD_DUAL_1_COLD] = {
1576                USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD)
1577        },
1578        [DIGITALNOW_BLUEBIRD_DUAL_1_WARM] = {
1579                USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM)
1580        },
1581        [DVICO_BLUEBIRD_DUAL_2_COLD] = {
1582                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD)
1583        },
1584        [DVICO_BLUEBIRD_DUAL_2_WARM] = {
1585                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM)
1586        },
1587        [DVICO_BLUEBIRD_DUAL_4] = {
1588                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4)
1589        },
1590        [DVICO_BLUEBIRD_DVB_T_NANO_2] = {
1591                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2)
1592        },
1593        [DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM] = {
1594                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM)
1595        },
1596        [AVERMEDIA_VOLAR_A868R] = {
1597                USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R)
1598        },
1599        [DVICO_BLUEBIRD_DUAL_4_REV_2] = {
1600                USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2)
1601        },
1602        [CONEXANT_D680_DMB] = {
1603                USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB)
1604        },
1605        [MYGICA_D689] = {
1606                USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689)
1607        },
1608        [MYGICA_T230] = {
1609                USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_T230)
1610        },
1611        {}              /* Terminating entry */
1612};
1613MODULE_DEVICE_TABLE (usb, cxusb_table);
1614
1615static struct dvb_usb_device_properties cxusb_medion_properties = {
1616        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1617
1618        .usb_ctrl = CYPRESS_FX2,
1619
1620        .size_of_priv     = sizeof(struct cxusb_state),
1621
1622        .num_adapters = 1,
1623        .adapter = {
1624                {
1625                .num_frontends = 1,
1626                .fe = {{
1627                        .streaming_ctrl   = cxusb_streaming_ctrl,
1628                        .frontend_attach  = cxusb_cx22702_frontend_attach,
1629                        .tuner_attach     = cxusb_fmd1216me_tuner_attach,
1630                        /* parameter for the MPEG2-data transfer */
1631                                        .stream = {
1632                                                .type = USB_BULK,
1633                                .count = 5,
1634                                .endpoint = 0x02,
1635                                .u = {
1636                                        .bulk = {
1637                                                .buffersize = 8192,
1638                                        }
1639                                }
1640                        },
1641                }},
1642                },
1643        },
1644        .power_ctrl       = cxusb_power_ctrl,
1645
1646        .i2c_algo         = &cxusb_i2c_algo,
1647
1648        .generic_bulk_ctrl_endpoint = 0x01,
1649
1650        .num_device_descs = 1,
1651        .devices = {
1652                {   "Medion MD95700 (MDUSBTV-HYBRID)",
1653                        { NULL },
1654                        { &cxusb_table[MEDION_MD95700], NULL },
1655                },
1656        }
1657};
1658
1659static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
1660        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1661
1662        .usb_ctrl          = DEVICE_SPECIFIC,
1663        .firmware          = "dvb-usb-bluebird-01.fw",
1664        .download_firmware = bluebird_patch_dvico_firmware_download,
1665        /* use usb alt setting 0 for EP4 transfer (dvb-t),
1666           use usb alt setting 7 for EP2 transfer (atsc) */
1667
1668        .size_of_priv     = sizeof(struct cxusb_state),
1669
1670        .num_adapters = 1,
1671        .adapter = {
1672                {
1673                .num_frontends = 1,
1674                .fe = {{
1675                        .streaming_ctrl   = cxusb_streaming_ctrl,
1676                        .frontend_attach  = cxusb_lgdt3303_frontend_attach,
1677                        .tuner_attach     = cxusb_lgh064f_tuner_attach,
1678
1679                        /* parameter for the MPEG2-data transfer */
1680                                        .stream = {
1681                                                .type = USB_BULK,
1682                                .count = 5,
1683                                .endpoint = 0x02,
1684                                .u = {
1685                                        .bulk = {
1686                                                .buffersize = 8192,
1687                                        }
1688                                }
1689                        },
1690                }},
1691                },
1692        },
1693
1694        .power_ctrl       = cxusb_bluebird_power_ctrl,
1695
1696        .i2c_algo         = &cxusb_i2c_algo,
1697
1698        .rc.legacy = {
1699                .rc_interval      = 100,
1700                .rc_map_table     = rc_map_dvico_portable_table,
1701                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
1702                .rc_query         = cxusb_rc_query,
1703        },
1704
1705        .generic_bulk_ctrl_endpoint = 0x01,
1706
1707        .num_device_descs = 1,
1708        .devices = {
1709                {   "DViCO FusionHDTV5 USB Gold",
1710                        { &cxusb_table[DVICO_BLUEBIRD_LG064F_COLD], NULL },
1711                        { &cxusb_table[DVICO_BLUEBIRD_LG064F_WARM], NULL },
1712                },
1713        }
1714};
1715
1716static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
1717        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1718
1719        .usb_ctrl          = DEVICE_SPECIFIC,
1720        .firmware          = "dvb-usb-bluebird-01.fw",
1721        .download_firmware = bluebird_patch_dvico_firmware_download,
1722        /* use usb alt setting 0 for EP4 transfer (dvb-t),
1723           use usb alt setting 7 for EP2 transfer (atsc) */
1724
1725        .size_of_priv     = sizeof(struct cxusb_state),
1726
1727        .num_adapters = 1,
1728        .adapter = {
1729                {
1730                .num_frontends = 1,
1731                .fe = {{
1732                        .streaming_ctrl   = cxusb_streaming_ctrl,
1733                        .frontend_attach  = cxusb_dee1601_frontend_attach,
1734                        .tuner_attach     = cxusb_dee1601_tuner_attach,
1735                        /* parameter for the MPEG2-data transfer */
1736                        .stream = {
1737                                .type = USB_BULK,
1738                                .count = 5,
1739                                .endpoint = 0x04,
1740                                .u = {
1741                                        .bulk = {
1742                                                .buffersize = 8192,
1743                                        }
1744                                }
1745                        },
1746                }},
1747                },
1748        },
1749
1750        .power_ctrl       = cxusb_bluebird_power_ctrl,
1751
1752        .i2c_algo         = &cxusb_i2c_algo,
1753
1754        .rc.legacy = {
1755                .rc_interval      = 150,
1756                .rc_map_table     = rc_map_dvico_mce_table,
1757                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_mce_table),
1758                .rc_query         = cxusb_rc_query,
1759        },
1760
1761        .generic_bulk_ctrl_endpoint = 0x01,
1762
1763        .num_device_descs = 3,
1764        .devices = {
1765                {   "DViCO FusionHDTV DVB-T Dual USB",
1766                        { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_COLD], NULL },
1767                        { &cxusb_table[DVICO_BLUEBIRD_DUAL_1_WARM], NULL },
1768                },
1769                {   "DigitalNow DVB-T Dual USB",
1770                        { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_COLD],  NULL },
1771                        { &cxusb_table[DIGITALNOW_BLUEBIRD_DUAL_1_WARM], NULL },
1772                },
1773                {   "DViCO FusionHDTV DVB-T Dual Digital 2",
1774                        { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_COLD], NULL },
1775                        { &cxusb_table[DVICO_BLUEBIRD_DUAL_2_WARM], NULL },
1776                },
1777        }
1778};
1779
1780static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
1781        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1782
1783        .usb_ctrl          = DEVICE_SPECIFIC,
1784        .firmware          = "dvb-usb-bluebird-01.fw",
1785        .download_firmware = bluebird_patch_dvico_firmware_download,
1786        /* use usb alt setting 0 for EP4 transfer (dvb-t),
1787           use usb alt setting 7 for EP2 transfer (atsc) */
1788
1789        .size_of_priv     = sizeof(struct cxusb_state),
1790
1791        .num_adapters = 2,
1792        .adapter = {
1793                {
1794                .num_frontends = 1,
1795                .fe = {{
1796                        .streaming_ctrl   = cxusb_streaming_ctrl,
1797                        .frontend_attach  = cxusb_mt352_frontend_attach,
1798                        .tuner_attach     = cxusb_lgz201_tuner_attach,
1799
1800                        /* parameter for the MPEG2-data transfer */
1801                        .stream = {
1802                                .type = USB_BULK,
1803                                .count = 5,
1804                                .endpoint = 0x04,
1805                                .u = {
1806                                        .bulk = {
1807                                                .buffersize = 8192,
1808                                        }
1809                                }
1810                        },
1811                }},
1812                },
1813        },
1814        .power_ctrl       = cxusb_bluebird_power_ctrl,
1815
1816        .i2c_algo         = &cxusb_i2c_algo,
1817
1818        .rc.legacy = {
1819                .rc_interval      = 100,
1820                .rc_map_table     = rc_map_dvico_portable_table,
1821                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
1822                .rc_query         = cxusb_rc_query,
1823        },
1824
1825        .generic_bulk_ctrl_endpoint = 0x01,
1826        .num_device_descs = 1,
1827        .devices = {
1828                {   "DViCO FusionHDTV DVB-T USB (LGZ201)",
1829                        { &cxusb_table[DVICO_BLUEBIRD_LGZ201_COLD], NULL },
1830                        { &cxusb_table[DVICO_BLUEBIRD_LGZ201_WARM], NULL },
1831                },
1832        }
1833};
1834
1835static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
1836        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1837
1838        .usb_ctrl          = DEVICE_SPECIFIC,
1839        .firmware          = "dvb-usb-bluebird-01.fw",
1840        .download_firmware = bluebird_patch_dvico_firmware_download,
1841        /* use usb alt setting 0 for EP4 transfer (dvb-t),
1842           use usb alt setting 7 for EP2 transfer (atsc) */
1843
1844        .size_of_priv     = sizeof(struct cxusb_state),
1845
1846        .num_adapters = 1,
1847        .adapter = {
1848                {
1849                .num_frontends = 1,
1850                .fe = {{
1851                        .streaming_ctrl   = cxusb_streaming_ctrl,
1852                        .frontend_attach  = cxusb_mt352_frontend_attach,
1853                        .tuner_attach     = cxusb_dtt7579_tuner_attach,
1854
1855                        /* parameter for the MPEG2-data transfer */
1856                        .stream = {
1857                                .type = USB_BULK,
1858                                .count = 5,
1859                                .endpoint = 0x04,
1860                                .u = {
1861                                        .bulk = {
1862                                                .buffersize = 8192,
1863                                        }
1864                                }
1865                        },
1866                }},
1867                },
1868        },
1869        .power_ctrl       = cxusb_bluebird_power_ctrl,
1870
1871        .i2c_algo         = &cxusb_i2c_algo,
1872
1873        .rc.legacy = {
1874                .rc_interval      = 100,
1875                .rc_map_table     = rc_map_dvico_portable_table,
1876                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
1877                .rc_query         = cxusb_rc_query,
1878        },
1879
1880        .generic_bulk_ctrl_endpoint = 0x01,
1881
1882        .num_device_descs = 1,
1883        .devices = {
1884                {   "DViCO FusionHDTV DVB-T USB (TH7579)",
1885                        { &cxusb_table[DVICO_BLUEBIRD_TH7579_COLD], NULL },
1886                        { &cxusb_table[DVICO_BLUEBIRD_TH7579_WARM], NULL },
1887                },
1888        }
1889};
1890
1891static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1892        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1893
1894        .usb_ctrl         = CYPRESS_FX2,
1895
1896        .size_of_priv     = sizeof(struct cxusb_state),
1897
1898        .num_adapters = 1,
1899        .adapter = {
1900                {
1901                .num_frontends = 1,
1902                .fe = {{
1903                        .streaming_ctrl   = cxusb_streaming_ctrl,
1904                        .frontend_attach  = cxusb_dualdig4_frontend_attach,
1905                        .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
1906                        /* parameter for the MPEG2-data transfer */
1907                        .stream = {
1908                                .type = USB_BULK,
1909                                .count = 5,
1910                                .endpoint = 0x02,
1911                                .u = {
1912                                        .bulk = {
1913                                                .buffersize = 8192,
1914                                        }
1915                                }
1916                        },
1917                }},
1918                },
1919        },
1920
1921        .power_ctrl       = cxusb_power_ctrl,
1922
1923        .i2c_algo         = &cxusb_i2c_algo,
1924
1925        .generic_bulk_ctrl_endpoint = 0x01,
1926
1927        .rc.legacy = {
1928                .rc_interval      = 100,
1929                .rc_map_table     = rc_map_dvico_mce_table,
1930                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_mce_table),
1931                .rc_query         = cxusb_bluebird2_rc_query,
1932        },
1933
1934        .num_device_descs = 1,
1935        .devices = {
1936                {   "DViCO FusionHDTV DVB-T Dual Digital 4",
1937                        { NULL },
1938                        { &cxusb_table[DVICO_BLUEBIRD_DUAL_4], NULL },
1939                },
1940        }
1941};
1942
1943static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1944        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1945
1946        .usb_ctrl         = CYPRESS_FX2,
1947        .identify_state   = bluebird_fx2_identify_state,
1948
1949        .size_of_priv     = sizeof(struct cxusb_state),
1950
1951        .num_adapters = 1,
1952        .adapter = {
1953                {
1954                .num_frontends = 1,
1955                .fe = {{
1956                        .streaming_ctrl   = cxusb_streaming_ctrl,
1957                        .frontend_attach  = cxusb_nano2_frontend_attach,
1958                        .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
1959                        /* parameter for the MPEG2-data transfer */
1960                        .stream = {
1961                                .type = USB_BULK,
1962                                .count = 5,
1963                                .endpoint = 0x02,
1964                                .u = {
1965                                        .bulk = {
1966                                                .buffersize = 8192,
1967                                        }
1968                                }
1969                        },
1970                }},
1971                },
1972        },
1973
1974        .power_ctrl       = cxusb_nano2_power_ctrl,
1975
1976        .i2c_algo         = &cxusb_i2c_algo,
1977
1978        .generic_bulk_ctrl_endpoint = 0x01,
1979
1980        .rc.legacy = {
1981                .rc_interval      = 100,
1982                .rc_map_table     = rc_map_dvico_portable_table,
1983                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
1984                .rc_query         = cxusb_bluebird2_rc_query,
1985        },
1986
1987        .num_device_descs = 1,
1988        .devices = {
1989                {   "DViCO FusionHDTV DVB-T NANO2",
1990                        { NULL },
1991                        { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL },
1992                },
1993        }
1994};
1995
1996static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1997        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1998
1999        .usb_ctrl          = DEVICE_SPECIFIC,
2000        .firmware          = "dvb-usb-bluebird-02.fw",
2001        .download_firmware = bluebird_patch_dvico_firmware_download,
2002        .identify_state    = bluebird_fx2_identify_state,
2003
2004        .size_of_priv      = sizeof(struct cxusb_state),
2005
2006        .num_adapters = 1,
2007        .adapter = {
2008                {
2009                .num_frontends = 1,
2010                .fe = {{
2011                        .streaming_ctrl   = cxusb_streaming_ctrl,
2012                        .frontend_attach  = cxusb_nano2_frontend_attach,
2013                        .tuner_attach     = cxusb_dvico_xc3028_tuner_attach,
2014                        /* parameter for the MPEG2-data transfer */
2015                        .stream = {
2016                                .type = USB_BULK,
2017                                .count = 5,
2018                                .endpoint = 0x02,
2019                                .u = {
2020                                        .bulk = {
2021                                                .buffersize = 8192,
2022                                        }
2023                                }
2024                        },
2025                }},
2026                },
2027        },
2028
2029        .power_ctrl       = cxusb_nano2_power_ctrl,
2030
2031        .i2c_algo         = &cxusb_i2c_algo,
2032
2033        .generic_bulk_ctrl_endpoint = 0x01,
2034
2035        .rc.legacy = {
2036                .rc_interval      = 100,
2037                .rc_map_table     = rc_map_dvico_portable_table,
2038                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_portable_table),
2039                .rc_query         = cxusb_rc_query,
2040        },
2041
2042        .num_device_descs = 1,
2043        .devices = {
2044                {   "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
2045                        { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2], NULL },
2046                        { &cxusb_table[DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM], NULL },
2047                },
2048        }
2049};
2050
2051static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
2052        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2053
2054        .usb_ctrl         = CYPRESS_FX2,
2055
2056        .size_of_priv     = sizeof(struct cxusb_state),
2057
2058        .num_adapters = 1,
2059        .adapter = {
2060                {
2061                .num_frontends = 1,
2062                .fe = {{
2063                        .streaming_ctrl   = cxusb_aver_streaming_ctrl,
2064                        .frontend_attach  = cxusb_aver_lgdt3303_frontend_attach,
2065                        .tuner_attach     = cxusb_mxl5003s_tuner_attach,
2066                        /* parameter for the MPEG2-data transfer */
2067                        .stream = {
2068                                .type = USB_BULK,
2069                                .count = 5,
2070                                .endpoint = 0x04,
2071                                .u = {
2072                                        .bulk = {
2073                                                .buffersize = 8192,
2074                                        }
2075                                }
2076                        },
2077                }},
2078                },
2079        },
2080        .power_ctrl       = cxusb_aver_power_ctrl,
2081
2082        .i2c_algo         = &cxusb_i2c_algo,
2083
2084        .generic_bulk_ctrl_endpoint = 0x01,
2085
2086        .num_device_descs = 1,
2087        .devices = {
2088                {   "AVerMedia AVerTVHD Volar (A868R)",
2089                        { NULL },
2090                        { &cxusb_table[AVERMEDIA_VOLAR_A868R], NULL },
2091                },
2092        }
2093};
2094
2095static
2096struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
2097        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2098
2099        .usb_ctrl         = CYPRESS_FX2,
2100
2101        .size_of_priv     = sizeof(struct cxusb_state),
2102
2103        .num_adapters = 1,
2104        .adapter = {
2105                {
2106                .size_of_priv    = sizeof(struct dib0700_adapter_state),
2107                .num_frontends = 1,
2108                .fe = {{
2109                        .streaming_ctrl  = cxusb_streaming_ctrl,
2110                        .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
2111                        .tuner_attach    = cxusb_dualdig4_rev2_tuner_attach,
2112                        /* parameter for the MPEG2-data transfer */
2113                        .stream = {
2114                                .type = USB_BULK,
2115                                .count = 7,
2116                                .endpoint = 0x02,
2117                                .u = {
2118                                        .bulk = {
2119                                                .buffersize = 4096,
2120                                        }
2121                                }
2122                        },
2123                }},
2124                },
2125        },
2126
2127        .power_ctrl       = cxusb_bluebird_power_ctrl,
2128
2129        .i2c_algo         = &cxusb_i2c_algo,
2130
2131        .generic_bulk_ctrl_endpoint = 0x01,
2132
2133        .rc.legacy = {
2134                .rc_interval      = 100,
2135                .rc_map_table     = rc_map_dvico_mce_table,
2136                .rc_map_size      = ARRAY_SIZE(rc_map_dvico_mce_table),
2137                .rc_query         = cxusb_rc_query,
2138        },
2139
2140        .num_device_descs = 1,
2141        .devices = {
2142                {   "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
2143                        { NULL },
2144                        { &cxusb_table[DVICO_BLUEBIRD_DUAL_4_REV_2], NULL },
2145                },
2146        }
2147};
2148
2149static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
2150        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2151
2152        .usb_ctrl         = CYPRESS_FX2,
2153
2154        .size_of_priv     = sizeof(struct cxusb_state),
2155
2156        .num_adapters = 1,
2157        .adapter = {
2158                {
2159                .num_frontends = 1,
2160                .fe = {{
2161                        .streaming_ctrl   = cxusb_d680_dmb_streaming_ctrl,
2162                        .frontend_attach  = cxusb_d680_dmb_frontend_attach,
2163                        .tuner_attach     = cxusb_d680_dmb_tuner_attach,
2164
2165                        /* parameter for the MPEG2-data transfer */
2166                        .stream = {
2167                                .type = USB_BULK,
2168                                .count = 5,
2169                                .endpoint = 0x02,
2170                                .u = {
2171                                        .bulk = {
2172                                                .buffersize = 8192,
2173                                        }
2174                                }
2175                        },
2176                }},
2177                },
2178        },
2179
2180        .power_ctrl       = cxusb_d680_dmb_power_ctrl,
2181
2182        .i2c_algo         = &cxusb_i2c_algo,
2183
2184        .generic_bulk_ctrl_endpoint = 0x01,
2185
2186        .rc.legacy = {
2187                .rc_interval      = 100,
2188                .rc_map_table     = rc_map_d680_dmb_table,
2189                .rc_map_size      = ARRAY_SIZE(rc_map_d680_dmb_table),
2190                .rc_query         = cxusb_d680_dmb_rc_query,
2191        },
2192
2193        .num_device_descs = 1,
2194        .devices = {
2195                {
2196                        "Conexant DMB-TH Stick",
2197                        { NULL },
2198                        { &cxusb_table[CONEXANT_D680_DMB], NULL },
2199                },
2200        }
2201};
2202
2203static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
2204        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2205
2206        .usb_ctrl         = CYPRESS_FX2,
2207
2208        .size_of_priv     = sizeof(struct cxusb_state),
2209
2210        .num_adapters = 1,
2211        .adapter = {
2212                {
2213                .num_frontends = 1,
2214                .fe = {{
2215                        .streaming_ctrl   = cxusb_d680_dmb_streaming_ctrl,
2216                        .frontend_attach  = cxusb_mygica_d689_frontend_attach,
2217                        .tuner_attach     = cxusb_mygica_d689_tuner_attach,
2218
2219                        /* parameter for the MPEG2-data transfer */
2220                        .stream = {
2221                                .type = USB_BULK,
2222                                .count = 5,
2223                                .endpoint = 0x02,
2224                                .u = {
2225                                        .bulk = {
2226                                                .buffersize = 8192,
2227                                        }
2228                                }
2229                        },
2230                }},
2231                },
2232        },
2233
2234        .power_ctrl       = cxusb_d680_dmb_power_ctrl,
2235
2236        .i2c_algo         = &cxusb_i2c_algo,
2237
2238        .generic_bulk_ctrl_endpoint = 0x01,
2239
2240        .rc.legacy = {
2241                .rc_interval      = 100,
2242                .rc_map_table     = rc_map_d680_dmb_table,
2243                .rc_map_size      = ARRAY_SIZE(rc_map_d680_dmb_table),
2244                .rc_query         = cxusb_d680_dmb_rc_query,
2245        },
2246
2247        .num_device_descs = 1,
2248        .devices = {
2249                {
2250                        "Mygica D689 DMB-TH",
2251                        { NULL },
2252                        { &cxusb_table[MYGICA_D689], NULL },
2253                },
2254        }
2255};
2256
2257static struct dvb_usb_device_properties cxusb_mygica_t230_properties = {
2258        .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2259
2260        .usb_ctrl         = CYPRESS_FX2,
2261
2262        .size_of_priv     = sizeof(struct cxusb_state),
2263
2264        .num_adapters = 1,
2265        .adapter = {
2266                {
2267                .num_frontends = 1,
2268                .fe = {{
2269                        .streaming_ctrl   = cxusb_streaming_ctrl,
2270                        .frontend_attach  = cxusb_mygica_t230_frontend_attach,
2271
2272                        /* parameter for the MPEG2-data transfer */
2273                        .stream = {
2274                                .type = USB_BULK,
2275                                .count = 5,
2276                                .endpoint = 0x02,
2277                                .u = {
2278                                        .bulk = {
2279                                                .buffersize = 8192,
2280                                        }
2281                                }
2282                        },
2283                } },
2284                },
2285        },
2286
2287        .power_ctrl       = cxusb_d680_dmb_power_ctrl,
2288
2289        .i2c_algo         = &cxusb_i2c_algo,
2290
2291        .generic_bulk_ctrl_endpoint = 0x01,
2292
2293        .rc.legacy = {
2294                .rc_interval      = 100,
2295                .rc_map_table     = rc_map_d680_dmb_table,
2296                .rc_map_size      = ARRAY_SIZE(rc_map_d680_dmb_table),
2297                .rc_query         = cxusb_d680_dmb_rc_query,
2298        },
2299
2300        .num_device_descs = 1,
2301        .devices = {
2302                {
2303                        "Mygica T230 DVB-T/T2/C",
2304                        { NULL },
2305                        { &cxusb_table[MYGICA_T230], NULL },
2306                },
2307        }
2308};
2309
2310static struct usb_driver cxusb_driver = {
2311        .name           = "dvb_usb_cxusb",
2312        .probe          = cxusb_probe,
2313        .disconnect     = cxusb_disconnect,
2314        .id_table       = cxusb_table,
2315};
2316
2317module_usb_driver(cxusb_driver);
2318
2319MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@posteo.de>");
2320MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
2321MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
2322MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
2323MODULE_VERSION("1.0-alpha");
2324MODULE_LICENSE("GPL");
Note: See TracBrowser for help on using the repository browser.