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