1 // SPDX-License-Identifier: GPL-2.0-only
2 /* DVB USB framework compliant Linux driver for the
3 * DVBWorld DVB-S 2101, 2102, DVB-S2 2104, DVB-C 3101,
4 * TeVii S421, S480, S482, S600, S630, S632, S650, S660, S662,
5 * Prof 1100, 7500,
6 * Geniatech SU3000, T220,
7 * TechnoTrend S2-4600,
8 * Terratec Cinergy S2 cards
9 * Copyright (C) 2008-2012 Igor M. Liplianin (liplianin@me.by)
10 *
11 * see Documentation/driver-api/media/drivers/dvb-usb.rst for more information
12 */
13 #include <media/dvb-usb-ids.h>
14 #include "dw2102.h"
15 #include "si21xx.h"
16 #include "stv0299.h"
17 #include "z0194a.h"
18 #include "stv0288.h"
19 #include "stb6000.h"
20 #include "eds1547.h"
21 #include "cx24116.h"
22 #include "tda1002x.h"
23 #include "mt312.h"
24 #include "zl10039.h"
25 #include "ts2020.h"
26 #include "ds3000.h"
27 #include "stv0900.h"
28 #include "stv6110.h"
29 #include "stb6100.h"
30 #include "stb6100_proc.h"
31 #include "m88rs2000.h"
32 #include "tda18271.h"
33 #include "cxd2820r.h"
34 #include "m88ds3103.h"
35
36 /* Max transfer size done by I2C transfer functions */
37 #define MAX_XFER_SIZE 64
38
39
40 #define DW210X_READ_MSG 0
41 #define DW210X_WRITE_MSG 1
42
43 #define REG_1F_SYMBOLRATE_BYTE0 0x1f
44 #define REG_20_SYMBOLRATE_BYTE1 0x20
45 #define REG_21_SYMBOLRATE_BYTE2 0x21
46 /* on my own*/
47 #define DW2102_VOLTAGE_CTRL (0x1800)
48 #define SU3000_STREAM_CTRL (0x1900)
49 #define DW2102_RC_QUERY (0x1a00)
50 #define DW2102_LED_CTRL (0x1b00)
51
52 #define DW2101_FIRMWARE "dvb-usb-dw2101.fw"
53 #define DW2102_FIRMWARE "dvb-usb-dw2102.fw"
54 #define DW2104_FIRMWARE "dvb-usb-dw2104.fw"
55 #define DW3101_FIRMWARE "dvb-usb-dw3101.fw"
56 #define S630_FIRMWARE "dvb-usb-s630.fw"
57 #define S660_FIRMWARE "dvb-usb-s660.fw"
58 #define P1100_FIRMWARE "dvb-usb-p1100.fw"
59 #define P7500_FIRMWARE "dvb-usb-p7500.fw"
60
61 #define err_str "did not find the firmware file '%s'. You can use <kernel_dir>/scripts/get_dvb_firmware to get the firmware"
62
63 struct dw2102_state {
64 u8 initialized;
65 u8 last_lock;
66 u8 data[MAX_XFER_SIZE + 4];
67 struct i2c_client *i2c_client_demod;
68 struct i2c_client *i2c_client_tuner;
69
70 /* fe hook functions*/
71 int (*old_set_voltage)(struct dvb_frontend *f, enum fe_sec_voltage v);
72 int (*fe_read_status)(struct dvb_frontend *fe,
73 enum fe_status *status);
74 };
75
76 /* debug */
77 static int dvb_usb_dw2102_debug;
78 module_param_named(debug, dvb_usb_dw2102_debug, int, 0644);
79 MODULE_PARM_DESC(debug, "set debugging level (1=info 2=xfer 4=rc(or-able))."
80 DVB_USB_DEBUG_STATUS);
81
82 /* demod probe */
83 static int demod_probe = 1;
84 module_param_named(demod, demod_probe, int, 0644);
85 MODULE_PARM_DESC(demod, "demod to probe (1=cx24116 2=stv0903+stv6110 4=stv0903+stb6100(or-able)).");
86
87 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
88
dw210x_op_rw(struct usb_device * dev,u8 request,u16 value,u16 index,u8 * data,u16 len,int flags)89 static int dw210x_op_rw(struct usb_device *dev, u8 request, u16 value,
90 u16 index, u8 * data, u16 len, int flags)
91 {
92 int ret;
93 u8 *u8buf;
94 unsigned int pipe = (flags == DW210X_READ_MSG) ?
95 usb_rcvctrlpipe(dev, 0) : usb_sndctrlpipe(dev, 0);
96 u8 request_type = (flags == DW210X_READ_MSG) ? USB_DIR_IN : USB_DIR_OUT;
97
98 u8buf = kmalloc(len, GFP_KERNEL);
99 if (!u8buf)
100 return -ENOMEM;
101
102
103 if (flags == DW210X_WRITE_MSG)
104 memcpy(u8buf, data, len);
105 ret = usb_control_msg(dev, pipe, request, request_type | USB_TYPE_VENDOR,
106 value, index , u8buf, len, 2000);
107
108 if (flags == DW210X_READ_MSG)
109 memcpy(data, u8buf, len);
110
111 kfree(u8buf);
112 return ret;
113 }
114
115 /* I2C */
dw2102_i2c_transfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)116 static int dw2102_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
117 int num)
118 {
119 struct dvb_usb_device *d = i2c_get_adapdata(adap);
120 int i = 0;
121 u8 buf6[] = {0x2c, 0x05, 0xc0, 0, 0, 0, 0};
122 u16 value;
123
124 if (!d)
125 return -ENODEV;
126 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
127 return -EAGAIN;
128
129 switch (num) {
130 case 2:
131 /* read stv0299 register */
132 value = msg[0].buf[0];/* register */
133 for (i = 0; i < msg[1].len; i++) {
134 dw210x_op_rw(d->udev, 0xb5, value + i, 0,
135 buf6, 2, DW210X_READ_MSG);
136 msg[1].buf[i] = buf6[0];
137 }
138 break;
139 case 1:
140 switch (msg[0].addr) {
141 case 0x68:
142 /* write to stv0299 register */
143 buf6[0] = 0x2a;
144 buf6[1] = msg[0].buf[0];
145 buf6[2] = msg[0].buf[1];
146 dw210x_op_rw(d->udev, 0xb2, 0, 0,
147 buf6, 3, DW210X_WRITE_MSG);
148 break;
149 case 0x60:
150 if (msg[0].flags == 0) {
151 /* write to tuner pll */
152 buf6[0] = 0x2c;
153 buf6[1] = 5;
154 buf6[2] = 0xc0;
155 buf6[3] = msg[0].buf[0];
156 buf6[4] = msg[0].buf[1];
157 buf6[5] = msg[0].buf[2];
158 buf6[6] = msg[0].buf[3];
159 dw210x_op_rw(d->udev, 0xb2, 0, 0,
160 buf6, 7, DW210X_WRITE_MSG);
161 } else {
162 /* read from tuner */
163 dw210x_op_rw(d->udev, 0xb5, 0, 0,
164 buf6, 1, DW210X_READ_MSG);
165 msg[0].buf[0] = buf6[0];
166 }
167 break;
168 case (DW2102_RC_QUERY):
169 dw210x_op_rw(d->udev, 0xb8, 0, 0,
170 buf6, 2, DW210X_READ_MSG);
171 msg[0].buf[0] = buf6[0];
172 msg[0].buf[1] = buf6[1];
173 break;
174 case (DW2102_VOLTAGE_CTRL):
175 buf6[0] = 0x30;
176 buf6[1] = msg[0].buf[0];
177 dw210x_op_rw(d->udev, 0xb2, 0, 0,
178 buf6, 2, DW210X_WRITE_MSG);
179 break;
180 }
181
182 break;
183 }
184
185 mutex_unlock(&d->i2c_mutex);
186 return num;
187 }
188
dw2102_serit_i2c_transfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)189 static int dw2102_serit_i2c_transfer(struct i2c_adapter *adap,
190 struct i2c_msg msg[], int num)
191 {
192 struct dvb_usb_device *d = i2c_get_adapdata(adap);
193 u8 buf6[] = {0, 0, 0, 0, 0, 0, 0};
194
195 if (!d)
196 return -ENODEV;
197 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
198 return -EAGAIN;
199
200 switch (num) {
201 case 2:
202 if (msg[0].len != 1) {
203 warn("i2c rd: len=%d is not 1!\n",
204 msg[0].len);
205 num = -EOPNOTSUPP;
206 break;
207 }
208
209 if (2 + msg[1].len > sizeof(buf6)) {
210 warn("i2c rd: len=%d is too big!\n",
211 msg[1].len);
212 num = -EOPNOTSUPP;
213 break;
214 }
215
216 /* read si2109 register by number */
217 buf6[0] = msg[0].addr << 1;
218 buf6[1] = msg[0].len;
219 buf6[2] = msg[0].buf[0];
220 dw210x_op_rw(d->udev, 0xc2, 0, 0,
221 buf6, msg[0].len + 2, DW210X_WRITE_MSG);
222 /* read si2109 register */
223 dw210x_op_rw(d->udev, 0xc3, 0xd0, 0,
224 buf6, msg[1].len + 2, DW210X_READ_MSG);
225 memcpy(msg[1].buf, buf6 + 2, msg[1].len);
226
227 break;
228 case 1:
229 switch (msg[0].addr) {
230 case 0x68:
231 if (2 + msg[0].len > sizeof(buf6)) {
232 warn("i2c wr: len=%d is too big!\n",
233 msg[0].len);
234 num = -EOPNOTSUPP;
235 break;
236 }
237
238 /* write to si2109 register */
239 buf6[0] = msg[0].addr << 1;
240 buf6[1] = msg[0].len;
241 memcpy(buf6 + 2, msg[0].buf, msg[0].len);
242 dw210x_op_rw(d->udev, 0xc2, 0, 0, buf6,
243 msg[0].len + 2, DW210X_WRITE_MSG);
244 break;
245 case(DW2102_RC_QUERY):
246 dw210x_op_rw(d->udev, 0xb8, 0, 0,
247 buf6, 2, DW210X_READ_MSG);
248 msg[0].buf[0] = buf6[0];
249 msg[0].buf[1] = buf6[1];
250 break;
251 case(DW2102_VOLTAGE_CTRL):
252 buf6[0] = 0x30;
253 buf6[1] = msg[0].buf[0];
254 dw210x_op_rw(d->udev, 0xb2, 0, 0,
255 buf6, 2, DW210X_WRITE_MSG);
256 break;
257 }
258 break;
259 }
260
261 mutex_unlock(&d->i2c_mutex);
262 return num;
263 }
264
dw2102_earda_i2c_transfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)265 static int dw2102_earda_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num)
266 {
267 struct dvb_usb_device *d = i2c_get_adapdata(adap);
268 int ret;
269
270 if (!d)
271 return -ENODEV;
272 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
273 return -EAGAIN;
274
275 switch (num) {
276 case 2: {
277 /* read */
278 /* first write first register number */
279 u8 ibuf[MAX_XFER_SIZE], obuf[3];
280
281 if (2 + msg[0].len != sizeof(obuf)) {
282 warn("i2c rd: len=%d is not 1!\n",
283 msg[0].len);
284 ret = -EOPNOTSUPP;
285 goto unlock;
286 }
287
288 if (2 + msg[1].len > sizeof(ibuf)) {
289 warn("i2c rd: len=%d is too big!\n",
290 msg[1].len);
291 ret = -EOPNOTSUPP;
292 goto unlock;
293 }
294
295 obuf[0] = msg[0].addr << 1;
296 obuf[1] = msg[0].len;
297 obuf[2] = msg[0].buf[0];
298 dw210x_op_rw(d->udev, 0xc2, 0, 0,
299 obuf, msg[0].len + 2, DW210X_WRITE_MSG);
300 /* second read registers */
301 dw210x_op_rw(d->udev, 0xc3, 0xd1 , 0,
302 ibuf, msg[1].len + 2, DW210X_READ_MSG);
303 memcpy(msg[1].buf, ibuf + 2, msg[1].len);
304
305 break;
306 }
307 case 1:
308 switch (msg[0].addr) {
309 case 0x68: {
310 /* write to register */
311 u8 obuf[MAX_XFER_SIZE];
312
313 if (2 + msg[0].len > sizeof(obuf)) {
314 warn("i2c wr: len=%d is too big!\n",
315 msg[1].len);
316 ret = -EOPNOTSUPP;
317 goto unlock;
318 }
319
320 obuf[0] = msg[0].addr << 1;
321 obuf[1] = msg[0].len;
322 memcpy(obuf + 2, msg[0].buf, msg[0].len);
323 dw210x_op_rw(d->udev, 0xc2, 0, 0,
324 obuf, msg[0].len + 2, DW210X_WRITE_MSG);
325 break;
326 }
327 case 0x61: {
328 /* write to tuner */
329 u8 obuf[MAX_XFER_SIZE];
330
331 if (2 + msg[0].len > sizeof(obuf)) {
332 warn("i2c wr: len=%d is too big!\n",
333 msg[1].len);
334 ret = -EOPNOTSUPP;
335 goto unlock;
336 }
337
338 obuf[0] = msg[0].addr << 1;
339 obuf[1] = msg[0].len;
340 memcpy(obuf + 2, msg[0].buf, msg[0].len);
341 dw210x_op_rw(d->udev, 0xc2, 0, 0,
342 obuf, msg[0].len + 2, DW210X_WRITE_MSG);
343 break;
344 }
345 case(DW2102_RC_QUERY): {
346 u8 ibuf[2];
347 dw210x_op_rw(d->udev, 0xb8, 0, 0,
348 ibuf, 2, DW210X_READ_MSG);
349 memcpy(msg[0].buf, ibuf , 2);
350 break;
351 }
352 case(DW2102_VOLTAGE_CTRL): {
353 u8 obuf[2];
354 obuf[0] = 0x30;
355 obuf[1] = msg[0].buf[0];
356 dw210x_op_rw(d->udev, 0xb2, 0, 0,
357 obuf, 2, DW210X_WRITE_MSG);
358 break;
359 }
360 }
361
362 break;
363 }
364 ret = num;
365
366 unlock:
367 mutex_unlock(&d->i2c_mutex);
368 return ret;
369 }
370
dw2104_i2c_transfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)371 static int dw2104_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[], int num)
372 {
373 struct dvb_usb_device *d = i2c_get_adapdata(adap);
374 int len, i, j, ret;
375
376 if (!d)
377 return -ENODEV;
378 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
379 return -EAGAIN;
380
381 for (j = 0; j < num; j++) {
382 switch (msg[j].addr) {
383 case(DW2102_RC_QUERY): {
384 u8 ibuf[2];
385 dw210x_op_rw(d->udev, 0xb8, 0, 0,
386 ibuf, 2, DW210X_READ_MSG);
387 memcpy(msg[j].buf, ibuf , 2);
388 break;
389 }
390 case(DW2102_VOLTAGE_CTRL): {
391 u8 obuf[2];
392 obuf[0] = 0x30;
393 obuf[1] = msg[j].buf[0];
394 dw210x_op_rw(d->udev, 0xb2, 0, 0,
395 obuf, 2, DW210X_WRITE_MSG);
396 break;
397 }
398 /*case 0x55: cx24116
399 case 0x6a: stv0903
400 case 0x68: ds3000, stv0903
401 case 0x60: ts2020, stv6110, stb6100 */
402 default: {
403 if (msg[j].flags == I2C_M_RD) {
404 /* read registers */
405 u8 ibuf[MAX_XFER_SIZE];
406
407 if (2 + msg[j].len > sizeof(ibuf)) {
408 warn("i2c rd: len=%d is too big!\n",
409 msg[j].len);
410 ret = -EOPNOTSUPP;
411 goto unlock;
412 }
413
414 dw210x_op_rw(d->udev, 0xc3,
415 (msg[j].addr << 1) + 1, 0,
416 ibuf, msg[j].len + 2,
417 DW210X_READ_MSG);
418 memcpy(msg[j].buf, ibuf + 2, msg[j].len);
419 mdelay(10);
420 } else if (((msg[j].buf[0] == 0xb0) &&
421 (msg[j].addr == 0x68)) ||
422 ((msg[j].buf[0] == 0xf7) &&
423 (msg[j].addr == 0x55))) {
424 /* write firmware */
425 u8 obuf[19];
426 obuf[0] = msg[j].addr << 1;
427 obuf[1] = (msg[j].len > 15 ? 17 : msg[j].len);
428 obuf[2] = msg[j].buf[0];
429 len = msg[j].len - 1;
430 i = 1;
431 do {
432 memcpy(obuf + 3, msg[j].buf + i,
433 (len > 16 ? 16 : len));
434 dw210x_op_rw(d->udev, 0xc2, 0, 0,
435 obuf, (len > 16 ? 16 : len) + 3,
436 DW210X_WRITE_MSG);
437 i += 16;
438 len -= 16;
439 } while (len > 0);
440 } else {
441 /* write registers */
442 u8 obuf[MAX_XFER_SIZE];
443
444 if (2 + msg[j].len > sizeof(obuf)) {
445 warn("i2c wr: len=%d is too big!\n",
446 msg[j].len);
447 ret = -EOPNOTSUPP;
448 goto unlock;
449 }
450
451 obuf[0] = msg[j].addr << 1;
452 obuf[1] = msg[j].len;
453 memcpy(obuf + 2, msg[j].buf, msg[j].len);
454 dw210x_op_rw(d->udev, 0xc2, 0, 0,
455 obuf, msg[j].len + 2,
456 DW210X_WRITE_MSG);
457 }
458 break;
459 }
460 }
461
462 }
463 ret = num;
464
465 unlock:
466 mutex_unlock(&d->i2c_mutex);
467 return ret;
468 }
469
dw3101_i2c_transfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)470 static int dw3101_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
471 int num)
472 {
473 struct dvb_usb_device *d = i2c_get_adapdata(adap);
474 int ret;
475 int i;
476
477 if (!d)
478 return -ENODEV;
479 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
480 return -EAGAIN;
481
482 switch (num) {
483 case 2: {
484 /* read */
485 /* first write first register number */
486 u8 ibuf[MAX_XFER_SIZE], obuf[3];
487
488 if (2 + msg[0].len != sizeof(obuf)) {
489 warn("i2c rd: len=%d is not 1!\n",
490 msg[0].len);
491 ret = -EOPNOTSUPP;
492 goto unlock;
493 }
494 if (2 + msg[1].len > sizeof(ibuf)) {
495 warn("i2c rd: len=%d is too big!\n",
496 msg[1].len);
497 ret = -EOPNOTSUPP;
498 goto unlock;
499 }
500 obuf[0] = msg[0].addr << 1;
501 obuf[1] = msg[0].len;
502 obuf[2] = msg[0].buf[0];
503 dw210x_op_rw(d->udev, 0xc2, 0, 0,
504 obuf, msg[0].len + 2, DW210X_WRITE_MSG);
505 /* second read registers */
506 dw210x_op_rw(d->udev, 0xc3, 0x19 , 0,
507 ibuf, msg[1].len + 2, DW210X_READ_MSG);
508 memcpy(msg[1].buf, ibuf + 2, msg[1].len);
509
510 break;
511 }
512 case 1:
513 switch (msg[0].addr) {
514 case 0x60:
515 case 0x0c: {
516 /* write to register */
517 u8 obuf[MAX_XFER_SIZE];
518
519 if (2 + msg[0].len > sizeof(obuf)) {
520 warn("i2c wr: len=%d is too big!\n",
521 msg[0].len);
522 ret = -EOPNOTSUPP;
523 goto unlock;
524 }
525 obuf[0] = msg[0].addr << 1;
526 obuf[1] = msg[0].len;
527 memcpy(obuf + 2, msg[0].buf, msg[0].len);
528 dw210x_op_rw(d->udev, 0xc2, 0, 0,
529 obuf, msg[0].len + 2, DW210X_WRITE_MSG);
530 break;
531 }
532 case(DW2102_RC_QUERY): {
533 u8 ibuf[2];
534 dw210x_op_rw(d->udev, 0xb8, 0, 0,
535 ibuf, 2, DW210X_READ_MSG);
536 memcpy(msg[0].buf, ibuf , 2);
537 break;
538 }
539 }
540
541 break;
542 }
543
544 for (i = 0; i < num; i++) {
545 deb_xfer("%02x:%02x: %s ", i, msg[i].addr,
546 msg[i].flags == 0 ? ">>>" : "<<<");
547 debug_dump(msg[i].buf, msg[i].len, deb_xfer);
548 }
549 ret = num;
550
551 unlock:
552 mutex_unlock(&d->i2c_mutex);
553 return ret;
554 }
555
s6x0_i2c_transfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)556 static int s6x0_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
557 int num)
558 {
559 struct dvb_usb_device *d = i2c_get_adapdata(adap);
560 struct usb_device *udev;
561 int len, i, j, ret;
562
563 if (!d)
564 return -ENODEV;
565 udev = d->udev;
566 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
567 return -EAGAIN;
568
569 for (j = 0; j < num; j++) {
570 switch (msg[j].addr) {
571 case (DW2102_RC_QUERY): {
572 u8 ibuf[5];
573 dw210x_op_rw(d->udev, 0xb8, 0, 0,
574 ibuf, 5, DW210X_READ_MSG);
575 memcpy(msg[j].buf, ibuf + 3, 2);
576 break;
577 }
578 case (DW2102_VOLTAGE_CTRL): {
579 u8 obuf[2];
580
581 obuf[0] = 1;
582 obuf[1] = msg[j].buf[1];/* off-on */
583 dw210x_op_rw(d->udev, 0x8a, 0, 0,
584 obuf, 2, DW210X_WRITE_MSG);
585 obuf[0] = 3;
586 obuf[1] = msg[j].buf[0];/* 13v-18v */
587 dw210x_op_rw(d->udev, 0x8a, 0, 0,
588 obuf, 2, DW210X_WRITE_MSG);
589 break;
590 }
591 case (DW2102_LED_CTRL): {
592 u8 obuf[2];
593
594 obuf[0] = 5;
595 obuf[1] = msg[j].buf[0];
596 dw210x_op_rw(d->udev, 0x8a, 0, 0,
597 obuf, 2, DW210X_WRITE_MSG);
598 break;
599 }
600 /*case 0x55: cx24116
601 case 0x6a: stv0903
602 case 0x68: ds3000, stv0903, rs2000
603 case 0x60: ts2020, stv6110, stb6100
604 case 0xa0: eeprom */
605 default: {
606 if (msg[j].flags == I2C_M_RD) {
607 /* read registers */
608 u8 ibuf[MAX_XFER_SIZE];
609
610 if (msg[j].len > sizeof(ibuf)) {
611 warn("i2c rd: len=%d is too big!\n",
612 msg[j].len);
613 ret = -EOPNOTSUPP;
614 goto unlock;
615 }
616
617 dw210x_op_rw(d->udev, 0x91, 0, 0,
618 ibuf, msg[j].len,
619 DW210X_READ_MSG);
620 memcpy(msg[j].buf, ibuf, msg[j].len);
621 break;
622 } else if ((msg[j].buf[0] == 0xb0) &&
623 (msg[j].addr == 0x68)) {
624 /* write firmware */
625 u8 obuf[19];
626 obuf[0] = (msg[j].len > 16 ?
627 18 : msg[j].len + 1);
628 obuf[1] = msg[j].addr << 1;
629 obuf[2] = msg[j].buf[0];
630 len = msg[j].len - 1;
631 i = 1;
632 do {
633 memcpy(obuf + 3, msg[j].buf + i,
634 (len > 16 ? 16 : len));
635 dw210x_op_rw(d->udev, 0x80, 0, 0,
636 obuf, (len > 16 ? 16 : len) + 3,
637 DW210X_WRITE_MSG);
638 i += 16;
639 len -= 16;
640 } while (len > 0);
641 } else if (j < (num - 1)) {
642 /* write register addr before read */
643 u8 obuf[MAX_XFER_SIZE];
644
645 if (2 + msg[j].len > sizeof(obuf)) {
646 warn("i2c wr: len=%d is too big!\n",
647 msg[j].len);
648 ret = -EOPNOTSUPP;
649 goto unlock;
650 }
651
652 obuf[0] = msg[j + 1].len;
653 obuf[1] = (msg[j].addr << 1);
654 memcpy(obuf + 2, msg[j].buf, msg[j].len);
655 dw210x_op_rw(d->udev,
656 le16_to_cpu(udev->descriptor.idProduct) ==
657 0x7500 ? 0x92 : 0x90, 0, 0,
658 obuf, msg[j].len + 2,
659 DW210X_WRITE_MSG);
660 break;
661 } else {
662 /* write registers */
663 u8 obuf[MAX_XFER_SIZE];
664
665 if (2 + msg[j].len > sizeof(obuf)) {
666 warn("i2c wr: len=%d is too big!\n",
667 msg[j].len);
668 ret = -EOPNOTSUPP;
669 goto unlock;
670 }
671 obuf[0] = msg[j].len + 1;
672 obuf[1] = (msg[j].addr << 1);
673 memcpy(obuf + 2, msg[j].buf, msg[j].len);
674 dw210x_op_rw(d->udev, 0x80, 0, 0,
675 obuf, msg[j].len + 2,
676 DW210X_WRITE_MSG);
677 break;
678 }
679 break;
680 }
681 }
682 }
683 ret = num;
684
685 unlock:
686 mutex_unlock(&d->i2c_mutex);
687 return ret;
688 }
689
su3000_i2c_transfer(struct i2c_adapter * adap,struct i2c_msg msg[],int num)690 static int su3000_i2c_transfer(struct i2c_adapter *adap, struct i2c_msg msg[],
691 int num)
692 {
693 struct dvb_usb_device *d = i2c_get_adapdata(adap);
694 struct dw2102_state *state;
695
696 if (!d)
697 return -ENODEV;
698
699 state = d->priv;
700
701 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
702 return -EAGAIN;
703 if (mutex_lock_interruptible(&d->data_mutex) < 0) {
704 mutex_unlock(&d->i2c_mutex);
705 return -EAGAIN;
706 }
707
708 switch (num) {
709 case 1:
710 switch (msg[0].addr) {
711 case SU3000_STREAM_CTRL:
712 state->data[0] = msg[0].buf[0] + 0x36;
713 state->data[1] = 3;
714 state->data[2] = 0;
715 if (dvb_usb_generic_rw(d, state->data, 3,
716 state->data, 0, 0) < 0)
717 err("i2c transfer failed.");
718 break;
719 case DW2102_RC_QUERY:
720 state->data[0] = 0x10;
721 if (dvb_usb_generic_rw(d, state->data, 1,
722 state->data, 2, 0) < 0)
723 err("i2c transfer failed.");
724 msg[0].buf[1] = state->data[0];
725 msg[0].buf[0] = state->data[1];
726 break;
727 default:
728 if (3 + msg[0].len > sizeof(state->data)) {
729 warn("i2c wr: len=%d is too big!\n",
730 msg[0].len);
731 num = -EOPNOTSUPP;
732 break;
733 }
734
735 /* always i2c write*/
736 state->data[0] = 0x08;
737 state->data[1] = msg[0].addr;
738 state->data[2] = msg[0].len;
739
740 memcpy(&state->data[3], msg[0].buf, msg[0].len);
741
742 if (dvb_usb_generic_rw(d, state->data, msg[0].len + 3,
743 state->data, 1, 0) < 0)
744 err("i2c transfer failed.");
745
746 }
747 break;
748 case 2:
749 /* always i2c read */
750 if (4 + msg[0].len > sizeof(state->data)) {
751 warn("i2c rd: len=%d is too big!\n",
752 msg[0].len);
753 num = -EOPNOTSUPP;
754 break;
755 }
756 if (1 + msg[1].len > sizeof(state->data)) {
757 warn("i2c rd: len=%d is too big!\n",
758 msg[1].len);
759 num = -EOPNOTSUPP;
760 break;
761 }
762
763 state->data[0] = 0x09;
764 state->data[1] = msg[0].len;
765 state->data[2] = msg[1].len;
766 state->data[3] = msg[0].addr;
767 memcpy(&state->data[4], msg[0].buf, msg[0].len);
768
769 if (dvb_usb_generic_rw(d, state->data, msg[0].len + 4,
770 state->data, msg[1].len + 1, 0) < 0)
771 err("i2c transfer failed.");
772
773 memcpy(msg[1].buf, &state->data[1], msg[1].len);
774 break;
775 default:
776 warn("more than 2 i2c messages at a time is not handled yet.");
777 break;
778 }
779 mutex_unlock(&d->data_mutex);
780 mutex_unlock(&d->i2c_mutex);
781 return num;
782 }
783
dw210x_i2c_func(struct i2c_adapter * adapter)784 static u32 dw210x_i2c_func(struct i2c_adapter *adapter)
785 {
786 return I2C_FUNC_I2C;
787 }
788
789 static struct i2c_algorithm dw2102_i2c_algo = {
790 .master_xfer = dw2102_i2c_transfer,
791 .functionality = dw210x_i2c_func,
792 };
793
794 static struct i2c_algorithm dw2102_serit_i2c_algo = {
795 .master_xfer = dw2102_serit_i2c_transfer,
796 .functionality = dw210x_i2c_func,
797 };
798
799 static struct i2c_algorithm dw2102_earda_i2c_algo = {
800 .master_xfer = dw2102_earda_i2c_transfer,
801 .functionality = dw210x_i2c_func,
802 };
803
804 static struct i2c_algorithm dw2104_i2c_algo = {
805 .master_xfer = dw2104_i2c_transfer,
806 .functionality = dw210x_i2c_func,
807 };
808
809 static struct i2c_algorithm dw3101_i2c_algo = {
810 .master_xfer = dw3101_i2c_transfer,
811 .functionality = dw210x_i2c_func,
812 };
813
814 static struct i2c_algorithm s6x0_i2c_algo = {
815 .master_xfer = s6x0_i2c_transfer,
816 .functionality = dw210x_i2c_func,
817 };
818
819 static struct i2c_algorithm su3000_i2c_algo = {
820 .master_xfer = su3000_i2c_transfer,
821 .functionality = dw210x_i2c_func,
822 };
823
dw210x_read_mac_address(struct dvb_usb_device * d,u8 mac[6])824 static int dw210x_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
825 {
826 int i;
827 u8 ibuf[] = {0, 0};
828 u8 eeprom[256], eepromline[16];
829
830 for (i = 0; i < 256; i++) {
831 if (dw210x_op_rw(d->udev, 0xb6, 0xa0 , i, ibuf, 2, DW210X_READ_MSG) < 0) {
832 err("read eeprom failed.");
833 return -1;
834 } else {
835 eepromline[i%16] = ibuf[0];
836 eeprom[i] = ibuf[0];
837 }
838 if ((i % 16) == 15) {
839 deb_xfer("%02x: ", i - 15);
840 debug_dump(eepromline, 16, deb_xfer);
841 }
842 }
843
844 memcpy(mac, eeprom + 8, 6);
845 return 0;
846 };
847
s6x0_read_mac_address(struct dvb_usb_device * d,u8 mac[6])848 static int s6x0_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
849 {
850 int i, ret;
851 u8 ibuf[] = { 0 }, obuf[] = { 0 };
852 u8 eeprom[256], eepromline[16];
853 struct i2c_msg msg[] = {
854 {
855 .addr = 0xa0 >> 1,
856 .flags = 0,
857 .buf = obuf,
858 .len = 1,
859 }, {
860 .addr = 0xa0 >> 1,
861 .flags = I2C_M_RD,
862 .buf = ibuf,
863 .len = 1,
864 }
865 };
866
867 for (i = 0; i < 256; i++) {
868 obuf[0] = i;
869 ret = s6x0_i2c_transfer(&d->i2c_adap, msg, 2);
870 if (ret != 2) {
871 err("read eeprom failed.");
872 return -1;
873 } else {
874 eepromline[i % 16] = ibuf[0];
875 eeprom[i] = ibuf[0];
876 }
877
878 if ((i % 16) == 15) {
879 deb_xfer("%02x: ", i - 15);
880 debug_dump(eepromline, 16, deb_xfer);
881 }
882 }
883
884 memcpy(mac, eeprom + 16, 6);
885 return 0;
886 };
887
su3000_streaming_ctrl(struct dvb_usb_adapter * adap,int onoff)888 static int su3000_streaming_ctrl(struct dvb_usb_adapter *adap, int onoff)
889 {
890 static u8 command_start[] = {0x00};
891 static u8 command_stop[] = {0x01};
892 struct i2c_msg msg = {
893 .addr = SU3000_STREAM_CTRL,
894 .flags = 0,
895 .buf = onoff ? command_start : command_stop,
896 .len = 1
897 };
898
899 i2c_transfer(&adap->dev->i2c_adap, &msg, 1);
900
901 return 0;
902 }
903
su3000_power_ctrl(struct dvb_usb_device * d,int i)904 static int su3000_power_ctrl(struct dvb_usb_device *d, int i)
905 {
906 struct dw2102_state *state = (struct dw2102_state *)d->priv;
907 int ret = 0;
908
909 info("%s: %d, initialized %d", __func__, i, state->initialized);
910
911 if (i && !state->initialized) {
912 mutex_lock(&d->data_mutex);
913
914 state->data[0] = 0xde;
915 state->data[1] = 0;
916
917 state->initialized = 1;
918 /* reset board */
919 ret = dvb_usb_generic_rw(d, state->data, 2, NULL, 0, 0);
920 mutex_unlock(&d->data_mutex);
921 }
922
923 return ret;
924 }
925
su3000_read_mac_address(struct dvb_usb_device * d,u8 mac[6])926 static int su3000_read_mac_address(struct dvb_usb_device *d, u8 mac[6])
927 {
928 int i;
929 u8 obuf[] = { 0x1f, 0xf0 };
930 u8 ibuf[] = { 0 };
931 struct i2c_msg msg[] = {
932 {
933 .addr = 0x51,
934 .flags = 0,
935 .buf = obuf,
936 .len = 2,
937 }, {
938 .addr = 0x51,
939 .flags = I2C_M_RD,
940 .buf = ibuf,
941 .len = 1,
942
943 }
944 };
945
946 for (i = 0; i < 6; i++) {
947 obuf[1] = 0xf0 + i;
948 if (i2c_transfer(&d->i2c_adap, msg, 2) != 2)
949 break;
950 else
951 mac[i] = ibuf[0];
952 }
953
954 return 0;
955 }
956
su3000_identify_state(struct usb_device * udev,const struct dvb_usb_device_properties * props,const struct dvb_usb_device_description ** desc,int * cold)957 static int su3000_identify_state(struct usb_device *udev,
958 const struct dvb_usb_device_properties *props,
959 const struct dvb_usb_device_description **desc,
960 int *cold)
961 {
962 info("%s", __func__);
963
964 *cold = 0;
965 return 0;
966 }
967
dw210x_set_voltage(struct dvb_frontend * fe,enum fe_sec_voltage voltage)968 static int dw210x_set_voltage(struct dvb_frontend *fe,
969 enum fe_sec_voltage voltage)
970 {
971 static u8 command_13v[] = {0x00, 0x01};
972 static u8 command_18v[] = {0x01, 0x01};
973 static u8 command_off[] = {0x00, 0x00};
974 struct i2c_msg msg = {
975 .addr = DW2102_VOLTAGE_CTRL,
976 .flags = 0,
977 .buf = command_off,
978 .len = 2,
979 };
980
981 struct dvb_usb_adapter *udev_adap =
982 (struct dvb_usb_adapter *)(fe->dvb->priv);
983 if (voltage == SEC_VOLTAGE_18)
984 msg.buf = command_18v;
985 else if (voltage == SEC_VOLTAGE_13)
986 msg.buf = command_13v;
987
988 i2c_transfer(&udev_adap->dev->i2c_adap, &msg, 1);
989
990 return 0;
991 }
992
s660_set_voltage(struct dvb_frontend * fe,enum fe_sec_voltage voltage)993 static int s660_set_voltage(struct dvb_frontend *fe,
994 enum fe_sec_voltage voltage)
995 {
996 struct dvb_usb_adapter *d =
997 (struct dvb_usb_adapter *)(fe->dvb->priv);
998 struct dw2102_state *st = (struct dw2102_state *)d->dev->priv;
999
1000 dw210x_set_voltage(fe, voltage);
1001 if (st->old_set_voltage)
1002 st->old_set_voltage(fe, voltage);
1003
1004 return 0;
1005 }
1006
dw210x_led_ctrl(struct dvb_frontend * fe,int offon)1007 static void dw210x_led_ctrl(struct dvb_frontend *fe, int offon)
1008 {
1009 static u8 led_off[] = { 0 };
1010 static u8 led_on[] = { 1 };
1011 struct i2c_msg msg = {
1012 .addr = DW2102_LED_CTRL,
1013 .flags = 0,
1014 .buf = led_off,
1015 .len = 1
1016 };
1017 struct dvb_usb_adapter *udev_adap =
1018 (struct dvb_usb_adapter *)(fe->dvb->priv);
1019
1020 if (offon)
1021 msg.buf = led_on;
1022 i2c_transfer(&udev_adap->dev->i2c_adap, &msg, 1);
1023 }
1024
tt_s2_4600_read_status(struct dvb_frontend * fe,enum fe_status * status)1025 static int tt_s2_4600_read_status(struct dvb_frontend *fe,
1026 enum fe_status *status)
1027 {
1028 struct dvb_usb_adapter *d =
1029 (struct dvb_usb_adapter *)(fe->dvb->priv);
1030 struct dw2102_state *st = (struct dw2102_state *)d->dev->priv;
1031 int ret;
1032
1033 ret = st->fe_read_status(fe, status);
1034
1035 /* resync slave fifo when signal change from unlock to lock */
1036 if ((*status & FE_HAS_LOCK) && (!st->last_lock))
1037 su3000_streaming_ctrl(d, 1);
1038
1039 st->last_lock = (*status & FE_HAS_LOCK) ? 1 : 0;
1040 return ret;
1041 }
1042
1043 static struct stv0299_config sharp_z0194a_config = {
1044 .demod_address = 0x68,
1045 .inittab = sharp_z0194a_inittab,
1046 .mclk = 88000000UL,
1047 .invert = 1,
1048 .skip_reinit = 0,
1049 .lock_output = STV0299_LOCKOUTPUT_1,
1050 .volt13_op0_op1 = STV0299_VOLT13_OP1,
1051 .min_delay_ms = 100,
1052 .set_symbol_rate = sharp_z0194a_set_symbol_rate,
1053 };
1054
1055 static struct cx24116_config dw2104_config = {
1056 .demod_address = 0x55,
1057 .mpg_clk_pos_pol = 0x01,
1058 };
1059
1060 static struct si21xx_config serit_sp1511lhb_config = {
1061 .demod_address = 0x68,
1062 .min_delay_ms = 100,
1063
1064 };
1065
1066 static struct tda10023_config dw3101_tda10023_config = {
1067 .demod_address = 0x0c,
1068 .invert = 1,
1069 };
1070
1071 static struct mt312_config zl313_config = {
1072 .demod_address = 0x0e,
1073 };
1074
1075 static struct ds3000_config dw2104_ds3000_config = {
1076 .demod_address = 0x68,
1077 };
1078
1079 static struct ts2020_config dw2104_ts2020_config = {
1080 .tuner_address = 0x60,
1081 .clk_out_div = 1,
1082 .frequency_div = 1060000,
1083 };
1084
1085 static struct ds3000_config s660_ds3000_config = {
1086 .demod_address = 0x68,
1087 .ci_mode = 1,
1088 .set_lock_led = dw210x_led_ctrl,
1089 };
1090
1091 static struct ts2020_config s660_ts2020_config = {
1092 .tuner_address = 0x60,
1093 .clk_out_div = 1,
1094 .frequency_div = 1146000,
1095 };
1096
1097 static struct stv0900_config dw2104a_stv0900_config = {
1098 .demod_address = 0x6a,
1099 .demod_mode = 0,
1100 .xtal = 27000000,
1101 .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */
1102 .diseqc_mode = 2,/* 2/3 PWM */
1103 .tun1_maddress = 0,/* 0x60 */
1104 .tun1_adc = 0,/* 2 Vpp */
1105 .path1_mode = 3,
1106 };
1107
1108 static struct stb6100_config dw2104a_stb6100_config = {
1109 .tuner_address = 0x60,
1110 .refclock = 27000000,
1111 };
1112
1113 static struct stv0900_config dw2104_stv0900_config = {
1114 .demod_address = 0x68,
1115 .demod_mode = 0,
1116 .xtal = 8000000,
1117 .clkmode = 3,
1118 .diseqc_mode = 2,
1119 .tun1_maddress = 0,
1120 .tun1_adc = 1,/* 1 Vpp */
1121 .path1_mode = 3,
1122 };
1123
1124 static struct stv6110_config dw2104_stv6110_config = {
1125 .i2c_address = 0x60,
1126 .mclk = 16000000,
1127 .clk_div = 1,
1128 };
1129
1130 static struct stv0900_config prof_7500_stv0900_config = {
1131 .demod_address = 0x6a,
1132 .demod_mode = 0,
1133 .xtal = 27000000,
1134 .clkmode = 3,/* 0-CLKI, 2-XTALI, else AUTO */
1135 .diseqc_mode = 2,/* 2/3 PWM */
1136 .tun1_maddress = 0,/* 0x60 */
1137 .tun1_adc = 0,/* 2 Vpp */
1138 .path1_mode = 3,
1139 .tun1_type = 3,
1140 .set_lock_led = dw210x_led_ctrl,
1141 };
1142
1143 static struct ds3000_config su3000_ds3000_config = {
1144 .demod_address = 0x68,
1145 .ci_mode = 1,
1146 .set_lock_led = dw210x_led_ctrl,
1147 };
1148
1149 static struct cxd2820r_config cxd2820r_config = {
1150 .i2c_address = 0x6c, /* (0xd8 >> 1) */
1151 .ts_mode = 0x38,
1152 .ts_clock_inv = 1,
1153 };
1154
1155 static struct tda18271_config tda18271_config = {
1156 .output_opt = TDA18271_OUTPUT_LT_OFF,
1157 .gate = TDA18271_GATE_DIGITAL,
1158 };
1159
1160 static u8 m88rs2000_inittab[] = {
1161 DEMOD_WRITE, 0x9a, 0x30,
1162 DEMOD_WRITE, 0x00, 0x01,
1163 WRITE_DELAY, 0x19, 0x00,
1164 DEMOD_WRITE, 0x00, 0x00,
1165 DEMOD_WRITE, 0x9a, 0xb0,
1166 DEMOD_WRITE, 0x81, 0xc1,
1167 DEMOD_WRITE, 0x81, 0x81,
1168 DEMOD_WRITE, 0x86, 0xc6,
1169 DEMOD_WRITE, 0x9a, 0x30,
1170 DEMOD_WRITE, 0xf0, 0x80,
1171 DEMOD_WRITE, 0xf1, 0xbf,
1172 DEMOD_WRITE, 0xb0, 0x45,
1173 DEMOD_WRITE, 0xb2, 0x01,
1174 DEMOD_WRITE, 0x9a, 0xb0,
1175 0xff, 0xaa, 0xff
1176 };
1177
1178 static struct m88rs2000_config s421_m88rs2000_config = {
1179 .demod_addr = 0x68,
1180 .inittab = m88rs2000_inittab,
1181 };
1182
dw2104_frontend_attach(struct dvb_usb_adapter * d)1183 static int dw2104_frontend_attach(struct dvb_usb_adapter *d)
1184 {
1185 struct dvb_tuner_ops *tuner_ops = NULL;
1186
1187 if (demod_probe & 4) {
1188 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &dw2104a_stv0900_config,
1189 &d->dev->i2c_adap, 0);
1190 if (d->fe_adap[0].fe != NULL) {
1191 if (dvb_attach(stb6100_attach, d->fe_adap[0].fe,
1192 &dw2104a_stb6100_config,
1193 &d->dev->i2c_adap)) {
1194 tuner_ops = &d->fe_adap[0].fe->ops.tuner_ops;
1195 tuner_ops->set_frequency = stb6100_set_freq;
1196 tuner_ops->get_frequency = stb6100_get_freq;
1197 tuner_ops->set_bandwidth = stb6100_set_bandw;
1198 tuner_ops->get_bandwidth = stb6100_get_bandw;
1199 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1200 info("Attached STV0900+STB6100!");
1201 return 0;
1202 }
1203 }
1204 }
1205
1206 if (demod_probe & 2) {
1207 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &dw2104_stv0900_config,
1208 &d->dev->i2c_adap, 0);
1209 if (d->fe_adap[0].fe != NULL) {
1210 if (dvb_attach(stv6110_attach, d->fe_adap[0].fe,
1211 &dw2104_stv6110_config,
1212 &d->dev->i2c_adap)) {
1213 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1214 info("Attached STV0900+STV6110A!");
1215 return 0;
1216 }
1217 }
1218 }
1219
1220 if (demod_probe & 1) {
1221 d->fe_adap[0].fe = dvb_attach(cx24116_attach, &dw2104_config,
1222 &d->dev->i2c_adap);
1223 if (d->fe_adap[0].fe != NULL) {
1224 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1225 info("Attached cx24116!");
1226 return 0;
1227 }
1228 }
1229
1230 d->fe_adap[0].fe = dvb_attach(ds3000_attach, &dw2104_ds3000_config,
1231 &d->dev->i2c_adap);
1232 if (d->fe_adap[0].fe != NULL) {
1233 dvb_attach(ts2020_attach, d->fe_adap[0].fe,
1234 &dw2104_ts2020_config, &d->dev->i2c_adap);
1235 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1236 info("Attached DS3000!");
1237 return 0;
1238 }
1239
1240 return -EIO;
1241 }
1242
1243 static struct dvb_usb_device_properties dw2102_properties;
1244 static struct dvb_usb_device_properties dw2104_properties;
1245 static struct dvb_usb_device_properties s6x0_properties;
1246
dw2102_frontend_attach(struct dvb_usb_adapter * d)1247 static int dw2102_frontend_attach(struct dvb_usb_adapter *d)
1248 {
1249 if (dw2102_properties.i2c_algo == &dw2102_serit_i2c_algo) {
1250 /*dw2102_properties.adapter->tuner_attach = NULL;*/
1251 d->fe_adap[0].fe = dvb_attach(si21xx_attach, &serit_sp1511lhb_config,
1252 &d->dev->i2c_adap);
1253 if (d->fe_adap[0].fe != NULL) {
1254 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1255 info("Attached si21xx!");
1256 return 0;
1257 }
1258 }
1259
1260 if (dw2102_properties.i2c_algo == &dw2102_earda_i2c_algo) {
1261 d->fe_adap[0].fe = dvb_attach(stv0288_attach, &earda_config,
1262 &d->dev->i2c_adap);
1263 if (d->fe_adap[0].fe != NULL) {
1264 if (dvb_attach(stb6000_attach, d->fe_adap[0].fe, 0x61,
1265 &d->dev->i2c_adap)) {
1266 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1267 info("Attached stv0288!");
1268 return 0;
1269 }
1270 }
1271 }
1272
1273 if (dw2102_properties.i2c_algo == &dw2102_i2c_algo) {
1274 /*dw2102_properties.adapter->tuner_attach = dw2102_tuner_attach;*/
1275 d->fe_adap[0].fe = dvb_attach(stv0299_attach, &sharp_z0194a_config,
1276 &d->dev->i2c_adap);
1277 if (d->fe_adap[0].fe != NULL) {
1278 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1279 info("Attached stv0299!");
1280 return 0;
1281 }
1282 }
1283 return -EIO;
1284 }
1285
dw3101_frontend_attach(struct dvb_usb_adapter * d)1286 static int dw3101_frontend_attach(struct dvb_usb_adapter *d)
1287 {
1288 d->fe_adap[0].fe = dvb_attach(tda10023_attach, &dw3101_tda10023_config,
1289 &d->dev->i2c_adap, 0x48);
1290 if (d->fe_adap[0].fe != NULL) {
1291 info("Attached tda10023!");
1292 return 0;
1293 }
1294 return -EIO;
1295 }
1296
zl100313_frontend_attach(struct dvb_usb_adapter * d)1297 static int zl100313_frontend_attach(struct dvb_usb_adapter *d)
1298 {
1299 d->fe_adap[0].fe = dvb_attach(mt312_attach, &zl313_config,
1300 &d->dev->i2c_adap);
1301 if (d->fe_adap[0].fe != NULL) {
1302 if (dvb_attach(zl10039_attach, d->fe_adap[0].fe, 0x60,
1303 &d->dev->i2c_adap)) {
1304 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1305 info("Attached zl100313+zl10039!");
1306 return 0;
1307 }
1308 }
1309
1310 return -EIO;
1311 }
1312
stv0288_frontend_attach(struct dvb_usb_adapter * d)1313 static int stv0288_frontend_attach(struct dvb_usb_adapter *d)
1314 {
1315 u8 obuf[] = {7, 1};
1316
1317 d->fe_adap[0].fe = dvb_attach(stv0288_attach, &earda_config,
1318 &d->dev->i2c_adap);
1319
1320 if (d->fe_adap[0].fe == NULL)
1321 return -EIO;
1322
1323 if (NULL == dvb_attach(stb6000_attach, d->fe_adap[0].fe, 0x61, &d->dev->i2c_adap))
1324 return -EIO;
1325
1326 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1327
1328 dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG);
1329
1330 info("Attached stv0288+stb6000!");
1331
1332 return 0;
1333
1334 }
1335
ds3000_frontend_attach(struct dvb_usb_adapter * d)1336 static int ds3000_frontend_attach(struct dvb_usb_adapter *d)
1337 {
1338 struct dw2102_state *st = d->dev->priv;
1339 u8 obuf[] = {7, 1};
1340
1341 d->fe_adap[0].fe = dvb_attach(ds3000_attach, &s660_ds3000_config,
1342 &d->dev->i2c_adap);
1343
1344 if (d->fe_adap[0].fe == NULL)
1345 return -EIO;
1346
1347 dvb_attach(ts2020_attach, d->fe_adap[0].fe, &s660_ts2020_config,
1348 &d->dev->i2c_adap);
1349
1350 st->old_set_voltage = d->fe_adap[0].fe->ops.set_voltage;
1351 d->fe_adap[0].fe->ops.set_voltage = s660_set_voltage;
1352
1353 dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG);
1354
1355 info("Attached ds3000+ts2020!");
1356
1357 return 0;
1358 }
1359
prof_7500_frontend_attach(struct dvb_usb_adapter * d)1360 static int prof_7500_frontend_attach(struct dvb_usb_adapter *d)
1361 {
1362 u8 obuf[] = {7, 1};
1363
1364 d->fe_adap[0].fe = dvb_attach(stv0900_attach, &prof_7500_stv0900_config,
1365 &d->dev->i2c_adap, 0);
1366 if (d->fe_adap[0].fe == NULL)
1367 return -EIO;
1368
1369 d->fe_adap[0].fe->ops.set_voltage = dw210x_set_voltage;
1370
1371 dw210x_op_rw(d->dev->udev, 0x8a, 0, 0, obuf, 2, DW210X_WRITE_MSG);
1372
1373 info("Attached STV0900+STB6100A!");
1374
1375 return 0;
1376 }
1377
su3000_frontend_attach(struct dvb_usb_adapter * adap)1378 static int su3000_frontend_attach(struct dvb_usb_adapter *adap)
1379 {
1380 struct dvb_usb_device *d = adap->dev;
1381 struct dw2102_state *state = d->priv;
1382
1383 mutex_lock(&d->data_mutex);
1384
1385 state->data[0] = 0xe;
1386 state->data[1] = 0x80;
1387 state->data[2] = 0;
1388
1389 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1390 err("command 0x0e transfer failed.");
1391
1392 state->data[0] = 0xe;
1393 state->data[1] = 0x02;
1394 state->data[2] = 1;
1395
1396 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1397 err("command 0x0e transfer failed.");
1398 msleep(300);
1399
1400 state->data[0] = 0xe;
1401 state->data[1] = 0x83;
1402 state->data[2] = 0;
1403
1404 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1405 err("command 0x0e transfer failed.");
1406
1407 state->data[0] = 0xe;
1408 state->data[1] = 0x83;
1409 state->data[2] = 1;
1410
1411 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1412 err("command 0x0e transfer failed.");
1413
1414 state->data[0] = 0x51;
1415
1416 if (dvb_usb_generic_rw(d, state->data, 1, state->data, 1, 0) < 0)
1417 err("command 0x51 transfer failed.");
1418
1419 mutex_unlock(&d->data_mutex);
1420
1421 adap->fe_adap[0].fe = dvb_attach(ds3000_attach, &su3000_ds3000_config,
1422 &d->i2c_adap);
1423 if (adap->fe_adap[0].fe == NULL)
1424 return -EIO;
1425
1426 if (dvb_attach(ts2020_attach, adap->fe_adap[0].fe,
1427 &dw2104_ts2020_config,
1428 &d->i2c_adap)) {
1429 info("Attached DS3000/TS2020!");
1430 return 0;
1431 }
1432
1433 info("Failed to attach DS3000/TS2020!");
1434 return -EIO;
1435 }
1436
t220_frontend_attach(struct dvb_usb_adapter * adap)1437 static int t220_frontend_attach(struct dvb_usb_adapter *adap)
1438 {
1439 struct dvb_usb_device *d = adap->dev;
1440 struct dw2102_state *state = d->priv;
1441
1442 mutex_lock(&d->data_mutex);
1443
1444 state->data[0] = 0xe;
1445 state->data[1] = 0x87;
1446 state->data[2] = 0x0;
1447
1448 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1449 err("command 0x0e transfer failed.");
1450
1451 state->data[0] = 0xe;
1452 state->data[1] = 0x86;
1453 state->data[2] = 1;
1454
1455 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1456 err("command 0x0e transfer failed.");
1457
1458 state->data[0] = 0xe;
1459 state->data[1] = 0x80;
1460 state->data[2] = 0;
1461
1462 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1463 err("command 0x0e transfer failed.");
1464
1465 msleep(50);
1466
1467 state->data[0] = 0xe;
1468 state->data[1] = 0x80;
1469 state->data[2] = 1;
1470
1471 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1472 err("command 0x0e transfer failed.");
1473
1474 state->data[0] = 0x51;
1475
1476 if (dvb_usb_generic_rw(d, state->data, 1, state->data, 1, 0) < 0)
1477 err("command 0x51 transfer failed.");
1478
1479 mutex_unlock(&d->data_mutex);
1480
1481 adap->fe_adap[0].fe = dvb_attach(cxd2820r_attach, &cxd2820r_config,
1482 &d->i2c_adap, NULL);
1483 if (adap->fe_adap[0].fe != NULL) {
1484 if (dvb_attach(tda18271_attach, adap->fe_adap[0].fe, 0x60,
1485 &d->i2c_adap, &tda18271_config)) {
1486 info("Attached TDA18271HD/CXD2820R!");
1487 return 0;
1488 }
1489 }
1490
1491 info("Failed to attach TDA18271HD/CXD2820R!");
1492 return -EIO;
1493 }
1494
m88rs2000_frontend_attach(struct dvb_usb_adapter * adap)1495 static int m88rs2000_frontend_attach(struct dvb_usb_adapter *adap)
1496 {
1497 struct dvb_usb_device *d = adap->dev;
1498 struct dw2102_state *state = d->priv;
1499
1500 mutex_lock(&d->data_mutex);
1501
1502 state->data[0] = 0x51;
1503
1504 if (dvb_usb_generic_rw(d, state->data, 1, state->data, 1, 0) < 0)
1505 err("command 0x51 transfer failed.");
1506
1507 mutex_unlock(&d->data_mutex);
1508
1509 adap->fe_adap[0].fe = dvb_attach(m88rs2000_attach,
1510 &s421_m88rs2000_config,
1511 &d->i2c_adap);
1512
1513 if (adap->fe_adap[0].fe == NULL)
1514 return -EIO;
1515
1516 if (dvb_attach(ts2020_attach, adap->fe_adap[0].fe,
1517 &dw2104_ts2020_config,
1518 &d->i2c_adap)) {
1519 info("Attached RS2000/TS2020!");
1520 return 0;
1521 }
1522
1523 info("Failed to attach RS2000/TS2020!");
1524 return -EIO;
1525 }
1526
tt_s2_4600_frontend_attach_probe_demod(struct dvb_usb_device * d,const int probe_addr)1527 static int tt_s2_4600_frontend_attach_probe_demod(struct dvb_usb_device *d,
1528 const int probe_addr)
1529 {
1530 struct dw2102_state *state = d->priv;
1531
1532 state->data[0] = 0x9;
1533 state->data[1] = 0x1;
1534 state->data[2] = 0x1;
1535 state->data[3] = probe_addr;
1536 state->data[4] = 0x0;
1537
1538 if (dvb_usb_generic_rw(d, state->data, 5, state->data, 2, 0) < 0) {
1539 err("i2c probe for address 0x%x failed.", probe_addr);
1540 return 0;
1541 }
1542
1543 if (state->data[0] != 8) /* fail(7) or error, no device at address */
1544 return 0;
1545
1546 /* probing successful */
1547 return 1;
1548 }
1549
tt_s2_4600_frontend_attach(struct dvb_usb_adapter * adap)1550 static int tt_s2_4600_frontend_attach(struct dvb_usb_adapter *adap)
1551 {
1552 struct dvb_usb_device *d = adap->dev;
1553 struct dw2102_state *state = d->priv;
1554 struct i2c_adapter *i2c_adapter;
1555 struct i2c_client *client;
1556 struct i2c_board_info board_info;
1557 struct m88ds3103_platform_data m88ds3103_pdata = {};
1558 struct ts2020_config ts2020_config = {};
1559 int demod_addr;
1560
1561 mutex_lock(&d->data_mutex);
1562
1563 state->data[0] = 0xe;
1564 state->data[1] = 0x80;
1565 state->data[2] = 0x0;
1566
1567 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1568 err("command 0x0e transfer failed.");
1569
1570 state->data[0] = 0xe;
1571 state->data[1] = 0x02;
1572 state->data[2] = 1;
1573
1574 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1575 err("command 0x0e transfer failed.");
1576 msleep(300);
1577
1578 state->data[0] = 0xe;
1579 state->data[1] = 0x83;
1580 state->data[2] = 0;
1581
1582 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1583 err("command 0x0e transfer failed.");
1584
1585 state->data[0] = 0xe;
1586 state->data[1] = 0x83;
1587 state->data[2] = 1;
1588
1589 if (dvb_usb_generic_rw(d, state->data, 3, state->data, 1, 0) < 0)
1590 err("command 0x0e transfer failed.");
1591
1592 state->data[0] = 0x51;
1593
1594 if (dvb_usb_generic_rw(d, state->data, 1, state->data, 1, 0) < 0)
1595 err("command 0x51 transfer failed.");
1596
1597 /* probe for demodulator i2c address */
1598 demod_addr = -1;
1599 if (tt_s2_4600_frontend_attach_probe_demod(d, 0x68))
1600 demod_addr = 0x68;
1601 else if (tt_s2_4600_frontend_attach_probe_demod(d, 0x69))
1602 demod_addr = 0x69;
1603 else if (tt_s2_4600_frontend_attach_probe_demod(d, 0x6a))
1604 demod_addr = 0x6a;
1605
1606 mutex_unlock(&d->data_mutex);
1607
1608 if (demod_addr < 0) {
1609 err("probing for demodulator failed. Is the external power switched on?");
1610 return -ENODEV;
1611 }
1612
1613 /* attach demod */
1614 m88ds3103_pdata.clk = 27000000;
1615 m88ds3103_pdata.i2c_wr_max = 33;
1616 m88ds3103_pdata.ts_mode = M88DS3103_TS_CI;
1617 m88ds3103_pdata.ts_clk = 16000;
1618 m88ds3103_pdata.ts_clk_pol = 0;
1619 m88ds3103_pdata.spec_inv = 0;
1620 m88ds3103_pdata.agc = 0x99;
1621 m88ds3103_pdata.agc_inv = 0;
1622 m88ds3103_pdata.clk_out = M88DS3103_CLOCK_OUT_ENABLED;
1623 m88ds3103_pdata.envelope_mode = 0;
1624 m88ds3103_pdata.lnb_hv_pol = 1;
1625 m88ds3103_pdata.lnb_en_pol = 0;
1626 memset(&board_info, 0, sizeof(board_info));
1627 if (demod_addr == 0x6a)
1628 strscpy(board_info.type, "m88ds3103b", I2C_NAME_SIZE);
1629 else
1630 strscpy(board_info.type, "m88ds3103", I2C_NAME_SIZE);
1631 board_info.addr = demod_addr;
1632 board_info.platform_data = &m88ds3103_pdata;
1633 request_module("m88ds3103");
1634 client = i2c_new_client_device(&d->i2c_adap, &board_info);
1635 if (!i2c_client_has_driver(client))
1636 return -ENODEV;
1637 if (!try_module_get(client->dev.driver->owner)) {
1638 i2c_unregister_device(client);
1639 return -ENODEV;
1640 }
1641 adap->fe_adap[0].fe = m88ds3103_pdata.get_dvb_frontend(client);
1642 i2c_adapter = m88ds3103_pdata.get_i2c_adapter(client);
1643
1644 state->i2c_client_demod = client;
1645
1646 /* attach tuner */
1647 ts2020_config.fe = adap->fe_adap[0].fe;
1648 memset(&board_info, 0, sizeof(board_info));
1649 strscpy(board_info.type, "ts2022", I2C_NAME_SIZE);
1650 board_info.addr = 0x60;
1651 board_info.platform_data = &ts2020_config;
1652 request_module("ts2020");
1653 client = i2c_new_client_device(i2c_adapter, &board_info);
1654
1655 if (!i2c_client_has_driver(client)) {
1656 dvb_frontend_detach(adap->fe_adap[0].fe);
1657 return -ENODEV;
1658 }
1659
1660 if (!try_module_get(client->dev.driver->owner)) {
1661 i2c_unregister_device(client);
1662 dvb_frontend_detach(adap->fe_adap[0].fe);
1663 return -ENODEV;
1664 }
1665
1666 /* delegate signal strength measurement to tuner */
1667 adap->fe_adap[0].fe->ops.read_signal_strength =
1668 adap->fe_adap[0].fe->ops.tuner_ops.get_rf_strength;
1669
1670 state->i2c_client_tuner = client;
1671
1672 /* hook fe: need to resync the slave fifo when signal locks */
1673 state->fe_read_status = adap->fe_adap[0].fe->ops.read_status;
1674 adap->fe_adap[0].fe->ops.read_status = tt_s2_4600_read_status;
1675
1676 state->last_lock = 0;
1677
1678 return 0;
1679 }
1680
dw2102_tuner_attach(struct dvb_usb_adapter * adap)1681 static int dw2102_tuner_attach(struct dvb_usb_adapter *adap)
1682 {
1683 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
1684 &adap->dev->i2c_adap, DVB_PLL_OPERA1);
1685 return 0;
1686 }
1687
dw3101_tuner_attach(struct dvb_usb_adapter * adap)1688 static int dw3101_tuner_attach(struct dvb_usb_adapter *adap)
1689 {
1690 dvb_attach(dvb_pll_attach, adap->fe_adap[0].fe, 0x60,
1691 &adap->dev->i2c_adap, DVB_PLL_TUA6034);
1692
1693 return 0;
1694 }
1695
dw2102_rc_query(struct dvb_usb_device * d)1696 static int dw2102_rc_query(struct dvb_usb_device *d)
1697 {
1698 u8 key[2];
1699 struct i2c_msg msg = {
1700 .addr = DW2102_RC_QUERY,
1701 .flags = I2C_M_RD,
1702 .buf = key,
1703 .len = 2
1704 };
1705
1706 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) {
1707 if (msg.buf[0] != 0xff) {
1708 deb_rc("%s: rc code: %x, %x\n",
1709 __func__, key[0], key[1]);
1710 rc_keydown(d->rc_dev, RC_PROTO_UNKNOWN, key[0], 0);
1711 }
1712 }
1713
1714 return 0;
1715 }
1716
prof_rc_query(struct dvb_usb_device * d)1717 static int prof_rc_query(struct dvb_usb_device *d)
1718 {
1719 u8 key[2];
1720 struct i2c_msg msg = {
1721 .addr = DW2102_RC_QUERY,
1722 .flags = I2C_M_RD,
1723 .buf = key,
1724 .len = 2
1725 };
1726
1727 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) {
1728 if (msg.buf[0] != 0xff) {
1729 deb_rc("%s: rc code: %x, %x\n",
1730 __func__, key[0], key[1]);
1731 rc_keydown(d->rc_dev, RC_PROTO_UNKNOWN, key[0] ^ 0xff,
1732 0);
1733 }
1734 }
1735
1736 return 0;
1737 }
1738
su3000_rc_query(struct dvb_usb_device * d)1739 static int su3000_rc_query(struct dvb_usb_device *d)
1740 {
1741 u8 key[2];
1742 struct i2c_msg msg = {
1743 .addr = DW2102_RC_QUERY,
1744 .flags = I2C_M_RD,
1745 .buf = key,
1746 .len = 2
1747 };
1748
1749 if (d->props.i2c_algo->master_xfer(&d->i2c_adap, &msg, 1) == 1) {
1750 if (msg.buf[0] != 0xff) {
1751 deb_rc("%s: rc code: %x, %x\n",
1752 __func__, key[0], key[1]);
1753 rc_keydown(d->rc_dev, RC_PROTO_RC5,
1754 RC_SCANCODE_RC5(key[1], key[0]), 0);
1755 }
1756 }
1757
1758 return 0;
1759 }
1760
1761 enum dw2102_table_entry {
1762 CYPRESS_DW2102,
1763 CYPRESS_DW2101,
1764 CYPRESS_DW2104,
1765 TEVII_S650,
1766 TERRATEC_CINERGY_S,
1767 CYPRESS_DW3101,
1768 TEVII_S630,
1769 PROF_1100,
1770 TEVII_S660,
1771 PROF_7500,
1772 GENIATECH_SU3000,
1773 HAUPPAUGE_MAX_S2,
1774 TERRATEC_CINERGY_S2_R1,
1775 TEVII_S480_1,
1776 TEVII_S480_2,
1777 GENIATECH_X3M_SPC1400HD,
1778 TEVII_S421,
1779 TEVII_S632,
1780 TERRATEC_CINERGY_S2_R2,
1781 TERRATEC_CINERGY_S2_R3,
1782 TERRATEC_CINERGY_S2_R4,
1783 TERRATEC_CINERGY_S2_1,
1784 TERRATEC_CINERGY_S2_2,
1785 GOTVIEW_SAT_HD,
1786 GENIATECH_T220,
1787 TECHNOTREND_CONNECT_S2_4600,
1788 TEVII_S482_1,
1789 TEVII_S482_2,
1790 TERRATEC_CINERGY_S2_BOX,
1791 TEVII_S662
1792 };
1793
1794 static struct usb_device_id dw2102_table[] = {
1795 DVB_USB_DEV(CYPRESS, CYPRESS_DW2102),
1796 DVB_USB_DEV(CYPRESS, CYPRESS_DW2101),
1797 DVB_USB_DEV(CYPRESS, CYPRESS_DW2104),
1798 DVB_USB_DEV(TEVII, TEVII_S650),
1799 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_S),
1800 DVB_USB_DEV(CYPRESS, CYPRESS_DW3101),
1801 DVB_USB_DEV(TEVII, TEVII_S630),
1802 DVB_USB_DEV(PROF_1, PROF_1100),
1803 DVB_USB_DEV(TEVII, TEVII_S660),
1804 DVB_USB_DEV(PROF_2, PROF_7500),
1805 DVB_USB_DEV(GTEK, GENIATECH_SU3000),
1806 DVB_USB_DEV(HAUPPAUGE, HAUPPAUGE_MAX_S2),
1807 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_S2_R1),
1808 DVB_USB_DEV(TEVII, TEVII_S480_1),
1809 DVB_USB_DEV(TEVII, TEVII_S480_2),
1810 DVB_USB_DEV(GTEK, GENIATECH_X3M_SPC1400HD),
1811 DVB_USB_DEV(TEVII, TEVII_S421),
1812 DVB_USB_DEV(TEVII, TEVII_S632),
1813 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_S2_R2),
1814 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_S2_R3),
1815 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_S2_R4),
1816 DVB_USB_DEV(TERRATEC_2, TERRATEC_CINERGY_S2_1),
1817 DVB_USB_DEV(TERRATEC_2, TERRATEC_CINERGY_S2_2),
1818 DVB_USB_DEV(GOTVIEW, GOTVIEW_SAT_HD),
1819 DVB_USB_DEV(GTEK, GENIATECH_T220),
1820 DVB_USB_DEV(TECHNOTREND, TECHNOTREND_CONNECT_S2_4600),
1821 DVB_USB_DEV(TEVII, TEVII_S482_1),
1822 DVB_USB_DEV(TEVII, TEVII_S482_2),
1823 DVB_USB_DEV(TERRATEC, TERRATEC_CINERGY_S2_BOX),
1824 DVB_USB_DEV(TEVII, TEVII_S662),
1825 { }
1826 };
1827
1828 MODULE_DEVICE_TABLE(usb, dw2102_table);
1829
dw2102_load_firmware(struct usb_device * dev,const struct firmware * frmwr)1830 static int dw2102_load_firmware(struct usb_device *dev,
1831 const struct firmware *frmwr)
1832 {
1833 u8 *b, *p;
1834 int ret = 0, i;
1835 u8 reset;
1836 u8 reset16[] = {0, 0, 0, 0, 0, 0, 0};
1837 const struct firmware *fw;
1838
1839 switch (le16_to_cpu(dev->descriptor.idProduct)) {
1840 case 0x2101:
1841 ret = request_firmware(&fw, DW2101_FIRMWARE, &dev->dev);
1842 if (ret != 0) {
1843 err(err_str, DW2101_FIRMWARE);
1844 return ret;
1845 }
1846 break;
1847 default:
1848 fw = frmwr;
1849 break;
1850 }
1851 info("start downloading DW210X firmware");
1852 p = kmalloc(fw->size, GFP_KERNEL);
1853 reset = 1;
1854 /*stop the CPU*/
1855 dw210x_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1, DW210X_WRITE_MSG);
1856 dw210x_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1, DW210X_WRITE_MSG);
1857
1858 if (p != NULL) {
1859 memcpy(p, fw->data, fw->size);
1860 for (i = 0; i < fw->size; i += 0x40) {
1861 b = (u8 *) p + i;
1862 if (dw210x_op_rw(dev, 0xa0, i, 0, b , 0x40,
1863 DW210X_WRITE_MSG) != 0x40) {
1864 err("error while transferring firmware");
1865 ret = -EINVAL;
1866 break;
1867 }
1868 }
1869 /* restart the CPU */
1870 reset = 0;
1871 if (ret || dw210x_op_rw(dev, 0xa0, 0x7f92, 0, &reset, 1,
1872 DW210X_WRITE_MSG) != 1) {
1873 err("could not restart the USB controller CPU.");
1874 ret = -EINVAL;
1875 }
1876 if (ret || dw210x_op_rw(dev, 0xa0, 0xe600, 0, &reset, 1,
1877 DW210X_WRITE_MSG) != 1) {
1878 err("could not restart the USB controller CPU.");
1879 ret = -EINVAL;
1880 }
1881 /* init registers */
1882 switch (le16_to_cpu(dev->descriptor.idProduct)) {
1883 case USB_PID_TEVII_S650:
1884 dw2104_properties.rc.core.rc_codes = RC_MAP_TEVII_NEC;
1885 fallthrough;
1886 case USB_PID_CYPRESS_DW2104:
1887 reset = 1;
1888 dw210x_op_rw(dev, 0xc4, 0x0000, 0, &reset, 1,
1889 DW210X_WRITE_MSG);
1890 fallthrough;
1891 case USB_PID_CYPRESS_DW3101:
1892 reset = 0;
1893 dw210x_op_rw(dev, 0xbf, 0x0040, 0, &reset, 0,
1894 DW210X_WRITE_MSG);
1895 break;
1896 case USB_PID_TERRATEC_CINERGY_S:
1897 case USB_PID_CYPRESS_DW2102:
1898 dw210x_op_rw(dev, 0xbf, 0x0040, 0, &reset, 0,
1899 DW210X_WRITE_MSG);
1900 dw210x_op_rw(dev, 0xb9, 0x0000, 0, &reset16[0], 2,
1901 DW210X_READ_MSG);
1902 /* check STV0299 frontend */
1903 dw210x_op_rw(dev, 0xb5, 0, 0, &reset16[0], 2,
1904 DW210X_READ_MSG);
1905 if ((reset16[0] == 0xa1) || (reset16[0] == 0x80)) {
1906 dw2102_properties.i2c_algo = &dw2102_i2c_algo;
1907 dw2102_properties.adapter->fe[0].tuner_attach = &dw2102_tuner_attach;
1908 break;
1909 } else {
1910 /* check STV0288 frontend */
1911 reset16[0] = 0xd0;
1912 reset16[1] = 1;
1913 reset16[2] = 0;
1914 dw210x_op_rw(dev, 0xc2, 0, 0, &reset16[0], 3,
1915 DW210X_WRITE_MSG);
1916 dw210x_op_rw(dev, 0xc3, 0xd1, 0, &reset16[0], 3,
1917 DW210X_READ_MSG);
1918 if (reset16[2] == 0x11) {
1919 dw2102_properties.i2c_algo = &dw2102_earda_i2c_algo;
1920 break;
1921 }
1922 }
1923 fallthrough;
1924 case 0x2101:
1925 dw210x_op_rw(dev, 0xbc, 0x0030, 0, &reset16[0], 2,
1926 DW210X_READ_MSG);
1927 dw210x_op_rw(dev, 0xba, 0x0000, 0, &reset16[0], 7,
1928 DW210X_READ_MSG);
1929 dw210x_op_rw(dev, 0xba, 0x0000, 0, &reset16[0], 7,
1930 DW210X_READ_MSG);
1931 dw210x_op_rw(dev, 0xb9, 0x0000, 0, &reset16[0], 2,
1932 DW210X_READ_MSG);
1933 break;
1934 }
1935
1936 msleep(100);
1937 kfree(p);
1938 }
1939
1940 if (le16_to_cpu(dev->descriptor.idProduct) == 0x2101)
1941 release_firmware(fw);
1942 return ret;
1943 }
1944
1945 static struct dvb_usb_device_properties dw2102_properties = {
1946 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1947 .usb_ctrl = DEVICE_SPECIFIC,
1948 .firmware = DW2102_FIRMWARE,
1949 .no_reconnect = 1,
1950
1951 .i2c_algo = &dw2102_serit_i2c_algo,
1952
1953 .rc.core = {
1954 .rc_interval = 150,
1955 .rc_codes = RC_MAP_DM1105_NEC,
1956 .module_name = "dw2102",
1957 .allowed_protos = RC_PROTO_BIT_NEC,
1958 .rc_query = dw2102_rc_query,
1959 },
1960
1961 .generic_bulk_ctrl_endpoint = 0x81,
1962 /* parameter for the MPEG2-data transfer */
1963 .num_adapters = 1,
1964 .download_firmware = dw2102_load_firmware,
1965 .read_mac_address = dw210x_read_mac_address,
1966 .adapter = {
1967 {
1968 .num_frontends = 1,
1969 .fe = {{
1970 .frontend_attach = dw2102_frontend_attach,
1971 .stream = {
1972 .type = USB_BULK,
1973 .count = 8,
1974 .endpoint = 0x82,
1975 .u = {
1976 .bulk = {
1977 .buffersize = 4096,
1978 }
1979 }
1980 },
1981 }},
1982 }
1983 },
1984 .num_device_descs = 3,
1985 .devices = {
1986 {"DVBWorld DVB-S 2102 USB2.0",
1987 {&dw2102_table[CYPRESS_DW2102], NULL},
1988 {NULL},
1989 },
1990 {"DVBWorld DVB-S 2101 USB2.0",
1991 {&dw2102_table[CYPRESS_DW2101], NULL},
1992 {NULL},
1993 },
1994 {"TerraTec Cinergy S USB",
1995 {&dw2102_table[TERRATEC_CINERGY_S], NULL},
1996 {NULL},
1997 },
1998 }
1999 };
2000
2001 static struct dvb_usb_device_properties dw2104_properties = {
2002 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2003 .usb_ctrl = DEVICE_SPECIFIC,
2004 .firmware = DW2104_FIRMWARE,
2005 .no_reconnect = 1,
2006
2007 .i2c_algo = &dw2104_i2c_algo,
2008 .rc.core = {
2009 .rc_interval = 150,
2010 .rc_codes = RC_MAP_DM1105_NEC,
2011 .module_name = "dw2102",
2012 .allowed_protos = RC_PROTO_BIT_NEC,
2013 .rc_query = dw2102_rc_query,
2014 },
2015
2016 .generic_bulk_ctrl_endpoint = 0x81,
2017 /* parameter for the MPEG2-data transfer */
2018 .num_adapters = 1,
2019 .download_firmware = dw2102_load_firmware,
2020 .read_mac_address = dw210x_read_mac_address,
2021 .adapter = {
2022 {
2023 .num_frontends = 1,
2024 .fe = {{
2025 .frontend_attach = dw2104_frontend_attach,
2026 .stream = {
2027 .type = USB_BULK,
2028 .count = 8,
2029 .endpoint = 0x82,
2030 .u = {
2031 .bulk = {
2032 .buffersize = 4096,
2033 }
2034 }
2035 },
2036 }},
2037 }
2038 },
2039 .num_device_descs = 2,
2040 .devices = {
2041 { "DVBWorld DW2104 USB2.0",
2042 {&dw2102_table[CYPRESS_DW2104], NULL},
2043 {NULL},
2044 },
2045 { "TeVii S650 USB2.0",
2046 {&dw2102_table[TEVII_S650], NULL},
2047 {NULL},
2048 },
2049 }
2050 };
2051
2052 static struct dvb_usb_device_properties dw3101_properties = {
2053 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2054 .usb_ctrl = DEVICE_SPECIFIC,
2055 .firmware = DW3101_FIRMWARE,
2056 .no_reconnect = 1,
2057
2058 .i2c_algo = &dw3101_i2c_algo,
2059 .rc.core = {
2060 .rc_interval = 150,
2061 .rc_codes = RC_MAP_DM1105_NEC,
2062 .module_name = "dw2102",
2063 .allowed_protos = RC_PROTO_BIT_NEC,
2064 .rc_query = dw2102_rc_query,
2065 },
2066
2067 .generic_bulk_ctrl_endpoint = 0x81,
2068 /* parameter for the MPEG2-data transfer */
2069 .num_adapters = 1,
2070 .download_firmware = dw2102_load_firmware,
2071 .read_mac_address = dw210x_read_mac_address,
2072 .adapter = {
2073 {
2074 .num_frontends = 1,
2075 .fe = {{
2076 .frontend_attach = dw3101_frontend_attach,
2077 .tuner_attach = dw3101_tuner_attach,
2078 .stream = {
2079 .type = USB_BULK,
2080 .count = 8,
2081 .endpoint = 0x82,
2082 .u = {
2083 .bulk = {
2084 .buffersize = 4096,
2085 }
2086 }
2087 },
2088 }},
2089 }
2090 },
2091 .num_device_descs = 1,
2092 .devices = {
2093 { "DVBWorld DVB-C 3101 USB2.0",
2094 {&dw2102_table[CYPRESS_DW3101], NULL},
2095 {NULL},
2096 },
2097 }
2098 };
2099
2100 static struct dvb_usb_device_properties s6x0_properties = {
2101 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2102 .usb_ctrl = DEVICE_SPECIFIC,
2103 .size_of_priv = sizeof(struct dw2102_state),
2104 .firmware = S630_FIRMWARE,
2105 .no_reconnect = 1,
2106
2107 .i2c_algo = &s6x0_i2c_algo,
2108 .rc.core = {
2109 .rc_interval = 150,
2110 .rc_codes = RC_MAP_TEVII_NEC,
2111 .module_name = "dw2102",
2112 .allowed_protos = RC_PROTO_BIT_NEC,
2113 .rc_query = dw2102_rc_query,
2114 },
2115
2116 .generic_bulk_ctrl_endpoint = 0x81,
2117 .num_adapters = 1,
2118 .download_firmware = dw2102_load_firmware,
2119 .read_mac_address = s6x0_read_mac_address,
2120 .adapter = {
2121 {
2122 .num_frontends = 1,
2123 .fe = {{
2124 .frontend_attach = zl100313_frontend_attach,
2125 .stream = {
2126 .type = USB_BULK,
2127 .count = 8,
2128 .endpoint = 0x82,
2129 .u = {
2130 .bulk = {
2131 .buffersize = 4096,
2132 }
2133 }
2134 },
2135 }},
2136 }
2137 },
2138 .num_device_descs = 1,
2139 .devices = {
2140 {"TeVii S630 USB",
2141 {&dw2102_table[TEVII_S630], NULL},
2142 {NULL},
2143 },
2144 }
2145 };
2146
2147 static struct dvb_usb_device_properties p1100_properties = {
2148 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2149 .usb_ctrl = DEVICE_SPECIFIC,
2150 .size_of_priv = sizeof(struct dw2102_state),
2151 .firmware = P1100_FIRMWARE,
2152 .no_reconnect = 1,
2153
2154 .i2c_algo = &s6x0_i2c_algo,
2155 .rc.core = {
2156 .rc_interval = 150,
2157 .rc_codes = RC_MAP_TBS_NEC,
2158 .module_name = "dw2102",
2159 .allowed_protos = RC_PROTO_BIT_NEC,
2160 .rc_query = prof_rc_query,
2161 },
2162
2163 .generic_bulk_ctrl_endpoint = 0x81,
2164 .num_adapters = 1,
2165 .download_firmware = dw2102_load_firmware,
2166 .read_mac_address = s6x0_read_mac_address,
2167 .adapter = {
2168 {
2169 .num_frontends = 1,
2170 .fe = {{
2171 .frontend_attach = stv0288_frontend_attach,
2172 .stream = {
2173 .type = USB_BULK,
2174 .count = 8,
2175 .endpoint = 0x82,
2176 .u = {
2177 .bulk = {
2178 .buffersize = 4096,
2179 }
2180 }
2181 },
2182 } },
2183 }
2184 },
2185 .num_device_descs = 1,
2186 .devices = {
2187 {"Prof 1100 USB ",
2188 {&dw2102_table[PROF_1100], NULL},
2189 {NULL},
2190 },
2191 }
2192 };
2193
2194 static struct dvb_usb_device_properties s660_properties = {
2195 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2196 .usb_ctrl = DEVICE_SPECIFIC,
2197 .size_of_priv = sizeof(struct dw2102_state),
2198 .firmware = S660_FIRMWARE,
2199 .no_reconnect = 1,
2200
2201 .i2c_algo = &s6x0_i2c_algo,
2202 .rc.core = {
2203 .rc_interval = 150,
2204 .rc_codes = RC_MAP_TEVII_NEC,
2205 .module_name = "dw2102",
2206 .allowed_protos = RC_PROTO_BIT_NEC,
2207 .rc_query = dw2102_rc_query,
2208 },
2209
2210 .generic_bulk_ctrl_endpoint = 0x81,
2211 .num_adapters = 1,
2212 .download_firmware = dw2102_load_firmware,
2213 .read_mac_address = s6x0_read_mac_address,
2214 .adapter = {
2215 {
2216 .num_frontends = 1,
2217 .fe = {{
2218 .frontend_attach = ds3000_frontend_attach,
2219 .stream = {
2220 .type = USB_BULK,
2221 .count = 8,
2222 .endpoint = 0x82,
2223 .u = {
2224 .bulk = {
2225 .buffersize = 4096,
2226 }
2227 }
2228 },
2229 } },
2230 }
2231 },
2232 .num_device_descs = 3,
2233 .devices = {
2234 {"TeVii S660 USB",
2235 {&dw2102_table[TEVII_S660], NULL},
2236 {NULL},
2237 },
2238 {"TeVii S480.1 USB",
2239 {&dw2102_table[TEVII_S480_1], NULL},
2240 {NULL},
2241 },
2242 {"TeVii S480.2 USB",
2243 {&dw2102_table[TEVII_S480_2], NULL},
2244 {NULL},
2245 },
2246 }
2247 };
2248
2249 static struct dvb_usb_device_properties p7500_properties = {
2250 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2251 .usb_ctrl = DEVICE_SPECIFIC,
2252 .size_of_priv = sizeof(struct dw2102_state),
2253 .firmware = P7500_FIRMWARE,
2254 .no_reconnect = 1,
2255
2256 .i2c_algo = &s6x0_i2c_algo,
2257 .rc.core = {
2258 .rc_interval = 150,
2259 .rc_codes = RC_MAP_TBS_NEC,
2260 .module_name = "dw2102",
2261 .allowed_protos = RC_PROTO_BIT_NEC,
2262 .rc_query = prof_rc_query,
2263 },
2264
2265 .generic_bulk_ctrl_endpoint = 0x81,
2266 .num_adapters = 1,
2267 .download_firmware = dw2102_load_firmware,
2268 .read_mac_address = s6x0_read_mac_address,
2269 .adapter = {
2270 {
2271 .num_frontends = 1,
2272 .fe = {{
2273 .frontend_attach = prof_7500_frontend_attach,
2274 .stream = {
2275 .type = USB_BULK,
2276 .count = 8,
2277 .endpoint = 0x82,
2278 .u = {
2279 .bulk = {
2280 .buffersize = 4096,
2281 }
2282 }
2283 },
2284 } },
2285 }
2286 },
2287 .num_device_descs = 1,
2288 .devices = {
2289 {"Prof 7500 USB DVB-S2",
2290 {&dw2102_table[PROF_7500], NULL},
2291 {NULL},
2292 },
2293 }
2294 };
2295
2296 static struct dvb_usb_device_properties su3000_properties = {
2297 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2298 .usb_ctrl = DEVICE_SPECIFIC,
2299 .size_of_priv = sizeof(struct dw2102_state),
2300 .power_ctrl = su3000_power_ctrl,
2301 .num_adapters = 1,
2302 .identify_state = su3000_identify_state,
2303 .i2c_algo = &su3000_i2c_algo,
2304
2305 .rc.core = {
2306 .rc_interval = 150,
2307 .rc_codes = RC_MAP_SU3000,
2308 .module_name = "dw2102",
2309 .allowed_protos = RC_PROTO_BIT_RC5,
2310 .rc_query = su3000_rc_query,
2311 },
2312
2313 .read_mac_address = su3000_read_mac_address,
2314
2315 .generic_bulk_ctrl_endpoint = 0x01,
2316
2317 .adapter = {
2318 {
2319 .num_frontends = 1,
2320 .fe = {{
2321 .streaming_ctrl = su3000_streaming_ctrl,
2322 .frontend_attach = su3000_frontend_attach,
2323 .stream = {
2324 .type = USB_BULK,
2325 .count = 8,
2326 .endpoint = 0x82,
2327 .u = {
2328 .bulk = {
2329 .buffersize = 4096,
2330 }
2331 }
2332 }
2333 }},
2334 }
2335 },
2336 .num_device_descs = 9,
2337 .devices = {
2338 { "SU3000HD DVB-S USB2.0",
2339 { &dw2102_table[GENIATECH_SU3000], NULL },
2340 { NULL },
2341 },
2342 { "Hauppauge MAX S2 or WinTV NOVA HD USB2.0",
2343 { &dw2102_table[HAUPPAUGE_MAX_S2], NULL },
2344 { NULL },
2345 },
2346 { "Terratec Cinergy S2 USB HD",
2347 { &dw2102_table[TERRATEC_CINERGY_S2_R1], NULL },
2348 { NULL },
2349 },
2350 { "X3M TV SPC1400HD PCI",
2351 { &dw2102_table[GENIATECH_X3M_SPC1400HD], NULL },
2352 { NULL },
2353 },
2354 { "Terratec Cinergy S2 USB HD Rev.2",
2355 { &dw2102_table[TERRATEC_CINERGY_S2_R2], NULL },
2356 { NULL },
2357 },
2358 { "Terratec Cinergy S2 USB HD Rev.3",
2359 { &dw2102_table[TERRATEC_CINERGY_S2_R3], NULL },
2360 { NULL },
2361 },
2362 { "Terratec Cinergy S2 PCIe Dual Port 1",
2363 { &dw2102_table[TERRATEC_CINERGY_S2_1], NULL },
2364 { NULL },
2365 },
2366 { "Terratec Cinergy S2 PCIe Dual Port 2",
2367 { &dw2102_table[TERRATEC_CINERGY_S2_2], NULL },
2368 { NULL },
2369 },
2370 { "GOTVIEW Satellite HD",
2371 { &dw2102_table[GOTVIEW_SAT_HD], NULL },
2372 { NULL },
2373 },
2374 }
2375 };
2376
2377 static struct dvb_usb_device_properties s421_properties = {
2378 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2379 .usb_ctrl = DEVICE_SPECIFIC,
2380 .size_of_priv = sizeof(struct dw2102_state),
2381 .power_ctrl = su3000_power_ctrl,
2382 .num_adapters = 1,
2383 .identify_state = su3000_identify_state,
2384 .i2c_algo = &su3000_i2c_algo,
2385
2386 .rc.core = {
2387 .rc_interval = 150,
2388 .rc_codes = RC_MAP_SU3000,
2389 .module_name = "dw2102",
2390 .allowed_protos = RC_PROTO_BIT_RC5,
2391 .rc_query = su3000_rc_query,
2392 },
2393
2394 .read_mac_address = su3000_read_mac_address,
2395
2396 .generic_bulk_ctrl_endpoint = 0x01,
2397
2398 .adapter = {
2399 {
2400 .num_frontends = 1,
2401 .fe = {{
2402 .streaming_ctrl = su3000_streaming_ctrl,
2403 .frontend_attach = m88rs2000_frontend_attach,
2404 .stream = {
2405 .type = USB_BULK,
2406 .count = 8,
2407 .endpoint = 0x82,
2408 .u = {
2409 .bulk = {
2410 .buffersize = 4096,
2411 }
2412 }
2413 }
2414 } },
2415 }
2416 },
2417 .num_device_descs = 2,
2418 .devices = {
2419 { "TeVii S421 PCI",
2420 { &dw2102_table[TEVII_S421], NULL },
2421 { NULL },
2422 },
2423 { "TeVii S632 USB",
2424 { &dw2102_table[TEVII_S632], NULL },
2425 { NULL },
2426 },
2427 }
2428 };
2429
2430 static struct dvb_usb_device_properties t220_properties = {
2431 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2432 .usb_ctrl = DEVICE_SPECIFIC,
2433 .size_of_priv = sizeof(struct dw2102_state),
2434 .power_ctrl = su3000_power_ctrl,
2435 .num_adapters = 1,
2436 .identify_state = su3000_identify_state,
2437 .i2c_algo = &su3000_i2c_algo,
2438
2439 .rc.core = {
2440 .rc_interval = 150,
2441 .rc_codes = RC_MAP_SU3000,
2442 .module_name = "dw2102",
2443 .allowed_protos = RC_PROTO_BIT_RC5,
2444 .rc_query = su3000_rc_query,
2445 },
2446
2447 .read_mac_address = su3000_read_mac_address,
2448
2449 .generic_bulk_ctrl_endpoint = 0x01,
2450
2451 .adapter = {
2452 {
2453 .num_frontends = 1,
2454 .fe = { {
2455 .streaming_ctrl = su3000_streaming_ctrl,
2456 .frontend_attach = t220_frontend_attach,
2457 .stream = {
2458 .type = USB_BULK,
2459 .count = 8,
2460 .endpoint = 0x82,
2461 .u = {
2462 .bulk = {
2463 .buffersize = 4096,
2464 }
2465 }
2466 }
2467 } },
2468 }
2469 },
2470 .num_device_descs = 1,
2471 .devices = {
2472 { "Geniatech T220 DVB-T/T2 USB2.0",
2473 { &dw2102_table[GENIATECH_T220], NULL },
2474 { NULL },
2475 },
2476 }
2477 };
2478
2479 static struct dvb_usb_device_properties tt_s2_4600_properties = {
2480 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
2481 .usb_ctrl = DEVICE_SPECIFIC,
2482 .size_of_priv = sizeof(struct dw2102_state),
2483 .power_ctrl = su3000_power_ctrl,
2484 .num_adapters = 1,
2485 .identify_state = su3000_identify_state,
2486 .i2c_algo = &su3000_i2c_algo,
2487
2488 .rc.core = {
2489 .rc_interval = 250,
2490 .rc_codes = RC_MAP_TT_1500,
2491 .module_name = "dw2102",
2492 .allowed_protos = RC_PROTO_BIT_RC5,
2493 .rc_query = su3000_rc_query,
2494 },
2495
2496 .read_mac_address = su3000_read_mac_address,
2497
2498 .generic_bulk_ctrl_endpoint = 0x01,
2499
2500 .adapter = {
2501 {
2502 .num_frontends = 1,
2503 .fe = {{
2504 .streaming_ctrl = su3000_streaming_ctrl,
2505 .frontend_attach = tt_s2_4600_frontend_attach,
2506 .stream = {
2507 .type = USB_BULK,
2508 .count = 8,
2509 .endpoint = 0x82,
2510 .u = {
2511 .bulk = {
2512 .buffersize = 4096,
2513 }
2514 }
2515 }
2516 } },
2517 }
2518 },
2519 .num_device_descs = 5,
2520 .devices = {
2521 { "TechnoTrend TT-connect S2-4600",
2522 { &dw2102_table[TECHNOTREND_CONNECT_S2_4600], NULL },
2523 { NULL },
2524 },
2525 { "TeVii S482 (tuner 1)",
2526 { &dw2102_table[TEVII_S482_1], NULL },
2527 { NULL },
2528 },
2529 { "TeVii S482 (tuner 2)",
2530 { &dw2102_table[TEVII_S482_2], NULL },
2531 { NULL },
2532 },
2533 { "Terratec Cinergy S2 USB BOX",
2534 { &dw2102_table[TERRATEC_CINERGY_S2_BOX], NULL },
2535 { NULL },
2536 },
2537 { "TeVii S662",
2538 { &dw2102_table[TEVII_S662], NULL },
2539 { NULL },
2540 },
2541 }
2542 };
2543
dw2102_probe(struct usb_interface * intf,const struct usb_device_id * id)2544 static int dw2102_probe(struct usb_interface *intf,
2545 const struct usb_device_id *id)
2546 {
2547 if (!(dvb_usb_device_init(intf, &dw2102_properties,
2548 THIS_MODULE, NULL, adapter_nr) &&
2549 dvb_usb_device_init(intf, &dw2104_properties,
2550 THIS_MODULE, NULL, adapter_nr) &&
2551 dvb_usb_device_init(intf, &dw3101_properties,
2552 THIS_MODULE, NULL, adapter_nr) &&
2553 dvb_usb_device_init(intf, &s6x0_properties,
2554 THIS_MODULE, NULL, adapter_nr) &&
2555 dvb_usb_device_init(intf, &p1100_properties,
2556 THIS_MODULE, NULL, adapter_nr) &&
2557 dvb_usb_device_init(intf, &s660_properties,
2558 THIS_MODULE, NULL, adapter_nr) &&
2559 dvb_usb_device_init(intf, &p7500_properties,
2560 THIS_MODULE, NULL, adapter_nr) &&
2561 dvb_usb_device_init(intf, &s421_properties,
2562 THIS_MODULE, NULL, adapter_nr) &&
2563 dvb_usb_device_init(intf, &su3000_properties,
2564 THIS_MODULE, NULL, adapter_nr) &&
2565 dvb_usb_device_init(intf, &t220_properties,
2566 THIS_MODULE, NULL, adapter_nr) &&
2567 dvb_usb_device_init(intf, &tt_s2_4600_properties,
2568 THIS_MODULE, NULL, adapter_nr))) {
2569
2570 return 0;
2571 }
2572
2573 return -ENODEV;
2574 }
2575
dw2102_disconnect(struct usb_interface * intf)2576 static void dw2102_disconnect(struct usb_interface *intf)
2577 {
2578 struct dvb_usb_device *d = usb_get_intfdata(intf);
2579 struct dw2102_state *st = (struct dw2102_state *)d->priv;
2580 struct i2c_client *client;
2581
2582 /* remove I2C client for tuner */
2583 client = st->i2c_client_tuner;
2584 if (client) {
2585 module_put(client->dev.driver->owner);
2586 i2c_unregister_device(client);
2587 }
2588
2589 /* remove I2C client for demodulator */
2590 client = st->i2c_client_demod;
2591 if (client) {
2592 module_put(client->dev.driver->owner);
2593 i2c_unregister_device(client);
2594 }
2595
2596 dvb_usb_device_exit(intf);
2597 }
2598
2599 static struct usb_driver dw2102_driver = {
2600 .name = "dw2102",
2601 .probe = dw2102_probe,
2602 .disconnect = dw2102_disconnect,
2603 .id_table = dw2102_table,
2604 };
2605
2606 module_usb_driver(dw2102_driver);
2607
2608 MODULE_AUTHOR("Igor M. Liplianin (c) liplianin@me.by");
2609 MODULE_DESCRIPTION("Driver for DVBWorld DVB-S 2101, 2102, DVB-S2 2104, DVB-C 3101 USB2.0, TeVii S421, S480, S482, S600, S630, S632, S650, TeVii S660, S662, Prof 1100, 7500 USB2.0, Geniatech SU3000, T220, TechnoTrend S2-4600, Terratec Cinergy S2 devices");
2610 MODULE_VERSION("0.1");
2611 MODULE_LICENSE("GPL");
2612 MODULE_FIRMWARE(DW2101_FIRMWARE);
2613 MODULE_FIRMWARE(DW2102_FIRMWARE);
2614 MODULE_FIRMWARE(DW2104_FIRMWARE);
2615 MODULE_FIRMWARE(DW3101_FIRMWARE);
2616 MODULE_FIRMWARE(S630_FIRMWARE);
2617 MODULE_FIRMWARE(S660_FIRMWARE);
2618 MODULE_FIRMWARE(P1100_FIRMWARE);
2619 MODULE_FIRMWARE(P7500_FIRMWARE);
2620
