2 * DVB USB Linux driver for Afatech AF9015 DVB-T USB2.0 receiver
4 * Copyright (C) 2007 Antti Palosaari <crope@iki.fi>
6 * Thanks to Afatech who kindly provided information.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 static int dvb_usb_af9015_remote;
27 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
28 MODULE_PARM_DESC(remote, "select remote");
29 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
31 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
34 #define REQ_HDR_LEN 8 /* send header size */
35 #define ACK_HDR_LEN 2 /* rece header size */
36 struct af9015_state *state = d_to_priv(d);
42 buf[1] = state->seq++;
43 buf[2] = req->i2c_addr;
44 buf[3] = req->addr >> 8;
45 buf[4] = req->addr & 0xff;
47 buf[6] = req->addr_len;
48 buf[7] = req->data_len;
58 buf[2] |= 0x01; /* set I2C direction */
60 buf[0] = READ_WRITE_I2C;
63 if (((req->addr & 0xff00) == 0xff00) ||
64 ((req->addr & 0xff00) == 0xae00))
65 buf[0] = WRITE_VIRTUAL_MEMORY;
66 case WRITE_VIRTUAL_MEMORY:
68 case DOWNLOAD_FIRMWARE:
72 dev_err(&d->udev->dev, "%s: unknown command=%d\n",
73 KBUILD_MODNAME, req->cmd);
78 /* buffer overflow check */
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);
87 /* write receives seq + status = 2 bytes
88 read receives seq + status + data = 2 + N bytes */
92 wlen += req->data_len;
93 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
95 rlen += req->data_len;
98 /* no ack for these packets */
99 if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
102 ret = dvb_usbv2_generic_rw(d, buf, wlen, buf, rlen);
107 if (rlen && buf[1]) {
108 dev_err(&d->udev->dev, "%s: command failed=%d\n",
109 KBUILD_MODNAME, buf[1]);
114 /* read request, copy returned data to return buf */
116 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
121 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
124 struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
126 return af9015_ctrl_msg(d, &req);
129 static int af9015_read_regs(struct dvb_usb_device *d, u16 addr, u8 *val, u8 len)
131 struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
133 return af9015_ctrl_msg(d, &req);
136 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
138 return af9015_write_regs(d, addr, &val, 1);
141 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
143 return af9015_read_regs(d, addr, val, 1);
146 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
149 struct af9015_state *state = d_to_priv(d);
150 struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
152 if (addr == state->af9013_config[0].i2c_addr ||
153 addr == state->af9013_config[1].i2c_addr)
156 return af9015_ctrl_msg(d, &req);
159 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
162 struct af9015_state *state = d_to_priv(d);
163 struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
165 if (addr == state->af9013_config[0].i2c_addr ||
166 addr == state->af9013_config[1].i2c_addr)
169 return af9015_ctrl_msg(d, &req);
172 static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
177 ret = af9015_read_reg(d, addr, &val);
191 return af9015_write_reg(d, addr, val);
194 static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
196 return af9015_do_reg_bit(d, addr, bit, 1);
199 static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
201 return af9015_do_reg_bit(d, addr, bit, 0);
204 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
207 struct dvb_usb_device *d = i2c_get_adapdata(adap);
208 struct af9015_state *state = d_to_priv(d);
211 u8 uninitialized_var(mbox), addr_len;
215 The bus lock is needed because there is two tuners both using same I2C-address.
216 Due to that the only way to select correct tuner is use demodulator I2C-gate.
218 ................................................
219 . AF9015 includes integrated AF9013 demodulator.
220 . ____________ ____________ . ____________
221 .| uC | | demod | . | tuner |
222 .|------------| |------------| . |------------|
223 .| AF9015 | | AF9013/5 | . | MXL5003 |
224 .| |--+----I2C-------|-----/ -----|-.-----I2C-------| |
225 .| | | | addr 0x38 | . | addr 0xc6 |
226 .|____________| | |____________| . |____________|
227 .................|..............................
228 | ____________ ____________
229 | | demod | | tuner |
230 | |------------| |------------|
231 | | AF9013 | | MXL5003 |
232 +----I2C-------|-----/ -----|-------I2C-------| |
233 | addr 0x3a | | addr 0xc6 |
234 |____________| |____________|
236 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
240 if (msg[i].addr == state->af9013_config[0].i2c_addr ||
241 msg[i].addr == state->af9013_config[1].i2c_addr) {
242 addr = msg[i].buf[0] << 8;
243 addr += msg[i].buf[1];
244 mbox = msg[i].buf[2];
247 addr = msg[i].buf[0];
249 /* mbox is don't care in that case */
252 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
253 if (msg[i].len > 3 || msg[i+1].len > 61) {
257 if (msg[i].addr == state->af9013_config[0].i2c_addr)
258 req.cmd = READ_MEMORY;
261 req.i2c_addr = msg[i].addr;
264 req.addr_len = addr_len;
265 req.data_len = msg[i+1].len;
266 req.data = &msg[i+1].buf[0];
267 ret = af9015_ctrl_msg(d, &req);
269 } else if (msg[i].flags & I2C_M_RD) {
270 if (msg[i].len > 61) {
274 if (msg[i].addr == state->af9013_config[0].i2c_addr) {
279 req.i2c_addr = msg[i].addr;
282 req.addr_len = addr_len;
283 req.data_len = msg[i].len;
284 req.data = &msg[i].buf[0];
285 ret = af9015_ctrl_msg(d, &req);
288 if (msg[i].len > 21) {
292 if (msg[i].addr == state->af9013_config[0].i2c_addr)
293 req.cmd = WRITE_MEMORY;
296 req.i2c_addr = msg[i].addr;
299 req.addr_len = addr_len;
300 req.data_len = msg[i].len-addr_len;
301 req.data = &msg[i].buf[addr_len];
302 ret = af9015_ctrl_msg(d, &req);
312 mutex_unlock(&d->i2c_mutex);
317 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
322 static struct i2c_algorithm af9015_i2c_algo = {
323 .master_xfer = af9015_i2c_xfer,
324 .functionality = af9015_i2c_func,
327 static int af9015_identify_state(struct dvb_usb_device *d, const char **name)
331 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
333 ret = af9015_ctrl_msg(d, &req);
337 dev_dbg(&d->udev->dev, "%s: reply=%02x\n", __func__, reply);
347 static int af9015_download_firmware(struct dvb_usb_device *d,
348 const struct firmware *fw)
350 struct af9015_state *state = d_to_priv(d);
351 int i, len, remaining, ret;
352 struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
354 dev_dbg(&d->udev->dev, "%s:\n", __func__);
357 for (i = 0; i < fw->size; i++)
358 checksum += fw->data[i];
360 state->firmware_size = fw->size;
361 state->firmware_checksum = checksum;
363 #define FW_ADDR 0x5100 /* firmware start address */
364 #define LEN_MAX 55 /* max packet size */
365 for (remaining = fw->size; remaining > 0; remaining -= LEN_MAX) {
371 req.data = (u8 *) &fw->data[fw->size - remaining];
372 req.addr = FW_ADDR + fw->size - remaining;
374 ret = af9015_ctrl_msg(d, &req);
376 dev_err(&d->udev->dev,
377 "%s: firmware download failed=%d\n",
378 KBUILD_MODNAME, ret);
383 /* firmware loaded, request boot */
386 ret = af9015_ctrl_msg(d, &req);
388 dev_err(&d->udev->dev, "%s: firmware boot failed=%d\n",
389 KBUILD_MODNAME, ret);
397 /* hash (and dump) eeprom */
398 static int af9015_eeprom_hash(struct dvb_usb_device *d)
400 struct af9015_state *state = d_to_priv(d);
402 static const unsigned int AF9015_EEPROM_SIZE = 256;
403 u8 buf[AF9015_EEPROM_SIZE];
404 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, NULL};
407 for (i = 0; i < AF9015_EEPROM_SIZE; i++) {
410 ret = af9015_ctrl_msg(d, &req);
415 /* calculate checksum */
416 for (i = 0; i < AF9015_EEPROM_SIZE / sizeof(u32); i++) {
417 state->eeprom_sum *= GOLDEN_RATIO_PRIME_32;
418 state->eeprom_sum += le32_to_cpu(((u32 *)buf)[i]);
421 for (i = 0; i < AF9015_EEPROM_SIZE; i += 16)
422 dev_dbg(&d->udev->dev, "%s: %*ph\n", __func__, 16, buf + i);
424 dev_dbg(&d->udev->dev, "%s: eeprom sum=%.8x\n",
425 __func__, state->eeprom_sum);
428 dev_err(&d->udev->dev, "%s: eeprom failed=%d\n", KBUILD_MODNAME, ret);
432 static int af9015_read_config(struct dvb_usb_device *d)
434 struct af9015_state *state = d_to_priv(d);
436 u8 val, i, offset = 0;
437 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
439 dev_dbg(&d->udev->dev, "%s:\n", __func__);
441 /* IR remote controller */
442 req.addr = AF9015_EEPROM_IR_MODE;
443 /* first message will timeout often due to possible hw bug */
444 for (i = 0; i < 4; i++) {
445 ret = af9015_ctrl_msg(d, &req);
452 ret = af9015_eeprom_hash(d);
456 state->ir_mode = val;
457 dev_dbg(&d->udev->dev, "%s: IR mode=%d\n", __func__, val);
459 /* TS mode - one or two receivers */
460 req.addr = AF9015_EEPROM_TS_MODE;
461 ret = af9015_ctrl_msg(d, &req);
465 state->dual_mode = val;
466 dev_dbg(&d->udev->dev, "%s: TS mode=%d\n", __func__, state->dual_mode);
468 /* disable 2nd adapter because we don't have PID-filters */
469 if (d->udev->speed == USB_SPEED_FULL)
470 state->dual_mode = 0;
472 if (state->dual_mode) {
473 /* read 2nd demodulator I2C address */
474 req.addr = AF9015_EEPROM_DEMOD2_I2C;
475 ret = af9015_ctrl_msg(d, &req);
479 state->af9013_config[1].i2c_addr = val;
482 for (i = 0; i < state->dual_mode + 1; i++) {
484 offset = AF9015_EEPROM_OFFSET;
486 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
487 ret = af9015_ctrl_msg(d, &req);
492 state->af9013_config[i].clock = 28800000;
495 state->af9013_config[i].clock = 20480000;
498 state->af9013_config[i].clock = 28000000;
501 state->af9013_config[i].clock = 25000000;
504 dev_dbg(&d->udev->dev, "%s: [%d] xtal=%d set clock=%d\n",
506 state->af9013_config[i].clock);
509 req.addr = AF9015_EEPROM_IF1H + offset;
510 ret = af9015_ctrl_msg(d, &req);
514 state->af9013_config[i].if_frequency = val << 8;
516 req.addr = AF9015_EEPROM_IF1L + offset;
517 ret = af9015_ctrl_msg(d, &req);
521 state->af9013_config[i].if_frequency += val;
522 state->af9013_config[i].if_frequency *= 1000;
523 dev_dbg(&d->udev->dev, "%s: [%d] IF frequency=%d\n", __func__,
524 i, state->af9013_config[i].if_frequency);
527 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;
528 ret = af9015_ctrl_msg(d, &req);
531 state->mt2060_if1[i] = val << 8;
532 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
533 ret = af9015_ctrl_msg(d, &req);
536 state->mt2060_if1[i] += val;
537 dev_dbg(&d->udev->dev, "%s: [%d] MT2060 IF1=%d\n", __func__, i,
538 state->mt2060_if1[i]);
541 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;
542 ret = af9015_ctrl_msg(d, &req);
546 case AF9013_TUNER_ENV77H11D5:
547 case AF9013_TUNER_MT2060:
548 case AF9013_TUNER_QT1010:
549 case AF9013_TUNER_UNKNOWN:
550 case AF9013_TUNER_MT2060_2:
551 case AF9013_TUNER_TDA18271:
552 case AF9013_TUNER_QT1010A:
553 case AF9013_TUNER_TDA18218:
554 state->af9013_config[i].spec_inv = 1;
556 case AF9013_TUNER_MXL5003D:
557 case AF9013_TUNER_MXL5005D:
558 case AF9013_TUNER_MXL5005R:
559 case AF9013_TUNER_MXL5007T:
560 state->af9013_config[i].spec_inv = 0;
562 case AF9013_TUNER_MC44S803:
563 state->af9013_config[i].gpio[1] = AF9013_GPIO_LO;
564 state->af9013_config[i].spec_inv = 1;
567 dev_err(&d->udev->dev, "%s: tuner id=%d not " \
568 "supported, please report!\n",
569 KBUILD_MODNAME, val);
573 state->af9013_config[i].tuner = val;
574 dev_dbg(&d->udev->dev, "%s: [%d] tuner id=%d\n",
580 dev_err(&d->udev->dev, "%s: eeprom read failed=%d\n",
581 KBUILD_MODNAME, ret);
583 /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
584 content :-( Override some wrong values here. Ditto for the
585 AVerTV Red HD+ (A850T) device. */
586 if (le16_to_cpu(d->udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
587 ((le16_to_cpu(d->udev->descriptor.idProduct) ==
588 USB_PID_AVERMEDIA_A850) ||
589 (le16_to_cpu(d->udev->descriptor.idProduct) ==
590 USB_PID_AVERMEDIA_A850T))) {
591 dev_dbg(&d->udev->dev,
592 "%s: AverMedia A850: overriding config\n",
594 /* disable dual mode */
595 state->dual_mode = 0;
598 state->af9013_config[0].if_frequency = 4570000;
604 static int af9015_get_stream_config(struct dvb_frontend *fe, u8 *ts_type,
605 struct usb_data_stream_properties *stream)
607 struct dvb_usb_device *d = fe_to_d(fe);
608 dev_dbg(&d->udev->dev, "%s: adap=%d\n", __func__, fe_to_adap(fe)->id);
610 if (d->udev->speed == USB_SPEED_FULL)
611 stream->u.bulk.buffersize = TS_USB11_FRAME_SIZE;
616 static int af9015_get_adapter_count(struct dvb_usb_device *d)
618 struct af9015_state *state = d_to_priv(d);
619 return state->dual_mode + 1;
622 /* override demod callbacks for resource locking */
623 static int af9015_af9013_set_frontend(struct dvb_frontend *fe)
626 struct af9015_state *state = fe_to_priv(fe);
628 if (mutex_lock_interruptible(&state->fe_mutex))
631 ret = state->set_frontend[fe_to_adap(fe)->id](fe);
633 mutex_unlock(&state->fe_mutex);
638 /* override demod callbacks for resource locking */
639 static int af9015_af9013_read_status(struct dvb_frontend *fe,
643 struct af9015_state *state = fe_to_priv(fe);
645 if (mutex_lock_interruptible(&state->fe_mutex))
648 ret = state->read_status[fe_to_adap(fe)->id](fe, status);
650 mutex_unlock(&state->fe_mutex);
655 /* override demod callbacks for resource locking */
656 static int af9015_af9013_init(struct dvb_frontend *fe)
659 struct af9015_state *state = fe_to_priv(fe);
661 if (mutex_lock_interruptible(&state->fe_mutex))
664 ret = state->init[fe_to_adap(fe)->id](fe);
666 mutex_unlock(&state->fe_mutex);
671 /* override demod callbacks for resource locking */
672 static int af9015_af9013_sleep(struct dvb_frontend *fe)
675 struct af9015_state *state = fe_to_priv(fe);
677 if (mutex_lock_interruptible(&state->fe_mutex))
680 ret = state->sleep[fe_to_adap(fe)->id](fe);
682 mutex_unlock(&state->fe_mutex);
687 /* override tuner callbacks for resource locking */
688 static int af9015_tuner_init(struct dvb_frontend *fe)
691 struct af9015_state *state = fe_to_priv(fe);
693 if (mutex_lock_interruptible(&state->fe_mutex))
696 ret = state->tuner_init[fe_to_adap(fe)->id](fe);
698 mutex_unlock(&state->fe_mutex);
703 /* override tuner callbacks for resource locking */
704 static int af9015_tuner_sleep(struct dvb_frontend *fe)
707 struct af9015_state *state = fe_to_priv(fe);
709 if (mutex_lock_interruptible(&state->fe_mutex))
712 ret = state->tuner_sleep[fe_to_adap(fe)->id](fe);
714 mutex_unlock(&state->fe_mutex);
719 static int af9015_copy_firmware(struct dvb_usb_device *d)
721 struct af9015_state *state = d_to_priv(d);
725 struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
727 dev_dbg(&d->udev->dev, "%s:\n", __func__);
729 fw_params[0] = state->firmware_size >> 8;
730 fw_params[1] = state->firmware_size & 0xff;
731 fw_params[2] = state->firmware_checksum >> 8;
732 fw_params[3] = state->firmware_checksum & 0xff;
734 /* wait 2nd demodulator ready */
737 ret = af9015_read_reg_i2c(d, state->af9013_config[1].i2c_addr,
742 dev_dbg(&d->udev->dev, "%s: firmware status=%02x\n",
745 if (val == 0x0c) /* fw is running, no need for download */
748 /* set I2C master clock to fast (to speed up firmware copy) */
749 ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
756 ret = af9015_ctrl_msg(d, &req);
758 dev_err(&d->udev->dev, "%s: firmware copy cmd failed=%d\n",
759 KBUILD_MODNAME, ret);
761 dev_dbg(&d->udev->dev, "%s: firmware copy done\n", __func__);
763 /* set I2C master clock back to normal */
764 ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
768 /* request boot firmware */
769 ret = af9015_write_reg_i2c(d, state->af9013_config[1].i2c_addr,
771 dev_dbg(&d->udev->dev, "%s: firmware boot cmd status=%d\n",
776 for (i = 0; i < 15; i++) {
779 /* check firmware status */
780 ret = af9015_read_reg_i2c(d, state->af9013_config[1].i2c_addr,
782 dev_dbg(&d->udev->dev, "%s: firmware status cmd status=%d " \
783 "firmware status=%02x\n", __func__, ret, val);
787 if (val == 0x0c || val == 0x04) /* success or fail */
792 dev_err(&d->udev->dev, "%s: firmware did not run\n",
795 } else if (val != 0x0c) {
796 dev_err(&d->udev->dev, "%s: firmware boot timeout\n",
806 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
809 struct af9015_state *state = adap_to_priv(adap);
812 state->af9013_config[0].ts_mode = AF9013_TS_USB;
813 memcpy(state->af9013_config[0].api_version, "\x0\x1\x9\x0", 4);
814 state->af9013_config[0].gpio[0] = AF9013_GPIO_HI;
815 state->af9013_config[0].gpio[3] = AF9013_GPIO_TUNER_ON;
816 } else if (adap->id == 1) {
817 state->af9013_config[1].ts_mode = AF9013_TS_SERIAL;
818 memcpy(state->af9013_config[1].api_version, "\x0\x1\x9\x0", 4);
819 state->af9013_config[1].gpio[0] = AF9013_GPIO_TUNER_ON;
820 state->af9013_config[1].gpio[1] = AF9013_GPIO_LO;
822 /* copy firmware to 2nd demodulator */
823 if (state->dual_mode) {
824 ret = af9015_copy_firmware(adap_to_d(adap));
826 dev_err(&adap_to_d(adap)->udev->dev,
827 "%s: firmware copy to 2nd " \
828 "frontend failed, will " \
829 "disable it\n", KBUILD_MODNAME);
830 state->dual_mode = 0;
838 /* attach demodulator */
839 adap->fe[0] = dvb_attach(af9013_attach,
840 &state->af9013_config[adap->id], &adap_to_d(adap)->i2c_adap);
843 * AF9015 firmware does not like if it gets interrupted by I2C adapter
844 * request on some critical phases. During normal operation I2C adapter
845 * is used only 2nd demodulator and tuner on dual tuner devices.
846 * Override demodulator callbacks and use mutex for limit access to
847 * those "critical" paths to keep AF9015 happy.
850 state->set_frontend[adap->id] =
851 adap->fe[0]->ops.set_frontend;
852 adap->fe[0]->ops.set_frontend =
853 af9015_af9013_set_frontend;
855 state->read_status[adap->id] =
856 adap->fe[0]->ops.read_status;
857 adap->fe[0]->ops.read_status =
858 af9015_af9013_read_status;
860 state->init[adap->id] = adap->fe[0]->ops.init;
861 adap->fe[0]->ops.init = af9015_af9013_init;
863 state->sleep[adap->id] = adap->fe[0]->ops.sleep;
864 adap->fe[0]->ops.sleep = af9015_af9013_sleep;
867 return adap->fe[0] == NULL ? -ENODEV : 0;
870 static struct mt2060_config af9015_mt2060_config = {
875 static struct qt1010_config af9015_qt1010_config = {
879 static struct tda18271_config af9015_tda18271_config = {
880 .gate = TDA18271_GATE_DIGITAL,
881 .small_i2c = TDA18271_16_BYTE_CHUNK_INIT,
884 static struct mxl5005s_config af9015_mxl5003_config = {
886 .if_freq = IF_FREQ_4570000HZ,
887 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
888 .agc_mode = MXL_SINGLE_AGC,
889 .tracking_filter = MXL_TF_DEFAULT,
890 .rssi_enable = MXL_RSSI_ENABLE,
891 .cap_select = MXL_CAP_SEL_ENABLE,
892 .div_out = MXL_DIV_OUT_4,
893 .clock_out = MXL_CLOCK_OUT_DISABLE,
894 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
895 .top = MXL5005S_TOP_25P2,
896 .mod_mode = MXL_DIGITAL_MODE,
897 .if_mode = MXL_ZERO_IF,
898 .AgcMasterByte = 0x00,
901 static struct mxl5005s_config af9015_mxl5005_config = {
903 .if_freq = IF_FREQ_4570000HZ,
904 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
905 .agc_mode = MXL_SINGLE_AGC,
906 .tracking_filter = MXL_TF_OFF,
907 .rssi_enable = MXL_RSSI_ENABLE,
908 .cap_select = MXL_CAP_SEL_ENABLE,
909 .div_out = MXL_DIV_OUT_4,
910 .clock_out = MXL_CLOCK_OUT_DISABLE,
911 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
912 .top = MXL5005S_TOP_25P2,
913 .mod_mode = MXL_DIGITAL_MODE,
914 .if_mode = MXL_ZERO_IF,
915 .AgcMasterByte = 0x00,
918 static struct mc44s803_config af9015_mc44s803_config = {
923 static struct tda18218_config af9015_tda18218_config = {
925 .i2c_wr_max = 21, /* max wr bytes AF9015 I2C adap can handle at once */
928 static struct mxl5007t_config af9015_mxl5007t_config = {
929 .xtal_freq_hz = MxL_XTAL_24_MHZ,
930 .if_freq_hz = MxL_IF_4_57_MHZ,
933 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
935 struct dvb_usb_device *d = adap_to_d(adap);
936 struct af9015_state *state = d_to_priv(d);
938 dev_dbg(&d->udev->dev, "%s:\n", __func__);
940 switch (state->af9013_config[adap->id].tuner) {
941 case AF9013_TUNER_MT2060:
942 case AF9013_TUNER_MT2060_2:
943 ret = dvb_attach(mt2060_attach, adap->fe[0],
944 &adap_to_d(adap)->i2c_adap, &af9015_mt2060_config,
945 state->mt2060_if1[adap->id])
946 == NULL ? -ENODEV : 0;
948 case AF9013_TUNER_QT1010:
949 case AF9013_TUNER_QT1010A:
950 ret = dvb_attach(qt1010_attach, adap->fe[0],
951 &adap_to_d(adap)->i2c_adap,
952 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
954 case AF9013_TUNER_TDA18271:
955 ret = dvb_attach(tda18271_attach, adap->fe[0], 0xc0,
956 &adap_to_d(adap)->i2c_adap,
957 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
959 case AF9013_TUNER_TDA18218:
960 ret = dvb_attach(tda18218_attach, adap->fe[0],
961 &adap_to_d(adap)->i2c_adap,
962 &af9015_tda18218_config) == NULL ? -ENODEV : 0;
964 case AF9013_TUNER_MXL5003D:
965 ret = dvb_attach(mxl5005s_attach, adap->fe[0],
966 &adap_to_d(adap)->i2c_adap,
967 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
969 case AF9013_TUNER_MXL5005D:
970 case AF9013_TUNER_MXL5005R:
971 ret = dvb_attach(mxl5005s_attach, adap->fe[0],
972 &adap_to_d(adap)->i2c_adap,
973 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
975 case AF9013_TUNER_ENV77H11D5:
976 ret = dvb_attach(dvb_pll_attach, adap->fe[0], 0xc0,
977 &adap_to_d(adap)->i2c_adap,
978 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
980 case AF9013_TUNER_MC44S803:
981 ret = dvb_attach(mc44s803_attach, adap->fe[0],
982 &adap_to_d(adap)->i2c_adap,
983 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
985 case AF9013_TUNER_MXL5007T:
986 ret = dvb_attach(mxl5007t_attach, adap->fe[0],
987 &adap_to_d(adap)->i2c_adap,
988 0xc0, &af9015_mxl5007t_config) == NULL ? -ENODEV : 0;
990 case AF9013_TUNER_UNKNOWN:
992 dev_err(&d->udev->dev, "%s: unknown tuner id=%d\n",
994 state->af9013_config[adap->id].tuner);
998 if (adap->fe[0]->ops.tuner_ops.init) {
999 state->tuner_init[adap->id] =
1000 adap->fe[0]->ops.tuner_ops.init;
1001 adap->fe[0]->ops.tuner_ops.init = af9015_tuner_init;
1004 if (adap->fe[0]->ops.tuner_ops.sleep) {
1005 state->tuner_sleep[adap->id] =
1006 adap->fe[0]->ops.tuner_ops.sleep;
1007 adap->fe[0]->ops.tuner_ops.sleep = af9015_tuner_sleep;
1013 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
1015 struct dvb_usb_device *d = adap_to_d(adap);
1017 dev_dbg(&d->udev->dev, "%s: onoff=%d\n", __func__, onoff);
1020 ret = af9015_set_reg_bit(d, 0xd503, 0);
1022 ret = af9015_clear_reg_bit(d, 0xd503, 0);
1027 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
1030 struct dvb_usb_device *d = adap_to_d(adap);
1033 dev_dbg(&d->udev->dev, "%s: index=%d pid=%04x onoff=%d\n",
1034 __func__, index, pid, onoff);
1036 ret = af9015_write_reg(d, 0xd505, (pid & 0xff));
1040 ret = af9015_write_reg(d, 0xd506, (pid >> 8));
1044 idx = ((index & 0x1f) | (1 << 5));
1045 ret = af9015_write_reg(d, 0xd504, idx);
1051 static int af9015_init_endpoint(struct dvb_usb_device *d)
1053 struct af9015_state *state = d_to_priv(d);
1057 dev_dbg(&d->udev->dev, "%s: USB speed=%d\n", __func__, d->udev->speed);
1059 if (d->udev->speed == USB_SPEED_FULL) {
1060 frame_size = TS_USB11_FRAME_SIZE/4;
1061 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
1063 frame_size = TS_USB20_FRAME_SIZE/4;
1064 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
1067 ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
1070 ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
1073 ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
1076 ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
1079 ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
1082 if (state->dual_mode) {
1083 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
1087 ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
1090 if (state->dual_mode) {
1091 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
1095 /* EP4 xfer length */
1096 ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
1099 ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
1102 /* EP5 xfer length */
1103 ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
1106 ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
1109 ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
1112 ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
1115 ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
1118 if (state->dual_mode) {
1119 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
1124 /* enable / disable mp2if2 */
1125 if (state->dual_mode)
1126 ret = af9015_set_reg_bit(d, 0xd50b, 0);
1128 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
1132 dev_err(&d->udev->dev, "%s: endpoint init failed=%d\n",
1133 KBUILD_MODNAME, ret);
1138 static int af9015_init(struct dvb_usb_device *d)
1140 struct af9015_state *state = d_to_priv(d);
1142 dev_dbg(&d->udev->dev, "%s:\n", __func__);
1144 mutex_init(&state->fe_mutex);
1146 /* init RC canary */
1147 ret = af9015_write_reg(d, 0x98e9, 0xff);
1151 ret = af9015_init_endpoint(d);
1159 #if IS_ENABLED(CONFIG_RC_CORE)
1160 struct af9015_rc_setup {
1165 static char *af9015_rc_setup_match(unsigned int id,
1166 const struct af9015_rc_setup *table)
1168 for (; table->rc_codes; table++)
1169 if (table->id == id)
1170 return table->rc_codes;
1174 static const struct af9015_rc_setup af9015_rc_setup_modparam[] = {
1175 { AF9015_REMOTE_A_LINK_DTU_M, RC_MAP_ALINK_DTU_M },
1176 { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3, RC_MAP_MSI_DIGIVOX_II },
1177 { AF9015_REMOTE_MYGICTV_U718, RC_MAP_TOTAL_MEDIA_IN_HAND },
1178 { AF9015_REMOTE_DIGITTRADE_DVB_T, RC_MAP_DIGITTRADE },
1179 { AF9015_REMOTE_AVERMEDIA_KS, RC_MAP_AVERMEDIA_RM_KS },
1183 static const struct af9015_rc_setup af9015_rc_setup_hashes[] = {
1184 { 0xb8feb708, RC_MAP_MSI_DIGIVOX_II },
1185 { 0xa3703d00, RC_MAP_ALINK_DTU_M },
1186 { 0x9b7dc64e, RC_MAP_TOTAL_MEDIA_IN_HAND }, /* MYGICTV U718 */
1187 { 0x5d49e3db, RC_MAP_DIGITTRADE }, /* LC-Power LC-USB-DVBT */
1191 static int af9015_rc_query(struct dvb_usb_device *d)
1193 struct af9015_state *state = d_to_priv(d);
1197 /* read registers needed to detect remote controller code */
1198 ret = af9015_read_regs(d, 0x98d9, buf, sizeof(buf));
1202 /* If any of these are non-zero, assume invalid data */
1203 if (buf[1] || buf[2] || buf[3]) {
1204 dev_dbg(&d->udev->dev, "%s: invalid data\n", __func__);
1208 /* Check for repeat of previous code */
1209 if ((state->rc_repeat != buf[6] || buf[0]) &&
1210 !memcmp(&buf[12], state->rc_last, 4)) {
1211 dev_dbg(&d->udev->dev, "%s: key repeated\n", __func__);
1212 rc_keydown(d->rc_dev, state->rc_keycode, 0);
1213 state->rc_repeat = buf[6];
1217 /* Only process key if canary killed */
1218 if (buf[16] != 0xff && buf[0] != 0x01) {
1219 dev_dbg(&d->udev->dev, "%s: key pressed %*ph\n",
1220 __func__, 4, buf + 12);
1222 /* Reset the canary */
1223 ret = af9015_write_reg(d, 0x98e9, 0xff);
1227 /* Remember this key */
1228 memcpy(state->rc_last, &buf[12], 4);
1229 if (buf[14] == (u8) ~buf[15]) {
1230 if (buf[12] == (u8) ~buf[13]) {
1232 state->rc_keycode = buf[12] << 8 | buf[14];
1235 state->rc_keycode = buf[12] << 16 |
1236 buf[13] << 8 | buf[14];
1240 state->rc_keycode = buf[12] << 24 | buf[13] << 16 |
1241 buf[14] << 8 | buf[15];
1243 rc_keydown(d->rc_dev, state->rc_keycode, 0);
1245 dev_dbg(&d->udev->dev, "%s: no key press\n", __func__);
1246 /* Invalidate last keypress */
1247 /* Not really needed, but helps with debug */
1248 state->rc_last[2] = state->rc_last[3];
1251 state->rc_repeat = buf[6];
1252 state->rc_failed = false;
1256 dev_warn(&d->udev->dev, "%s: rc query failed=%d\n",
1257 KBUILD_MODNAME, ret);
1259 /* allow random errors as dvb-usb will stop polling on error */
1260 if (!state->rc_failed)
1263 state->rc_failed = true;
1269 static int af9015_get_rc_config(struct dvb_usb_device *d, struct dvb_usb_rc *rc)
1271 struct af9015_state *state = d_to_priv(d);
1272 u16 vid = le16_to_cpu(d->udev->descriptor.idVendor);
1274 if (state->ir_mode == AF9015_IR_MODE_DISABLED)
1277 /* try to load remote based module param */
1279 rc->map_name = af9015_rc_setup_match(dvb_usb_af9015_remote,
1280 af9015_rc_setup_modparam);
1282 /* try to load remote based eeprom hash */
1284 rc->map_name = af9015_rc_setup_match(state->eeprom_sum,
1285 af9015_rc_setup_hashes);
1287 /* try to load remote based USB iManufacturer string */
1288 if (!rc->map_name && vid == USB_VID_AFATECH) {
1289 /* Check USB manufacturer and product strings and try
1290 to determine correct remote in case of chip vendor
1291 reference IDs are used.
1292 DO NOT ADD ANYTHING NEW HERE. Use hashes instead. */
1293 char manufacturer[10];
1294 memset(manufacturer, 0, sizeof(manufacturer));
1295 usb_string(d->udev, d->udev->descriptor.iManufacturer,
1296 manufacturer, sizeof(manufacturer));
1297 if (!strcmp("MSI", manufacturer)) {
1298 /* iManufacturer 1 MSI
1299 iProduct 2 MSI K-VOX */
1300 rc->map_name = af9015_rc_setup_match(
1301 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
1302 af9015_rc_setup_modparam);
1306 /* load empty to enable rc */
1308 rc->map_name = RC_MAP_EMPTY;
1310 rc->allowed_protos = RC_BIT_NEC;
1311 rc->query = af9015_rc_query;
1317 #define af9015_get_rc_config NULL
1320 /* interface 0 is used by DVB-T receiver and
1321 interface 1 is for remote controller (HID) */
1322 static struct dvb_usb_device_properties af9015_props = {
1323 .driver_name = KBUILD_MODNAME,
1324 .owner = THIS_MODULE,
1325 .adapter_nr = adapter_nr,
1326 .size_of_priv = sizeof(struct af9015_state),
1328 .generic_bulk_ctrl_endpoint = 0x02,
1329 .generic_bulk_ctrl_endpoint_response = 0x81,
1331 .identify_state = af9015_identify_state,
1332 .firmware = AF9015_FIRMWARE,
1333 .download_firmware = af9015_download_firmware,
1335 .i2c_algo = &af9015_i2c_algo,
1336 .read_config = af9015_read_config,
1337 .frontend_attach = af9015_af9013_frontend_attach,
1338 .tuner_attach = af9015_tuner_attach,
1339 .init = af9015_init,
1340 .get_rc_config = af9015_get_rc_config,
1341 .get_stream_config = af9015_get_stream_config,
1343 .get_adapter_count = af9015_get_adapter_count,
1346 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1347 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1348 .pid_filter_count = 32,
1349 .pid_filter = af9015_pid_filter,
1350 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1352 .stream = DVB_USB_STREAM_BULK(0x84, 8, TS_USB20_FRAME_SIZE),
1354 .stream = DVB_USB_STREAM_BULK(0x85, 8, TS_USB20_FRAME_SIZE),
1359 static const struct usb_device_id af9015_id_table[] = {
1360 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015,
1361 &af9015_props, "Afatech AF9015 reference design", NULL) },
1362 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016,
1363 &af9015_props, "Afatech AF9015 reference design", NULL) },
1364 { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD,
1365 &af9015_props, "Leadtek WinFast DTV Dongle Gold", RC_MAP_LEADTEK_Y04G0051) },
1366 { DVB_USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E,
1367 &af9015_props, "Pinnacle PCTV 71e", NULL) },
1368 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U,
1369 &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },
1370 { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_TINYTWIN,
1371 &af9015_props, "DigitalNow TinyTwin", RC_MAP_AZUREWAVE_AD_TU700) },
1372 { DVB_USB_DEVICE(USB_VID_VISIONPLUS, USB_PID_AZUREWAVE_AD_TU700,
1373 &af9015_props, "TwinHan AzureWave AD-TU700(704J)", RC_MAP_AZUREWAVE_AD_TU700) },
1374 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2,
1375 &af9015_props, "TerraTec Cinergy T USB XE", NULL) },
1376 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T,
1377 &af9015_props, "KWorld PlusTV Dual DVB-T PCI (DVB-T PC160-2T)", NULL) },
1378 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X,
1379 &af9015_props, "AVerMedia AVerTV DVB-T Volar X", RC_MAP_AVERMEDIA_M135A) },
1380 { DVB_USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380,
1381 &af9015_props, "Xtensions XD-380", NULL) },
1382 { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO,
1383 &af9015_props, "MSI DIGIVOX Duo", RC_MAP_MSI_DIGIVOX_III) },
1384 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2,
1385 &af9015_props, "Fujitsu-Siemens Slim Mobile USB DVB-T", NULL) },
1386 { DVB_USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2,
1387 &af9015_props, "Telestar Starstick 2", NULL) },
1388 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309,
1389 &af9015_props, "AVerMedia A309", NULL) },
1390 { DVB_USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III,
1391 &af9015_props, "MSI Digi VOX mini III", RC_MAP_MSI_DIGIVOX_III) },
1392 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U,
1393 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1394 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2,
1395 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1396 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3,
1397 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1398 { DVB_USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT,
1399 &af9015_props, "TrekStor DVB-T USB Stick", RC_MAP_TREKSTOR) },
1400 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850,
1401 &af9015_props, "AverMedia AVerTV Volar Black HD (A850)", NULL) },
1402 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805,
1403 &af9015_props, "AverMedia AVerTV Volar GPS 805 (A805)", NULL) },
1404 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU,
1405 &af9015_props, "Conceptronic USB2.0 DVB-T CTVDIGRCU V3.0", NULL) },
1406 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810,
1407 &af9015_props, "KWorld Digial MC-810", NULL) },
1408 { DVB_USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03,
1409 &af9015_props, "Genius TVGo DVB-T03", NULL) },
1410 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2,
1411 &af9015_props, "KWorld PlusTV Dual DVB-T Stick (DVB-T 399U)", NULL) },
1412 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T,
1413 &af9015_props, "KWorld PlusTV DVB-T PCI Pro Card (DVB-T PC160-T)", NULL) },
1414 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20,
1415 &af9015_props, "Sveon STV20 Tuner USB DVB-T HDTV", NULL) },
1416 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2,
1417 &af9015_props, "DigitalNow TinyTwin v2", RC_MAP_DIGITALNOW_TINYTWIN) },
1418 { DVB_USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV2000DS,
1419 &af9015_props, "Leadtek WinFast DTV2000DS", RC_MAP_LEADTEK_Y04G0051) },
1420 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_UB383_T,
1421 &af9015_props, "KWorld USB DVB-T Stick Mobile (UB383-T)", NULL) },
1422 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_4,
1423 &af9015_props, "KWorld USB DVB-T TV Stick II (VS-DVB-T 395U)", NULL) },
1424 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A815M,
1425 &af9015_props, "AverMedia AVerTV Volar M (A815Mac)", NULL) },
1426 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_RC,
1427 &af9015_props, "TerraTec Cinergy T Stick RC", RC_MAP_TERRATEC_SLIM_2) },
1428 { DVB_USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_STICK_DUAL_RC,
1429 &af9015_props, "TerraTec Cinergy T Stick Dual RC", RC_MAP_TERRATEC_SLIM) },
1430 { DVB_USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850T,
1431 &af9015_props, "AverMedia AVerTV Red HD+ (A850T)", NULL) },
1432 { DVB_USB_DEVICE(USB_VID_GTEK, USB_PID_TINYTWIN_3,
1433 &af9015_props, "DigitalNow TinyTwin v3", RC_MAP_DIGITALNOW_TINYTWIN) },
1434 { DVB_USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV22,
1435 &af9015_props, "Sveon STV22 Dual USB DVB-T Tuner HDTV", RC_MAP_MSI_DIGIVOX_III) },
1438 MODULE_DEVICE_TABLE(usb, af9015_id_table);
1440 /* usb specific object needed to register this driver with the usb subsystem */
1441 static struct usb_driver af9015_usb_driver = {
1442 .name = KBUILD_MODNAME,
1443 .id_table = af9015_id_table,
1444 .probe = dvb_usbv2_probe,
1445 .disconnect = dvb_usbv2_disconnect,
1446 .suspend = dvb_usbv2_suspend,
1447 .resume = dvb_usbv2_resume,
1448 .reset_resume = dvb_usbv2_reset_resume,
1453 module_usb_driver(af9015_usb_driver);
1455 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1456 MODULE_DESCRIPTION("Afatech AF9015 driver");
1457 MODULE_LICENSE("GPL");
1458 MODULE_FIRMWARE(AF9015_FIRMWARE);