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