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