1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24#include <linux/hash.h>
25#include <linux/slab.h>
26
27#include "af9015.h"
28#include "af9013.h"
29#include "mt2060.h"
30#include "qt1010.h"
31#include "tda18271.h"
32#include "mxl5005s.h"
33#include "mc44s803.h"
34#include "tda18218.h"
35#include "mxl5007t.h"
36
37static int dvb_usb_af9015_debug;
38module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
39MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
40static int dvb_usb_af9015_remote;
41module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
42MODULE_PARM_DESC(remote, "select remote");
43DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
44
45static DEFINE_MUTEX(af9015_usb_mutex);
46
47static struct af9015_config af9015_config;
48static struct dvb_usb_device_properties af9015_properties[3];
49static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
50
51static struct af9013_config af9015_af9013_config[] = {
52 {
53 .demod_address = AF9015_I2C_DEMOD,
54 .output_mode = AF9013_OUTPUT_MODE_USB,
55 .api_version = { 0, 1, 9, 0 },
56 .gpio[0] = AF9013_GPIO_HI,
57 .gpio[3] = AF9013_GPIO_TUNER_ON,
58
59 }, {
60 .output_mode = AF9013_OUTPUT_MODE_SERIAL,
61 .api_version = { 0, 1, 9, 0 },
62 .gpio[0] = AF9013_GPIO_TUNER_ON,
63 .gpio[1] = AF9013_GPIO_LO,
64 }
65};
66
67static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
68{
69#define BUF_LEN 63
70#define REQ_HDR_LEN 8
71#define ACK_HDR_LEN 2
72 int act_len, ret;
73 u8 buf[BUF_LEN];
74 u8 write = 1;
75 u8 msg_len = REQ_HDR_LEN;
76 static u8 seq;
77
78 if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
79 return -EAGAIN;
80
81 buf[0] = req->cmd;
82 buf[1] = seq++;
83 buf[2] = req->i2c_addr;
84 buf[3] = req->addr >> 8;
85 buf[4] = req->addr & 0xff;
86 buf[5] = req->mbox;
87 buf[6] = req->addr_len;
88 buf[7] = req->data_len;
89
90 switch (req->cmd) {
91 case GET_CONFIG:
92 case READ_MEMORY:
93 case RECONNECT_USB:
94 case GET_IR_CODE:
95 write = 0;
96 break;
97 case READ_I2C:
98 write = 0;
99 buf[2] |= 0x01;
100 case WRITE_I2C:
101 buf[0] = READ_WRITE_I2C;
102 break;
103 case WRITE_MEMORY:
104 if (((req->addr & 0xff00) == 0xff00) ||
105 ((req->addr & 0xff00) == 0xae00))
106 buf[0] = WRITE_VIRTUAL_MEMORY;
107 case WRITE_VIRTUAL_MEMORY:
108 case COPY_FIRMWARE:
109 case DOWNLOAD_FIRMWARE:
110 case BOOT:
111 break;
112 default:
113 err("unknown command:%d", req->cmd);
114 ret = -1;
115 goto error_unlock;
116 }
117
118
119 if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
120 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
121 err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
122 ret = -EINVAL;
123 goto error_unlock;
124 }
125
126
127 if (write) {
128 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
129 msg_len += req->data_len;
130 }
131
132 deb_xfer(">>> ");
133 debug_dump(buf, msg_len, deb_xfer);
134
135
136 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
137 &act_len, AF9015_USB_TIMEOUT);
138 if (ret)
139 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
140 else
141 if (act_len != msg_len)
142 ret = -1;
143 if (ret)
144 goto error_unlock;
145
146
147 if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
148 goto exit_unlock;
149
150
151
152 msg_len = ACK_HDR_LEN;
153 if (!write)
154 msg_len += req->data_len;
155
156 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
157 &act_len, AF9015_USB_TIMEOUT);
158 if (ret) {
159 err("recv bulk message failed:%d", ret);
160 ret = -1;
161 goto error_unlock;
162 }
163
164 deb_xfer("<<< ");
165 debug_dump(buf, act_len, deb_xfer);
166
167
168 if (req->cmd == GET_IR_CODE && buf[1] == 1) {
169 buf[1] = 0;
170 memset(&buf[2], 0, req->data_len);
171 buf[3] = 1;
172 }
173
174
175 if (buf[1]) {
176 err("command failed:%d", buf[1]);
177 ret = -1;
178 goto error_unlock;
179 }
180
181
182 if (!write)
183 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
184
185error_unlock:
186exit_unlock:
187 mutex_unlock(&af9015_usb_mutex);
188
189 return ret;
190}
191
192static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
193{
194 return af9015_rw_udev(d->udev, req);
195}
196
197static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
198 u8 len)
199{
200 struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
201 val};
202 return af9015_ctrl_msg(d, &req);
203}
204
205static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
206{
207 return af9015_write_regs(d, addr, &val, 1);
208}
209
210static int af9015_read_regs(struct dvb_usb_device *d, u16 addr, u8 *val, u8 len)
211{
212 struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
213 val};
214 return af9015_ctrl_msg(d, &req);
215}
216
217static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
218{
219 return af9015_read_regs(d, addr, val, 1);
220}
221
222static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
223 u8 val)
224{
225 struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
226
227 if (addr == af9015_af9013_config[0].demod_address ||
228 addr == af9015_af9013_config[1].demod_address)
229 req.addr_len = 3;
230
231 return af9015_ctrl_msg(d, &req);
232}
233
234static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
235 u8 *val)
236{
237 struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
238
239 if (addr == af9015_af9013_config[0].demod_address ||
240 addr == af9015_af9013_config[1].demod_address)
241 req.addr_len = 3;
242
243 return af9015_ctrl_msg(d, &req);
244}
245
246static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
247 int num)
248{
249 struct dvb_usb_device *d = i2c_get_adapdata(adap);
250 int ret = 0, i = 0;
251 u16 addr;
252 u8 uninitialized_var(mbox), addr_len;
253 struct req_t req;
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
279 return -EAGAIN;
280
281 while (i < num) {
282 if (msg[i].addr == af9015_af9013_config[0].demod_address ||
283 msg[i].addr == af9015_af9013_config[1].demod_address) {
284 addr = msg[i].buf[0] << 8;
285 addr += msg[i].buf[1];
286 mbox = msg[i].buf[2];
287 addr_len = 3;
288 } else {
289 addr = msg[i].buf[0];
290 addr_len = 1;
291
292 }
293
294 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
295 if (msg[i].addr ==
296 af9015_af9013_config[0].demod_address)
297 req.cmd = READ_MEMORY;
298 else
299 req.cmd = READ_I2C;
300 req.i2c_addr = msg[i].addr;
301 req.addr = addr;
302 req.mbox = mbox;
303 req.addr_len = addr_len;
304 req.data_len = msg[i+1].len;
305 req.data = &msg[i+1].buf[0];
306 ret = af9015_ctrl_msg(d, &req);
307 i += 2;
308 } else if (msg[i].flags & I2C_M_RD) {
309 ret = -EINVAL;
310 if (msg[i].addr ==
311 af9015_af9013_config[0].demod_address)
312 goto error;
313 else
314 req.cmd = READ_I2C;
315 req.i2c_addr = msg[i].addr;
316 req.addr = addr;
317 req.mbox = mbox;
318 req.addr_len = addr_len;
319 req.data_len = msg[i].len;
320 req.data = &msg[i].buf[0];
321 ret = af9015_ctrl_msg(d, &req);
322 i += 1;
323 } else {
324 if (msg[i].addr ==
325 af9015_af9013_config[0].demod_address)
326 req.cmd = WRITE_MEMORY;
327 else
328 req.cmd = WRITE_I2C;
329 req.i2c_addr = msg[i].addr;
330 req.addr = addr;
331 req.mbox = mbox;
332 req.addr_len = addr_len;
333 req.data_len = msg[i].len-addr_len;
334 req.data = &msg[i].buf[addr_len];
335 ret = af9015_ctrl_msg(d, &req);
336 i += 1;
337 }
338 if (ret)
339 goto error;
340
341 }
342 ret = i;
343
344error:
345 mutex_unlock(&d->i2c_mutex);
346
347 return ret;
348}
349
350static u32 af9015_i2c_func(struct i2c_adapter *adapter)
351{
352 return I2C_FUNC_I2C;
353}
354
355static struct i2c_algorithm af9015_i2c_algo = {
356 .master_xfer = af9015_i2c_xfer,
357 .functionality = af9015_i2c_func,
358};
359
360static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
361{
362 int ret;
363 u8 val, mask = 0x01;
364
365 ret = af9015_read_reg(d, addr, &val);
366 if (ret)
367 return ret;
368
369 mask <<= bit;
370 if (op) {
371
372 val |= mask;
373 } else {
374
375 mask ^= 0xff;
376 val &= mask;
377 }
378
379 return af9015_write_reg(d, addr, val);
380}
381
382static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
383{
384 return af9015_do_reg_bit(d, addr, bit, 1);
385}
386
387static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
388{
389 return af9015_do_reg_bit(d, addr, bit, 0);
390}
391
392static int af9015_init_endpoint(struct dvb_usb_device *d)
393{
394 int ret;
395 u16 frame_size;
396 u8 packet_size;
397 deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
398
399
400
401#define TS_PACKET_SIZE 188
402
403#define TS_USB20_PACKET_COUNT 87
404#define TS_USB20_FRAME_SIZE (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
405
406#define TS_USB11_PACKET_COUNT 5
407#define TS_USB11_FRAME_SIZE (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
408
409#define TS_USB20_MAX_PACKET_SIZE 512
410#define TS_USB11_MAX_PACKET_SIZE 64
411
412 if (d->udev->speed == USB_SPEED_FULL) {
413 frame_size = TS_USB11_FRAME_SIZE/4;
414 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
415 } else {
416 frame_size = TS_USB20_FRAME_SIZE/4;
417 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
418 }
419
420 ret = af9015_set_reg_bit(d, 0xd507, 2);
421 if (ret)
422 goto error;
423 ret = af9015_set_reg_bit(d, 0xd50b, 1);
424 if (ret)
425 goto error;
426 ret = af9015_clear_reg_bit(d, 0xdd11, 5);
427 if (ret)
428 goto error;
429 ret = af9015_clear_reg_bit(d, 0xdd11, 6);
430 if (ret)
431 goto error;
432 ret = af9015_set_reg_bit(d, 0xdd11, 5);
433 if (ret)
434 goto error;
435 if (af9015_config.dual_mode) {
436 ret = af9015_set_reg_bit(d, 0xdd11, 6);
437 if (ret)
438 goto error;
439 }
440 ret = af9015_clear_reg_bit(d, 0xdd13, 5);
441 if (ret)
442 goto error;
443 if (af9015_config.dual_mode) {
444 ret = af9015_clear_reg_bit(d, 0xdd13, 6);
445 if (ret)
446 goto error;
447 }
448
449 ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
450 if (ret)
451 goto error;
452 ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
453 if (ret)
454 goto error;
455
456 ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
457 if (ret)
458 goto error;
459 ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
460 if (ret)
461 goto error;
462 ret = af9015_write_reg(d, 0xdd0c, packet_size);
463 if (ret)
464 goto error;
465 ret = af9015_write_reg(d, 0xdd0d, packet_size);
466 if (ret)
467 goto error;
468 ret = af9015_clear_reg_bit(d, 0xd507, 2);
469 if (ret)
470 goto error;
471 if (af9015_config.dual_mode) {
472 ret = af9015_clear_reg_bit(d, 0xd50b, 1);
473 if (ret)
474 goto error;
475 }
476
477
478 if (af9015_config.dual_mode)
479 ret = af9015_set_reg_bit(d, 0xd50b, 0);
480 else
481 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
482error:
483 if (ret)
484 err("endpoint init failed:%d", ret);
485 return ret;
486}
487
488static int af9015_copy_firmware(struct dvb_usb_device *d)
489{
490 int ret;
491 u8 fw_params[4];
492 u8 val, i;
493 struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
494 fw_params };
495 deb_info("%s:\n", __func__);
496
497 fw_params[0] = af9015_config.firmware_size >> 8;
498 fw_params[1] = af9015_config.firmware_size & 0xff;
499 fw_params[2] = af9015_config.firmware_checksum >> 8;
500 fw_params[3] = af9015_config.firmware_checksum & 0xff;
501
502
503 msleep(100);
504
505 ret = af9015_read_reg_i2c(d,
506 af9015_af9013_config[1].demod_address, 0x98be, &val);
507 if (ret)
508 goto error;
509 else
510 deb_info("%s: firmware status:%02x\n", __func__, val);
511
512 if (val == 0x0c)
513 goto exit;
514
515
516 ret = af9015_write_reg(d, 0xd416, 0x04);
517 if (ret)
518 goto error;
519
520 msleep(50);
521
522
523 ret = af9015_ctrl_msg(d, &req);
524 if (ret)
525 err("firmware copy cmd failed:%d", ret);
526 deb_info("%s: firmware copy done\n", __func__);
527
528
529 ret = af9015_write_reg(d, 0xd416, 0x14);
530 if (ret)
531 goto error;
532
533
534 ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].demod_address,
535 0xe205, 1);
536 deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
537 if (ret)
538 goto error;
539
540 for (i = 0; i < 15; i++) {
541 msleep(100);
542
543
544 ret = af9015_read_reg_i2c(d,
545 af9015_af9013_config[1].demod_address, 0x98be, &val);
546 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
547 __func__, ret, val);
548 if (ret)
549 goto error;
550
551 if (val == 0x0c || val == 0x04)
552 break;
553 }
554
555 if (val == 0x04) {
556 err("firmware did not run");
557 ret = -1;
558 } else if (val != 0x0c) {
559 err("firmware boot timeout");
560 ret = -1;
561 }
562
563error:
564exit:
565 return ret;
566}
567
568
569static int af9015_eeprom_hash(struct usb_device *udev)
570{
571 static const unsigned int eeprom_size = 256;
572 unsigned int reg;
573 int ret;
574 u8 val, *eeprom;
575 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
576
577 eeprom = kmalloc(eeprom_size, GFP_KERNEL);
578 if (eeprom == NULL)
579 return -ENOMEM;
580
581 for (reg = 0; reg < eeprom_size; reg++) {
582 req.addr = reg;
583 ret = af9015_rw_udev(udev, &req);
584 if (ret)
585 goto free;
586 eeprom[reg] = val;
587 }
588
589 if (dvb_usb_af9015_debug & 0x01)
590 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, eeprom,
591 eeprom_size);
592
593 BUG_ON(eeprom_size % 4);
594
595 af9015_config.eeprom_sum = 0;
596 for (reg = 0; reg < eeprom_size / sizeof(u32); reg++) {
597 af9015_config.eeprom_sum *= GOLDEN_RATIO_PRIME_32;
598 af9015_config.eeprom_sum += le32_to_cpu(((u32 *)eeprom)[reg]);
599 }
600
601 deb_info("%s: eeprom sum=%.8x\n", __func__, af9015_config.eeprom_sum);
602
603 ret = 0;
604free:
605 kfree(eeprom);
606 return ret;
607}
608
609static int af9015_init(struct dvb_usb_device *d)
610{
611 int ret;
612 deb_info("%s:\n", __func__);
613
614 ret = af9015_init_endpoint(d);
615 if (ret)
616 goto error;
617
618error:
619 return ret;
620}
621
622static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
623{
624 int ret;
625 deb_info("%s: onoff:%d\n", __func__, onoff);
626
627 if (onoff)
628 ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
629 else
630 ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
631
632 return ret;
633}
634
635static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
636 int onoff)
637{
638 int ret;
639 u8 idx;
640
641 deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
642 __func__, index, pid, onoff);
643
644 ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
645 if (ret)
646 goto error;
647
648 ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
649 if (ret)
650 goto error;
651
652 idx = ((index & 0x1f) | (1 << 5));
653 ret = af9015_write_reg(adap->dev, 0xd504, idx);
654
655error:
656 return ret;
657}
658
659static int af9015_download_firmware(struct usb_device *udev,
660 const struct firmware *fw)
661{
662 int i, len, packets, remainder, ret;
663 struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
664 u16 addr = 0x5100;
665 u16 checksum = 0;
666
667 deb_info("%s:\n", __func__);
668
669
670 for (i = 0; i < fw->size; i++)
671 checksum += fw->data[i];
672
673 af9015_config.firmware_size = fw->size;
674 af9015_config.firmware_checksum = checksum;
675
676 #define FW_PACKET_MAX_DATA 55
677
678 packets = fw->size / FW_PACKET_MAX_DATA;
679 remainder = fw->size % FW_PACKET_MAX_DATA;
680 len = FW_PACKET_MAX_DATA;
681 for (i = 0; i <= packets; i++) {
682 if (i == packets)
683 len = remainder;
684
685 req.data_len = len;
686 req.data = (u8 *)(fw->data + i * FW_PACKET_MAX_DATA);
687 req.addr = addr;
688 addr += FW_PACKET_MAX_DATA;
689
690 ret = af9015_rw_udev(udev, &req);
691 if (ret) {
692 err("firmware download failed at packet %d with " \
693 "code %d", i, ret);
694 goto error;
695 }
696 }
697
698
699 req.cmd = BOOT;
700 ret = af9015_rw_udev(udev, &req);
701 if (ret) {
702 err("firmware boot failed:%d", ret);
703 goto error;
704 }
705
706error:
707 return ret;
708}
709
710struct af9015_rc_setup {
711 unsigned int id;
712 char *rc_codes;
713};
714
715static char *af9015_rc_setup_match(unsigned int id,
716 const struct af9015_rc_setup *table)
717{
718 for (; table->rc_codes; table++)
719 if (table->id == id)
720 return table->rc_codes;
721 return NULL;
722}
723
724static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
725 { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
726 { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
727 { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
728 { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
729 { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
730 { }
731};
732
733static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
734 { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
735 { 0xa3703d00, RC_MAP_ALINK_DTU_M },
736 { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND },
737 { }
738};
739
740static const struct af9015_rc_setup af9015_rc_setup_usbids[] = {
741 { (USB_VID_TERRATEC << 16) + USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
742 RC_MAP_TERRATEC_SLIM },
743 { (USB_VID_VISIONPLUS << 16) + USB_PID_AZUREWAVE_AD_TU700,
744 RC_MAP_AZUREWAVE_AD_TU700 },
745 { (USB_VID_VISIONPLUS << 16) + USB_PID_TINYTWIN,
746 RC_MAP_AZUREWAVE_AD_TU700 },
747 { (USB_VID_MSI_2 << 16) + USB_PID_MSI_DIGI_VOX_MINI_III,
748 RC_MAP_MSI_DIGIVOX_III },
749 { (USB_VID_LEADTEK << 16) + USB_PID_WINFAST_DTV_DONGLE_GOLD,
750 RC_MAP_LEADTEK_Y04G0051 },
751 { (USB_VID_AVERMEDIA << 16) + USB_PID_AVERMEDIA_VOLAR_X,
752 RC_MAP_AVERMEDIA_M135A },
753 { (USB_VID_AFATECH << 16) + USB_PID_TREKSTOR_DVBT,
754 RC_MAP_TREKSTOR },
755 { (USB_VID_KWORLD_2 << 16) + USB_PID_TINYTWIN_2,
756 RC_MAP_DIGITALNOW_TINYTWIN },
757 { (USB_VID_GTEK << 16) + USB_PID_TINYTWIN_3,
758 RC_MAP_DIGITALNOW_TINYTWIN },
759 { }
760};
761
762static void af9015_set_remote_config(struct usb_device *udev,
763 struct dvb_usb_device_properties *props)
764{
765 u16 vid = le16_to_cpu(udev->descriptor.idVendor);
766 u16 pid = le16_to_cpu(udev->descriptor.idProduct);
767
768
769 props->rc.core.rc_codes = af9015_rc_setup_match(
770 dvb_usb_af9015_remote, af9015_rc_setup_modparam);
771
772
773 if (!props->rc.core.rc_codes)
774 props->rc.core.rc_codes = af9015_rc_setup_match(
775 af9015_config.eeprom_sum, af9015_rc_setup_hashes);
776
777
778 if (!props->rc.core.rc_codes)
779 props->rc.core.rc_codes = af9015_rc_setup_match(
780 (vid << 16) + pid, af9015_rc_setup_usbids);
781
782
783 if (!props->rc.core.rc_codes && vid == USB_VID_AFATECH) {
784
785
786
787
788 char manufacturer[10];
789 memset(manufacturer, 0, sizeof(manufacturer));
790 usb_string(udev, udev->descriptor.iManufacturer,
791 manufacturer, sizeof(manufacturer));
792 if (!strcmp("MSI", manufacturer)) {
793
794
795 props->rc.core.rc_codes = af9015_rc_setup_match(
796 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
797 af9015_rc_setup_modparam);
798 }
799 }
800
801
802 if (!props->rc.core.rc_codes)
803 props->rc.core.rc_codes = RC_MAP_EMPTY;
804
805 return;
806}
807
808static int af9015_read_config(struct usb_device *udev)
809{
810 int ret;
811 u8 val, i, offset = 0;
812 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
813
814
815 req.addr = AF9015_EEPROM_IR_MODE;
816
817 for (i = 0; i < 4; i++) {
818 ret = af9015_rw_udev(udev, &req);
819 if (!ret)
820 break;
821 }
822 if (ret)
823 goto error;
824
825 ret = af9015_eeprom_hash(udev);
826 if (ret)
827 goto error;
828
829 deb_info("%s: IR mode:%d\n", __func__, val);
830 for (i = 0; i < af9015_properties_count; i++) {
831 if (val == AF9015_IR_MODE_DISABLED)
832 af9015_properties[i].rc.core.rc_codes = NULL;
833 else
834 af9015_set_remote_config(udev, &af9015_properties[i]);
835 }
836
837
838 req.addr = AF9015_EEPROM_TS_MODE;
839 ret = af9015_rw_udev(udev, &req);
840 if (ret)
841 goto error;
842 af9015_config.dual_mode = val;
843 deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
844
845
846
847 for (i = 0; i < af9015_properties_count; i++) {
848
849 if (udev->speed == USB_SPEED_FULL) {
850 af9015_properties[i].adapter[0].stream.u.bulk.buffersize
851 = TS_USB11_FRAME_SIZE;
852
853
854 af9015_config.dual_mode = 0;
855 } else {
856 af9015_properties[i].adapter[0].stream.u.bulk.buffersize
857 = TS_USB20_FRAME_SIZE;
858 }
859 }
860
861 if (af9015_config.dual_mode) {
862
863 req.addr = AF9015_EEPROM_DEMOD2_I2C;
864 ret = af9015_rw_udev(udev, &req);
865 if (ret)
866 goto error;
867 af9015_af9013_config[1].demod_address = val;
868
869
870 for (i = 0; i < af9015_properties_count; i++)
871 af9015_properties[i].num_adapters = 2;
872
873 } else {
874
875 for (i = 0; i < af9015_properties_count; i++)
876 af9015_properties[i].num_adapters = 1;
877 }
878
879 for (i = 0; i < af9015_properties[0].num_adapters; i++) {
880 if (i == 1)
881 offset = AF9015_EEPROM_OFFSET;
882
883 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
884 ret = af9015_rw_udev(udev, &req);
885 if (ret)
886 goto error;
887 switch (val) {
888 case 0:
889 af9015_af9013_config[i].adc_clock = 28800;
890 break;
891 case 1:
892 af9015_af9013_config[i].adc_clock = 20480;
893 break;
894 case 2:
895 af9015_af9013_config[i].adc_clock = 28000;
896 break;
897 case 3:
898 af9015_af9013_config[i].adc_clock = 25000;
899 break;
900 };
901 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
902 val, af9015_af9013_config[i].adc_clock);
903
904
905 req.addr = AF9015_EEPROM_IF1H + offset;
906 ret = af9015_rw_udev(udev, &req);
907 if (ret)
908 goto error;
909 af9015_af9013_config[i].tuner_if = val << 8;
910 req.addr = AF9015_EEPROM_IF1L + offset;
911 ret = af9015_rw_udev(udev, &req);
912 if (ret)
913 goto error;
914 af9015_af9013_config[i].tuner_if += val;
915 deb_info("%s: [%d] IF1:%d\n", __func__, i,
916 af9015_af9013_config[0].tuner_if);
917
918
919 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;
920 ret = af9015_rw_udev(udev, &req);
921 if (ret)
922 goto error;
923 af9015_config.mt2060_if1[i] = val << 8;
924 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
925 ret = af9015_rw_udev(udev, &req);
926 if (ret)
927 goto error;
928 af9015_config.mt2060_if1[i] += val;
929 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
930 af9015_config.mt2060_if1[i]);
931
932
933 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;
934 ret = af9015_rw_udev(udev, &req);
935 if (ret)
936 goto error;
937 switch (val) {
938 case AF9013_TUNER_ENV77H11D5:
939 case AF9013_TUNER_MT2060:
940 case AF9013_TUNER_QT1010:
941 case AF9013_TUNER_UNKNOWN:
942 case AF9013_TUNER_MT2060_2:
943 case AF9013_TUNER_TDA18271:
944 case AF9013_TUNER_QT1010A:
945 case AF9013_TUNER_TDA18218:
946 af9015_af9013_config[i].rf_spec_inv = 1;
947 break;
948 case AF9013_TUNER_MXL5003D:
949 case AF9013_TUNER_MXL5005D:
950 case AF9013_TUNER_MXL5005R:
951 case AF9013_TUNER_MXL5007T:
952 af9015_af9013_config[i].rf_spec_inv = 0;
953 break;
954 case AF9013_TUNER_MC44S803:
955 af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
956 af9015_af9013_config[i].rf_spec_inv = 1;
957 break;
958 default:
959 warn("tuner id:%d not supported, please report!", val);
960 return -ENODEV;
961 };
962
963 af9015_af9013_config[i].tuner = val;
964 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
965 }
966
967error:
968 if (ret)
969 err("eeprom read failed:%d", ret);
970
971
972
973
974 if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
975 ((le16_to_cpu(udev->descriptor.idProduct) ==
976 USB_PID_AVERMEDIA_A850) ||
977 (le16_to_cpu(udev->descriptor.idProduct) ==
978 USB_PID_AVERMEDIA_A850T))) {
979 deb_info("%s: AverMedia A850: overriding config\n", __func__);
980
981 af9015_config.dual_mode = 0;
982
983 for (i = 0; i < af9015_properties_count; i++)
984 af9015_properties[i].num_adapters = 1;
985
986
987 af9015_af9013_config[0].tuner_if = 4570;
988 }
989
990 return ret;
991}
992
993static int af9015_identify_state(struct usb_device *udev,
994 struct dvb_usb_device_properties *props,
995 struct dvb_usb_device_description **desc,
996 int *cold)
997{
998 int ret;
999 u8 reply;
1000 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1001
1002 ret = af9015_rw_udev(udev, &req);
1003 if (ret)
1004 return ret;
1005
1006 deb_info("%s: reply:%02x\n", __func__, reply);
1007 if (reply == 0x02)
1008 *cold = 0;
1009 else
1010 *cold = 1;
1011
1012 return ret;
1013}
1014
1015static int af9015_rc_query(struct dvb_usb_device *d)
1016{
1017 struct af9015_state *priv = d->priv;
1018 int ret;
1019 u8 buf[16];
1020
1021
1022 ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
1023 if (ret)
1024 goto error;
1025
1026 if (buf[14] || buf[15]) {
1027 deb_rc("%s: key pressed %02x %02x %02x %02x\n", __func__,
1028 buf[12], buf[13], buf[14], buf[15]);
1029
1030
1031 ret = af9015_write_regs(d, 0x98e5, "\x00\x00\x00\x00", 4);
1032 if (ret)
1033 goto error;
1034
1035 if (buf[14] == (u8) ~buf[15]) {
1036 if (buf[12] == (u8) ~buf[13]) {
1037
1038 priv->rc_keycode = buf[12] << 8 | buf[14];
1039 } else {
1040
1041 priv->rc_keycode = buf[12] << 16 |
1042 buf[13] << 8 | buf[14];
1043 }
1044 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1045 } else {
1046 priv->rc_keycode = 0;
1047 }
1048 } else if (priv->rc_repeat != buf[6] || buf[0]) {
1049 deb_rc("%s: key repeated\n", __func__);
1050 rc_keydown(d->rc_dev, priv->rc_keycode, 0);
1051 } else {
1052 deb_rc("%s: no key press\n", __func__);
1053 }
1054
1055 priv->rc_repeat = buf[6];
1056
1057error:
1058 if (ret)
1059 err("%s: failed:%d", __func__, ret);
1060
1061 return ret;
1062}
1063
1064
1065static int af9015_i2c_init(struct dvb_usb_device *d)
1066{
1067 int ret;
1068 struct af9015_state *state = d->priv;
1069 deb_info("%s:\n", __func__);
1070
1071 strncpy(state->i2c_adap.name, d->desc->name,
1072 sizeof(state->i2c_adap.name));
1073 state->i2c_adap.algo = d->props.i2c_algo;
1074 state->i2c_adap.algo_data = NULL;
1075 state->i2c_adap.dev.parent = &d->udev->dev;
1076
1077 i2c_set_adapdata(&state->i2c_adap, d);
1078
1079 ret = i2c_add_adapter(&state->i2c_adap);
1080 if (ret < 0)
1081 err("could not add i2c adapter");
1082
1083 return ret;
1084}
1085
1086static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1087{
1088 int ret;
1089 struct af9015_state *state = adap->dev->priv;
1090 struct i2c_adapter *i2c_adap;
1091
1092 if (adap->id == 0) {
1093
1094 i2c_adap = &adap->dev->i2c_adap;
1095
1096 deb_info("%s: init I2C\n", __func__);
1097 ret = af9015_i2c_init(adap->dev);
1098 } else {
1099
1100 i2c_adap = &state->i2c_adap;
1101
1102
1103 if (af9015_config.dual_mode) {
1104 ret = af9015_copy_firmware(adap->dev);
1105 if (ret) {
1106 err("firmware copy to 2nd frontend " \
1107 "failed, will disable it");
1108 af9015_config.dual_mode = 0;
1109 return -ENODEV;
1110 }
1111 } else {
1112 return -ENODEV;
1113 }
1114 }
1115
1116
1117 adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1118 i2c_adap);
1119
1120 return adap->fe == NULL ? -ENODEV : 0;
1121}
1122
1123static struct mt2060_config af9015_mt2060_config = {
1124 .i2c_address = 0xc0,
1125 .clock_out = 0,
1126};
1127
1128static struct qt1010_config af9015_qt1010_config = {
1129 .i2c_address = 0xc4,
1130};
1131
1132static struct tda18271_config af9015_tda18271_config = {
1133 .gate = TDA18271_GATE_DIGITAL,
1134 .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
1135};
1136
1137static struct mxl5005s_config af9015_mxl5003_config = {
1138 .i2c_address = 0xc6,
1139 .if_freq = IF_FREQ_4570000HZ,
1140 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1141 .agc_mode = MXL_SINGLE_AGC,
1142 .tracking_filter = MXL_TF_DEFAULT,
1143 .rssi_enable = MXL_RSSI_ENABLE,
1144 .cap_select = MXL_CAP_SEL_ENABLE,
1145 .div_out = MXL_DIV_OUT_4,
1146 .clock_out = MXL_CLOCK_OUT_DISABLE,
1147 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1148 .top = MXL5005S_TOP_25P2,
1149 .mod_mode = MXL_DIGITAL_MODE,
1150 .if_mode = MXL_ZERO_IF,
1151 .AgcMasterByte = 0x00,
1152};
1153
1154static struct mxl5005s_config af9015_mxl5005_config = {
1155 .i2c_address = 0xc6,
1156 .if_freq = IF_FREQ_4570000HZ,
1157 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1158 .agc_mode = MXL_SINGLE_AGC,
1159 .tracking_filter = MXL_TF_OFF,
1160 .rssi_enable = MXL_RSSI_ENABLE,
1161 .cap_select = MXL_CAP_SEL_ENABLE,
1162 .div_out = MXL_DIV_OUT_4,
1163 .clock_out = MXL_CLOCK_OUT_DISABLE,
1164 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1165 .top = MXL5005S_TOP_25P2,
1166 .mod_mode = MXL_DIGITAL_MODE,
1167 .if_mode = MXL_ZERO_IF,
1168 .AgcMasterByte = 0x00,
1169};
1170
1171static struct mc44s803_config af9015_mc44s803_config = {
1172 .i2c_address = 0xc0,
1173 .dig_out = 1,
1174};
1175
1176static struct tda18218_config af9015_tda18218_config = {
1177 .i2c_address = 0xc0,
1178 .i2c_wr_max = 21,
1179};
1180
1181static struct mxl5007t_config af9015_mxl5007t_config = {
1182 .xtal_freq_hz = MxL_XTAL_24_MHZ,
1183 .if_freq_hz = MxL_IF_4_57_MHZ,
1184};
1185
1186static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1187{
1188 struct af9015_state *state = adap->dev->priv;
1189 struct i2c_adapter *i2c_adap;
1190 int ret;
1191 deb_info("%s:\n", __func__);
1192
1193
1194 if (adap->id == 0)
1195 i2c_adap = &adap->dev->i2c_adap;
1196 else
1197 i2c_adap = &state->i2c_adap;
1198
1199 switch (af9015_af9013_config[adap->id].tuner) {
1200 case AF9013_TUNER_MT2060:
1201 case AF9013_TUNER_MT2060_2:
1202 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1203 &af9015_mt2060_config,
1204 af9015_config.mt2060_if1[adap->id])
1205 == NULL ? -ENODEV : 0;
1206 break;
1207 case AF9013_TUNER_QT1010:
1208 case AF9013_TUNER_QT1010A:
1209 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1210 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1211 break;
1212 case AF9013_TUNER_TDA18271:
1213 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1214 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1215 break;
1216 case AF9013_TUNER_TDA18218:
1217 ret = dvb_attach(tda18218_attach, adap->fe, i2c_adap,
1218 &af9015_tda18218_config) == NULL ? -ENODEV : 0;
1219 break;
1220 case AF9013_TUNER_MXL5003D:
1221 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1222 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1223 break;
1224 case AF9013_TUNER_MXL5005D:
1225 case AF9013_TUNER_MXL5005R:
1226 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1227 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1228 break;
1229 case AF9013_TUNER_ENV77H11D5:
1230 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1231 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1232 break;
1233 case AF9013_TUNER_MC44S803:
1234 ret = dvb_attach(mc44s803_attach, adap->fe, i2c_adap,
1235 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1236 break;
1237 case AF9013_TUNER_MXL5007T:
1238 ret = dvb_attach(mxl5007t_attach, adap->fe, i2c_adap,
1239 0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
1240 break;
1241 case AF9013_TUNER_UNKNOWN:
1242 default:
1243 ret = -ENODEV;
1244 err("Unknown tuner id:%d",
1245 af9015_af9013_config[adap->id].tuner);
1246 }
1247 return ret;
1248}
1249
1250static struct usb_device_id af9015_usb_table[] = {
1251{USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1252 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1253 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1254 {USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1255 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1256{USB_DEVICE(USB_VID_VISIONPLUS,
1257 USB_PID_TINYTWIN)},
1258 {USB_DEVICE(USB_VID_VISIONPLUS,
1259 USB_PID_AZUREWAVE_AD_TU700)},
1260 {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1261 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1262 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1263{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1264 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1265 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1266 {USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2)},
1267 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1268{USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III)},
1269 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U)},
1270 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2)},
1271 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3)},
1272 {USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT)},
1273{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1274 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1275 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1276 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810)},
1277 {USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03)},
1278{USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2)},
1279 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T)},
1280 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20)},
1281 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2)},
1282 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS)},
1283{USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T)},
1284 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4)},
1285 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M)},
1286 {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_RC)},
1287 {USB_DEVICE(USB_VID_TERRATEC,
1288 USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC)},
1289{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T)},
1290 {USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3)},
1291 {0},
1292};
1293MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1294
1295#define AF9015_RC_INTERVAL 500
1296static struct dvb_usb_device_properties af9015_properties[] = {
1297 {
1298 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1299
1300 .usb_ctrl = DEVICE_SPECIFIC,
1301 .download_firmware = af9015_download_firmware,
1302 .firmware = "dvb-usb-af9015.fw",
1303 .no_reconnect = 1,
1304
1305 .size_of_priv = sizeof(struct af9015_state),
1306
1307 .num_adapters = 2,
1308 .adapter = {
1309 {
1310 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1311 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1312
1313 .pid_filter_count = 32,
1314 .pid_filter = af9015_pid_filter,
1315 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1316
1317 .frontend_attach =
1318 af9015_af9013_frontend_attach,
1319 .tuner_attach = af9015_tuner_attach,
1320 .stream = {
1321 .type = USB_BULK,
1322 .count = 6,
1323 .endpoint = 0x84,
1324 },
1325 },
1326 {
1327 .frontend_attach =
1328 af9015_af9013_frontend_attach,
1329 .tuner_attach = af9015_tuner_attach,
1330 .stream = {
1331 .type = USB_BULK,
1332 .count = 6,
1333 .endpoint = 0x85,
1334 .u = {
1335 .bulk = {
1336 .buffersize =
1337 TS_USB20_FRAME_SIZE,
1338 }
1339 }
1340 },
1341 }
1342 },
1343
1344 .identify_state = af9015_identify_state,
1345
1346 .rc.core = {
1347 .protocol = RC_TYPE_NEC,
1348 .module_name = "af9015",
1349 .rc_query = af9015_rc_query,
1350 .rc_interval = AF9015_RC_INTERVAL,
1351 .allowed_protos = RC_TYPE_NEC,
1352 },
1353
1354 .i2c_algo = &af9015_i2c_algo,
1355
1356 .num_device_descs = 12,
1357 .devices = {
1358 {
1359 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1360 .cold_ids = {&af9015_usb_table[0],
1361 &af9015_usb_table[1], NULL},
1362 .warm_ids = {NULL},
1363 },
1364 {
1365 .name = "Leadtek WinFast DTV Dongle Gold",
1366 .cold_ids = {&af9015_usb_table[2], NULL},
1367 .warm_ids = {NULL},
1368 },
1369 {
1370 .name = "Pinnacle PCTV 71e",
1371 .cold_ids = {&af9015_usb_table[3], NULL},
1372 .warm_ids = {NULL},
1373 },
1374 {
1375 .name = "KWorld PlusTV Dual DVB-T Stick " \
1376 "(DVB-T 399U)",
1377 .cold_ids = {&af9015_usb_table[4],
1378 &af9015_usb_table[25], NULL},
1379 .warm_ids = {NULL},
1380 },
1381 {
1382 .name = "DigitalNow TinyTwin DVB-T Receiver",
1383 .cold_ids = {&af9015_usb_table[5],
1384 &af9015_usb_table[28],
1385 &af9015_usb_table[36], NULL},
1386 .warm_ids = {NULL},
1387 },
1388 {
1389 .name = "TwinHan AzureWave AD-TU700(704J)",
1390 .cold_ids = {&af9015_usb_table[6], NULL},
1391 .warm_ids = {NULL},
1392 },
1393 {
1394 .name = "TerraTec Cinergy T USB XE",
1395 .cold_ids = {&af9015_usb_table[7], NULL},
1396 .warm_ids = {NULL},
1397 },
1398 {
1399 .name = "KWorld PlusTV Dual DVB-T PCI " \
1400 "(DVB-T PC160-2T)",
1401 .cold_ids = {&af9015_usb_table[8], NULL},
1402 .warm_ids = {NULL},
1403 },
1404 {
1405 .name = "AVerMedia AVerTV DVB-T Volar X",
1406 .cold_ids = {&af9015_usb_table[9], NULL},
1407 .warm_ids = {NULL},
1408 },
1409 {
1410 .name = "TerraTec Cinergy T Stick RC",
1411 .cold_ids = {&af9015_usb_table[33], NULL},
1412 .warm_ids = {NULL},
1413 },
1414 {
1415 .name = "TerraTec Cinergy T Stick Dual RC",
1416 .cold_ids = {&af9015_usb_table[34], NULL},
1417 .warm_ids = {NULL},
1418 },
1419 {
1420 .name = "AverMedia AVerTV Red HD+ (A850T)",
1421 .cold_ids = {&af9015_usb_table[35], NULL},
1422 .warm_ids = {NULL},
1423 },
1424 }
1425 }, {
1426 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1427
1428 .usb_ctrl = DEVICE_SPECIFIC,
1429 .download_firmware = af9015_download_firmware,
1430 .firmware = "dvb-usb-af9015.fw",
1431 .no_reconnect = 1,
1432
1433 .size_of_priv = sizeof(struct af9015_state),
1434
1435 .num_adapters = 2,
1436 .adapter = {
1437 {
1438 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1439 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1440
1441 .pid_filter_count = 32,
1442 .pid_filter = af9015_pid_filter,
1443 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1444
1445 .frontend_attach =
1446 af9015_af9013_frontend_attach,
1447 .tuner_attach = af9015_tuner_attach,
1448 .stream = {
1449 .type = USB_BULK,
1450 .count = 6,
1451 .endpoint = 0x84,
1452 },
1453 },
1454 {
1455 .frontend_attach =
1456 af9015_af9013_frontend_attach,
1457 .tuner_attach = af9015_tuner_attach,
1458 .stream = {
1459 .type = USB_BULK,
1460 .count = 6,
1461 .endpoint = 0x85,
1462 .u = {
1463 .bulk = {
1464 .buffersize =
1465 TS_USB20_FRAME_SIZE,
1466 }
1467 }
1468 },
1469 }
1470 },
1471
1472 .identify_state = af9015_identify_state,
1473
1474 .rc.core = {
1475 .protocol = RC_TYPE_NEC,
1476 .module_name = "af9015",
1477 .rc_query = af9015_rc_query,
1478 .rc_interval = AF9015_RC_INTERVAL,
1479 .allowed_protos = RC_TYPE_NEC,
1480 },
1481
1482 .i2c_algo = &af9015_i2c_algo,
1483
1484 .num_device_descs = 9,
1485 .devices = {
1486 {
1487 .name = "Xtensions XD-380",
1488 .cold_ids = {&af9015_usb_table[10], NULL},
1489 .warm_ids = {NULL},
1490 },
1491 {
1492 .name = "MSI DIGIVOX Duo",
1493 .cold_ids = {&af9015_usb_table[11], NULL},
1494 .warm_ids = {NULL},
1495 },
1496 {
1497 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1498 .cold_ids = {&af9015_usb_table[12], NULL},
1499 .warm_ids = {NULL},
1500 },
1501 {
1502 .name = "Telestar Starstick 2",
1503 .cold_ids = {&af9015_usb_table[13], NULL},
1504 .warm_ids = {NULL},
1505 },
1506 {
1507 .name = "AVerMedia A309",
1508 .cold_ids = {&af9015_usb_table[14], NULL},
1509 .warm_ids = {NULL},
1510 },
1511 {
1512 .name = "MSI Digi VOX mini III",
1513 .cold_ids = {&af9015_usb_table[15], NULL},
1514 .warm_ids = {NULL},
1515 },
1516 {
1517 .name = "KWorld USB DVB-T TV Stick II " \
1518 "(VS-DVB-T 395U)",
1519 .cold_ids = {&af9015_usb_table[16],
1520 &af9015_usb_table[17],
1521 &af9015_usb_table[18],
1522 &af9015_usb_table[31], NULL},
1523 .warm_ids = {NULL},
1524 },
1525 {
1526 .name = "TrekStor DVB-T USB Stick",
1527 .cold_ids = {&af9015_usb_table[19], NULL},
1528 .warm_ids = {NULL},
1529 },
1530 {
1531 .name = "AverMedia AVerTV Volar Black HD " \
1532 "(A850)",
1533 .cold_ids = {&af9015_usb_table[20], NULL},
1534 .warm_ids = {NULL},
1535 },
1536 }
1537 }, {
1538 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1539
1540 .usb_ctrl = DEVICE_SPECIFIC,
1541 .download_firmware = af9015_download_firmware,
1542 .firmware = "dvb-usb-af9015.fw",
1543 .no_reconnect = 1,
1544
1545 .size_of_priv = sizeof(struct af9015_state),
1546
1547 .num_adapters = 2,
1548 .adapter = {
1549 {
1550 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1551 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1552
1553 .pid_filter_count = 32,
1554 .pid_filter = af9015_pid_filter,
1555 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1556
1557 .frontend_attach =
1558 af9015_af9013_frontend_attach,
1559 .tuner_attach = af9015_tuner_attach,
1560 .stream = {
1561 .type = USB_BULK,
1562 .count = 6,
1563 .endpoint = 0x84,
1564 },
1565 },
1566 {
1567 .frontend_attach =
1568 af9015_af9013_frontend_attach,
1569 .tuner_attach = af9015_tuner_attach,
1570 .stream = {
1571 .type = USB_BULK,
1572 .count = 6,
1573 .endpoint = 0x85,
1574 .u = {
1575 .bulk = {
1576 .buffersize =
1577 TS_USB20_FRAME_SIZE,
1578 }
1579 }
1580 },
1581 }
1582 },
1583
1584 .identify_state = af9015_identify_state,
1585
1586 .rc.core = {
1587 .protocol = RC_TYPE_NEC,
1588 .module_name = "af9015",
1589 .rc_query = af9015_rc_query,
1590 .rc_interval = AF9015_RC_INTERVAL,
1591 .allowed_protos = RC_TYPE_NEC,
1592 },
1593
1594 .i2c_algo = &af9015_i2c_algo,
1595
1596 .num_device_descs = 9,
1597 .devices = {
1598 {
1599 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1600 .cold_ids = {&af9015_usb_table[21], NULL},
1601 .warm_ids = {NULL},
1602 },
1603 {
1604 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1605 "V3.0",
1606 .cold_ids = {&af9015_usb_table[22], NULL},
1607 .warm_ids = {NULL},
1608 },
1609 {
1610 .name = "KWorld Digial MC-810",
1611 .cold_ids = {&af9015_usb_table[23], NULL},
1612 .warm_ids = {NULL},
1613 },
1614 {
1615 .name = "Genius TVGo DVB-T03",
1616 .cold_ids = {&af9015_usb_table[24], NULL},
1617 .warm_ids = {NULL},
1618 },
1619 {
1620 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1621 "(DVB-T PC160-T)",
1622 .cold_ids = {&af9015_usb_table[26], NULL},
1623 .warm_ids = {NULL},
1624 },
1625 {
1626 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1627 .cold_ids = {&af9015_usb_table[27], NULL},
1628 .warm_ids = {NULL},
1629 },
1630 {
1631 .name = "Leadtek WinFast DTV2000DS",
1632 .cold_ids = {&af9015_usb_table[29], NULL},
1633 .warm_ids = {NULL},
1634 },
1635 {
1636 .name = "KWorld USB DVB-T Stick Mobile " \
1637 "(UB383-T)",
1638 .cold_ids = {&af9015_usb_table[30], NULL},
1639 .warm_ids = {NULL},
1640 },
1641 {
1642 .name = "AverMedia AVerTV Volar M (A815Mac)",
1643 .cold_ids = {&af9015_usb_table[32], NULL},
1644 .warm_ids = {NULL},
1645 },
1646 }
1647 },
1648};
1649
1650static int af9015_usb_probe(struct usb_interface *intf,
1651 const struct usb_device_id *id)
1652{
1653 int ret = 0;
1654 struct dvb_usb_device *d = NULL;
1655 struct usb_device *udev = interface_to_usbdev(intf);
1656 u8 i;
1657
1658 deb_info("%s: interface:%d\n", __func__,
1659 intf->cur_altsetting->desc.bInterfaceNumber);
1660
1661
1662
1663 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1664 ret = af9015_read_config(udev);
1665 if (ret)
1666 return ret;
1667
1668 for (i = 0; i < af9015_properties_count; i++) {
1669 ret = dvb_usb_device_init(intf, &af9015_properties[i],
1670 THIS_MODULE, &d, adapter_nr);
1671 if (!ret)
1672 break;
1673 if (ret != -ENODEV)
1674 return ret;
1675 }
1676 if (ret)
1677 return ret;
1678
1679 if (d)
1680 ret = af9015_init(d);
1681 }
1682
1683 return ret;
1684}
1685
1686static void af9015_i2c_exit(struct dvb_usb_device *d)
1687{
1688 struct af9015_state *state = d->priv;
1689 deb_info("%s:\n", __func__);
1690
1691
1692 if (d->state & DVB_USB_STATE_I2C)
1693 i2c_del_adapter(&state->i2c_adap);
1694}
1695
1696static void af9015_usb_device_exit(struct usb_interface *intf)
1697{
1698 struct dvb_usb_device *d = usb_get_intfdata(intf);
1699 deb_info("%s:\n", __func__);
1700
1701
1702 if (d != NULL && d->desc != NULL)
1703 af9015_i2c_exit(d);
1704
1705 dvb_usb_device_exit(intf);
1706}
1707
1708
1709static struct usb_driver af9015_usb_driver = {
1710 .name = "dvb_usb_af9015",
1711 .probe = af9015_usb_probe,
1712 .disconnect = af9015_usb_device_exit,
1713 .id_table = af9015_usb_table,
1714};
1715
1716
1717static int __init af9015_usb_module_init(void)
1718{
1719 int ret;
1720 ret = usb_register(&af9015_usb_driver);
1721 if (ret)
1722 err("module init failed:%d", ret);
1723
1724 return ret;
1725}
1726
1727static void __exit af9015_usb_module_exit(void)
1728{
1729
1730 usb_deregister(&af9015_usb_driver);
1731}
1732
1733module_init(af9015_usb_module_init);
1734module_exit(af9015_usb_module_exit);
1735
1736MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1737MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1738MODULE_LICENSE("GPL");
1739
