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