projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
V4L/DVB (8757): v4l-dvb: fix a bunch of sparse warnings
[deliverable/linux.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>
827855d3 28
22c6d93a
PB		 29#include "cxusb.h"
30
31#include "cx22702.h"
effee033 32#include "lgdt330x.h"
0029ee14
CP		 33#include "mt352.h"
34#include "mt352_priv.h"
c9ce3940 35#include "zl10353.h"
aeb012bb 36#include "tuner-xc2028.h"
827855d3 37#include "tuner-simple.h"
f5376ada 38#include "mxl5005s.h"
22c6d93a
PB		 39
40/* debug */
53133afb 41static int dvb_usb_cxusb_debug;
f35db23c 42module_param_named(debug, dvb_usb_cxusb_debug, int, 0644);
22c6d93a 43MODULE_PARM_DESC(debug, "set debugging level (1=rc (or-able))." DVB_USB_DEBUG_STATUS);
78e92006
JG		 44
45DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
46
f5376ada
DG		 47#define deb_info(args...) dprintk(dvb_usb_cxusb_debug, 0x03, args)
48#define deb_i2c(args...) dprintk(dvb_usb_cxusb_debug, 0x02, args)
22c6d93a
PB		 49
50static int cxusb_ctrl_msg(struct dvb_usb_device *d,
f35db23c 51 u8 cmd, u8 *wbuf, int wlen, u8 *rbuf, int rlen)
22c6d93a
PB		 52{
53 int wo = (rbuf == NULL || rlen == 0); /* write-only */
54 u8 sndbuf[1+wlen];
f35db23c 55 memset(sndbuf, 0, 1+wlen);
22c6d93a
PB		 56
57 sndbuf[0] = cmd;
f35db23c 58 memcpy(&sndbuf[1], wbuf, wlen);
22c6d93a 59 if (wo)
b17f109d 60 return dvb_usb_generic_write(d, sndbuf, 1+wlen);
22c6d93a 61 else
b17f109d 62 return dvb_usb_generic_rw(d, sndbuf, 1+wlen, rbuf, rlen, 0);
22c6d93a
PB		 63}
64
e2efeab2
PB		 65/* GPIO */
66static void cxusb_gpio_tuner(struct dvb_usb_device *d, int onoff)
22c6d93a
PB		 67{
68 struct cxusb_state *st = d->priv;
f35db23c 69 u8 o[2], i;
22c6d93a 70
e2efeab2 71 if (st->gpio_write_state[GPIO_TUNER] == onoff)
22c6d93a
PB		 72 return;
73
e2efeab2
PB		 74 o[0] = GPIO_TUNER;
75 o[1] = onoff;
f35db23c 76 cxusb_ctrl_msg(d, CMD_GPIO_WRITE, o, 2, &i, 1);
22c6d93a
PB		 77
78 if (i != 0x01)
e2efeab2 79 deb_info("gpio_write failed.\n");
22c6d93a 80
e2efeab2 81 st->gpio_write_state[GPIO_TUNER] = onoff;
22c6d93a
PB		 82}
83
aeb012bb
CP		 84static int cxusb_bluebird_gpio_rw(struct dvb_usb_device *d, u8 changemask,
85 u8 newval)
86{
87 u8 o[2], gpio_state;
88 int rc;
89
90 o[0] = 0xff & ~changemask; /* mask of bits to keep */
91 o[1] = newval & changemask; /* new values for bits */
92
93 rc = cxusb_ctrl_msg(d, CMD_BLUEBIRD_GPIO_RW, o, 2, &gpio_state, 1);
94 if (rc < 0 || (gpio_state & changemask) != (newval & changemask))
95 deb_info("bluebird_gpio_write failed.\n");
96
97 return rc < 0 ? rc : gpio_state;
98}
99
100static void cxusb_bluebird_gpio_pulse(struct dvb_usb_device *d, u8 pin, int low)
101{
102 cxusb_bluebird_gpio_rw(d, pin, low ? 0 : pin);
103 msleep(5);
104 cxusb_bluebird_gpio_rw(d, pin, low ? pin : 0);
105}
106
5ccaf905
CP		 107static void cxusb_nano2_led(struct dvb_usb_device *d, int onoff)
108{
109 cxusb_bluebird_gpio_rw(d, 0x40, onoff ? 0 : 0x40);
110}
111
e2efeab2 112/* I2C */
f35db23c
MK		 113static int cxusb_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
114 int num)
22c6d93a
PB		 115{
116 struct dvb_usb_device *d = i2c_get_adapdata(adap);
117 int i;
118
3593cab5 119 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
22c6d93a
PB		 120 return -EAGAIN;
121
22c6d93a
PB		 122 for (i = 0; i < num; i++) {
123
5e805eff
MK		 124 if (d->udev->descriptor.idVendor == USB_VID_MEDION)
125 switch (msg[i].addr) {
f35db23c
MK		 126 case 0x63:
127 cxusb_gpio_tuner(d, 0);
128 break;
129 default:
130 cxusb_gpio_tuner(d, 1);
131 break;
5e805eff 132 }
22c6d93a 133
272479d7
CP		 134 if (msg[i].flags & I2C_M_RD) {
135 /* read only */
136 u8 obuf[3], ibuf[1+msg[i].len];
137 obuf[0] = 0;
138 obuf[1] = msg[i].len;
139 obuf[2] = msg[i].addr;
140 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
141 obuf, 3,
142 ibuf, 1+msg[i].len) < 0) {
143 warn("i2c read failed");
144 break;
145 }
146 memcpy(msg[i].buf, &ibuf[1], msg[i].len);
a644e4a3
CP		 147 } else if (i+1 < num && (msg[i+1].flags & I2C_M_RD) &&
148 msg[i].addr == msg[i+1].addr) {
149 /* write to then read from same address */
22c6d93a
PB		 150 u8 obuf[3+msg[i].len], ibuf[1+msg[i+1].len];
151 obuf[0] = msg[i].len;
152 obuf[1] = msg[i+1].len;
153 obuf[2] = msg[i].addr;
f35db23c 154 memcpy(&obuf[3], msg[i].buf, msg[i].len);
22c6d93a
PB		 155
156 if (cxusb_ctrl_msg(d, CMD_I2C_READ,
f35db23c
MK		 157 obuf, 3+msg[i].len,
158 ibuf, 1+msg[i+1].len) < 0)
22c6d93a
PB		 159 break;
160
161 if (ibuf[0] != 0x08)
ae62e3d4 162 deb_i2c("i2c read may have failed\n");
22c6d93a 163
f35db23c 164 memcpy(msg[i+1].buf, &ibuf[1], msg[i+1].len);
22c6d93a
PB		 165
166 i++;
272479d7
CP		 167 } else {
168 /* write only */
22c6d93a
PB		 169 u8 obuf[2+msg[i].len], ibuf;
170 obuf[0] = msg[i].addr;
171 obuf[1] = msg[i].len;
f35db23c 172 memcpy(&obuf[2], msg[i].buf, msg[i].len);
22c6d93a 173
f35db23c
MK		 174 if (cxusb_ctrl_msg(d, CMD_I2C_WRITE, obuf,
175 2+msg[i].len, &ibuf,1) < 0)
22c6d93a
PB		 176 break;
177 if (ibuf != 0x08)
ae62e3d4 178 deb_i2c("i2c write may have failed\n");
22c6d93a
PB		 179 }
180 }
181
3593cab5 182 mutex_unlock(&d->i2c_mutex);
13e001df 183 return i == num ? num : -EREMOTEIO;
22c6d93a
PB		 184}
185
186static u32 cxusb_i2c_func(struct i2c_adapter *adapter)
187{
188 return I2C_FUNC_I2C;
189}
190
191static struct i2c_algorithm cxusb_i2c_algo = {
22c6d93a
PB		 192 .master_xfer = cxusb_i2c_xfer,
193 .functionality = cxusb_i2c_func,
194};
195
196static int cxusb_power_ctrl(struct dvb_usb_device *d, int onoff)
197{
e2efeab2
PB		 198 u8 b = 0;
199 if (onoff)
200 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
201 else
202 return cxusb_ctrl_msg(d, CMD_POWER_OFF, &b, 1, NULL, 0);
22c6d93a
PB		 203}
204
f5376ada
DG		 205static int cxusb_aver_power_ctrl(struct dvb_usb_device *d, int onoff)
206{
207 int ret;
208 if (!onoff)
209 return cxusb_ctrl_msg(d, CMD_POWER_OFF, NULL, 0, NULL, 0);
210 if (d->state == DVB_USB_STATE_INIT &&
211 usb_set_interface(d->udev, 0, 0) < 0)
212 err("set interface failed");
c6eb8eaf 213 do {} while (!(ret = cxusb_ctrl_msg(d, CMD_POWER_ON, NULL, 0, NULL, 0)) &&
f5376ada
DG		 214 !(ret = cxusb_ctrl_msg(d, 0x15, NULL, 0, NULL, 0)) &&
215 !(ret = cxusb_ctrl_msg(d, 0x17, NULL, 0, NULL, 0)) && 0);
216 if (!ret) {
217 /* FIXME: We don't know why, but we need to configure the
218 * lgdt3303 with the register settings below on resume */
219 int i;
220 u8 buf, bufs[] = {
221 0x0e, 0x2, 0x00, 0x7f,
222 0x0e, 0x2, 0x02, 0xfe,
223 0x0e, 0x2, 0x02, 0x01,
224 0x0e, 0x2, 0x00, 0x03,
225 0x0e, 0x2, 0x0d, 0x40,
226 0x0e, 0x2, 0x0e, 0x87,
227 0x0e, 0x2, 0x0f, 0x8e,
228 0x0e, 0x2, 0x10, 0x01,
229 0x0e, 0x2, 0x14, 0xd7,
230 0x0e, 0x2, 0x47, 0x88,
231 };
232 msleep(20);
233 for (i = 0; i < sizeof(bufs)/sizeof(u8); i += 4/sizeof(u8)) {
234 ret = cxusb_ctrl_msg(d, CMD_I2C_WRITE,
235 bufs+i, 4, &buf, 1);
236 if (ret)
237 break;
238 if (buf != 0x8)
239 return -EREMOTEIO;
240 }
241 }
242 return ret;
243}
244
5691c847
MK		 245static int cxusb_bluebird_power_ctrl(struct dvb_usb_device *d, int onoff)
246{
247 u8 b = 0;
248 if (onoff)
249 return cxusb_ctrl_msg(d, CMD_POWER_ON, &b, 1, NULL, 0);
250 else
251 return 0;
252}
253
5ccaf905
CP		 254static int cxusb_nano2_power_ctrl(struct dvb_usb_device *d, int onoff)
255{
256 int rc = 0;
257
258 rc = cxusb_power_ctrl(d, onoff);
259 if (!onoff)
260 cxusb_nano2_led(d, 0);
261
262 return rc;
263}
264
4d43e13f 265static int cxusb_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
22c6d93a 266{
8257e8a4
PB		 267 u8 buf[2] = { 0x03, 0x00 };
268 if (onoff)
4d43e13f 269 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_ON, buf, 2, NULL, 0);
8257e8a4 270 else
4d43e13f 271 cxusb_ctrl_msg(adap->dev, CMD_STREAMING_OFF, NULL, 0, NULL, 0);
8257e8a4 272
22c6d93a
PB		 273 return 0;
274}
275
f5376ada
DG		 276static int cxusb_aver_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
277{
278 if (onoff)
279 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_ON, NULL, 0, NULL, 0);
280 else
281 cxusb_ctrl_msg(adap->dev, CMD_AVER_STREAM_OFF,
282 NULL, 0, NULL, 0);
283 return 0;
284}
285
7c239703
CP		 286static int cxusb_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
287{
288 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
a07e6096 289 u8 ircode[4];
7c239703
CP		 290 int i;
291
a07e6096 292 cxusb_ctrl_msg(d, CMD_GET_IR_CODE, NULL, 0, ircode, 4);
7c239703
CP		 293
294 *event = 0;
295 *state = REMOTE_NO_KEY_PRESSED;
296
297 for (i = 0; i < d->props.rc_key_map_size; i++) {
a07e6096
MK		 298 if (keymap[i].custom == ircode[2] &&
299 keymap[i].data == ircode[3]) {
7c239703
CP		 300 *event = keymap[i].event;
301 *state = REMOTE_KEY_PRESSED;
302
303 return 0;
304 }
305 }
306
307 return 0;
308}
309
aeb012bb
CP		 310static int cxusb_bluebird2_rc_query(struct dvb_usb_device *d, u32 *event,
311 int *state)
312{
313 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
314 u8 ircode[4];
315 int i;
316 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
317 .buf = ircode, .len = 4 };
318
319 *event = 0;
320 *state = REMOTE_NO_KEY_PRESSED;
321
322 if (cxusb_i2c_xfer(&d->i2c_adap, &msg, 1) != 1)
323 return 0;
324
325 for (i = 0; i < d->props.rc_key_map_size; i++) {
326 if (keymap[i].custom == ircode[1] &&
327 keymap[i].data == ircode[2]) {
328 *event = keymap[i].event;
329 *state = REMOTE_KEY_PRESSED;
330
331 return 0;
332 }
333 }
334
335 return 0;
336}
337
703cb2cb 338static struct dvb_usb_rc_key dvico_mce_rc_keys[] = {
a07e6096
MK		 339 { 0xfe, 0x02, KEY_TV },
340 { 0xfe, 0x0e, KEY_MP3 },
341 { 0xfe, 0x1a, KEY_DVD },
342 { 0xfe, 0x1e, KEY_FAVORITES },
343 { 0xfe, 0x16, KEY_SETUP },
344 { 0xfe, 0x46, KEY_POWER2 },
345 { 0xfe, 0x0a, KEY_EPG },
346 { 0xfe, 0x49, KEY_BACK },
347 { 0xfe, 0x4d, KEY_MENU },
348 { 0xfe, 0x51, KEY_UP },
349 { 0xfe, 0x5b, KEY_LEFT },
350 { 0xfe, 0x5f, KEY_RIGHT },
351 { 0xfe, 0x53, KEY_DOWN },
352 { 0xfe, 0x5e, KEY_OK },
353 { 0xfe, 0x59, KEY_INFO },
354 { 0xfe, 0x55, KEY_TAB },
355 { 0xfe, 0x0f, KEY_PREVIOUSSONG },/* Replay */
356 { 0xfe, 0x12, KEY_NEXTSONG }, /* Skip */
357 { 0xfe, 0x42, KEY_ENTER }, /* Windows/Start */
358 { 0xfe, 0x15, KEY_VOLUMEUP },
359 { 0xfe, 0x05, KEY_VOLUMEDOWN },
360 { 0xfe, 0x11, KEY_CHANNELUP },
361 { 0xfe, 0x09, KEY_CHANNELDOWN },
362 { 0xfe, 0x52, KEY_CAMERA },
363 { 0xfe, 0x5a, KEY_TUNER }, /* Live */
364 { 0xfe, 0x19, KEY_OPEN },
365 { 0xfe, 0x0b, KEY_1 },
366 { 0xfe, 0x17, KEY_2 },
367 { 0xfe, 0x1b, KEY_3 },
368 { 0xfe, 0x07, KEY_4 },
369 { 0xfe, 0x50, KEY_5 },
370 { 0xfe, 0x54, KEY_6 },
371 { 0xfe, 0x48, KEY_7 },
372 { 0xfe, 0x4c, KEY_8 },
373 { 0xfe, 0x58, KEY_9 },
374 { 0xfe, 0x13, KEY_ANGLE }, /* Aspect */
375 { 0xfe, 0x03, KEY_0 },
376 { 0xfe, 0x1f, KEY_ZOOM },
377 { 0xfe, 0x43, KEY_REWIND },
378 { 0xfe, 0x47, KEY_PLAYPAUSE },
379 { 0xfe, 0x4f, KEY_FASTFORWARD },
380 { 0xfe, 0x57, KEY_MUTE },
381 { 0xfe, 0x0d, KEY_STOP },
382 { 0xfe, 0x01, KEY_RECORD },
383 { 0xfe, 0x4e, KEY_POWER },
384};
385
c150178b
MK		 386static struct dvb_usb_rc_key dvico_portable_rc_keys[] = {
387 { 0xfc, 0x02, KEY_SETUP }, /* Profile */
388 { 0xfc, 0x43, KEY_POWER2 },
389 { 0xfc, 0x06, KEY_EPG },
390 { 0xfc, 0x5a, KEY_BACK },
391 { 0xfc, 0x05, KEY_MENU },
392 { 0xfc, 0x47, KEY_INFO },
393 { 0xfc, 0x01, KEY_TAB },
394 { 0xfc, 0x42, KEY_PREVIOUSSONG },/* Replay */
395 { 0xfc, 0x49, KEY_VOLUMEUP },
396 { 0xfc, 0x09, KEY_VOLUMEDOWN },
397 { 0xfc, 0x54, KEY_CHANNELUP },
398 { 0xfc, 0x0b, KEY_CHANNELDOWN },
dbcb86ed 399 { 0xfc, 0x16, KEY_CAMERA },
c150178b
MK		 400 { 0xfc, 0x40, KEY_TUNER }, /* ATV/DTV */
401 { 0xfc, 0x45, KEY_OPEN },
402 { 0xfc, 0x19, KEY_1 },
403 { 0xfc, 0x18, KEY_2 },
404 { 0xfc, 0x1b, KEY_3 },
405 { 0xfc, 0x1a, KEY_4 },
406 { 0xfc, 0x58, KEY_5 },
407 { 0xfc, 0x59, KEY_6 },
408 { 0xfc, 0x15, KEY_7 },
409 { 0xfc, 0x14, KEY_8 },
410 { 0xfc, 0x17, KEY_9 },
411 { 0xfc, 0x44, KEY_ANGLE }, /* Aspect */
412 { 0xfc, 0x55, KEY_0 },
413 { 0xfc, 0x07, KEY_ZOOM },
414 { 0xfc, 0x0a, KEY_REWIND },
415 { 0xfc, 0x08, KEY_PLAYPAUSE },
416 { 0xfc, 0x4b, KEY_FASTFORWARD },
417 { 0xfc, 0x5b, KEY_MUTE },
418 { 0xfc, 0x04, KEY_STOP },
419 { 0xfc, 0x56, KEY_RECORD },
420 { 0xfc, 0x57, KEY_POWER },
421 { 0xfc, 0x41, KEY_UNKNOWN }, /* INPUT */
422 { 0xfc, 0x00, KEY_UNKNOWN }, /* HD */
423};
424
0029ee14
CP		 425static int cxusb_dee1601_demod_init(struct dvb_frontend* fe)
426{
d9ed881c 427 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x28 };
0029ee14
CP		 428 static u8 reset [] = { RESET, 0x80 };
429 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
430 static u8 agc_cfg [] = { AGC_TARGET, 0x28, 0x20 };
431 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
432 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
433
434 mt352_write(fe, clock_config, sizeof(clock_config));
435 udelay(200);
436 mt352_write(fe, reset, sizeof(reset));
437 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
438
439 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
440 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
441 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
442
443 return 0;
444}
445
6f447259
MK		 446static int cxusb_mt352_demod_init(struct dvb_frontend* fe)
447{ /* used in both lgz201 and th7579 */
fb51fd2d 448 static u8 clock_config [] = { CLOCK_CTL, 0x38, 0x29 };
6f447259
MK		 449 static u8 reset [] = { RESET, 0x80 };
450 static u8 adc_ctl_1_cfg [] = { ADC_CTL_1, 0x40 };
451 static u8 agc_cfg [] = { AGC_TARGET, 0x24, 0x20 };
452 static u8 gpp_ctl_cfg [] = { GPP_CTL, 0x33 };
453 static u8 capt_range_cfg[] = { CAPT_RANGE, 0x32 };
454
455 mt352_write(fe, clock_config, sizeof(clock_config));
456 udelay(200);
457 mt352_write(fe, reset, sizeof(reset));
458 mt352_write(fe, adc_ctl_1_cfg, sizeof(adc_ctl_1_cfg));
459
460 mt352_write(fe, agc_cfg, sizeof(agc_cfg));
461 mt352_write(fe, gpp_ctl_cfg, sizeof(gpp_ctl_cfg));
462 mt352_write(fe, capt_range_cfg, sizeof(capt_range_cfg));
463 return 0;
464}
465
703cb2cb 466static struct cx22702_config cxusb_cx22702_config = {
22c6d93a 467 .demod_address = 0x63,
8257e8a4 468 .output_mode = CX22702_PARALLEL_OUTPUT,
22c6d93a
PB		 469};
470
fddd632a 471static struct lgdt330x_config cxusb_lgdt3303_config = {
effee033
MK		 472 .demod_address = 0x0e,
473 .demod_chip = LGDT3303,
effee033
MK		 474};
475
f5376ada
DG		 476static struct lgdt330x_config cxusb_aver_lgdt3303_config = {
477 .demod_address = 0x0e,
478 .demod_chip = LGDT3303,
479 .clock_polarity_flip = 2,
480};
481
703cb2cb 482static struct mt352_config cxusb_dee1601_config = {
0029ee14
CP		 483 .demod_address = 0x0f,
484 .demod_init = cxusb_dee1601_demod_init,
0029ee14
CP		 485};
486
c9ce3940
MK		 487static struct zl10353_config cxusb_zl10353_dee1601_config = {
488 .demod_address = 0x0f,
8fb95784 489 .parallel_ts = 1,
c9ce3940
MK		 490};
491
6fe00b0e 492static struct mt352_config cxusb_mt352_config = {
6f447259
MK		 493 /* used in both lgz201 and th7579 */
494 .demod_address = 0x0f,
495 .demod_init = cxusb_mt352_demod_init,
6f447259
MK		 496};
497
aeb012bb
CP		 498static struct zl10353_config cxusb_zl10353_xc3028_config = {
499 .demod_address = 0x0f,
a1dcd9de 500 .if2 = 45600,
aeb012bb
CP		 501 .no_tuner = 1,
502 .parallel_ts = 1,
503};
504
702a6762
CP		 505static struct mt352_config cxusb_mt352_xc3028_config = {
506 .demod_address = 0x0f,
507 .if2 = 4560,
508 .no_tuner = 1,
509 .demod_init = cxusb_mt352_demod_init,
510};
511
f5376ada
DG		 512/* FIXME: needs tweaking */
513static struct mxl5005s_config aver_a868r_tuner = {
514 .i2c_address = 0x63,
515 .if_freq = 6000000UL,
516 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
517 .agc_mode = MXL_SINGLE_AGC,
518 .tracking_filter = MXL_TF_C,
519 .rssi_enable = MXL_RSSI_ENABLE,
520 .cap_select = MXL_CAP_SEL_ENABLE,
521 .div_out = MXL_DIV_OUT_4,
522 .clock_out = MXL_CLOCK_OUT_DISABLE,
523 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
524 .top = MXL5005S_TOP_25P2,
525 .mod_mode = MXL_DIGITAL_MODE,
526 .if_mode = MXL_ZERO_IF,
527 .AgcMasterByte = 0x00,
528};
529
22c6d93a 530/* Callbacks for DVB USB */
4d43e13f 531static int cxusb_fmd1216me_tuner_attach(struct dvb_usb_adapter *adap)
22c6d93a 532{
cb89cd33
MK		 533 dvb_attach(simple_tuner_attach, adap->fe,
534 &adap->dev->i2c_adap, 0x61,
535 TUNER_PHILIPS_FMD1216ME_MK3);
22c6d93a
PB		 536 return 0;
537}
538
4d43e13f 539static int cxusb_dee1601_tuner_attach(struct dvb_usb_adapter *adap)
0029ee14 540{
79a54cbd 541 dvb_attach(dvb_pll_attach, adap->fe, 0x61,
47a9991e 542 NULL, DVB_PLL_THOMSON_DTT7579);
0029ee14
CP		 543 return 0;
544}
545
4d43e13f 546static int cxusb_lgz201_tuner_attach(struct dvb_usb_adapter *adap)
6f447259 547{
47a9991e 548 dvb_attach(dvb_pll_attach, adap->fe, 0x61, NULL, DVB_PLL_LG_Z201);
6f447259
MK		 549 return 0;
550}
551
4d43e13f 552static int cxusb_dtt7579_tuner_attach(struct dvb_usb_adapter *adap)
6f447259 553{
79a54cbd 554 dvb_attach(dvb_pll_attach, adap->fe, 0x60,
47a9991e 555 NULL, DVB_PLL_THOMSON_DTT7579);
332bed5f
PB		 556 return 0;
557}
558
f71a56c1 559static int cxusb_lgh064f_tuner_attach(struct dvb_usb_adapter *adap)
332bed5f 560{
827855d3
MK		 561 dvb_attach(simple_tuner_attach, adap->fe,
562 &adap->dev->i2c_adap, 0x61, TUNER_LG_TDVS_H06XF);
6f447259
MK		 563 return 0;
564}
565
aeb012bb
CP		 566static int dvico_bluebird_xc2028_callback(void *ptr, int command, int arg)
567{
d483b730
RL		 568 struct dvb_usb_adapter *adap = ptr;
569 struct dvb_usb_device *d = adap->dev;
aeb012bb
CP		 570
571 switch (command) {
572 case XC2028_TUNER_RESET:
708bebdd 573 deb_info("%s: XC2028_TUNER_RESET %d\n", __func__, arg);
aeb012bb
CP		 574 cxusb_bluebird_gpio_pulse(d, 0x01, 1);
575 break;
576 case XC2028_RESET_CLK:
708bebdd 577 deb_info("%s: XC2028_RESET_CLK %d\n", __func__, arg);
aeb012bb
CP		 578 break;
579 default:
708bebdd 580 deb_info("%s: unknown command %d, arg %d\n", __func__,
aeb012bb
CP		 581 command, arg);
582 return -EINVAL;
583 }
584
585 return 0;
586}
587
588static int cxusb_dvico_xc3028_tuner_attach(struct dvb_usb_adapter *adap)
589{
590 struct dvb_frontend *fe;
591 struct xc2028_config cfg = {
592 .i2c_adap = &adap->dev->i2c_adap,
593 .i2c_addr = 0x61,
aeb012bb
CP		 594 .callback = dvico_bluebird_xc2028_callback,
595 };
596 static struct xc2028_ctrl ctl = {
d483b730 597 .fname = "xc3028-v27.fw",
aeb012bb 598 .max_len = 64,
d483b730 599 .demod = XC3028_FE_ZARLINK456,
aeb012bb
CP		 600 };
601
602 fe = dvb_attach(xc2028_attach, adap->fe, &cfg);
603 if (fe == NULL || fe->ops.tuner_ops.set_config == NULL)
604 return -EIO;
605
606 fe->ops.tuner_ops.set_config(fe, &ctl);
607
608 return 0;
609}
610
f5376ada
DG		 611static int cxusb_mxl5003s_tuner_attach(struct dvb_usb_adapter *adap)
612{
613 dvb_attach(mxl5005s_attach, adap->fe,
614 &adap->dev->i2c_adap, &aver_a868r_tuner);
615 return 0;
616}
617
4d43e13f 618static int cxusb_cx22702_frontend_attach(struct dvb_usb_adapter *adap)
22c6d93a 619{
e2efeab2 620 u8 b;
4d43e13f 621 if (usb_set_interface(adap->dev->udev, 0, 6) < 0)
8257e8a4 622 err("set interface failed");
22c6d93a 623
4d43e13f 624 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, &b, 1);
22c6d93a 625
f35db23c
MK		 626 if ((adap->fe = dvb_attach(cx22702_attach, &cxusb_cx22702_config,
627 &adap->dev->i2c_adap)) != NULL)
22c6d93a
PB		 628 return 0;
629
630 return -EIO;
631}
632
4d43e13f 633static int cxusb_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
effee033 634{
4d43e13f 635 if (usb_set_interface(adap->dev->udev, 0, 7) < 0)
effee033
MK		 636 err("set interface failed");
637
4d43e13f 638 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
effee033 639
f35db23c
MK		 640 if ((adap->fe = dvb_attach(lgdt330x_attach, &cxusb_lgdt3303_config,
641 &adap->dev->i2c_adap)) != NULL)
effee033
MK		 642 return 0;
643
644 return -EIO;
645}
646
f5376ada
DG		 647static int cxusb_aver_lgdt3303_frontend_attach(struct dvb_usb_adapter *adap)
648{
649 adap->fe = dvb_attach(lgdt330x_attach, &cxusb_aver_lgdt3303_config,
650 &adap->dev->i2c_adap);
651 if (adap->fe != NULL)
652 return 0;
653
654 return -EIO;
655}
656
4d43e13f
PB		 657static int cxusb_mt352_frontend_attach(struct dvb_usb_adapter *adap)
658{
659 /* used in both lgz201 and th7579 */
660 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
6f447259
MK		 661 err("set interface failed");
662
4d43e13f 663 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
6f447259 664
f35db23c
MK		 665 if ((adap->fe = dvb_attach(mt352_attach, &cxusb_mt352_config,
666 &adap->dev->i2c_adap)) != NULL)
6f447259
MK		 667 return 0;
668
669 return -EIO;
670}
671
4d43e13f 672static int cxusb_dee1601_frontend_attach(struct dvb_usb_adapter *adap)
0029ee14 673{
4d43e13f 674 if (usb_set_interface(adap->dev->udev, 0, 0) < 0)
0029ee14
CP		 675 err("set interface failed");
676
4d43e13f 677 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
0029ee14 678
f35db23c
MK		 679 if (((adap->fe = dvb_attach(mt352_attach, &cxusb_dee1601_config,
680 &adap->dev->i2c_adap)) != NULL) ||
681 ((adap->fe = dvb_attach(zl10353_attach,
682 &cxusb_zl10353_dee1601_config,
683 &adap->dev->i2c_adap)) != NULL))
0029ee14
CP		 684 return 0;
685
686 return -EIO;
687}
688
aeb012bb
CP		 689static int cxusb_dualdig4_frontend_attach(struct dvb_usb_adapter *adap)
690{
691 u8 ircode[4];
692 int i;
693 struct i2c_msg msg = { .addr = 0x6b, .flags = I2C_M_RD,
694 .buf = ircode, .len = 4 };
695
696 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
697 err("set interface failed");
698
699 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
700
701 /* reset the tuner and demodulator */
702 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
703 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
704 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
705
706 if ((adap->fe = dvb_attach(zl10353_attach,
707 &cxusb_zl10353_xc3028_config,
708 &adap->dev->i2c_adap)) == NULL)
709 return -EIO;
710
711 /* try to determine if there is no IR decoder on the I2C bus */
712 for (i = 0; adap->dev->props.rc_key_map != NULL && i < 5; i++) {
713 msleep(20);
714 if (cxusb_i2c_xfer(&adap->dev->i2c_adap, &msg, 1) != 1)
715 goto no_IR;
716 if (ircode[0] == 0 && ircode[1] == 0)
717 continue;
718 if (ircode[2] + ircode[3] != 0xff) {
719no_IR:
720 adap->dev->props.rc_key_map = NULL;
721 info("No IR receiver detected on this device.");
722 break;
723 }
724 }
725
726 return 0;
727}
728
5ccaf905
CP		 729static int cxusb_nano2_frontend_attach(struct dvb_usb_adapter *adap)
730{
731 if (usb_set_interface(adap->dev->udev, 0, 1) < 0)
732 err("set interface failed");
733
734 cxusb_ctrl_msg(adap->dev, CMD_DIGITAL, NULL, 0, NULL, 0);
735
736 /* reset the tuner and demodulator */
737 cxusb_bluebird_gpio_rw(adap->dev, 0x04, 0);
738 cxusb_bluebird_gpio_pulse(adap->dev, 0x01, 1);
739 cxusb_bluebird_gpio_pulse(adap->dev, 0x02, 1);
740
741 if ((adap->fe = dvb_attach(zl10353_attach,
742 &cxusb_zl10353_xc3028_config,
743 &adap->dev->i2c_adap)) != NULL)
744 return 0;
745
702a6762
CP		 746 if ((adap->fe = dvb_attach(mt352_attach,
747 &cxusb_mt352_xc3028_config,
748 &adap->dev->i2c_adap)) != NULL)
749 return 0;
750
5ccaf905
CP		 751 return -EIO;
752}
753
702a6762
CP		 754/*
755 * DViCO has shipped two devices with the same USB ID, but only one of them
756 * needs a firmware download. Check the device class details to see if they
757 * have non-default values to decide whether the device is actually cold or
758 * not, and forget a match if it turns out we selected the wrong device.
759 */
760static int bluebird_fx2_identify_state(struct usb_device *udev,
761 struct dvb_usb_device_properties *props,
762 struct dvb_usb_device_description **desc,
763 int *cold)
764{
765 int wascold = *cold;
766
767 *cold = udev->descriptor.bDeviceClass == 0xff &&
768 udev->descriptor.bDeviceSubClass == 0xff &&
769 udev->descriptor.bDeviceProtocol == 0xff;
770
771 if (*cold && !wascold)
772 *desc = NULL;
773
774 return 0;
775}
776
f5373788
PB		 777/*
778 * DViCO bluebird firmware needs the "warm" product ID to be patched into the
779 * firmware file before download.
780 */
781
702a6762 782static const int dvico_firmware_id_offsets[] = { 6638, 3204 };
f35db23c
MK		 783static int bluebird_patch_dvico_firmware_download(struct usb_device *udev,
784 const struct firmware *fw)
f5373788 785{
702a6762
CP		 786 int pos;
787
788 for (pos = 0; pos < ARRAY_SIZE(dvico_firmware_id_offsets); pos++) {
789 int idoff = dvico_firmware_id_offsets[pos];
f5373788 790
702a6762
CP		 791 if (fw->size < idoff + 4)
792 continue;
f5373788 793
702a6762
CP		 794 if (fw->data[idoff] == (USB_VID_DVICO & 0xff) &&
795 fw->data[idoff + 1] == USB_VID_DVICO >> 8) {
e62f89f2
DW		 796 struct firmware new_fw;
797 u8 *new_fw_data = vmalloc(fw->size);
798 int ret;
799
800 if (!new_fw_data)
801 return -ENOMEM;
802
803 memcpy(new_fw_data, fw->data, fw->size);
804 new_fw.size = fw->size;
805 new_fw.data = new_fw_data;
806
807 new_fw_data[idoff + 2] =
702a6762 808 le16_to_cpu(udev->descriptor.idProduct) + 1;
e62f89f2 809 new_fw_data[idoff + 3] =
702a6762 810 le16_to_cpu(udev->descriptor.idProduct) >> 8;
f5373788 811
e62f89f2
DW		 812 ret = usb_cypress_load_firmware(udev, &new_fw,
813 CYPRESS_FX2);
814 vfree(new_fw_data);
815 return ret;
702a6762 816 }
f5373788
PB		 817 }
818
819 return -EINVAL;
820}
821
22c6d93a 822/* DVB USB Driver stuff */
4d43e13f
PB		 823static struct dvb_usb_device_properties cxusb_medion_properties;
824static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties;
825static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties;
826static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties;
827static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties;
aeb012bb 828static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties;
5ccaf905 829static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties;
702a6762 830static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties;
f5376ada 831static struct dvb_usb_device_properties cxusb_aver_a868r_properties;
22c6d93a
PB		 832
833static int cxusb_probe(struct usb_interface *intf,
f35db23c 834 const struct usb_device_id *id)
22c6d93a 835{
78e92006
JG		 836 if (0 == dvb_usb_device_init(intf, &cxusb_medion_properties,
837 THIS_MODULE, NULL, adapter_nr) ||
838 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgh064f_properties,
839 THIS_MODULE, NULL, adapter_nr) ||
840 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dee1601_properties,
841 THIS_MODULE, NULL, adapter_nr) ||
842 0 == dvb_usb_device_init(intf, &cxusb_bluebird_lgz201_properties,
843 THIS_MODULE, NULL, adapter_nr) ||
844 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dtt7579_properties,
845 THIS_MODULE, NULL, adapter_nr) ||
846 0 == dvb_usb_device_init(intf, &cxusb_bluebird_dualdig4_properties,
847 THIS_MODULE, NULL, adapter_nr) ||
848 0 == dvb_usb_device_init(intf, &cxusb_bluebird_nano2_properties,
849 THIS_MODULE, NULL, adapter_nr) ||
850 0 == dvb_usb_device_init(intf,
851 &cxusb_bluebird_nano2_needsfirmware_properties,
f5376ada
DG		 852 THIS_MODULE, NULL, adapter_nr) ||
853 0 == dvb_usb_device_init(intf, &cxusb_aver_a868r_properties,
854 THIS_MODULE, NULL, adapter_nr) ||
855 0)
effee033 856 return 0;
effee033
MK		 857
858 return -EINVAL;
22c6d93a
PB		 859}
860
861static struct usb_device_id cxusb_table [] = {
f35db23c
MK		 862 { USB_DEVICE(USB_VID_MEDION, USB_PID_MEDION_MD95700) },
863 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_COLD) },
864 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LG064F_WARM) },
865 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_COLD) },
866 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_1_WARM) },
867 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_COLD) },
868 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_LGZ201_WARM) },
869 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_COLD) },
870 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_TH7579_WARM) },
871 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_COLD) },
872 { USB_DEVICE(USB_VID_DVICO, USB_PID_DIGITALNOW_BLUEBIRD_DUAL_1_WARM) },
873 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_COLD) },
874 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_2_WARM) },
aeb012bb 875 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DUAL_4) },
5ccaf905 876 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2) },
702a6762 877 { USB_DEVICE(USB_VID_DVICO, USB_PID_DVICO_BLUEBIRD_DVB_T_NANO_2_NFW_WARM) },
f5376ada 878 { USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_A868R) },
f35db23c 879 {} /* Terminating entry */
22c6d93a
PB		 880};
881MODULE_DEVICE_TABLE (usb, cxusb_table);
882
4d43e13f 883static struct dvb_usb_device_properties cxusb_medion_properties = {
22c6d93a
PB		 884 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
885
886 .usb_ctrl = CYPRESS_FX2,
887
888 .size_of_priv = sizeof(struct cxusb_state),
889
4d43e13f
PB		 890 .num_adapters = 1,
891 .adapter = {
892 {
01451e72
PB		 893 .streaming_ctrl = cxusb_streaming_ctrl,
894 .frontend_attach = cxusb_cx22702_frontend_attach,
895 .tuner_attach = cxusb_fmd1216me_tuner_attach,
896 /* parameter for the MPEG2-data transfer */
897 .stream = {
898 .type = USB_BULK,
899 .count = 5,
900 .endpoint = 0x02,
901 .u = {
902 .bulk = {
903 .buffersize = 8192,
904 }
905 }
906 },
22c6d93a 907
4d43e13f
PB		 908 },
909 },
910 .power_ctrl = cxusb_power_ctrl,
911
912 .i2c_algo = &cxusb_i2c_algo,
913
914 .generic_bulk_ctrl_endpoint = 0x01,
915
22c6d93a
PB		 916 .num_device_descs = 1,
917 .devices = {
918 { "Medion MD95700 (MDUSBTV-HYBRID)",
919 { NULL },
920 { &cxusb_table[0], NULL },
921 },
922 }
923};
924
4d43e13f 925static struct dvb_usb_device_properties cxusb_bluebird_lgh064f_properties = {
effee033
MK		 926 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
927
f5373788
PB		 928 .usb_ctrl = DEVICE_SPECIFIC,
929 .firmware = "dvb-usb-bluebird-01.fw",
930 .download_firmware = bluebird_patch_dvico_firmware_download,
37bdfa06
MK		 931 /* use usb alt setting 0 for EP4 transfer (dvb-t),
932 use usb alt setting 7 for EP2 transfer (atsc) */
effee033
MK		 933
934 .size_of_priv = sizeof(struct cxusb_state),
935
4d43e13f
PB		 936 .num_adapters = 1,
937 .adapter = {
938 {
01451e72
PB		 939 .streaming_ctrl = cxusb_streaming_ctrl,
940 .frontend_attach = cxusb_lgdt3303_frontend_attach,
f71a56c1 941 .tuner_attach = cxusb_lgh064f_tuner_attach,
01451e72
PB		 942
943 /* parameter for the MPEG2-data transfer */
944 .stream = {
945 .type = USB_BULK,
946 .count = 5,
947 .endpoint = 0x02,
948 .u = {
949 .bulk = {
950 .buffersize = 8192,
951 }
952 }
953 },
4d43e13f
PB		 954 },
955 },
956
957 .power_ctrl = cxusb_bluebird_power_ctrl,
958
959 .i2c_algo = &cxusb_i2c_algo,
960
961 .rc_interval = 100,
962 .rc_key_map = dvico_portable_rc_keys,
963 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
964 .rc_query = cxusb_rc_query,
965
966 .generic_bulk_ctrl_endpoint = 0x01,
effee033
MK		 967
968 .num_device_descs = 1,
969 .devices = {
970 { "DViCO FusionHDTV5 USB Gold",
971 { &cxusb_table[1], NULL },
972 { &cxusb_table[2], NULL },
973 },
974 }
975};
976
4d43e13f 977static struct dvb_usb_device_properties cxusb_bluebird_dee1601_properties = {
0029ee14
CP		 978 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
979
f5373788
PB		 980 .usb_ctrl = DEVICE_SPECIFIC,
981 .firmware = "dvb-usb-bluebird-01.fw",
982 .download_firmware = bluebird_patch_dvico_firmware_download,
0029ee14
CP		 983 /* use usb alt setting 0 for EP4 transfer (dvb-t),
984 use usb alt setting 7 for EP2 transfer (atsc) */
985
986 .size_of_priv = sizeof(struct cxusb_state),
987
4d43e13f
PB		 988 .num_adapters = 1,
989 .adapter = {
990 {
01451e72
PB		 991 .streaming_ctrl = cxusb_streaming_ctrl,
992 .frontend_attach = cxusb_dee1601_frontend_attach,
993 .tuner_attach = cxusb_dee1601_tuner_attach,
994 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 995 .stream = {
996 .type = USB_BULK,
01451e72
PB		 997 .count = 5,
998 .endpoint = 0x04,
999 .u = {
1000 .bulk = {
1001 .buffersize = 8192,
1002 }
1003 }
1004 },
4d43e13f
PB		 1005 },
1006 },
1007
1008 .power_ctrl = cxusb_bluebird_power_ctrl,
1009
1010 .i2c_algo = &cxusb_i2c_algo,
1011
1012 .rc_interval = 150,
1013 .rc_key_map = dvico_mce_rc_keys,
1014 .rc_key_map_size = ARRAY_SIZE(dvico_mce_rc_keys),
1015 .rc_query = cxusb_rc_query,
1016
1017 .generic_bulk_ctrl_endpoint = 0x01,
0029ee14 1018
587c03d1 1019 .num_device_descs = 3,
0029ee14
CP		 1020 .devices = {
1021 { "DViCO FusionHDTV DVB-T Dual USB",
1022 { &cxusb_table[3], NULL },
1023 { &cxusb_table[4], NULL },
1024 },
ac9ffb90
MK		 1025 { "DigitalNow DVB-T Dual USB",
1026 { &cxusb_table[9], NULL },
1027 { &cxusb_table[10], NULL },
1028 },
587c03d1
MK		 1029 { "DViCO FusionHDTV DVB-T Dual Digital 2",
1030 { &cxusb_table[11], NULL },
1031 { &cxusb_table[12], NULL },
1032 },
0029ee14
CP		 1033 }
1034};
1035
4d43e13f 1036static struct dvb_usb_device_properties cxusb_bluebird_lgz201_properties = {
6f447259
MK		 1037 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1038
1039 .usb_ctrl = DEVICE_SPECIFIC,
1040 .firmware = "dvb-usb-bluebird-01.fw",
1041 .download_firmware = bluebird_patch_dvico_firmware_download,
1042 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1043 use usb alt setting 7 for EP2 transfer (atsc) */
1044
1045 .size_of_priv = sizeof(struct cxusb_state),
1046
4d43e13f
PB		 1047 .num_adapters = 2,
1048 .adapter = {
1049 {
01451e72
PB		 1050 .streaming_ctrl = cxusb_streaming_ctrl,
1051 .frontend_attach = cxusb_mt352_frontend_attach,
1052 .tuner_attach = cxusb_lgz201_tuner_attach,
6f447259 1053
01451e72 1054 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 1055 .stream = {
1056 .type = USB_BULK,
01451e72
PB		 1057 .count = 5,
1058 .endpoint = 0x04,
1059 .u = {
1060 .bulk = {
1061 .buffersize = 8192,
1062 }
1063 }
1064 },
4d43e13f
PB		 1065 },
1066 },
1067 .power_ctrl = cxusb_bluebird_power_ctrl,
1068
1069 .i2c_algo = &cxusb_i2c_algo,
6f447259 1070
4d43e13f
PB		 1071 .rc_interval = 100,
1072 .rc_key_map = dvico_portable_rc_keys,
1073 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1074 .rc_query = cxusb_rc_query,
1075
1076 .generic_bulk_ctrl_endpoint = 0x01,
6f447259
MK		 1077 .num_device_descs = 1,
1078 .devices = {
1079 { "DViCO FusionHDTV DVB-T USB (LGZ201)",
1080 { &cxusb_table[5], NULL },
1081 { &cxusb_table[6], NULL },
1082 },
1083 }
1084};
1085
4d43e13f 1086static struct dvb_usb_device_properties cxusb_bluebird_dtt7579_properties = {
6f447259
MK		 1087 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1088
1089 .usb_ctrl = DEVICE_SPECIFIC,
1090 .firmware = "dvb-usb-bluebird-01.fw",
1091 .download_firmware = bluebird_patch_dvico_firmware_download,
1092 /* use usb alt setting 0 for EP4 transfer (dvb-t),
1093 use usb alt setting 7 for EP2 transfer (atsc) */
1094
1095 .size_of_priv = sizeof(struct cxusb_state),
1096
4d43e13f
PB		 1097 .num_adapters = 1,
1098 .adapter = {
1099 {
01451e72
PB		 1100 .streaming_ctrl = cxusb_streaming_ctrl,
1101 .frontend_attach = cxusb_mt352_frontend_attach,
1102 .tuner_attach = cxusb_dtt7579_tuner_attach,
6f447259 1103
01451e72 1104 /* parameter for the MPEG2-data transfer */
4d43e13f
PB		 1105 .stream = {
1106 .type = USB_BULK,
01451e72
PB		 1107 .count = 5,
1108 .endpoint = 0x04,
1109 .u = {
1110 .bulk = {
1111 .buffersize = 8192,
1112 }
1113 }
1114 },
4d43e13f
PB		 1115 },
1116 },
1117 .power_ctrl = cxusb_bluebird_power_ctrl,
1118
1119 .i2c_algo = &cxusb_i2c_algo,
1120
1121 .rc_interval = 100,
1122 .rc_key_map = dvico_portable_rc_keys,
1123 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1124 .rc_query = cxusb_rc_query,
1125
1126 .generic_bulk_ctrl_endpoint = 0x01,
6f447259
MK		 1127
1128 .num_device_descs = 1,
1129 .devices = {
1130 { "DViCO FusionHDTV DVB-T USB (TH7579)",
1131 { &cxusb_table[7], NULL },
1132 { &cxusb_table[8], NULL },
1133 },
1134 }
1135};
1136
aeb012bb
CP		 1137static struct dvb_usb_device_properties cxusb_bluebird_dualdig4_properties = {
1138 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1139
1140 .usb_ctrl = CYPRESS_FX2,
1141
1142 .size_of_priv = sizeof(struct cxusb_state),
1143
1144 .num_adapters = 1,
1145 .adapter = {
1146 {
1147 .streaming_ctrl = cxusb_streaming_ctrl,
1148 .frontend_attach = cxusb_dualdig4_frontend_attach,
1149 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1150 /* parameter for the MPEG2-data transfer */
1151 .stream = {
1152 .type = USB_BULK,
1153 .count = 5,
1154 .endpoint = 0x02,
1155 .u = {
1156 .bulk = {
1157 .buffersize = 8192,
1158 }
1159 }
1160 },
1161 },
1162 },
1163
1164 .power_ctrl = cxusb_power_ctrl,
1165
1166 .i2c_algo = &cxusb_i2c_algo,
1167
1168 .generic_bulk_ctrl_endpoint = 0x01,
1169
1170 .rc_interval = 100,
1171 .rc_key_map = dvico_mce_rc_keys,
1172 .rc_key_map_size = ARRAY_SIZE(dvico_mce_rc_keys),
1173 .rc_query = cxusb_bluebird2_rc_query,
1174
1175 .num_device_descs = 1,
1176 .devices = {
1177 { "DViCO FusionHDTV DVB-T Dual Digital 4",
1178 { NULL },
1179 { &cxusb_table[13], NULL },
1180 },
1181 }
1182};
1183
5ccaf905
CP		 1184static struct dvb_usb_device_properties cxusb_bluebird_nano2_properties = {
1185 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1186
1187 .usb_ctrl = CYPRESS_FX2,
702a6762 1188 .identify_state = bluebird_fx2_identify_state,
5ccaf905
CP		 1189
1190 .size_of_priv = sizeof(struct cxusb_state),
1191
1192 .num_adapters = 1,
1193 .adapter = {
1194 {
1195 .streaming_ctrl = cxusb_streaming_ctrl,
1196 .frontend_attach = cxusb_nano2_frontend_attach,
1197 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1198 /* parameter for the MPEG2-data transfer */
1199 .stream = {
1200 .type = USB_BULK,
1201 .count = 5,
1202 .endpoint = 0x02,
1203 .u = {
1204 .bulk = {
1205 .buffersize = 8192,
1206 }
1207 }
1208 },
1209 },
1210 },
1211
1212 .power_ctrl = cxusb_nano2_power_ctrl,
1213
1214 .i2c_algo = &cxusb_i2c_algo,
1215
1216 .generic_bulk_ctrl_endpoint = 0x01,
1217
1218 .rc_interval = 100,
1219 .rc_key_map = dvico_portable_rc_keys,
1220 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1221 .rc_query = cxusb_bluebird2_rc_query,
1222
1223 .num_device_descs = 1,
1224 .devices = {
1225 { "DViCO FusionHDTV DVB-T NANO2",
1226 { NULL },
1227 { &cxusb_table[14], NULL },
1228 },
1229 }
1230};
1231
702a6762
CP		 1232static struct dvb_usb_device_properties cxusb_bluebird_nano2_needsfirmware_properties = {
1233 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1234
1235 .usb_ctrl = DEVICE_SPECIFIC,
1236 .firmware = "dvb-usb-bluebird-02.fw",
1237 .download_firmware = bluebird_patch_dvico_firmware_download,
1238 .identify_state = bluebird_fx2_identify_state,
1239
1240 .size_of_priv = sizeof(struct cxusb_state),
1241
1242 .num_adapters = 1,
1243 .adapter = {
1244 {
1245 .streaming_ctrl = cxusb_streaming_ctrl,
1246 .frontend_attach = cxusb_nano2_frontend_attach,
1247 .tuner_attach = cxusb_dvico_xc3028_tuner_attach,
1248 /* parameter for the MPEG2-data transfer */
1249 .stream = {
1250 .type = USB_BULK,
1251 .count = 5,
1252 .endpoint = 0x02,
1253 .u = {
1254 .bulk = {
1255 .buffersize = 8192,
1256 }
1257 }
1258 },
1259 },
1260 },
1261
1262 .power_ctrl = cxusb_nano2_power_ctrl,
1263
1264 .i2c_algo = &cxusb_i2c_algo,
1265
1266 .generic_bulk_ctrl_endpoint = 0x01,
1267
1268 .rc_interval = 100,
1269 .rc_key_map = dvico_portable_rc_keys,
1270 .rc_key_map_size = ARRAY_SIZE(dvico_portable_rc_keys),
1271 .rc_query = cxusb_rc_query,
1272
1273 .num_device_descs = 1,
1274 .devices = {
1275 { "DViCO FusionHDTV DVB-T NANO2 w/o firmware",
1276 { &cxusb_table[14], NULL },
1277 { &cxusb_table[15], NULL },
1278 },
1279 }
1280};
1281
f5376ada
DG		 1282static struct dvb_usb_device_properties cxusb_aver_a868r_properties = {
1283 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1284
1285 .usb_ctrl = CYPRESS_FX2,
1286
1287 .size_of_priv = sizeof(struct cxusb_state),
1288
1289 .num_adapters = 1,
1290 .adapter = {
1291 {
1292 .streaming_ctrl = cxusb_aver_streaming_ctrl,
1293 .frontend_attach = cxusb_aver_lgdt3303_frontend_attach,
1294 .tuner_attach = cxusb_mxl5003s_tuner_attach,
1295 /* parameter for the MPEG2-data transfer */
1296 .stream = {
1297 .type = USB_BULK,
1298 .count = 5,
1299 .endpoint = 0x04,
1300 .u = {
1301 .bulk = {
1302 .buffersize = 8192,
1303 }
1304 }
1305 },
1306
1307 },
1308 },
1309 .power_ctrl = cxusb_aver_power_ctrl,
1310
1311 .i2c_algo = &cxusb_i2c_algo,
1312
1313 .generic_bulk_ctrl_endpoint = 0x01,
1314
1315 .num_device_descs = 1,
1316 .devices = {
1317 { "AVerMedia AVerTVHD Volar (A868R)",
1318 { NULL },
1319 { &cxusb_table[16], NULL },
1320 },
1321 }
1322};
1323
22c6d93a 1324static struct usb_driver cxusb_driver = {
63b5c1c4 1325 .name = "dvb_usb_cxusb",
22c6d93a 1326 .probe = cxusb_probe,
f35db23c 1327 .disconnect = dvb_usb_device_exit,
22c6d93a
PB		 1328 .id_table = cxusb_table,
1329};
1330
1331/* module stuff */
1332static int __init cxusb_module_init(void)
1333{
1334 int result;
1335 if ((result = usb_register(&cxusb_driver))) {
1336 err("usb_register failed. Error number %d",result);
1337 return result;
1338 }
1339
1340 return 0;
1341}
1342
1343static void __exit cxusb_module_exit(void)
1344{
1345 /* deregister this driver from the USB subsystem */
1346 usb_deregister(&cxusb_driver);
1347}
1348
1349module_init (cxusb_module_init);
1350module_exit (cxusb_module_exit);
1351
1352MODULE_AUTHOR("Patrick Boettcher <patrick.boettcher@desy.de>");
5b9ed286 1353MODULE_AUTHOR("Michael Krufky <mkrufky@linuxtv.org>");
f4efb4db 1354MODULE_AUTHOR("Chris Pascoe <c.pascoe@itee.uq.edu.au>");
22c6d93a
PB		 1355MODULE_DESCRIPTION("Driver for Conexant USB2.0 hybrid reference design");
1356MODULE_VERSION("1.0-alpha");
1357MODULE_LICENSE("GPL");
Linux kernel - Deliverables
This page took 0.518356 seconds and 5 git commands to generate.