Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

Linux/drivers/media/usb/dvb-usb/cxusb.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us