]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blame - drivers/media/dvb/dvb-usb/cxusb.c
projects / mirror_ubuntu-artful-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[media] dvb: remove dvb_frontend_parameters from calc_regs()
[mirror_ubuntu-artful-kernel.git] / drivers / media / dvb / dvb-usb / cxusb.c
CommitLineData
22c6d93a
PB		 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 *
81481e9e 14 * TODO: Use the cx25840-driver for the analogue part
22c6d93a 15 *
22c6d93a 16 * Copyright (C) 2005 Patrick Boettcher (patrick.boettcher@desy.de)
5b9ed286 17 * Copyright (C) 2006 Michael Krufky (mkrufky@linuxtv.org)
aeb012bb 18 * Copyright (C) 2006, 2007 Chris Pascoe (c.pascoe@itee.uq.edu.au)
22c6d93a 19 *
f35db23c
MK		 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.
22c6d93a
PB		 23 *
24 * see Documentation/dvb/README.dvb-usb for more information
25 */
827855d3 26#include <media/tuner.h>
e62f89f2 27#include <linux/vmalloc.h>
5a0e3ad6 28#include <linux/slab.h>
827855d3 29
22c6d93a
PB		 30#include "cxusb.h"
31
32#include "cx22702.h"
effee033 33#include "lgdt330x.h"
0029ee14
CP		 34#include "mt352.h"
35#include "mt352_priv.h"
c9ce3940 36#include "zl10353.h"
aeb012bb 37#include "tuner-xc2028.h"
827855d3 38#include "tuner-simple.h"
f5376ada 39#include "mxl5005s.h"
b18bd1d8 40#include "max2165.h"
8d798988
AB		 41#include "dib7000p.h"
42#include "dib0070.h"
6bf1a997 43#include "lgs8gxx.h"
b18bd1d8 44#include "atbm8830.h"
22c6d93a
PB		 45
46/* debug */
53133afb 47static int dvb_usb_cxusb_debug;
f35db23c 48module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
22c6d93a 49MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
78e92006
JG		 50
51DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
52
f5376ada
DG		 53#define deb_info(args...) dprintk(dvb_usb_cxusb_debug, 0x03, args)
54#define deb_i2c(args...) dprintk(dvb_usb_cxusb_debug, 0x02, args)
22c6d93a
PB		 55
56static int cxusb_ctrl_msg(struct dvb_usb_device *d,
f35db23c 57 u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
22c6d93a
PB		 58{
59 int wo = (rbuf == NULL || rlen == 0); /* write-only */
60 u8 sndbuf[1+wlen];
f35db23c 61 memset(sndbuf, 0, 1+wlen);
22c6d93a
PB		 62
63 sndbuf[0] = cmd;
f35db23c 64 memcpy(&sndbuf[1], wbuf, wlen);
22c6d93a 65 if (wo)
b17f109d 66 return dvb_usb_generic_write(d, sndbuf, 1+wlen);
22c6d93a 67 else
b17f109d 68 return dvb_usb_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen, 0);
22c6d93a
PB		 69}
70
e2efeab2
PB		 71/* GPIO */
72static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
22c6d93a
PB		 73{
74 struct cxusb_state *st = d->priv;
f35db23c 75 u8 o[2], i;
22c6d93a 76
e2efeab2 77 if (st->gpio_write_state[GPIO_TUNER] == onoff)
22c6d93a
PB		 78 return;
79
e2efeab2
PB		 80 o[0] = GPIO_TUNER;
81 o[1] = onoff;
f35db23c 82 cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
22c6d93a
PB		 83
84 if (i != 0x01)
e2efeab2 85 deb_info("gpio_write failed.\n");
22c6d93a 86
e2efeab2 87 st->gpio_write_state[GPIO_TUNER] = onoff;
22c6d93a
PB		 88}
89
aeb012bb
CP		 90static 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
106static 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
5ccaf905
CP		 113static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff)
114{
115 cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40);
116}
117
dfbdce04
TL		 118static 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
e2efeab2 137/* I2C */
f35db23c
MK		 138static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
139 int num)
22c6d93a
PB		 140{
141 struct dvb_usb_device *d = i2c_get_adapdata(adap);
142 int i;
143
3593cab5 144 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
22c6d93a
PB		 145 return -EAGAIN;
146
22c6d93a
PB		 147 for (i = 0; i < num; i++) {
148
5e805eff
MK		 149 if (d->udev->descriptor.idVendor == USB_VID_MEDION)
150 switch (msg[i].addr) {
f35db23c
MK		 151 case 0x63:
152 cxusb_gpio_tuner(d, 0);
153 break;
154 default:
155 cxusb_gpio_tuner(d, 1);
156 break;
5e805eff 157 }
22c6d93a 158
272479d7
CP		 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);
a644e4a3
CP		 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 */
22c6d93a
PB		 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;
f35db23c 179 memcpy(&obuf[3], msg[i].buf, msg[i].len);
22c6d93a
PB		 180
181 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
f35db23c
MK		 182 obuf, 3+msg[i].len,
183 ibuf, 1+msg[i+1].len) < 0)
22c6d93a
PB		 184 break;
185
186 if (ibuf[0] != 0x08)
ae62e3d4 187 deb_i2c("i2c read may have failed\n");
22c6d93a 188
f35db23c 189 memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
22c6d93a
PB		 190
191 i++;
272479d7
CP		 192 } else {
193 /* write only */
22c6d93a
PB		 194 u8 obuf[2+msg[i].len], ibuf;
195 obuf[0] = msg[i].addr;
196 obuf[1] = msg[i].len;
f35db23c 197 memcpy(&obuf[2], msg[i].buf, msg[i].len);
22c6d93a 198
f35db23c
MK		 199 if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf,
200 2+msg[i].len, &ibuf,1) < 0)
22c6d93a
PB		 201 break;
202 if (ibuf != 0x08)
ae62e3d4 203 deb_i2c("i2c write may have failed\n");
22c6d93a
PB		 204 }
205 }
206
3593cab5 207 mutex_unlock(&d->i2c_mutex);
13e001df 208 return i == num ? num : -EREMOTEIO;
22c6d93a
PB		 209}
210
211static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
212{
213 return I2C_FUNC_I2C;
214}
215
216static struct i2c_algorithm cxusb_i2c_algo = {
22c6d93a
PB		 217 .master_xfer = cxusb_i2c_xfer,
218 .functionality = cxusb_i2c_func,
219};
220
221static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
222{
e2efeab2
PB		 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);
22c6d93a
PB		 228}
229
f5376ada
DG		 230static 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");
c6eb8eaf 238 do {} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, 0, NULL, 0)) &&
f5376ada
DG		 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
5691c847
MK		 270static 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
5ccaf905
CP		 279static 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
dfbdce04
TL		 290static 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
4d43e13f 304static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
22c6d93a 305{
8257e8a4
PB		 306 u8 buf[2] = { 0x03, 0x00 };
307 if (onoff)
4d43e13f 308 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0);
8257e8a4 309 else
4d43e13f 310 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
8257e8a4 311
22c6d93a
PB		 312 return 0;
313}
314
f5376ada
DG		 315static 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
dfbdce04
TL		 325static 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
348static void cxusb_d680_dmb_drain_video(struct dvb_usb_device *d)
349{
77eed219 350 struct usb_data_stream_properties *p = &d->props.adapter[0].fe[0].stream;
dfbdce04
TL		 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
371static 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
7c239703
CP		 386static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
387{
2f4f58d6 388 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
a07e6096 389 u8 ircode[4];
7c239703
CP		 390 int i;
391
a07e6096 392 cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4);
7c239703
CP		 393
394 *event = 0;
395 *state = REMOTE_NO_KEY_PRESSED;
396
2f4f58d6 397 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
2e365883
MCC		 398 if (rc5_custom(&keymap[i]) == ircode[2] &&
399 rc5_data(&keymap[i]) == ircode[3]) {
34abf219 400 *event = keymap[i].keycode;
7c239703
CP		 401 *state = REMOTE_KEY_PRESSED;
402
403 return 0;
404 }
405 }
406
407 return 0;
408}
409
aeb012bb
CP		 410static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d, u32 *event,
411 int *state)
412{
2f4f58d6 413 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
aeb012bb
CP		 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
2f4f58d6 425 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
2e365883
MCC		 426 if (rc5_custom(&keymap[i]) == ircode[1] &&
427 rc5_data(&keymap[i]) == ircode[2]) {
34abf219 428 *event = keymap[i].keycode;
aeb012bb
CP		 429 *state = REMOTE_KEY_PRESSED;
430
431 return 0;
432 }
433 }
434
435 return 0;
436}
437
dfbdce04
TL		 438static int cxusb_d680_dmb_rc_query(struct dvb_usb_device *d, u32 *event,
439 int *state)
440{
2f4f58d6 441 struct rc_map_table *keymap = d->props.rc.legacy.rc_map_table;
dfbdce04
TL		 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
2f4f58d6 451 for (i = 0; i < d->props.rc.legacy.rc_map_size; i++) {
2e365883
MCC		 452 if (rc5_custom(&keymap[i]) == ircode[0] &&
453 rc5_data(&keymap[i]) == ircode[1]) {
34abf219 454 *event = keymap[i].keycode;
dfbdce04
TL		 455 *state = REMOTE_KEY_PRESSED;
456
457 return 0;
458 }
459 }
460
461 return 0;
462}
463
2f4f58d6 464static struct rc_map_table rc_map_dvico_mce_table[] = {
2e365883
MCC		 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 },
a07e6096
MK		 510};
511
2f4f58d6 512static struct rc_map_table rc_map_dvico_portable_table[] = {
2e365883
MCC		 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 */
c150178b
MK		 549};
550
2f4f58d6 551static struct rc_map_table rc_map_d680_dmb_table[] = {
2e365883
MCC		 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 },
dfbdce04
TL		 587};
588
0029ee14
CP		 589static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
590{
d9ed881c 591 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 };
0029ee14
CP		 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
6f447259
MK		 610static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
611{ /* used in both lgz201 and th7579 */
fb51fd2d 612 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x29 };
6f447259
MK		 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
703cb2cb 630static struct cx22702_config cxusb_cx22702_config = {
22c6d93a 631 .demod_address = 0x63,
8257e8a4 632 .output_mode = CX22702_PARALLEL_OUTPUT,
22c6d93a
PB		 633};
634
fddd632a 635static struct lgdt330x_config cxusb_lgdt3303_config = {
effee033
MK		 636 .demod_address = 0x0e,
637 .demod_chip = LGDT3303,
effee033
MK		 638};
639
f5376ada
DG		 640static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
641 .demod_address = 0x0e,
642 .demod_chip = LGDT3303,
643 .clock_polarity_flip = 2,
644};
645
703cb2cb 646static struct mt352_config cxusb_dee1601_config = {
0029ee14
CP		 647 .demod_address = 0x0f,
648 .demod_init = cxusb_dee1601_demod_init,
0029ee14
CP		 649};
650
c9ce3940
MK		 651static struct zl10353_config cxusb_zl10353_dee1601_config = {
652 .demod_address = 0x0f,
8fb95784 653 .parallel_ts = 1,
c9ce3940
MK		 654};
655
6fe00b0e 656static struct mt352_config cxusb_mt352_config = {
6f447259
MK		 657 /* used in both lgz201 and th7579 */
658 .demod_address = 0x0f,
659 .demod_init = cxusb_mt352_demod_init,
6f447259
MK		 660};
661
aeb012bb
CP		 662static struct zl10353_config cxusb_zl10353_xc3028_config = {
663 .demod_address = 0x0f,
a1dcd9de 664 .if2 = 45600,
aeb012bb
CP		 665 .no_tuner = 1,
666 .parallel_ts = 1,
667};
668
0bc35180
RL		 669static 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
702a6762
CP		 677static 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
f5376ada
DG		 684/* FIXME: needs tweaking */
685static 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
dfbdce04
TL		 702/* FIXME: needs tweaking */
703static 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
b18bd1d8
DW		 720static struct max2165_config mygica_d689_max2165_cfg = {
721 .i2c_address = 0x60,
722 .osc_clk = 20
723};
724
22c6d93a 725/* Callbacks for DVB USB */
4d43e13f 726static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
22c6d93a 727{
77eed219 728 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
cb89cd33
MK		 729 &adap->dev->i2c_adap, 0x61,
730 TUNER_PHILIPS_FMD1216ME_MK3);
22c6d93a
PB		 731 return 0;
732}
733
4d43e13f 734static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
0029ee14 735{
77eed219 736 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61,
47a9991e 737 NULL, DVB_PLL_THOMSON_DTT7579);
0029ee14
CP		 738 return 0;
739}
740
4d43e13f 741static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
6f447259 742{
77eed219 743 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x61, NULL, DVB_PLL_LG_Z201);
6f447259
MK		 744 return 0;
745}
746
4d43e13f 747static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
6f447259 748{
77eed219 749 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
47a9991e 750 NULL, DVB_PLL_THOMSON_DTT7579);
332bed5f
PB		 751 return 0;
752}
753
f71a56c1 754static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
332bed5f 755{
77eed219 756 dvb_attach(simple_tuner_attach, adap->fe_adap[0].fe,
827855d3 757 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
6f447259
MK		 758 return 0;
759}
760
d7cba043
MK		 761static int dvico_bluebird_xc2028_callback(void *ptr, int component,
762 int command, int arg)
aeb012bb 763{
d483b730
RL		 764 struct dvb_usb_adapter *adap = ptr;
765 struct dvb_usb_device *d = adap->dev;
aeb012bb
CP		 766
767 switch (command) {
768 case XC2028_TUNER_RESET:
708bebdd 769 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
aeb012bb
CP		 770 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
771 break;
772 case XC2028_RESET_CLK:
708bebdd 773 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
aeb012bb
CP		 774 break;
775 default:
708bebdd 776 deb_info("%s: unknown command %d, arg %d\n", __func__,
aeb012bb
CP		 777 command, arg);
778 return -EINVAL;
779 }
780
781 return 0;
782}
783
784static 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,
aeb012bb
CP		 790 };
791 static struct xc2028_ctrl ctl = {
ef80bfeb 792 .fname = XC2028_DEFAULT_FIRMWARE,
aeb012bb 793 .max_len = 64,
d483b730 794 .demod = XC3028_FE_ZARLINK456,
aeb012bb
CP		 795 };
796
d7cba043 797 /* FIXME: generalize & move to common area */
77eed219 798 adap->fe_adap[0].fe->callback = dvico_bluebird_xc2028_callback;
d7cba043 799
77eed219 800 fe = dvb_attach(xc2028_attach, adap->fe_adap[0].fe, &cfg);
aeb012bb
CP		 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
f5376ada
DG		 809static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
810{
77eed219 811 dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
f5376ada
DG		 812 &adap->dev->i2c_adap, &aver_a868r_tuner);
813 return 0;
814}
815
dfbdce04
TL		 816static int cxusb_d680_dmb_tuner_attach(struct dvb_usb_adapter *adap)
817{
818 struct dvb_frontend *fe;
77eed219 819 fe = dvb_attach(mxl5005s_attach, adap->fe_adap[0].fe,
dfbdce04
TL		 820 &adap->dev->i2c_adap, &d680_dmb_tuner);
821 return (fe == NULL) ? -EIO : 0;
822}
823
b18bd1d8
DW		 824static int cxusb_mygica_d689_tuner_attach(struct dvb_usb_adapter *adap)
825{
826 struct dvb_frontend *fe;
77eed219 827 fe = dvb_attach(max2165_attach, adap->fe_adap[0].fe,
b18bd1d8
DW		 828 &adap->dev->i2c_adap, &mygica_d689_max2165_cfg);
829 return (fe == NULL) ? -EIO : 0;
830}
831
4d43e13f 832static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
22c6d93a 833{
e2efeab2 834 u8 b;
4d43e13f 835 if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
8257e8a4 836 err("set interface failed");
22c6d93a 837
4d43e13f 838 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
22c6d93a 839
310df366
MK		 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)
22c6d93a
PB		 843 return 0;
844
845 return -EIO;
846}
847
4d43e13f 848static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
effee033 849{
4d43e13f 850 if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
effee033
MK		 851 err("set interface failed");
852
4d43e13f 853 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
effee033 854
310df366
MK		 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)
effee033
MK		 859 return 0;
860
861 return -EIO;
862}
863
f5376ada
DG		 864static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
865{
77eed219 866 adap->fe_adap[0].fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
f5376ada 867 &adap->dev->i2c_adap);
77eed219 868 if (adap->fe_adap[0].fe != NULL)
f5376ada
DG		 869 return 0;
870
871 return -EIO;
872}
873
4d43e13f
PB		 874static 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)
6f447259
MK		 878 err("set interface failed");
879
4d43e13f 880 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
6f447259 881
310df366
MK		 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)
6f447259
MK		 885 return 0;
886
887 return -EIO;
888}
889
4d43e13f 890static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
0029ee14 891{
4d43e13f 892 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
0029ee14
CP		 893 err("set interface failed");
894
4d43e13f 895 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
0029ee14 896
310df366
MK		 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)
0029ee14
CP		 906 return 0;
907
908 return -EIO;
909}
910
aeb012bb
CP		 911static 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
310df366
MK		 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)
aeb012bb
CP		 933 return -EIO;
934
935 /* try to determine if there is no IR decoder on the I2C bus */
2f4f58d6 936 for (i = 0; adap->dev->props.rc.legacy.rc_map_table != NULL && i < 5; i++) {
aeb012bb
CP		 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) {
943no_IR:
2f4f58d6 944 adap->dev->props.rc.legacy.rc_map_table = NULL;
aeb012bb
CP		 945 info("No IR receiver detected on this device.");
946 break;
947 }
948 }
949
950 return 0;
951}
952
8d798988
AB		 953static 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
991static 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
1011static 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
1029static 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
30d81bb0 1038 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
a49ba167
PB		 1039 &cxusb_dualdig4_rev2_config) < 0) {
1040 printk(KERN_WARNING "Unable to enumerate dib7000p\n");
30d81bb0 1041 return -ENODEV;
a49ba167 1042 }
8d798988 1043
77eed219 1044 adap->fe_adap[0].fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
a2dc86b6 1045 &cxusb_dualdig4_rev2_config);
77eed219 1046 if (adap->fe_adap[0].fe == NULL)
8d798988
AB		 1047 return -EIO;
1048
1049 return 0;
1050}
1051
1052static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1053{
1054 return dib7000p_set_gpio(fe, 8, 0, !onoff);
1055}
1056
1057static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1058{
1059 return 0;
1060}
1061
1062static 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
1069struct dib0700_adapter_state {
1070 int (*set_param_save) (struct dvb_frontend *,
1071 struct dvb_frontend_parameters *);
1072};
1073
1074static int dib7070_set_param_override(struct dvb_frontend *fe,
1075 struct dvb_frontend_parameters *fep)
1076{
afd2b38a 1077 struct dtv_frontend_properties *p = &fe->dtv_property_cache;
8d798988
AB		 1078 struct dvb_usb_adapter *adap = fe->dvb->priv;
1079 struct dib0700_adapter_state *state = adap->priv;
1080
1081 u16 offset;
afd2b38a 1082 u8 band = BAND_OF_FREQUENCY(p->frequency/1000);
8d798988 1083 switch (band) {
a2dc86b6
MK		 1084 case BAND_VHF: offset = 950; break;
1085 default:
1086 case BAND_UHF: offset = 550; break;
8d798988
AB		 1087 }
1088
1089 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1090
1091 return state->set_param_save(fe, fep);
1092}
1093
1094static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1095{
1096 struct dib0700_adapter_state *st = adap->priv;
a2dc86b6 1097 struct i2c_adapter *tun_i2c =
77eed219 1098 dib7000p_get_i2c_master(adap->fe_adap[0].fe,
a2dc86b6 1099 DIBX000_I2C_INTERFACE_TUNER, 1);
8d798988 1100
77eed219 1101 if (dvb_attach(dib0070_attach, adap->fe_adap[0].fe, tun_i2c,
8d798988
AB		 1102 &dib7070p_dib0070_config) == NULL)
1103 return -ENODEV;
1104
77eed219
MK		 1105 st->set_param_save = adap->fe_adap[0].fe->ops.tuner_ops.set_params;
1106 adap->fe_adap[0].fe->ops.tuner_ops.set_params = dib7070_set_param_override;
8d798988
AB		 1107 return 0;
1108}
1109
5ccaf905
CP		 1110static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1111{
1112 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1113 err("set interface failed");
1114
1115 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1116
1117 /* reset the tuner and demodulator */
1118 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1119 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1120 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1121
310df366
MK		 1122 adap->fe_adap[0].fe = dvb_attach(zl10353_attach,
1123 &cxusb_zl10353_xc3028_config,
1124 &adap->dev->i2c_adap);
1125 if ((adap->fe_adap[0].fe) != NULL)
5ccaf905
CP		 1126 return 0;
1127
310df366
MK		 1128 adap->fe_adap[0].fe = dvb_attach(mt352_attach,
1129 &cxusb_mt352_xc3028_config,
1130 &adap->dev->i2c_adap);
1131 if ((adap->fe_adap[0].fe) != NULL)
702a6762
CP		 1132 return 0;
1133
5ccaf905
CP		 1134 return -EIO;
1135}
1136
6bf1a997
DW		 1137static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1138 .prod = LGS8GXX_PROD_LGS8GL5,
dfbdce04 1139 .demod_address = 0x19,
6bf1a997
DW		 1140 .serial_ts = 0,
1141 .ts_clk_pol = 0,
1142 .ts_clk_gated = 1,
1143 .if_clk_freq = 30400, /* 30.4 MHz */
1144 .if_freq = 5725, /* 5.725 MHz */
1145 .if_neg_center = 0,
1146 .ext_adc = 0,
1147 .adc_signed = 0,
1148 .if_neg_edge = 0,
dfbdce04
TL		 1149};
1150
1151static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1152{
1153 struct dvb_usb_device *d = adap->dev;
1154 int n;
1155
1156 /* Select required USB configuration */
1157 if (usb_set_interface(d->udev, 0, 0) < 0)
1158 err("set interface failed");
1159
1160 /* Unblock all USB pipes */
1161 usb_clear_halt(d->udev,
1162 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1163 usb_clear_halt(d->udev,
1164 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1165 usb_clear_halt(d->udev,
77eed219 1166 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
dfbdce04
TL		 1167
1168 /* Drain USB pipes to avoid hang after reboot */
1169 for (n = 0; n < 5; n++) {
1170 cxusb_d680_dmb_drain_message(d);
1171 cxusb_d680_dmb_drain_video(d);
1172 msleep(200);
1173 }
1174
1175 /* Reset the tuner */
1176 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1177 err("clear tuner gpio failed");
1178 return -EIO;
1179 }
1180 msleep(100);
1181 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1182 err("set tuner gpio failed");
1183 return -EIO;
1184 }
1185 msleep(100);
1186
1187 /* Attach frontend */
77eed219
MK		 1188 adap->fe_adap[0].fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap);
1189 if (adap->fe_adap[0].fe == NULL)
dfbdce04
TL		 1190 return -EIO;
1191
1192 return 0;
1193}
1194
b18bd1d8
DW		 1195static struct atbm8830_config mygica_d689_atbm8830_cfg = {
1196 .prod = ATBM8830_PROD_8830,
1197 .demod_address = 0x40,
1198 .serial_ts = 0,
1199 .ts_sampling_edge = 1,
1200 .ts_clk_gated = 0,
1201 .osc_clk_freq = 30400, /* in kHz */
1202 .if_freq = 0, /* zero IF */
1203 .zif_swap_iq = 1,
c245c75c
DW		 1204 .agc_min = 0x2E,
1205 .agc_max = 0x90,
1206 .agc_hold_loop = 0,
b18bd1d8
DW		 1207};
1208
1209static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
1210{
1211 struct dvb_usb_device *d = adap->dev;
b18bd1d8
DW		 1212
1213 /* Select required USB configuration */
1214 if (usb_set_interface(d->udev, 0, 0) < 0)
1215 err("set interface failed");
1216
1217 /* Unblock all USB pipes */
1218 usb_clear_halt(d->udev,
1219 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1220 usb_clear_halt(d->udev,
1221 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1222 usb_clear_halt(d->udev,
77eed219 1223 usb_rcvbulkpipe(d->udev, d->props.adapter[0].fe[0].stream.endpoint));
b18bd1d8
DW		 1224
1225
1226 /* Reset the tuner */
1227 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1228 err("clear tuner gpio failed");
1229 return -EIO;
1230 }
1231 msleep(100);
1232 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1233 err("set tuner gpio failed");
1234 return -EIO;
1235 }
1236 msleep(100);
1237
1238 /* Attach frontend */
77eed219 1239 adap->fe_adap[0].fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg,
b18bd1d8 1240 &d->i2c_adap);
77eed219 1241 if (adap->fe_adap[0].fe == NULL)
b18bd1d8
DW		 1242 return -EIO;
1243
1244 return 0;
1245}
1246
702a6762
CP		 1247/*
1248 * DViCO has shipped two devices with the same USB ID, but only one of them
1249 * needs a firmware download. Check the device class details to see if they
1250 * have non-default values to decide whether the device is actually cold or
1251 * not, and forget a match if it turns out we selected the wrong device.
1252 */
1253static int bluebird_fx2_identify_state(struct usb_device *udev,
1254 struct dvb_usb_device_properties *props,
1255 struct dvb_usb_device_description **desc,
1256 int *cold)
1257{
1258 int wascold = *cold;
1259
1260 *cold = udev->descriptor.bDeviceClass == 0xff &&
1261 udev->descriptor.bDeviceSubClass == 0xff &&
1262 udev->descriptor.bDeviceProtocol == 0xff;
1263
1264 if (*cold && !wascold)
1265 *desc = NULL;
1266
1267 return 0;
1268}
1269
f5373788
PB		 1270/*
1271 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1272 * firmware file before download.
1273 */
1274
702a6762 1275static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
f35db23c
MK		 1276static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1277 const struct firmware *fw)
f5373788 1278{
702a6762
CP		 1279 int pos;
1280
1281 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1282 int idoff = dvico_firmware_id_offsets[pos];
f5373788 1283
702a6762
CP		 1284 if (fw->size < idoff + 4)
1285 continue;
f5373788 1286
702a6762
CP		 1287 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1288 fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
e62f89f2
DW		 1289 struct firmware new_fw;
1290 u8 *new_fw_data = vmalloc(fw->size);
1291 int ret;
1292
1293 if (!new_fw_data)
1294 return -ENOMEM;
1295
1296 memcpy(new_fw_data, fw->data, fw->size);
1297 new_fw.size = fw->size;
1298 new_fw.data = new_fw_data;
1299
1300 new_fw_data[idoff + 2] =
702a6762 1301 le16_to_cpu(udev->descriptor.idProduct) + 1;
e62f89f2 1302 new_fw_data[idoff + 3] =
702a6762 1303 le16_to_cpu(udev->descriptor.idProduct) >> 8;
f5373788 1304
e62f89f2
DW		 1305 ret = usb_cypress_load_firmware(udev, &new_fw,
1306 CYPRESS_FX2);
1307 vfree(new_fw_data);
1308 return ret;
702a6762 1309 }
f5373788
PB		 1310 }
1311
1312 return -EINVAL;
1313}
1314
22c6d93a 1315/* DVB USB Driver stuff */
4d43e13f
PB		 1316static struct dvb_usb_device_properties cxusb_medion_properties;
1317static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1318static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1319static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1320static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
aeb012bb 1321static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
8d798988 1322static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
5ccaf905 1323static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
702a6762 1324static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
f5376ada 1325static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
dfbdce04 1326static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
b18bd1d8 1327static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
22c6d93a
PB		 1328
1329static int cxusb_probe(struct usb_interface *intf,
f35db23c 1330 const struct usb_device_id *id)
22c6d93a 1331{
78e92006
JG		 1332 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
1333 THIS_MODULE, NULL, adapter_nr) ||
1334 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
1335 THIS_MODULE, NULL, adapter_nr) ||
1336 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
1337 THIS_MODULE, NULL, adapter_nr) ||
1338 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
1339 THIS_MODULE, NULL, adapter_nr) ||
1340 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
1341 THIS_MODULE, NULL, adapter_nr) ||
1342 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
1343 THIS_MODULE, NULL, adapter_nr) ||
1344 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
1345 THIS_MODULE, NULL, adapter_nr) ||
1346 0 == dvb_usb_device_init(intf,
1347 &cxusb_bluebird_nano2_needsfirmware_properties,
f5376ada
DG		 1348 THIS_MODULE, NULL, adapter_nr) ||
1349 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1350 THIS_MODULE, NULL, adapter_nr) ||
8d798988
AB		 1351 0 == dvb_usb_device_init(intf,
1352 &cxusb_bluebird_dualdig4_rev2_properties,
1353 THIS_MODULE, NULL, adapter_nr) ||
dfbdce04
TL		 1354 0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1355 THIS_MODULE, NULL, adapter_nr) ||
b18bd1d8
DW		 1356 0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
1357 THIS_MODULE, NULL, adapter_nr) ||
f5376ada 1358 0)
effee033 1359 return 0;
effee033
MK		 1360
1361 return -EINVAL;
22c6d93a
PB		 1362}
1363
1364static struct usb_device_id cxusb_table [] = {
f35db23c
MK		 1365 { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
1366 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
1367 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
1368 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
1369 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
1370 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
1371 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
1372 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
1373 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
1374 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
1375 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
1376 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
1377 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
aeb012bb 1378 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) },
5ccaf905 1379 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) },
702a6762 1380 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) },
f5376ada 1381 { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) },
8d798988 1382 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
dfbdce04 1383 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
b18bd1d8 1384 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) },
f35db23c 1385 {} /* Terminating entry */
22c6d93a
PB		 1386};
1387MODULE_DEVICE_TABLE (usb, cxusb_table);
1388
4d43e13f 1389static struct dvb_usb_device_properties cxusb_medion_properties = {
22c6d93a
PB		 1390 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1391
1392 .usb_ctrl = CYPRESS_FX2,
1393
1394 .size_of_priv = sizeof(struct cxusb_state),
1395
4d43e13f
PB		 1396 .num_adapters = 1,
1397 .adapter = {
1398 {
77eed219
MK		 1399 .num_frontends = 1,
1400 .fe = {{
01451e72
PB		 1401 .streaming_ctrl = cxusb_streaming_ctrl,
1402 .frontend_attach = cxusb_cx22702_frontend_attach,
1403 .tuner_attach = cxusb_fmd1216me_tuner_attach,
1404 /* parameter for the MPEG2-data transfer */
1405 .stream = {
1406 .type = USB_BULK,
1407 .count = 5,
1408 .endpoint = 0x02,
1409 .u = {
1410 .bulk = {
1411 .buffersize = 8192,
1412 }
1413 }
1414 },
77eed219 1415 }},
4d43e13f
PB		 1416 },
1417 },
1418 .power_ctrl = cxusb_power_ctrl,
1419
1420 .i2c_algo = &cxusb_i2c_algo,
1421
1422 .generic_bulk_ctrl_endpoint = 0x01,
1423
22c6d93a
PB		 1424 .num_device_descs = 1,
1425 .devices = {
1426 { "Medion MD95700 (MDUSBTV-HYBRID)",
1427 { NULL },
1428 { &cxusb_table[0], NULL },
1429 },
1430 }
1431};
1432
4d43e13f 1433static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
effee033
MK		 1434 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1435
f5373788
PB		 1436 .usb_ctrl = DEVICE_SPECIFIC,
1437 .firmware = "dvb-usb-bluebird-01.fw",
1438 .download_firmware = bluebird_patch_dvico_firmware_download,
37bdfa06
MK		 1439 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1440 use usb alt setting 7 for EP2 transfer (atsc) */
effee033
MK		 1441
1442 .size_of_priv = sizeof(struct cxusb_state),
1443
4d43e13f
PB		 1444 .num_adapters = 1,
1445 .adapter = {
1446 {
77eed219
MK		 1447 .num_frontends = 1,
1448 .fe = {{
01451e72
PB		 1449 .streaming_ctrl = cxusb_streaming_ctrl,
1450 .frontend_attach = cxusb_lgdt3303_frontend_attach,
f71a56c1 1451 .tuner_attach = cxusb_lgh064f_tuner_attach,
01451e72
PB		 1452
1453 /* parameter for the MPEG2-data transfer */
1454 .stream = {
1455 .type = USB_BULK,
1456 .count = 5,
1457 .endpoint = 0x02,
1458 .u = {
1459 .bulk = {
1460 .buffersize = 8192,
1461 }
1462 }
1463 },
77eed219 1464 }},
4d43e13f
PB		 1465 },
1466 },
1467
1468 .power_ctrl = cxusb_bluebird_power_ctrl,
1469
1470 .i2c_algo = &cxusb_i2c_algo,
1471
f72a27b8
MCC		 1472 .rc.legacy = {
1473 .rc_interval = 100,
2f4f58d6
MCC		 1474 .rc_map_table = rc_map_dvico_portable_table,
1475 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
f72a27b8
MCC		 1476 .rc_query = cxusb_rc_query,
1477 },
4d43e13f
PB		 1478
1479 .generic_bulk_ctrl_endpoint = 0x01,
effee033
MK		 1480
1481 .num_device_descs = 1,
1482 .devices = {
1483 { "DViCO FusionHDTV5 USB Gold",
1484 { &cxusb_table[1], NULL },
1485 { &cxusb_table[2], NULL },
1486 },
1487 }
1488};
1489
4d43e13f 1490static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
0029ee14
CP		 1491 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1492
f5373788
PB		 1493 .usb_ctrl = DEVICE_SPECIFIC,
1494 .firmware = "dvb-usb-bluebird-01.fw",
1495 .download_firmware = bluebird_patch_dvico_firmware_download,
0029ee14
CP		 1496 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1497 use usb alt setting 7 for EP2 transfer (atsc) */
1498
1499 .size_of_priv = sizeof(struct cxusb_state),
1500
4d43e13f
PB		 1501 .num_adapters = 1,
1502 .adapter = {
1503 {
77eed219
MK		 1504 .num_frontends = 1,
1505 .fe = {{
01451e72
PB		 1506 .streaming_ctrl = cxusb_streaming_ctrl,
1507 .frontend_attach = cxusb_dee1601_frontend_attach,
1508 .tuner_attach = cxusb_dee1601_tuner_attach,
1509 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 1510 .stream = {
1511 .type = USB_BULK,
01451e72
PB		 1512 .count = 5,
1513 .endpoint = 0x04,
1514 .u = {
1515 .bulk = {
1516 .buffersize = 8192,
1517 }
1518 }
1519 },
77eed219 1520 }},
4d43e13f
PB		 1521 },
1522 },
1523
1524 .power_ctrl = cxusb_bluebird_power_ctrl,
1525
1526 .i2c_algo = &cxusb_i2c_algo,
1527
f72a27b8
MCC		 1528 .rc.legacy = {
1529 .rc_interval = 150,
2f4f58d6
MCC		 1530 .rc_map_table = rc_map_dvico_mce_table,
1531 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
f72a27b8
MCC		 1532 .rc_query = cxusb_rc_query,
1533 },
4d43e13f
PB		 1534
1535 .generic_bulk_ctrl_endpoint = 0x01,
0029ee14 1536
587c03d1 1537 .num_device_descs = 3,
0029ee14
CP		 1538 .devices = {
1539 { "DViCO FusionHDTV DVB-T Dual USB",
1540 { &cxusb_table[3], NULL },
1541 { &cxusb_table[4], NULL },
1542 },
ac9ffb90
MK		 1543 { "DigitalNow DVB-T Dual USB",
1544 { &cxusb_table[9], NULL },
1545 { &cxusb_table[10], NULL },
1546 },
587c03d1
MK		 1547 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1548 { &cxusb_table[11], NULL },
1549 { &cxusb_table[12], NULL },
1550 },
0029ee14
CP		 1551 }
1552};
1553
4d43e13f 1554static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
6f447259
MK		 1555 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1556
1557 .usb_ctrl = DEVICE_SPECIFIC,
1558 .firmware = "dvb-usb-bluebird-01.fw",
1559 .download_firmware = bluebird_patch_dvico_firmware_download,
1560 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1561 use usb alt setting 7 for EP2 transfer (atsc) */
1562
1563 .size_of_priv = sizeof(struct cxusb_state),
1564
4d43e13f
PB		 1565 .num_adapters = 2,
1566 .adapter = {
1567 {
77eed219
MK		 1568 .num_frontends = 1,
1569 .fe = {{
01451e72
PB		 1570 .streaming_ctrl = cxusb_streaming_ctrl,
1571 .frontend_attach = cxusb_mt352_frontend_attach,
1572 .tuner_attach = cxusb_lgz201_tuner_attach,
6f447259 1573
01451e72 1574 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 1575 .stream = {
1576 .type = USB_BULK,
01451e72
PB		 1577 .count = 5,
1578 .endpoint = 0x04,
1579 .u = {
1580 .bulk = {
1581 .buffersize = 8192,
1582 }
1583 }
1584 },
77eed219 1585 }},
4d43e13f
PB		 1586 },
1587 },
1588 .power_ctrl = cxusb_bluebird_power_ctrl,
1589
1590 .i2c_algo = &cxusb_i2c_algo,
6f447259 1591
f72a27b8
MCC		 1592 .rc.legacy = {
1593 .rc_interval = 100,
2f4f58d6
MCC		 1594 .rc_map_table = rc_map_dvico_portable_table,
1595 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
f72a27b8
MCC		 1596 .rc_query = cxusb_rc_query,
1597 },
4d43e13f
PB		 1598
1599 .generic_bulk_ctrl_endpoint = 0x01,
6f447259
MK		 1600 .num_device_descs = 1,
1601 .devices = {
1602 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1603 { &cxusb_table[5], NULL },
1604 { &cxusb_table[6], NULL },
1605 },
1606 }
1607};
1608
4d43e13f 1609static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
6f447259
MK		 1610 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1611
1612 .usb_ctrl = DEVICE_SPECIFIC,
1613 .firmware = "dvb-usb-bluebird-01.fw",
1614 .download_firmware = bluebird_patch_dvico_firmware_download,
1615 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1616 use usb alt setting 7 for EP2 transfer (atsc) */
1617
1618 .size_of_priv = sizeof(struct cxusb_state),
1619
4d43e13f
PB		 1620 .num_adapters = 1,
1621 .adapter = {
1622 {
77eed219
MK		 1623 .num_frontends = 1,
1624 .fe = {{
01451e72
PB		 1625 .streaming_ctrl = cxusb_streaming_ctrl,
1626 .frontend_attach = cxusb_mt352_frontend_attach,
1627 .tuner_attach = cxusb_dtt7579_tuner_attach,
6f447259 1628
01451e72 1629 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 1630 .stream = {
1631 .type = USB_BULK,
01451e72
PB		 1632 .count = 5,
1633 .endpoint = 0x04,
1634 .u = {
1635 .bulk = {
1636 .buffersize = 8192,
1637 }
1638 }
1639 },
77eed219 1640 }},
4d43e13f
PB		 1641 },
1642 },
1643 .power_ctrl = cxusb_bluebird_power_ctrl,
1644
1645 .i2c_algo = &cxusb_i2c_algo,
1646
f72a27b8
MCC		 1647 .rc.legacy = {
1648 .rc_interval = 100,
2f4f58d6
MCC		 1649 .rc_map_table = rc_map_dvico_portable_table,
1650 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
f72a27b8
MCC		 1651 .rc_query = cxusb_rc_query,
1652 },
4d43e13f
PB		 1653
1654 .generic_bulk_ctrl_endpoint = 0x01,
6f447259
MK		 1655
1656 .num_device_descs = 1,
1657 .devices = {
1658 { "DViCO FusionHDTV DVB-T USB (TH7579)",
1659 { &cxusb_table[7], NULL },
1660 { &cxusb_table[8], NULL },
1661 },
1662 }
1663};
1664
aeb012bb
CP		 1665static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1666 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1667
1668 .usb_ctrl = CYPRESS_FX2,
1669
1670 .size_of_priv = sizeof(struct cxusb_state),
1671
1672 .num_adapters = 1,
1673 .adapter = {
1674 {
77eed219
MK		 1675 .num_frontends = 1,
1676 .fe = {{
aeb012bb
CP		 1677 .streaming_ctrl = cxusb_streaming_ctrl,
1678 .frontend_attach = cxusb_dualdig4_frontend_attach,
1679 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1680 /* parameter for the MPEG2-data transfer */
1681 .stream = {
1682 .type = USB_BULK,
1683 .count = 5,
1684 .endpoint = 0x02,
1685 .u = {
1686 .bulk = {
1687 .buffersize = 8192,
1688 }
1689 }
1690 },
77eed219 1691 }},
aeb012bb
CP		 1692 },
1693 },
1694
1695 .power_ctrl = cxusb_power_ctrl,
1696
1697 .i2c_algo = &cxusb_i2c_algo,
1698
1699 .generic_bulk_ctrl_endpoint = 0x01,
1700
f72a27b8
MCC		 1701 .rc.legacy = {
1702 .rc_interval = 100,
2f4f58d6
MCC		 1703 .rc_map_table = rc_map_dvico_mce_table,
1704 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
f72a27b8
MCC		 1705 .rc_query = cxusb_bluebird2_rc_query,
1706 },
aeb012bb
CP		 1707
1708 .num_device_descs = 1,
1709 .devices = {
1710 { "DViCO FusionHDTV DVB-T Dual Digital 4",
1711 { NULL },
1712 { &cxusb_table[13], NULL },
1713 },
1714 }
1715};
1716
5ccaf905
CP		 1717static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1718 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1719
1720 .usb_ctrl = CYPRESS_FX2,
702a6762 1721 .identify_state = bluebird_fx2_identify_state,
5ccaf905
CP		 1722
1723 .size_of_priv = sizeof(struct cxusb_state),
1724
1725 .num_adapters = 1,
1726 .adapter = {
1727 {
77eed219
MK		 1728 .num_frontends = 1,
1729 .fe = {{
5ccaf905
CP		 1730 .streaming_ctrl = cxusb_streaming_ctrl,
1731 .frontend_attach = cxusb_nano2_frontend_attach,
1732 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1733 /* parameter for the MPEG2-data transfer */
1734 .stream = {
1735 .type = USB_BULK,
1736 .count = 5,
1737 .endpoint = 0x02,
1738 .u = {
1739 .bulk = {
1740 .buffersize = 8192,
1741 }
1742 }
1743 },
77eed219 1744 }},
5ccaf905
CP		 1745 },
1746 },
1747
1748 .power_ctrl = cxusb_nano2_power_ctrl,
1749
1750 .i2c_algo = &cxusb_i2c_algo,
1751
1752 .generic_bulk_ctrl_endpoint = 0x01,
1753
f72a27b8
MCC		 1754 .rc.legacy = {
1755 .rc_interval = 100,
2f4f58d6
MCC		 1756 .rc_map_table = rc_map_dvico_portable_table,
1757 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
f72a27b8
MCC		 1758 .rc_query = cxusb_bluebird2_rc_query,
1759 },
5ccaf905
CP		 1760
1761 .num_device_descs = 1,
1762 .devices = {
1763 { "DViCO FusionHDTV DVB-T NANO2",
1764 { NULL },
1765 { &cxusb_table[14], NULL },
1766 },
1767 }
1768};
1769
702a6762
CP		 1770static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1771 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1772
1773 .usb_ctrl = DEVICE_SPECIFIC,
1774 .firmware = "dvb-usb-bluebird-02.fw",
1775 .download_firmware = bluebird_patch_dvico_firmware_download,
1776 .identify_state = bluebird_fx2_identify_state,
1777
1778 .size_of_priv = sizeof(struct cxusb_state),
1779
1780 .num_adapters = 1,
1781 .adapter = {
1782 {
77eed219
MK		 1783 .num_frontends = 1,
1784 .fe = {{
702a6762
CP		 1785 .streaming_ctrl = cxusb_streaming_ctrl,
1786 .frontend_attach = cxusb_nano2_frontend_attach,
1787 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1788 /* parameter for the MPEG2-data transfer */
1789 .stream = {
1790 .type = USB_BULK,
1791 .count = 5,
1792 .endpoint = 0x02,
1793 .u = {
1794 .bulk = {
1795 .buffersize = 8192,
1796 }
1797 }
1798 },
77eed219 1799 }},
702a6762
CP		 1800 },
1801 },
1802
1803 .power_ctrl = cxusb_nano2_power_ctrl,
1804
1805 .i2c_algo = &cxusb_i2c_algo,
1806
1807 .generic_bulk_ctrl_endpoint = 0x01,
1808
f72a27b8
MCC		 1809 .rc.legacy = {
1810 .rc_interval = 100,
2f4f58d6
MCC		 1811 .rc_map_table = rc_map_dvico_portable_table,
1812 .rc_map_size = ARRAY_SIZE(rc_map_dvico_portable_table),
f72a27b8
MCC		 1813 .rc_query = cxusb_rc_query,
1814 },
702a6762
CP		 1815
1816 .num_device_descs = 1,
1817 .devices = {
1818 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
1819 { &cxusb_table[14], NULL },
1820 { &cxusb_table[15], NULL },
1821 },
1822 }
1823};
1824
f5376ada
DG		 1825static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
1826 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1827
1828 .usb_ctrl = CYPRESS_FX2,
1829
1830 .size_of_priv = sizeof(struct cxusb_state),
1831
1832 .num_adapters = 1,
1833 .adapter = {
1834 {
77eed219
MK		 1835 .num_frontends = 1,
1836 .fe = {{
f5376ada
DG		 1837 .streaming_ctrl = cxusb_aver_streaming_ctrl,
1838 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
1839 .tuner_attach = cxusb_mxl5003s_tuner_attach,
1840 /* parameter for the MPEG2-data transfer */
1841 .stream = {
1842 .type = USB_BULK,
1843 .count = 5,
1844 .endpoint = 0x04,
1845 .u = {
1846 .bulk = {
1847 .buffersize = 8192,
1848 }
1849 }
1850 },
77eed219 1851 }},
f5376ada
DG		 1852 },
1853 },
1854 .power_ctrl = cxusb_aver_power_ctrl,
1855
1856 .i2c_algo = &cxusb_i2c_algo,
1857
1858 .generic_bulk_ctrl_endpoint = 0x01,
1859
1860 .num_device_descs = 1,
1861 .devices = {
1862 { "AVerMedia AVerTVHD Volar (A868R)",
1863 { NULL },
1864 { &cxusb_table[16], NULL },
1865 },
1866 }
1867};
1868
a2dc86b6
MK		 1869static
1870struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
8d798988
AB		 1871 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1872
1873 .usb_ctrl = CYPRESS_FX2,
1874
1875 .size_of_priv = sizeof(struct cxusb_state),
1876
1877 .num_adapters = 1,
1878 .adapter = {
1879 {
77eed219
MK		 1880 .size_of_priv = sizeof(struct dib0700_adapter_state),
1881 .num_frontends = 1,
1882 .fe = {{
a2dc86b6
MK		 1883 .streaming_ctrl = cxusb_streaming_ctrl,
1884 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
1885 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach,
8d798988
AB		 1886 /* parameter for the MPEG2-data transfer */
1887 .stream = {
1888 .type = USB_BULK,
1889 .count = 7,
1890 .endpoint = 0x02,
1891 .u = {
1892 .bulk = {
1893 .buffersize = 4096,
1894 }
1895 }
1896 },
77eed219 1897 }},
8d798988
AB		 1898 },
1899 },
1900
1901 .power_ctrl = cxusb_bluebird_power_ctrl,
1902
1903 .i2c_algo = &cxusb_i2c_algo,
1904
1905 .generic_bulk_ctrl_endpoint = 0x01,
1906
f72a27b8
MCC		 1907 .rc.legacy = {
1908 .rc_interval = 100,
2f4f58d6
MCC		 1909 .rc_map_table = rc_map_dvico_mce_table,
1910 .rc_map_size = ARRAY_SIZE(rc_map_dvico_mce_table),
f72a27b8
MCC		 1911 .rc_query = cxusb_rc_query,
1912 },
8d798988
AB		 1913
1914 .num_device_descs = 1,
1915 .devices = {
1916 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
1917 { NULL },
1918 { &cxusb_table[17], NULL },
1919 },
1920 }
1921};
1922
dfbdce04
TL		 1923static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
1924 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1925
1926 .usb_ctrl = CYPRESS_FX2,
1927
1928 .size_of_priv = sizeof(struct cxusb_state),
1929
1930 .num_adapters = 1,
1931 .adapter = {
1932 {
77eed219
MK		 1933 .num_frontends = 1,
1934 .fe = {{
dfbdce04
TL		 1935 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
1936 .frontend_attach = cxusb_d680_dmb_frontend_attach,
1937 .tuner_attach = cxusb_d680_dmb_tuner_attach,
1938
1939 /* parameter for the MPEG2-data transfer */
1940 .stream = {
1941 .type = USB_BULK,
1942 .count = 5,
1943 .endpoint = 0x02,
1944 .u = {
1945 .bulk = {
1946 .buffersize = 8192,
1947 }
1948 }
1949 },
77eed219 1950 }},
dfbdce04
TL		 1951 },
1952 },
1953
1954 .power_ctrl = cxusb_d680_dmb_power_ctrl,
1955
1956 .i2c_algo = &cxusb_i2c_algo,
1957
1958 .generic_bulk_ctrl_endpoint = 0x01,
1959
f72a27b8
MCC		 1960 .rc.legacy = {
1961 .rc_interval = 100,
2f4f58d6
MCC		 1962 .rc_map_table = rc_map_d680_dmb_table,
1963 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
f72a27b8
MCC		 1964 .rc_query = cxusb_d680_dmb_rc_query,
1965 },
dfbdce04
TL		 1966
1967 .num_device_descs = 1,
1968 .devices = {
1969 {
1970 "Conexant DMB-TH Stick",
1971 { NULL },
1972 { &cxusb_table[18], NULL },
1973 },
1974 }
1975};
1976
b18bd1d8
DW		 1977static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
1978 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1979
1980 .usb_ctrl = CYPRESS_FX2,
1981
1982 .size_of_priv = sizeof(struct cxusb_state),
1983
1984 .num_adapters = 1,
1985 .adapter = {
1986 {
77eed219
MK		 1987 .num_frontends = 1,
1988 .fe = {{
b18bd1d8
DW		 1989 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
1990 .frontend_attach = cxusb_mygica_d689_frontend_attach,
1991 .tuner_attach = cxusb_mygica_d689_tuner_attach,
1992
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 },
77eed219 2004 }},
b18bd1d8
DW		 2005 },
2006 },
2007
2008 .power_ctrl = cxusb_d680_dmb_power_ctrl,
2009
2010 .i2c_algo = &cxusb_i2c_algo,
2011
2012 .generic_bulk_ctrl_endpoint = 0x01,
2013
f72a27b8
MCC		 2014 .rc.legacy = {
2015 .rc_interval = 100,
2f4f58d6
MCC		 2016 .rc_map_table = rc_map_d680_dmb_table,
2017 .rc_map_size = ARRAY_SIZE(rc_map_d680_dmb_table),
f72a27b8
MCC		 2018 .rc_query = cxusb_d680_dmb_rc_query,
2019 },
b18bd1d8
DW		 2020
2021 .num_device_descs = 1,
2022 .devices = {
2023 {
2024 "Mygica D689 DMB-TH",
2025 { NULL },
2026 { &cxusb_table[19], NULL },
2027 },
2028 }
2029};
2030
22c6d93a 2031static struct usb_driver cxusb_driver = {
63b5c1c4 2032 .name = "dvb_usb_cxusb",
22c6d93a 2033 .probe = cxusb_probe,
f35db23c 2034 .disconnect = dvb_usb_device_exit,
22c6d93a
PB		 2035 .id_table = cxusb_table,
2036};
2037
2038/* module stuff */
2039static int __init cxusb_module_init(void)
2040{
2041 int result;
2042 if ((result = usb_register(&cxusb_driver))) {
2043 err("usb_register failed. Error number %d",result);
2044 return result;
2045 }
2046
2047 return 0;
2048}
2049
2050static void __exit cxusb_module_exit(void)
2051{
2052 /* deregister this driver from the USB subsystem */
2053 usb_deregister(&cxusb_driver);
2054}
2055
2056module_init (cxusb_module_init);
2057module_exit (cxusb_module_exit);
2058
2059MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
5b9ed286 2060MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
f4efb4db 2061MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
22c6d93a
PB		 2062MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
2063MODULE_VERSION("1.0-alpha");
2064MODULE_LICENSE("GPL");
Ubuntu Artful kernel mirror