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.
24 #include <linux/hash.h>
34 static int dvb_usb_af9015_debug;
35 module_param_named(debug, dvb_usb_af9015_debug, int, 0644);
36 MODULE_PARM_DESC(debug, "set debugging level" DVB_USB_DEBUG_STATUS);
37 static int dvb_usb_af9015_remote;
38 module_param_named(remote, dvb_usb_af9015_remote, int, 0644);
39 MODULE_PARM_DESC(remote, "select remote");
40 DVB_DEFINE_MOD_OPT_ADAPTER_NR(adapter_nr);
42 static DEFINE_MUTEX(af9015_usb_mutex);
44 static struct af9015_config af9015_config;
45 static struct dvb_usb_device_properties af9015_properties[3];
46 static int af9015_properties_count = ARRAY_SIZE(af9015_properties);
48 static struct af9013_config af9015_af9013_config[] = {
50 .demod_address = AF9015_I2C_DEMOD,
51 .output_mode = AF9013_OUTPUT_MODE_USB,
52 .api_version = { 0, 1, 9, 0 },
53 .gpio[0] = AF9013_GPIO_HI,
54 .gpio[3] = AF9013_GPIO_TUNER_ON,
57 .output_mode = AF9013_OUTPUT_MODE_SERIAL,
58 .api_version = { 0, 1, 9, 0 },
59 .gpio[0] = AF9013_GPIO_TUNER_ON,
60 .gpio[1] = AF9013_GPIO_LO,
64 static int af9015_rw_udev(struct usb_device *udev, struct req_t *req)
67 #define REQ_HDR_LEN 8 /* send header size */
68 #define ACK_HDR_LEN 2 /* rece header size */
72 u8 msg_len = REQ_HDR_LEN;
73 static u8 seq; /* packet sequence number */
75 if (mutex_lock_interruptible(&af9015_usb_mutex) < 0)
80 buf[2] = req->i2c_addr;
81 buf[3] = req->addr >> 8;
82 buf[4] = req->addr & 0xff;
84 buf[6] = req->addr_len;
85 buf[7] = req->data_len;
96 buf[2] |= 0x01; /* set I2C direction */
98 buf[0] = READ_WRITE_I2C;
101 if (((req->addr & 0xff00) == 0xff00) ||
102 ((req->addr & 0xff00) == 0xae00))
103 buf[0] = WRITE_VIRTUAL_MEMORY;
104 case WRITE_VIRTUAL_MEMORY:
106 case DOWNLOAD_FIRMWARE:
110 err("unknown command:%d", req->cmd);
115 /* buffer overflow check */
116 if ((write && (req->data_len > BUF_LEN - REQ_HDR_LEN)) ||
117 (!write && (req->data_len > BUF_LEN - ACK_HDR_LEN))) {
118 err("too much data; cmd:%d len:%d", req->cmd, req->data_len);
123 /* write requested */
125 memcpy(&buf[REQ_HDR_LEN], req->data, req->data_len);
126 msg_len += req->data_len;
130 debug_dump(buf, msg_len, deb_xfer);
133 ret = usb_bulk_msg(udev, usb_sndbulkpipe(udev, 0x02), buf, msg_len,
134 &act_len, AF9015_USB_TIMEOUT);
136 err("bulk message failed:%d (%d/%d)", ret, msg_len, act_len);
138 if (act_len != msg_len)
139 ret = -1; /* all data is not send */
143 /* no ack for those packets */
144 if (req->cmd == DOWNLOAD_FIRMWARE || req->cmd == RECONNECT_USB)
147 /* write receives seq + status = 2 bytes
148 read receives seq + status + data = 2 + N bytes */
149 msg_len = ACK_HDR_LEN;
151 msg_len += req->data_len;
153 ret = usb_bulk_msg(udev, usb_rcvbulkpipe(udev, 0x81), buf, msg_len,
154 &act_len, AF9015_USB_TIMEOUT);
156 err("recv bulk message failed:%d", ret);
162 debug_dump(buf, act_len, deb_xfer);
164 /* remote controller query status is 1 if remote code is not received */
165 if (req->cmd == GET_IR_CODE && buf[1] == 1) {
166 buf[1] = 0; /* clear command "error" status */
167 memset(&buf[2], 0, req->data_len);
168 buf[3] = 1; /* no remote code received mark */
173 err("command failed:%d", buf[1]);
178 /* read request, copy returned data to return buf */
180 memcpy(req->data, &buf[ACK_HDR_LEN], req->data_len);
184 mutex_unlock(&af9015_usb_mutex);
189 static int af9015_ctrl_msg(struct dvb_usb_device *d, struct req_t *req)
191 return af9015_rw_udev(d->udev, req);
194 static int af9015_write_regs(struct dvb_usb_device *d, u16 addr, u8 *val,
197 struct req_t req = {WRITE_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, len,
199 return af9015_ctrl_msg(d, &req);
202 static int af9015_write_reg(struct dvb_usb_device *d, u16 addr, u8 val)
204 return af9015_write_regs(d, addr, &val, 1);
207 static int af9015_read_reg(struct dvb_usb_device *d, u16 addr, u8 *val)
209 struct req_t req = {READ_MEMORY, AF9015_I2C_DEMOD, addr, 0, 0, 1, val};
210 return af9015_ctrl_msg(d, &req);
213 static int af9015_write_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
216 struct req_t req = {WRITE_I2C, addr, reg, 1, 1, 1, &val};
218 if (addr == af9015_af9013_config[0].demod_address ||
219 addr == af9015_af9013_config[1].demod_address)
222 return af9015_ctrl_msg(d, &req);
225 static int af9015_read_reg_i2c(struct dvb_usb_device *d, u8 addr, u16 reg,
228 struct req_t req = {READ_I2C, addr, reg, 0, 1, 1, val};
230 if (addr == af9015_af9013_config[0].demod_address ||
231 addr == af9015_af9013_config[1].demod_address)
234 return af9015_ctrl_msg(d, &req);
237 static int af9015_i2c_xfer(struct i2c_adapter *adap, struct i2c_msg msg[],
240 struct dvb_usb_device *d = i2c_get_adapdata(adap);
246 /* TODO: implement bus lock
248 The bus lock is needed because there is two tuners both using same I2C-address.
249 Due to that the only way to select correct tuner is use demodulator I2C-gate.
251 ................................................
252 . AF9015 includes integrated AF9013 demodulator.
253 . ____________ ____________ . ____________
254 .| uC | | demod | . | tuner |
255 .|------------| |------------| . |------------|
256 .| AF9015 | | AF9013/5 | . | MXL5003 |
257 .| |--+----I2C-------|-----/ -----|-.-----I2C-------| |
258 .| | | | addr 0x38 | . | addr 0xc6 |
259 .|____________| | |____________| . |____________|
260 .................|..............................
261 | ____________ ____________
262 | | demod | | tuner |
263 | |------------| |------------|
264 | | AF9013 | | MXL5003 |
265 +----I2C-------|-----/ -----|-------I2C-------| |
266 | addr 0x3a | | addr 0xc6 |
267 |____________| |____________|
269 if (mutex_lock_interruptible(&d->i2c_mutex) < 0)
273 if (msg[i].addr == af9015_af9013_config[0].demod_address ||
274 msg[i].addr == af9015_af9013_config[1].demod_address) {
275 addr = msg[i].buf[0] << 8;
276 addr += msg[i].buf[1];
277 mbox = msg[i].buf[2];
280 addr = msg[i].buf[0];
285 if (num > i + 1 && (msg[i+1].flags & I2C_M_RD)) {
287 af9015_af9013_config[0].demod_address)
288 req.cmd = READ_MEMORY;
291 req.i2c_addr = msg[i].addr;
294 req.addr_len = addr_len;
295 req.data_len = msg[i+1].len;
296 req.data = &msg[i+1].buf[0];
297 ret = af9015_ctrl_msg(d, &req);
299 } else if (msg[i].flags & I2C_M_RD) {
302 af9015_af9013_config[0].demod_address)
306 req.i2c_addr = msg[i].addr;
309 req.addr_len = addr_len;
310 req.data_len = msg[i].len;
311 req.data = &msg[i].buf[0];
312 ret = af9015_ctrl_msg(d, &req);
316 af9015_af9013_config[0].demod_address)
317 req.cmd = WRITE_MEMORY;
320 req.i2c_addr = msg[i].addr;
323 req.addr_len = addr_len;
324 req.data_len = msg[i].len-addr_len;
325 req.data = &msg[i].buf[addr_len];
326 ret = af9015_ctrl_msg(d, &req);
336 mutex_unlock(&d->i2c_mutex);
341 static u32 af9015_i2c_func(struct i2c_adapter *adapter)
346 static struct i2c_algorithm af9015_i2c_algo = {
347 .master_xfer = af9015_i2c_xfer,
348 .functionality = af9015_i2c_func,
351 static int af9015_do_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit, u8 op)
356 ret = af9015_read_reg(d, addr, &val);
370 return af9015_write_reg(d, addr, val);
373 static int af9015_set_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
375 return af9015_do_reg_bit(d, addr, bit, 1);
378 static int af9015_clear_reg_bit(struct dvb_usb_device *d, u16 addr, u8 bit)
380 return af9015_do_reg_bit(d, addr, bit, 0);
383 static int af9015_init_endpoint(struct dvb_usb_device *d)
388 deb_info("%s: USB speed:%d\n", __func__, d->udev->speed);
390 /* Windows driver uses packet count 21 for USB1.1 and 348 for USB2.0.
391 We use smaller - about 1/4 from the original, 5 and 87. */
392 #define TS_PACKET_SIZE 188
394 #define TS_USB20_PACKET_COUNT 87
395 #define TS_USB20_FRAME_SIZE (TS_PACKET_SIZE*TS_USB20_PACKET_COUNT)
397 #define TS_USB11_PACKET_COUNT 5
398 #define TS_USB11_FRAME_SIZE (TS_PACKET_SIZE*TS_USB11_PACKET_COUNT)
400 #define TS_USB20_MAX_PACKET_SIZE 512
401 #define TS_USB11_MAX_PACKET_SIZE 64
403 if (d->udev->speed == USB_SPEED_FULL) {
404 frame_size = TS_USB11_FRAME_SIZE/4;
405 packet_size = TS_USB11_MAX_PACKET_SIZE/4;
407 frame_size = TS_USB20_FRAME_SIZE/4;
408 packet_size = TS_USB20_MAX_PACKET_SIZE/4;
411 ret = af9015_set_reg_bit(d, 0xd507, 2); /* assert EP4 reset */
414 ret = af9015_set_reg_bit(d, 0xd50b, 1); /* assert EP5 reset */
417 ret = af9015_clear_reg_bit(d, 0xdd11, 5); /* disable EP4 */
420 ret = af9015_clear_reg_bit(d, 0xdd11, 6); /* disable EP5 */
423 ret = af9015_set_reg_bit(d, 0xdd11, 5); /* enable EP4 */
426 if (af9015_config.dual_mode) {
427 ret = af9015_set_reg_bit(d, 0xdd11, 6); /* enable EP5 */
431 ret = af9015_clear_reg_bit(d, 0xdd13, 5); /* disable EP4 NAK */
434 if (af9015_config.dual_mode) {
435 ret = af9015_clear_reg_bit(d, 0xdd13, 6); /* disable EP5 NAK */
439 /* EP4 xfer length */
440 ret = af9015_write_reg(d, 0xdd88, frame_size & 0xff);
443 ret = af9015_write_reg(d, 0xdd89, frame_size >> 8);
446 /* EP5 xfer length */
447 ret = af9015_write_reg(d, 0xdd8a, frame_size & 0xff);
450 ret = af9015_write_reg(d, 0xdd8b, frame_size >> 8);
453 ret = af9015_write_reg(d, 0xdd0c, packet_size); /* EP4 packet size */
456 ret = af9015_write_reg(d, 0xdd0d, packet_size); /* EP5 packet size */
459 ret = af9015_clear_reg_bit(d, 0xd507, 2); /* negate EP4 reset */
462 if (af9015_config.dual_mode) {
463 ret = af9015_clear_reg_bit(d, 0xd50b, 1); /* negate EP5 reset */
468 /* enable / disable mp2if2 */
469 if (af9015_config.dual_mode)
470 ret = af9015_set_reg_bit(d, 0xd50b, 0);
472 ret = af9015_clear_reg_bit(d, 0xd50b, 0);
475 err("endpoint init failed:%d", ret);
479 static int af9015_copy_firmware(struct dvb_usb_device *d)
484 struct req_t req = {COPY_FIRMWARE, 0, 0x5100, 0, 0, sizeof(fw_params),
486 deb_info("%s:\n", __func__);
488 fw_params[0] = af9015_config.firmware_size >> 8;
489 fw_params[1] = af9015_config.firmware_size & 0xff;
490 fw_params[2] = af9015_config.firmware_checksum >> 8;
491 fw_params[3] = af9015_config.firmware_checksum & 0xff;
493 /* wait 2nd demodulator ready */
496 ret = af9015_read_reg_i2c(d, 0x3a, 0x98be, &val);
500 deb_info("%s: firmware status:%02x\n", __func__, val);
502 if (val == 0x0c) /* fw is running, no need for download */
505 /* set I2C master clock to fast (to speed up firmware copy) */
506 ret = af9015_write_reg(d, 0xd416, 0x04); /* 0x04 * 400ns */
513 ret = af9015_ctrl_msg(d, &req);
515 err("firmware copy cmd failed:%d", ret);
516 deb_info("%s: firmware copy done\n", __func__);
518 /* set I2C master clock back to normal */
519 ret = af9015_write_reg(d, 0xd416, 0x14); /* 0x14 * 400ns */
523 /* request boot firmware */
524 ret = af9015_write_reg_i2c(d, af9015_af9013_config[1].demod_address,
526 deb_info("%s: firmware boot cmd status:%d\n", __func__, ret);
530 for (i = 0; i < 15; i++) {
533 /* check firmware status */
534 ret = af9015_read_reg_i2c(d,
535 af9015_af9013_config[1].demod_address, 0x98be, &val);
536 deb_info("%s: firmware status cmd status:%d fw status:%02x\n",
541 if (val == 0x0c || val == 0x04) /* success or fail */
546 err("firmware did not run");
548 } else if (val != 0x0c) {
549 err("firmware boot timeout");
558 /* hash (and dump) eeprom */
559 static int af9015_eeprom_hash(struct usb_device *udev)
561 static const unsigned int eeprom_size = 256;
565 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
567 eeprom = kmalloc(eeprom_size, GFP_KERNEL);
571 for (reg = 0; reg < eeprom_size; reg++) {
573 ret = af9015_rw_udev(udev, &req);
579 if (dvb_usb_af9015_debug & 0x01)
580 print_hex_dump_bytes("", DUMP_PREFIX_OFFSET, eeprom,
583 BUG_ON(eeprom_size % 4);
585 af9015_config.eeprom_sum = 0;
586 for (reg = 0; reg < eeprom_size / sizeof(u32); reg++) {
587 af9015_config.eeprom_sum *= GOLDEN_RATIO_PRIME_32;
588 af9015_config.eeprom_sum += le32_to_cpu(((u32 *)eeprom)[reg]);
591 deb_info("%s: eeprom sum=%.8x\n", __func__, af9015_config.eeprom_sum);
599 static int af9015_download_ir_table(struct dvb_usb_device *d)
601 int i, packets = 0, ret;
602 u16 addr = 0x9a56; /* ir-table start address */
603 struct req_t req = {WRITE_MEMORY, 0, 0, 0, 0, 1, NULL};
605 deb_info("%s:\n", __func__);
607 data = af9015_config.ir_table;
608 packets = af9015_config.ir_table_size;
614 /* load remote ir-table */
615 for (i = 0; i < packets; i++) {
618 ret = af9015_ctrl_msg(d, &req);
620 err("ir-table download failed at packet %d with " \
630 static int af9015_init(struct dvb_usb_device *d)
633 deb_info("%s:\n", __func__);
635 ret = af9015_init_endpoint(d);
639 ret = af9015_download_ir_table(d);
647 static int af9015_pid_filter_ctrl(struct dvb_usb_adapter *adap, int onoff)
650 deb_info("%s: onoff:%d\n", __func__, onoff);
653 ret = af9015_set_reg_bit(adap->dev, 0xd503, 0);
655 ret = af9015_clear_reg_bit(adap->dev, 0xd503, 0);
660 static int af9015_pid_filter(struct dvb_usb_adapter *adap, int index, u16 pid,
666 deb_info("%s: set pid filter, index %d, pid %x, onoff %d\n",
667 __func__, index, pid, onoff);
669 ret = af9015_write_reg(adap->dev, 0xd505, (pid & 0xff));
673 ret = af9015_write_reg(adap->dev, 0xd506, (pid >> 8));
677 idx = ((index & 0x1f) | (1 << 5));
678 ret = af9015_write_reg(adap->dev, 0xd504, idx);
684 static int af9015_download_firmware(struct usb_device *udev,
685 const struct firmware *fw)
687 int i, len, packets, remainder, ret;
688 struct req_t req = {DOWNLOAD_FIRMWARE, 0, 0, 0, 0, 0, NULL};
689 u16 addr = 0x5100; /* firmware start address */
692 deb_info("%s:\n", __func__);
695 for (i = 0; i < fw->size; i++)
696 checksum += fw->data[i];
698 af9015_config.firmware_size = fw->size;
699 af9015_config.firmware_checksum = checksum;
701 #define FW_PACKET_MAX_DATA 55
703 packets = fw->size / FW_PACKET_MAX_DATA;
704 remainder = fw->size % FW_PACKET_MAX_DATA;
705 len = FW_PACKET_MAX_DATA;
706 for (i = 0; i <= packets; i++) {
707 if (i == packets) /* set size of the last packet */
711 req.data = (u8 *)(fw->data + i * FW_PACKET_MAX_DATA);
713 addr += FW_PACKET_MAX_DATA;
715 ret = af9015_rw_udev(udev, &req);
717 err("firmware download failed at packet %d with " \
723 /* firmware loaded, request boot */
725 ret = af9015_rw_udev(udev, &req);
727 err("firmware boot failed:%d", ret);
735 struct af9015_setup {
737 struct dvb_usb_rc_key *rc_key_map;
738 unsigned int rc_key_map_size;
740 unsigned int ir_table_size;
743 static const struct af9015_setup *af9015_setup_match(unsigned int id,
744 const struct af9015_setup *table)
746 for (; table->rc_key_map; table++)
752 static const struct af9015_setup af9015_setup_modparam[] = {
753 { AF9015_REMOTE_A_LINK_DTU_M,
754 af9015_rc_keys_a_link, ARRAY_SIZE(af9015_rc_keys_a_link),
755 af9015_ir_table_a_link, ARRAY_SIZE(af9015_ir_table_a_link) },
756 { AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
757 af9015_rc_keys_msi, ARRAY_SIZE(af9015_rc_keys_msi),
758 af9015_ir_table_msi, ARRAY_SIZE(af9015_ir_table_msi) },
759 { AF9015_REMOTE_MYGICTV_U718,
760 af9015_rc_keys_mygictv, ARRAY_SIZE(af9015_rc_keys_mygictv),
761 af9015_ir_table_mygictv, ARRAY_SIZE(af9015_ir_table_mygictv) },
762 { AF9015_REMOTE_DIGITTRADE_DVB_T,
763 af9015_rc_keys_digittrade, ARRAY_SIZE(af9015_rc_keys_digittrade),
764 af9015_ir_table_digittrade, ARRAY_SIZE(af9015_ir_table_digittrade) },
765 { AF9015_REMOTE_AVERMEDIA_KS,
766 af9015_rc_keys_avermedia, ARRAY_SIZE(af9015_rc_keys_avermedia),
767 af9015_ir_table_avermedia_ks, ARRAY_SIZE(af9015_ir_table_avermedia_ks) },
771 /* don't add new entries here anymore, use hashes instead */
772 static const struct af9015_setup af9015_setup_usbids[] = {
774 af9015_rc_keys_leadtek, ARRAY_SIZE(af9015_rc_keys_leadtek),
775 af9015_ir_table_leadtek, ARRAY_SIZE(af9015_ir_table_leadtek) },
776 { USB_VID_VISIONPLUS,
777 af9015_rc_keys_twinhan, ARRAY_SIZE(af9015_rc_keys_twinhan),
778 af9015_ir_table_twinhan, ARRAY_SIZE(af9015_ir_table_twinhan) },
779 { USB_VID_KWORLD_2, /* TODO: use correct rc keys */
780 af9015_rc_keys_twinhan, ARRAY_SIZE(af9015_rc_keys_twinhan),
781 af9015_ir_table_kworld, ARRAY_SIZE(af9015_ir_table_kworld) },
783 af9015_rc_keys_avermedia, ARRAY_SIZE(af9015_rc_keys_avermedia),
784 af9015_ir_table_avermedia, ARRAY_SIZE(af9015_ir_table_avermedia) },
786 af9015_rc_keys_msi_digivox_iii, ARRAY_SIZE(af9015_rc_keys_msi_digivox_iii),
787 af9015_ir_table_msi_digivox_iii, ARRAY_SIZE(af9015_ir_table_msi_digivox_iii) },
791 static const struct af9015_setup af9015_setup_hashes[] = {
793 af9015_rc_keys_msi, ARRAY_SIZE(af9015_rc_keys_msi),
794 af9015_ir_table_msi, ARRAY_SIZE(af9015_ir_table_msi) },
798 static void af9015_set_remote_config(struct usb_device *udev,
799 struct dvb_usb_device_properties *props)
801 const struct af9015_setup *table = NULL;
803 if (dvb_usb_af9015_remote) {
804 /* load remote defined as module param */
805 table = af9015_setup_match(dvb_usb_af9015_remote,
806 af9015_setup_modparam);
808 u16 vendor = le16_to_cpu(udev->descriptor.idVendor);
810 table = af9015_setup_match(af9015_config.eeprom_sum,
811 af9015_setup_hashes);
813 if (!table && vendor == USB_VID_AFATECH) {
814 /* Check USB manufacturer and product strings and try
815 to determine correct remote in case of chip vendor
816 reference IDs are used.
817 DO NOT ADD ANYTHING NEW HERE. Use hashes instead.
819 char manufacturer[10];
820 memset(manufacturer, 0, sizeof(manufacturer));
821 usb_string(udev, udev->descriptor.iManufacturer,
822 manufacturer, sizeof(manufacturer));
823 if (!strcmp("Geniatech", manufacturer)) {
824 /* iManufacturer 1 Geniatech
826 table = af9015_setup_match(
827 AF9015_REMOTE_MYGICTV_U718,
828 af9015_setup_modparam);
829 } else if (!strcmp("MSI", manufacturer)) {
830 /* iManufacturer 1 MSI
831 iProduct 2 MSI K-VOX */
832 table = af9015_setup_match(
833 AF9015_REMOTE_MSI_DIGIVOX_MINI_II_V3,
834 af9015_setup_modparam);
835 } else if (udev->descriptor.idProduct ==
836 cpu_to_le16(USB_PID_TREKSTOR_DVBT)) {
837 table = &(const struct af9015_setup){ 0,
838 af9015_rc_keys_trekstor,
839 ARRAY_SIZE(af9015_rc_keys_trekstor),
840 af9015_ir_table_trekstor,
841 ARRAY_SIZE(af9015_ir_table_trekstor)
845 table = af9015_setup_match(vendor, af9015_setup_usbids);
849 props->rc_key_map = table->rc_key_map;
850 props->rc_key_map_size = table->rc_key_map_size;
851 af9015_config.ir_table = table->ir_table;
852 af9015_config.ir_table_size = table->ir_table_size;
856 static int af9015_read_config(struct usb_device *udev)
859 u8 val, i, offset = 0;
860 struct req_t req = {READ_I2C, AF9015_I2C_EEPROM, 0, 0, 1, 1, &val};
862 /* IR remote controller */
863 req.addr = AF9015_EEPROM_IR_MODE;
864 /* first message will timeout often due to possible hw bug */
865 for (i = 0; i < 4; i++) {
866 ret = af9015_rw_udev(udev, &req);
873 ret = af9015_eeprom_hash(udev);
877 deb_info("%s: IR mode:%d\n", __func__, val);
878 for (i = 0; i < af9015_properties_count; i++) {
879 if (val == AF9015_IR_MODE_DISABLED) {
880 af9015_properties[i].rc_key_map = NULL;
881 af9015_properties[i].rc_key_map_size = 0;
883 af9015_set_remote_config(udev, &af9015_properties[i]);
886 /* TS mode - one or two receivers */
887 req.addr = AF9015_EEPROM_TS_MODE;
888 ret = af9015_rw_udev(udev, &req);
891 af9015_config.dual_mode = val;
892 deb_info("%s: TS mode:%d\n", __func__, af9015_config.dual_mode);
894 /* Set adapter0 buffer size according to USB port speed, adapter1 buffer
895 size can be static because it is enabled only USB2.0 */
896 for (i = 0; i < af9015_properties_count; i++) {
897 /* USB1.1 set smaller buffersize and disable 2nd adapter */
898 if (udev->speed == USB_SPEED_FULL) {
899 af9015_properties[i].adapter[0].stream.u.bulk.buffersize
900 = TS_USB11_FRAME_SIZE;
901 /* disable 2nd adapter because we don't have
903 af9015_config.dual_mode = 0;
905 af9015_properties[i].adapter[0].stream.u.bulk.buffersize
906 = TS_USB20_FRAME_SIZE;
910 if (af9015_config.dual_mode) {
911 /* read 2nd demodulator I2C address */
912 req.addr = AF9015_EEPROM_DEMOD2_I2C;
913 ret = af9015_rw_udev(udev, &req);
916 af9015_af9013_config[1].demod_address = val;
918 /* enable 2nd adapter */
919 for (i = 0; i < af9015_properties_count; i++)
920 af9015_properties[i].num_adapters = 2;
923 /* disable 2nd adapter */
924 for (i = 0; i < af9015_properties_count; i++)
925 af9015_properties[i].num_adapters = 1;
928 for (i = 0; i < af9015_properties[0].num_adapters; i++) {
930 offset = AF9015_EEPROM_OFFSET;
932 req.addr = AF9015_EEPROM_XTAL_TYPE1 + offset;
933 ret = af9015_rw_udev(udev, &req);
938 af9015_af9013_config[i].adc_clock = 28800;
941 af9015_af9013_config[i].adc_clock = 20480;
944 af9015_af9013_config[i].adc_clock = 28000;
947 af9015_af9013_config[i].adc_clock = 25000;
950 deb_info("%s: [%d] xtal:%d set adc_clock:%d\n", __func__, i,
951 val, af9015_af9013_config[i].adc_clock);
954 req.addr = AF9015_EEPROM_IF1H + offset;
955 ret = af9015_rw_udev(udev, &req);
958 af9015_af9013_config[i].tuner_if = val << 8;
959 req.addr = AF9015_EEPROM_IF1L + offset;
960 ret = af9015_rw_udev(udev, &req);
963 af9015_af9013_config[i].tuner_if += val;
964 deb_info("%s: [%d] IF1:%d\n", __func__, i,
965 af9015_af9013_config[0].tuner_if);
968 req.addr = AF9015_EEPROM_MT2060_IF1H + offset;
969 ret = af9015_rw_udev(udev, &req);
972 af9015_config.mt2060_if1[i] = val << 8;
973 req.addr = AF9015_EEPROM_MT2060_IF1L + offset;
974 ret = af9015_rw_udev(udev, &req);
977 af9015_config.mt2060_if1[i] += val;
978 deb_info("%s: [%d] MT2060 IF1:%d\n", __func__, i,
979 af9015_config.mt2060_if1[i]);
982 req.addr = AF9015_EEPROM_TUNER_ID1 + offset;
983 ret = af9015_rw_udev(udev, &req);
987 case AF9013_TUNER_ENV77H11D5:
988 case AF9013_TUNER_MT2060:
989 case AF9013_TUNER_QT1010:
990 case AF9013_TUNER_UNKNOWN:
991 case AF9013_TUNER_MT2060_2:
992 case AF9013_TUNER_TDA18271:
993 case AF9013_TUNER_QT1010A:
994 af9015_af9013_config[i].rf_spec_inv = 1;
996 case AF9013_TUNER_MXL5003D:
997 case AF9013_TUNER_MXL5005D:
998 case AF9013_TUNER_MXL5005R:
999 af9015_af9013_config[i].rf_spec_inv = 0;
1001 case AF9013_TUNER_MC44S803:
1002 af9015_af9013_config[i].gpio[1] = AF9013_GPIO_LO;
1003 af9015_af9013_config[i].rf_spec_inv = 1;
1006 warn("tuner id:%d not supported, please report!", val);
1010 af9015_af9013_config[i].tuner = val;
1011 deb_info("%s: [%d] tuner id:%d\n", __func__, i, val);
1016 err("eeprom read failed:%d", ret);
1018 /* AverMedia AVerTV Volar Black HD (A850) device have bad EEPROM
1019 content :-( Override some wrong values here. */
1020 if (le16_to_cpu(udev->descriptor.idVendor) == USB_VID_AVERMEDIA &&
1021 le16_to_cpu(udev->descriptor.idProduct) == USB_PID_AVERMEDIA_A850) {
1022 deb_info("%s: AverMedia A850: overriding config\n", __func__);
1023 /* disable dual mode */
1024 af9015_config.dual_mode = 0;
1025 /* disable 2nd adapter */
1026 for (i = 0; i < af9015_properties_count; i++)
1027 af9015_properties[i].num_adapters = 1;
1029 /* set correct IF */
1030 af9015_af9013_config[0].tuner_if = 4570;
1036 static int af9015_identify_state(struct usb_device *udev,
1037 struct dvb_usb_device_properties *props,
1038 struct dvb_usb_device_description **desc,
1043 struct req_t req = {GET_CONFIG, 0, 0, 0, 0, 1, &reply};
1045 ret = af9015_rw_udev(udev, &req);
1049 deb_info("%s: reply:%02x\n", __func__, reply);
1058 static int af9015_rc_query(struct dvb_usb_device *d, u32 *event, int *state)
1061 struct req_t req = {GET_IR_CODE, 0, 0, 0, 0, sizeof(buf), buf};
1062 struct dvb_usb_rc_key *keymap = d->props.rc_key_map;
1065 memset(buf, 0, sizeof(buf));
1067 ret = af9015_ctrl_msg(d, &req);
1072 *state = REMOTE_NO_KEY_PRESSED;
1074 for (i = 0; i < d->props.rc_key_map_size; i++) {
1075 if (!buf[1] && rc5_custom(&keymap[i]) == buf[0] &&
1076 rc5_data(&keymap[i]) == buf[2]) {
1077 *event = keymap[i].event;
1078 *state = REMOTE_KEY_PRESSED;
1083 deb_rc("%s: %02x %02x %02x %02x %02x %02x %02x %02x\n",
1084 __func__, buf[0], buf[1], buf[2], buf[3], buf[4],
1085 buf[5], buf[6], buf[7]);
1090 /* init 2nd I2C adapter */
1091 static int af9015_i2c_init(struct dvb_usb_device *d)
1094 struct af9015_state *state = d->priv;
1095 deb_info("%s:\n", __func__);
1097 strncpy(state->i2c_adap.name, d->desc->name,
1098 sizeof(state->i2c_adap.name));
1099 #ifdef I2C_ADAP_CLASS_TV_DIGITAL
1100 state->i2c_adap.class = I2C_ADAP_CLASS_TV_DIGITAL,
1102 state->i2c_adap.class = I2C_CLASS_TV_DIGITAL,
1104 state->i2c_adap.algo = d->props.i2c_algo;
1105 state->i2c_adap.algo_data = NULL;
1106 state->i2c_adap.dev.parent = &d->udev->dev;
1108 i2c_set_adapdata(&state->i2c_adap, d);
1110 ret = i2c_add_adapter(&state->i2c_adap);
1112 err("could not add i2c adapter");
1117 static int af9015_af9013_frontend_attach(struct dvb_usb_adapter *adap)
1120 struct af9015_state *state = adap->dev->priv;
1121 struct i2c_adapter *i2c_adap;
1123 if (adap->id == 0) {
1124 /* select I2C adapter */
1125 i2c_adap = &adap->dev->i2c_adap;
1127 deb_info("%s: init I2C\n", __func__);
1128 ret = af9015_i2c_init(adap->dev);
1130 /* select I2C adapter */
1131 i2c_adap = &state->i2c_adap;
1133 /* copy firmware to 2nd demodulator */
1134 if (af9015_config.dual_mode) {
1135 ret = af9015_copy_firmware(adap->dev);
1137 err("firmware copy to 2nd frontend " \
1138 "failed, will disable it");
1139 af9015_config.dual_mode = 0;
1147 /* attach demodulator */
1148 adap->fe = dvb_attach(af9013_attach, &af9015_af9013_config[adap->id],
1151 return adap->fe == NULL ? -ENODEV : 0;
1154 static struct mt2060_config af9015_mt2060_config = {
1155 .i2c_address = 0xc0,
1159 static struct qt1010_config af9015_qt1010_config = {
1160 .i2c_address = 0xc4,
1163 static struct tda18271_config af9015_tda18271_config = {
1164 .gate = TDA18271_GATE_DIGITAL,
1168 static struct mxl5005s_config af9015_mxl5003_config = {
1169 .i2c_address = 0xc6,
1170 .if_freq = IF_FREQ_4570000HZ,
1171 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1172 .agc_mode = MXL_SINGLE_AGC,
1173 .tracking_filter = MXL_TF_DEFAULT,
1174 .rssi_enable = MXL_RSSI_ENABLE,
1175 .cap_select = MXL_CAP_SEL_ENABLE,
1176 .div_out = MXL_DIV_OUT_4,
1177 .clock_out = MXL_CLOCK_OUT_DISABLE,
1178 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1179 .top = MXL5005S_TOP_25P2,
1180 .mod_mode = MXL_DIGITAL_MODE,
1181 .if_mode = MXL_ZERO_IF,
1182 .AgcMasterByte = 0x00,
1185 static struct mxl5005s_config af9015_mxl5005_config = {
1186 .i2c_address = 0xc6,
1187 .if_freq = IF_FREQ_4570000HZ,
1188 .xtal_freq = CRYSTAL_FREQ_16000000HZ,
1189 .agc_mode = MXL_SINGLE_AGC,
1190 .tracking_filter = MXL_TF_OFF,
1191 .rssi_enable = MXL_RSSI_ENABLE,
1192 .cap_select = MXL_CAP_SEL_ENABLE,
1193 .div_out = MXL_DIV_OUT_4,
1194 .clock_out = MXL_CLOCK_OUT_DISABLE,
1195 .output_load = MXL5005S_IF_OUTPUT_LOAD_200_OHM,
1196 .top = MXL5005S_TOP_25P2,
1197 .mod_mode = MXL_DIGITAL_MODE,
1198 .if_mode = MXL_ZERO_IF,
1199 .AgcMasterByte = 0x00,
1202 static struct mc44s803_config af9015_mc44s803_config = {
1203 .i2c_address = 0xc0,
1207 static int af9015_tuner_attach(struct dvb_usb_adapter *adap)
1209 struct af9015_state *state = adap->dev->priv;
1210 struct i2c_adapter *i2c_adap;
1212 deb_info("%s: \n", __func__);
1214 /* select I2C adapter */
1216 i2c_adap = &adap->dev->i2c_adap;
1218 i2c_adap = &state->i2c_adap;
1220 switch (af9015_af9013_config[adap->id].tuner) {
1221 case AF9013_TUNER_MT2060:
1222 case AF9013_TUNER_MT2060_2:
1223 ret = dvb_attach(mt2060_attach, adap->fe, i2c_adap,
1224 &af9015_mt2060_config,
1225 af9015_config.mt2060_if1[adap->id])
1226 == NULL ? -ENODEV : 0;
1228 case AF9013_TUNER_QT1010:
1229 case AF9013_TUNER_QT1010A:
1230 ret = dvb_attach(qt1010_attach, adap->fe, i2c_adap,
1231 &af9015_qt1010_config) == NULL ? -ENODEV : 0;
1233 case AF9013_TUNER_TDA18271:
1234 ret = dvb_attach(tda18271_attach, adap->fe, 0xc0, i2c_adap,
1235 &af9015_tda18271_config) == NULL ? -ENODEV : 0;
1237 case AF9013_TUNER_MXL5003D:
1238 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1239 &af9015_mxl5003_config) == NULL ? -ENODEV : 0;
1241 case AF9013_TUNER_MXL5005D:
1242 case AF9013_TUNER_MXL5005R:
1243 ret = dvb_attach(mxl5005s_attach, adap->fe, i2c_adap,
1244 &af9015_mxl5005_config) == NULL ? -ENODEV : 0;
1246 case AF9013_TUNER_ENV77H11D5:
1247 ret = dvb_attach(dvb_pll_attach, adap->fe, 0xc0, i2c_adap,
1248 DVB_PLL_TDA665X) == NULL ? -ENODEV : 0;
1250 case AF9013_TUNER_MC44S803:
1251 ret = dvb_attach(mc44s803_attach, adap->fe, i2c_adap,
1252 &af9015_mc44s803_config) == NULL ? -ENODEV : 0;
1254 case AF9013_TUNER_UNKNOWN:
1257 err("Unknown tuner id:%d",
1258 af9015_af9013_config[adap->id].tuner);
1263 static struct usb_device_id af9015_usb_table[] = {
1264 /* 0 */{USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9015)},
1265 {USB_DEVICE(USB_VID_AFATECH, USB_PID_AFATECH_AF9015_9016)},
1266 {USB_DEVICE(USB_VID_LEADTEK, USB_PID_WINFAST_DTV_DONGLE_GOLD)},
1267 {USB_DEVICE(USB_VID_PINNACLE, USB_PID_PINNACLE_PCTV71E)},
1268 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U)},
1269 /* 5 */{USB_DEVICE(USB_VID_VISIONPLUS,
1271 {USB_DEVICE(USB_VID_VISIONPLUS,
1272 USB_PID_AZUREWAVE_AD_TU700)},
1273 {USB_DEVICE(USB_VID_TERRATEC, USB_PID_TERRATEC_CINERGY_T_USB_XE_REV2)},
1274 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_2T)},
1275 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X)},
1276 /* 10 */{USB_DEVICE(USB_VID_XTENSIONS, USB_PID_XTENSIONS_XD_380)},
1277 {USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGIVOX_DUO)},
1278 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_VOLAR_X_2)},
1279 {USB_DEVICE(USB_VID_TELESTAR, USB_PID_TELESTAR_STARSTICK_2)},
1280 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A309)},
1281 /* 15 */{USB_DEVICE(USB_VID_MSI_2, USB_PID_MSI_DIGI_VOX_MINI_III)},
1282 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U)},
1283 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_2)},
1284 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_395U_3)},
1285 {USB_DEVICE(USB_VID_AFATECH, USB_PID_TREKSTOR_DVBT)},
1286 /* 20 */{USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A850)},
1287 {USB_DEVICE(USB_VID_AVERMEDIA, USB_PID_AVERMEDIA_A805)},
1288 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_CONCEPTRONIC_CTVDIGRCU)},
1289 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_MC810)},
1290 {USB_DEVICE(USB_VID_KYE, USB_PID_GENIUS_TVGO_DVB_T03)},
1291 /* 25 */{USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_399U_2)},
1292 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_KWORLD_PC160_T)},
1293 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_SVEON_STV20)},
1294 {USB_DEVICE(USB_VID_KWORLD_2, USB_PID_TINYTWIN_2)},
1297 MODULE_DEVICE_TABLE(usb, af9015_usb_table);
1299 static struct dvb_usb_device_properties af9015_properties[] = {
1301 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1303 .usb_ctrl = DEVICE_SPECIFIC,
1304 .download_firmware = af9015_download_firmware,
1305 .firmware = "dvb-usb-af9015.fw",
1308 .size_of_priv = sizeof(struct af9015_state),
1313 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1314 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1316 .pid_filter_count = 32,
1317 .pid_filter = af9015_pid_filter,
1318 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1321 af9015_af9013_frontend_attach,
1322 .tuner_attach = af9015_tuner_attach,
1331 af9015_af9013_frontend_attach,
1332 .tuner_attach = af9015_tuner_attach,
1340 TS_USB20_FRAME_SIZE,
1347 .identify_state = af9015_identify_state,
1349 .rc_query = af9015_rc_query,
1352 .i2c_algo = &af9015_i2c_algo,
1354 .num_device_descs = 9, /* max 9 */
1357 .name = "Afatech AF9015 DVB-T USB2.0 stick",
1358 .cold_ids = {&af9015_usb_table[0],
1359 &af9015_usb_table[1], NULL},
1363 .name = "Leadtek WinFast DTV Dongle Gold",
1364 .cold_ids = {&af9015_usb_table[2], NULL},
1368 .name = "Pinnacle PCTV 71e",
1369 .cold_ids = {&af9015_usb_table[3], NULL},
1373 .name = "KWorld PlusTV Dual DVB-T Stick " \
1375 .cold_ids = {&af9015_usb_table[4],
1376 &af9015_usb_table[25], NULL},
1380 .name = "DigitalNow TinyTwin DVB-T Receiver",
1381 .cold_ids = {&af9015_usb_table[5],
1382 &af9015_usb_table[28], NULL},
1386 .name = "TwinHan AzureWave AD-TU700(704J)",
1387 .cold_ids = {&af9015_usb_table[6], NULL},
1391 .name = "TerraTec Cinergy T USB XE",
1392 .cold_ids = {&af9015_usb_table[7], NULL},
1396 .name = "KWorld PlusTV Dual DVB-T PCI " \
1398 .cold_ids = {&af9015_usb_table[8], NULL},
1402 .name = "AVerMedia AVerTV DVB-T Volar X",
1403 .cold_ids = {&af9015_usb_table[9], NULL},
1408 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1410 .usb_ctrl = DEVICE_SPECIFIC,
1411 .download_firmware = af9015_download_firmware,
1412 .firmware = "dvb-usb-af9015.fw",
1415 .size_of_priv = sizeof(struct af9015_state),
1420 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1421 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1423 .pid_filter_count = 32,
1424 .pid_filter = af9015_pid_filter,
1425 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1428 af9015_af9013_frontend_attach,
1429 .tuner_attach = af9015_tuner_attach,
1438 af9015_af9013_frontend_attach,
1439 .tuner_attach = af9015_tuner_attach,
1447 TS_USB20_FRAME_SIZE,
1454 .identify_state = af9015_identify_state,
1456 .rc_query = af9015_rc_query,
1459 .i2c_algo = &af9015_i2c_algo,
1461 .num_device_descs = 9, /* max 9 */
1464 .name = "Xtensions XD-380",
1465 .cold_ids = {&af9015_usb_table[10], NULL},
1469 .name = "MSI DIGIVOX Duo",
1470 .cold_ids = {&af9015_usb_table[11], NULL},
1474 .name = "Fujitsu-Siemens Slim Mobile USB DVB-T",
1475 .cold_ids = {&af9015_usb_table[12], NULL},
1479 .name = "Telestar Starstick 2",
1480 .cold_ids = {&af9015_usb_table[13], NULL},
1484 .name = "AVerMedia A309",
1485 .cold_ids = {&af9015_usb_table[14], NULL},
1489 .name = "MSI Digi VOX mini III",
1490 .cold_ids = {&af9015_usb_table[15], NULL},
1494 .name = "KWorld USB DVB-T TV Stick II " \
1496 .cold_ids = {&af9015_usb_table[16],
1497 &af9015_usb_table[17],
1498 &af9015_usb_table[18], NULL},
1502 .name = "TrekStor DVB-T USB Stick",
1503 .cold_ids = {&af9015_usb_table[19], NULL},
1507 .name = "AverMedia AVerTV Volar Black HD " \
1509 .cold_ids = {&af9015_usb_table[20], NULL},
1514 .caps = DVB_USB_IS_AN_I2C_ADAPTER,
1516 .usb_ctrl = DEVICE_SPECIFIC,
1517 .download_firmware = af9015_download_firmware,
1518 .firmware = "dvb-usb-af9015.fw",
1521 .size_of_priv = sizeof(struct af9015_state),
1526 .caps = DVB_USB_ADAP_HAS_PID_FILTER |
1527 DVB_USB_ADAP_PID_FILTER_CAN_BE_TURNED_OFF,
1529 .pid_filter_count = 32,
1530 .pid_filter = af9015_pid_filter,
1531 .pid_filter_ctrl = af9015_pid_filter_ctrl,
1534 af9015_af9013_frontend_attach,
1535 .tuner_attach = af9015_tuner_attach,
1544 af9015_af9013_frontend_attach,
1545 .tuner_attach = af9015_tuner_attach,
1553 TS_USB20_FRAME_SIZE,
1560 .identify_state = af9015_identify_state,
1562 .rc_query = af9015_rc_query,
1565 .i2c_algo = &af9015_i2c_algo,
1567 .num_device_descs = 6, /* max 9 */
1570 .name = "AverMedia AVerTV Volar GPS 805 (A805)",
1571 .cold_ids = {&af9015_usb_table[21], NULL},
1575 .name = "Conceptronic USB2.0 DVB-T CTVDIGRCU " \
1577 .cold_ids = {&af9015_usb_table[22], NULL},
1581 .name = "KWorld Digial MC-810",
1582 .cold_ids = {&af9015_usb_table[23], NULL},
1586 .name = "Genius TVGo DVB-T03",
1587 .cold_ids = {&af9015_usb_table[24], NULL},
1591 .name = "KWorld PlusTV DVB-T PCI Pro Card " \
1593 .cold_ids = {&af9015_usb_table[26], NULL},
1597 .name = "Sveon STV20 Tuner USB DVB-T HDTV",
1598 .cold_ids = {&af9015_usb_table[27], NULL},
1605 static int af9015_usb_probe(struct usb_interface *intf,
1606 const struct usb_device_id *id)
1609 struct dvb_usb_device *d = NULL;
1610 struct usb_device *udev = interface_to_usbdev(intf);
1613 deb_info("%s: interface:%d\n", __func__,
1614 intf->cur_altsetting->desc.bInterfaceNumber);
1616 /* interface 0 is used by DVB-T receiver and
1617 interface 1 is for remote controller (HID) */
1618 if (intf->cur_altsetting->desc.bInterfaceNumber == 0) {
1619 ret = af9015_read_config(udev);
1623 for (i = 0; i < af9015_properties_count; i++) {
1624 ret = dvb_usb_device_init(intf, &af9015_properties[i],
1625 THIS_MODULE, &d, adapter_nr);
1635 ret = af9015_init(d);
1641 static void af9015_i2c_exit(struct dvb_usb_device *d)
1643 struct af9015_state *state = d->priv;
1644 deb_info("%s: \n", __func__);
1646 /* remove 2nd I2C adapter */
1647 if (d->state & DVB_USB_STATE_I2C)
1648 i2c_del_adapter(&state->i2c_adap);
1651 static void af9015_usb_device_exit(struct usb_interface *intf)
1653 struct dvb_usb_device *d = usb_get_intfdata(intf);
1654 deb_info("%s: \n", __func__);
1656 /* remove 2nd I2C adapter */
1657 if (d != NULL && d->desc != NULL)
1660 dvb_usb_device_exit(intf);
1663 /* usb specific object needed to register this driver with the usb subsystem */
1664 static struct usb_driver af9015_usb_driver = {
1665 .name = "dvb_usb_af9015",
1666 .probe = af9015_usb_probe,
1667 .disconnect = af9015_usb_device_exit,
1668 .id_table = af9015_usb_table,
1672 static int __init af9015_usb_module_init(void)
1675 ret = usb_register(&af9015_usb_driver);
1677 err("module init failed:%d", ret);
1682 static void __exit af9015_usb_module_exit(void)
1684 /* deregister this driver from the USB subsystem */
1685 usb_deregister(&af9015_usb_driver);
1688 module_init(af9015_usb_module_init);
1689 module_exit(af9015_usb_module_exit);
1691 MODULE_AUTHOR("Antti Palosaari <crope@iki.fi>");
1692 MODULE_DESCRIPTION("Driver for Afatech AF9015 DVB-T");
1693 MODULE_LICENSE("GPL");