]> bbs.cooldavid.org Git - net-next-2.6.git/blame - drivers/media/dvb/dvb-usb/cxusb.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
[net-next-2.6.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{
350 struct usb_data_stream_properties *p = &d->props.adapter[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
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{
388 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
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
397 for (i = 0; i < d->props.rc_key_map_size; i++) {
2e365883
MCC		 398 if (rc5_custom(&keymap[i]) == ircode[2] &&
399 rc5_data(&keymap[i]) == ircode[3]) {
7c239703
CP		 400 *event = keymap[i].event;
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{
413 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
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_key_map_size; i++) {
2e365883
MCC		 426 if (rc5_custom(&keymap[i]) == ircode[1] &&
427 rc5_data(&keymap[i]) == ircode[2]) {
aeb012bb
CP		 428 *event = keymap[i].event;
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{
441 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
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_key_map_size; i++) {
2e365883
MCC		 452 if (rc5_custom(&keymap[i]) == ircode[0] &&
453 rc5_data(&keymap[i]) == ircode[1]) {
dfbdce04
TL		 454 *event = keymap[i].event;
455 *state = REMOTE_KEY_PRESSED;
456
457 return 0;
458 }
459 }
460
461 return 0;
462}
463
e27e971c 464static struct dvb_usb_rc_key ir_codes_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
e27e971c 512static struct dvb_usb_rc_key ir_codes_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
e27e971c 551static struct dvb_usb_rc_key ir_codes_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{
cb89cd33
MK		 728 dvb_attach(simple_tuner_attach, adap->fe,
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{
79a54cbd 736 dvb_attach(dvb_pll_attach, adap->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{
47a9991e 743 dvb_attach(dvb_pll_attach, adap->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{
79a54cbd 749 dvb_attach(dvb_pll_attach, adap->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{
827855d3
MK		 756 dvb_attach(simple_tuner_attach, adap->fe,
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
MK		 797 /* FIXME: generalize & move to common area */
798 adap->fe->callback = dvico_bluebird_xc2028_callback;
799
aeb012bb
CP		 800 fe = dvb_attach(xc2028_attach, adap->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
f5376ada
DG		 809static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
810{
811 dvb_attach(mxl5005s_attach, adap->fe,
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;
819 fe = dvb_attach(mxl5005s_attach, adap->fe,
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;
827 fe = dvb_attach(max2165_attach, adap->fe,
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
f35db23c
MK		 840 if ((adap->fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
841 &adap->dev->i2c_adap)) != NULL)
22c6d93a
PB		 842 return 0;
843
844 return -EIO;
845}
846
4d43e13f 847static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
effee033 848{
4d43e13f 849 if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
effee033
MK		 850 err("set interface failed");
851
4d43e13f 852 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
effee033 853
f35db23c
MK		 854 if ((adap->fe = dvb_attach(lgdt330x_attach, &cxusb_lgdt3303_config,
855 &adap->dev->i2c_adap)) != NULL)
effee033
MK		 856 return 0;
857
858 return -EIO;
859}
860
f5376ada
DG		 861static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
862{
863 adap->fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
864 &adap->dev->i2c_adap);
865 if (adap->fe != NULL)
866 return 0;
867
868 return -EIO;
869}
870
4d43e13f
PB		 871static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
872{
873 /* used in both lgz201 and th7579 */
874 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
6f447259
MK		 875 err("set interface failed");
876
4d43e13f 877 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
6f447259 878
f35db23c
MK		 879 if ((adap->fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
880 &adap->dev->i2c_adap)) != NULL)
6f447259
MK		 881 return 0;
882
883 return -EIO;
884}
885
4d43e13f 886static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
0029ee14 887{
4d43e13f 888 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
0029ee14
CP		 889 err("set interface failed");
890
4d43e13f 891 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
0029ee14 892
f35db23c
MK		 893 if (((adap->fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
894 &adap->dev->i2c_adap)) != NULL) ||
895 ((adap->fe = dvb_attach(zl10353_attach,
896 &cxusb_zl10353_dee1601_config,
897 &adap->dev->i2c_adap)) != NULL))
0029ee14
CP		 898 return 0;
899
900 return -EIO;
901}
902
aeb012bb
CP		 903static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
904{
905 u8 ircode[4];
906 int i;
907 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
908 .buf = ircode, .len = 4 };
909
910 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
911 err("set interface failed");
912
913 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
914
915 /* reset the tuner and demodulator */
916 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
917 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
918 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
919
920 if ((adap->fe = dvb_attach(zl10353_attach,
0bc35180 921 &cxusb_zl10353_xc3028_config_no_i2c_gate,
aeb012bb
CP		 922 &adap->dev->i2c_adap)) == NULL)
923 return -EIO;
924
925 /* try to determine if there is no IR decoder on the I2C bus */
926 for (i = 0; adap->dev->props.rc_key_map != NULL && i < 5; i++) {
927 msleep(20);
928 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
929 goto no_IR;
930 if (ircode[0] == 0 && ircode[1] == 0)
931 continue;
932 if (ircode[2] + ircode[3] != 0xff) {
933no_IR:
934 adap->dev->props.rc_key_map = NULL;
935 info("No IR receiver detected on this device.");
936 break;
937 }
938 }
939
940 return 0;
941}
942
8d798988
AB		 943static struct dibx000_agc_config dib7070_agc_config = {
944 .band_caps = BAND_UHF | BAND_VHF | BAND_LBAND | BAND_SBAND,
945
946 /*
947 * P_agc_use_sd_mod1=0, P_agc_use_sd_mod2=0, P_agc_freq_pwm_div=5,
948 * P_agc_inv_pwm1=0, P_agc_inv_pwm2=0, P_agc_inh_dc_rv_est=0,
949 * P_agc_time_est=3, P_agc_freeze=0, P_agc_nb_est=5, P_agc_write=0
950 */
951 .setup = (0 << 15) | (0 << 14) | (5 << 11) | (0 << 10) | (0 << 9) |
952 (0 << 8) | (3 << 5) | (0 << 4) | (5 << 1) | (0 << 0),
953 .inv_gain = 600,
954 .time_stabiliz = 10,
955 .alpha_level = 0,
956 .thlock = 118,
957 .wbd_inv = 0,
958 .wbd_ref = 3530,
959 .wbd_sel = 1,
960 .wbd_alpha = 5,
961 .agc1_max = 65535,
962 .agc1_min = 0,
963 .agc2_max = 65535,
964 .agc2_min = 0,
965 .agc1_pt1 = 0,
966 .agc1_pt2 = 40,
967 .agc1_pt3 = 183,
968 .agc1_slope1 = 206,
969 .agc1_slope2 = 255,
970 .agc2_pt1 = 72,
971 .agc2_pt2 = 152,
972 .agc2_slope1 = 88,
973 .agc2_slope2 = 90,
974 .alpha_mant = 17,
975 .alpha_exp = 27,
976 .beta_mant = 23,
977 .beta_exp = 51,
978 .perform_agc_softsplit = 0,
979};
980
981static struct dibx000_bandwidth_config dib7070_bw_config_12_mhz = {
982 .internal = 60000,
983 .sampling = 15000,
984 .pll_prediv = 1,
985 .pll_ratio = 20,
986 .pll_range = 3,
987 .pll_reset = 1,
988 .pll_bypass = 0,
989 .enable_refdiv = 0,
990 .bypclk_div = 0,
991 .IO_CLK_en_core = 1,
992 .ADClkSrc = 1,
993 .modulo = 2,
994 /* refsel, sel, freq_15k */
995 .sad_cfg = (3 << 14) | (1 << 12) | (524 << 0),
996 .ifreq = (0 << 25) | 0,
997 .timf = 20452225,
998 .xtal_hz = 12000000,
999};
1000
1001static struct dib7000p_config cxusb_dualdig4_rev2_config = {
1002 .output_mode = OUTMODE_MPEG2_PAR_GATED_CLK,
1003 .output_mpeg2_in_188_bytes = 1,
1004
1005 .agc_config_count = 1,
1006 .agc = &dib7070_agc_config,
1007 .bw = &dib7070_bw_config_12_mhz,
1008 .tuner_is_baseband = 1,
1009 .spur_protect = 1,
1010
1011 .gpio_dir = 0xfcef,
1012 .gpio_val = 0x0110,
1013
1014 .gpio_pwm_pos = DIB7000P_GPIO_DEFAULT_PWM_POS,
1015
1016 .hostbus_diversity = 1,
1017};
1018
1019static int cxusb_dualdig4_rev2_frontend_attach(struct dvb_usb_adapter *adap)
1020{
1021 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1022 err("set interface failed");
1023
1024 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1025
1026 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1027
30d81bb0 1028 if (dib7000p_i2c_enumeration(&adap->dev->i2c_adap, 1, 18,
a49ba167
PB		 1029 &cxusb_dualdig4_rev2_config) < 0) {
1030 printk(KERN_WARNING "Unable to enumerate dib7000p\n");
30d81bb0 1031 return -ENODEV;
a49ba167 1032 }
8d798988 1033
a2dc86b6
MK		 1034 adap->fe = dvb_attach(dib7000p_attach, &adap->dev->i2c_adap, 0x80,
1035 &cxusb_dualdig4_rev2_config);
1036 if (adap->fe == NULL)
8d798988
AB		 1037 return -EIO;
1038
1039 return 0;
1040}
1041
1042static int dib7070_tuner_reset(struct dvb_frontend *fe, int onoff)
1043{
1044 return dib7000p_set_gpio(fe, 8, 0, !onoff);
1045}
1046
1047static int dib7070_tuner_sleep(struct dvb_frontend *fe, int onoff)
1048{
1049 return 0;
1050}
1051
1052static struct dib0070_config dib7070p_dib0070_config = {
1053 .i2c_address = DEFAULT_DIB0070_I2C_ADDRESS,
1054 .reset = dib7070_tuner_reset,
1055 .sleep = dib7070_tuner_sleep,
1056 .clock_khz = 12000,
1057};
1058
1059struct dib0700_adapter_state {
1060 int (*set_param_save) (struct dvb_frontend *,
1061 struct dvb_frontend_parameters *);
1062};
1063
1064static int dib7070_set_param_override(struct dvb_frontend *fe,
1065 struct dvb_frontend_parameters *fep)
1066{
1067 struct dvb_usb_adapter *adap = fe->dvb->priv;
1068 struct dib0700_adapter_state *state = adap->priv;
1069
1070 u16 offset;
1071 u8 band = BAND_OF_FREQUENCY(fep->frequency/1000);
1072 switch (band) {
a2dc86b6
MK		 1073 case BAND_VHF: offset = 950; break;
1074 default:
1075 case BAND_UHF: offset = 550; break;
8d798988
AB		 1076 }
1077
1078 dib7000p_set_wbd_ref(fe, offset + dib0070_wbd_offset(fe));
1079
1080 return state->set_param_save(fe, fep);
1081}
1082
1083static int cxusb_dualdig4_rev2_tuner_attach(struct dvb_usb_adapter *adap)
1084{
1085 struct dib0700_adapter_state *st = adap->priv;
a2dc86b6
MK		 1086 struct i2c_adapter *tun_i2c =
1087 dib7000p_get_i2c_master(adap->fe,
1088 DIBX000_I2C_INTERFACE_TUNER, 1);
8d798988
AB		 1089
1090 if (dvb_attach(dib0070_attach, adap->fe, tun_i2c,
1091 &dib7070p_dib0070_config) == NULL)
1092 return -ENODEV;
1093
1094 st->set_param_save = adap->fe->ops.tuner_ops.set_params;
1095 adap->fe->ops.tuner_ops.set_params = dib7070_set_param_override;
1096 return 0;
1097}
1098
5ccaf905
CP		 1099static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
1100{
1101 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
1102 err("set interface failed");
1103
1104 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
1105
1106 /* reset the tuner and demodulator */
1107 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
1108 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
1109 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
1110
1111 if ((adap->fe = dvb_attach(zl10353_attach,
1112 &cxusb_zl10353_xc3028_config,
1113 &adap->dev->i2c_adap)) != NULL)
1114 return 0;
1115
702a6762
CP		 1116 if ((adap->fe = dvb_attach(mt352_attach,
1117 &cxusb_mt352_xc3028_config,
1118 &adap->dev->i2c_adap)) != NULL)
1119 return 0;
1120
5ccaf905
CP		 1121 return -EIO;
1122}
1123
6bf1a997
DW		 1124static struct lgs8gxx_config d680_lgs8gl5_cfg = {
1125 .prod = LGS8GXX_PROD_LGS8GL5,
dfbdce04 1126 .demod_address = 0x19,
6bf1a997
DW		 1127 .serial_ts = 0,
1128 .ts_clk_pol = 0,
1129 .ts_clk_gated = 1,
1130 .if_clk_freq = 30400, /* 30.4 MHz */
1131 .if_freq = 5725, /* 5.725 MHz */
1132 .if_neg_center = 0,
1133 .ext_adc = 0,
1134 .adc_signed = 0,
1135 .if_neg_edge = 0,
dfbdce04
TL		 1136};
1137
1138static int cxusb_d680_dmb_frontend_attach(struct dvb_usb_adapter *adap)
1139{
1140 struct dvb_usb_device *d = adap->dev;
1141 int n;
1142
1143 /* Select required USB configuration */
1144 if (usb_set_interface(d->udev, 0, 0) < 0)
1145 err("set interface failed");
1146
1147 /* Unblock all USB pipes */
1148 usb_clear_halt(d->udev,
1149 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1150 usb_clear_halt(d->udev,
1151 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1152 usb_clear_halt(d->udev,
1153 usb_rcvbulkpipe(d->udev, d->props.adapter[0].stream.endpoint));
1154
1155 /* Drain USB pipes to avoid hang after reboot */
1156 for (n = 0; n < 5; n++) {
1157 cxusb_d680_dmb_drain_message(d);
1158 cxusb_d680_dmb_drain_video(d);
1159 msleep(200);
1160 }
1161
1162 /* Reset the tuner */
1163 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1164 err("clear tuner gpio failed");
1165 return -EIO;
1166 }
1167 msleep(100);
1168 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1169 err("set tuner gpio failed");
1170 return -EIO;
1171 }
1172 msleep(100);
1173
1174 /* Attach frontend */
6bf1a997 1175 adap->fe = dvb_attach(lgs8gxx_attach, &d680_lgs8gl5_cfg, &d->i2c_adap);
dfbdce04
TL		 1176 if (adap->fe == NULL)
1177 return -EIO;
1178
1179 return 0;
1180}
1181
b18bd1d8
DW		 1182static struct atbm8830_config mygica_d689_atbm8830_cfg = {
1183 .prod = ATBM8830_PROD_8830,
1184 .demod_address = 0x40,
1185 .serial_ts = 0,
1186 .ts_sampling_edge = 1,
1187 .ts_clk_gated = 0,
1188 .osc_clk_freq = 30400, /* in kHz */
1189 .if_freq = 0, /* zero IF */
1190 .zif_swap_iq = 1,
c245c75c
DW		 1191 .agc_min = 0x2E,
1192 .agc_max = 0x90,
1193 .agc_hold_loop = 0,
b18bd1d8
DW		 1194};
1195
1196static int cxusb_mygica_d689_frontend_attach(struct dvb_usb_adapter *adap)
1197{
1198 struct dvb_usb_device *d = adap->dev;
b18bd1d8
DW		 1199
1200 /* Select required USB configuration */
1201 if (usb_set_interface(d->udev, 0, 0) < 0)
1202 err("set interface failed");
1203
1204 /* Unblock all USB pipes */
1205 usb_clear_halt(d->udev,
1206 usb_sndbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1207 usb_clear_halt(d->udev,
1208 usb_rcvbulkpipe(d->udev, d->props.generic_bulk_ctrl_endpoint));
1209 usb_clear_halt(d->udev,
1210 usb_rcvbulkpipe(d->udev, d->props.adapter[0].stream.endpoint));
1211
1212
1213 /* Reset the tuner */
1214 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 0) < 0) {
1215 err("clear tuner gpio failed");
1216 return -EIO;
1217 }
1218 msleep(100);
1219 if (cxusb_d680_dmb_gpio_tuner(d, 0x07, 1) < 0) {
1220 err("set tuner gpio failed");
1221 return -EIO;
1222 }
1223 msleep(100);
1224
1225 /* Attach frontend */
1226 adap->fe = dvb_attach(atbm8830_attach, &mygica_d689_atbm8830_cfg,
1227 &d->i2c_adap);
1228 if (adap->fe == NULL)
1229 return -EIO;
1230
1231 return 0;
1232}
1233
702a6762
CP		 1234/*
1235 * DViCO has shipped two devices with the same USB ID, but only one of them
1236 * needs a firmware download. Check the device class details to see if they
1237 * have non-default values to decide whether the device is actually cold or
1238 * not, and forget a match if it turns out we selected the wrong device.
1239 */
1240static int bluebird_fx2_identify_state(struct usb_device *udev,
1241 struct dvb_usb_device_properties *props,
1242 struct dvb_usb_device_description **desc,
1243 int *cold)
1244{
1245 int wascold = *cold;
1246
1247 *cold = udev->descriptor.bDeviceClass == 0xff &&
1248 udev->descriptor.bDeviceSubClass == 0xff &&
1249 udev->descriptor.bDeviceProtocol == 0xff;
1250
1251 if (*cold && !wascold)
1252 *desc = NULL;
1253
1254 return 0;
1255}
1256
f5373788
PB		 1257/*
1258 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
1259 * firmware file before download.
1260 */
1261
702a6762 1262static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
f35db23c
MK		 1263static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
1264 const struct firmware *fw)
f5373788 1265{
702a6762
CP		 1266 int pos;
1267
1268 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
1269 int idoff = dvico_firmware_id_offsets[pos];
f5373788 1270
702a6762
CP		 1271 if (fw->size < idoff + 4)
1272 continue;
f5373788 1273
702a6762
CP		 1274 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
1275 fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
e62f89f2
DW		 1276 struct firmware new_fw;
1277 u8 *new_fw_data = vmalloc(fw->size);
1278 int ret;
1279
1280 if (!new_fw_data)
1281 return -ENOMEM;
1282
1283 memcpy(new_fw_data, fw->data, fw->size);
1284 new_fw.size = fw->size;
1285 new_fw.data = new_fw_data;
1286
1287 new_fw_data[idoff + 2] =
702a6762 1288 le16_to_cpu(udev->descriptor.idProduct) + 1;
e62f89f2 1289 new_fw_data[idoff + 3] =
702a6762 1290 le16_to_cpu(udev->descriptor.idProduct) >> 8;
f5373788 1291
e62f89f2
DW		 1292 ret = usb_cypress_load_firmware(udev, &new_fw,
1293 CYPRESS_FX2);
1294 vfree(new_fw_data);
1295 return ret;
702a6762 1296 }
f5373788
PB		 1297 }
1298
1299 return -EINVAL;
1300}
1301
22c6d93a 1302/* DVB USB Driver stuff */
4d43e13f
PB		 1303static struct dvb_usb_device_properties cxusb_medion_properties;
1304static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
1305static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
1306static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
1307static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
aeb012bb 1308static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
8d798988 1309static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties;
5ccaf905 1310static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
702a6762 1311static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
f5376ada 1312static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
dfbdce04 1313static struct dvb_usb_device_properties cxusb_d680_dmb_properties;
b18bd1d8 1314static struct dvb_usb_device_properties cxusb_mygica_d689_properties;
22c6d93a
PB		 1315
1316static int cxusb_probe(struct usb_interface *intf,
f35db23c 1317 const struct usb_device_id *id)
22c6d93a 1318{
78e92006
JG		 1319 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
1320 THIS_MODULE, NULL, adapter_nr) ||
1321 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
1322 THIS_MODULE, NULL, adapter_nr) ||
1323 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
1324 THIS_MODULE, NULL, adapter_nr) ||
1325 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
1326 THIS_MODULE, NULL, adapter_nr) ||
1327 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
1328 THIS_MODULE, NULL, adapter_nr) ||
1329 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
1330 THIS_MODULE, NULL, adapter_nr) ||
1331 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
1332 THIS_MODULE, NULL, adapter_nr) ||
1333 0 == dvb_usb_device_init(intf,
1334 &cxusb_bluebird_nano2_needsfirmware_properties,
f5376ada
DG		 1335 THIS_MODULE, NULL, adapter_nr) ||
1336 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
1337 THIS_MODULE, NULL, adapter_nr) ||
8d798988
AB		 1338 0 == dvb_usb_device_init(intf,
1339 &cxusb_bluebird_dualdig4_rev2_properties,
1340 THIS_MODULE, NULL, adapter_nr) ||
dfbdce04
TL		 1341 0 == dvb_usb_device_init(intf, &cxusb_d680_dmb_properties,
1342 THIS_MODULE, NULL, adapter_nr) ||
b18bd1d8
DW		 1343 0 == dvb_usb_device_init(intf, &cxusb_mygica_d689_properties,
1344 THIS_MODULE, NULL, adapter_nr) ||
f5376ada 1345 0)
effee033 1346 return 0;
effee033
MK		 1347
1348 return -EINVAL;
22c6d93a
PB		 1349}
1350
1351static struct usb_device_id cxusb_table [] = {
f35db23c
MK		 1352 { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
1353 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
1354 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
1355 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
1356 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
1357 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
1358 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
1359 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
1360 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
1361 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
1362 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
1363 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
1364 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
aeb012bb 1365 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) },
5ccaf905 1366 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) },
702a6762 1367 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) },
f5376ada 1368 { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) },
8d798988 1369 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4_REV_2) },
dfbdce04 1370 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_CONEXANT_D680_DMB) },
b18bd1d8 1371 { USB_DEVICE(USB_VID_CONEXANT, USB_PID_MYGICA_D689) },
f35db23c 1372 {} /* Terminating entry */
22c6d93a
PB		 1373};
1374MODULE_DEVICE_TABLE (usb, cxusb_table);
1375
4d43e13f 1376static struct dvb_usb_device_properties cxusb_medion_properties = {
22c6d93a
PB		 1377 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1378
1379 .usb_ctrl = CYPRESS_FX2,
1380
1381 .size_of_priv = sizeof(struct cxusb_state),
1382
4d43e13f
PB		 1383 .num_adapters = 1,
1384 .adapter = {
1385 {
01451e72
PB		 1386 .streaming_ctrl = cxusb_streaming_ctrl,
1387 .frontend_attach = cxusb_cx22702_frontend_attach,
1388 .tuner_attach = cxusb_fmd1216me_tuner_attach,
1389 /* parameter for the MPEG2-data transfer */
1390 .stream = {
1391 .type = USB_BULK,
1392 .count = 5,
1393 .endpoint = 0x02,
1394 .u = {
1395 .bulk = {
1396 .buffersize = 8192,
1397 }
1398 }
1399 },
22c6d93a 1400
4d43e13f
PB		 1401 },
1402 },
1403 .power_ctrl = cxusb_power_ctrl,
1404
1405 .i2c_algo = &cxusb_i2c_algo,
1406
1407 .generic_bulk_ctrl_endpoint = 0x01,
1408
22c6d93a
PB		 1409 .num_device_descs = 1,
1410 .devices = {
1411 { "Medion MD95700 (MDUSBTV-HYBRID)",
1412 { NULL },
1413 { &cxusb_table[0], NULL },
1414 },
1415 }
1416};
1417
4d43e13f 1418static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
effee033
MK		 1419 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1420
f5373788
PB		 1421 .usb_ctrl = DEVICE_SPECIFIC,
1422 .firmware = "dvb-usb-bluebird-01.fw",
1423 .download_firmware = bluebird_patch_dvico_firmware_download,
37bdfa06
MK		 1424 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1425 use usb alt setting 7 for EP2 transfer (atsc) */
effee033
MK		 1426
1427 .size_of_priv = sizeof(struct cxusb_state),
1428
4d43e13f
PB		 1429 .num_adapters = 1,
1430 .adapter = {
1431 {
01451e72
PB		 1432 .streaming_ctrl = cxusb_streaming_ctrl,
1433 .frontend_attach = cxusb_lgdt3303_frontend_attach,
f71a56c1 1434 .tuner_attach = cxusb_lgh064f_tuner_attach,
01451e72
PB		 1435
1436 /* parameter for the MPEG2-data transfer */
1437 .stream = {
1438 .type = USB_BULK,
1439 .count = 5,
1440 .endpoint = 0x02,
1441 .u = {
1442 .bulk = {
1443 .buffersize = 8192,
1444 }
1445 }
1446 },
4d43e13f
PB		 1447 },
1448 },
1449
1450 .power_ctrl = cxusb_bluebird_power_ctrl,
1451
1452 .i2c_algo = &cxusb_i2c_algo,
1453
1454 .rc_interval = 100,
e27e971c
MCC		 1455 .rc_key_map = ir_codes_dvico_portable_table,
1456 .rc_key_map_size = ARRAY_SIZE(ir_codes_dvico_portable_table),
4d43e13f
PB		 1457 .rc_query = cxusb_rc_query,
1458
1459 .generic_bulk_ctrl_endpoint = 0x01,
effee033
MK		 1460
1461 .num_device_descs = 1,
1462 .devices = {
1463 { "DViCO FusionHDTV5 USB Gold",
1464 { &cxusb_table[1], NULL },
1465 { &cxusb_table[2], NULL },
1466 },
1467 }
1468};
1469
4d43e13f 1470static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
0029ee14
CP		 1471 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1472
f5373788
PB		 1473 .usb_ctrl = DEVICE_SPECIFIC,
1474 .firmware = "dvb-usb-bluebird-01.fw",
1475 .download_firmware = bluebird_patch_dvico_firmware_download,
0029ee14
CP		 1476 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1477 use usb alt setting 7 for EP2 transfer (atsc) */
1478
1479 .size_of_priv = sizeof(struct cxusb_state),
1480
4d43e13f
PB		 1481 .num_adapters = 1,
1482 .adapter = {
1483 {
01451e72
PB		 1484 .streaming_ctrl = cxusb_streaming_ctrl,
1485 .frontend_attach = cxusb_dee1601_frontend_attach,
1486 .tuner_attach = cxusb_dee1601_tuner_attach,
1487 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 1488 .stream = {
1489 .type = USB_BULK,
01451e72
PB		 1490 .count = 5,
1491 .endpoint = 0x04,
1492 .u = {
1493 .bulk = {
1494 .buffersize = 8192,
1495 }
1496 }
1497 },
4d43e13f
PB		 1498 },
1499 },
1500
1501 .power_ctrl = cxusb_bluebird_power_ctrl,
1502
1503 .i2c_algo = &cxusb_i2c_algo,
1504
1505 .rc_interval = 150,
e27e971c
MCC		 1506 .rc_key_map = ir_codes_dvico_mce_table,
1507 .rc_key_map_size = ARRAY_SIZE(ir_codes_dvico_mce_table),
4d43e13f
PB		 1508 .rc_query = cxusb_rc_query,
1509
1510 .generic_bulk_ctrl_endpoint = 0x01,
0029ee14 1511
587c03d1 1512 .num_device_descs = 3,
0029ee14
CP		 1513 .devices = {
1514 { "DViCO FusionHDTV DVB-T Dual USB",
1515 { &cxusb_table[3], NULL },
1516 { &cxusb_table[4], NULL },
1517 },
ac9ffb90
MK		 1518 { "DigitalNow DVB-T Dual USB",
1519 { &cxusb_table[9], NULL },
1520 { &cxusb_table[10], NULL },
1521 },
587c03d1
MK		 1522 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1523 { &cxusb_table[11], NULL },
1524 { &cxusb_table[12], NULL },
1525 },
0029ee14
CP		 1526 }
1527};
1528
4d43e13f 1529static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
6f447259
MK		 1530 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1531
1532 .usb_ctrl = DEVICE_SPECIFIC,
1533 .firmware = "dvb-usb-bluebird-01.fw",
1534 .download_firmware = bluebird_patch_dvico_firmware_download,
1535 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1536 use usb alt setting 7 for EP2 transfer (atsc) */
1537
1538 .size_of_priv = sizeof(struct cxusb_state),
1539
4d43e13f
PB		 1540 .num_adapters = 2,
1541 .adapter = {
1542 {
01451e72
PB		 1543 .streaming_ctrl = cxusb_streaming_ctrl,
1544 .frontend_attach = cxusb_mt352_frontend_attach,
1545 .tuner_attach = cxusb_lgz201_tuner_attach,
6f447259 1546
01451e72 1547 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 1548 .stream = {
1549 .type = USB_BULK,
01451e72
PB		 1550 .count = 5,
1551 .endpoint = 0x04,
1552 .u = {
1553 .bulk = {
1554 .buffersize = 8192,
1555 }
1556 }
1557 },
4d43e13f
PB		 1558 },
1559 },
1560 .power_ctrl = cxusb_bluebird_power_ctrl,
1561
1562 .i2c_algo = &cxusb_i2c_algo,
6f447259 1563
4d43e13f 1564 .rc_interval = 100,
e27e971c
MCC		 1565 .rc_key_map = ir_codes_dvico_portable_table,
1566 .rc_key_map_size = ARRAY_SIZE(ir_codes_dvico_portable_table),
4d43e13f
PB		 1567 .rc_query = cxusb_rc_query,
1568
1569 .generic_bulk_ctrl_endpoint = 0x01,
6f447259
MK		 1570 .num_device_descs = 1,
1571 .devices = {
1572 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1573 { &cxusb_table[5], NULL },
1574 { &cxusb_table[6], NULL },
1575 },
1576 }
1577};
1578
4d43e13f 1579static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
6f447259
MK		 1580 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1581
1582 .usb_ctrl = DEVICE_SPECIFIC,
1583 .firmware = "dvb-usb-bluebird-01.fw",
1584 .download_firmware = bluebird_patch_dvico_firmware_download,
1585 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1586 use usb alt setting 7 for EP2 transfer (atsc) */
1587
1588 .size_of_priv = sizeof(struct cxusb_state),
1589
4d43e13f
PB		 1590 .num_adapters = 1,
1591 .adapter = {
1592 {
01451e72
PB		 1593 .streaming_ctrl = cxusb_streaming_ctrl,
1594 .frontend_attach = cxusb_mt352_frontend_attach,
1595 .tuner_attach = cxusb_dtt7579_tuner_attach,
6f447259 1596
01451e72 1597 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 1598 .stream = {
1599 .type = USB_BULK,
01451e72
PB		 1600 .count = 5,
1601 .endpoint = 0x04,
1602 .u = {
1603 .bulk = {
1604 .buffersize = 8192,
1605 }
1606 }
1607 },
4d43e13f
PB		 1608 },
1609 },
1610 .power_ctrl = cxusb_bluebird_power_ctrl,
1611
1612 .i2c_algo = &cxusb_i2c_algo,
1613
1614 .rc_interval = 100,
e27e971c
MCC		 1615 .rc_key_map = ir_codes_dvico_portable_table,
1616 .rc_key_map_size = ARRAY_SIZE(ir_codes_dvico_portable_table),
4d43e13f
PB		 1617 .rc_query = cxusb_rc_query,
1618
1619 .generic_bulk_ctrl_endpoint = 0x01,
6f447259
MK		 1620
1621 .num_device_descs = 1,
1622 .devices = {
1623 { "DViCO FusionHDTV DVB-T USB (TH7579)",
1624 { &cxusb_table[7], NULL },
1625 { &cxusb_table[8], NULL },
1626 },
1627 }
1628};
1629
aeb012bb
CP		 1630static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1631 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1632
1633 .usb_ctrl = CYPRESS_FX2,
1634
1635 .size_of_priv = sizeof(struct cxusb_state),
1636
1637 .num_adapters = 1,
1638 .adapter = {
1639 {
1640 .streaming_ctrl = cxusb_streaming_ctrl,
1641 .frontend_attach = cxusb_dualdig4_frontend_attach,
1642 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1643 /* parameter for the MPEG2-data transfer */
1644 .stream = {
1645 .type = USB_BULK,
1646 .count = 5,
1647 .endpoint = 0x02,
1648 .u = {
1649 .bulk = {
1650 .buffersize = 8192,
1651 }
1652 }
1653 },
1654 },
1655 },
1656
1657 .power_ctrl = cxusb_power_ctrl,
1658
1659 .i2c_algo = &cxusb_i2c_algo,
1660
1661 .generic_bulk_ctrl_endpoint = 0x01,
1662
1663 .rc_interval = 100,
e27e971c
MCC		 1664 .rc_key_map = ir_codes_dvico_mce_table,
1665 .rc_key_map_size = ARRAY_SIZE(ir_codes_dvico_mce_table),
aeb012bb
CP		 1666 .rc_query = cxusb_bluebird2_rc_query,
1667
1668 .num_device_descs = 1,
1669 .devices = {
1670 { "DViCO FusionHDTV DVB-T Dual Digital 4",
1671 { NULL },
1672 { &cxusb_table[13], NULL },
1673 },
1674 }
1675};
1676
5ccaf905
CP		 1677static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1678 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1679
1680 .usb_ctrl = CYPRESS_FX2,
702a6762 1681 .identify_state = bluebird_fx2_identify_state,
5ccaf905
CP		 1682
1683 .size_of_priv = sizeof(struct cxusb_state),
1684
1685 .num_adapters = 1,
1686 .adapter = {
1687 {
1688 .streaming_ctrl = cxusb_streaming_ctrl,
1689 .frontend_attach = cxusb_nano2_frontend_attach,
1690 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1691 /* parameter for the MPEG2-data transfer */
1692 .stream = {
1693 .type = USB_BULK,
1694 .count = 5,
1695 .endpoint = 0x02,
1696 .u = {
1697 .bulk = {
1698 .buffersize = 8192,
1699 }
1700 }
1701 },
1702 },
1703 },
1704
1705 .power_ctrl = cxusb_nano2_power_ctrl,
1706
1707 .i2c_algo = &cxusb_i2c_algo,
1708
1709 .generic_bulk_ctrl_endpoint = 0x01,
1710
1711 .rc_interval = 100,
e27e971c
MCC		 1712 .rc_key_map = ir_codes_dvico_portable_table,
1713 .rc_key_map_size = ARRAY_SIZE(ir_codes_dvico_portable_table),
5ccaf905
CP		 1714 .rc_query = cxusb_bluebird2_rc_query,
1715
1716 .num_device_descs = 1,
1717 .devices = {
1718 { "DViCO FusionHDTV DVB-T NANO2",
1719 { NULL },
1720 { &cxusb_table[14], NULL },
1721 },
1722 }
1723};
1724
702a6762
CP		 1725static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1726 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1727
1728 .usb_ctrl = DEVICE_SPECIFIC,
1729 .firmware = "dvb-usb-bluebird-02.fw",
1730 .download_firmware = bluebird_patch_dvico_firmware_download,
1731 .identify_state = bluebird_fx2_identify_state,
1732
1733 .size_of_priv = sizeof(struct cxusb_state),
1734
1735 .num_adapters = 1,
1736 .adapter = {
1737 {
1738 .streaming_ctrl = cxusb_streaming_ctrl,
1739 .frontend_attach = cxusb_nano2_frontend_attach,
1740 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1741 /* parameter for the MPEG2-data transfer */
1742 .stream = {
1743 .type = USB_BULK,
1744 .count = 5,
1745 .endpoint = 0x02,
1746 .u = {
1747 .bulk = {
1748 .buffersize = 8192,
1749 }
1750 }
1751 },
1752 },
1753 },
1754
1755 .power_ctrl = cxusb_nano2_power_ctrl,
1756
1757 .i2c_algo = &cxusb_i2c_algo,
1758
1759 .generic_bulk_ctrl_endpoint = 0x01,
1760
1761 .rc_interval = 100,
e27e971c
MCC		 1762 .rc_key_map = ir_codes_dvico_portable_table,
1763 .rc_key_map_size = ARRAY_SIZE(ir_codes_dvico_portable_table),
702a6762
CP		 1764 .rc_query = cxusb_rc_query,
1765
1766 .num_device_descs = 1,
1767 .devices = {
1768 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
1769 { &cxusb_table[14], NULL },
1770 { &cxusb_table[15], NULL },
1771 },
1772 }
1773};
1774
f5376ada
DG		 1775static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
1776 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1777
1778 .usb_ctrl = CYPRESS_FX2,
1779
1780 .size_of_priv = sizeof(struct cxusb_state),
1781
1782 .num_adapters = 1,
1783 .adapter = {
1784 {
1785 .streaming_ctrl = cxusb_aver_streaming_ctrl,
1786 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
1787 .tuner_attach = cxusb_mxl5003s_tuner_attach,
1788 /* parameter for the MPEG2-data transfer */
1789 .stream = {
1790 .type = USB_BULK,
1791 .count = 5,
1792 .endpoint = 0x04,
1793 .u = {
1794 .bulk = {
1795 .buffersize = 8192,
1796 }
1797 }
1798 },
1799
1800 },
1801 },
1802 .power_ctrl = cxusb_aver_power_ctrl,
1803
1804 .i2c_algo = &cxusb_i2c_algo,
1805
1806 .generic_bulk_ctrl_endpoint = 0x01,
1807
1808 .num_device_descs = 1,
1809 .devices = {
1810 { "AVerMedia AVerTVHD Volar (A868R)",
1811 { NULL },
1812 { &cxusb_table[16], NULL },
1813 },
1814 }
1815};
1816
a2dc86b6
MK		 1817static
1818struct dvb_usb_device_properties cxusb_bluebird_dualdig4_rev2_properties = {
8d798988
AB		 1819 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1820
1821 .usb_ctrl = CYPRESS_FX2,
1822
1823 .size_of_priv = sizeof(struct cxusb_state),
1824
1825 .num_adapters = 1,
1826 .adapter = {
1827 {
a2dc86b6
MK		 1828 .streaming_ctrl = cxusb_streaming_ctrl,
1829 .frontend_attach = cxusb_dualdig4_rev2_frontend_attach,
1830 .tuner_attach = cxusb_dualdig4_rev2_tuner_attach,
1831 .size_of_priv = sizeof(struct dib0700_adapter_state),
8d798988
AB		 1832 /* parameter for the MPEG2-data transfer */
1833 .stream = {
1834 .type = USB_BULK,
1835 .count = 7,
1836 .endpoint = 0x02,
1837 .u = {
1838 .bulk = {
1839 .buffersize = 4096,
1840 }
1841 }
1842 },
1843 },
1844 },
1845
1846 .power_ctrl = cxusb_bluebird_power_ctrl,
1847
1848 .i2c_algo = &cxusb_i2c_algo,
1849
1850 .generic_bulk_ctrl_endpoint = 0x01,
1851
1852 .rc_interval = 100,
e27e971c
MCC		 1853 .rc_key_map = ir_codes_dvico_mce_table,
1854 .rc_key_map_size = ARRAY_SIZE(ir_codes_dvico_mce_table),
8d798988
AB		 1855 .rc_query = cxusb_rc_query,
1856
1857 .num_device_descs = 1,
1858 .devices = {
1859 { "DViCO FusionHDTV DVB-T Dual Digital 4 (rev 2)",
1860 { NULL },
1861 { &cxusb_table[17], NULL },
1862 },
1863 }
1864};
1865
dfbdce04
TL		 1866static struct dvb_usb_device_properties cxusb_d680_dmb_properties = {
1867 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1868
1869 .usb_ctrl = CYPRESS_FX2,
1870
1871 .size_of_priv = sizeof(struct cxusb_state),
1872
1873 .num_adapters = 1,
1874 .adapter = {
1875 {
1876 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
1877 .frontend_attach = cxusb_d680_dmb_frontend_attach,
1878 .tuner_attach = cxusb_d680_dmb_tuner_attach,
1879
1880 /* parameter for the MPEG2-data transfer */
1881 .stream = {
1882 .type = USB_BULK,
1883 .count = 5,
1884 .endpoint = 0x02,
1885 .u = {
1886 .bulk = {
1887 .buffersize = 8192,
1888 }
1889 }
1890 },
1891 },
1892 },
1893
1894 .power_ctrl = cxusb_d680_dmb_power_ctrl,
1895
1896 .i2c_algo = &cxusb_i2c_algo,
1897
1898 .generic_bulk_ctrl_endpoint = 0x01,
1899
1900 .rc_interval = 100,
e27e971c
MCC		 1901 .rc_key_map = ir_codes_d680_dmb_table,
1902 .rc_key_map_size = ARRAY_SIZE(ir_codes_d680_dmb_table),
dfbdce04
TL		 1903 .rc_query = cxusb_d680_dmb_rc_query,
1904
1905 .num_device_descs = 1,
1906 .devices = {
1907 {
1908 "Conexant DMB-TH Stick",
1909 { NULL },
1910 { &cxusb_table[18], NULL },
1911 },
1912 }
1913};
1914
b18bd1d8
DW		 1915static struct dvb_usb_device_properties cxusb_mygica_d689_properties = {
1916 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1917
1918 .usb_ctrl = CYPRESS_FX2,
1919
1920 .size_of_priv = sizeof(struct cxusb_state),
1921
1922 .num_adapters = 1,
1923 .adapter = {
1924 {
1925 .streaming_ctrl = cxusb_d680_dmb_streaming_ctrl,
1926 .frontend_attach = cxusb_mygica_d689_frontend_attach,
1927 .tuner_attach = cxusb_mygica_d689_tuner_attach,
1928
1929 /* parameter for the MPEG2-data transfer */
1930 .stream = {
1931 .type = USB_BULK,
1932 .count = 5,
1933 .endpoint = 0x02,
1934 .u = {
1935 .bulk = {
1936 .buffersize = 8192,
1937 }
1938 }
1939 },
1940 },
1941 },
1942
1943 .power_ctrl = cxusb_d680_dmb_power_ctrl,
1944
1945 .i2c_algo = &cxusb_i2c_algo,
1946
1947 .generic_bulk_ctrl_endpoint = 0x01,
1948
1949 .rc_interval = 100,
e27e971c
MCC		 1950 .rc_key_map = ir_codes_d680_dmb_table,
1951 .rc_key_map_size = ARRAY_SIZE(ir_codes_d680_dmb_table),
b18bd1d8
DW		 1952 .rc_query = cxusb_d680_dmb_rc_query,
1953
1954 .num_device_descs = 1,
1955 .devices = {
1956 {
1957 "Mygica D689 DMB-TH",
1958 { NULL },
1959 { &cxusb_table[19], NULL },
1960 },
1961 }
1962};
1963
22c6d93a 1964static struct usb_driver cxusb_driver = {
63b5c1c4 1965 .name = "dvb_usb_cxusb",
22c6d93a 1966 .probe = cxusb_probe,
f35db23c 1967 .disconnect = dvb_usb_device_exit,
22c6d93a
PB		 1968 .id_table = cxusb_table,
1969};
1970
1971/* module stuff */
1972static int __init cxusb_module_init(void)
1973{
1974 int result;
1975 if ((result = usb_register(&cxusb_driver))) {
1976 err("usb_register failed. Error number %d",result);
1977 return result;
1978 }
1979
1980 return 0;
1981}
1982
1983static void __exit cxusb_module_exit(void)
1984{
1985 /* deregister this driver from the USB subsystem */
1986 usb_deregister(&cxusb_driver);
1987}
1988
1989module_init (cxusb_module_init);
1990module_exit (cxusb_module_exit);
1991
1992MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
5b9ed286 1993MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
f4efb4db 1994MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
22c6d93a
PB		 1995MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
1996MODULE_VERSION("1.0-alpha");
1997MODULE_LICENSE("GPL");
Clone of davem's net-next-2.6 tree